-- 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.18

-- | A module aimed at making working with GtkBuilder easier. It's meant to
--   be used like this (requires OverloadedStrings):
--   
--   
--   buildUI :: BuildFn ()
--   buildUI = do
--       mainWin <- buildMainWin
--       buildAboutDialog
--   
--       widgetShowAll mainWin
--   
--   buildMainWin :: BuildFn ApplicationWindow
--   buildMainWin = do
--       buildHeaderBar
--       buildMenuBar
--       buildMainArea
--   
--       mainWin <- getObject' ApplicationWindow "mainWin"
--       on mainWin Destroy mainQuit
--       return mainWin
--   
--   buildAboutDialog :: BuildFn AboutDialog
--   ...
--   
--   buildHeaderBar :: BuildFn HeaderBar
--   ...
--   
--   buildMenuBar :: BuildFn MenuBar
--   ...
--   
--   buildMainArea :: BuildFn Grid
--   ...
--   
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 :: Type -> Type)
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
--   TreeModel. The node that correspond to a given TreePath
--   might change if nodes are removed or added and a TreePath may
--   refer to a different or even non-existent node after a modification of
--   the model. In contrast, a TreeIter is a more compact
--   representation of a TreePath 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 TreeRowReference.
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 TreePath. 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 ColumnMap.
data ColumnAccess row
[CAInvalid] :: forall row. ColumnAccess row
[CAInt] :: forall row. (row -> Int32) -> ColumnAccess row
[CABool] :: forall row. (row -> Bool) -> ColumnAccess row
[CAString] :: forall row. (row -> Text) -> ColumnAccess row
[CAPixbuf] :: forall row. (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.Base.BasicTypes.GObject (Data.GI.Gtk.ModelView.Types.TypedTreeModelSort row)
instance Data.GI.Base.Overloading.HasParentTypes (Data.GI.Gtk.ModelView.Types.TypedTreeModelSort row)
instance Data.GI.Gtk.ModelView.Types.IsTypedTreeModel Data.GI.Gtk.ModelView.Types.TypedTreeModel
instance Data.GI.Gtk.ModelView.Types.IsTypedTreeModel Data.GI.Gtk.ModelView.Types.TypedTreeModelFilter
instance Data.GI.Gtk.ModelView.Types.IsTypedTreeModel Data.GI.Gtk.ModelView.Types.TypedTreeModelSort
instance Data.GI.Base.BasicTypes.TypedObject (Data.GI.Gtk.ModelView.Types.TypedTreeModelSort row)

-- | The tree interface used by TreeView.
module Data.GI.Gtk.ModelView.TreeModel

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

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

-- | Calls func on each node in model in a depth-first fashion.
--   
--   If func returns True, then the tree ceases to
--   be walked, and treeModelForeach 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 ()

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

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

-- | 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 path 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 ()

-- | Creates a new TreeModel, with childModel as the
--   child_model and root as the virtual root.
--   
--   Since: 2.4
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 iter with the first iterator in the tree
--   (the one at the path "0") and returns True. Returns
--   False if the tree is empty.
treeModelGetIterFirst :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m (Bool, TreeIter)

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

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

-- | Returns a newly-created TreePath-struct referenced by
--   iter.
--   
--   This path should be freed with treePathFree.
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.
--   
--   Since: 2.2
treeModelGetStringFromIter :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m Text

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

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

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

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

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

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

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

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

-- | Emits the TreeModel::rowDeleted signal on
--   treeModel.
--   
--   This should be called by models after a row has been removed. The
--   location pointed to by path 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 TreeModel::rowHasChildToggled signal on
--   treeModel. 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 TreeModel::rowInserted signal on
--   treeModel.
treeModelRowInserted :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> TreeIter -> m ()

-- | Emits the TreeModel::rows-reordered signal on
--   treeModel.
--   
--   This should be called by models when their rows have been reordered.
--   
--   Since: 3.10
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
--   treeModelRefNode.
--   
--   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 rowChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on treeModel #rowChanged callback
--   
onTreeModelRowChanged :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowChangedCallback) -> m SignalHandlerId

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Convert a comma or colon separated string into a TreePath. 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 TreeIter.
treeModelGetValue :: IsTreeModel self => self -> TreeIter -> ColumnId row ty -> IO ty

-- | Gets the a TreeIter 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.Internal.Show.Show (Data.GI.Gtk.ModelView.Types.ColumnId row ty)

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

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

-- | These flags indicate various properties of a TreeModel.
--   
--   They are returned by treeModelGetFlags, and must be static for
--   the lifetime of the object. A more complete description of
--   GTK_TREE_MODEL_ITERS_PERSIST 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 TreeModelIface structure contains all functions that are
--   required to implement an application-specific TreeModel.
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 TreeIter.
--   Return Nothing 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
--   Nothing 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
--   Notihing 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 nth child. Return Nothing
--   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 :: Type -> Type) row
DragSourceIface :: (model row -> TreePath -> IO Bool) -> (model row -> TreePath -> SelectionData -> IO Bool) -> (model row -> TreePath -> IO Bool) -> DragSourceIface (model :: Type -> Type) row

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

-- | Fill in the SelectionData structure with information on the
--   given node using selectionDataSet.
[customDragSourceDragDataGet] :: DragSourceIface (model :: Type -> Type) 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 :: Type -> Type) 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 :: Type -> Type) row
DragDestIface :: (model row -> TreePath -> SelectionData -> IO Bool) -> (model row -> TreePath -> SelectionData -> IO Bool) -> DragDestIface (model :: Type -> Type) row

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

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

-- | Create a new store that implements the TreeModelIface interface
--   and optionally the DragSourceIface and the
--   DragDestIface. If the latter two are set to Nothing 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 TreeIter.
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 CustomStore. 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
--   TreeIter 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 TreeIter,
--   i.e., one that refers to an old model.
customStoreGetStamp :: MonadIO m => CustomStore private row -> m Int32

-- | Create a new stamp. See customStoreGetStamp.
customStoreInvalidateIters :: MonadIO m => CustomStore private row -> m ()
instance Data.GI.Base.BasicTypes.GObject (Data.GI.Gtk.ModelView.CustomStore.CustomStore private row)
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)

-- | 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 TreeModel that contains a list of elements.
seqStoreNew :: (Applicative m, MonadIO m) => [a] -> m (SeqStore a)

-- | Create a new TreeModel 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 SeqStore. 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 SelectionDataM object is set
--   with treeSetRowDragData, i.e. it contains the model and the
--   TreePath to the row.
seqStoreDefaultDragSourceIface :: DragSourceIface SeqStore row

-- | Default drop functions for SeqStore. 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 TreeIterRaw to an an index into the
--   SeqStore. Note that this function merely extracts the second
--   element of the TreeIterRaw.
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.BasicTypes.GObject (Data.GI.Gtk.ModelView.SeqStore.SeqStore a)
instance Data.GI.Base.Overloading.HasParentTypes (Data.GI.Gtk.ModelView.SeqStore.SeqStore a)
instance Data.GI.Gtk.ModelView.Types.IsTypedTreeModel Data.GI.Gtk.ModelView.SeqStore.SeqStore
instance Data.GI.Base.BasicTypes.TypedObject (Data.GI.Gtk.ModelView.SeqStore.SeqStore a)

-- | 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.
--   
--   
--   
- The given rose tree determines the initial content and may be the
--   empty list. Each Tree in the forest corresponds to one
--   top-level node.
--   
- The ForestStore maintains the initially given Forest and aligns
--   the TreePath bits to fit in 96-bit length TreeIter
--   storage.
--   
- Additionally, a cache is used to achieve higher performance if
--   operating on recently used TreePaths.
--   
- Note: 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.
--   
forestStoreNew :: MonadIO m => Forest a -> m (ForestStore a)

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

-- | Default drag functions for ForestStore. 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 SelectionDataM object is
--   set with treeSetRowDragData, i.e. it contains the model and the
--   TreePath to the row.
forestStoreDefaultDragSourceIface :: DragSourceIface ForestStore row

-- | Default drop functions for ForestStore. 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
--   TreePath 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
--   TreePath 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
--   forestStoreGetTree but returns Nothing 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.
--   
--   
--   
- This function inserts a single node without children into the
--   tree. Its arguments are similar to those of
--   forestStoreInsert.
--   
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.
--   
--   
--   
- The given list of nodes is inserted into given parent at
--   pos. If the parent existed, the function returns Just
--   path where path is the position of the newly inserted
--   elements. If pos is negative or greater or equal to the
--   number of children of the node at path, the new nodes are
--   appended to the list.
--   
forestStoreInsertForest :: MonadIO m => ForestStore a -> TreePath -> Int -> Forest a -> m ()

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

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

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

-- | An interface for packing cells
--   
--   
--   
- Module available since Gtk+ version 2.4
--   
module Data.GI.Gtk.ModelView.CellLayout
data CellLayoutAddAttributeMethodInfo
data CellLayoutClearAttributesMethodInfo
data CellLayoutClearMethodInfo
data CellLayoutGetAreaMethodInfo
data CellLayoutGetCellsMethodInfo
data CellLayoutPackEndMethodInfo
data CellLayoutPackStartMethodInfo
data CellLayoutReorderMethodInfo
data CellLayoutSetCellDataFuncMethodInfo
type family ResolveCellLayoutMethod (t :: Symbol) o

-- | Adds an attribute mapping to the renderer cell. The
--   column is the ColumnId of the model to get a value
--   from, and the attribute is the parameter on cell 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
--   CellRendererText get its values from column 2.
--   
--   cellLayoutAddColumnAttribute :: (MonadIO m, IsCellLayout self,
--   IsCellRenderer cell) => self -> cell -- ^ cell - A
--   CellRenderer. -> ReadWriteAttr cell a v -- ^
--   attribute - An attribute of a renderer. -> ColumnId row v
--   -- ^ column - The virtual column of the model from which to
--   -- retrieve the attribute. -> m () cellLayoutAddColumnAttribute
--   self cell attr column = cellLayoutAddAttribute self cell (T.pack $
--   show attr) (columnIdToNumber column)
--   
--   Specify how a row of the model defines the attributes of the
--   CellRenderer cell. This is a convenience wrapper
--   around cellLayoutSetAttributeFunc in that it sets the cells
--   of the cell with the data retrieved from the model.
--   
--   
--   
- Note on using TreeModelSort and TreeModelFilter:
--   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
--   TreeIters 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.
--   treeModelSortConvertIterToChildIter. Hence, it is possible to
--   install the encapsulating model in the view and to pass the child
--   model to this function.
--   
cellLayoutSetAttributes :: (MonadIO m, IsCellLayout self, IsCellRenderer cell, IsTreeModel (model row), IsTypedTreeModel model) => self -> cell -> model row -> (row -> [AttrOp cell 'AttrSet]) -> m ()

-- | Like cellLayoutSetAttributes, 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 CellRenderer cell 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.
--   
--   
--   
- Module available since Gtk+ version 2.4
--   
module Data.GI.Gtk.ComboBox
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
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"

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

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

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

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

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

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

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

-- | Returns the currently active string in comboBox or
--   Nothing if none is selected. Note that you can only use this
--   function with combo boxes constructed with comboBoxNewText.
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 threadSelf >>= setGUIThread
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 setGUIThread or
--   setCurrentThreadAsGUIThread before this.
--   
--   Priority is typically between PRIORITY_HIGH_IDLE (100) and
--   PRIORITY_DEFAULT_IDLE (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 setGUIThread or
--   setCurrentThreadAsGUIThread before this.
--   
--   Equivalent to postGUISyncWithPriority
--   PRIORITY_DEFAULT_IDLE
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 PRIORITY_HIGH_IDLE (100) and
--   PRIORITY_DEFAULT_IDLE (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 postGUIASyncWithPriority
--   PRIORITY_DEFAULT_IDLE
postGUIASync :: IO () -> IO ()

-- | Test if two Threads refer to the same OS thread. A
--   Thread can be gotten from threadSelf. Note that
--   threadSelf 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 setGUIThread or
--   setCurrentThreadAsGUIThread 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 Thread corresponding to the current
--   thread. Note that this function does not increase the reference count
--   of the returned struct.
--   
--   This function will return a Thread 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 threadJoin) on
--   these threads.
threadSelf :: (HasCallStack, MonadIO m) => m Thread

-- | Helper functions for working with Widgets.
module Data.GI.Gtk.Widget

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

module Data.GI.Gtk

-- | Runs the main loop until mainQuit is called.
--   
--   You can nest calls to main. In that case mainQuit will
--   make the innermost invocation of the main loop return.
main :: (HasCallStack, MonadIO m) => m ()

-- | The type of license for an application.
--   
--   This enumeration can be expanded at later date.
--   
--   Since: 3.0
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

-- | 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 argc,
--   argv parameters from main() to this
--   function, it is possible to pass Nothing if
--   argv is not available or commandline handling is not
--   required.
--   
--   argc and argv 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 parseArgs, initCheck, initWithArgs or
--   optionContextParse with the option group returned by
--   getOptionGroup, you don’t have to call init.
--   
--   And if you are using Application, you don't have to call any of
--   the initialization functions either; the
--   Application::startup 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
--   initCheck instead.
--   
--   Since 2.18, GTK+ calls signal (SIGPIPE, SIG_IGN) 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 init, but
--   notice that other libraries (e.g. libdbus or gvfs) might do similar
--   things.
init :: (HasCallStack, MonadIO m) => Maybe [Text] -> m (Maybe [Text])

-- | 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

-- | 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

-- | See also printSettingsSetPaperWidth.
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

-- | Set a number of properties for some object.
set :: forall o m. MonadIO m => o -> [AttrOp o 'AttrSet] -> m ()

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

-- | 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 memcpy 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

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

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

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

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

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

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

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

-- | 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.
--   
--   
--   catchGErrorJustDomain
--     loadImage
--     (\err message -> case err of
--         PixbufErrorCorruptImage -> ...
--         PixbufErrorInsufficientMemory -> ...
--         PixbufErrorUnknownType -> ...
--         _ -> ...)
--   
catchGErrorJustDomain :: GErrorClass err => IO a -> (err -> GErrorMessage -> IO a) -> IO a

-- | A verson of catchGErrorJustDomain with the arguments swapped
--   around.
handleGErrorJustDomain :: GErrorClass err => (err -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Creates a new Window, which is a toplevel window that can
--   contain other widgets. Nearly always, the type of the window should be
--   GTK_WINDOW_TOPLEVEL. If you’re implementing something
--   like a popup menu from scratch (which is a bad idea, just use
--   Menu), you might use GTK_WINDOW_POPUP.
--   GTK_WINDOW_POPUP is not for dialogs, though in some
--   other toolkits dialogs are called “popups”. In GTK+,
--   GTK_WINDOW_POPUP 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
--   windowSetDecorated, don’t use GTK_WINDOW_POPUP.
--   
--   All top-level windows created by windowNew are stored in an
--   internal top-level window list. This list can be obtained from
--   windowListToplevels. Due to Gtk+ keeping a reference to the
--   window internally, windowNew does not return a reference to the
--   caller.
--   
--   To delete a Window, call widgetDestroy.
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 Nothing. Usage:
--   
--   
--   maybeWidget <- castTo Widget label
--   
castTo :: (HasCallStack, ManagedPtrNewtype o, TypedObject o, ManagedPtrNewtype o', TypedObject o', GObject o') => (ManagedPtr o' -> o') -> o -> IO (Maybe o')

-- | Haskell-side representation of a GValue.
newtype GValue
GValue :: ManagedPtr GValue -> GValue

-- | Create a GValue from the given Haskell value.
toGValue :: (IsGValue a, MonadIO m) => a -> m GValue

-- | Create a Haskell object out of the given GValue.
fromGValue :: (IsGValue a, MonadIO m) => GValue -> m a

-- | 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 := instead, which
--   has no potential memory leaks (at the cost of sometimes requiring some
--   explicit Haskell -> 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

-- | Bind a property to the given DynVal, so that the property is
--   changed whenever the DynVal is. This requires the implicit
--   param ?_haskell_gi_modelProxy, of type ModelProxy
--   model to be set.
[:!<~] :: forall obj info (attr :: Symbol) (tag1 :: AttrOpTag) b model (tag :: AttrOpTag). (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag1 info obj, AttrSetTypeConstraint info b, ?_haskell_gi_modelProxy :: ModelProxy model) => AttrLabelProxy attr -> DynVal model b -> AttrOp obj tag

-- | Bind a property to the given DynVal, so that the property is
--   changed whenever the DynVal is. This requires the implicit
--   param ?_haskell_gi_modelProxy, of type ModelProxy
--   model to be set. This will only actually set the property
--   whenever the DynVal changes if the new value of the
--   DynVal is different from the actual value of the property. If
--   you want to set the property without checking equality you can use
--   :!<~ instead.
[:<~] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b model. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b, AttrOpAllowed 'AttrGet info obj, EqMaybe b (AttrGetType info), ?_haskell_gi_modelProxy :: ModelProxy model) => AttrLabelProxy attr -> DynVal model b -> AttrOp obj tag

-- | Given an AttrLabelProxy, bind the given attribute to the corresponding
--   field in the model proxy (if there's one), so that changes in the
--   attribute are reflected back into changes of the model.
[Bind] :: forall obj info (propName :: Symbol) (tag :: AttrOpTag) model outType (components :: [Symbol]) (fieldName :: Symbol). (HasAttributeList obj, GObject obj, info ~ ResolveAttribute propName obj, AttrInfo info, KnownSymbol (AttrLabel info), AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrOpAllowed 'AttrPut info obj, ?_haskell_gi_modelProxy :: ModelProxy model, outType ~ AttrGetType info, AttrSetTypeConstraint info outType, components ~ Components fieldName, PathFieldAccess components model outType, KnownSymbol fieldName, Eq outType) => AttrLabelProxy propName -> AttrLabelProxy fieldName -> 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 On, 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 :=>
infixr 0 :~
infixr 0 :~>

-- | 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

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

-- | Retrieves a snapshot of the contained widget in the form of a
--   Surface. If you need to keep this around over window resizes
--   then you should add a reference to it.
--   
--   Since: 2.20
offscreenWindowGetSurface :: (HasCallStack, MonadIO m, IsOffscreenWindow a) => a -> m (Maybe Surface)

-- | This function returns the position you need to pass to
--   windowMove to keep window in its current
--   position. This means that the meaning of the returned value varies
--   with window gravity. See windowMove 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
--   GDK_GRAVITY_NORTH_WEST. This means that
--   windowGetPosition gets the position of the top-left corner of
--   the window manager frame for the window. windowMove sets the
--   position of this same top-left corner.
--   
--   If a window has gravity GDK_GRAVITY_STATIC the window
--   manager frame is not relevant, and thus windowGetPosition 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)

-- | A Window can be one of these types. Most things you’d consider
--   a “window” should have type GTK_WINDOW_TOPLEVEL;
--   windows with this type are managed by the window manager and have a
--   frame by default (call windowSetDecorated to toggle the frame).
--   Windows with type GTK_WINDOW_POPUP 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). GTK_WINDOW_POPUP
--   is used to implement widgets such as Menu or tooltips that you
--   normally don’t think of as windows per se. Nearly all windows should
--   be GTK_WINDOW_TOPLEVEL. In particular, do not use
--   GTK_WINDOW_POPUP just to turn off the window borders;
--   use windowSetDecorated 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

-- | Asks the [window manager][gtk-X11-arch] to move window
--   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 GDK_GRAVITY_NORTH_WEST, so
--   the reference point is simply the x, y
--   supplied to windowMove. The top-left corner of the window
--   decorations (aka window frame or border) will be placed at
--   x, y. Therefore, to position a window
--   at the top left of the screen, you want to use the default gravity
--   (which is GDK_GRAVITY_NORTH_WEST) and move the window
--   to 0,0.
--   
--   To position a window at the bottom right corner of the screen, you
--   would set GDK_GRAVITY_SOUTH_EAST, which means that the
--   reference point is at x + the window width and
--   y + 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: gtk_window_move (window, gdk_screen_width
--   () - window_width, gdk_screen_height () - window_height) (note
--   that this example does not take multi-head scenarios into account).
--   
--   The Extended Window Manager Hints Specification has a nice
--   table of gravities in the “implementation notes” section.
--   
--   The windowGetPosition 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
--   widgetSetSizeRequest to set the window's request to a smaller
--   value.
--   
--   If windowResize is called before showing a window for the first
--   time, it overrides any default size set with
--   windowSetDefaultSize.
--   
--   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 windowResize is issued.
--   
--   If the GtkWindow has a titlebar widget (see windowSetTitlebar),
--   then typically, windowResize 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 windowResize and not a larger window.
windowResize :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> m ()

-- | Request the windowing system to make window 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 widgetIsComposited. 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.
--   
--   Since: 2.12
windowSetOpacity :: (HasCallStack, MonadIO m, IsWindow a) => a -> Double -> m ()

-- | Sets the title of the Window. 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. gtk_dialog_new_with_buttons()
--   and other convenience functions in GTK+ will sometimes call
--   windowSetTransientFor on your behalf.
--   
--   Passing Nothing for parent unsets the current
--   transient window.
--   
--   On Wayland, this function can also be used to attach a new
--   GTK_WINDOW_POPUP to a
--   GTK_WINDOW_TOPLEVEL parent already mapped on screen so
--   that the GTK_WINDOW_POPUP will be created as a
--   subsurface-based window GDK_WINDOW_SUBSURFACE which
--   can be positioned at will relatively to the
--   GTK_WINDOW_TOPLEVEL 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.
--   
--   gtk_dialog_new_with_buttons() and other convenience
--   functions in GTK+ will sometimes call windowSetTypeHint on your
--   behalf.
windowSetTypeHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> WindowTypeHint -> m ()

-- | Sets the icon for the window from a named themed icon. See the docs
--   for IconTheme 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.
--   
--   Since: 2.6
windowSetIconName :: (HasCallStack, MonadIO m, IsWindow a) => a -> Maybe Text -> m ()

-- | Asks to stick window, 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
--   Widget.
windowStick :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

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

-- | Parses command line arguments, and initializes global attributes of
--   GTK+, but does not actually open a connection to a display. (See
--   displayOpen, getDisplayArgName)
--   
--   Any arguments used by GTK+ or GDK are removed from the array and
--   argc and argv are updated accordingly.
--   
--   There is no need to call this function explicitly if you are using
--   init, or initCheck.
--   
--   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 init 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 False 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 False results in undefined behavior.
initCheck :: (HasCallStack, MonadIO m) => Maybe [Text] -> m (Bool, Maybe [Text])

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

-- | Like getMajorVersion, 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 getMicroVersion, 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 getMinorVersion, but from the headers used at application
--   compile time, rather than from the library linked against at
--   application run time.
pattern MINOR_VERSION :: Int32

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

-- | Cast to Window, for types for which this is known to be safe.
--   For general casts, use castTo.
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
--   window. 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
--   Widget.
windowDeiconify :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to place window 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 Widget.
--   
--   Since: 2.2
windowFullscreen :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to place window 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 Widget.
--   
--   Since: 3.18
windowFullscreenOnMonitor :: (HasCallStack, MonadIO m, IsWindow a, IsScreen b) => a -> b -> Int32 -> m ()

-- | Gets the value set by windowSetAcceptFocus.
--   
--   Since: 2.4
windowGetAcceptFocus :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Gets the value set by windowSetFocusOnMap.
--   
--   Since: 2.6
windowGetFocusOnMap :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns the group for window or the default group, if
--   window is Nothing or if window
--   does not have an explicit window group.
--   
--   Since: 2.10
windowGetGroup :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> m WindowGroup

-- | Returns the Screen associated with window.
--   
--   Since: 2.2
windowGetScreen :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Screen

-- | Gets the type hint for this window. See windowSetTypeHint.
windowGetTypeHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> m WindowTypeHint

-- | Gets the type of the window. See WindowType.
--   
--   Since: 2.20
windowGetWindowType :: (HasCallStack, MonadIO m, IsWindow a) => a -> m WindowType

-- | Asks to iconify (i.e. minimize) the specified window.
--   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
--   Widget.
windowIconify :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to maximize window, 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
--   Widget, or by listening to notifications on the
--   Window:isMaximized property.
windowMaximize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Windows may set a hint asking the desktop environment not to receive
--   the input focus. This function sets this hint.
--   
--   Since: 2.4
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.
--   
--   Since: 2.6
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 Geometry struct.
windowSetGeometryHints :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> Maybe Geometry -> [WindowHints] -> m ()

-- | Sets up the icon representing a Window. 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.
--   
--   windowSetIconList 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 windowSetDefaultIconList 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 windowSetTransientFor) 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 ()

-- | Asks to keep window 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
--   Widget.
--   
--   Note that, according to the Extended Window Manager Hints
--   Specification, the above state is mainly meant for user
--   preferences and should not be used by applications e.g. for drawing
--   attention to their dialogs.
--   
--   Since: 2.4
windowSetKeepAbove :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Asks to keep window 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
--   Widget.
--   
--   Note that, according to the Extended Window Manager Hints
--   Specification, the above state is mainly meant for user
--   preferences and should not be used by applications e.g. for drawing
--   attention to their dialogs.
--   
--   Since: 2.4
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.)
--   
--   Since: 2.2
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.
--   
--   Since: 2.2
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 windowPresent or any equivalent
--   function generating a window map event.
--   
--   This function is only useful on X11, not with other GTK+ targets.
--   
--   Since: 2.12
windowSetStartupId :: (HasCallStack, MonadIO m, IsWindow a) => a -> Text -> m ()

-- | Windows may set a hint asking the desktop environment to draw the
--   users attention to the window. This function sets this hint.
--   
--   Since: 2.8
windowSetUrgencyHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Asks to toggle off the fullscreen state for window.
--   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 Widget.
--   
--   Since: 2.2
windowUnfullscreen :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to unmaximize window. 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
--   Widget.
windowUnmaximize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to unstick window, 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
--   Widget.
windowUnstick :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Claim ownership of a given selection for a particular widget, or, if
--   widget is Nothing, release ownership of the
--   selection.
--   
--   Since: 2.2
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
--   widget is Nothing, 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.
--   
--   
Updating the UI during a long computation
--   
--   
C code
--   
--   
--   // computation going on...
--   
--   while (gtk_events_pending ())
--     gtk_main_iteration ();
--   
--   // ...computation continued
--   
eventsPending :: (HasCallStack, MonadIO m) => m Bool

-- | The basic type. This corresponds to a wrapped GClosure on the
--   C side, which is a boxed object.
data GClosure a
byteStringToCString :: ByteString -> IO CString
cstringToByteString :: HasCallStack => CString -> IO ByteString
cstringToString :: HasCallStack => CString -> IO String
cstringToText :: HasCallStack => CString -> IO Text
gflagsToWord :: (Num b, IsGFlag a) => [a] -> b
mapCArrayWithLength :: (Storable a, Integral b) => b -> (a -> IO c) -> Ptr a -> IO ()
mapGArray :: Storable a => (a -> IO b) -> Ptr (GArray a) -> IO ()
mapGList :: (Ptr a -> IO b) -> Ptr (GList (Ptr a)) -> IO ()
mapGSList :: (Ptr a -> IO b) -> Ptr (GSList (Ptr a)) -> IO ()
mapPtrArray :: (Ptr a -> IO b) -> Ptr (GPtrArray (Ptr a)) -> IO ()
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
--   allocBytes) continuous area of memory.
packBlockArray :: Int -> [Ptr a] -> IO (Ptr a)
packByteString :: ByteString -> IO (Ptr Word8)
packFileNameArray :: [String] -> IO (Ptr CString)
packGArray :: Storable a => [a] -> IO (Ptr (GArray a))
packGByteArray :: ByteString -> IO (Ptr GByteArray)
packGHashTable :: GHashFunc a -> GEqualFunc a -> Maybe (GDestroyNotify a) -> Maybe (GDestroyNotify b) -> [(PtrWrapped a, PtrWrapped b)] -> IO (Ptr (GHashTable a b))

-- | Given a Haskell list of items, construct a GList with those values.
packGList :: [Ptr a] -> IO (Ptr (GList (Ptr a)))
packGPtrArray :: [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))

-- | Given a Haskell list of items, construct a GSList with those values.
packGSList :: [Ptr a] -> IO (Ptr (GSList (Ptr 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)
packPtrArray :: [Ptr a] -> IO (Ptr (Ptr a))
packStorableArray :: Storable a => [a] -> IO (Ptr a)
packUTF8CArray :: [Text] -> IO (Ptr CString)
packZeroTerminatedByteString :: ByteString -> IO (Ptr Word8)
packZeroTerminatedFileNameArray :: [String] -> IO (Ptr CString)
packZeroTerminatedPtrArray :: [Ptr a] -> IO (Ptr (Ptr a))
packZeroTerminatedStorableArray :: (Num a, Storable a) => [a] -> IO (Ptr a)
packZeroTerminatedUTF8CArray :: [Text] -> IO (Ptr CString)
stringToCString :: String -> IO CString

-- | Convert Text into a CString, using the GLib allocator.
textToCString :: Text -> IO CString
unpackBlockArrayWithLength :: Integral a => Int -> a -> Ptr b -> IO [Ptr b]
unpackBoxedArrayWithLength :: (Integral a, GBoxed b) => Int -> a -> Ptr b -> IO [Ptr b]
unpackByteStringWithLength :: Integral a => a -> Ptr Word8 -> IO ByteString
unpackFileNameArrayWithLength :: (HasCallStack, Integral a) => a -> Ptr CString -> IO [String]
unpackGArray :: Storable a => Ptr (GArray a) -> IO [a]
unpackGByteArray :: Ptr GByteArray -> IO ByteString
unpackGHashTable :: Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]

-- | Given a GSList construct the corresponding Haskell list.
unpackGList :: Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGPtrArray :: Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]

-- | Given a GSList construct the corresponding Haskell list.
unpackGSList :: Ptr (GSList (Ptr a)) -> IO [Ptr a]
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]
unpackPtrArrayWithLength :: Integral a => a -> Ptr (Ptr b) -> IO [Ptr b]
unpackStorableArrayWithLength :: (Integral a, Storable b) => a -> Ptr b -> IO [b]
unpackUTF8CArrayWithLength :: (HasCallStack, Integral a) => a -> Ptr CString -> IO [Text]
unpackZeroTerminatedByteString :: Ptr Word8 -> IO ByteString
unpackZeroTerminatedFileNameArray :: HasCallStack => Ptr CString -> IO [String]
unpackZeroTerminatedPtrArray :: Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedStorableArray :: (Eq a, Num a, Storable a) => Ptr a -> IO [a]
unpackZeroTerminatedUTF8CArray :: HasCallStack => Ptr CString -> IO [Text]
unrefGArray :: Ptr (GArray a) -> IO ()
unrefGByteArray :: Ptr GByteArray -> IO ()
unrefGHashTable :: Ptr (GHashTable a b) -> IO ()
unrefPtrArray :: Ptr (GPtrArray a) -> IO ()
withTextCString :: Text -> (CString -> IO a) -> IO a
wordToGFlags :: (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]

-- | Free the given GList.
g_list_free :: Ptr (GList a) -> IO ()

-- | Free the given GSList.
g_slist_free :: Ptr (GSList a) -> IO ()

-- | Get the name assigned to the given GType.
gtypeName :: GType -> IO String

-- | A convenient synonym for Nothing :: Maybe GParamSpec.
noGParamSpec :: Maybe GParamSpec

-- | This will catch just a specific GError exception. If you need to catch
--   a range of related errors, catchGErrorJustDomain is probably
--   more appropriate. Example:
--   
--   
--   do image <- catchGErrorJust PixbufErrorCorruptImage
--                 loadImage
--                 (\errorMessage -> do log errorMessage
--                                      return mssingImagePlaceholder)
--   
catchGErrorJust :: GErrorClass err => err -> IO a -> (GErrorMessage -> IO a) -> IO a

-- | Like propagateGError, but allows to specify a custom handler
--   instead of just throwing the exception.
checkGError :: (Ptr (Ptr GError) -> IO a) -> (GError -> IO a) -> IO a

-- | The numeric code for the given GError.
gerrorCode :: GError -> IO GErrorCode

-- | Return the domain for the given GError. This is a GQuark, a
--   textual representation can be obtained with quarkToString.
gerrorDomain :: GError -> IO GQuark

-- | A text message describing the GError.
gerrorMessage :: GError -> IO GErrorMessage

-- | Create a new GError.
gerrorNew :: GErrorDomain -> GErrorCode -> GErrorMessage -> IO GError

-- | A verson of handleGErrorJust with the arguments swapped around.
handleGErrorJust :: GErrorClass err => err -> (GErrorMessage -> IO a) -> IO a -> IO a

-- | If the passed in Maybe GError is not
--   Nothing, store a copy in the passed in pointer, unless the
--   pointer is nullPtr.
maybePokeGError :: Ptr (Ptr GError) -> Maybe GError -> IO ()

-- | Run the given function catching possible GErrors in its
--   execution. If a GError is emitted this throws the corresponding
--   exception.
propagateGError :: (Ptr (Ptr GError) -> IO a) -> IO a

-- | Pack a CString into a Ptr than can go into a
--   GHashTable.
cstringPackPtr :: CString -> PtrWrapped CString

-- | Extract a CString wrapped into a Ptr coming from a
--   GHashTable.
cstringUnpackPtr :: PtrWrapped CString -> CString

-- | Check whether two pointers are equal.
gDirectEqual :: GEqualFunc (Ptr a)

-- | Compute the hash for a Ptr.
gDirectHash :: GHashFunc (Ptr a)

-- | Check whether two CStrings are equal.
gStrEqual :: GEqualFunc CString

-- | Compute the hash for a CString.
gStrHash :: GHashFunc CString

-- | Pack a Ptr to GValue into a Ptr than can go into
--   a GHashTable.
gvaluePackPtr :: Ptr GValue -> PtrWrapped (Ptr GValue)

-- | Extract a Ptr to GValue wrapped into a Ptr coming
--   from a GHashTable.
gvalueUnpackPtr :: PtrWrapped (Ptr GValue) -> Ptr GValue

-- | Pack a Ptr into a PtrWrapped Ptr.
ptrPackPtr :: Ptr a -> PtrWrapped (Ptr a)

-- | Extract a Ptr from a PtrWrapped Ptr.
ptrUnpackPtr :: PtrWrapped (Ptr a) -> Ptr a

-- | Disown a GVariant, i.e. do not unref the underlying object when
--   the Haskell object is garbage collected.
disownGVariant :: GVariant -> IO (Ptr GVariant)
gvariantFromBool :: Bool -> IO GVariant

-- | Encode a ByteString into a list of bytes GVariant.
gvariantFromBytestring :: ByteString -> IO GVariant

-- | Construct a GVariant of type DictEntry from the given
--   key and value. The key must be a basic
--   GVariant type, i.e. not a container. This is determined by
--   whether it belongs to the IsGVariantBasicType typeclass. On the
--   other hand value is an arbitrary GVariant, and in
--   particular it can be a container type.
gvariantFromDictEntry :: (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => key -> value -> IO GVariant
gvariantFromDouble :: Double -> IO GVariant

-- | Box a GVariant inside another GVariant.
gvariantFromGVariant :: GVariant -> IO GVariant

-- | Convert a DBus handle (an Int32) into a GVariant.
gvariantFromHandle :: Int32 -> IO GVariant
gvariantFromInt16 :: Int16 -> IO GVariant
gvariantFromInt32 :: Int32 -> IO GVariant
gvariantFromInt64 :: Int64 -> IO GVariant

-- | Given a list of elements construct a GVariant array containing
--   them.
gvariantFromList :: IsGVariant a => [a] -> IO GVariant

-- | Pack a Map into a GVariant for dictionary type, which
--   is just an array of GVariantDictEntry.
gvariantFromMap :: (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => Map key value -> IO GVariant

-- | Convert a Maybe value into a corresponding GVariant of
--   maybe type.
gvariantFromMaybe :: IsGVariant a => Maybe a -> IO GVariant

-- | Construct a GVariant containing an object path. In order to
--   build a GVariantObjectPath value see
--   newGVariantObjectPath.
gvariantFromObjectPath :: GVariantObjectPath -> IO GVariant

-- | Construct a GVariant containing an DBus signature. In order to
--   build a GVariantSignature value see
--   newGVariantSignature.
gvariantFromSignature :: GVariantSignature -> IO GVariant

-- | Encode a Text into an UTF-8 encoded string GVariant.
gvariantFromText :: Text -> IO GVariant

-- | Given a list of GVariant, construct a GVariant tuple
--   containing the elements in the list.
gvariantFromTuple :: [GVariant] -> IO GVariant
gvariantFromWord16 :: Word16 -> IO GVariant
gvariantFromWord32 :: Word32 -> IO GVariant
gvariantFromWord64 :: Word64 -> IO GVariant
gvariantFromWord8 :: Word8 -> IO GVariant

-- | Get the expected type of a GVariant, in GVariant
--   notation. See https://docs.gtk.org/glib/struct.VariantType.html
--   for the meaning of the resulting format string.
gvariantGetTypeString :: GVariant -> IO Text

-- | Return the Text representation of a GVariantObjectPath.
gvariantObjectPathToText :: GVariantObjectPath -> Text

-- | Return the Text representation of a GVariantSignature.
gvariantSignatureToText :: GVariantSignature -> Text
gvariantToBool :: GVariant -> IO (Maybe Bool)

-- | Extract a zero terminated list of bytes into a ByteString.
gvariantToBytestring :: GVariant -> IO (Maybe ByteString)

-- | Unpack a DictEntry variant into key and value, which
--   are returned as a two element tuple in case of success.
gvariantToDictEntry :: (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => GVariant -> IO (Maybe (key, value))
gvariantToDouble :: GVariant -> IO (Maybe Double)

-- | Unbox a GVariant contained inside another GVariant.
gvariantToGVariant :: GVariant -> IO (Maybe GVariant)

-- | Extract the DBus handle (an Int32) inside a GVariant.
gvariantToHandle :: GVariant -> IO (Maybe Int32)
gvariantToInt16 :: GVariant -> IO (Maybe Int16)
gvariantToInt32 :: GVariant -> IO (Maybe Int32)
gvariantToInt64 :: GVariant -> IO (Maybe Int64)

-- | Unpack a GVariant array into its elements.
gvariantToList :: IsGVariant a => GVariant -> IO (Maybe [a])

-- | Unpack a GVariant into a Map. Notice that this assumes
--   that all the elements in the GVariant array of
--   GVariantDictEntry are of the same type, which is not necessary
--   for a generic GVariant, so this is somewhat restrictive. For
--   the general case it is necessary to use gvariantToList plus
--   gvariantToDictEntry directly.
gvariantToMap :: (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => GVariant -> IO (Maybe (Map key value))

-- | Try to decode a maybe GVariant into the corresponding
--   Maybe type. If the conversion is successful this returns
--   Just x, where x itself is of Maybe type. So,
--   in particular, Just Nothing indicates a successful call, and
--   means that the GVariant of maybe type was empty.
gvariantToMaybe :: IsGVariant a => GVariant -> IO (Maybe (Maybe a))

-- | Extract a GVariantObjectPath from a GVariant,
--   represented as its underlying Text representation.
gvariantToObjectPath :: GVariant -> IO (Maybe Text)

-- | Extract a GVariantSignature from a GVariant, represented
--   as Text.
gvariantToSignature :: GVariant -> IO (Maybe Text)

-- | Decode an UTF-8 encoded string GVariant into Text.
gvariantToText :: GVariant -> IO (Maybe Text)

-- | Extract the children of a GVariant tuple into a list.
gvariantToTuple :: GVariant -> IO (Maybe [GVariant])
gvariantToWord16 :: GVariant -> IO (Maybe Word16)
gvariantToWord32 :: GVariant -> IO (Maybe Word32)
gvariantToWord64 :: GVariant -> IO (Maybe Word64)
gvariantToWord8 :: GVariant -> IO (Maybe Word8)

-- | Construct a Haskell wrapper for the given GVariant, without
--   assuming ownership.
newGVariantFromPtr :: Ptr GVariant -> IO GVariant

-- | Try to construct a DBus object path. If the passed string is not a
--   valid object path Nothing will be returned.
newGVariantObjectPath :: Text -> Maybe GVariantObjectPath

-- | Try to construct a DBus object path. If the passed string is not a
--   valid DBus signature Nothing will be returned.
newGVariantSignature :: Text -> Maybe GVariantSignature

-- | An alias for Nothing :: Maybe GVariant to save some typing.
noGVariant :: Maybe GVariant

-- | Remove a reference to the given GVariant.
unrefGVariant :: GVariant -> IO ()

-- | Take ownership of a passed in Ptr (typically created just for
--   us, so if it is floating we sink it).
wrapGVariantPtr :: Ptr GVariant -> IO GVariant

-- | Check whether the given object is an instance of the given type.
checkInstanceType :: (ManagedPtrNewtype o, TypedObject o) => o -> GType -> IO Bool

-- | Make a copy of the given boxed object.
copyBoxed :: (HasCallStack, GBoxed a) => a -> IO (Ptr a)

-- | Like copyBoxed, but acting directly on a pointer, instead of a
--   managed pointer.
copyBoxedPtr :: GBoxed a => Ptr a -> IO (Ptr a)

-- | 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 GBoxed.
disownBoxed :: (HasCallStack, GBoxed a) => a -> IO (Ptr a)

-- | Do not run the finalizers upon garbage collection of the
--   ManagedPtr.
disownManagedPtr :: (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)

-- | 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)

-- | Free the memory associated with a boxed object. Note that this disowns
--   the associated ManagedPtr via disownManagedPtr.
freeBoxed :: (HasCallStack, GBoxed a) => a -> IO ()

-- | Like withManagedPtr, but accepts a Maybe type. If the
--   passed value is Nothing the inner action will be executed with
--   a nullPtr argument.
maybeWithManagedPtr :: (HasCallStack, ManagedPtrNewtype a) => Maybe a -> (Ptr a -> IO c) -> IO c

-- | 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

-- | Thin wrapper over newForeignPtr.
newManagedPtr :: HasCallStack => Ptr a -> IO () -> IO (ManagedPtr a)

-- | Version of newManagedPtr taking a FinalizerPtr and a
--   corresponding Ptr, as in newForeignPtr.
newManagedPtr' :: HasCallStack => FinalizerPtr a -> Ptr a -> IO (ManagedPtr a)

-- | Thin wrapper over newForeignPtr_.
newManagedPtr_ :: Ptr a -> IO (ManagedPtr a)

-- | Construct a Haskell wrapper for a GObject, 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

-- | Wrap a pointer, making a copy of the data.
newPtr :: (HasCallStack, BoxedPtr a) => (ManagedPtr a -> a) -> Ptr a -> IO a

-- | Unref the given GObject and disown it. Use this if you want to
--   manually release the memory associated to a given GObject
--   (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 GObject after calling this function.
releaseObject :: (HasCallStack, GObject a) => a -> IO ()

-- | Ensure that the Ptr 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 ()

-- | Decrease the reference count of the given GObject. The memory
--   associated with the object may be released if the reference count
--   reaches 0.
unrefObject :: (HasCallStack, GObject a) => a -> IO ()

-- | Cast a typed object to a new type (without any assumption that both
--   types descend from GObject), assuming that the cast will
--   succeed. This function will call error if the cast is illegal.
unsafeCastTo :: (HasCallStack, ManagedPtrNewtype o, TypedObject o, ManagedPtrNewtype o', TypedObject o') => (ManagedPtr o' -> o') -> o -> IO o'

-- | Same as unsafeManagedPtrGetPtr, but is polymorphic on the
--   return type.
unsafeManagedPtrCastPtr :: (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)

-- | Return the Ptr in a given managed pointer. As the name says,
--   this is potentially unsafe: the given Ptr may only be used
--   before a call to touchManagedPtr. This function is of
--   most interest to the autogenerated bindings, for hand-written code
--   withManagedPtr is almost always a better choice.
unsafeManagedPtrGetPtr :: (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)

-- | Perform an IO action on the Ptr inside a managed pointer.
withManagedPtr :: (HasCallStack, ManagedPtrNewtype a) => a -> (Ptr a -> IO c) -> IO c

-- | Perform an IO action taking a list of Ptr on a list of managed
--   pointers.
withManagedPtrList :: (HasCallStack, ManagedPtrNewtype a) => [a] -> ([Ptr a] -> IO c) -> IO c

-- | 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 newObject.
withNewObject :: (HasCallStack, GObject o) => Ptr o -> (o -> IO b) -> IO b

-- | 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

-- | Like newBoxed, 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

-- | Same as newObject, but we steal ownership of the object.
wrapObject :: (HasCallStack, GObject a, GObject b) => (ManagedPtr a -> a) -> Ptr b -> IO a

-- | Wrap a pointer, taking ownership of it.
wrapPtr :: (HasCallStack, BoxedPtr a) => (ManagedPtr a -> a) -> Ptr a -> IO a

-- | Safe coercions to a parent class. For instance:
--   
--   
--   #show $ label `asA` Gtk.Widget
--   
asA :: (ManagedPtrNewtype a, ManagedPtrNewtype b, HasParentTypes b, IsDescendantOf a b) => b -> (ManagedPtr a -> a) -> a

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

-- | Flags with an associated GType.
class TypedObject a => BoxedFlags 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 BoxedPtr.
boxedPtrCopy :: BoxedPtr a => a -> IO a

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

-- | 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 GType below.
type CGType = Word64

-- | 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)

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

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

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

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

-- | 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

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

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

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

-- | A GParamSpec. See Data.GI.Base.GParamSpec for further
--   methods.
newtype GParamSpec
GParamSpec :: ManagedPtr GParamSpec -> GParamSpec

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

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

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

-- | A GVariant. See Data.GI.Base.GVariant for further
--   methods.
newtype GVariant
GVariant :: ManagedPtr GVariant -> GVariant

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

-- | Thin wrapper over ForeignPtr, supporting the extra notion of
--   disowning, 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

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

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

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

-- | Some APIs, such as GHashTable, 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 wrapped object that has an associated GLib type. This does not
--   necessarily descend from GObject, that constraint is
--   implemented by GObject below.
class HasParentTypes a => TypedObject a

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

-- | 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 nullPtr.
data UnexpectedNullPointerReturn
UnexpectedNullPointerReturn :: Text -> UnexpectedNullPointerReturn
[nullPtrErrorMsg] :: UnexpectedNullPointerReturn -> Text

-- | 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 PixbufError:
--   
--   
--   instance GErrorClass PixbufError where
--     gerrorClassDomain _ = "gdk-pixbuf-error-quark"
--   
class Enum err => GErrorClass err
gerrorClassDomain :: GErrorClass err => err -> Text

-- | A code to identify a specific error within a given
--   GErrorDomain. 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 catchGErrorJustDomain or handleGErrorJustDomain,
--   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

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

-- | Class for types that can be marshaled back and forth between Haskell
--   values and GValues. These are low-level methods, you might want
--   to use toGValue and fromGValue 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

-- | A DictEntry GVariant is isomorphic to a two-tuple. Wrapping the
--   values into a GVariantDictentry allows the IsGVariant
--   instance to do the right thing.
data GVariantDictEntry key value
GVariantDictEntry :: key -> value -> GVariantDictEntry key value
newtype GVariantHandle
GVariantHandle :: Int32 -> GVariantHandle

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

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

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

-- | The typeclass for types that can be automatically marshalled into
--   GVariant using toGVariant and fromGVariant.
class IsGVariant a

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

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

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

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

-- | A signal connector for the notify signal on the given
--   property, similar to PropertyNotify, but it passes the new
--   value of the property to the callback for convenience.
[PropertySet] :: forall info1 (propName :: Symbol) object b (pl :: Symbol). (info1 ~ ResolveAttribute propName object, AttrInfo info1, AttrBaseTypeConstraint info1 object, b ~ AttrGetType info1, pl ~ AttrLabel info1, KnownSymbol pl) => AttrLabelProxy propName -> SignalProxy object (GObjectPropertySetSignalInfo b)

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

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

-- | Generate a function pointer callable from C code, from a
--   C_TranslateFunc.
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 Nothing :: Maybe
--   TranslateFunc.
noTranslateFunc :: Maybe TranslateFunc

-- | Wrap the callback into a GClosure.
genClosure_TranslateFunc :: MonadIO m => TranslateFunc -> m (GClosure C_TranslateFunc)

-- | Wrap a TranslateFunc into a C_TranslateFunc.
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
--   MAJOR_VERSION, MINOR_VERSION, MICRO_VERSION 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
--   requiredMajor.required_minor.requiredMicro.
--   Second the running library must be binary compatible with the version
--   requiredMajor.required_minor.requiredMicro
--   (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 checkVersion, but still get loaded into an
--   application using a newer version of GTK+.
checkVersion :: (HasCallStack, MonadIO m) => Word32 -> Word32 -> Word32 -> m (Maybe Text)

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

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

-- | Generate a function pointer callable from C code, from a
--   C_Callback.
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 Nothing :: Maybe
--   Callback.
noCallback :: Maybe Callback

-- | Wrap the callback into a GClosure.
genClosure_Callback :: MonadIO m => Callback -> m (GClosure C_Callback)

-- | Wrap a Callback into a C_Callback.
wrap_Callback :: Maybe (Ptr (FunPtr C_Callback)) -> Callback_WithClosures -> C_Callback

-- | Returns the binary age as passed to libtool when building the
--   GTK+ library the process is running against. If libtool means
--   nothing to you, don't worry about it.
--   
--   Since: 3.0
getBinaryAge :: (HasCallStack, MonadIO m) => m Word32

-- | Returns the interface age as passed to libtool when building
--   the GTK+ library the process is running against. If libtool
--   means nothing to you, don't worry about it.
--   
--   Since: 3.0
getInterfaceAge :: (HasCallStack, MonadIO m) => m Word32

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

-- | 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 MAJOR_VERSION
--   macro, which represents the major version of the GTK+ headers you have
--   included when compiling your code.
--   
--   Since: 3.0
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
--   MICRO_VERSION macro, which represents the micro version of the
--   GTK+ headers you have included when compiling your code.
--   
--   Since: 3.0
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
--   MINOR_VERSION macro, which represents the minor version of the
--   GTK+ headers you have included when compiling your code.
--   
--   Since: 3.0
getMinorVersion :: (HasCallStack, MonadIO m) => m Word32

-- | 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 gTKBORDERSTYLENONE
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

-- | Renders a frame around the rectangle defined by x,
--   y, width, height.
--   
--   Examples of frame rendering, showing the effect of
--   border-image, border-color, border-width,
--   border-radius and junctions:
--   
--   
--   Since: 3.0
renderFrame :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

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

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

-- | The priority used for style information provided by themes.
pattern STYLE_PROVIDER_PRIORITY_THEME :: Int32

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

-- | Sets the current sort column to be sortColumnId. The
--   sortable will resort itself to reflect this change,
--   after emitting a TreeSortable::sortColumnChanged signal.
--   sortColumnId may either be a regular column id, or one
--   of the following special values:
--   
--   
--   
- TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort
--   function will be used, if it is set
--   
- TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will
--   occur
--   
treeSortableSetSortColumnId :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> Int32 -> SortType -> m ()

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

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

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

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

-- | 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.
--   
--   Since: 2.22
assistantCommit :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m ()

-- | 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
--   BaselinePosition to select where to put the baseline inside the
--   extra availible space.
--   
--   Since: 3.10
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

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

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

-- | Prebuilt sets of buttons for the dialog. If none of these choices are
--   appropriate, simply use ButtonsTypeNone then call
--   gtk_dialog_add_buttons().
--   
--   
--   Please note that 'GI.Gtk.Enums.ButtonsTypeOk', 'GI.Gtk.Enums.ButtonsTypeYesNo'
--   and 'GI.Gtk.Enums.ButtonsTypeOkCancel' are discouraged by the
--   <http://library.gnome.org/devel/hig-book/stable/ GNOME Human Interface Guidelines>.
--   
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

-- | 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

-- | Gets the type of representation being used by the Image to
--   store image data. If the Image has no image data, the return
--   value will be ImageTypeEmpty.
imageGetStorageType :: (HasCallStack, MonadIO m, IsImage a) => a -> m ImageType

-- | Gets the Pixbuf being displayed by the Image. The
--   storage type of the image must be ImageTypeEmpty or
--   ImageTypePixbuf (see imageGetStorageType). 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 Image.
--   The storage type of the image must be ImageTypeEmpty or
--   ImageTypeStock (see imageGetStorageType). The returned
--   string is owned by the Image and should not be freed.
imageGetStock :: (HasCallStack, MonadIO m, IsImage a) => a -> m (Text, Int32)

-- | 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

-- | Sets the value of PRINT_SETTINGS_ORIENTATION.
--   
--   Since: 2.10
printSettingsSetOrientation :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PageOrientation -> m ()

-- | This function was used internally by the GtkRC parsing mechanism to
--   assign match patterns to BindingSet structures.
--   
--   In GTK+ 3, these match patterns are unused.
bindingSetAddPath :: (HasCallStack, MonadIO m) => BindingSet -> PathType -> Text -> PathPriorityType -> m ()

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

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

-- | Sets the value of PRINT_SETTINGS_DUPLEX.
--   
--   Since: 2.10
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
--   PrintOperation::statusChanged signal on op 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 printOperationSetAllowAsync or set the
--   PrintOperation:allowAsync property the operation will run
--   asynchronously if this is supported on the platform. The
--   PrintOperation::done 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).
--   
--   
C code
--   
--   
--   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), &data);
--   g_signal_connect (print, "draw-page",
--                     G_CALLBACK (draw_page), &data);
--    
--   res = gtk_print_operation_run (print,
--                                  GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
--                                  parent,
--                                  &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->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));
--    }
--   
--   
--   Note that printOperationRun can only be called once on a given
--   PrintOperation.
--   
--   Since: 2.10
printOperationRun :: (HasCallStack, MonadIO m, IsPrintOperation a, IsWindow b) => a -> PrintOperationAction -> Maybe b -> m PrintOperationResult

-- | Sets the value of PRINT_SETTINGS_QUALITY.
--   
--   Since: 2.10
printSettingsSetQuality :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PrintQuality -> m ()

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

-- | The RcTokenType 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

-- | 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

-- | Adds a button with the given text and sets things up so that clicking
--   the button will emit the Dialog::response signal with the given
--   responseId. 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

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

-- | 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 type indicates the current state of a widget; the state
--   determines how the widget is drawn. The StateType enumeration
--   is also used to identify different colors in a Style 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 True nor False, or buttons
--   requiring the user attention.
StateTypeInconsistent :: StateType

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

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

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

-- | 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
--   info values from the TextBufferTargetInfo enum,
--   using targetListAddRichTextTargets and
--   targetListAddTextTargets.
--   
--   Since: 2.10
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 info values from the TextBufferTargetInfo
--   enum, using targetListAddRichTextTargets and
--   targetListAddTextTargets.
--   
--   Since: 2.10
textBufferGetPasteTargetList :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TargetList

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

-- | Sets the value of PRINT_SETTINGS_PAPER_WIDTH.
--   
--   Since: 2.10
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 False 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
--   widgetShow.
--   
--   On Windows, this function always works, since there’s no window
--   manager policy involved.
windowSetDecorated :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

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

-- | Adds a widget to the action area of a Assistant.
--   
--   Since: 2.10
assistantAddActionWidget :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m ()

-- | Sets the Box:homogeneous property of box,
--   controlling whether or not all children of box are
--   given equal space in the box.
boxSetHomogeneous :: (HasCallStack, MonadIO m, IsBox a) => a -> Bool -> m ()

-- | Sets the Box:spacing property of box, which is
--   the number of pixels to place between children of box.
boxSetSpacing :: (HasCallStack, MonadIO m, IsBox a) => a -> Int32 -> m ()

-- | Gets the parent section for the given section. The
--   parent section is the section that contains this
--   section. A special case are sections of type
--   GTK_CSS_SECTION_DOCUMENT. Their parent will either be
--   Nothing if they are the original CSS document that was loaded
--   by cssProviderLoadFromFile or a section of type
--   GTK_CSS_SECTION_IMPORT if it was loaded with an import
--   rule from a different file.
--   
--   Since: 3.2
cssSectionGetParent :: (HasCallStack, MonadIO m) => CssSection -> m (Maybe CssSection)

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

-- | Feeds an events into controller, so it can be
--   interpreted and the controller actions triggered.
--   
--   Since: 3.14
eventControllerHandleEvent :: (HasCallStack, MonadIO m, IsEventController a) => a -> Event -> m Bool

-- | Sets the comparison function used when sorting to be
--   sortFunc. If the chooser has the sort
--   type set to GTK_RECENT_SORT_CUSTOM then the chooser
--   will sort using this function.
--   
--   To the comparison function will be passed two RecentInfo
--   structs and sortData; sortFunc 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.
--   
--   Since: 2.10
recentChooserSetSortFunc :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> RecentSortFunc -> m ()

-- | 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 SelectionModeBrowse. 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

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

-- | Used to reference the layers of TextView for the purpose of
--   customized drawing with the draw_layer vfunc.
data TextViewLayer

-- | Old deprecated layer, use TextViewLayerBelowText instead
TextViewLayerBelow :: TextViewLayer

-- | Old deprecated layer, use TextViewLayerAboveText 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

-- | Installs an accelerator in this group. When accelGroup
--   is being activated in response to a call to
--   accelGroupsActivate, closure will be invoked if
--   the accelKey and accelMods from
--   accelGroupsActivate match those of this connection.
--   
--   The signature used for the closure is that of
--   AccelGroupActivate.
--   
--   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
--   flags parameter. When the application completes the
--   operation it should call applicationUninhibit 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 window is given, the session manager may point the
--   user to this window to find out more about why the action is
--   inhibited.
--   
--   Since: 3.4
applicationInhibit :: (HasCallStack, MonadIO m, IsApplication a, IsWindow b) => a -> Maybe b -> [ApplicationInhibitFlags] -> Maybe Text -> m Word32

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

-- | The DestDefaults 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 dragStatus 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 widgetDragGetData on behalf of the widget.
--   Whether or not the drop is successful, GTK+ will call
--   dragFinish. If the action was a move, then if the drag was
--   successful, then True will be passed for the
--   delete parameter to dragFinish.
DestDefaultsDrop :: DestDefaults

-- | If set, specifies that all default actions should be taken.
DestDefaultsAll :: DestDefaults

-- | Catch-all for unknown values
AnotherDestDefaults :: Int -> DestDefaults

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

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

-- | Looks up a named icon and returns a IconInfo containing
--   information such as the filename of the icon. The icon can then be
--   rendered into a pixbuf using iconInfoLoadIcon.
--   (iconThemeLoadIcon combines these two steps if all you need is
--   the pixbuf.)
--   
--   When rendering on displays with high pixel densities you should not
--   use a size multiplied by the scaling factor returned
--   by functions like windowGetScaleFactor. Instead, you should use
--   iconThemeLookupIconForScale, as the assets loaded for a given
--   scaling factor may be different.
--   
--   Since: 2.4
iconThemeLookupIcon :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> Int32 -> [IconLookupFlags] -> m (Maybe IconInfo)

-- | 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 gTKINPUTPURPOSEDIGITS and
--   gTKINPUTPURPOSENUMBER 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”.
--   
--   Since: 3.6
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 gTKINPUTPURPOSEFREEFORM, but characters are
--   hidden
InputPurposePassword :: InputPurpose

-- | Like gTKINPUTPURPOSEDIGITS, but characters are hidden
InputPurposePin :: InputPurpose

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

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

-- | 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 sidebar 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 PlacesSidebar::openLocation signal is emitted, its
--   flags argument will be set to one of the flags that
--   was passed in placesSidebarSetOpenFlags.
--   
--   Passing 0 for flags will cause
--   GTK_PLACES_OPEN_NORMAL to always be sent to callbacks
--   for the “open-location” signal.
--   
--   Since: 3.10
placesSidebarSetOpenFlags :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> [PlacesOpenFlags] -> m ()

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

-- | 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 context. 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.
--   
--   Since: 3.20
styleContextToString :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StyleContextPrintFlags] -> m Text

-- | The TargetFlags enumeration is used to specify constraints on a
--   TargetEntry.
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 TargetEntry
TargetEntry :: ManagedPtr TargetEntry -> TargetEntry

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

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

-- | Adds a UI element to the current contents of manager.
--   
--   If type is UIManagerItemTypeAuto, GTK+ inserts
--   a menuitem, toolitem or separator if such an element can be inserted
--   at the place determined by path. Otherwise
--   type must indicate an element that can be inserted at
--   the place determined by path.
--   
--   If path points to a menuitem or toolitem, the new
--   element will be inserted before or after this item, depending on
--   top.
--   
--   Since: 2.4
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
--   Calendar:showDetails is set. A tooltip containing with full
--   detail information is provided, if the entire text should not fit into
--   the details area, or if Calendar:showDetails is not set.
--   
--   The size of the details area can be restricted by setting the
--   Calendar:detailWidthChars and Calendar:detailHeightRows
--   properties.
--   
--   Since: 2.14
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 Widget::dragDataReceived
--   signal. Failure of the retrieval is indicated by the length field of
--   the selectionData signal parameter being negative.
--   However, when widgetDragGetData is called implicitely because
--   the DestDefaultsDrop 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 windowSetTransientFor 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 setting is True, then destroying the
--   transient parent of window will also destroy
--   window 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 ()

-- | Used to specify options for iconThemeLookupIcon
data IconLookupFlags

-- | Never get SVG icons, even if gdk-pixbuf supports them. Cannot be used
--   together with IconLookupFlagsForceSvg.
IconLookupFlagsNoSvg :: IconLookupFlags

-- | Get SVG icons, even if gdk-pixbuf doesn’t support them. Cannot be used
--   together with IconLookupFlagsNoSvg.
IconLookupFlagsForceSvg :: IconLookupFlags

-- | When passed to iconThemeLookupIcon includes builtin icons as
--   well as files. For a builtin icon, iconInfoGetFilename is
--   Nothing and you need to call iconInfoGetBuiltinPixbuf.
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 iconThemeChooseIcon.
--   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

-- | Gets the filename for the icon. If the
--   IconLookupFlagsUseBuiltin flag was passed to
--   iconThemeLookupIcon, there may be no filename if a builtin icon
--   is returned; in this case, you should use
--   iconInfoGetBuiltinPixbuf.
--   
--   Since: 2.4
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
--   IconLookupFlagsUseBuiltin to iconThemeLookupIcon.
--   
--   Since: 2.4
iconInfoGetBuiltinPixbuf :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m (Maybe Pixbuf)

-- | Looks up a named icon and returns a IconInfo containing
--   information such as the filename of the icon. The icon can then be
--   rendered into a pixbuf using iconInfoLoadIcon.
--   (iconThemeLoadIcon combines these two steps if all you need is
--   the pixbuf.)
--   
--   If iconNames contains more than one name, this
--   function tries them all in the given order before falling back to
--   inherited icon themes.
--   
--   Since: 2.12
iconThemeChooseIcon :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> [Text] -> Int32 -> [IconLookupFlags] -> m (Maybe IconInfo)

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

-- | These enumeration values are used by uIManagerAddUi 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 UIManagerItemTypePopup, but the actions’ accelerators
--   are shown.
UIManagerItemTypePopupWithAccels :: UIManagerItemType

-- | Catch-all for unknown values
AnotherUIManagerItemType :: Int -> UIManagerItemType

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

-- | Memory-managed wrapper type.
newtype ColorChooser
ColorChooser :: ManagedPtr ColorChooser -> ColorChooser

-- | Represents the orientation of widgets and other objects which can be
--   switched between horizontal and vertical orientation on the fly, like
--   Toolbar or GesturePan.
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

-- | Deletes a sequence of characters. The characters that are deleted are
--   those characters at positions from startPos up to, but
--   not including endPos. If endPos is
--   negative, then the characters deleted are those from
--   startPos 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 ()

-- | Memory-managed wrapper type.
newtype Editable
Editable :: ManagedPtr Editable -> Editable

-- | Determines if the user can edit the text in the editable widget or
--   not.
editableSetEditable :: (HasCallStack, MonadIO m, IsEditable a) => a -> Bool -> m ()

-- | Memory-managed wrapper type.
newtype Orientable
Orientable :: ManagedPtr Orientable -> Orientable

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

-- | Sets the minimum value of the adjustment.
--   
--   When setting multiple adjustment properties via their individual
--   setters, multiple Adjustment::changed signals will be emitted.
--   However, since the emission of the Adjustment::changed signal
--   is tied to the emission of the Object::notify signals of the
--   changed properties, it’s possible to compress the
--   Adjustment::changed signals into one by calling
--   objectFreezeNotify and objectThawNotify around the calls
--   to the individual setters.
--   
--   Alternatively, using a single g_object_set() for all
--   the properties to change, or using adjustmentConfigure has the
--   same effect of compressing Adjustment::changed emissions.
--   
--   Since: 2.14
adjustmentSetLower :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets the Adjustment value. The value is clamped to lie between
--   Adjustment:lower and Adjustment:upper.
--   
--   Note that for adjustments which are used in a Scrollbar, the
--   effective range of allowed values goes from Adjustment:lower to
--   Adjustment:upper - Adjustment:pageSize.
adjustmentSetValue :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets all properties of the adjustment at once.
--   
--   Use this function to avoid multiple emissions of the
--   Adjustment::changed signal. See adjustmentSetLower for
--   an alternative way of compressing multiple emissions of
--   Adjustment::changed into one.
--   
--   Since: 2.14
adjustmentConfigure :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> Double -> Double -> Double -> Double -> Double -> m ()

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

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

-- | Retrieves the length in characters of the buffer.
--   
--   Since: 2.18
entryBufferGetLength :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m Word32

-- | 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.
--   
--   Since: 2.18
entryBufferSetMaxLength :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Int32 -> m ()

-- | Deletes a sequence of characters from the buffer.
--   nChars characters are deleted starting at
--   position. If nChars is negative, then
--   all characters until the end of the text are deleted.
--   
--   If position or nChars are out of
--   bounds, then they are coerced to sane values.
--   
--   Note that the positions are specified in characters, not bytes.
--   
--   Since: 2.18
entryBufferDeleteText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Word32 -> Int32 -> m Word32

-- | Inserts nChars characters of chars
--   into the contents of the buffer, at position position.
--   
--   If nChars is negative, then characters from chars will
--   be inserted until a null-terminator is found. If
--   position or nChars 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.
--   
--   Since: 2.18
entryBufferInsertText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Word32 -> Text -> Int32 -> m Word32

-- | Sets surrounding context around the insertion point and preedit
--   string. This function is expected to be called in response to the
--   GtkIMContextretrieve_surrounding signal, and will likely have
--   no effect if called at other times.
iMContextSetSurrounding :: (HasCallStack, MonadIO m, IsIMContext a) => a -> Text -> Int32 -> Int32 -> 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)

-- | Memory-managed wrapper type.
newtype IMContext
IMContext :: ManagedPtr IMContext -> IMContext

-- | 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
--   GtkIMContextretrieve_surrounding 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
--   iMContextSetSurrounding. Note that there is no obligation for a
--   widget to respond to the retrieve_surrounding signal, so input
--   methods must be prepared to function without context.
iMContextGetSurrounding :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m (Bool, Text, Int32)

-- | Memory-managed wrapper type.
newtype IMContextSimple
IMContextSimple :: ManagedPtr IMContextSimple -> IMContextSimple

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

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

-- | Parses a string representing an accelerator. The format looks like
--   <Control>a or <Shift><Alt>F1 or
--   <Release>z (the last one is for key release).
--   
--   The parser is fairly liberal and allows lower or upper case, and also
--   abbreviations such as <Ctl> and <Ctrl>.
--   Key names are parsed using keyvalFromName. For character keys
--   the name is not the symbol, but the lowercase name, e.g. one would use
--   <Ctrl>minus instead of <Ctrl>-.
--   
--   If the parse fails, acceleratorKey and
--   acceleratorMods will be set to 0 (zero).
acceleratorParse :: (HasCallStack, MonadIO m) => Text -> m (Word32, [ModifierType])

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

-- | Frees a Border-struct.
borderFree :: (HasCallStack, MonadIO m) => Border -> m ()

-- | 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

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

-- | 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
--   section is not yet parsed completely. This will for
--   example happen in the GtkCssProviderparsingError signal. The
--   end position and line may be identical to the start position and line
--   for sections which failed to parse anything successfully.
--   
--   Since: 3.2
cssSectionGetEndLine :: (HasCallStack, MonadIO m) => CssSection -> m Word32

-- | Loads the data contained in file into
--   cssProvider, making it clear any previously loaded
--   information.
cssProviderLoadFromFile :: (HasCallStack, MonadIO m, IsCssProvider a, IsFile b) => a -> b -> m ()

-- | 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.
--   
--   Since: 3.2
cssSectionGetStartLine :: (HasCallStack, MonadIO m) => CssSection -> m Word32

-- | Memory-managed wrapper type.
newtype CssSection
CssSection :: ManagedPtr CssSection -> CssSection

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

-- | Creates a new IconSet with pixbuf as the
--   default/fallback source image. If you don’t add any additional
--   IconSource to the icon set, all variants of the icon will be
--   created from pixbuf, 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 IconSource, which they use as base
--   icons for rendering icons in different states and sizes. Icons are
--   scaled, made to look insensitive, etc. in iconSetRenderIcon,
--   but IconSet needs base images to work with. The base images and
--   when to use them are described by a IconSource.
--   
--   This function copies source, 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. IconSet 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.
--   
--   iconSetNewFromPixbuf creates a new icon set with a default icon
--   source based on the given pixbuf.
iconSetAddSource :: (HasCallStack, MonadIO m) => IconSet -> IconSource -> m ()

-- | If the text direction is wildcarded, this source can be used as the
--   base image for an icon in any TextDirection. If the text
--   direction is not wildcarded, then the text direction the icon source
--   applies to should be set with iconSourceSetDirection, and the
--   icon source will only be used with that text direction.
--   
--   IconSet prefers non-wildcarded sources (exact matches) over
--   wildcarded sources, and will use an exact match when possible.
iconSourceSetDirectionWildcarded :: (HasCallStack, MonadIO m) => IconSource -> Bool -> 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 iconSourceSetSize
--   and the icon source will only be used with that specific size.
--   
--   IconSet prefers non-wildcarded sources (exact matches) over
--   wildcarded sources, and will use an exact match when possible.
--   
--   IconSet 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 ()

-- | If the widget state is wildcarded, this source can be used as the base
--   image for an icon in any StateType. If the widget state is not
--   wildcarded, then the state the source applies to should be set with
--   iconSourceSetState and the icon source will only be used with
--   that specific state.
--   
--   IconSet prefers non-wildcarded sources (exact matches) over
--   wildcarded sources, and will use an exact match when possible.
--   
--   IconSet 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 ()

-- | 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

-- | 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
--   iconSourceSetDirectionWildcarded to un-wildcard it in addition
--   to calling this function.
iconSourceSetDirection :: (HasCallStack, MonadIO m) => IconSource -> TextDirection -> 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
--   iconSourceSetSizeWildcarded to un-wildcard it in addition to
--   calling this function.
iconSourceSetSize :: (HasCallStack, MonadIO m) => IconSource -> Int32 -> 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
--   iconSourceSetStateWildcarded to un-wildcard it in addition to
--   calling this function.
iconSourceSetState :: (HasCallStack, MonadIO m) => IconSource -> StateType -> m ()

-- | 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 PaperSize
PaperSize :: ManagedPtr PaperSize -> PaperSize

-- | Returns the name of the default paper size, which depends on the
--   current locale.
--   
--   Since: 2.10
paperSizeGetDefault :: (HasCallStack, MonadIO m) => m Text

-- | Serialize a paper size to an a{sv} variant.
--   
--   Since: 3.22
paperSizeToGvariant :: (HasCallStack, MonadIO m) => PaperSize -> m GVariant

-- | Free the given PaperSize object.
--   
--   Since: 2.10
paperSizeFree :: (HasCallStack, MonadIO m) => PaperSize -> m ()

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

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

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

-- | This function saves the information from setup to
--   fileName.
--   
--   Since: 2.12
pageSetupToFile :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> [Char] -> m ()

-- | Serialize page setup to an a{sv} variant.
--   
--   Since: 3.22
pageSetupToGvariant :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> m GVariant

-- | Returns the paper height in units of unit.
--   
--   Note that this function takes orientation, but not margins into
--   consideration. See pageSetupGetPageHeight.
--   
--   Since: 2.10
pageSetupGetPaperHeight :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Returns the paper width in units of unit.
--   
--   Note that this function takes orientation, but not margins into
--   consideration. See pageSetupGetPageWidth.
--   
--   Since: 2.10
pageSetupGetPaperWidth :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Returns the page height in units of unit.
--   
--   Note that this function takes orientation and margins into
--   consideration. See pageSetupGetPaperHeight.
--   
--   Since: 2.10
pageSetupGetPageHeight :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Returns the page width in units of unit.
--   
--   Note that this function takes orientation and margins into
--   consideration. See pageSetupGetPaperWidth.
--   
--   Since: 2.10
pageSetupGetPageWidth :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Sets the paper size of the PageSetup and modifies the margins
--   according to the new paper size.
--   
--   Since: 2.10
pageSetupSetPaperSizeAndDefaultMargins :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> PaperSize -> m ()

-- | See also printSettingsSetOrientation.
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

-- | 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.
--   
--   Since: 2.10
printContextSetCairoContext :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> Context -> Double -> Double -> m ()

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

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

-- | No description available in the introspection data.
settingsInstallPropertyParser :: (HasCallStack, MonadIO m) => GParamSpec -> RcPropertyParser -> m ()

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

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

-- | Gets the URI of the resource.
--   
--   Since: 2.10
recentInfoGetUri :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Adds a new resource, pointed by uri, 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 recentManagerAddFull.
--   
--   See recentManagerAddFull if you want to explicitly define the
--   metadata for the resource pointed by uri.
--   
--   Since: 2.10
recentManagerAddItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> m Bool

-- | Gets a unique instance of RecentManager, that you can share in
--   your application without caring about memory management.
--   
--   Since: 2.10
recentManagerGetDefault :: (HasCallStack, MonadIO m) => m RecentManager

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

-- | Adds a new resource, pointed by uri, into the recently
--   used resources list, using the metadata specified inside the
--   RecentData-struct passed in recentData.
--   
--   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 RecentData-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 RecentData-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.
--   
--   Since: 2.10
recentManagerAddFull :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> RecentData -> m Bool

-- | Decreases the reference count of info by one. If the
--   reference count reaches zero, info is deallocated, and
--   the memory freed.
--   
--   Since: 2.10
recentInfoUnref :: (HasCallStack, MonadIO m) => RecentInfo -> m ()

-- | Frees a Requisition.
requisitionFree :: (HasCallStack, MonadIO m) => Requisition -> m ()

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

-- | Makes a new TargetEntry.
targetEntryNew :: (HasCallStack, MonadIO m) => Text -> Word32 -> Word32 -> m TargetEntry

-- | Makes a copy of a TargetEntry and its data.
targetEntryCopy :: (HasCallStack, MonadIO m) => TargetEntry -> m TargetEntry

-- | Frees a TargetEntry returned from targetEntryNew or
--   targetEntryCopy.
targetEntryFree :: (HasCallStack, MonadIO m) => TargetEntry -> m ()

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

-- | Decrements the reference count on values, freeing the
--   structure if the reference count reaches 0.
textAttributesUnref :: (HasCallStack, MonadIO m) => TextAttributes -> m ()

-- | Frees an iterator that has been allocated by treeIterCopy.
--   
--   This function is mainly used for language bindings.
treeIterFree :: (HasCallStack, MonadIO m) => TreeIter -> m ()

-- | Creates a dynamically allocated tree iterator as a copy of
--   iter.
--   
--   This function is not intended for use in applications, because you can
--   just copy the structs by value (GtkTreeIter new_iter =
--   iter;). You must free this iter with treeIterFree.
treeIterCopy :: (HasCallStack, MonadIO m) => TreeIter -> m TreeIter

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

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

-- | Sets the page forwarding function to be pageFunc.
--   
--   This function will be used to determine what will be the next page
--   when the user presses the forward button. Setting
--   pageFunc to Nothing will make the assistant to
--   use the default forward function, which just goes to the next visible
--   page.
--   
--   Since: 2.10
assistantSetForwardPageFunc :: (HasCallStack, MonadIO m, IsAssistant a) => a -> Maybe AssistantPageFunc -> m ()

-- | This method is a simpler variation of
--   builderConnectSignalsFull. It uses symbols explicitly added to
--   builder with prior calls to
--   builderAddCallbackSymbol. In the case that symbols are not
--   explicitly added; it uses Module’s introspective features (by
--   opening the module Nothing) 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 builderAddCallbackSymbol is called for all
--   signal callbacks which are referenced by the loaded XML, this function
--   will require that Module be supported on the platform.
--   
--   If you rely on Module 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 G_MODULE_EXPORT, 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.
--   
--   Since: 2.12
builderConnectSignals :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Ptr () -> m ()

-- | This function can be thought of the interpreted language binding
--   version of builderConnectSignals, except that it does not
--   require GModule to function correctly.
--   
--   Since: 2.12
builderConnectSignalsFull :: (HasCallStack, MonadIO m, IsBuilder a) => a -> BuilderConnectFunc -> m ()

-- | Invokes callback on each non-internal child of
--   container. See containerForall 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
--   add() calls.
--   
--   It is permissible to remove the child from the
--   callback handler.
--   
--   Most applications should use containerForeach, rather than
--   containerForall.
containerForeach :: (HasCallStack, MonadIO m, IsContainer a) => a -> Callback -> m ()

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

-- | Calls callback for every CellRenderer in
--   area with the allocated rectangle inside
--   cellArea.
--   
--   Since: 3.0
cellAreaForeachAlloc :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Rectangle -> Rectangle -> CellAllocCallback -> m ()

-- | Calls callback for every CellRenderer in
--   area.
--   
--   Since: 3.0
cellAreaForeach :: (HasCallStack, MonadIO m, IsCellArea a) => a -> CellCallback -> m ()

-- | Stores new data into a SelectionData 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
--   selectionData->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 Pixbuf, and
--   callback will be called.
--   
--   The pixbuf parameter to callback will
--   contain the resulting Pixbuf if the request succeeded, or
--   Nothing 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.
--   
--   Since: 2.6
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, callback will be called.
--   
--   The text parameter to callback will
--   contain the resulting rich text if the request succeeded, or
--   Nothing if it failed. The length parameter will
--   contain text’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.
--   
--   Since: 2.10
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, callback will be
--   called.
--   
--   The targets parameter to callback will
--   contain the resulting targets if the request succeeded, or
--   Nothing if it failed.
--   
--   Since: 2.4
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
--   callback will be called.
--   
--   The text parameter to callback will
--   contain the resulting text if the request succeeded, or Nothing
--   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 callback will be called.
--   
--   The uris parameter to callback will
--   contain the resulting array of URIs if the request succeeded, or
--   Nothing 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.
--   
--   Since: 2.14
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 needed 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.
--   
--   Since: 2.4
fileFilterAddCustom :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> [FileFilterFlags] -> FileFilterFunc -> m ()

-- | Binds model to box.
--   
--   If box was already bound to a model, that previous
--   binding is destroyed.
--   
--   The contents of box are cleared and then filled with
--   widgets that represent items from model.
--   box is updated whenever model changes.
--   If model is Nothing, box is
--   left empty.
--   
--   It is undefined to add or remove widgets directly (for example, with
--   flowBoxInsert or containerAdd) while box
--   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.
--   
--   Since: 3.18
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.
--   
--   Since: 3.12
flowBoxSelectedForeach :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> FlowBoxForeachFunc -> m ()

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

-- | Adds a filter function that decides which fonts to display in the font
--   chooser.
--   
--   Since: 3.2
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.
--   
--   Since: 2.6
iconViewSelectedForeach :: (HasCallStack, MonadIO m, IsIconView a) => a -> IconViewForeachFunc -> m ()

-- | Binds model to box.
--   
--   If box was already bound to a model, that previous
--   binding is destroyed.
--   
--   The contents of box are cleared and then filled with
--   widgets that represent items from model.
--   box is updated whenever model changes.
--   If model is Nothing, box is
--   left empty.
--   
--   It is undefined to add or remove widgets directly (for example, with
--   listBoxInsert or containerAdd) while box
--   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.
--   
--   Since: 3.16
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.
--   
--   Since: 3.14
listBoxSelectedForeach :: (HasCallStack, MonadIO m, IsListBox a) => a -> ListBoxForeachFunc -> m ()

-- | Sets the current header of the row. This is only
--   allowed to be called from a ListBoxUpdateHeaderFunc. It will
--   replace any existing header in the row, and be shown in front of the
--   row in the listbox.
--   
--   Since: 3.10
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 menuDetach 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 Nothing for the
--   parentMenuShell, parentMenuItem,
--   func and data parameters. The default
--   menu positioning function will position the menu at the current mouse
--   cursor position.
--   
--   The button 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, button should be 0.
--   
--   The activateTime 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, getCurrentEventTime
--   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
--   monitorGetGeometry.
--   
--   This function should be called from a MenuPositionFunc 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 MenuPositionFunc, since, for very long menus, these
--   coordinates may extend beyond the monitor boundaries or even the
--   screen boundaries.
--   
--   Since: 2.4
menuSetMonitor :: (HasCallStack, MonadIO m, IsMenu a) => a -> Int32 -> m ()

-- | Runs a page setup dialog, letting the user modify the values from
--   pageSetup.
--   
--   In contrast to printRunPageSetupDialog, this function returns
--   after showing the page setup dialog on platforms that support this,
--   and calls doneCb from a signal handler for the
--   response signal of the dialog.
--   
--   Since: 2.10
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 needed 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.
--   
--   Since: 2.10
recentFilterAddCustom :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> [RecentFilterFlags] -> RecentFilterFunc -> m ()

-- | This function serializes the portion of text between
--   start and end in the rich text format
--   represented by format.
--   
--   formats to be used must be registered using
--   textBufferRegisterSerializeFormat or
--   textBufferRegisterSerializeTagset beforehand.
--   
--   Since: 2.10
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 Label), then you will
--   have to call widgetQueueResize or widgetQueueDrawArea
--   yourself.
--   
--   frameClockGetFrameTime should generally be used for timing
--   continuous animations and
--   frameTimingsGetPredictedPresentationTime if you are trying to
--   display isolated frames at particular times.
--   
--   This is a more convenient alternative to connecting directly to the
--   FrameClock::update signal of FrameClock, since you don't
--   have to worry about when a FrameClock is assigned to a widget.
--   
--   Since: 3.8
widgetAddTickCallback :: (HasCallStack, MonadIO m, IsWidget a) => a -> TickCallback -> m Word32

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

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

-- | Sets the TreeCellDataFunc 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 treeColumn's
--   cell renderer as appropriate. func may be
--   Nothing 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 func returns True, then the tree ceases to
--   be walked, and treeModelForeach 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,
--   treeSelectionGetSelectedRows 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 True if the state of the node may
--   be toggled, and False if the state of the node should be left
--   unchanged.
treeSelectionSetSelectFunction :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> Maybe TreeSelectionFunc -> m ()

-- | Calls func on all expanded rows.
treeViewMapExpandedRows :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreeViewMappingFunc -> m ()

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

-- | Loops over the entries in the accelerator map whose accel path doesn’t
--   match any of the filters added with accelMapAddFilter, and
--   execute foreachFunc on each. The signature of
--   foreachFunc is that of AccelMapForeach, the
--   changed 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
--   foreachFunc on each. The signature of
--   foreachFunc is that of AccelMapForeach, the
--   changed 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 ()

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

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

-- | Sets the CellLayoutDataFunc to use for
--   cellLayout.
--   
--   This function is used instead of the standard attributes mapping for
--   setting the column value, and should set the value of
--   cellLayout’s cell renderer(s) as appropriate.
--   
--   func may be Nothing to remove a previously set
--   function.
--   
--   Since: 2.4
cellLayoutSetCellDataFunc :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Maybe CellLayoutDataFunc -> m ()

-- | 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

-- | Sets the match function for completion to be
--   func. The match function is used to determine if a row
--   should or should not be in the completion list.
--   
--   Since: 2.4
entryCompletionSetMatchFunc :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> EntryCompletionMatchFunc -> m ()

-- | 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 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

-- | Calls func on each tag in table, with
--   user data data. 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
--   frameClockGetFrameTime, 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 frameClockGetFrameTime, and then
--   update the animation by calling frameClockGetFrameTime again
--   during each repaint.
--   
--   frameClockRequestPhase will result in a new frame on the clock,
--   but won’t necessarily repaint any widgets. To repaint a widget, you
--   have to use widgetQueueDraw which invalidates the widget (thus
--   scheduling it to receive a draw on the next frame).
--   widgetQueueDraw 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.
--   
--   Since: 3.8
widgetGetFrameClock :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe FrameClock)

-- | 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

-- | Sets the comparison function used when sorting to be
--   sortFunc. If the current sort column id of
--   sortable is the same as sortColumnId,
--   then the model will sort using this function.
treeSortableSetSortFunc :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> Int32 -> TreeIterCompareFunc -> m ()

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

-- | Sets the visible function used when filtering the
--   filter to be func. The function should
--   return True if the given row should be visible and False
--   otherwise.
--   
--   If the condition calculated by the function changes over time (e.g.
--   because it depends on some global parameters), you must call
--   treeModelFilterRefilter to keep the visibility information of
--   the model up-to-date.
--   
--   Note that func 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.
--   
--   
C code
--   
--   
--   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, &str, -1);
--     if (str && strcmp (str, "HI") == 0)
--       visible = TRUE;
--     g_free (str);
--   
--     return visible;
--   }
--   
--   
--   Note that treeModelFilterSetVisibleFunc or
--   treeModelFilterSetVisibleColumn can only be called once for a
--   given filter model.
--   
--   Since: 2.4
treeModelFilterSetVisibleFunc :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreeModelFilterVisibleFunc -> m ()

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

-- | Sets column 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 column 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 strcmp() returning 0 for
--   equality TreeViewSearchEqualFunc returns False on
--   matches.
treeViewSetSearchEqualFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreeViewSearchEqualFunc -> m ()

-- | 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

-- | Appends a widget type to the widget hierarchy represented by
--   path.
--   
--   Since: 3.0
widgetPathAppendType :: (HasCallStack, MonadIO m) => WidgetPath -> GType -> m Int32

-- | Updates the style context of widget and all
--   descendants by updating its widget path. GtkContainers
--   may want to use this on a child when reordering it in a way that a
--   different style might apply to it. See also
--   containerGetPathForChild.
--   
--   Since: 3.0
widgetResetStyle :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Adds a style class to context, so posterior calls to
--   gtk_style_context_get() or any of the gtk_render_*()
--   functions will make use of this new class for styling.
--   
--   In the CSS file format, a Entry defining a “search” class,
--   would be matched by:
--   
--   
--    <!-- language="CSS" -->
--   entry.search { ... }
--   
--   
--   While any widget defining a “search” class would be matched by:
--   
--   
--    <!-- language="CSS" -->
--   .search { ... }
--   
--   
--   Since: 3.0
styleContextAddClass :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m ()

-- | Adds a region to context, so posterior calls to
--   gtk_style_context_get() or any of the gtk_render_*()
--   functions will make use of this new region for styling.
--   
--   In the CSS file format, a TreeView defining a “row” region,
--   would be matched by:
--   
--   
--    <!-- language="CSS" -->
--   treeview row { ... }
--   
--   
--   Pseudo-classes are used for matching flags, so the two
--   following rules:
--   
--   
--    <!-- language="CSS" -->
--   treeview row:nth-child(even) { ... }
--   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.
--   
--   Since: 3.0
styleContextAddRegion :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> [RegionFlags] -> m ()

-- | Returns the list of siblings for the element at pos.
--   If the element was not added with siblings, Nothing is
--   returned.
widgetPathIterGetSiblings :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m WidgetPath

-- | Returns True if the widget at position pos has
--   the class name defined, False otherwise.
--   
--   Since: 3.0
widgetPathIterHasClass :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m Bool

-- | Returns True if the widget at position pos has
--   the name name, False otherwise.
--   
--   Since: 3.0
widgetPathIterHasName :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m Bool

-- | Returns True if the widget at position pos has
--   the class name defined, False otherwise.
--   
--   Since: 3.0
widgetPathIterHasRegion :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m (Bool, [RegionFlags])

-- | Adds the callbackSymbol to the scope of
--   builder under the given callbackName.
--   
--   Using this function overrides the behavior of
--   builderConnectSignals 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.
--   
--   Since: 3.10
builderAddCallbackSymbol :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> Callback -> m ()

-- | This should be called at class initialization time to specify the
--   GtkBuilder XML to be used to extend a widget.
--   
--   For convenience, widgetClassSetTemplateFromResource is also
--   provided.
--   
--   Note that any class that installs templates must call
--   widgetInitTemplate in the widget’s instance initializer.
--   
--   Since: 3.10
widgetClassSetTemplate :: (HasCallStack, MonadIO m) => WidgetClass -> Bytes -> m ()

-- | Fetch an object build from the template XML for
--   widgetType in this widget instance.
--   
--   This will only report children which were previously declared with
--   widgetClassBindTemplateChildFull or one of its variants.
--   
--   This function is only meant to be called for code which is private to
--   the widgetType 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

-- | Memory-managed wrapper type.
newtype WidgetClass
WidgetClass :: ManagedPtr WidgetClass -> WidgetClass

-- | 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.
--   
--   Since: 3.20
widgetClassSetCssName :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> m ()

-- | Sets the type to be used for creating accessibles for widgets of
--   widgetClass. The given type 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.
--   
--   Since: 3.2
widgetClassSetAccessibleType :: (HasCallStack, MonadIO m) => WidgetClass -> GType -> m ()

-- | This is the signature of a function used to connect signals. It is
--   used by the builderConnectSignals and
--   builderConnectSignalsFull 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.
--   
--   Since: 2.12
type BuilderConnectFunc = Builder -> Object -> Text -> Text -> Maybe Object -> [ConnectFlags] -> IO ()

-- | A convenience function to call widgetClassSetTemplate.
--   
--   Note that any class that installs templates must call
--   widgetInitTemplate in the widget’s instance initializer.
--   
--   Since: 3.10
widgetClassSetTemplateFromResource :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> m ()

-- | 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 widgetClassSetTemplate
--   
--   It is important to call this function in the instance initializer of a
--   Widget subclass and not in
--   Object.constructed() or
--   Object.constructor() 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 g_object_new() on
--   a widget with composite templates, it’s important to build the
--   composite widgets before the construct properties are set. Properties
--   passed to g_object_new() should take precedence over
--   properties set in the private template XML.
--   
--   Since: 3.10
widgetInitTemplate :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Creates a row reference based on path.
--   
--   This reference will keep pointing to the node pointed to by
--   path, so long as it exists. Any changes that occur on
--   model are propagated, and the path is updated
--   appropriately. If path isn’t a valid path in
--   model, then Nothing is returned.
treeRowReferenceNew :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> m TreeRowReference

-- | Lets a set of row reference created by treeRowReferenceNewProxy
--   know that the model emitted the TreeModel::rowInserted signal.
treeRowReferenceInserted :: (HasCallStack, MonadIO m, IsObject a) => a -> TreePath -> m ()

-- | Lets a set of row reference created by treeRowReferenceNewProxy
--   know that the model emitted the TreeModel::rowDeleted signal.
treeRowReferenceDeleted :: (HasCallStack, MonadIO m, IsObject a) => a -> TreePath -> m ()

-- | Memory-managed wrapper type.
newtype TreeRowReference
TreeRowReference :: ManagedPtr TreeRowReference -> TreeRowReference

-- | You do not need to use this function.
--   
--   Creates a row reference based on path.
--   
--   This reference will keep pointing to the node pointed to by
--   path, so long as it exists. If path
--   isn’t a valid path in model, then Nothing is
--   returned. However, unlike references created with
--   treeRowReferenceNew, it does not listen to the model for
--   changes. The creator of the row reference must do this explicitly
--   using treeRowReferenceInserted, treeRowReferenceDeleted,
--   gtk_tree_row_reference_reordered().
--   
--   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
--   TreeView already use this mechanism internally, using them as
--   the proxy object will produce unpredictable results. Further more,
--   passing the same object as model and
--   proxy 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

-- | Moves backward by one character offset. Returns True if
--   movement was possible; if iter was the first in the
--   buffer (character offset 0), textIterBackwardChar returns
--   False for convenience when writing loops.
textIterBackwardChar :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves iter 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 LogAttr-struct and
--   break function.
textIterForwardCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Advances iter, calling pred on each
--   character. If pred returns True, returns
--   True and stops scanning. If pred never returns
--   True, iter is set to limit if
--   limit is non-Nothing, otherwise to the end
--   iterator.
textIterForwardFindChar :: (HasCallStack, MonadIO m) => TextIter -> TextCharPredicate -> Maybe TextIter -> m Bool

-- | Searches forward for str. Any match is returned by
--   setting matchStart to the first character of the match
--   and matchEnd to the first character after the match.
--   The search will not continue past limit. Note that a
--   search is a linear or O(n) operation, so you may wish to use
--   limit to avoid locking up your UI on large buffers.
--   
--   matchStart will never be set to a TextIter
--   located before iter, even if there is a possible
--   matchEnd after or at iter.
textIterForwardSearch :: (HasCallStack, MonadIO m) => TextIter -> Text -> [TextSearchFlags] -> Maybe TextIter -> m (Bool, TextIter, TextIter)

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

-- | Moves backward to the previous sentence start; if iter
--   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

-- | Like textIterForwardCursorPosition, but moves backward.
textIterBackwardCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves backward to the previous visible word start. (If
--   iter 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).
--   
--   Since: 2.4
textIterBackwardVisibleWordStart :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves backward to the previous word start. (If iter 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

-- | Returns True if tag is toggled on at exactly
--   this point. If tag is Nothing, returns
--   True if any tag is toggled on at this point.
--   
--   Note that if textIterBeginsTag returns True, it means
--   that iter is at the beginning of the tagged range, and
--   that the character at iter is inside the tagged range.
--   In other words, unlike textIterEndsTag, if
--   textIterBeginsTag returns True, textIterHasTag
--   will also return True for the same parameters.
textIterBeginsTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

-- | Returns True if tag is toggled off at exactly
--   this point. If tag is Nothing, returns
--   True if any tag is toggled off at this point.
--   
--   Note that if textIterEndsTag returns True, it means that
--   iter is at the end of the tagged range, but that the
--   character at iter is outside the tagged range. In
--   other words, unlike textIterStartsTag, if
--   textIterEndsTag returns True, textIterHasTag will
--   return False for the same parameters.
textIterEndsTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

-- | Returns True if iter points to a character that
--   is part of a range tagged with tag. See also
--   textIterStartsTag and textIterEndsTag.
textIterHasTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> a -> m Bool

-- | Like textBufferInsert, but the insertion will not occur if
--   iter 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).
--   
--   defaultEditable indicates the editability of text that
--   doesn't have a tag affecting editability applied to it. Typically the
--   result of textViewGetEditable is appropriate here.
textBufferInsertInteractive :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> Text -> Int32 -> Bool -> m Bool

-- | Computes the effect of any tags applied to this spot in the text. The
--   values 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 textViewGetDefaultAttributes.
--   
--   textIterGetAttributes will modify values,
--   applying the effects of any tags present at iter. If
--   any tags affected values, the function returns
--   True.
textIterGetAttributes :: (HasCallStack, MonadIO m) => TextIter -> m (Bool, TextAttributes)

-- | Considering the default editability of the buffer, and tags that
--   affect editability, determines whether text inserted at
--   iter would be editable. If text inserted at
--   iter would be editable then the user should be allowed
--   to insert text at iter.
--   textBufferInsertInteractive uses this function to decide
--   whether insertions are allowed at a given position.
textIterCanInsert :: (HasCallStack, MonadIO m) => TextIter -> Bool -> m Bool

-- | Returns True if tag is toggled on at exactly
--   this point. If tag is Nothing, returns
--   True if any tag is toggled on at this point.
--   
--   Note that if textIterStartsTag returns True, it means
--   that iter is at the beginning of the tagged range, and
--   that the character at iter is inside the tagged range.
--   In other words, unlike textIterEndsTag, if
--   textIterStartsTag returns True, textIterHasTag
--   will also return True for the same parameters.
--   
--   Since: 3.20
textIterStartsTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

-- | A qsort()-style function that returns negative if
--   lhs is less than rhs, positive if
--   lhs is greater than rhs, 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

-- | Moves iter forward by one character offset. Note that
--   images embedded in the buffer occupy 1 character slot, so
--   textIterForwardChar may actually move onto an image instead of
--   a character, if you have images in your buffer. If
--   iter is the end iterator or one character before it,
--   iter will now point at the end iterator, and
--   textIterForwardChar returns False for convenience when
--   writing loops.
textIterForwardChar :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves forward to the next sentence end. (If iter 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

-- | 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 textIterGetChar returns 0.
textIterGetChar :: (HasCallStack, MonadIO m) => TextIter -> m Char

-- | Moves forward to the next visible word end. (If iter
--   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).
--   
--   Since: 2.4
textIterForwardVisibleWordEnd :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves forward to the next word end. (If iter 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

-- | 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 textIterGetAttributes 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 textAttributesUnref.
textViewGetDefaultAttributes :: (HasCallStack, MonadIO m, IsTextView a) => a -> m TextAttributes

-- | Returns the Language 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 languageGetDefault. See that
--   function for details.
getDefaultLanguage :: (HasCallStack, MonadIO m) => m Language

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

-- | Initializes iter to a position
--   charOffset chars from the start of the entire buffer.
--   If charOffset is -1 or greater than the number of
--   characters in the buffer, iter 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

-- | 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 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
--   textIterGetSlice.
textIterGetText :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Text

-- | Determines whether iter 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

-- | Returns True if iter is the end iterator, i.e.
--   one past the last dereferenceable iterator in the buffer.
--   textIterIsEnd is the most efficient way to check whether an
--   iterator is the end iterator.
textIterIsEnd :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Checks whether iter falls in the range
--   [start, end). start
--   and end must be in ascending order.
textIterInRange :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> TextIter -> m Bool

-- | Moves iter 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, iter
--   moves to the start of the next line. See textIterSetLineIndex
--   if you have a byte index rather than a character offset.
textIterSetLineOffset :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Same as textIterSetLineOffset, 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 ()

-- | 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

-- | 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 ()

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

-- | This function registers a rich text serialization
--   function along with its mimeType with
--   the passed buffer.
--   
--   Since: 2.10
textBufferRegisterSerializeFormat :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> TextBufferSerializeFunc -> m Atom

-- | This function registers a rich text deserialization
--   function along with its mimeType with
--   the passed buffer.
--   
--   Since: 2.10
textBufferRegisterDeserializeFormat :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> FunPtr C_TextBufferDeserializeFunc -> m Atom

-- | Looks up and resolves a color name in the context
--   color map.
styleContextLookupColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m (Bool, RGBA)

-- | Returns the symbolic color that is mapped to name.
--   
--   Since: 3.0
stylePropertiesLookupColor :: (HasCallStack, MonadIO m, IsStyleProperties a) => a -> Text -> m SymbolicColor

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

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

-- | Makes a copy of a SelectionData-struct and its data.
selectionDataCopy :: (HasCallStack, MonadIO m) => SelectionData -> m SelectionData

-- | A convenience function that uses the theme engine and style settings
--   for widget to look up stockId and
--   render it to a pixbuf. stockId should be a stock icon
--   ID such as STOCK_OPEN or STOCK_OK. size
--   should be a size such as GTK_ICON_SIZE_MENU.
--   
--   The pixels in the returned Pixbuf are shared with the rest of
--   the application and should not be modified. The pixbuf should be freed
--   after use with objectUnref.
--   
--   Since: 3.0
widgetRenderIconPixbuf :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> Int32 -> m (Maybe Pixbuf)

-- | Renders an icon using styleRenderIcon. In most cases,
--   widgetRenderIcon is better, since it automatically provides
--   most of the arguments from the current widget settings. This function
--   never returns Nothing; 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 the icon specified by source at the given
--   size 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
--   widget to look up stockId and render
--   it to a pixbuf. stockId should be a stock icon ID such
--   as STOCK_OPEN or STOCK_OK. size should
--   be a size such as GTK_ICON_SIZE_MENU.
--   detail 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 Pixbuf are shared with the rest of
--   the application and should not be modified. The pixbuf should be freed
--   after use with objectUnref.
widgetRenderIcon :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> Int32 -> Maybe Text -> m (Maybe Pixbuf)

-- | Renders the icon specified by source at the given
--   size, returning the result in a pixbuf.
--   
--   Since: 3.0
renderIconPixbuf :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> IconSource -> Int32 -> m Pixbuf

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

-- | Adds a stop color to gradient.
--   
--   Since: 3.0
gradientAddColorStop :: (HasCallStack, MonadIO m) => Gradient -> Double -> SymbolicColor -> m ()

-- | Memory-managed wrapper type.
newtype Gradient
Gradient :: ManagedPtr Gradient -> Gradient

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

-- | Modifies a subclass of ContainerClass 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.
--   
--   containerClassHandleBorderWidth 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 ()

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

-- | Makes widget 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 widget 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 ()

-- | 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 g_list_foreach (result,
--   (GFunc)g_object_ref, NULL) first, and then unref all the widgets
--   afterwards.
windowListToplevels :: (HasCallStack, MonadIO m) => m [Widget]

-- | Destroys a widget.
--   
--   When a widget is destroyed all references it holds on other objects
--   will be released:
--   
--   
--   
- if the widget is inside a container, it will be removed from its
--   parent
--   
- if the widget is a container, all its children will be destroyed,
--   recursively
--   
- if the widget is a top level, it will be removed from the list of
--   top level widgets that GTK+ maintains internally
--   
--   
--   It's expected that all references held on the widget will also be
--   released; you should connect to the Widget::destroy signal if
--   you hold a reference to widget and you wish to remove
--   it when this function is called. It is not necessary to do so if you
--   are implementing a Container, as you'll be able to use the
--   ContainerClass.remove() virtual function for
--   that.
--   
--   It's important to notice that widgetDestroy will only cause the
--   widget to be finalized if no additional references,
--   acquired using objectRef, are held on it. In case additional
--   references are in place, the widget will be in an
--   "inert" state after calling this function; widget 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: containerRemove
widgetDestroy :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Specifies whether widget will be treated as the
--   default widget within its toplevel when it has the focus, even if
--   another widget is the default.
--   
--   See widgetGrabDefault for details about the meaning of
--   “default”.
--   
--   Since: 2.18
widgetSetReceivesDefault :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Finds the first accelerator in any AccelGroup attached to
--   object that matches accelKey and
--   accelMods, and activates that accelerator.
accelGroupsActivate :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> [ModifierType] -> m Bool

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

-- | Marks window as attached to
--   attachWidget. 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
--   window as if it was a children of
--   attachWidget.
--   
--   Examples of places where specifying this relation is useful are for
--   instance a Menu created by a ComboBox, a completion
--   popup window created by Entry or a typeahead search entry
--   created by TreeView.
--   
--   Note that this function should not be confused with
--   windowSetTransientFor, which specifies a window manager
--   relation between two toplevels instead.
--   
--   Passing Nothing for attachWidget detaches the
--   window.
--   
--   Since: 3.4
windowSetAttachedTo :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> 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 Window. When setting (rather than
--   unsetting) the default widget it’s generally easier to call
--   widgetGrabDefault on the widget. Before making a widget the
--   default widget, you must call widgetSetCanDefault on the widget
--   you’d like to make the default.
windowSetDefault :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> 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 False 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 widgetShow.
--   
--   On Windows, this function always works, since there’s no window
--   manager policy involved.
--   
--   Since: 2.10
windowSetDeletable :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Window gravity defines the meaning of coordinates passed to
--   windowMove. See windowMove and Gravity for more
--   details.
--   
--   The default window gravity is GDK_GRAVITY_NORTH_WEST
--   which will typically “do what you mean.”
windowSetGravity :: (HasCallStack, MonadIO m, IsWindow a) => a -> Gravity -> m ()

-- | Sets up the icon representing a Window. 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
--   windowSetIconList. Then the best size will be used.
--   
--   This function is equivalent to calling windowSetIconList with a
--   1-element list.
--   
--   See also windowSetDefaultIconList 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 mnemonic modifier for this window.
windowSetMnemonicModifier :: (HasCallStack, MonadIO m, IsWindow a) => a -> [ModifierType] -> 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 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 (windowSetGeometryHints can be used to set these
--   explicitly), the default size will be clamped to the nearest permitted
--   size.
--   
--   Unlike widgetSetSizeRequest, 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 windowSetGeometryHints.
--   
--   For some uses, windowResize is a more appropriate function.
--   windowResize changes the current size of the window, rather
--   than the size to be used on initial display. windowResize
--   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 width and height 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
--   windowGetSize. 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 a position constraint for this window. If the old or new
--   constraint is WindowPositionCenterAlways, this will also cause
--   the window to be repositioned to satisfy the new constraint.
windowSetPosition :: (HasCallStack, MonadIO m, IsWindow a) => a -> WindowPosition -> m ()

-- | Sets a custom titlebar for window.
--   
--   A typical widget used here is HeaderBar, 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 widgetShow.
--   
--   Since: 3.10
windowSetTitlebar :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> m ()

-- | Returns whether the window is part of the current active toplevel.
--   (That is, the toplevel window receiving keystrokes.) The return value
--   is True if the window is active toplevel itself, but also if it
--   is, say, a Plug 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
--   windowHasToplevelFocus
--   
--   Since: 2.4
windowIsActive :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

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

-- | Returns whether the input focus is within this GtkWindow. For real
--   toplevel windows, this is identical to windowIsActive, but for
--   embedded windows, like Plug, the results will differ.
--   
--   Since: 2.4
windowHasToplevelFocus :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Parses a standard X Window System geometry string - see the manual
--   page for X (type “man X”) for details on this.
--   windowParseGeometry 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, windowParseGeometry returns True and calls
--   windowSetDefaultSize and/or windowMove to resize/move
--   the window.
--   
--   If windowParseGeometry returns True, it will also set
--   the GDK_HINT_USER_POS and/or
--   GDK_HINT_USER_SIZE 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 windowParseGeometry to work as expected, it has
--   to be called when the window has its “final” size, i.e. after calling
--   widgetShowAll on the contents and windowSetGeometryHints
--   on the window.
--   
--   
C code
--   
--   
--   #include <gtk/gtk.h>
--   
--   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 (&argc, &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,
--   				    &size_hints,
--   				    GDK_HINT_MIN_SIZE |
--   				    GDK_HINT_BASE_SIZE |
--   				    GDK_HINT_RESIZE_INC);
--   
--     if (argc > 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;
--   }
--   
windowParseGeometry :: (HasCallStack, MonadIO m, IsWindow a) => a -> Text -> 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 widgetShowAll 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 ()

-- | 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 ()

-- | Associate accelGroup with window, such
--   that calling accelGroupsActivate on window will
--   activate accelerators in accelGroup.
windowAddAccelGroup :: (HasCallStack, MonadIO m, IsWindow a, IsAccelGroup b) => a -> b -> m ()

-- | Sets the minimum size of a widget; that is, the widget’s size request
--   will be at least width by height. You
--   can use this function to force a widget to be larger than it normally
--   would be.
--   
--   In most cases, windowSetDefaultSize 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, windowSetGeometryHints 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
--   Widget 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 Widget.
widgetSetSizeRequest :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> Int32 -> m ()

-- | Remove a window from application.
--   
--   If window belongs to application then
--   this call is equivalent to setting the Window:application
--   property of window to Nothing.
--   
--   The application may stop running as a result of a call to this
--   function.
--   
--   Since: 3.0
applicationRemoveWindow :: (HasCallStack, MonadIO m, IsApplication a, IsWindow b) => a -> b -> m ()

-- | Adds a window to application.
--   
--   This call can only happen after the application has
--   started; typically, you should add new application windows in response
--   to the emission of the Application::activate signal.
--   
--   This call is equivalent to setting the Window:application
--   property of window to application.
--   
--   Normally, the connection between the application and the window will
--   remain until the window is destroyed, but you can explicitly remove it
--   with applicationRemoveWindow.
--   
--   GTK+ will keep the application running as long as it
--   has any windows.
--   
--   Since: 3.0
applicationAddWindow :: (HasCallStack, MonadIO m, IsApplication a, IsWindow b) => a -> b -> m ()

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

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

-- | Causes widget to become the default widget.
--   widget must be able to be a default widget; typically
--   you would ensure this yourself by calling widgetSetCanDefault
--   with a True value. The default widget is activated when the
--   user presses Enter in a window. Default widgets must be activatable,
--   that is, widgetActivate should affect them. Note that
--   Entry widgets require the “activates-default” property set to
--   True before they activate the default widget when Enter is
--   pressed and the Entry is focused.
widgetGrabDefault :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Specifies whether widget can be a default widget. See
--   widgetGrabDefault for details about the meaning of “default”.
--   
--   Since: 2.18
widgetSetCanDefault :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Obtains the current size of window.
--   
--   If window 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: windowSetDefaultSize.
--   
--   Depending on the windowing system and the window manager constraints,
--   the size returned by this function may not match the size set using
--   windowResize; additionally, since windowResize may be
--   implemented as an asynchronous operation, GTK+ cannot guarantee in any
--   way that this code:
--   
--   
C code
--   
--   
--   // width and height are set elsewhere
--   gtk_window_resize (window, width, height);
--   
--   int new_width, new_height;
--   gtk_window_get_size (window, &new_width, &new_height);
--   
--   
--   will result in new_width and new_height matching
--   width and height, respectively.
--   
--   This function will return the logical size of the Window,
--   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 windowSetDefaultSize 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 Widget::sizeAllocate signal, or inside a
--   handler for the Widget::configureEvent signal:
--   
--   
C code
--   
--   
--   static void
--   on_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
--   {
--     int new_width, new_height;
--   
--     gtk_window_get_size (GTK_WINDOW (widget), &new_width, &new_height);
--   
--     ...
--   }
--   
--   
--   Note that, if you connect to the Widget::sizeAllocate signal,
--   you should not use the dimensions of the GtkAllocation
--   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 windowSetTypeHint, which allows the window manager to e.g.
--   center dialogs. Also, if you set the transient parent of dialogs with
--   windowSetTransientFor 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:
--   windowSetPosition.
windowGetSize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Int32, Int32)

-- | Causes widget to have the keyboard focus for the
--   Window it's inside. widget must be a focusable
--   widget, such as a Entry; something like Frame won’t
--   work.
--   
--   More precisely, it must have the GTK_CAN_FOCUS flag
--   set. Use widgetSetCanFocus 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 ()

-- | Determines whether a resize grip is visible for the specified window.
--   
--   Since: 3.0
windowResizeGripIsVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Sets an icon list to be used as fallback for windows that haven't had
--   windowSetIconList 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 windowSetIconList for more details.
windowSetDefaultIconList :: (HasCallStack, MonadIO m, IsPixbuf a) => [a] -> m ()

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

-- | Whether widget can rely on having its alpha channel
--   drawn correctly. On X11 this function returns whether a compositing
--   manager is running for widget’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 windowSetComposited).
--   
--   Since: 2.10
widgetIsComposited :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Window placement can be influenced using this enumeration. Note that
--   using GTK_WIN_POS_CENTER_ALWAYS 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
--   windowSetTransientFor).
WindowPositionCenterOnParent :: WindowPosition

-- | Catch-all for unknown values
AnotherWindowPosition :: Int -> WindowPosition

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

-- | Sets an icon to be used as fallback for windows that haven't had
--   windowSetIconList called on them from a named themed icon, see
--   windowSetIconName.
--   
--   Since: 2.6
windowSetDefaultIconName :: (HasCallStack, MonadIO m) => Text -> m ()

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

-- | This function is only useful in widget implementations. Causes a
--   widget to be unrealized (frees all GDK resources associated with the
--   widget, such as widget->window).
widgetUnrealize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Returns the style context associated to widget. The
--   returned object is guaranteed to be the same for the lifetime of
--   widget.
widgetGetStyleContext :: (HasCallStack, MonadIO m, IsWidget a) => a -> m StyleContext

-- | 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
--   GtkButtons, 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
--   styleContextAddClass.
--   
--   This way, your widget library can install a CssProvider with
--   the STYLE_PROVIDER_PRIORITY_FALLBACK 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 CssProvider with
--   the STYLE_PROVIDER_PRIORITY_APPLICATION priority.
--   
--   Since: 3.0
widgetOverrideColor :: (HasCallStack, MonadIO m, IsWidget a) => a -> [StateFlags] -> Maybe RGBA -> m ()

-- | 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 widgetModifyText) for
--   widgets such as Entry and TextView. See also
--   widgetModifyStyle.
--   
--   
--   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.
--   
widgetModifyBase :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe Color -> m ()

-- | Returns the widget state as a flag set. It is worth mentioning that
--   the effective StateFlagsInsensitive state will be returned,
--   that is, also based on parent insensitivity, even if
--   widget itself is sensitive.
--   
--   Also note that if you are looking for a way to obtain the
--   StateFlags to pass to a StyleContext method, you should
--   look at styleContextGetState.
--   
--   Since: 3.0
widgetGetStateFlags :: (HasCallStack, MonadIO m, IsWidget a) => a -> m [StateFlags]

-- | Returns the widget’s state. See widgetSetState.
--   
--   Since: 2.18
widgetGetState :: (HasCallStack, MonadIO m, IsWidget a) => a -> m StateType

-- | Creates the GDK (windowing system) resources associated with a widget.
--   For example, widget->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 widgetRealize realizes the widget’s parents
--   in addition to widget 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 Widget::draw. Or
--   simply g_signal_connect () to the Widget::realize signal.
widgetRealize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Sets the visibility state of widget. Note that setting
--   this to True doesn’t mean the widget is actually viewable, see
--   widgetGetVisible.
--   
--   This function simply calls widgetShow or widgetHide but
--   is nicer to use when the visibility of the widget depends on some
--   condition.
--   
--   Since: 2.18
widgetSetVisible :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | This function should be called whenever keyboard navigation within a
--   single widget hits a boundary. The function emits the
--   Widget::keynavFailed signal on the widget and its return value
--   should be interpreted in a way similar to the return value of
--   widgetChildFocus:
--   
--   When True 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 False is returned, the caller should continue with
--   keyboard navigation outside the widget, e.g. by calling
--   widgetChildFocus on the widget’s toplevel.
--   
--   The default keynavFailed handler returns False for
--   DirectionTypeTabForward and DirectionTypeTabBackward.
--   For the other values of DirectionType it returns True.
--   
--   Whenever the default handler returns True, it also calls
--   widgetErrorBell to notify the user of the failed keyboard
--   navigation.
--   
--   A use case for providing an own implementation of keynavFailed
--   (either by connecting to it or by overriding it) would be a row of
--   Entry 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.
--   
--   Since: 2.12
widgetKeynavFailed :: (HasCallStack, MonadIO m, IsWidget a) => a -> DirectionType -> m Bool

-- | Reverses the effects of widgetShow, causing the widget to be
--   hidden (invisible to the user).
widgetHide :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Returns the width that has currently been allocated to
--   widget. This function is intended to be used when
--   implementing handlers for the Widget::draw function.
widgetGetAllocatedWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Returns the height that has currently been allocated to
--   widget. This function is intended to be used when
--   implementing handlers for the Widget::draw function.
widgetGetAllocatedHeight :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Sets a widget as a potential drop destination, and adds default
--   behaviors.
--   
--   The default behaviors listed in flags have an effect
--   similar to installing default handlers for the widget’s drag-and-drop
--   signals (Widget::dragMotion, Widget::dragDrop, ...).
--   They all exist for convenience. When passing
--   GTK_DEST_DEFAULT_ALL for instance it is sufficient to
--   connect to the widget’s Widget::dragDataReceived 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 Widget::dragMotion.
--   The default behaviors described by flags make some
--   assumptions, that can conflict with your own signal handlers. For
--   instance GTK_DEST_DEFAULT_DROP causes invokations of
--   dragStatus in the context of Widget::dragMotion, and
--   invokations of dragFinish in Widget::dragDataReceived.
--   Especially the later is dramatic, when your own
--   Widget::dragMotion handler calls widgetDragGetData to
--   inspect the dragged data.
--   
--   There’s no way to set a default action here, you can use the
--   Widget::dragMotion callback for that. Here’s an example which
--   selects the action to use depending on whether the control key is
--   pressed or not:
--   
--   
C code
--   
--   
--   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, &mask);
--     if (mask & GDK_CONTROL_MASK)
--       gdk_drag_status (context, GDK_ACTION_COPY, time);
--     else
--       gdk_drag_status (context, GDK_ACTION_MOVE, time);
--   }
--   
widgetDragDestSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> [DestDefaults] -> Maybe [TargetEntry] -> [DragAction] -> m ()

-- | Highlights a widget as a currently hovered drop target. To end the
--   highlight, call widgetDragUnhighlight. GTK+ calls this
--   automatically if DestDefaultsHighlight is set.
widgetDragHighlight :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Removes a highlight set by widgetDragHighlight from a widget.
widgetDragUnhighlight :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Sets the icon that will be used for drags from a particular widget
--   from a Pixbuf. GTK+ retains a reference for
--   pixbuf and will release it when it is no longer
--   needed.
widgetDragSourceSetIconPixbuf :: (HasCallStack, MonadIO m, IsWidget a, IsPixbuf b) => a -> b -> m ()

-- | Utility function; intended to be connected to the
--   Widget::deleteEvent signal on a Window. The function
--   calls widgetHide on its argument, then returns True. If
--   connected to deleteEvent, 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 deleteEvent is received.
widgetHideOnDelete :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Registers a new accelerator with the global accelerator map. This
--   function should only be called once per accelPath with
--   the canonical accelKey and accelMods
--   for this path. To change the accelerator during runtime
--   programatically, use accelMapChangeEntry.
--   
--   Set accelKey and accelMods to 0 to
--   request a removal of the accelerator.
--   
--   Note that accelPath string will be stored in a
--   GQuark. Therefore, if you pass a static string, you
--   can save some memory by interning it first with
--   internStaticString.
accelMapAddEntry :: (HasCallStack, MonadIO m) => Text -> Word32 -> [ModifierType] -> m ()

-- | Given an accelerator group, accelGroup, and an
--   accelerator path, accelPath, sets up an accelerator in
--   accelGroup so whenever the key binding that is defined
--   for accelPath is pressed, widget will
--   be activated. This removes any accelerators (for any accelerator
--   group) installed by previous calls to widgetSetAccelPath.
--   Associating accelerators with paths allows them to be modified by the
--   user and the modifications to be saved for future use. (See
--   accelMapSave.)
--   
--   This function is a low level function that would most likely be used
--   by a menu creation system like UIManager. If you use
--   UIManager, setting up accelerator paths will be done
--   automatically.
--   
--   Even when you you aren’t using UIManager, if you only want to
--   set up accelerators on menu items menuItemSetAccelPath provides
--   a somewhat more convenient interface.
--   
--   Note that accelPath string will be stored in a
--   GQuark. Therefore, if you pass a static string, you
--   can save some memory by interning it first with
--   internStaticString.
widgetSetAccelPath :: (HasCallStack, MonadIO m, IsWidget a, IsAccelGroup b) => a -> Maybe Text -> Maybe b -> m ()

-- | Set the accelerator path on menuItem, through which
--   runtime changes of the menu item’s accelerator caused by the user can
--   be identified and saved to persistent storage (see accelMapSave
--   on this). To set up a default accelerator for this menu item, call
--   accelMapAddEntry with the same accelPath. See
--   also accelMapAddEntry on the specifics of accelerator paths,
--   and menuSetAccelPath for a more convenient variant of this
--   function.
--   
--   This function is basically a convenience wrapper that handles calling
--   widgetSetAccelPath with the appropriate accelerator group for
--   the menu item.
--   
--   Note that you do need to set an accelerator on the parent menu with
--   menuSetAccelGroup for this to work.
--   
--   Note that accelPath string will be stored in a
--   GQuark. Therefore, if you pass a static string, you
--   can save some memory by interning it first with
--   internStaticString.
menuItemSetAccelPath :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Maybe Text -> m ()

-- | Sets the device event mask (see EventMask) for a widget. The
--   event mask determines which events a widget will receive from
--   device. 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
--   widgetAddDeviceEvents 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 False from
--   widgetGetHasWindow); to get events on those widgets, place them
--   inside a EventBox and receive events on the event box.
--   
--   Since: 3.0
widgetSetDeviceEvents :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> [EventMask] -> m ()

-- | Sets the event mask (see EventMask) 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 widgetAddEvents 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
--   widgetGetHasWindow). To get events on those widgets, place them
--   inside a EventBox and receive events on the event box.
widgetSetEvents :: (HasCallStack, MonadIO m, IsWidget a) => a -> [EventMask] -> m ()

-- | Returns a newly allocated list of the widgets, normally labels, for
--   which this widget is the target of a mnemonic (see for example,
--   labelSetMnemonicWidget).
--   
--   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 g_list_foreach
--   (result, (GFunc)g_object_ref, NULL) first, and then unref all the
--   widgets afterwards.
--   
--   Since: 2.4
widgetListMnemonicLabels :: (HasCallStack, MonadIO m, IsWidget a) => a -> m [Widget]

-- | 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 Label, Label queues a resize to ensure
--   there’s enough space for the new text.
--   
--   Note that you cannot call widgetQueueResize on a widget from
--   inside its implementation of the GtkWidgetClasssize_allocate
--   virtual method. Calls to widgetQueueResize from inside
--   GtkWidgetClasssize_allocate will be silently ignored.
widgetQueueResize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Convenience function that calls widgetQueueDrawRegion 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
--   widget->window coordinates for widgets that return
--   True for widgetGetHasWindow, and are relative to
--   widget->allocation.x,
--   widget->allocation.y otherwise.
--   
--   width or height may be 0, in this case
--   this function does nothing. Negative values for width
--   and height are not allowed.
widgetQueueDrawArea :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> Int32 -> Int32 -> Int32 -> 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 ()

-- | This function is used by custom widget implementations; if you're
--   writing an app, you’d use widgetGrabFocus to move the focus to
--   a particular widget, and containerSetFocusChain to change the
--   focus tab order. So you may want to investigate those functions
--   instead.
--   
--   widgetChildFocus is called by containers as the user moves
--   around the window using keyboard shortcuts. direction
--   indicates what kind of motion is taking place (up, down, left, right,
--   tab forward, tab backward). widgetChildFocus emits the
--   Widget::focus signal; widgets override the default handler for
--   this signal in order to implement appropriate focus behavior.
--   
--   The default focus handler for a widget should return
--   True if moving in direction left the focus on a
--   focusable location inside that widget, and False if moving in
--   direction moved the focus outside the widget. If
--   returning True, widgets normally call widgetGrabFocus to
--   place the focus accordingly; if returning False, they don’t
--   modify the current focus location.
widgetChildFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> DirectionType -> m Bool

-- | Emits a Widget::childNotify signal for the [child
--   property][child-properties] childProperty on the
--   child.
--   
--   This is an analogue of objectNotify for child properties.
--   
--   Also see widgetChildNotify.
--   
--   Since: 3.2
containerChildNotify :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> b -> Text -> m ()

-- | Obtains the full path to widget. 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
--   widgetGetName. 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 widgetSetName. By setting the name of a widget, you
--   allow users or theme authors to apply styles to that specific widget
--   in their gtkrc file. pathReversedP fills in the path
--   in reverse order, i.e. starting with widget’s name
--   instead of starting with the name of widget’s
--   outermost ancestor.
widgetPath :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Word32, Text, Text)

-- | 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 StyleContext).
--   
--   Note that the CSS syntax has certain special characters to delimit and
--   represent elements in a selector (period, #, >, *...), 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 ()

-- | Gets whether the widget would like any available extra horizontal
--   space. When a user resizes a Window, 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 widgetComputeExpand 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 the widget would like any available extra vertical space.
--   
--   See widgetGetHexpand for more detail.
widgetGetVexpand :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets a Context with the appropriate font map, font description,
--   and base direction for this widget. Unlike the context returned by
--   widgetCreatePangoContext, 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
--   Widget::screenChanged signal on the widget.
widgetGetPangoContext :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Context

-- | Removes widget from container.
--   widget must be inside container. Note
--   that container will own a reference to
--   widget, 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 widget again, you need to add a
--   reference to it before removing it from a container, using
--   objectRef. If you don’t want to use widget
--   again it’s usually more efficient to simply destroy it directly using
--   widgetDestroy 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 ()

-- | This function sets *widgetPointer to Nothing if
--   widgetPointer != Nothing. It’s intended to be
--   used as a callback connected to the “destroy” signal of a widget. You
--   connect widgetDestroyed 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 Nothing. Useful for
--   example to avoid multiple copies of the same dialog.
widgetDestroyed :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m Widget

-- | Adds a GTK+ grab on device, so all the events on
--   device and its associated pointer or keyboard (if any)
--   are delivered to widget. If the
--   blockOthers parameter is True, any other
--   devices will be unable to interact with widget during
--   the grab.
--   
--   Since: 3.0
deviceGrabAdd :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> Bool -> m ()

-- | 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 widgetDragSourceSet is used.
--   
--   The event is used to retrieve the timestamp that will
--   be used internally to grab the pointer. If event is
--   Nothing, then CURRENT_TIME 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:
--   
--   
--   
- During a Widget::buttonPressEvent handler, if you want to
--   start a drag immediately when the user presses the mouse button. Pass
--   the event that you have in your
--   Widget::buttonPressEvent handler.
--   
- During a Widget::motionNotifyEvent handler, if you want to
--   start a drag when the mouse moves past a certain threshold distance
--   after a button-press. Pass the event that you have in
--   your Widget::motionNotifyEvent handler.
--   
- 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 eventCopy, and pass it to
--   this function (remember to free the event with eventFree when
--   you are done). If you really cannot pass a real event, pass
--   Nothing instead.
--   
--   
--   Since: 3.10
widgetDragBeginWithCoordinates :: (HasCallStack, MonadIO m, IsWidget a) => a -> TargetList -> [DragAction] -> Int32 -> Maybe Event -> Int32 -> Int32 -> m DragContext

-- | 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 ()

-- | Appends the image targets supported by SelectionData to the
--   target list. All targets are added with the same info.
--   
--   Since: 2.6
targetListAddImageTargets :: (HasCallStack, MonadIO m) => TargetList -> Word32 -> 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
--   widgetDragDestSet.
widgetDragDestSetTargetList :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe TargetList -> m ()

-- | Appends the text targets supported by SelectionData to the
--   target list. All targets are added with the same info.
--   
--   Since: 2.6
targetListAddTextTargets :: (HasCallStack, MonadIO m) => TargetList -> Word32 -> m ()

-- | Appends the URI targets supported by SelectionData to the
--   target list. All targets are added with the same info.
--   
--   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.
--   
--   Since: 2.6
targetListAddUriTargets :: (HasCallStack, MonadIO m) => TargetList -> Word32 -> m ()

-- | Returns the list of targets this widget can accept from drag-and-drop.
widgetDragDestGetTargetList :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe TargetList)

-- | Changes the target types that this widget offers for drag-and-drop.
--   The widget must first be made into a drag source with
--   widgetDragSourceSet.
--   
--   Since: 2.4
widgetDragSourceSetTargetList :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe TargetList -> m ()

-- | Draws widget to cr. The top left
--   corner of the widget will be drawn to the currently set origin point
--   of cr.
--   
--   You should pass a cairo context as cr argument that is
--   in an original state. Otherwise the resulting drawing is undefined.
--   For example changing the operator using
--   cairo_set_operator() or the line width using
--   cairo_set_line_width() might have unwanted side
--   effects. You may however change the context’s transform matrix - like
--   with cairo_scale(), cairo_translate()
--   or cairo_set_matrix() and clip region with
--   cairo_clip() prior to calling this function. Also, it
--   is fine to modify the context with cairo_save() and
--   cairo_push_group() 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 widgetDraw.
--   
--   Since: 3.0
widgetDraw :: (HasCallStack, MonadIO m, IsWidget a) => a -> Context -> 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:
--   
--   
--   
- 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.
--   
- 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.
--   
- Then the event is pushed onto a stack so you can query the
--   currently handled event with getCurrentEvent.
--   
- 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 gtk_key_snooper_install() if you need
--   this feature.
--   
--   
--   
- After finishing the delivery the event is popped from the event
--   stack.
--   
mainDoEvent :: (HasCallStack, MonadIO m) => Event -> m ()

-- | Reverts the effect of a previous call to
--   widgetFreezeChildNotify. This causes all queued
--   Widget::childNotify signals on widget to be
--   emitted.
widgetThawChildNotify :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | This function is only used by Container 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
--   Widget:halign and Widget:valign properties.
--   
--   If the child widget does not have a valign of AlignBaseline the
--   baseline argument is ignored and -1 is used instead.
--   
--   Since: 3.10
widgetSizeAllocateWithBaseline :: (HasCallStack, MonadIO m, IsWidget a) => a -> Rectangle -> Int32 -> m ()

-- | Retrieves the widget’s allocation.
--   
--   Note, when implementing a Container: a widget’s allocation will
--   be its “adjusted” allocation, that is, the widget’s parent container
--   typically calls widgetSizeAllocate with an allocation, and that
--   allocation is then adjusted (to handle margin and alignment for
--   example) before assignment to the widget. widgetGetAllocation
--   returns the adjusted allocation that was actually assigned to the
--   widget. The adjusted allocation is guaranteed to be completely
--   contained within the widgetSizeAllocate allocation, however. So
--   a Container 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 widgetSizeAllocate, since it isn’t stored; if a
--   container implementation needs that information it will have to track
--   it itself.
--   
--   Since: 2.18
widgetGetAllocation :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Rectangle

-- | Sets the horizontal alignment of widget. See the
--   Widget:halign property.
widgetSetHalign :: (HasCallStack, MonadIO m, IsWidget a) => a -> Align -> m ()

-- | This function is only used by Container 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
--   Widget:halign and Widget:valign properties.
--   
--   For baseline support in containers you need to use
--   widgetSizeAllocateWithBaseline instead.
widgetSizeAllocate :: (HasCallStack, MonadIO m, IsWidget a) => a -> Rectangle -> m ()

-- | This function returns the topmost widget in the container hierarchy
--   widget is a part of. If widget 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. widgetGetAncestor;
--   gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW) would
--   return Nothing if widget wasn’t inside a
--   toplevel window, and if the window was inside a Window-derived
--   widget which was in turn inside the toplevel Window. While the
--   second case may seem unlikely, it actually happens when a Plug
--   is embedded inside a Socket within the same application.
--   
--   To reliably find the toplevel Window, use
--   widgetGetToplevel and call GTK_IS_WINDOW() on
--   the result. For instance, to get the title of a widget's toplevel
--   window, one might use:
--   
--   
C code
--   
--   
--   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;
--   }
--   
widgetGetToplevel :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Widget

-- | Determines whether widget is somewhere inside
--   ancestor, possibly with intermediate containers.
widgetIsAncestor :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m Bool

-- | Gets the first ancestor of widget with type
--   widgetType. For example, gtk_widget_get_ancestor
--   (widget, GTK_TYPE_BOX) gets the first Box that’s an
--   ancestor of widget. No reference will be added to the
--   returned widget; it should not be unreferenced. See note about
--   checking for a toplevel Window in the docs for
--   widgetGetToplevel.
--   
--   Note that unlike widgetIsAncestor, widgetGetAncestor
--   considers widget to be an ancestor of itself.
widgetGetAncestor :: (HasCallStack, MonadIO m, IsWidget a) => a -> GType -> m (Maybe Widget)

-- | Sets whether the application intends to draw on the widget in an
--   Widget::draw 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 EventBox and Window,
--   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 widget can own the input focus. See
--   widgetGrabFocus for actually setting the input focus on a
--   widget.
--   
--   Since: 2.18
widgetSetCanFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | This function is typically used when implementing a Container
--   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 widgetSizeAllocate.
--   
--   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

-- | Sets whether widget should be mapped along with its
--   when its parent is mapped and widget has been shown
--   with widgetShow.
--   
--   The child visibility can be set for widget before it is added to a
--   container with widgetSetParent, to avoid mapping children
--   unnecessary before immediately unmapping them. However it will be
--   reset to its default state of True 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 ()

-- | Enables or disables a Device to interact with
--   widget and all its children.
--   
--   It does so by descending through the Window hierarchy and
--   enabling the same mask that is has for core events (i.e. the one that
--   windowGetEvents returns).
--   
--   Since: 3.0
widgetSetDeviceEnabled :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> 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 TextDirectionNone, then the value
--   set by widgetSetDefaultDirection will be used.
widgetSetDirection :: (HasCallStack, MonadIO m, IsWidget a) => a -> TextDirection -> m ()

-- | Widgets are double buffered by default; you can use this function to
--   turn off the buffering. “Double buffered” simply means that
--   windowBeginDrawFrame and windowEndDrawFrame are called
--   automatically around expose events sent to the widget.
--   windowBeginDrawFrame diverts all drawing to a widget's window
--   to an offscreen buffer, and windowEndDrawFrame 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
--   windowBeginDrawFrame).
--   
--   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 ()

-- | Adds the events in the bitfield events to the event
--   mask for widget. See widgetSetEvents and the
--   [input handling overview][event-masks] for details.
widgetAddEvents :: (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.
--   
--   Since: 3.20
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.
--   
--   Since: 3.18
widgetSetFontMap :: (HasCallStack, MonadIO m, IsWidget a, IsFontMap b) => a -> Maybe b -> m ()

-- | Equivalent to calling widgetQueueDrawArea for the entire area
--   of a widget.
widgetQueueDraw :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | 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
--   Widget:expand flag inside a Box, 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 gTKALIGNSTART and
--   gTKALIGNEND 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
--   gTKALIGNFILL.
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

-- | Specifies whether widget has a Window of its
--   own. Note that all realized widgets have a non-Nothing “window”
--   pointer (widgetGetWindow never returns a Nothing window
--   when a widget is realized), but for many of them it’s actually the
--   Window of one of its parent widgets. Widgets that do not create
--   a window for themselves in Widget::realize must
--   announce this by calling this function with hasWindow
--   = False.
--   
--   This function should only be called by widget implementations, and
--   they should call it in their init() function.
--   
--   Since: 2.18
widgetSetHasWindow :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Computes whether a container should give this widget extra space when
--   possible. Containers should check this, rather than looking at
--   widgetGetHexpand or widgetGetVexpand.
--   
--   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

-- | Sets whether the widget would like any available extra horizontal
--   space. When a user resizes a Window, 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 widgetComputeExpand. A
--   container can decide how the expandability of children affects the
--   expansion of the container by overriding the compute_expand virtual
--   method on Widget.).
--   
--   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 widgetSetHexpand sets
--   the hexpand-set property (see widgetSetHexpandSet) 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 ()

-- | 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 widgetSetStyle. The
--   RcStyle-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 widgetModifyStyle or with such functions
--   as widgetModifyFg. If you wish to retain previous values, you
--   must first call widgetGetModifierStyle, make your modifications
--   to the returned style, then call widgetModifyStyle with that
--   style. On the other hand, if you first call widgetModifyStyle,
--   subsequent calls to such functions widgetModifyFg will have a
--   cumulative effect with the initial modifications.
widgetModifyStyle :: (HasCallStack, MonadIO m, IsWidget a, IsRcStyle b) => a -> b -> m ()

-- | Request the widget 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 widgetIsComposited. 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.
--   
--   Since: 3.8
widgetSetOpacity :: (HasCallStack, MonadIO m, IsWidget a) => a -> Double -> m ()

-- | Creates a new Context with the appropriate font map, font
--   options, font description, and base direction for drawing text for
--   this widget. See also widgetGetPangoContext.
widgetCreatePangoContext :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Context

-- | Determines whether widget has a Window of its
--   own. See widgetSetHasWindow.
--   
--   Since: 2.18
widgetGetHasWindow :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Retrieves a widget’s minimum and natural height and the corresponding
--   baselines if it would be given the specified width, or
--   the default height if width 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
--   GtkWidgetClassadjust_size_request and
--   GtkWidgetClassadjust_baseline_request virtual methods and by
--   any GtkSizeGroups 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.
--   
--   Since: 3.10
widgetGetPreferredHeightAndBaselineForWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m (Int32, Int32, Int32, Int32)

-- | 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 ()

-- | Returns the widget’s effective sensitivity, which means it is
--   sensitive itself and also its parent widget is sensitive
--   
--   Since: 2.18
widgetIsSensitive :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | 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 widgetGetPreferredHeightAndBaselineForWidth if you want to
--   support baseline alignment.
--   
--   Since: 3.0
widgetGetPreferredSize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Requisition, Requisition)

-- | 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 widgetSetSensitive.
widgetSetState :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> m ()

-- | 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

-- | Returns the state used for style matching.
--   
--   This method should only be used to retrieve the StateFlags to
--   pass to StyleContext methods, like
--   styleContextGetPadding. If you need to retrieve the current
--   state of a Widget, use widgetGetStateFlags.
--   
--   Since: 3.0
styleContextGetState :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m [StateFlags]

-- | Enables or disables multiple pointer awareness. If this setting is
--   True, widget will start receiving multiple, per
--   device enter/leave events. Note that if custom
--   GdkWindows are created in Widget::realize,
--   windowSetSupportMultidevice will have to be called manually on
--   them.
--   
--   Since: 3.0
widgetSetSupportMultidevice :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | 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 widgetGetTemplateChild.
--   
--   The struct can point either into the public instance, then you should
--   use G_STRUCT_OFFSET(WidgetType, member) for
--   structOffset, 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 ObjectClass.dispose() runs
--   on your instance and if a structOffset that is != 0 is
--   specified, then the automatic location in your instance public or
--   private data will be set to Nothing. You can however access an
--   automated child pointer the first time your classes
--   ObjectClass.dispose() runs, or alternatively in
--   WidgetClass.destroy().
--   
--   If internalChild is specified,
--   BuildableIface.get_internal_child() will be
--   automatically implemented by the Widget class so there is no
--   need to implement it manually.
--   
--   The wrapper macros
--   gtk_widget_class_bind_template_child(),
--   gtk_widget_class_bind_template_child_internal(),
--   gtk_widget_class_bind_template_child_private() and
--   gtk_widget_class_bind_template_child_internal_private()
--   might be more convenient to use.
--   
--   Note that this must be called from a composite widget classes class
--   initializer after calling widgetClassSetTemplate.
--   
--   Since: 3.10
widgetClassBindTemplateChildFull :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> Bool -> Int64 -> m ()

-- | Replaces the default window used for displaying tooltips with
--   customWindow. GTK+ will take care of showing and
--   hiding customWindow at the right moment, to behave
--   likewise as the default tooltip window. If
--   customWindow is Nothing, the default tooltip
--   window will be used.
--   
--   Since: 2.12
widgetSetTooltipWindow :: (HasCallStack, MonadIO m, IsWidget a, IsWindow b) => a -> Maybe b -> m ()

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

-- | Gets the value of the Widget:valign property, including
--   AlignBaseline.
--   
--   Since: 3.10
widgetGetValignWithBaseline :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Align

-- | Sets whether the widget would like any available extra vertical space.
--   
--   See widgetSetHexpand for more detail.
widgetSetVexpand :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Gets whether widgetSetHexpand 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

-- | 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 widgetGetVisible and widgetSetVisible
--   
--   Since: 3.8
widgetIsVisible :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | 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 widget
--   isn't activatable, the function returns False.
widgetActivate :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Removes the grab from the given widget.
--   
--   You have to pair calls to widgetGrabAdd and
--   widgetGrabRemove.
--   
--   If widget does not have the grab, this function does
--   nothing.
widgetGrabRemove :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Determines if the widget is the focus widget within its toplevel.
--   (This does not mean that the Widget:hasFocus property is
--   necessarily set; Widget:hasFocus will only be set if the
--   toplevel widget additionally has the global input focus.)
widgetIsFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the value of the Window:focusVisible property.
--   
--   Since: 3.2
windowGetFocusVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Determines if the widget has the global input focus. See
--   widgetIsFocus for the difference between having the global
--   input focus, and only having the focus within a toplevel.
--   
--   Since: 2.18
widgetHasFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

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

-- | Determines whether the widget is visible. If you want to take into
--   account whether the widget’s parent is also marked as visible, use
--   widgetIsVisible instead.
--   
--   This function does not check if the widget is obscured in any way.
--   
--   See widgetSetVisible.
--   
--   Since: 2.18
widgetGetVisible :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | 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

-- | Notifies the user about an input-related error on this widget. If the
--   Settings:gtkErrorBell setting is True, it calls
--   windowBeep, otherwise it does nothing.
--   
--   Note that the effect of windowBeep can be configured in many
--   ways, depending on the windowing backend and the desktop environment
--   or window manager that is used.
--   
--   Since: 2.12
widgetErrorBell :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Installs an accelerator in this group, using an accelerator path to
--   look up the appropriate key and modifiers (see
--   accelMapAddEntry). When accelGroup is being
--   activated in response to a call to accelGroupsActivate,
--   closure will be invoked if the
--   accelKey and accelMods from
--   accelGroupsActivate match the key and modifiers for the path.
--   
--   The signature used for the closure is that of
--   AccelGroupActivate.
--   
--   Note that accelPath string will be stored in a
--   GQuark. Therefore, if you pass a static string, you
--   can save some memory by interning it first with
--   internStaticString.
accelGroupConnectByPath :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> Text -> GClosure b -> m ()

-- | Finds the AccelGroup to which closure is
--   connected; see accelGroupConnect.
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.
--   labelSetMarkupWithMnemonic, labelSetTextWithMnemonic,
--   labelNewWithMnemonic 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 Button or a
--   Notebook tab) it is automatically associated with the correct
--   widget, but sometimes (i.e. when the target is a Entry next to
--   the label) you need to set it explicitly using this function.
--   
--   The target widget will be accelerated by emitting the
--   GtkWidgetmnemonicActivate 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 ()

-- | 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
--   widgetModifyBase) for widgets such as Entry and
--   TextView. See also widgetModifyStyle.
widgetModifyText :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe Color -> m ()

-- | Used to set the Style for a widget
--   (widget->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 ()

-- | Sets the foreground color for a widget in a particular state.
--   
--   All other style values are left untouched. See also
--   widgetModifyStyle.
widgetModifyFg :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe Color -> m ()

-- | Returns the current modifier style for the widget. (As set by
--   widgetModifyStyle.) If no style has previously set, a new
--   RcStyle 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 widgetModifyStyle, passing in the returned rc
--   style, to make sure that your changes take effect.
--   
--   Caution: passing the style back to widgetModifyStyle will
--   normally end up destroying it, because widgetModifyStyle 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

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

-- | 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 * {...} rules.
pattern STYLE_PROVIDER_PRIORITY_FALLBACK :: Int32

-- | A priority that can be used when adding a StyleProvider for
--   application-specific style information.
pattern STYLE_PROVIDER_PRIORITY_APPLICATION :: Int32

-- | Retrieves the name of a widget. See widgetSetName for the
--   significance of widget names.
widgetGetName :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Text

-- | Invalidates the area of widget defined by
--   region by calling windowInvalidateRegion 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 DrawingArea or
--   some portion thereof.
--   
--   Since: 3.0
widgetQueueDrawRegion :: (HasCallStack, MonadIO m, IsWidget a) => a -> Region -> m ()

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

-- | Unregisters a Window from the widget that was previously set up
--   with widgetRegisterWindow. You need to call this when the
--   window is no longer used by the widget, such as when you destroy it.
--   
--   Since: 3.8
widgetUnregisterWindow :: (HasCallStack, MonadIO m, IsWidget a, IsWindow b) => a -> b -> m ()

-- | Registers a Window with the widget and sets it up so that the
--   widget receives events for it. Call widgetUnregisterWindow when
--   destroying the window.
--   
--   Before 3.8 you needed to call windowSetUserData directly to set
--   this up. This is now deprecated and you should use
--   widgetRegisterWindow instead. Old code will keep working as is,
--   although some new features like transparency might not work perfectly.
--   
--   Since: 3.8
widgetRegisterWindow :: (HasCallStack, MonadIO m, IsWidget a, IsWindow b) => a -> b -> m ()

-- | Installs an accelerator for this widget in
--   accelGroup that causes accelSignal to
--   be emitted if the accelerator is activated. The
--   accelGroup needs to be added to the widget’s toplevel
--   via windowAddAccelGroup, and the signal must be of type
--   SignalFlagsAction. 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
--   accelMapAddEntry and widgetSetAccelPath or
--   menuItemSetAccelPath instead.
widgetAddAccelerator :: (HasCallStack, MonadIO m, IsWidget a, IsAccelGroup b) => a -> Text -> b -> Word32 -> [ModifierType] -> [AccelFlags] -> m ()

-- | Adds a widget to the list of mnemonic labels for this widget. (See
--   widgetListMnemonicLabels). 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 Widget::destroy signal or a weak notifier.
--   
--   Since: 2.4
widgetAddMnemonicLabel :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m ()

-- | The “Open” item and icon.
pattern STOCK_OPEN :: Text

-- | The “OK” item and icon.
pattern STOCK_OK :: Text

-- | Returns a newly created widget path representing all the widget
--   hierarchy from the toplevel down to and including
--   child.
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 Widget::draw calls to all children that don’t have
--   their own GdkWindows. This function provides a
--   convenient way of doing this. A container, when it receives a call to
--   its Widget::draw function, calls containerPropagateDraw
--   once for each child, passing in the cr the container
--   received.
--   
--   containerPropagateDraw takes care of translating the origin of
--   cr, 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 widgetDraw on the child directly.
--   
--   In most cases, a container can simply either inherit the
--   Widget::draw implementation from Container, or do some
--   drawing and then chain to the draw implementation from
--   Container.
containerPropagateDraw :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> b -> Context -> m ()

-- | Saves current accelerator specifications (accelerator path, key and
--   modifiers) to fileName. The file is written in a
--   format suitable to be read back in by accelMapLoad.
accelMapSave :: (HasCallStack, MonadIO m) => [Char] -> m ()

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

-- | 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 Container, you want to use
--   widgetSizeAllocate instead of widgetSetAllocation. The
--   GtkWidgetClassadjust_size_allocation virtual method adjusts the
--   allocation inside widgetSizeAllocate to create an adjusted
--   allocation.
--   
--   Since: 2.18
widgetSetAllocation :: (HasCallStack, MonadIO m, IsWidget a) => a -> Rectangle -> m ()

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

-- | This function is useful only when implementing subclasses of
--   Container. Sets the container as the parent of
--   widget, 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 widgetUnparent.
widgetSetParent :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m ()

-- | Makes all newly-created widgets as composite children until the
--   corresponding widgetPopCompositeChild 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 containerForeach vs. containerForall), but e.g. GUI
--   builders might want to treat them in a different way.
widgetPushCompositeChild :: (HasCallStack, MonadIO m) => m ()

-- | Adds the device events in the bitfield events to the
--   event mask for widget. See
--   widgetSetDeviceEvents for details.
--   
--   Since: 3.0
widgetAddDeviceEvents :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> [EventMask] -> m ()

-- | Sets the default reading direction for widgets where the direction has
--   not been explicitly set by widgetSetDirection.
widgetSetDefaultDirection :: (HasCallStack, MonadIO m) => TextDirection -> m ()

-- | Returns the widget’s window if it is realized, Nothing
--   otherwise
--   
--   Since: 2.14
widgetGetWindow :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Window)

-- | Sets whether the hexpand flag (see widgetGetHexpand) will be
--   used.
--   
--   The hexpand-set property will be set automatically when you call
--   widgetSetHexpand 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 ()

-- | This function is only for use in widget implementations. Should be
--   called by implementations of the remove method on Container, to
--   dissociate a child from the container.
widgetUnparent :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Sets the text of the tooltip to be markup, which is
--   marked up with the [Pango text markup language][PangoMarkupFormat]. If
--   markup is Nothing, the label will be hidden.
--   
--   Since: 2.12
tooltipSetMarkup :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe Text -> m ()

-- | Sets the text of the tooltip to be text. If
--   text is Nothing, the label will be hidden. See
--   also tooltipSetMarkup.
--   
--   Since: 2.12
tooltipSetText :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe Text -> m ()

-- | Get the Screen 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 Window 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.
--   
--   Since: 2.2
widgetGetScreen :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Screen

-- | Gets widget’s parent window, or Nothing if it
--   does not have one.
widgetGetParentWindow :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Window)

-- | Stops emission of Widget::childNotify signals on
--   widget. The signals are queued until
--   widgetThawChildNotify is called on widget.
--   
--   This is the analogue of objectFreezeNotify for child
--   properties.
widgetFreezeChildNotify :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Triggers a new tooltip query on display, 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.
--   
--   Since: 2.12
tooltipTriggerTooltipQuery :: (HasCallStack, MonadIO m, IsDisplay a) => a -> 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 StateFlagsDirLtr and
--   StateFlagsDirRtl but ignores them. If you want to set the
--   widget's direction, use widgetSetDirection.
--   
--   It is worth mentioning that any other state than
--   StateFlagsInsensitive, will be propagated down to all
--   non-internal children if widget is a Container,
--   while StateFlagsInsensitive itself will be propagated down to
--   all Container children by different means than turning on the
--   state flag down the hierarchy, both widgetGetStateFlags and
--   widgetIsSensitive will make use of these.
--   
--   Since: 3.0
widgetSetStateFlags :: (HasCallStack, MonadIO m, IsWidget a) => a -> [StateFlags] -> Bool -> m ()

-- | Cancels the effect of a previous call to
--   widgetPushCompositeChild.
widgetPopCompositeChild :: (HasCallStack, MonadIO m) => m ()

-- | Invokes callback on each direct child of
--   container, 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 containerForeach, rather than
--   containerForall.
containerForall :: (HasCallStack, MonadIO m, IsContainer a) => a -> Callback -> m ()

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

-- | Accelerator flags used with accelGroupConnect.
data AccelFlags

-- | Accelerator is visible
AccelFlagsVisible :: AccelFlags

-- | Accelerator not removable
AccelFlagsLocked :: AccelFlags

-- | Mask
AccelFlagsMask :: AccelFlags

-- | Catch-all for unknown values
AnotherAccelFlags :: Int -> AccelFlags

-- | Removes a tick callback previously registered with
--   widgetAddTickCallback.
--   
--   Since: 3.8
widgetRemoveTickCallback :: (HasCallStack, MonadIO m, IsWidget a) => a -> Word32 -> m ()

-- | Looks for a match between the supported targets of
--   context and the destTargetList,
--   returning the first matching target, otherwise returning
--   GDK_NONE. destTargetList should
--   usually be the return value from widgetDragDestGetTargetList,
--   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)

-- | Determines whether widget can be drawn to. A widget
--   can be drawn to if it is mapped and visible.
--   
--   Since: 2.18
widgetIsDrawable :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Sets the background color for a widget in a particular state.
--   
--   All other style values are left untouched. See also
--   widgetModifyStyle.
--   
--   
--   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.
--   
widgetModifyBg :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe Color -> m ()

-- | Sets the cursor color to use in a widget, overriding the Widget
--   cursor-color and secondary-cursor-color style properties.
--   
--   All other style values are left untouched. See also
--   widgetModifyStyle.
--   
--   Since: 2.12
widgetModifyCursor :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Color -> Maybe Color -> m ()

-- | Sets the font to use for a widget.
--   
--   All other style values are left untouched. See also
--   widgetModifyStyle.
widgetModifyFont :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe FontDescription -> m ()

-- | Sets the background color to use for a widget.
--   
--   All other style values are left untouched. See
--   widgetOverrideColor.
--   
--   Since: 3.0
widgetOverrideBackgroundColor :: (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 widgetModifyStyle.
--   
--   Note that the underlying properties have the Color type, so the
--   alpha value in primary and secondary
--   will be ignored.
--   
--   Since: 3.0
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 widgetOverrideColor.
--   
--   Since: 3.0
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
--   widgetOverrideColor for overriding the foreground or background
--   color.
--   
--   Since: 3.0
widgetOverrideSymbolicColor :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> Maybe RGBA -> m ()

-- | Memory-managed wrapper type.
newtype VolumeButton
VolumeButton :: ManagedPtr VolumeButton -> VolumeButton

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

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

-- | Sets the shadow type of the viewport.
viewportSetShadowType :: (HasCallStack, MonadIO m, IsViewport a) => a -> ShadowType -> m ()

-- | Memory-managed wrapper type.
newtype VSeparator
VSeparator :: ManagedPtr VSeparator -> VSeparator

-- | Memory-managed wrapper type.
newtype VScrollbar
VScrollbar :: ManagedPtr VScrollbar -> VScrollbar

-- | Memory-managed wrapper type.
newtype VScale
VScale :: ManagedPtr VScale -> VScale

-- | 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
--   Scale:drawValue is True when the value changes. If you
--   want to enforce rounding the value when Scale:drawValue is
--   False, you can set Range:roundDigits instead.
--   
--   Note that rounding to a small number of digits can interfere with the
--   smooth autoscrolling that is built into Scale. As an
--   alternative, you can use the Scale::formatValue signal to
--   format the displayed value yourself.
scaleSetDigits :: (HasCallStack, MonadIO m, IsScale a) => a -> Int32 -> m ()

-- | Memory-managed wrapper type.
newtype VPaned
VPaned :: ManagedPtr VPaned -> VPaned

-- | 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.
--   <popup>) 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
--   <menu>; 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.
--   
--   Since: 2.4
uIManagerGetWidget :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Text -> m (Maybe Widget)

-- | Returns an unused merge id, suitable for use with
--   uIManagerAddUi.
--   
--   Since: 2.4
uIManagerNewMergeId :: (HasCallStack, MonadIO m, IsUIManager a) => a -> m Word32

-- | Unmerges the part of manager's content identified by
--   mergeId.
--   
--   Since: 2.4
uIManagerRemoveUi :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Word32 -> m ()

-- | Parses a string containing a [UI definition][XML-UI] and merges it
--   with the current contents of manager. An enclosing
--   <ui> element is added if it is missing.
--   
--   Since: 2.4
uIManagerAddUiFromString :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Text -> Int64 -> m Word32

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

-- | Sets the cell renderer based on the treeModel and
--   iter. That is, for every attribute mapping in
--   treeColumn, it will get a value from the set column on
--   the iter, and use that value to set the attribute on
--   the cell renderer. This is used primarily by the TreeView.
treeViewColumnCellSetCellData :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsTreeModel b) => a -> b -> TreeIter -> Bool -> Bool -> m ()

-- | Returns the current size of treeColumn in pixels.
treeViewColumnGetWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Sets the logical sortColumnId 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 setting of True to
--   display an arrow in the header button indicating the column is sorted.
--   Call treeViewColumnSetSortOrder 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
--   treeViewColumnSetSortColumnId if you want automatic sorting
--   support. This function is primarily for custom sorting behavior, and
--   should be used in conjunction with treeSortableSetSortColumnId
--   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
--   treeViewColumnSetSortIndicator.
treeViewColumnSetSortOrder :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> SortType -> m ()

-- | 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 treeModel, and render it to the
--   “text” attribute of “cell” by converting it to its written equivalent.
--   This is set by calling treeViewColumnSetCellDataFunc
type TreeCellDataFunc = TreeViewColumn -> CellRenderer -> TreeModel -> TreeIter -> IO ()

-- | The sizing method the column uses to determine its width. Please note
--   that gTKTREEVIEWCOLUMNAUTOSIZE 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

-- | Activates the cell determined by path and
--   column.
treeViewRowActivated :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> TreePath -> b -> m ()

-- | Sets the current keyboard focus to be at path, and
--   selects it. This is useful when you want to focus the user’s attention
--   on a particular row. If focusColumn is not
--   Nothing, then focus is given to the column specified by it.
--   Additionally, if focusColumn is specified, and
--   startEditing is True, then editing should be
--   started in the specified cell. This function is often followed by
--   gtkWidgetGrabFocus (treeView) in order
--   to give keyboard focus to the widget. Please note that editing can
--   only happen when the widget is realized.
--   
--   If path is invalid for model, 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 ()

-- | Sets the current keyboard focus to be at path, and
--   selects it. This is useful when you want to focus the user’s attention
--   on a particular row. If focusColumn is not
--   Nothing, then focus is given to the column specified by it. If
--   focusColumn and focusCell are not
--   Nothing, and focusColumn contains 2 or more
--   editable or activatable cells, then focus is given to the cell
--   specified by focusCell. Additionally, if
--   focusColumn is specified, and
--   startEditing is True, then editing should be
--   started in the specified cell. This function is often followed by
--   gtkWidgetGrabFocus (treeView) in order
--   to give keyboard focus to the widget. Please note that editing can
--   only happen when the widget is realized.
--   
--   If path is invalid for model, the
--   current cursor (if any) will be unset and the function will return
--   without failing.
--   
--   Since: 2.2
treeViewSetCursorOnCell :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsCellRenderer c) => a -> TreePath -> Maybe b -> Maybe c -> Bool -> m ()

-- | Returns the window that treeView renders to. This is
--   used primarily to compare to event->window to confirm that
--   the event on treeView is on the right window.
treeViewGetBinWindow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Maybe Window)

-- | Cause the TreeView::rowActivated signal to be emitted on a
--   single click instead of a double click.
--   
--   Since: 3.8
treeViewSetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Invokes the virtual render function of the CellRenderer. The
--   three passed-in rectangles are areas in cr. Most
--   renderers will draw within cellArea; the xalign,
--   yalign, xpad, and ypad fields of the CellRenderer should be
--   honored with respect to cellArea.
--   backgroundArea includes the blank space around the
--   cell, and also the area containing the tree expander; so the
--   backgroundArea rectangles for all cells tile to cover
--   the entire window.
cellRendererRender :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> Context -> b -> Rectangle -> Rectangle -> [CellRendererState] -> m ()

-- | Fills the bounding rectangle in bin_window coordinates for the cell at
--   the row specified by path and the column specified by
--   column. If path is Nothing, or
--   points to a path not currently displayed, the y and
--   height fields of the rectangle will be filled with 0.
--   If column is Nothing, the x and
--   width 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
--   cellArea passed to cellRendererRender. This
--   function is only valid if treeView is realized.
treeViewGetCellArea :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe TreePath -> Maybe b -> m Rectangle

-- | Frees path. If path is Nothing,
--   it simply returns.
treePathFree :: (HasCallStack, MonadIO m) => Maybe TreePath -> m ()

-- | Converts widget coordinates to coordinates for the bin_window (see
--   treeViewGetBinWindow).
--   
--   Since: 2.12
treeViewConvertWidgetToBinWindowCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | This function is a convenience function to allow you to reorder models
--   that support the TreeDragSourceIface and the
--   TreeDragDestIface. Both TreeStore and ListStore
--   support these. If reorderable is True, 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
--   TreeModel::rowInserted and TreeModel::rowDeleted
--   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 a hint for the theme to draw even/odd rows in the
--   treeView 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 ()

-- | Converts tree coordinates (coordinates in full scrollable area of the
--   tree) to bin_window coordinates.
--   
--   Since: 2.12
treeViewConvertTreeToBinWindowCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Packs the cell into the beginning of the column. If
--   expand is False, then the cell
--   is allocated no more space than it needs. Any unused space is divided
--   evenly between cells for which expand is True.
treeViewColumnPackStart :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> Bool -> m ()

-- | Finds the path at the point (x, y),
--   relative to bin_window coordinates (please see
--   treeViewGetBinWindow). That is, x and
--   y are relative to an events coordinates.
--   x and y must come from an event on the
--   treeView only where event->window ==
--   gtk_tree_view_get_bin_window (). It is primarily for things like
--   popup menus. If path is non-Nothing, then it
--   will be filled with the TreePath at that point. This path
--   should be freed with treePathFree. If column is
--   non-Nothing, then it will be filled with the column at that
--   point. cellX and cellY return the
--   coordinates relative to the cell background (i.e. the
--   backgroundArea passed to cellRendererRender).
--   This function is only meaningful if treeView is
--   realized. Therefore this function will always return False if
--   treeView is not realized or does not have a model.
--   
--   For converting widget coordinates (eg. the ones you get from
--   GtkWidgetqueryTooltip), please see
--   treeViewConvertWidgetToBinWindowCoords.
treeViewGetPathAtPos :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Bool, Maybe TreePath, Maybe TreeViewColumn, Int32, Int32)

-- | Moves the alignments of treeView to the position
--   specified by column and path. If
--   column is Nothing, then no horizontal scrolling
--   occurs. Likewise, if path is Nothing no
--   vertical scrolling occurs. At a minimum, one of column
--   or path need to be non-Nothing.
--   rowAlign determines where the row is placed, and
--   colAlign determines where column 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 useAlign is False, 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 path
--   is a valid row on the model. If the model changes before the
--   treeView 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 ()

-- | 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 model
--   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 strcmp() returning 0 for equal strings.
type TreeViewSearchEqualFunc = TreeModel -> Int32 -> Text -> TreeIter -> IO Bool

-- | Sets the amount of extra indentation for child levels to use in
--   treeView 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.
--   
--   Since: 2.12
treeViewSetLevelIndentation :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> m ()

-- | Sets the area of the widget, where the contents of this tooltip apply,
--   to be rect (in widget coordinates). This is especially
--   useful for properly setting tooltips on TreeView rows and
--   cells, GtkIconViews, etc.
--   
--   For setting tooltips on TreeView, please refer to the
--   convenience functions for this: treeViewSetTooltipRow and
--   treeViewSetTooltipCell.
--   
--   Since: 2.12
tooltipSetTipArea :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Rectangle -> m ()

-- | If you only plan to have simple (text-only) tooltips on full rows, you
--   can use this function to have TreeView handle these
--   automatically for you. column should be set to the
--   column in treeView’s model containing the tooltip
--   texts, or -1 to disable this feature.
--   
--   When enabled, Widget:hasTooltip will be set to True and
--   treeView will connect a Widget::queryTooltip
--   signal handler.
--   
--   Note that the signal handler sets the text with
--   tooltipSetMarkup, so &, <, etc have to be escaped in the
--   text.
--   
--   Since: 2.12
treeViewSetTooltipColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> m ()

-- | Turns treeView into a drop destination for automatic
--   DND. Calling this method sets TreeView:reorderable to
--   False.
treeViewEnableModelDragDest :: (HasCallStack, MonadIO m, IsTreeView a) => a -> [TargetEntry] -> [DragAction] -> m ()

-- | Turns treeView into a drag source for automatic DND.
--   Calling this method sets TreeView:reorderable to False.
treeViewEnableModelDragSource :: (HasCallStack, MonadIO m, IsTreeView a) => a -> [ModifierType] -> [TargetEntry] -> [DragAction] -> m ()

-- | No description available in the introspection data.
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

-- | Sets the data in the cell specified by iter and
--   column. The type of value must be
--   convertible to the type of the column.
treeStoreSetValue :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> Int32 -> GValue -> m ()

-- | Sets the selection mode of the selection. If the
--   previous type was GTK_SELECTION_MULTIPLE, then the
--   anchor is kept selected, if it was previously selected.
treeSelectionSetMode :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> SelectionMode -> m ()

-- | 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 GtkTreeRowReferences.
--   
--   To do this, you can use treeRowReferenceNew.
--   
--   To free the return value, use:
--   
--   
C code
--   
--   
--   g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
--   
--   
--   Since: 2.2
treeSelectionGetSelectedRows :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m ([TreePath], TreeModel)

-- | Memory-managed wrapper type.
newtype TreeModelSort
TreeModelSort :: ManagedPtr TreeModelSort -> TreeModelSort

-- | 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 column of the child_model to be the column where
--   filter should look for visibility information.
--   columns should be a column of type
--   G_TYPE_BOOLEAN, where True means that a row is
--   visible, and False if not.
--   
--   Note that treeModelFilterSetVisibleFunc or
--   treeModelFilterSetVisibleColumn can only be called once for a
--   given filter model.
--   
--   Since: 2.4
treeModelFilterSetVisibleColumn :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> Int32 -> m ()

-- | Emits row_changed for each row in the child model, which causes
--   the filter to re-evaluate whether a row is visible or not.
--   
--   Since: 2.4
treeModelFilterRefilter :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> m ()

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

-- | Sets the icon of the tooltip (which is in front of the text) to be
--   pixbuf. If pixbuf is Nothing,
--   the image will be hidden.
--   
--   Since: 2.12
tooltipSetIcon :: (HasCallStack, MonadIO m, IsTooltip a, IsPixbuf b) => a -> Maybe b -> m ()

-- | Sets the tip area of tooltip to be the area covered by
--   the row at path. See also
--   treeViewSetTooltipColumn for a simpler alternative. See also
--   tooltipSetTipArea.
--   
--   Since: 2.12
treeViewSetTooltipRow :: (HasCallStack, MonadIO m, IsTreeView a, IsTooltip b) => a -> b -> TreePath -> m ()

-- | Sets the tip area of tooltip to the area
--   path, column and cell
--   have in common. For example if path is Nothing
--   and column is set, the tip area will be set to the
--   full area covered by column. See also
--   tooltipSetTipArea.
--   
--   Note that if path is not specified and
--   cell is set and part of a column containing the
--   expander, the tooltip might not show and hide at the correct position.
--   In such cases path must be set to the current node
--   under the mouse cursor for this function to operate correctly.
--   
--   See also treeViewSetTooltipColumn for a simpler alternative.
--   
--   Since: 2.12
treeViewSetTooltipCell :: (HasCallStack, MonadIO m, IsTreeView a, IsTooltip b, IsTreeViewColumn c, IsCellRenderer d) => a -> b -> Maybe TreePath -> Maybe c -> Maybe d -> 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 the relief style of the edges of the given Button widget.
--   Two styles exist, ReliefStyleNormal and ReliefStyleNone.
--   The default style is, as one can guess, ReliefStyleNormal. The
--   deprecated value ReliefStyleHalf behaves the same as
--   ReliefStyleNormal.
buttonSetRelief :: (HasCallStack, MonadIO m, IsButton a) => a -> ReliefStyle -> m ()

-- | Sets whether to show an overflow menu when toolbar
--   isn’t allocated enough size to show all of its items. If True,
--   items which can’t fit in toolbar, and which have a
--   proxy menu item set by toolItemSetProxyMenuItem or
--   ToolItem::createMenuProxy, will be available in an overflow
--   menu, which can be opened by an added arrow button. If False,
--   toolbar will request enough size to fit all of its
--   child items without any overflow.
--   
--   Since: 2.4
toolbarSetShowArrow :: (HasCallStack, MonadIO m, IsToolbar a) => a -> Bool -> m ()

-- | Alters the view of toolbar to display either icons
--   only, text only, or both.
toolbarSetStyle :: (HasCallStack, MonadIO m, IsToolbar a) => a -> ToolbarStyle -> m ()

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

-- | Sets the MenuItem used in the toolbar overflow menu. The
--   menuItemId is used to identify the caller of this
--   function and should also be used with toolItemGetProxyMenuItem.
--   
--   See also ToolItem::createMenuProxy.
--   
--   Since: 2.4
toolItemSetProxyMenuItem :: (HasCallStack, MonadIO m, IsToolItem a, IsWidget b) => a -> Text -> Maybe b -> m ()

-- | Used to customize the appearance of a Toolbar. 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

-- | 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 widgetDragSourceSet.
--   
--   Since: 2.20
toolPaletteSetDragSource :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> [ToolPaletteDragTargets] -> m ()

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

-- | Gets the group at position (x, y).
--   
--   Since: 2.20
toolPaletteGetDropGroup :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> Int32 -> Int32 -> m (Maybe ToolItemGroup)

-- | Sets whether the group should be exclusive or not. If an exclusive
--   group is expanded all other groups are collapsed.
--   
--   Since: 2.20
toolPaletteSetExclusive :: (HasCallStack, MonadIO m, IsToolPalette a, IsToolItemGroup b) => a -> b -> Bool -> m ()

-- | Sets whether the group should be given extra space.
--   
--   Since: 2.20
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.
--   
--   Since: 2.20
toolPaletteSetGroupPosition :: (HasCallStack, MonadIO m, IsToolPalette a, IsToolItemGroup b) => a -> b -> Int32 -> m ()

-- | Sets the size of icons in the tool palette.
--   
--   Since: 2.20
toolPaletteSetIconSize :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> Int32 -> m ()

-- | Sets the style (text, icons or both) of items in the tool palette.
--   
--   Since: 2.20
toolPaletteSetStyle :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> ToolbarStyle -> m ()

-- | Memory-managed wrapper type.
newtype ToolPalette
ToolPalette :: ManagedPtr ToolPalette -> ToolPalette

-- | 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

-- | 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.
--   
--   Since: 2.20
toolItemGroupSetLabelWidget :: (HasCallStack, MonadIO m, IsToolItemGroup a, IsWidget b) => a -> b -> m ()

-- | Indicated the relief to be drawn around a Button.
data ReliefStyle

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

-- | A half relief. Deprecated in 3.14, does the same as
--   gTKRELIEFNORMAL
ReliefStyleHalf :: ReliefStyle

-- | No relief.
ReliefStyleNone :: ReliefStyle

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

-- | Retrieves the current orientation for the tool shell. Tool items must
--   not call this function directly, but rely on
--   toolItemGetOrientation instead.
--   
--   Since: 2.14
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
--   toolItemGetToolbarStyle instead.
--   
--   Since: 2.14
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 toolItemGetIconSize
--   instead.
--   
--   Since: 2.14
toolShellGetIconSize :: (HasCallStack, MonadIO m, IsToolShell a) => a -> m Int32

-- | Returns the relief style of buttons on shell. Tool
--   items must not call this function directly, but rely on
--   toolItemGetReliefStyle instead.
--   
--   Since: 2.14
toolShellGetReliefStyle :: (HasCallStack, MonadIO m, IsToolShell a) => a -> m ReliefStyle

-- | Calling this function signals to the toolbar that the overflow menu
--   item for toolItem 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 ToolItem::createMenuProxy signal.
--   
--   Since: 2.6
toolItemRebuildMenu :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m ()

-- | Sets whether toolItem 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.
--   
--   Since: 2.4
toolItemSetExpand :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Bool -> m ()

-- | Sets whether toolItem 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.
--   
--   Since: 2.4
toolItemSetHomogeneous :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Bool -> m ()

-- | Sets whether toolItem should be considered important.
--   The ToolButton class uses this property to determine whether to
--   show or hide its label when the toolbar style is
--   ToolbarStyleBothHoriz. The result is that only tool buttons
--   with the “is_important” property set have labels, an effect known as
--   “priority text”
--   
--   Since: 2.4
toolItemSetIsImportant :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Bool -> m ()

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

-- | Sets whether toolItem has a drag window. When
--   True the toolitem can be used as a drag source through
--   widgetDragSourceSet. When toolItem has a drag
--   window it will intercept all events, even those that would otherwise
--   be sent to a child of toolItem.
--   
--   Since: 2.4
toolItemSetUseDragWindow :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Bool -> m ()

-- | Sets whether toolItem 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
--   visibleVertical is False
--   toolItem will not appear on toolbars that are docked
--   vertically.
--   
--   Since: 2.4
toolItemSetVisibleVertical :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Bool -> m ()

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

-- | If menuItemId matches the string passed to
--   toolItemSetProxyMenuItem return the corresponding
--   MenuItem.
--   
--   Custom subclasses of ToolItem should use this function to
--   update their menu item when the ToolItem changes. That the
--   menuItemIds must match ensures that a ToolItem
--   will not inadvertently change a menu item that they did not create.
--   
--   Since: 2.4
toolItemGetProxyMenuItem :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Text -> m (Maybe Widget)

-- | Sets markup as the contents of the tooltip, which is
--   marked up with the [Pango text markup language][PangoMarkupFormat].
--   
--   This function will take care of setting Widget:hasTooltip to
--   True and of the default handler for the
--   Widget::queryTooltip signal.
--   
--   See also the Widget:tooltipMarkup property and
--   tooltipSetMarkup.
--   
--   Since: 2.12
widgetSetTooltipMarkup :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Text -> m ()

-- | Sets text as the contents of the tooltip. This
--   function will take care of setting Widget:hasTooltip to
--   True and of the default handler for the
--   Widget::queryTooltip signal.
--   
--   See also the Widget:tooltipText property and
--   tooltipSetText.
--   
--   Since: 2.12
widgetSetTooltipText :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Text -> m ()

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

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

-- | The “Apply” item and icon.
pattern STOCK_APPLY :: Text

-- | Sets the icon for the tool button from a named themed icon. See the
--   docs for IconTheme for more details. The
--   ToolButton:iconName property only has an effect if not
--   overridden by non-Nothing ToolButton:labelWidget,
--   ToolButton:iconWidget and ToolButton:stockId properties.
--   
--   Since: 2.8
toolButtonSetIconName :: (HasCallStack, MonadIO m, IsToolButton a) => a -> Maybe Text -> m ()

-- | Sets icon as the widget used as icon on
--   button. If iconWidget is
--   Nothing the icon is determined by the ToolButton:stockId
--   property. If the ToolButton:stockId property is also
--   Nothing, button will not have an icon.
--   
--   Since: 2.4
toolButtonSetIconWidget :: (HasCallStack, MonadIO m, IsToolButton a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets labelWidget as the widget that will be used as
--   the label for button. If labelWidget
--   is Nothing the ToolButton:label property is used as
--   label. If ToolButton:label is also Nothing, the label in
--   the stock item determined by the ToolButton:stockId property is
--   used as label. If ToolButton:stockId is also Nothing,
--   button does not have a label.
--   
--   Since: 2.4
toolButtonSetLabelWidget :: (HasCallStack, MonadIO m, IsToolButton a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the name of the stock item. See toolButtonNewFromStock.
--   The stock_id property only has an effect if not overridden by
--   non-Nothing ToolButton:labelWidget and
--   ToolButton:iconWidget properties.
--   
--   Since: 2.4
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
--   useUnderline is True, 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.
--   
--   Since: 2.4
toolButtonSetUseUnderline :: (HasCallStack, MonadIO m, IsToolButton a) => a -> Bool -> m ()

-- | Creates a new ToolButton containing the image and text from a
--   stock item. Some stock ids have preprocessor macros like
--   STOCK_OK and STOCK_APPLY.
--   
--   It is an error if stockId is not a name of a stock
--   item.
--   
--   Since: 2.4
toolButtonNewFromStock :: (HasCallStack, MonadIO m) => Text -> m ToolButton

-- | Memory-managed wrapper type.
newtype ToggleToolButton
ToggleToolButton :: ManagedPtr ToggleToolButton -> ToggleToolButton

-- | Memory-managed wrapper type.
newtype ToggleButton
ToggleButton :: ManagedPtr ToggleButton -> ToggleButton

-- | Creates a new Button widget. To add a child widget to the
--   button, use containerAdd.
buttonNew :: (HasCallStack, MonadIO m) => m Button

-- | Creates a new Label, containing the text in
--   str.
--   
--   If characters in str 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 labelSetMnemonicWidget.
--   
--   If labelSetMnemonicWidget is not called, then the first
--   activatable ancestor of the Label 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

-- | 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, toggleButtonSetInconsistent 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 drawIndicator = False to make the button
--   look like a normal button.
--   
--   This can be used to create linked strip of buttons that work like a
--   StackSwitcher.
--   
--   This function only affects instances of classes like
--   CheckButton and RadioButton that derive from
--   ToggleButton, not instances of ToggleButton itself.
toggleButtonSetMode :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> Bool -> m ()

-- | 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 ToggleAction
ToggleAction :: ManagedPtr ToggleAction -> ToggleAction

-- | Adds an action object to the action group and sets up the accelerator.
--   
--   If accelerator is Nothing, attempts to use the
--   accelerator associated with the stock_id of the action.
--   
--   Accel paths are set to
--   <Actions>/group-name/action-name.
--   
--   Since: 2.4
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
--   styleContextPopAnimatableRegion will potentially show
--   transition animations for this region if
--   styleContextNotifyStateChange is called for a given state, and
--   the current theme/style defines transition animations for state
--   changes.
--   
--   The regionId used must be unique in
--   context so the themes can uniquely identify rendered
--   elements subject to a state transition.
--   
--   Since: 3.0
styleContextPushAnimatableRegion :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Ptr () -> m ()

-- | Memory-managed wrapper type.
newtype ThemingEngine
ThemingEngine :: ManagedPtr ThemingEngine -> ThemingEngine

-- | See also: Entry::deleteFromCursor.
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

-- | Sets buffer as the buffer being displayed by
--   textView. The previous buffer displayed by the text
--   view is unreferenced, and a reference is added to
--   buffer. If you owned a reference to
--   buffer before passing it to this function, you must
--   remove that reference yourself; TextView will not “adopt” it.
textViewSetBuffer :: (HasCallStack, MonadIO m, IsTextView a, IsTextBuffer b) => a -> Maybe b -> m ()

-- | Returns the TextBuffer 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

-- | Creates a new TextView widget displaying the buffer
--   buffer. One buffer can be shared among many widgets.
--   buffer may be Nothing to create a default
--   buffer, in which case this function is equivalent to
--   textViewNew. 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

-- | Creates a new TextView. If you don’t call
--   textViewSetBuffer before using the text view, an empty default
--   buffer will be created for you. Get the buffer with
--   textViewGetBuffer. If you want to specify your own buffer,
--   consider textViewNewWithBuffer.
textViewNew :: (HasCallStack, MonadIO m) => m TextView

-- | Sets the width of TextWindowTypeLeft or
--   TextWindowTypeRight, or the height of TextWindowTypeTop
--   or TextWindowTypeBottom. 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 TextWindowTypeWidget,
--   TextWindowTypeText, or TextWindowTypePrivate.
textViewSetBorderWindowSize :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> Int32 -> m ()

-- | Sets the behavior of the text widget when the Tab key is pressed. If
--   acceptsTab is True, a tab character is
--   inserted. If acceptsTab is False the keyboard
--   focus is moved to the next widget in the focus chain.
--   
--   Since: 2.4
textViewSetAcceptsTab :: (HasCallStack, MonadIO m, IsTextView a) => a -> Bool -> m ()

-- | Converts coordinate (bufferX, bufferY)
--   to coordinates for the window win, and stores the
--   result in (windowX, windowY).
--   
--   Note that you can’t convert coordinates for a nonexisting window (see
--   textViewSetBorderWindowSize).
textViewBufferToWindowCoords :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> Int32 -> Int32 -> m (Int32, Int32)

-- | Converts coordinates on the window identified by win
--   to buffer coordinates, storing the result in
--   (bufferX,bufferY).
--   
--   Note that you can’t convert coordinates for a nonexisting window (see
--   textViewSetBorderWindowSize).
textViewWindowToBufferCoords :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> Int32 -> Int32 -> m (Int32, Int32)

-- | Retrieves the iterator at buffer coordinates x and
--   y. 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 textViewWindowToBufferCoords.
textViewGetIterAtLocation :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> Int32 -> m (Bool, TextIter)

-- | Gets the value set by textViewSetPixelsBelowLines.
--   
--   The line space is the sum of the value returned by this function and
--   the value returned by textViewGetPixelsAboveLines.
textViewGetPixelsBelowLines :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Sets the default number of pixels of blank space to put below
--   paragraphs in textView. May be overridden by tags
--   applied to textView’s buffer.
textViewSetPixelsBelowLines :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Gets the default number of pixels to put above paragraphs. Adding this
--   function with textViewGetPixelsBelowLines is equal to the line
--   space between each paragraph.
textViewGetPixelsAboveLines :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Sets the default number of pixels of blank space to leave between
--   display/wrapped lines within a paragraph. May be overridden by tags in
--   textView’s buffer.
textViewSetPixelsInsideWrap :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Allow an input method to internally handle key press and release
--   events. If this function returns True, then no further
--   processing should be done for this key event.
iMContextFilterKeypress :: (HasCallStack, MonadIO m, IsIMContext a) => a -> EventKey -> m Bool

-- | Adds a child at fixed coordinates in one of the text widget's windows.
--   
--   The window must have nonzero size (see
--   textViewSetBorderWindowSize). Note that the child coordinates
--   are given relative to scrolling. When placing a child in
--   GTK_TEXT_WINDOW_WIDGET, 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 ()

-- | Scrolls textView so that mark is on
--   the screen in the position indicated by xalign and
--   yalign. An alignment of 0.0 indicates left or top, 1.0
--   indicates right or bottom, 0.5 means center. If
--   useAlign is False, 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 withinMargin.
textViewScrollToMark :: (HasCallStack, MonadIO m, IsTextView a, IsTextMark b) => a -> b -> Double -> Bool -> Double -> Double -> m ()

-- | Used to reference the parts of TextView.
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

-- | Moves the given iter 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 TextBuffer.
textViewForwardDisplayLine :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | No description available in the introspection data.
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

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

-- | 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 getLogAttrs)
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

-- | Returns the size of the table (number of tags)
textTagTableGetSize :: (HasCallStack, MonadIO m, IsTextTagTable a) => a -> m Int32

-- | Adds the mark at position where. The mark must not be
--   added to another buffer, and if its name is not Nothing then
--   there must not be another mark in the buffer with the same name.
--   
--   Emits the TextBuffer::markSet signal as notification of the
--   mark's initial placement.
--   
--   Since: 2.12
textBufferAddMark :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextMark b) => a -> b -> TextIter -> m ()

-- | Returns the mark named name in buffer
--   buffer, or Nothing if no such mark exists in
--   the buffer.
textBufferGetMark :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> m (Maybe TextMark)

-- | Deletes mark, 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 objectRef on the mark, it will be freed.
--   Even if the mark isn’t freed, most operations on mark
--   become invalid, until it gets added to a buffer again with
--   textBufferAddMark. Use textMarkGetDeleted to find out if
--   a mark has been removed from its buffer. The
--   TextBuffer::markDeleted 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
--   iter. 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 textBufferGetSlice and
--   textBufferGetText. Consider textBufferCreateChildAnchor
--   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 textChildAnchorNew and inserts it into the buffer with
--   textBufferInsertChildAnchor. The new anchor is owned by the
--   buffer; no reference count is returned to the caller of
--   textBufferCreateChildAnchor.
textBufferCreateChildAnchor :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> m TextChildAnchor

-- | Emits the “remove-tag” signal. The default handler for the signal
--   removes all occurrences of tag from the given range.
--   start and end don’t have to be in
--   order.
textBufferRemoveTag :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextTag b) => a -> b -> TextIter -> TextIter -> m ()

-- | Pastes the contents of a clipboard. If
--   overrideLocation is Nothing, 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 ()

-- | 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 (buffer, FALSE). When the
--   buffer is modified, it will automatically toggled on the modified bit
--   again. When the modified bit flips, the buffer emits the
--   TextBuffer::modifiedChanged signal.
textBufferSetModified :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Bool -> m ()

-- | Creates a mark at position where. If
--   markName is Nothing, the mark is anonymous;
--   otherwise, the mark can be retrieved by name using
--   textBufferGetMark. 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
--   (leftGravity = False), 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
--   TextMark, 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 TextBuffer::markSet signal as notification of the
--   mark's initial placement.
textBufferCreateMark :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Maybe Text -> TextIter -> Bool -> m TextMark

-- | Moves mark to the new location where.
--   Emits the TextBuffer::markSet signal as notification of the
--   move.
textBufferMoveMark :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextMark b) => a -> b -> TextIter -> m ()

-- | Inserts len bytes of text at position
--   iter. If len is -1,
--   text 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. iter 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 ()

-- | Copies text, tags, and pixbufs between start and
--   end (the order of start and
--   end doesn’t matter) and inserts the copy at
--   iter. Used instead of simply getting/inserting text
--   because it preserves images and tags. If start and
--   end are in a different buffer from
--   buffer, 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 ()

-- | Inserts an image into the text buffer at iter. 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
--   textBufferGetSlice and textBufferGetText.
textBufferInsertPixbuf :: (HasCallStack, MonadIO m, IsTextBuffer a, IsPixbuf b) => a -> TextIter -> b -> m ()

-- | Should be paired with a call to textBufferBeginUserAction. See
--   that function for a full explanation.
textBufferEndUserAction :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m ()

-- | Same as textBufferInsertRange, but does nothing if the
--   insertion point isn’t editable. The defaultEditable
--   parameter indicates whether the text is editable at
--   iter if no tags enclosing iter affect
--   editability. Typically the result of textViewGetEditable is
--   appropriate here.
textBufferInsertRangeInteractive :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> TextIter -> Bool -> m Bool

-- | Deletes all editable text in the given range. Calls
--   textBufferDelete for each editable sub-range of
--   [start,end). start and
--   end 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

-- | Performs the appropriate action as if the user hit the delete key with
--   the cursor at the position specified by iter. 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 iter
--   will be re-initialized to point to the location where text was
--   deleted.
--   
--   Since: 2.6
textBufferBackspace :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> Bool -> Bool -> m Bool

-- | Deletes the range between the “insert” and “selection_bound” marks,
--   that is, the currently-selected text. If interactive
--   is True, 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

-- | Deletes text between start and end.
--   The order of start and end is not
--   actually relevant; textBufferDelete 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 start and end
--   will be re-initialized to point to the location where text was
--   deleted.
textBufferDelete :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> m ()

-- | Called to indicate that the buffer operations between here and a call
--   to textBufferEndUserAction are part of a single user-visible
--   operation. The operations between textBufferBeginUserAction and
--   textBufferEndUserAction can then be grouped when creating an
--   undo stack. TextBuffer maintains a count of calls to
--   textBufferBeginUserAction that have not been closed with a call
--   to textBufferEndUserAction, 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
--   textBufferInsertInteractive, 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 ()

-- | Emits the “apply-tag” signal on buffer. The default
--   handler for the signal applies tag to the given range.
--   start and end do not have to be in
--   order.
textBufferApplyTag :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextTag b) => a -> b -> TextIter -> TextIter -> m ()

-- | Look up a named tag.
textTagTableLookup :: (HasCallStack, MonadIO m, IsTextTagTable a) => a -> Text -> m (Maybe TextTag)

-- | Creates a new TextChildAnchor. Usually you would then insert it
--   into a TextBuffer with textBufferInsertChildAnchor. To
--   perform the creation and insertion in one step, use the convenience
--   function textBufferCreateChildAnchor.
textChildAnchorNew :: (HasCallStack, MonadIO m) => m TextChildAnchor

-- | Returns True if the mark has been removed from its buffer with
--   textBufferDeleteMark. See textBufferAddMark for a way to
--   add it to a buffer again.
textMarkGetDeleted :: (HasCallStack, MonadIO m, IsTextMark a) => a -> m Bool

-- | This function registers GTK+’s internal rich text serialization format
--   with the passed buffer. See
--   textBufferRegisterSerializeTagset for details.
--   
--   Since: 2.10
textBufferRegisterDeserializeTagset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Maybe Text -> m Atom

-- | 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 textBufferRegisterDeserializeTagset, 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.
--   
--   Since: 2.10
textBufferDeserializeSetCanCreateTags :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Atom -> Bool -> m ()

-- | These values are used as “info” for the targets contained in the lists
--   returned by textBufferGetCopyTargetList and
--   textBufferGetPasteTargetList.
--   
--   The values counts down from -1 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

-- | Appends the rich text targets registered with
--   textBufferRegisterSerializeFormat or
--   textBufferRegisterDeserializeFormat to the target list. All
--   targets are added with the same info.
--   
--   Since: 2.10
targetListAddRichTextTargets :: (HasCallStack, MonadIO m, IsTextBuffer a) => TargetList -> Word32 -> Bool -> a -> m ()

-- | Initialized iter with the first position in the text
--   buffer. This is the same as using textBufferGetIterAtOffset to
--   get the iter at character offset 0.
textBufferGetStartIter :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextIter

-- | Returns True if some text is selected; places the bounds of the
--   selection in start and end (if the
--   selection has length 0, then start and
--   end are filled in with the same value).
--   start and end will be in ascending
--   order. If start and end 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 registers GTK+’s internal rich text serialization format
--   with the passed buffer. The internal format does not
--   comply to any standard rich text format and only works between
--   TextBuffer instances. It is capable of serializing all of a
--   text buffer’s tags and embedded pixbufs.
--   
--   This function is just a wrapper around
--   textBufferRegisterSerializeFormat. The mime type used for
--   registering is “application/x-gtk-text-buffer-rich-text”, or
--   “application/x-gtk-text-buffer-rich-text;format=tagsetName”
--   if a tagsetName was passed.
--   
--   The tagsetName 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 != Nothing here, since the Nothing tagset
--   requires the receiving buffer to deal with with pasting of arbitrary
--   tags.
--   
--   Since: 2.10
textBufferRegisterSerializeTagset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Maybe Text -> m Atom

-- | Returns the text in the range
--   [start,end). Excludes undisplayed text
--   (text marked with tags that set the invisibility attribute) if
--   includeHiddenChars is False. 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 textBufferGetSlice.
textBufferGetText :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> Bool -> m Text

-- | Returns the text in the range
--   [start,end). Excludes undisplayed text
--   (text marked with tags that set the invisibility attribute) if
--   includeHiddenChars is False. 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 textBufferGetText. 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

-- | Returns the default editability of the TextView. Tags in the
--   buffer may override this setting for some ranges of text.
textViewGetEditable :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Adds clipboard to the list of clipboards in which the
--   selection contents of buffer are available. In most
--   cases, clipboard will be the Clipboard of type
--   GDK_SELECTION_PRIMARY for a view of
--   buffer.
textBufferAddSelectionClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> m ()

-- | Memory-managed wrapper type.
newtype TearoffMenuItem
TearoffMenuItem :: ManagedPtr TearoffMenuItem -> TearoffMenuItem

-- | 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 ()

-- | Adds a widget to a table. The number of “cells” that a widget will
--   occupy is specified by leftAttach,
--   rightAttach, topAttach and
--   bottomAttach. 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
--   
--   
--   gtk_table_attach (table, button,
--                     1, 2, // left, right attach
--                     1, 2, // top, bottom attach
--                     xoptions, yoptions,
--                     xpadding, ypadding);
--   
--   
--   If you want to make the button span the entire bottom row, use
--   leftAttach == 0 and rightAttach = 2
--   instead.
tableAttach :: (HasCallStack, MonadIO m, IsTable a, IsWidget b) => a -> b -> Word32 -> Word32 -> Word32 -> Word32 -> [AttachOptions] -> [AttachOptions] -> Word32 -> Word32 -> m ()

-- | 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

-- | 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 table equal to
--   spacing.
tableSetColSpacings :: (HasCallStack, MonadIO m, IsTable a) => a -> Word32 -> m ()

-- | Sets the space between every row in table equal to
--   spacing.
tableSetRowSpacings :: (HasCallStack, MonadIO m, IsTable a) => a -> Word32 -> 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 underlying state of the Switch.
--   
--   Normally, this is the same as Switch:active, unless the switch
--   is set up for delayed state changes. This function is typically called
--   from a Switch::stateSet signal handler.
--   
--   See Switch::stateSet for details.
--   
--   Since: 3.14
switchSetState :: (HasCallStack, MonadIO m, IsSwitch a) => a -> Bool -> m ()

-- | Memory-managed wrapper type.
newtype Switch
Switch :: ManagedPtr Switch -> Switch

-- | Sets the WidgetPath used for style matching. As a consequence,
--   the style will be regenerated to match the new given path.
--   
--   If you are using a StyleContext returned from
--   widgetGetStyleContext, you do not need to call this yourself.
--   
--   Since: 3.0
styleContextSetPath :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> WidgetPath -> m ()

-- | Adds a global style provider to screen, which will be
--   used in style construction for all GtkStyleContexts
--   under screen.
--   
--   GTK+ uses this to make styling information from Settings
--   available.
--   
--   Note: If both priorities are the same, A StyleProvider added
--   through styleContextAddProvider takes precedence over another
--   added through this function.
--   
--   Since: 3.0
styleContextAddProviderForScreen :: (HasCallStack, MonadIO m, IsScreen a, IsStyleProvider b) => a -> b -> Word32 -> 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
--   styleContextGetBackgroundColor is to use the returned value to
--   draw the background with it; the correct way to achieve this result is
--   to use renderBackground instead, along with CSS style classes
--   to modify the color to be rendered.
--   
--   Since: 3.0
styleContextGetBackgroundColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m RGBA

-- | Renders the background of an element.
--   
--   Typical background rendering, showing the effect of
--   background-image, border-width and
--   border-radius:
--   
--   
--   Since: 3.0
renderBackground :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Gets a style property from context 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
--   Value. 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
--   context is not recommended unless the style context
--   has been saved with styleContextSave.
--   
--   When value is no longer needed, valueUnset must
--   be called to free any allocated memory.
--   
--   Since: 3.0
styleContextGetProperty :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> [StateFlags] -> m GValue

-- | A property holding the rendered element’s border width in pixels as a
--   Border. The border is the intermediary spacing property of the
--   padding/border/margin series.
--   
--   renderFrame uses this property to find out the frame line
--   width, so GtkWidgets 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
--   RGBA.
pattern STYLE_PROPERTY_COLOR :: Text

-- | A property holding the rendered element’s margin as a Border.
--   The margin is defined as the spacing between the border of the element
--   and its surrounding elements. It is external to Widget'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 Border.
--   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

-- | Sets the parent style context for context. The parent
--   style context is used to implement inheritance of properties.
--   
--   If you are using a StyleContext returned from
--   widgetGetStyleContext, the parent will be set for you.
--   
--   Since: 3.4
styleContextSetParent :: (HasCallStack, MonadIO m, IsStyleContext a, IsStyleContext b) => a -> Maybe b -> m ()

-- | Saves the context state, so temporary modifications
--   done through styleContextAddClass,
--   styleContextRemoveClass, styleContextSetState, etc. can
--   quickly be reverted in one go through styleContextRestore.
--   
--   The matching call to styleContextRestore must be done before
--   GTK returns to the main loop.
--   
--   Since: 3.0
styleContextSave :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m ()

-- | Gets the padding for a given state as a Border. See
--   gtk_style_context_get() and
--   STYLE_PROPERTY_PADDING for details.
--   
--   Since: 3.0
styleContextGetPadding :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m Border

-- | Pops an animatable region from context. See
--   styleContextPushAnimatableRegion.
--   
--   Since: 3.0
styleContextPopAnimatableRegion :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m ()

-- | Notifies a state change on context, so if the current
--   style makes use of transition animations, one will be started so all
--   rendered elements under regionId are animated for
--   state state being set to value
--   stateValue.
--   
--   The window 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 regionId is Nothing, all rendered elements
--   using context will be affected by this state
--   transition.
--   
--   As a practical example, a Button notifying a state transition
--   on the prelight state:
--   
--   
--    <!-- language="C" -->
--   gtk_style_context_notify_state_change (context,
--                                          gtk_widget_get_window (widget),
--                                          NULL,
--                                          GTK_STATE_PRELIGHT,
--                                          button->in_button);
--   
--   
--   Can be handled in the CSS file like this:
--   
--   
--    <!-- language="CSS" -->
--   button {
--       background-color: #f00
--   }
--   
--   button:hover {
--       background-color: #fff;
--       transition: 200ms linear
--   }
--   
--   
--   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 state is used when finding the transition
--   parameters, which is why the style places the transition under the
--   :hover pseudo-class.
--   
--   Since: 3.0
styleContextNotifyStateChange :: (HasCallStack, MonadIO m, IsStyleContext a, IsWindow b) => a -> b -> Ptr () -> StateType -> Bool -> m ()

-- | Removes className from context.
--   
--   Since: 3.0
styleContextRemoveClass :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m ()

-- | Sets the state to be used for style matching.
--   
--   Since: 3.0
styleContextSetState :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m ()

-- | Restores context state to a previous stage. See
--   styleContextSave.
--   
--   Since: 3.0
styleContextRestore :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m ()

-- | Adds a style provider to context, to be used in style
--   construction. Note that a style provider added by this function only
--   affects the style of the widget to which context
--   belongs. If you want to affect the style of all widgets, use
--   styleContextAddProviderForScreen.
--   
--   Note: If both priorities are the same, a StyleProvider added
--   through this function takes precedence over another added through
--   styleContextAddProviderForScreen.
--   
--   Since: 3.0
styleContextAddProvider :: (HasCallStack, MonadIO m, IsStyleContext a, IsStyleProvider b) => a -> b -> Word32 -> m ()

-- | The priority used for the style information from
--   XDG_CONFIG_HOME/gtk-3.0/gtk.css.
--   
--   You should not use priorities higher than this, to give the user the
--   last word.
pattern STYLE_PROVIDER_PRIORITY_USER :: Int32

-- | Memory-managed wrapper type.
newtype Statusbar
Statusbar :: ManagedPtr Statusbar -> 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

-- | Forces the removal of a message from a statusbar’s stack. The exact
--   contextId and messageId must be
--   specified.
statusbarRemove :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> Word32 -> Word32 -> m ()

-- | Pushes a new message onto a statusbar’s stack.
statusbarPush :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> Word32 -> Text -> m Word32

-- | The “Quit” item and icon.
pattern STOCK_QUIT :: Text

-- | Adds an icon factory to the list of icon factories searched by
--   styleLookupIconSet. This means that, for example,
--   imageNewFromStock will be able to find icons in
--   factory. 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 iconSet to the icon factory, under the
--   name stockId. stockId should be
--   namespaced for your application, e.g. “myapp-whatever-icon”. Normally
--   applications create a IconFactory, then add it to the list of
--   default factories with iconFactoryAddDefault. Then they pass
--   the stockId to widgets such as Image 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 factory for
--   stockId, it is unreferenced and replaced with the new
--   iconSet.
iconFactoryAdd :: (HasCallStack, MonadIO m, IsIconFactory a) => a -> Text -> IconSet -> m ()

-- | Menu positioning function to use with menuPopup to position
--   menu aligned to the status icon
--   userData.
--   
--   Since: 2.10
statusIconPositionMenu :: (HasCallStack, MonadIO m, IsMenu a, IsStatusIcon b) => a -> Int32 -> Int32 -> b -> m (Int32, Int32, Bool)

-- | Returns whether the status icon is embedded in a notification area.
--   
--   Since: 2.10
statusIconIsEmbedded :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m Bool

-- | Memory-managed wrapper type.
newtype StatusIcon
StatusIcon :: ManagedPtr StatusIcon -> StatusIcon

-- | Describes the image data representation used by a Image. If you
--   want to get the image from the widget, you can only get the
--   currently-stored representation. e.g. if the
--   imageGetStorageType returns GTK_IMAGE_PIXBUF,
--   then you can call imageGetPixbuf but not imageGetStock.
--   For empty images, you can request any storage type (call any of the
--   "get" functions), but they will all return Nothing values.
data ImageType

-- | there is no image displayed by the widget
ImageTypeEmpty :: ImageType

-- | the widget contains a Pixbuf
ImageTypePixbuf :: ImageType

-- | the widget contains a [stock item name][gtkstock]
ImageTypeStock :: ImageType

-- | the widget contains a IconSet
ImageTypeIconSet :: ImageType

-- | the widget contains a PixbufAnimation
ImageTypeAnimation :: ImageType

-- | the widget contains a named icon. This image type was added in GTK+
--   2.6
ImageTypeIconName :: ImageType

-- | the widget contains a Icon. This image type was added in GTK+
--   2.14
ImageTypeGicon :: ImageType

-- | the widget contains a Surface. This image type was added in
--   GTK+ 3.10
ImageTypeSurface :: ImageType

-- | Catch-all for unknown values
AnotherImageType :: Int -> ImageType

-- | Gets the type of representation being used by the StatusIcon to
--   store image data. If the StatusIcon has no image data, the
--   return value will be ImageTypeEmpty.
--   
--   Since: 2.10
statusIconGetStorageType :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m ImageType

-- | 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.
--   
--   Since: 2.18
statusIconSetTitle :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Text -> m ()

-- | Creates a status icon displaying the file filename.
--   
--   The image will be scaled down to fit in the available space in the
--   notification area, if necessary.
--   
--   Since: 2.10
statusIconNewFromFile :: (HasCallStack, MonadIO m) => [Char] -> m StatusIcon

-- | Creates a status icon displaying a Icon. If the icon is a
--   themed icon, it will be updated when the theme changes.
--   
--   Since: 2.14
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.
--   
--   Since: 2.10
statusIconNewFromIconName :: (HasCallStack, MonadIO m) => Text -> m StatusIcon

-- | Creates a status icon displaying pixbuf.
--   
--   The image will be scaled down to fit in the available space in the
--   notification area, if necessary.
--   
--   Since: 2.10
statusIconNewFromPixbuf :: (HasCallStack, MonadIO m, IsPixbuf a) => a -> m StatusIcon

-- | Creates a status icon displaying a stock icon. Sample stock icon names
--   are STOCK_OPEN, STOCK_QUIT. You can register your own
--   stock icon names, see iconFactoryAddDefault and
--   iconFactoryAdd.
--   
--   Since: 2.10
statusIconNewFromStock :: (HasCallStack, MonadIO m) => Text -> m StatusIcon

-- | Sets the stack to control.
--   
--   Since: 3.10
stackSwitcherSetStack :: (HasCallStack, MonadIO m, IsStackSwitcher a, IsStack b) => a -> Maybe b -> m ()

-- | Set the Stack associated with this StackSidebar.
--   
--   The sidebar widget will automatically update according to the order
--   (packing) and items within the given Stack.
--   
--   Since: 3.16
stackSidebarSetStack :: (HasCallStack, MonadIO m, IsStackSidebar a, IsStack b) => a -> b -> m ()

-- | Memory-managed wrapper type.
newtype StackSidebar
StackSidebar :: ManagedPtr StackSidebar -> StackSidebar

-- | Sets the Stack to be horizontally homogeneous or not. If it is
--   homogeneous, the Stack will request the same width for all its
--   children. If it isn't, the stack may change width when a different
--   child becomes visible.
--   
--   Since: 3.16
stackSetHhomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> Bool -> m ()

-- | Sets the Stack to be homogeneous or not. If it is homogeneous,
--   the Stack 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 Stack:hhomogeneous and
--   Stack:vhomogeneous.
--   
--   Since: 3.10
stackSetHomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> Bool -> m ()

-- | Sets the Stack to be vertically homogeneous or not. If it is
--   homogeneous, the Stack will request the same height for all its
--   children. If it isn't, the stack may change height when a different
--   child becomes visible.
--   
--   Since: 3.16
stackSetVhomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> Bool -> m ()

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

-- | Retrieves the contents of the entry widget. See also
--   editableGetChars.
--   
--   This is equivalent to getting entry's
--   EntryBuffer and calling entryBufferGetText on it.
entryGetText :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Text

-- | Set the precision to be displayed by spinButton. 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
--   spinButton.
--   
--   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 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 ()

-- | Constant to return from a signal handler for the
--   SpinButton::input signal in case of conversion failure.
pattern INPUT_ERROR :: Int32

-- | 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 spinButtonSetUpdatePolicy.
data SpinButtonUpdatePolicy

-- | When refreshing your SpinButton, the value is always displayed
SpinButtonUpdatePolicyAlways :: SpinButtonUpdatePolicy

-- | When refreshing your SpinButton, 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 spinButtonSpin.
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

-- | Gets the window ID of a Plug widget, which can then be used to
--   embed this window inside another window, for instance with
--   socketAddId.
plugGetId :: (HasCallStack, MonadIO m, IsPlug a) => a -> m CULong

-- | Adds an XEMBED client, such as a Plug, to the Socket.
--   The client may be in the same process or in a different process.
--   
--   To embed a Plug in a Socket, you can either create the
--   Plug with gtk_plug_new (0), call plugGetId to
--   get the window ID of the plug, and then pass that to the
--   socketAddId, or you can call socketGetId to get the
--   window ID for the socket, and call plugNew passing in that ID.
--   
--   The Socket must have already be added into a toplevel window
--   before you can make this call.
socketAddId :: (HasCallStack, MonadIO m, IsSocket a) => a -> CULong -> m ()

-- | Gets the window ID of a Socket widget, which can then be used
--   to create a client embedded inside the socket, for instance with
--   plugNew.
--   
--   The Socket must have already be added into a toplevel window
--   before you can make this call.
socketGetId :: (HasCallStack, MonadIO m, IsSocket a) => a -> m CULong

-- | Creates a new plug widget inside the Socket identified by
--   socketId. If socketId is 0, the plug
--   is left “unplugged” and can later be plugged into a Socket by
--   socketAddId.
plugNew :: (HasCallStack, MonadIO m) => CULong -> m Plug

-- | Sets the SizeGroupMode 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 (SizeGroupModeHorizontal) all
--   have the same vertical requisition (SizeGroupModeVertical), or
--   should all have the same requisition in both directions
--   (SizeGroupModeBoth).
sizeGroupSetMode :: (HasCallStack, MonadIO m, IsSizeGroup a) => a -> SizeGroupMode -> m ()

-- | 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 ShortcutLabel
ShortcutLabel :: ManagedPtr ShortcutLabel -> ShortcutLabel

-- | Gets the Settings object for screen, creating
--   it if necessary.
--   
--   Since: 2.2
settingsGetForScreen :: (HasCallStack, MonadIO m, IsScreen a) => a -> m Settings

-- | Memory-managed wrapper type.
newtype SeparatorToolItem
SeparatorToolItem :: ManagedPtr SeparatorToolItem -> SeparatorToolItem

-- | Whether item is drawn as a vertical line, or just
--   blank. Setting this to False along with
--   toolItemSetExpand is useful to create an item that forces
--   following items to the end of the toolbar.
--   
--   Since: 2.4
separatorToolItemSetDraw :: (HasCallStack, MonadIO m, IsSeparatorToolItem a) => a -> Bool -> m ()

-- | Memory-managed wrapper type.
newtype SeparatorMenuItem
SeparatorMenuItem :: ManagedPtr SeparatorMenuItem -> SeparatorMenuItem

-- | Memory-managed wrapper type.
newtype SearchEntry
SearchEntry :: ManagedPtr SearchEntry -> SearchEntry

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

-- | 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 EVENT_STOP will
--   be returned. The caller should ensure that events are not propagated
--   further.
--   
--   If no entry has been connected to the search bar, using
--   searchBarConnectEntry, this function will return immediately
--   with a warning.
--   
--   
Showing the search bar on key presses
--   
--   
C code
--   
--   
--   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);
--   }
--   
--   
--   Since: 3.10
searchBarHandleEvent :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> Event -> m Bool

-- | Connects the Entry 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).
--   
--   Since: 3.10
searchBarConnectEntry :: (HasCallStack, MonadIO m, IsSearchBar a, IsEntry b) => a -> b -> m ()

-- | Adds widget to container. Typically
--   used for simple containers such as Window, Frame, or
--   Button; for more complicated layout containers such as
--   Box or Grid, this function will pick default packing
--   parameters that may not be correct. So consider functions such as
--   boxPackStart and gridAttach as an alternative to
--   containerAdd 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 ScrolledWindow or
--   ListBox, may add intermediate children between the added widget
--   and the container.
containerAdd :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> b -> m ()

-- | Changes the behaviour of scrolledWindow with regard to
--   the initial event that possibly starts kinetic scrolling. When
--   captureButtonPress is set to True, 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 Widget::buttonPressEvent. If they don't, and handle
--   additionally handle Widget::grabBrokenEvent, it might be better
--   to set captureButtonPress to False.
--   
--   This setting only has an effect if kinetic scrolling is enabled.
--   
--   Since: 3.4
scrolledWindowSetCaptureButtonPress :: (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 CornerTypeTopLeft, meaning the child is in the
--   top left, with the scrollbars underneath and to the right. Other
--   values in CornerType are CornerTypeTopRight,
--   CornerTypeBottomLeft, and CornerTypeBottomRight.
--   
--   See also scrolledWindowGetPlacement and
--   scrolledWindowUnsetPlacement.
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 PolicyType enumeration. If PolicyTypeAlways,
--   the scrollbar is always present; if PolicyTypeNever, the
--   scrollbar is never present; if PolicyTypeAutomatic, 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 ()

-- | Changes the type of shadow drawn around the contents of
--   scrolledWindow.
scrolledWindowSetShadowType :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> ShadowType -> m ()

-- | Specifies which corner a child widget should be placed in when packed
--   into a ScrolledWindow. 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

-- | Gets the placement of the contents with respect to the scrollbars for
--   the scrolled window. See scrolledWindowSetPlacement.
scrolledWindowGetPlacement :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m CornerType

-- | 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 CornerTypeTopLeft.
--   
--   See also scrolledWindowSetPlacement and
--   scrolledWindowGetPlacement.
--   
--   Since: 2.10
scrolledWindowUnsetPlacement :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m ()

-- | 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 TreeView 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

-- | Get the Adjustment which is the “model” object for
--   Range. See rangeSetAdjustment 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 Scale and nonzero for Scrollbar, 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 the icons to be used by the scale button. For details, see the
--   ScaleButton:icons property.
--   
--   Since: 2.12
scaleButtonSetIcons :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> [Text] -> m ()

-- | Removes any marks that have been added with scaleAddMark.
--   
--   Since: 2.16
scaleClearMarks :: (HasCallStack, MonadIO m, IsScale a) => a -> m ()

-- | Adds a mark at value.
--   
--   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 markup is not Nothing, text is shown next to
--   the tick mark.
--   
--   To remove marks from a scale, use scaleClearMarks.
--   
--   Since: 2.16
scaleAddMark :: (HasCallStack, MonadIO m, IsScale a) => a -> Double -> PositionType -> Maybe Text -> m ()

-- | Describes which edge of a widget a certain feature is positioned at,
--   e.g. the tabs of a Notebook, the handle of a HandleBox
--   or the label of a Scale.
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

-- | Tells the Revealer to reveal or conceal its child.
--   
--   The transition will be animated with the current transition type of
--   revealer.
--   
--   Since: 3.10
revealerSetRevealChild :: (HasCallStack, MonadIO m, IsRevealer a) => a -> Bool -> m ()

-- | Returns whether the child is fully revealed, in other words whether
--   the transition to the revealed state is completed.
--   
--   Since: 3.10
revealerGetChildRevealed :: (HasCallStack, MonadIO m, IsRevealer a) => a -> m Bool

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

-- | Adds a rule that allows resources based on a pattern matching their
--   display name.
--   
--   Since: 2.10
recentFilterAddPattern :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> Text -> m ()

-- | Adds a rule that allows resources based on their registered MIME type.
--   
--   Since: 2.10
recentFilterAddMimeType :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> Text -> m ()

-- | Adds a rule that allows resources based on the name of the application
--   that has registered them.
--   
--   Since: 2.10
recentFilterAddApplication :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> Text -> m ()

-- | Adds a rule that allows resources based on their age - that is, the
--   number of days elapsed since they were last modified.
--   
--   Since: 2.10
recentFilterAddAge :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> Int32 -> m ()

-- | Gets the fields that need to be filled in for the
--   RecentFilterInfo passed to recentFilterFilter
--   
--   This function will not typically be used by applications; it is
--   intended principally for use in the implementation of
--   RecentChooser.
--   
--   Since: 2.10
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.
--   
--   Since: 2.10
recentFilterSetName :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> Text -> m ()

-- | Tests whether a file should be displayed according to
--   filter. The RecentFilterInfo
--   filterInfo should include the fields returned from
--   recentFilterGetNeeded, and must set the
--   RecentFilterInfo.contains field of
--   filterInfo 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
--   RecentChooser.
--   
--   Since: 2.10
recentFilterFilter :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> RecentFilterInfo -> m Bool

-- | Memory-managed wrapper type.
newtype RecentChooserWidget
RecentChooserWidget :: ManagedPtr RecentChooserWidget -> RecentChooserWidget

-- | Memory-managed wrapper type.
newtype RecentChooserMenu
RecentChooserMenu :: ManagedPtr RecentChooserMenu -> RecentChooserMenu

-- | Creates a new RecentChooserMenu widget using
--   manager 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 RecentManager object or if
--   you wish to share a common RecentManager object among multiple
--   RecentChooser widgets.
--   
--   Since: 2.10
recentChooserMenuNewForManager :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> m RecentChooserMenu

-- | Sets whether a number should be added to the items of
--   menu. 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.
--   
--   Since: 2.10
recentChooserMenuSetShowNumbers :: (HasCallStack, MonadIO m, IsRecentChooserMenu a) => a -> Bool -> m ()

-- | Memory-managed wrapper type.
newtype RecentAction
RecentAction :: ManagedPtr RecentAction -> RecentAction

-- | Memory-managed wrapper type.
newtype Range
Range :: ManagedPtr Range -> Range

-- | If a range is flippable, it will switch its direction if it is
--   horizontal and its direction is TextDirectionRtl.
--   
--   See widgetGetDirection.
--   
--   Since: 2.18
rangeSetFlippable :: (HasCallStack, MonadIO m, IsRange a) => a -> Bool -> 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 minimum size of the range’s slider.
--   
--   This function is useful mainly for Range subclasses.
--   
--   Since: 2.20
rangeSetMinSliderSize :: (HasCallStack, MonadIO m, IsRange a) => a -> Int32 -> 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 Range subclasses.
--   
--   Since: 2.20
rangeSetSliderSizeFixed :: (HasCallStack, MonadIO m, IsRange a) => a -> Bool -> m ()

-- | Sets whether a graphical fill level is show on the trough. See
--   rangeSetFillLevel for a general description of the fill level
--   concept.
--   
--   Since: 2.12
rangeSetShowFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> Bool -> m ()

-- | Sets whether the slider is restricted to the fill level. See
--   rangeSetFillLevel for a general description of the fill level
--   concept.
--   
--   Since: 2.12
rangeSetRestrictToFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> Bool -> m ()

-- | Gets the reading direction for a particular widget. See
--   widgetSetDirection.
widgetGetDirection :: (HasCallStack, MonadIO m, IsWidget a) => a -> m TextDirection

-- | 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 rangeSetShowFillLevel. 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
--   rangeSetRestrictToFillLevel and is by default enabled.
--   
--   Since: 2.12
rangeSetFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> Double -> m ()

-- | Memory-managed wrapper type.
newtype RadioToolButton
RadioToolButton :: ManagedPtr RadioToolButton -> RadioToolButton

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

-- | Returns the group to which the radio menu item belongs, as a
--   List of RadioMenuItem. The list belongs to GTK+ and
--   should not be freed.
radioMenuItemGetGroup :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => a -> m [RadioMenuItem]

-- | Sets the group of a radio menu item, or changes it.
radioMenuItemSetGroup :: (HasCallStack, MonadIO m, IsRadioMenuItem a, IsRadioMenuItem b) => a -> [b] -> m ()

-- | Creates a new RadioButton. 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

-- | Retrieves the group assigned to a radio button.
radioButtonGetGroup :: (HasCallStack, MonadIO m, IsRadioButton a) => a -> m [RadioButton]

-- | Sets a RadioButton’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 ()

-- | Memory-managed wrapper type.
newtype RadioAction
RadioAction :: ManagedPtr RadioAction -> RadioAction

-- | 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:
--   
--   
C code
--   
--   
--   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);
--     }
--   
--   
--   Since: 2.4
radioActionGetGroup :: (HasCallStack, MonadIO m, IsRadioAction a) => a -> m [RadioAction]

-- | Sets the radio group for the radio action object.
--   
--   Since: 2.4
radioActionSetGroup :: (HasCallStack, MonadIO m, IsRadioAction a, IsRadioAction b) => a -> [b] -> m ()

-- | Obtains the value property of the currently active member of the group
--   to which action belongs.
--   
--   Since: 2.4
radioActionGetCurrentValue :: (HasCallStack, MonadIO m, IsRadioAction a) => a -> m Int32

-- | Memory-managed wrapper type.
newtype ProgressBar
ProgressBar :: ManagedPtr ProgressBar -> ProgressBar

-- | Sets the mode used to ellipsize (add an ellipsis: "...") the text if
--   there is not enough space to render the entire string.
--   
--   Since: 2.6
progressBarSetEllipsize :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> EllipsizeMode -> 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 progressBarPulse.
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 ProgressBar:text property
--   or, if that is Nothing, the ProgressBar:fraction 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
--   ProgressBar:showText to True and ProgressBar:text
--   to the empty string (not Nothing).
--   
--   Since: 3.0
progressBarSetShowText :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> Bool -> m ()

-- | 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 progressBarPulse causes
--   the block to move by a little bit (the amount of movement per pulse is
--   determined by progressBarSetPulseStep).
progressBarPulse :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m ()

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

-- | This function saves the print settings from settings
--   to fileName. If the file could not be loaded then
--   error is set to either a FileError or KeyFileError.
--   
--   Since: 2.12
printSettingsToFile :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> [Char] -> m ()

-- | Serialize print settings to an a{sv} variant.
--   
--   Since: 3.22
printSettingsToGvariant :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m GVariant

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_COLLATE :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_DEFAULT_SOURCE :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_DITHER :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_DUPLEX :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_FINISHINGS :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_MEDIA_TYPE :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_N_COPIES :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_NUMBER_UP :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_NUMBER_UP_LAYOUT :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_ORIENTATION :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_OUTPUT_BIN :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_PAGE_RANGES :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_PAGE_SET :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_PAPER_HEIGHT :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_PAPER_FORMAT :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_PAPER_WIDTH :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_PRINT_PAGES :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_PRINTER :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_PRINTER_LPI :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_QUALITY :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_RESOLUTION :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_RESOLUTION_X :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_RESOLUTION_Y :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_REVERSE :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_SCALE :: Text

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_USE_COLOR :: Text

-- | See also printSettingsSetDuplex.
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 gtk_print_job_set_page_set().
data PageSet

-- | All pages.
PageSetAll :: PageSet

-- | Even pages.
PageSetEven :: PageSet

-- | Odd pages.
PageSetOdd :: PageSet

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

-- | See also gtk_print_job_set_pages()
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 printSettingsSetQuality.
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

-- | Returns the status of the print operation. Also see
--   printOperationGetStatusString.
--   
--   Since: 2.10
printOperationGetStatus :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m PrintStatus

-- | Returns whether the given page is included in the set of pages that
--   have been selected for printing.
--   
--   Since: 2.10
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 PrintOperation::preview handler together with
--   preview.
--   
--   A custom iprint preview should use this function in its expose
--   handler to render the currently selected page.
--   
--   Note that this function requires a suitable cairo context to be
--   associated with the print context.
--   
--   Since: 2.10
printOperationPreviewRenderPage :: (HasCallStack, MonadIO m, IsPrintOperationPreview a) => a -> Int32 -> m ()

-- | Ends a preview.
--   
--   This function must be called to finish a custom print preview.
--   
--   Since: 2.10
printOperationPreviewEndPreview :: (HasCallStack, MonadIO m, IsPrintOperationPreview a) => a -> 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 PrintOperation::beginPrint signal hander.
--   
--   Note that the page numbers passed to the
--   PrintOperation::requestPageSetup and
--   PrintOperation::drawPage signals are 0-based, i.e. if the user
--   chooses to print all pages, the last drawPage signal will be
--   for page nPages - 1.
--   
--   Since: 2.10
printOperationSetNPages :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Int32 -> m ()

-- | Obtains the cairo context that is associated with the
--   PrintContext.
--   
--   Since: 2.10
printContextGetCairoContext :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Context

-- | If fullPage is True, the transformation for the
--   cairo context obtained from PrintContext 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).
--   
--   Since: 2.10
printOperationSetUseFullPage :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Sets up the transformation for the cairo context obtained from
--   PrintContext in such a way that distances are measured in units
--   of unit.
--   
--   Since: 2.10
printOperationSetUnit :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Unit -> m ()

-- | A value of this type is returned by printOperationRun.
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

-- | Call this when the result of a print operation is
--   PrintOperationResultError, either as returned by
--   printOperationRun, or in the PrintOperation::done signal
--   handler. The returned GError will contain more details on what
--   went wrong.
--   
--   Since: 2.10
printOperationGetError :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m ()

-- | A convenience function to find out if the print operation is finished,
--   either successfully (PrintStatusFinished) or unsuccessfully
--   (PrintStatusFinishedAborted).
--   
--   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.
--   
--   Since: 2.10
printOperationIsFinished :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Bool

-- | Memory-managed wrapper type.
newtype PrintOperation
PrintOperation :: ManagedPtr PrintOperation -> PrintOperation

-- | Sets up the PrintOperation to wait for calling of
--   printOperationDrawPageFinish from application. It can be used
--   for drawing page in another thread.
--   
--   This function must be called in the callback of “draw-page” signal.
--   
--   Since: 2.16
printOperationSetDeferDrawing :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m ()

-- | Makes defaultPageSetup the default page setup for
--   op.
--   
--   This page setup will be used by printOperationRun, but it can
--   be overridden on a per-page basis by connecting to the
--   PrintOperation::requestPageSetup signal.
--   
--   Since: 2.10
printOperationSetDefaultPageSetup :: (HasCallStack, MonadIO m, IsPrintOperation a, IsPageSetup b) => a -> Maybe b -> m ()

-- | Returns the number of pages that will be printed.
--   
--   Note that this value is set during print preparation phase
--   (PrintStatusPreparing), so this function should never be called
--   before the data generation phase (PrintStatusGeneratingData).
--   You can connect to the PrintOperation::statusChanged signal and
--   call printOperationGetNPagesToPrint when print status is
--   PrintStatusGeneratingData. This is typically used to track the
--   progress of print operation.
--   
--   Since: 2.18
printOperationGetNPagesToPrint :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Int32

-- | Sets the print settings for op. This is typically used
--   to re-establish print settings from a previous print operation, see
--   printOperationRun.
--   
--   Since: 2.10
printOperationSetPrintSettings :: (HasCallStack, MonadIO m, IsPrintOperation a, IsPrintSettings b) => a -> Maybe b -> m ()

-- | 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 Statusbar.
--   
--   Use printOperationGetStatus to obtain a status value that is
--   suitable for programmatic use.
--   
--   Since: 2.10
printOperationGetStatusString :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Text

-- | Sets whether the printOperationRun may return before the print
--   operation is completed. Note that some platforms may not allow
--   asynchronous operation.
--   
--   Since: 2.10
printOperationSetAllowAsync :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Signalize that drawing of particular page is complete.
--   
--   It is called after completion of page drawing (e.g. drawing in another
--   thread). If printOperationSetDeferDrawing was called before,
--   then this function has to be called by application. In another case it
--   is called by the library itself.
--   
--   Since: 2.16
printOperationDrawPageFinish :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m ()

-- | Returns the current print settings.
--   
--   Note that the return value is Nothing until either
--   printOperationSetPrintSettings or printOperationRun have
--   been called.
--   
--   Since: 2.10
printOperationGetPrintSettings :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m PrintSettings

-- | Memory-managed wrapper type.
newtype PopoverMenu
PopoverMenu :: ManagedPtr PopoverMenu -> PopoverMenu

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

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

-- | Inserts group into widget. Children of
--   widget that implement Actionable can then be
--   associated with actions in group by setting their
--   “action-name” to prefix.action-name.
--   
--   If group is Nothing, a previously inserted
--   group for name is removed from widget.
--   
--   Since: 3.6
widgetInsertActionGroup :: (HasCallStack, MonadIO m, IsWidget a, IsActionGroup b) => a -> Text -> Maybe b -> m ()

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

-- | Sets a constraint for positioning this popover.
--   
--   Note that not all platforms support placing popovers freely, and may
--   already impose constraints.
--   
--   Since: 3.20
popoverSetConstrainTo :: (HasCallStack, MonadIO m, IsPopover a) => a -> PopoverConstraint -> m ()

-- | Sets a new widget to be attached to popover. If
--   popover is visible, the position will be updated.
--   
--   Note: the ownership of popovers is always given to their
--   relativeTo widget, so if relativeTo is
--   set to Nothing on an attached popover, it will
--   be detached from its previous widget, and consequently destroyed
--   unless extra references are kept.
--   
--   Since: 3.12
popoverSetRelativeTo :: (HasCallStack, MonadIO m, IsPopover a, IsWidget b) => a -> Maybe b -> m ()

-- | Gets the currently selected location in the sidebar.
--   This can be Nothing when nothing is selected, for example, when
--   placesSidebarSetLocation 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
--   sidebar. Also, if you connect to the
--   PlacesSidebar::populatePopup signal, you can use this function
--   to get the location that is being referred to during the callbacks for
--   your menu items.
--   
--   Since: 3.10
placesSidebarGetLocation :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m (Maybe File)

-- | Sets whether the sidebar should only show local files.
--   
--   Since: 3.12
placesSidebarSetLocalOnly :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | Sets the location that is being shown in the widgets surrounding the
--   sidebar, for example, in a folder view in a file
--   manager. In turn, the sidebar will highlight that
--   location if it is being shown in the list of places, or it will
--   unhighlight everything if the location is not among
--   the places in the list.
--   
--   Since: 3.10
placesSidebarSetLocation :: (HasCallStack, MonadIO m, IsPlacesSidebar a, IsFile b) => a -> Maybe b -> m ()

-- | Sets whether the sidebar 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
--   PlacesSidebar::showConnectToServer signal.
--   
--   Since: 3.10
placesSidebarSetShowConnectToServer :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | Sets whether the sidebar 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.
--   
--   Since: 3.10
placesSidebarSetShowDesktop :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | Sets whether the sidebar 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
--   PlacesSidebar::showEnterLocation signal.
--   
--   Since: 3.14
placesSidebarSetShowEnterLocation :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | Sets whether the sidebar should show an item for the
--   application to show an Other Locations view; this is off by default.
--   When set to True, 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
--   PlacesSidebar::showOtherLocations signal.
--   
--   Since: 3.18
placesSidebarSetShowOtherLocations :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | Sets whether the sidebar 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.
--   
--   Since: 3.18
placesSidebarSetShowRecent :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | If you enable this, you should connect to the
--   PlacesSidebar::showStarredLocation signal.
--   
--   Since: 3.22.26
placesSidebarSetShowStarredLocation :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | Sets whether the sidebar should show an item for the
--   Trash location.
--   
--   Since: 3.18
placesSidebarSetShowTrash :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | 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 location 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.
--   
--   Since: 3.10
placesSidebarAddShortcut :: (HasCallStack, MonadIO m, IsPlacesSidebar a, IsFile b) => a -> b -> m ()

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

-- | These flags serve two purposes. First, the application can call
--   placesSidebarSetOpenFlags 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 PlacesSidebar::openLocation 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 placesSidebarSetOpenFlags, then
--   the sidebar will only use GTK_PLACES_OPEN_NORMAL in
--   the PlacesSidebar::openLocation signal. This is the default
--   mode of operation.
data PlacesOpenFlags

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

-- | Similar to gTKPLACESOPENNEWTAB, 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 PadController
PadController :: ManagedPtr PadController -> PadController

-- | This is a convenience function to add a group of action entries on
--   controller. See PadActionEntry and
--   padControllerSetAction.
--   
--   Since: 3.22
padControllerSetActionEntries :: (HasCallStack, MonadIO m, IsPadController a) => a -> [PadActionEntry] -> m ()

-- | Adds an individual action to controller. This action
--   will only be activated if the given button/ring/strip number in
--   index is interacted while the current mode is
--   mode. -1 may be used for simple cases, so the action
--   is triggered on all modes.
--   
--   The given label should be considered user-visible, so
--   internationalization rules apply. Some windowing systems may be able
--   to use those for user feedback.
--   
--   Since: 3.22
padControllerSetAction :: (HasCallStack, MonadIO m, IsPadController a) => a -> PadActionType -> Int32 -> Int32 -> Text -> Text -> m ()

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

-- | Memory-managed wrapper type.
newtype Overlay
Overlay :: ManagedPtr Overlay -> Overlay

-- | Memory-managed wrapper type.
newtype OffscreenWindow
OffscreenWindow :: ManagedPtr OffscreenWindow -> OffscreenWindow

-- | Updates the icon to use icon as the base background
--   image. If icon is Nothing, self
--   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, icon will be used, i.e. the
--   last method called between numerableIconSetBackgroundGicon and
--   numerableIconSetBackgroundIconName has always priority.
--   
--   Since: 3.0
numerableIconSetBackgroundGicon :: (HasCallStack, MonadIO m, IsNumerableIcon a, IsIcon b) => a -> Maybe b -> m ()

-- | Updates the icon to use the icon named iconName from
--   the current icon theme as the base background image. If
--   iconName is Nothing, self will
--   go back using style information or default theming for its background
--   image.
--   
--   If this method is called and a Icon was already set as
--   background for the icon, iconName will be used, i.e.
--   the last method called between
--   numerableIconSetBackgroundIconName and
--   numerableIconSetBackgroundGicon has always priority.
--   
--   Since: 3.0
numerableIconSetBackgroundIconName :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> Maybe Text -> m ()

-- | Sets the currently displayed value of self to
--   count.
--   
--   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 Nothing before rendering the
--   number, i.e. the last method called between
--   numerableIconSetCount and numerableIconSetLabel has
--   always priority.
--   
--   Since: 3.0
numerableIconSetCount :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> Int32 -> m ()

-- | Sets the currently displayed value of self to the
--   string in label. 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 numerableIconSetLabel and
--   numerableIconSetCount has always priority.
--   
--   Since: 3.0
numerableIconSetLabel :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> Maybe Text -> m ()

-- | Memory-managed wrapper type.
newtype NumerableIcon
NumerableIcon :: ManagedPtr NumerableIcon -> NumerableIcon

-- | Updates the icon to fetch theme information from the given
--   StyleContext.
--   
--   Since: 3.0
numerableIconSetStyleContext :: (HasCallStack, MonadIO m, IsNumerableIcon a, IsStyleContext b) => a -> b -> m ()

-- | Sets widget 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 Box 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 containerForeach.
--   
--   Since: 2.20
notebookSetActionWidget :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> PackType -> 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
--   notebookSetShowTabs.
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 a group name for notebook.
--   
--   Notebooks with the same name will be able to exchange tabs via drag
--   and drop. A notebook with a Nothing group name will not be able
--   to exchange tabs with any other notebook.
--   
--   Since: 2.24
notebookSetGroupName :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Maybe Text -> m ()

-- | Removes the child from the notebook.
--   
--   This function is very similar to containerRemove, but
--   additionally informs the notebook that the removal is happening as
--   part of a tab DND operation, which should not be cancelled.
--   
--   Since: 3.16
notebookDetachTab :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m ()

-- | Hides the dialog if it is visilbe, aborting any interaction. Once this
--   is called the NativeDialog::response signal will not be emitted
--   until after the next call to nativeDialogShow.
--   
--   If the dialog is not visible this does nothing.
--   
--   Since: 3.20
nativeDialogHide :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m ()

-- | Memory-managed wrapper type.
newtype NativeDialog
NativeDialog :: ManagedPtr NativeDialog -> NativeDialog

-- | 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
--   nativeDialogSetTransientFor to make the dialog transient for
--   the parent; most [window managers][gtk-X11-arch] will then disallow
--   lowering the dialog below the parent.
--   
--   Since: 3.20
nativeDialogSetModal :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> Bool -> 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 Nothing for parent unsets the current
--   transient window.
--   
--   Since: 3.20
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 NativeDialog::response signal will
--   be emitted.
--   
--   Multiple calls while the dialog is visible will be ignored.
--   
--   Since: 3.20
nativeDialogShow :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m ()

-- | Blocks in a recursive main loop until self emits the
--   NativeDialog::response signal. It then returns the response ID
--   from the response signal emission.
--   
--   Before entering the recursive main loop, nativeDialogRun calls
--   nativeDialogShow on the dialog for you.
--   
--   After nativeDialogRun returns, then dialog will be hidden.
--   
--   Typical usage of this function might be:
--   
--   
C code
--   
--   
--   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);
--   
--   
--   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 nativeDialogRun call.
--   
--   Since: 3.20
nativeDialogRun :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m 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 ()

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

-- | Returns the content area of dialog.
--   
--   Since: 2.14
dialogGetContentArea :: (HasCallStack, MonadIO m, IsDialog a) => a -> m Box

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

-- | Memory-managed wrapper type.
newtype MessageDialog
MessageDialog :: ManagedPtr MessageDialog -> MessageDialog

-- | Sets the Menu that is popped up when the user clicks on the
--   arrow. If menu is NULL, the arrow button becomes
--   insensitive.
--   
--   Since: 2.6
menuToolButtonSetMenu :: (HasCallStack, MonadIO m, IsMenuToolButton a, IsWidget b) => a -> b -> m ()

-- | Memory-managed wrapper type.
newtype MenuToolButton
MenuToolButton :: ManagedPtr MenuToolButton -> MenuToolButton

-- | Sets the text to be displayed as tooltip on the item. See
--   widgetSetTooltipText.
--   
--   Since: 2.12
toolItemSetTooltipText :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Text -> m ()

-- | Creates a Menu and populates it with menu items and submenus
--   according to model.
--   
--   The created menu items are connected to actions found in the
--   ApplicationWindow to which the menu belongs - typically by
--   means of being attached to a widget (see menuAttachToWidget)
--   that is contained within the GtkApplicationWindows
--   widget hierarchy.
--   
--   Actions can also be added using widgetInsertActionGroup on the
--   menu's attach widget or on any of its parent widgets.
--   
--   Since: 3.4
menuNewFromModel :: (HasCallStack, MonadIO m, IsMenuModel a) => a -> m Menu

-- | Creates a new MenuBar and populates it with menu items and
--   submenus according to model.
--   
--   The created menu items are connected to actions found in the
--   ApplicationWindow to which the menu bar belongs - typically by
--   means of being contained within the
--   GtkApplicationWindows widget hierarchy.
--   
--   Since: 3.4
menuBarNewFromModel :: (HasCallStack, MonadIO m, IsMenuModel a) => a -> m MenuBar

-- | Sets or unsets the application menu for application.
--   
--   This can only be done in the primary instance of the application,
--   after it has been registered. Application::startup 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 ActionMap interface to add actions, to respond to
--   the user selecting these menu items.
--   
--   Since: 3.4
applicationSetAppMenu :: (HasCallStack, MonadIO m, IsApplication a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Sets or unsets the menubar for windows of application.
--   
--   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. Application::startup 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 ActionMap interface to add actions, to respond to
--   the user selecting these menu items.
--   
--   Since: 3.4
applicationSetMenubar :: (HasCallStack, MonadIO m, IsApplication a, IsMenuModel b) => a -> Maybe b -> m ()

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

-- | Sets or replaces the menu item’s submenu, or removes it when a
--   Nothing submenu is passed.
menuItemSetSubmenu :: (HasCallStack, MonadIO m, IsMenuItem a, IsMenu 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 menuItemSetAccelPath on each
--   menu item that should support runtime user changable accelerators.
--   Instead, by just calling menuSetAccelPath 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 gtk_menu_set_accel_path (menu,
--   "<Gnumeric-Sheet>/File"); has been called, assign its items
--   the accel paths: "<Gnumeric-Sheet>/File/New" and
--   "<Gnumeric-Sheet>/File/Exit".
--   
--   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 accelMapAddEntry.
--   
--   Note that accelPath string will be stored in a
--   GQuark. Therefore, if you pass a static string, you
--   can save some memory by interning it first with
--   internStaticString.
menuSetAccelPath :: (HasCallStack, MonadIO m, IsMenu a) => a -> Maybe Text -> m ()

-- | Set the AccelGroup 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 windowAddAccelGroup, 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 ()

-- | Memory-managed wrapper type.
newtype MenuButton
MenuButton :: ManagedPtr MenuButton -> MenuButton

-- | 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

-- | Creates a Popover and populates it according to
--   model. The popover is pointed to the
--   relativeTo widget.
--   
--   The created buttons are connected to actions found in the
--   ApplicationWindow to which the popover belongs - typically by
--   means of being attached to a widget that is contained within the
--   GtkApplicationWindows widget hierarchy.
--   
--   Actions can also be added using widgetInsertActionGroup on the
--   menus attach widget or on any of its parent widgets.
--   
--   Since: 3.12
popoverNewFromModel :: (HasCallStack, MonadIO m, IsWidget a, IsMenuModel b) => Maybe a -> b -> m Popover

-- | Sets the MenuModel from which the popup will be constructed, or
--   Nothing to dissociate any existing menu model and disable the
--   button.
--   
--   Depending on the value of MenuButton:usePopover, either a
--   Menu will be created with menuNewFromModel, or a
--   Popover with popoverNewFromModel. In either case,
--   actions will be connected as documented for these functions.
--   
--   If MenuButton:popup or MenuButton:popover are already
--   set, those widgets are dissociated from the
--   menuButton, and those properties are set to
--   Nothing.
--   
--   Since: 3.6
menuButtonSetMenuModel :: (HasCallStack, MonadIO m, IsMenuButton a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Sets how widgets should be packed inside the children of a menubar.
--   
--   Since: 2.8
menuBarSetChildPackDirection :: (HasCallStack, MonadIO m, IsMenuBar a) => a -> PackDirection -> m ()

-- | Sets how items should be packed inside a menubar.
--   
--   Since: 2.8
menuBarSetPackDirection :: (HasCallStack, MonadIO m, IsMenuBar a) => a -> PackDirection -> m ()

-- | 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

-- | Detaches the menu from the widget to which it had been attached. This
--   function will call the callback function, detacher,
--   provided when the menuAttachToWidget function was called.
menuDetach :: (HasCallStack, MonadIO m, IsMenu a) => a -> 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
--   title is Nothing, 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 ()

-- | If there is a current event and it has a timestamp, return that
--   timestamp, otherwise return CURRENT_TIME.
getCurrentEventTime :: (HasCallStack, MonadIO m) => m Word32

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

-- | Memory-managed wrapper type.
newtype LockButton
LockButton :: ManagedPtr LockButton -> LockButton

-- | Sets the data in the cell specified by iter and
--   column. The type of value must be
--   convertible to the type of the column.
listStoreSetValue :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> Int32 -> GValue -> m ()

-- | Marks row 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 listBoxRowChanged 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
--   listBoxInvalidateSort on any model change, but that is more
--   expensive.
--   
--   Since: 3.10
listBoxRowChanged :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m ()

-- | Update the sorting for all rows. Call this when result of the sort
--   function on the box is changed due to an external
--   factor.
--   
--   Since: 3.10
listBoxInvalidateSort :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

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

-- | Insert the child into the box at
--   position. If a sort function is set, the widget will
--   actually be inserted at the calculated position and this function has
--   the same effect of containerAdd.
--   
--   If position is -1, or larger than the total number of
--   items in the box, then the child will
--   be appended to the end.
--   
--   Since: 3.10
listBoxInsert :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> b -> Int32 -> m ()

-- | This is a helper function for implementing DnD onto a ListBox.
--   The passed in row will be highlighted via
--   widgetDragHighlight, and any previously highlighted row will be
--   unhighlighted.
--   
--   The row will also be unhighlighted when the widget gets a drag leave
--   event.
--   
--   Since: 3.10
listBoxDragHighlightRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> b -> m ()

-- | Update the filtering for all rows. Call this when result of the filter
--   function on the box 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.
--   
--   Since: 3.10
listBoxInvalidateFilter :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Returns the current header of the row. This can be
--   used in a ListBoxUpdateHeaderFunc to see if there is a header
--   set already, and if so to update the state of it.
--   
--   Since: 3.10
listBoxRowGetHeader :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m (Maybe Widget)

-- | Update the separators for all rows. Call this when result of the
--   header function on the box is changed due to an
--   external factor.
--   
--   Since: 3.10
listBoxInvalidateHeaders :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Memory-managed wrapper type.
newtype LinkButton
LinkButton :: ManagedPtr LinkButton -> LinkButton

-- | 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 * file:///home/gnome/pict.jpg *
--   http://www.gnome.org * mailto:me@gnome.org
--   
--   Ideally the timestamp is taken from the event triggering the
--   showUri call. If timestamp is not known you can take
--   CURRENT_TIME.
--   
--   This is the recommended call to be used as it passes information
--   necessary for sandbox helpers to parent their dialogs properly.
--   
--   Since: 3.22
showUriOnWindow :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> Text -> Word32 -> m ()

-- | Sets uri as the URI where the LinkButton
--   points. As a side-effect this unsets the “visited” state of the
--   button.
--   
--   Since: 2.10
linkButtonSetUri :: (HasCallStack, MonadIO m, IsLinkButton a) => a -> Text -> m ()

-- | Sets the “visited” state of the URI where the LinkButton
--   points. See linkButtonGetVisited for more details.
--   
--   Since: 2.14
linkButtonSetVisited :: (HasCallStack, MonadIO m, IsLinkButton a) => a -> Bool -> m ()

-- | Retrieves the “visited” state of the URI where the LinkButton
--   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 linkButtonSetVisited.
--   
--   Since: 2.14
linkButtonGetVisited :: (HasCallStack, MonadIO m, IsLinkButton a) => a -> m Bool

-- | Adds a new offset marker on self at the position
--   specified by value. When the bar value is in the
--   interval topped by value (or between
--   value and LevelBar:maxValue in case the offset
--   is the last one on the bar) a style class named
--   level-name will be applied when rendering the
--   level bar fill. If another offset marker named name
--   exists, its value will be replaced by value.
--   
--   Since: 3.6
levelBarAddOffsetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Text -> Double -> m ()

-- | Describes how LevelBar contents should be rendered. Note that
--   this enumeration could be extended with additional modes in the
--   future.
--   
--   Since: 3.6
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

-- | 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.
--   
--   Since: 2.6
labelSetAngle :: (HasCallStack, MonadIO m, IsLabel a) => a -> Double -> m ()

-- | Sets a AttrList; 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
--   Label:useUnderline or Label:useMarkup 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 ()

-- | Parses str 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 str is external data, you may need to escape it
--   with markupEscapeText or
--   g_markup_printf_escaped():
--   
--   
C code
--   
--   
--   GtkWidget *label = gtk_label_new (NULL);
--   const char *str = "some text";
--   const char *format = "<span style=\"italic\">\%s</span>";
--   char *markup;
--   
--   markup = g_markup_printf_escaped (format, str);
--   gtk_label_set_markup (GTK_LABEL (label), markup);
--   g_free (markup);
--   
--   
--   This function will set the Label:useMarkup property to
--   True as a side effect.
--   
--   If you set the label contents using the Label:label property
--   you should also ensure that you set the Label:useMarkup
--   property accordingly.
--   
--   See also: labelSetText
labelSetMarkup :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Sets the mode used to ellipsize (add an ellipsis: "...") to the text
--   if there is not enough space to render the entire string.
--   
--   Since: 2.6
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. JustificationLeft is the default value when the
--   widget is first created with labelNew. If you instead want to
--   set the alignment of the label as a whole, use widgetSetHalign
--   instead. labelSetJustify has no effect on labels containing
--   only a single line.
labelSetJustify :: (HasCallStack, MonadIO m, IsLabel a) => a -> Justification -> m ()

-- | 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 labelGetLabel)
labelGetText :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Text

-- | Obtains the coordinates where the label will draw the Layout
--   representing the text in the label; useful to convert mouse events
--   into coordinates inside the Layout, e.g. to take some action if
--   some part of the label is clicked. Of course you will need to create a
--   EventBox to receive the events, and pack the label inside it,
--   since labels are windowless (they return False from
--   widgetGetHasWindow). Remember when using the Layout
--   functions you need to convert to and from pixels using
--   PANGO_PIXELS() or SCALE.
labelGetLayoutOffsets :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Int32, Int32)

-- | Toggles line wrapping within the Label widget. True
--   makes it break lines if text exceeds the widget’s size. False
--   lets the text get cut off by the edge of the widget if it exceeds the
--   widget size.
--   
--   Note that setting line wrapping to True 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 widgetSetSizeRequest.
labelSetLineWrap :: (HasCallStack, MonadIO m, IsLabel a) => a -> Bool -> m ()

-- | If line wrapping is on (see labelSetLineWrap) this controls how
--   the line wrapping is done. The default is WrapModeWord which
--   means wrap on word boundaries.
--   
--   Since: 2.10
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.
--   
--   Since: 3.10
labelSetLines :: (HasCallStack, MonadIO m, IsLabel a) => a -> Int32 -> m ()

-- | Sets the desired width in characters of label to
--   nChars.
--   
--   Since: 2.6
labelSetWidthChars :: (HasCallStack, MonadIO m, IsLabel a) => a -> Int32 -> 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 ()

-- | Fetches the text from a label widget including any embedded underlines
--   indicating mnemonics and Pango markup. (See labelGetText).
labelGetLabel :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Text

-- | 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 ()

-- | Used for justifying the text inside a Label widget. (See also
--   Alignment).
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

-- | Creates a new label with the given text inside it. You can pass
--   Nothing to get an empty label widget.
labelNew :: (HasCallStack, MonadIO m) => Maybe Text -> m Label

-- | Sets the text within the Label widget. It overwrites any text
--   that was there before.
--   
--   This function will clear any previously set mnemonic accelerators, and
--   set the Label:useUnderline property to False as a side
--   effect.
--   
--   This function will set the Label:useMarkup property to
--   False as a side effect.
--   
--   See also: labelSetMarkup
labelSetText :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Parses str 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
--   str 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 labelSetMnemonicWidget.
labelSetMarkupWithMnemonic :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Sets the label’s text from the string str. If
--   characters in str 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
--   labelSetMnemonicWidget.
labelSetTextWithMnemonic :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Emits the Dialog::response signal with the given response ID.
--   Used to indicate that the user has responded to the dialog in some
--   way; typically either you or dialogRun will be monitoring the
--   response signal and take appropriate action.
dialogResponse :: (HasCallStack, MonadIO m, IsDialog a) => a -> Int32 -> m ()

-- | Memory-managed wrapper type.
newtype InfoBar
InfoBar :: ManagedPtr InfoBar -> InfoBar

-- | Predefined values for use as response ids in dialogAddButton.
--   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

-- | 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 ImageMenuItem
ImageMenuItem :: ManagedPtr ImageMenuItem -> ImageMenuItem

-- | Fills item with the registered values for
--   stockId, returning True if
--   stockId was known.
stockLookup :: (HasCallStack, MonadIO m) => Text -> m (Bool, StockItem)

-- | Sets the image of imageMenuItem 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 True, the label set in the menuitem is used as a stock id to
--   select the stock item for the item.
--   
--   Since: 2.16
imageMenuItemSetUseStock :: (HasCallStack, MonadIO m, IsImageMenuItem a) => a -> Bool -> m ()

-- | Sets text on the menuItem label
--   
--   Since: 2.16
menuItemSetLabel :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Text -> m ()

-- | Creates a new ImageMenuItem containing the image and text from
--   a stock item. Some stock ids have preprocessor macros like
--   STOCK_OK and STOCK_APPLY.
--   
--   If you want this menu item to have changeable accelerators, then pass
--   in Nothing for accel_group. Next call
--   menuItemSetAccelPath with an appropriate path for the menu
--   item, use stockLookup to look up the standard accelerator for
--   the stock item, and if one is found, call accelMapAddEntry to
--   register it.
imageMenuItemNewFromStock :: (HasCallStack, MonadIO m, IsAccelGroup a) => Text -> Maybe a -> m ImageMenuItem

-- | Creates a Image displaying a stock icon. Sample stock icon
--   names are STOCK_OPEN, STOCK_QUIT. Sample stock sizes are
--   GTK_ICON_SIZE_MENU,
--   GTK_ICON_SIZE_SMALL_TOOLBAR. If the stock icon name
--   isn’t known, the image will be empty. You can register your own stock
--   icon names, see iconFactoryAddDefault and
--   iconFactoryAdd.
imageNewFromStock :: (HasCallStack, MonadIO m) => Text -> Int32 -> m Image

-- | Creates a Image 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.
--   
--   Since: 2.6
imageNewFromIconName :: (HasCallStack, MonadIO m) => Maybe Text -> Int32 -> m Image

-- | Creates a new Image displaying the file
--   filename. If the file isn’t found or can’t be loaded,
--   the resulting Image will display a “broken image” icon. This
--   function never returns Nothing, it always returns a valid
--   Image widget.
--   
--   If the file contains an animation, the image will contain an
--   animation.
--   
--   If you need to detect failures to load the file, use
--   pixbufNewFromFile to load the file yourself, then create the
--   Image from the pixbuf. (Or for animations, use
--   pixbufAnimationNewFromFile).
--   
--   The storage type (imageGetStorageType) 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 Image 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.
--   
--   Since: 2.14
imageNewFromGicon :: (HasCallStack, MonadIO m, IsIcon a) => a -> Int32 -> m Image

-- | Creates a Image displaying an icon set. Sample stock sizes are
--   GTK_ICON_SIZE_MENU,
--   GTK_ICON_SIZE_SMALL_TOOLBAR. Instead of using this
--   function, usually it’s better to create a IconFactory, put your
--   icon sets in the icon factory, add the icon factory to the list of
--   default factories with iconFactoryAddDefault, and then use
--   imageNewFromStock. This will allow themes to override the icon
--   you ship with your application.
--   
--   The Image does not assume a reference to the icon set; you
--   still need to unref it if you own references. Image will add
--   its own reference rather than adopting yours.
imageNewFromIconSet :: (HasCallStack, MonadIO m) => IconSet -> Int32 -> m Image

-- | Creates a new Image displaying pixbuf. The
--   Image does not assume a reference to the pixbuf; you still need
--   to unref it if you own references. Image will add its own
--   reference rather than adopting yours.
--   
--   Note that this function just creates an Image from the pixbuf.
--   The Image created will not react to state changes. Should you
--   want that, you should use imageNewFromIconName.
imageNewFromPixbuf :: (HasCallStack, MonadIO m, IsPixbuf a) => Maybe a -> m Image

-- | Creates a new Image displaying the resource file
--   resourcePath. If the file isn’t found or can’t be
--   loaded, the resulting Image will display a “broken image” icon.
--   This function never returns Nothing, it always returns a valid
--   Image widget.
--   
--   If the file contains an animation, the image will contain an
--   animation.
--   
--   If you need to detect failures to load the file, use
--   pixbufNewFromFile to load the file yourself, then create the
--   Image from the pixbuf. (Or for animations, use
--   pixbufAnimationNewFromFile).
--   
--   The storage type (imageGetStorageType) of the returned image is
--   not defined, it will be whatever is appropriate for displaying the
--   file.
--   
--   Since: 3.4
imageNewFromResource :: (HasCallStack, MonadIO m) => Text -> m Image

-- | Creates a new Image displaying surface. The
--   Image does not assume a reference to the surface; you still
--   need to unref it if you own references. Image will add its own
--   reference rather than adopting yours.
--   
--   Since: 3.10
imageNewFromSurface :: (HasCallStack, MonadIO m) => Maybe Surface -> m Image

-- | See imageNewFromIconName for details.
--   
--   Since: 2.6
imageSetFromIconName :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe Text -> Int32 -> m ()

-- | Activates the item determined by path.
--   
--   Since: 2.6
iconViewItemActivated :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m ()

-- | Finds the path at the point (x, y),
--   relative to bin_window coordinates. See iconViewGetItemAtPos,
--   if you are also interested in the cell at the specified position. See
--   iconViewConvertWidgetToBinWindowCoords for converting widget
--   coordinates to bin_window coordinates.
--   
--   Since: 2.6
iconViewGetPathAtPos :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m (Maybe TreePath)

-- | Causes the IconView::itemActivated signal to be emitted on a
--   single click instead of a double click.
--   
--   Since: 3.8
iconViewSetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsIconView a) => a -> Bool -> m ()

-- | Converts widget coordinates to coordinates for the bin_window, as
--   expected by e.g. iconViewGetPathAtPos.
--   
--   Since: 2.12
iconViewConvertWidgetToBinWindowCoords :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Finds the path at the point (x, y),
--   relative to bin_window coordinates. In contrast to
--   iconViewGetPathAtPos, this function also obtains the cell at
--   the specified position. The returned path should be freed with
--   treePathFree. See iconViewConvertWidgetToBinWindowCoords
--   for converting widget coordinates to bin_window coordinates.
--   
--   Since: 2.8
iconViewGetItemAtPos :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m (Bool, TreePath, CellRenderer)

-- | This function is a convenience function to allow you to reorder models
--   that support the TreeDragSourceIface and the
--   TreeDragDestIface. Both TreeStore and ListStore
--   support these. If reorderable is True, 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.
--   
--   Since: 2.8
iconViewSetReorderable :: (HasCallStack, MonadIO m, IsIconView a) => a -> Bool -> m ()

-- | Sets the column with text for iconView to be
--   column. The text column must be of type
--   G_TYPE_STRING.
--   
--   Since: 2.6
iconViewSetTextColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | If you only plan to have simple (text-only) tooltips on full items,
--   you can use this function to have IconView handle these
--   automatically for you. column should be set to the
--   column in iconView’s model containing the tooltip
--   texts, or -1 to disable this feature.
--   
--   When enabled, Widget:hasTooltip will be set to True and
--   iconView will connect a Widget::queryTooltip
--   signal handler.
--   
--   Note that the signal handler sets the text with
--   tooltipSetMarkup, so &, <, etc have to be escaped in the
--   text.
--   
--   Since: 2.12
iconViewSetTooltipColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Turns iconView into a drop destination for automatic
--   DND. Calling this method sets IconView:reorderable to
--   False.
--   
--   Since: 2.8
iconViewEnableModelDragDest :: (HasCallStack, MonadIO m, IsIconView a) => a -> [TargetEntry] -> [DragAction] -> m ()

-- | Turns iconView into a drag source for automatic DND.
--   Calling this method sets IconView:reorderable to False.
--   
--   Since: 2.8
iconViewEnableModelDragSource :: (HasCallStack, MonadIO m, IsIconView a) => a -> [ModifierType] -> [TargetEntry] -> [DragAction] -> m ()

-- | Gets the icon theme for the default screen. See
--   iconThemeGetForScreen.
--   
--   Since: 2.4
iconThemeGetDefault :: (HasCallStack, MonadIO m) => m IconTheme

-- | Gets the icon theme object associated with screen; 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
--   iconThemeNew and setting the screen yourself; by using this
--   function a single icon theme object will be shared between users.
--   
--   Since: 2.4
iconThemeGetForScreen :: (HasCallStack, MonadIO m, IsScreen a) => a -> m IconTheme

-- | 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 path 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 path, 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.)
--   
--   Since: 2.4
iconThemeSetSearchPath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> [[Char]] -> m ()

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

-- | Renders an icon previously looked up in an icon theme using
--   iconThemeLookupIcon; the size will be based on the size passed
--   to iconThemeLookupIcon. 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 IconLookupFlagsForceSize flag when obtaining the
--   IconInfo. If this flag has been specified, the pixbuf returned
--   by this function will be scaled to the exact size.
--   
--   Since: 2.4
iconInfoLoadIcon :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m Pixbuf

-- | 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 iconThemeLookupIcon
--   followed by iconInfoLoadIcon.
--   
--   Note that you probably want to listen for icon theme changes and
--   update the icon. This is usually done by connecting to the
--   GtkWidgetstyleSet signal. If for some reason you do not want to
--   update the icon when the icon theme changes, you should consider using
--   pixbufCopy 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.
--   
--   Since: 2.4
iconThemeLoadIcon :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> Int32 -> [IconLookupFlags] -> m (Maybe Pixbuf)

-- | 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 Icon Theme Specification. The standard contexts are listed
--   in the Icon Naming Specification. Also see
--   iconThemeListContexts.
--   
--   Since: 2.4
iconThemeListIcons :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Maybe Text -> m [Text]

-- | Gets the list of contexts available within the current hierarchy of
--   icon themes. See iconThemeListIcons for details about contexts.
--   
--   Since: 2.12
iconThemeListContexts :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> m [Text]

-- | Renders an icon previously looked up in an icon theme using
--   iconThemeLookupIcon; the size will be based on the size passed
--   to iconThemeLookupIcon. 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 IconLookupFlagsForceSize flag when obtaining the
--   IconInfo. If this flag has been specified, the pixbuf returned
--   by this function will be scaled to the exact size.
--   
--   Since: 3.10
iconInfoLoadSurface :: (HasCallStack, MonadIO m, IsIconInfo a, IsWindow b) => a -> Maybe b -> m Surface

-- | Looks up an icon and returns a IconInfo containing information
--   such as the filename of the icon. The icon can then be rendered into a
--   pixbuf using iconInfoLoadIcon.
--   
--   Since: 3.10
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
--   IconInfo containing information such as the filename of the
--   icon. The icon can then be rendered into a pixbuf using
--   iconInfoLoadIcon. (iconThemeLoadIcon combines these two
--   steps if all you need is the pixbuf.)
--   
--   Since: 3.10
iconThemeLookupIconForScale :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> Int32 -> Int32 -> [IconLookupFlags] -> m (Maybe IconInfo)

-- | 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 iconThemeAddBuiltinIcon 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
--   pixbufNewFromInline.
--   
--   Since: 2.4
iconThemeAddBuiltinIcon :: (HasCallStack, MonadIO m, IsPixbuf a) => Text -> Int32 -> a -> m ()

-- | 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 iconThemeGetDefault or iconThemeGetForScreen rather
--   than creating a new icon theme object for scratch.
--   
--   Since: 2.4
iconThemeNew :: (HasCallStack, MonadIO m) => m IconTheme

-- | Asynchronously load, render and scale an icon previously looked up
--   from the icon theme using iconThemeLookupIcon.
--   
--   For more details, see iconInfoLoadIcon which is the synchronous
--   version of this call.
--   
--   Since: 3.8
iconInfoLoadIconAsync :: (HasCallStack, MonadIO m, IsIconInfo a, IsCancellable b) => a -> Maybe b -> Maybe AsyncReadyCallback -> m ()

-- | 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
--   iconInfoLoadIcon.
--   
--   This allows loading symbolic icons that will match the system theme.
--   
--   Unless you are implementing a widget, you will want to use
--   themedIconNewWithDefaultFallbacks 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 Symbolic Icons Specification for more information about
--   symbolic icons.
--   
--   Since: 3.0
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 iconThemeLookupIcon.
--   
--   For more details, see iconInfoLoadSymbolic which is the
--   synchronous version of this call.
--   
--   Since: 3.8
iconInfoLoadSymbolicAsync :: (HasCallStack, MonadIO m, IsIconInfo a, IsCancellable b) => a -> RGBA -> Maybe RGBA -> Maybe RGBA -> Maybe RGBA -> Maybe b -> Maybe AsyncReadyCallback -> m ()

-- | 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
--   iconInfoLoadIcon. 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 iconInfoLoadSymbolic for more details.
--   
--   Since: 3.0
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 iconThemeLookupIcon.
--   
--   For more details, see iconInfoLoadSymbolicForContext which is
--   the synchronous version of this call.
--   
--   Since: 3.8
iconInfoLoadSymbolicForContextAsync :: (HasCallStack, MonadIO m, IsIconInfo a, IsStyleContext b, IsCancellable c) => a -> b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | This function is deprecated and always returns False.
--   
--   Since: 2.4
iconInfoGetEmbeddedRect :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m (Bool, Rectangle)

-- | This function is deprecated and always returns False.
--   
--   Since: 2.4
iconInfoGetAttachPoints :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m (Bool, [Point])

-- | 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 up stockId in the icon factories associated with
--   style and the default icon factory, returning an icon
--   set if found, otherwise Nothing.
styleLookupIconSet :: (HasCallStack, MonadIO m, IsStyle a) => a -> Text -> m IconSet

-- | Memory-managed wrapper type.
newtype IMMulticontext
IMMulticontext :: ManagedPtr IMMulticontext -> IMMulticontext

-- | Sets a custom title for the HeaderBar.
--   
--   The title should help a user identify the current view. This
--   supersedes any title set by headerBarSetTitle or
--   headerBarSetSubtitle. 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 Nothing, for the header
--   title label to be visible again.
--   
--   Since: 3.10
headerBarSetCustomTitle :: (HasCallStack, MonadIO m, IsHeaderBar a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the decoration layout for this header bar, overriding the
--   Settings:gtkDecorationLayout 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.
--   
--   Since: 3.12
headerBarSetDecorationLayout :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Maybe Text -> m ()

-- | Sets the subtitle of the HeaderBar. 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
--   HeaderBar:hasSubtitle property to False.
--   
--   Since: 3.10
headerBarSetSubtitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Maybe Text -> m ()

-- | Sets the title of the HeaderBar. The title should help a user
--   identify the current view. A good title should not include the
--   application name.
--   
--   Since: 3.10
headerBarSetTitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Maybe Text -> m ()

-- | 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
--   PositionTypeRight or PositionTypeLeft, then the snap
--   edge will be PositionTypeTop, otherwise it will be
--   PositionTypeLeft.
handleBoxSetSnapEdge :: (HasCallStack, MonadIO m, IsHandleBox a) => a -> PositionType -> m ()

-- | Memory-managed wrapper type.
newtype HSeparator
HSeparator :: ManagedPtr HSeparator -> HSeparator

-- | Memory-managed wrapper type.
newtype HScrollbar
HScrollbar :: ManagedPtr HScrollbar -> HScrollbar

-- | Memory-managed wrapper type.
newtype HScale
HScale :: ManagedPtr HScale -> HScale

-- | Memory-managed wrapper type.
newtype HSV
HSV :: ManagedPtr HSV -> HSV

-- | Memory-managed wrapper type.
newtype HPaned
HPaned :: ManagedPtr HPaned -> HPaned

-- | Sets how the baseline should be positioned on row of
--   the grid, in case that row is assigned more space than is requested.
--   
--   Since: 3.10
gridSetRowBaselinePosition :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> BaselinePosition -> m ()

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

-- | Memory-managed wrapper type.
newtype GestureZoom
GestureZoom :: ManagedPtr GestureZoom -> GestureZoom

-- | Memory-managed wrapper type.
newtype GestureSwipe
GestureSwipe :: ManagedPtr GestureSwipe -> GestureSwipe

-- | Memory-managed wrapper type.
newtype GestureStylus
GestureStylus :: ManagedPtr GestureStylus -> GestureStylus

-- | Returns True if the gesture is currently active. A gesture is
--   active meanwhile there are touch sequences interacting with it.
--   
--   Since: 3.14
gestureIsActive :: (HasCallStack, MonadIO m, IsGesture a) => a -> m Bool

-- | Sets whether gesture 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.
--   
--   Since: 3.14
gestureSingleSetExclusive :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> Bool -> m ()

-- | Memory-managed wrapper type.
newtype GestureSingle
GestureSingle :: ManagedPtr GestureSingle -> GestureSingle

-- | Memory-managed wrapper type.
newtype GestureRotate
GestureRotate :: ManagedPtr GestureRotate -> GestureRotate

-- | If rect is non-Nothing, 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
--   rect is Nothing, 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.
--   
--   Since: 3.14
gestureMultiPressSetArea :: (HasCallStack, MonadIO m, IsGestureMultiPress a) => a -> Maybe Rectangle -> m ()

-- | Memory-managed wrapper type.
newtype GestureMultiPress
GestureMultiPress :: ManagedPtr GestureMultiPress -> GestureMultiPress

-- | Memory-managed wrapper type.
newtype GestureLongPress
GestureLongPress :: ManagedPtr GestureLongPress -> GestureLongPress

-- | Memory-managed wrapper type.
newtype GestureDrag
GestureDrag :: ManagedPtr GestureDrag -> GestureDrag

-- | Sets the state of sequence in gesture.
--   Sequences start in state GTK_EVENT_SEQUENCE_NONE, and
--   whenever they change state, they can never go back to that state.
--   Likewise, sequences in state GTK_EVENT_SEQUENCE_DENIED
--   cannot turn back to a not denied state. With these rules, the lifetime
--   of an event sequence is constrained to the next four:
--   
--   
--   
- None
--   
- None → Denied
--   
- None → Claimed
--   
- None → Claimed → Denied
--   
--   
--   Note: Due to event handling ordering, it may be unsafe to set the
--   state on another gesture within a Gesture::begin signal
--   handler, as the callback might be executed before the other gesture
--   knows about the sequence. A safe way to perform this could be:
--   
--   
--   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);
--   }
--   
--   
--   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.
--   
--   Since: 3.14
gestureSetSequenceState :: (HasCallStack, MonadIO m, IsGesture a) => a -> EventSequence -> EventSequenceState -> m Bool

-- | Returns True if gesture is currently handling
--   events corresponding to sequence.
--   
--   Since: 3.14
gestureHandlesSequence :: (HasCallStack, MonadIO m, IsGesture a) => a -> Maybe EventSequence -> m Bool

-- | Resets the controller to a clean state. Every
--   interaction the controller did through
--   EventController::handle-event will be dropped
--   at this point.
--   
--   Since: 3.14
eventControllerReset :: (HasCallStack, MonadIO m, IsEventController a) => a -> m ()

-- | Sets a specific window to receive events about, so
--   gesture will effectively handle only events targeting
--   window, or a child of it. window must
--   pertain to eventControllerGetWidget.
--   
--   Since: 3.14
gestureSetWindow :: (HasCallStack, MonadIO m, IsGesture a, IsWindow b) => a -> Maybe b -> m ()

-- | Returns the Widget this controller relates to.
--   
--   Since: 3.14
eventControllerGetWidget :: (HasCallStack, MonadIO m, IsEventController a) => a -> m Widget

-- | Memory-managed wrapper type.
newtype GLArea
GLArea :: ManagedPtr GLArea -> GLArea

-- | Sets an error on the area which will be shown instead of the GL
--   rendering. This is useful in the GLArea::createContext signal
--   if GL context creation fails.
--   
--   Since: 3.16
gLAreaSetError :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Maybe GError -> 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.
--   
--   Since: 3.16
gLAreaSetRequiredVersion :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Int32 -> Int32 -> m ()

-- | Sets whether the area should create an OpenGL or an
--   OpenGL ES context.
--   
--   You should check the capabilities of the GLContext before
--   drawing with either API.
--   
--   Since: 3.22
gLAreaSetUseEs :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()

-- | If autoRender is True the GLArea::render
--   signal will be emitted every time the widget draws. This is the
--   default and is useful if drawing the widget is faster.
--   
--   If autoRender is False 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
--   gLAreaQueueRender must be called. This mode is useful when the
--   scene changes seldomly, but takes a long time to redraw.
--   
--   Since: 3.16
gLAreaSetAutoRender :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()

-- | Marks the currently rendered data (if any) as invalid, and queues a
--   redraw of the widget, ensuring that the GLArea::render signal
--   is emitted during the draw.
--   
--   This is only needed when the gLAreaSetAutoRender has been
--   called with a False value. The default behaviour is to emit
--   GLArea::render on each draw.
--   
--   Since: 3.16
gLAreaQueueRender :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m ()

-- | Creates a new Frame, with optional label label.
--   If label is Nothing, the label is omitted.
frameNew :: (HasCallStack, MonadIO m) => Maybe Text -> m Frame

-- | 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 Frame:labelWidget 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 Frame:shadowType for frame, i.e.
--   whether it is drawn without (ShadowTypeNone) or with (other
--   values) a visible border. Values other than ShadowTypeNone 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 ()

-- | Used to change the appearance of an outline typically provided by a
--   Frame.
--   
--   Note that many themes do not differentiate the appearance of the
--   various shadow types: Either their is no visible shadow
--   (gTKSHADOWNONE), 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 FontSelectionDialog
FontSelectionDialog :: ManagedPtr FontSelectionDialog -> FontSelectionDialog

-- | Sets the currently selected font.
fontSelectionDialogSetFontName :: (HasCallStack, MonadIO m, IsFontSelectionDialog a) => a -> Text -> m Bool

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

-- | Sets the currently-selected font.
--   
--   Note that the fontsel needs to know the screen in
--   which it will appear for this to work; this can be guaranteed by
--   simply making sure that the fontsel is inserted in a
--   toplevel window before you call this function.
fontSelectionSetFontName :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> Text -> m Bool

-- | Memory-managed wrapper type.
newtype FontChooserWidget
FontChooserWidget :: ManagedPtr FontChooserWidget -> FontChooserWidget

-- | Memory-managed wrapper type.
newtype FontChooserDialog
FontChooserDialog :: ManagedPtr FontChooserDialog -> FontChooserDialog

-- | Gets the currently-selected font name.
--   
--   Note that this can be a different string than what you set with
--   fontChooserSetFont, 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 fontDescriptionEqual if you want to compare two font
--   descriptions.
--   
--   Since: 3.2
fontChooserGetFont :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe Text)

-- | Memory-managed wrapper type.
newtype FontButton
FontButton :: ManagedPtr FontButton -> FontButton

-- | Marks child 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 flowBoxChildChanged 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
--   flowBoxInvalidateSort on any model change, but that is more
--   expensive.
--   
--   Since: 3.12
flowBoxChildChanged :: (HasCallStack, MonadIO m, IsFlowBoxChild a) => a -> m ()

-- | Updates the sorting for all children.
--   
--   Call this when the result of the sort function on box
--   is changed due to an external factor.
--   
--   Since: 3.12
flowBoxInvalidateSort :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m ()

-- | Creates a list of all selected children.
--   
--   Since: 3.12
flowBoxGetSelectedChildren :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m [FlowBoxChild]

-- | Inserts the widget into box at
--   position.
--   
--   If a sort function is set, the widget will actually be inserted at the
--   calculated position and this function has the same effect as
--   containerAdd.
--   
--   If position is -1, or larger than the total number of
--   children in the box, then the widget
--   will be appended to the end.
--   
--   Since: 3.12
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
--   box 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.
--   
--   Since: 3.12
flowBoxInvalidateFilter :: (HasCallStack, MonadIO m, IsFlowBox 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

-- | Hooks up an adjustment to focus handling in box. The
--   adjustment is also used for autoscrolling during rubberband selection.
--   See scrolledWindowGetVadjustment for a typical way of obtaining
--   the adjustment, and flowBoxSetHadjustmentfor 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.
--   
--   Since: 3.12
flowBoxSetVadjustment :: (HasCallStack, MonadIO m, IsFlowBox a, IsAdjustment b) => a -> b -> m ()

-- | 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

-- | Hooks up an adjustment to focus handling in box. The
--   adjustment is also used for autoscrolling during rubberband selection.
--   See scrolledWindowGetHadjustment for a typical way of obtaining
--   the adjustment, and flowBoxSetVadjustmentfor 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.
--   
--   Since: 3.12
flowBoxSetHadjustment :: (HasCallStack, MonadIO m, IsFlowBox a, IsAdjustment b) => a -> b -> m ()

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

-- | Adds a rule allowing a given mime type to filter.
--   
--   Since: 2.4
fileFilterAddMimeType :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> Text -> m ()

-- | Adds a rule allowing a shell style glob to a filter.
--   
--   Since: 2.4
fileFilterAddPattern :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> Text -> m ()

-- | Serialize a file filter to an a{sv} variant.
--   
--   Since: 3.22
fileFilterToGvariant :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> m GVariant

-- | Gets the fields that need to be filled in for the
--   FileFilterInfo passed to fileFilterFilter
--   
--   This function will not typically be used by applications; it is
--   intended principally for use in the implementation of
--   FileChooser.
--   
--   Since: 2.4
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.
--   
--   Since: 2.4
fileFilterSetName :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> Maybe Text -> m ()

-- | Tests whether a file should be displayed according to
--   filter. The FileFilterInfo
--   filterInfo should include the fields returned from
--   fileFilterGetNeeded.
--   
--   This function will not typically be used by applications; it is
--   intended principally for use in the implementation of
--   FileChooser.
--   
--   Since: 2.4
fileFilterFilter :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> FileFilterInfo -> m Bool

-- | Memory-managed wrapper type.
newtype FileChooserWidget
FileChooserWidget :: ManagedPtr FileChooserWidget -> FileChooserWidget

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

-- | Memory-managed wrapper type.
newtype FileChooserNative
FileChooserNative :: ManagedPtr FileChooserNative -> FileChooserNative

-- | Memory-managed wrapper type.
newtype FileChooserButton
FileChooserButton :: ManagedPtr FileChooserButton -> FileChooserButton

-- | Flags used to influence dialog construction.
data DialogFlags

-- | Make the constructed dialog modal, see windowSetModal
DialogFlagsModal :: DialogFlags

-- | Destroy the dialog when its parent is destroyed, see
--   windowSetDestroyWithParent
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

-- | 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.
--   
--   Since: 2.10
fileChooserButtonSetFocusOnClick :: (HasCallStack, MonadIO m, IsFileChooserButton a) => a -> Bool -> m ()

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

-- | Sets the state of the expander. Set to True, if you want the
--   child widget to be revealed, and False if you want the child
--   widget to be hidden.
--   
--   Since: 2.4
expanderSetExpanded :: (HasCallStack, MonadIO m, IsExpander a) => a -> Bool -> m ()

-- | Sets the text of the label of the expander to label.
--   
--   This will also clear any previously set labels.
--   
--   Since: 2.4
expanderSetLabel :: (HasCallStack, MonadIO m, IsExpander a) => a -> Maybe Text -> m ()

-- | Set the label widget for the expander. This is the widget that will
--   appear embedded alongside the expander arrow.
--   
--   Since: 2.4
expanderSetLabelWidget :: (HasCallStack, MonadIO m, IsExpander a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the spacing field of expander, which is the
--   number of pixels to place between expander and the child.
--   
--   Since: 2.4
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 labelSetMarkup.
--   
--   Since: 2.4
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.
--   
--   Since: 2.4
expanderSetUseUnderline :: (HasCallStack, MonadIO m, IsExpander a) => a -> Bool -> m ()

-- | Memory-managed wrapper type.
newtype EventControllerMotion
EventControllerMotion :: ManagedPtr EventControllerMotion -> EventControllerMotion

-- | Memory-managed wrapper type.
newtype EventControllerKey
EventControllerKey :: ManagedPtr EventControllerKey -> EventControllerKey

-- | Describes the stage at which events are fed into a
--   EventController.
--   
--   Since: 3.14
data PropagationPhase

-- | Events are not delivered automatically. Those can be manually fed
--   through eventControllerHandleEvent. 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

-- | 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.
--   
--   Since: 2.4
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 WindowWindowClassInputOnly window, which means
--   that it is invisible and only serves to receive events.
--   
--   A visible window event box creates a visible
--   (WindowWindowClassInputOutput) 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 eventBoxSetAboveChild.) 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 widgetAddEvents), 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.
--   
--   Since: 2.4
eventBoxSetVisibleWindow :: (HasCallStack, MonadIO m, IsEventBox a) => a -> Bool -> m ()

-- | Sets the model for a EntryCompletion. If
--   completion already has a model set, it will remove it
--   before setting the new model. If model is Nothing, then it will
--   unset the model.
--   
--   Since: 2.4
entryCompletionSetModel :: (HasCallStack, MonadIO m, IsEntryCompletion a, IsTreeModel b) => a -> Maybe b -> m ()

-- | Convenience function for setting up the most used case of this code: a
--   completion list with just strings. This function will set up
--   completion to have a list displaying all (and just)
--   strings in the completion list, and to get those strings from
--   column in the model of completion.
--   
--   This functions creates and adds a CellRendererText for the
--   selected column. If you need to set the text column, but don't want
--   the cell renderer, use g_object_set() to set the
--   EntryCompletion:textColumn property directly.
--   
--   Since: 2.4
entryCompletionSetTextColumn :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Int32 -> m ()

-- | Inserts an action in completion’s action item list at
--   position index_ with markup markup.
--   
--   Since: 2.4
entryCompletionInsertActionMarkup :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Int32 -> Text -> m ()

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

-- | If setting is True, pressing Enter in the
--   entry 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 setting is True, the entry
--   calls windowActivateDefault on the window containing the entry,
--   in the default handler for the Entry::activate 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.
--   
--   Since: 2.4
entrySetAlignment :: (HasCallStack, MonadIO m, IsEntry a) => a -> Float -> m ()

-- | Sets a AttrList; the attributes in the list are applied to the
--   entry text.
--   
--   Since: 3.6
entrySetAttributes :: (HasCallStack, MonadIO m, IsEntry a) => a -> AttrList -> 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 scrolledWindowGetHadjustment 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.
--   
--   Since: 2.12
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 ()

-- | 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, textArea is filled with
--   zeros.
--   
--   See also entryGetIconArea.
--   
--   Since: 3.0
entryGetTextArea :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Rectangle

-- | Sets entry’s inner-border property to
--   border, or clears it if Nothing 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.
--   
--   Since: 2.10
entrySetInnerBorder :: (HasCallStack, MonadIO m, IsEntry a) => a -> Maybe Border -> m ()

-- | Sets the character to use in place of the actual text when
--   entrySetVisibility has been called to set text visibility to
--   False. 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 ()

-- | Obtains the position of the Layout 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
--   Layout, 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 “notifyscrollOffset”
--   signal to track this. Remember when using the Layout functions
--   you need to convert to and from pixels using
--   PANGO_PIXELS() or SCALE.
--   
--   Keep in mind that the layout text may contain a preedit string, so
--   entryLayoutIndexToTextIndex and
--   entryTextIndexToLayoutIndex 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)

-- | Converts from a position in the entry’s Layout (returned by
--   entryGetLayout) to a position in the entry contents (returned
--   by entryGetText).
entryLayoutIndexToTextIndex :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m Int32

-- | Converts from a position in the entry contents (returned by
--   entryGetText) to a position in the entry’s Layout
--   (returned by entryGetLayout, with text retrieved via
--   layoutGetText).
entryTextIndexToLayoutIndex :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m Int32

-- | 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 entry's
--   EntryBuffer and calling entryBufferSetMaxLength on it.
--   ]|
entrySetMaxLength :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m ()

-- | Retrieves the maximum allowed length of the text in
--   buffer. See entryBufferSetMaxLength.
--   
--   Since: 2.18
entryBufferGetMaxLength :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m Int32

-- | Sets the desired maximum width in characters of entry.
--   
--   Since: 3.12
entrySetMaxWidthChars :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m ()

-- | Sets whether the text is overwritten when typing in the Entry.
--   
--   Since: 2.14
entrySetOverwriteMode :: (HasCallStack, MonadIO m, IsEntry a) => a -> Bool -> 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.
--   
--   Since: 2.16
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 entryProgressPulse.
--   
--   Since: 2.16
entrySetProgressPulseStep :: (HasCallStack, MonadIO m, IsEntry a) => a -> Double -> m ()

-- | Sets a TabArray; the tabstops in the array are applied to the
--   entry text.
--   
--   Since: 3.10
entrySetTabs :: (HasCallStack, MonadIO m, IsEntry a) => a -> TabArray -> m ()

-- | Retrieves a sequence of characters. The characters that are retrieved
--   are those characters at positions from startPos up to,
--   but not including endPos. If endPos is
--   negative, then the characters retrieved are those characters from
--   startPos 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.
--   
--   Since: 2.18
entryBufferGetText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m Text

-- | Gets the area where entry’s icon at iconPos 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,
--   iconArea is filled with zeros. Otherwise,
--   iconArea will be filled with the icon’s allocation,
--   relative to entry’s allocation.
--   
--   See also entryGetTextArea
--   
--   Since: 3.0
entryGetIconArea :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Rectangle

-- | Sets whether the contents of the entry are visible or not. When
--   visibility is set to False, 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 entrySetInvisibleChar.
--   
--   Note that you probably want to set Entry:inputPurpose to
--   InputPurposePassword or InputPurposePin to inform input
--   methods about the purpose of this entry, in addition to setting
--   visibility to False.
entrySetVisibility :: (HasCallStack, MonadIO m, IsEntry a) => a -> Bool -> m ()

-- | Changes the size request of the entry to be about the right size for
--   nChars characters. Note that it changes the size
--   request, the size can still be affected by how you pack the widget
--   into containers. If nChars is -1, the size reverts to
--   the default entry size.
entrySetWidthChars :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m ()

-- | 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.
--   
--   Since: 2.22
textViewResetImContext :: (HasCallStack, MonadIO m, IsTextView a) => a -> m ()

-- | Gets the Layout used to display the entry. The layout is useful
--   to e.g. convert text positions to pixel positions, in combination with
--   entryGetLayoutOffsets. 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
--   entryLayoutIndexToTextIndex and
--   entryTextIndexToLayoutIndex 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

-- | 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 entryProgressPulse
--   causes the block to move by a little bit (the amount of movement per
--   pulse is determined by entrySetProgressPulseStep).
--   
--   Since: 2.16
entryProgressPulse :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()

-- | Activates the default widget for the window, unless the current
--   focused widget has been configured to receive the default action (see
--   widgetSetReceivesDefault), in which case the focused widget is
--   activated.
windowActivateDefault :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | 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 Widget::dragDataGet
--   callback.
--   
--   Since: 2.16
entryGetCurrentIconDragSource :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Int32

-- | Sets tooltip as the contents of the tooltip for the
--   icon at the specified position.
--   
--   Use Nothing for tooltip to remove an existing
--   tooltip.
--   
--   See also widgetSetTooltipText and
--   entrySetIconTooltipMarkup.
--   
--   If you unset the widget tooltip via widgetSetTooltipText or
--   widgetSetTooltipMarkup, this sets GtkWidget:has-tooltip to
--   False, which suppresses icon tooltips too. You can resolve this
--   by then calling widgetSetHasTooltip to set
--   GtkWidget:has-tooltip back to True, or setting at least one
--   non-empty tooltip on any icon achieves the same result.
--   
--   Since: 2.16
entrySetIconTooltipText :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

-- | Sets tooltip as the contents of the tooltip for the
--   icon at the specified position. tooltip is assumed to
--   be marked up with the [Pango text markup language][PangoMarkupFormat].
--   
--   Use Nothing for tooltip to remove an existing
--   tooltip.
--   
--   See also widgetSetTooltipMarkup and
--   entrySetIconTooltipText.
--   
--   Since: 2.16
entrySetIconTooltipMarkup :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

-- | Sets the has-tooltip property on widget to
--   hasTooltip. See Widget:hasTooltip for more
--   information.
--   
--   Since: 2.12
widgetSetHasTooltip :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the text in the buffer.
--   
--   This is roughly equivalent to calling entryBufferDeleteText and
--   entryBufferInsertText.
--   
--   Note that nChars is in characters, not in bytes.
--   
--   Since: 2.18
entryBufferSetText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Text -> Int32 -> m ()

-- | Blocks in a recursive main loop until the dialog
--   either emits the Dialog::response signal, or is destroyed. If
--   the dialog is destroyed during the call to dialogRun,
--   dialogRun returns GTK_RESPONSE_NONE. Otherwise,
--   it returns the response ID from the response signal emission.
--   
--   Before entering the recursive main loop, dialogRun calls
--   widgetShow on the dialog for you. Note that you still need to
--   show any children of the dialog yourself.
--   
--   During dialogRun, the default behavior of
--   Widget::deleteEvent is disabled; if the dialog receives
--   delete_event, it will not be destroyed as windows usually are,
--   and dialogRun will return
--   GTK_RESPONSE_DELETE_EVENT. Also, during
--   dialogRun the dialog will be modal. You can force
--   dialogRun to return at any time by calling
--   dialogResponse to emit the response signal. Destroying
--   the dialog during dialogRun is a very bad idea, because your
--   post-run code won’t know whether the dialog was destroyed or not.
--   
--   After dialogRun returns, you are responsible for hiding or
--   destroying the dialog if you wish to do so.
--   
--   Typical usage of this function might be:
--   
--   
C code
--   
--   
--   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);
--   
--   
--   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 dialogRun call.
dialogRun :: (HasCallStack, MonadIO m, IsDialog a) => a -> m Int32

-- | Loads data into cssProvider, and by
--   doing so clears any previously loaded information.
cssProviderLoadFromData :: (HasCallStack, MonadIO m, IsCssProvider a) => a -> ByteString -> m ()

-- | Returns a newly created CssProvider.
cssProviderNew :: (HasCallStack, MonadIO m) => m CssProvider

-- | Adds child to box, packed with
--   reference to the start of box. The
--   child is packed after any other child packed with
--   reference to the start of box.
boxPackStart :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> b -> Bool -> Bool -> Word32 -> m ()

-- | Adds a widget to the grid.
--   
--   The position of child is determined by
--   left and top. The number of “cells”
--   that child will occupy is determined by
--   width and height.
gridAttach :: (HasCallStack, MonadIO m, IsGrid a, IsWidget b) => a -> b -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Emits a Widget::childNotify signal for the [child
--   property][child-properties] childProperty on
--   widget.
--   
--   This is the analogue of objectNotify for child properties.
--   
--   Also see containerChildNotify.
widgetChildNotify :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> 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
--   Window; 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
--   Widget:margin property on the child widget, for example
--   Widget:marginTop.
containerSetBorderWidth :: (HasCallStack, MonadIO m, IsContainer a) => a -> Word32 -> 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
--   gtk_widget_has_focus (widget) will not be True for the
--   widget.
windowGetFocus :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Widget)

-- | 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
--   scrolledWindowGetVadjustment for a typical way of obtaining the
--   adjustment and containerSetFocusHadjustment 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 ()

-- | 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
--   scrolledWindowGetHadjustment for a typical way of obtaining the
--   adjustment and containerSetFocusVadjustment 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 ()

-- | Memory-managed wrapper type.
newtype ComboBoxText
ComboBoxText :: ManagedPtr ComboBoxText -> ComboBoxText

-- | Inserts text at position in the list
--   of strings stored in comboBox. If id
--   is non-Nothing then it is used as the ID of the row. See
--   ComboBox:idColumn.
--   
--   If position is negative then text is
--   appended.
--   
--   Since: 3.0
comboBoxTextInsert :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Int32 -> Maybe Text -> Text -> m ()

-- | Inserts text at position in the list
--   of strings stored in comboBox.
--   
--   If position is negative then text is
--   appended.
--   
--   This is the same as calling comboBoxTextInsert with a
--   Nothing ID string.
--   
--   Since: 2.24
comboBoxTextInsertText :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Int32 -> Text -> m ()

-- | Sets the current active item to be the one referenced by
--   iter, or unsets the active item if
--   iter is Nothing.
--   
--   Since: 2.4
comboBoxSetActiveIter :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Maybe TreeIter -> m ()

-- | Sets the model column which comboBox should use to get
--   string IDs for values from. The column idColumn in the
--   model of comboBox must be of type
--   G_TYPE_STRING.
--   
--   Since: 3.0
comboBoxSetIdColumn :: (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.
--   
--   Since: 2.6
comboBoxSetFocusOnClick :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Bool -> m ()

-- | Sets whether the popup menu should have a tearoff menu item.
--   
--   Since: 2.6
comboBoxSetAddTearoffs :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Bool -> m ()

-- | 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

-- | Unsets all the mappings on all renderers on cellLayout
--   and removes all renderers from cellLayout.
--   
--   Since: 2.4
cellLayoutClear :: (HasCallStack, MonadIO m, IsCellLayout a) => a -> m ()

-- | Memory-managed wrapper type.
newtype ColorSelectionDialog
ColorSelectionDialog :: ManagedPtr ColorSelectionDialog -> ColorSelectionDialog

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

-- | Sets the current color to be color.
--   
--   The first time this is called, it will also set the original color to
--   be color too.
colorSelectionSetCurrentColor :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> Color -> m ()

-- | Sets the current color to be rgba.
--   
--   The first time this is called, it will also set the original color to
--   be rgba too.
--   
--   Since: 3.0
colorSelectionSetCurrentRgba :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> RGBA -> m ()

-- | Memory-managed wrapper type.
newtype ColorChooserDialog
ColorChooserDialog :: ManagedPtr ColorChooserDialog -> ColorChooserDialog

-- | Memory-managed wrapper type.
newtype ColorButton
ColorButton :: ManagedPtr ColorButton -> ColorButton

-- | Clears the contents of the clipboard. Generally this should only be
--   called between the time you call
--   gtk_clipboard_set_with_owner() or
--   gtk_clipboard_set_with_data(), and when the
--   clearFunc you supplied is called. Otherwise, the
--   clipboard may be owned by someone else.
clipboardClear :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m ()

-- | Requests the contents of the clipboard as image and converts the
--   result to a Pixbuf. This function waits for the data to be
--   received using the main loop, so events, timeouts, etc, may be
--   dispatched during the wait.
--   
--   Since: 2.6
clipboardWaitForImage :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m (Maybe Pixbuf)

-- | 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.
--   
--   Since: 2.14
clipboardWaitForUris :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m (Maybe [Text])

-- | Returns the clipboard object for the given selection. Cut/copy/paste
--   menu items and keyboard shortcuts should use the default clipboard,
--   returned by passing GDK_SELECTION_CLIPBOARD for
--   selection. (GDK_NONE 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 GDK_SELECTION_PRIMARY.
--   Cut/copy/paste menu items conceptually copy the contents of the
--   GDK_SELECTION_PRIMARY clipboard to the default
--   clipboard, i.e. they copy the selection to what the user sees as the
--   clipboard.
--   
--   (Passing GDK_NONE is the same as using
--   gdk_atom_intern ("CLIPBOARD", FALSE).
--   
--   See the FreeDesktop Clipboard Specification for a detailed
--   discussion of the “CLIPBOARD” vs. “PRIMARY” selections under the X
--   window system. On Win32 the GDK_SELECTION_PRIMARY
--   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”.
--   
--   Since: 2.2
clipboardGetForDisplay :: (HasCallStack, MonadIO m, IsDisplay a) => a -> Atom -> m Clipboard

-- | Frees a SelectionData-struct returned from
--   selectionDataCopy.
selectionDataFree :: (HasCallStack, MonadIO m) => SelectionData -> m ()

-- | Returns whether the check menu item is active. See
--   gtk_check_menu_item_set_active ().
checkMenuItemGetActive :: (HasCallStack, MonadIO m, IsCheckMenuItem a) => a -> m Bool

-- | Memory-managed wrapper type.
newtype CheckMenuItem
CheckMenuItem :: ManagedPtr CheckMenuItem -> CheckMenuItem

-- | 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, checkMenuItemSetInconsistent only affects visual
--   appearance, it doesn’t affect the semantics of the widget.
checkMenuItemSetInconsistent :: (HasCallStack, MonadIO m, IsCheckMenuItem a) => a -> Bool -> m ()

-- | Memory-managed wrapper type.
newtype CellView
CellView :: ManagedPtr CellView -> CellView

-- | 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

-- | Makes the cell renderer activatable.
--   
--   Since: 2.18
cellRendererToggleSetActivatable :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> Bool -> m ()

-- | Activates or deactivates a cell renderer.
cellRendererToggleSetActive :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> Bool -> m ()

-- | Memory-managed wrapper type.
newtype CellRendererSpin
CellRendererSpin :: ManagedPtr CellRendererSpin -> CellRendererSpin

-- | Memory-managed wrapper type.
newtype CellRendererProgress
CellRendererProgress :: ManagedPtr CellRendererProgress -> CellRendererProgress

-- | Memory-managed wrapper type.
newtype CellRendererCombo
CellRendererCombo :: ManagedPtr CellRendererCombo -> CellRendererCombo

-- | Memory-managed wrapper type.
newtype CellRendererAccel
CellRendererAccel :: ManagedPtr CellRendererAccel -> CellRendererAccel

-- | Begins editing on a cellEditable.
--   
--   The CellRenderer for the cell creates and returns a
--   CellEditable from cellRendererStartEditing, configured
--   for the CellRenderer type.
--   
--   cellEditableStartEditing can then set up
--   cellEditable suitably for editing a cell, e.g. making
--   the Esc key emit CellEditable::editingDone.
--   
--   Note that the cellEditable 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 ()

-- | Informs the cell renderer that the editing is stopped. If
--   canceled is True, the cell renderer will emit
--   the CellRenderer::editingCanceled signal.
--   
--   This function should be called by cell renderer implementations in
--   response to the CellEditable::editingDone signal of
--   CellEditable.
--   
--   Since: 2.6
cellRendererStopEditing :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Bool -> m ()

-- | 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

-- | Resets any previously cached request and allocation data.
--   
--   When underlying TreeModel 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
--   cellAreaGetPreferredWidth.
--   
--   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
--   cellAreaGetPreferredHeightForWidth.
--   
--   Since 3.0
cellAreaContextReset :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m ()

-- | Retrieves a cell area’s initial minimum and natural height.
--   
--   area will store some geometrical information in
--   context along the way; when requesting sizes over an
--   arbitrary number of rows, it’s not important to check the
--   minimumHeight and naturalHeight of
--   this call but rather to consult
--   cellAreaContextGetPreferredHeight after a series of requests.
--   
--   Since: 3.0
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.
--   
--   area will store some geometrical information in
--   context along the way; when requesting sizes over an
--   arbitrary number of rows, it’s not important to check the
--   minimumWidth and naturalWidth of this
--   call but rather to consult cellAreaContextGetPreferredWidth
--   after a series of requests.
--   
--   Since: 3.0
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 width.
--   
--   area stores some geometrical information in
--   context along the way while calling
--   cellAreaGetPreferredWidth. It’s important to perform a series
--   of cellAreaGetPreferredWidth requests with
--   context first and then call
--   cellAreaGetPreferredHeightForWidth 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 cellAreaGetPreferredWidth again and then the
--   full width of the requested rows checked again with
--   cellAreaContextGetPreferredWidth.
--   
--   Since: 3.0
cellAreaGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Int32 -> m (Int32, Int32)

-- | Memory-managed wrapper type.
newtype CellAreaBox
CellAreaBox :: ManagedPtr CellAreaBox -> CellAreaBox

-- | Applies any connected attributes to the renderers in
--   area by pulling the values from
--   treeModel.
--   
--   Since: 3.0
cellAreaApplyAttributes :: (HasCallStack, MonadIO m, IsCellArea a, IsTreeModel b) => a -> b -> TreeIter -> Bool -> Bool -> m ()

-- | Gets the accumulative preferred height for all rows which have been
--   requested with this context.
--   
--   After cellAreaContextReset is called and/or before ever
--   requesting the size of a CellArea, the returned values are 0.
--   
--   Since: 3.0
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 cellAreaContextReset is called and/or before ever
--   requesting the size of a CellArea, the returned values are 0.
--   
--   Since: 3.0
cellAreaContextGetPreferredWidth :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m (Int32, Int32)

-- | Retrieves a cell area’s minimum and natural width if it would be given
--   the specified height.
--   
--   area stores some geometrical information in
--   context along the way while calling
--   cellAreaGetPreferredHeight. It’s important to perform a series
--   of cellAreaGetPreferredHeight requests with
--   context first and then call
--   cellAreaGetPreferredWidthForHeight 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 cellAreaGetPreferredHeight again and then the
--   full height of the requested rows checked again with
--   cellAreaContextGetPreferredHeight.
--   
--   Since: 3.0
cellAreaGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Int32 -> m (Int32, Int32)

-- | This is a convenience function for CellArea implementations to
--   request size for cell renderers. It’s important to use this function
--   to request size and then use cellAreaInnerCellArea at render
--   and event time since this function will add padding around the cell
--   for focus painting.
--   
--   Since: 3.0
cellAreaRequestRenderer :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b, IsWidget c) => a -> b -> Orientation -> c -> Int32 -> m (Int32, Int32)

-- | Adds sibling to renderer’s focusable
--   area, focus will be drawn around renderer and all of
--   its siblings if renderer can focus for a given row.
--   
--   Events handled by focus siblings can also activate the given focusable
--   renderer.
--   
--   Since: 3.0
cellAreaAddFocusSibling :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b, IsCellRenderer c) => a -> b -> c -> m ()

-- | This is a convenience function for CellArea implementations to
--   get the inner area where a given CellRenderer will be rendered.
--   It removes any padding previously added by
--   cellAreaRequestRenderer.
--   
--   Since: 3.0
cellAreaInnerCellArea :: (HasCallStack, MonadIO m, IsCellArea a, IsWidget b) => a -> b -> Rectangle -> m Rectangle

-- | Gets the CellRenderer in area that is currently
--   being edited.
--   
--   Since: 3.0
cellAreaGetEditedCell :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m CellRenderer

-- | Gets the CellEditable widget currently used to edit the
--   currently edited cell.
--   
--   Since: 3.0
cellAreaGetEditWidget :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m CellEditable

-- | 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

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

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

-- | Used to dictate the style that a ButtonBox 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 boxSetHomogeneous and boxSetSpacing
--   manually). Since 3.12.
ButtonBoxStyleExpand :: ButtonBoxStyle

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

-- | Set the image of button to the given widget. The image
--   will be displayed if the label text is Nothing or if
--   Button:alwaysShowImage is True. You don’t have to call
--   widgetShow on image yourself.
--   
--   Since: 2.6
buttonSetImage :: (HasCallStack, MonadIO m, IsButton a, IsWidget b) => a -> Maybe b -> m ()

-- | Creates a new Button containing a label. If characters in
--   label 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

-- | 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.
--   
--   Since: 2.4
buttonSetFocusOnClick :: (HasCallStack, MonadIO m, IsButton a) => a -> Bool -> m ()

-- | Creates a new Button containing the image and text from a
--   [stock item][gtkstock]. Some stock ids have preprocessor macros like
--   STOCK_OK and STOCK_APPLY.
--   
--   If stockId is unknown, then it will be treated as a
--   mnemonic label (as for buttonNewWithMnemonic).
buttonNewFromStock :: (HasCallStack, MonadIO m) => Text -> m Button

-- | Sets the text of the label of the button to str. This
--   text is also used to select the stock item if buttonSetUseStock
--   is used.
--   
--   This will also clear any previously set labels.
buttonSetLabel :: (HasCallStack, MonadIO m, IsButton a) => a -> Text -> m ()

-- | If True, 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 ()

-- | Parses a file containing a [GtkBuilder UI definition][BUILDER-UI] and
--   merges it with the current contents of builder.
--   
--   Most users will probably want to use builderNewFromFile.
--   
--   If an error occurs, 0 will be returned and error will
--   be assigned a GError from the
--   GTK_BUILDER_ERROR, G_MARKUP_ERROR or
--   G_FILE_ERROR 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 Builder 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 g_error().
--   
--   Since: 2.12
builderAddFromFile :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> m Word32

-- | Parses a resource file containing a [GtkBuilder UI
--   definition][BUILDER-UI] and merges it with the current contents of
--   builder.
--   
--   Most users will probably want to use builderNewFromResource.
--   
--   If an error occurs, 0 will be returned and error will
--   be assigned a GError from the
--   GTK_BUILDER_ERROR, G_MARKUP_ERROR or
--   G_RESOURCE_ERROR 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
--   g_error().
--   
--   Since: 3.4
builderAddFromResource :: (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 builder.
--   
--   Most users will probably want to use builderNewFromString.
--   
--   Upon errors 0 will be returned and error will be
--   assigned a GError from the GTK_BUILDER_ERROR,
--   G_MARKUP_ERROR or
--   G_VARIANT_PARSE_ERROR 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
--   g_error().
--   
--   Since: 2.12
builderAddFromString :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> Int64 -> m Word32

-- | Builds the [GtkBuilder UI definition][BUILDER-UI] in the file
--   filename.
--   
--   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.
--   
--   Since: 3.10
builderNewFromFile :: (HasCallStack, MonadIO m) => Text -> m Builder

-- | Builds the [GtkBuilder UI definition][BUILDER-UI] at
--   resourcePath.
--   
--   If there is an error locating the resource or parsing the description,
--   then the program will be aborted.
--   
--   Since: 3.10
builderNewFromResource :: (HasCallStack, MonadIO m) => Text -> m Builder

-- | Builds the user interface described by string (in the
--   [GtkBuilder UI definition][BUILDER-UI] format).
--   
--   If string is Nothing-terminated, then
--   length should be -1. If length is not
--   -1, then it is the length of string.
--   
--   If there is an error parsing string then the program
--   will be aborted. You should not attempt to parse user interface
--   description from untrusted sources.
--   
--   Since: 3.10
builderNewFromString :: (HasCallStack, MonadIO m) => Text -> Int64 -> m Builder

-- | Sets the application associated with builder.
--   
--   You only need this function if there is more than one
--   Application in your process. application cannot
--   be Nothing.
--   
--   Since: 3.10
builderSetApplication :: (HasCallStack, MonadIO m, IsBuilder a, IsApplication b) => a -> b -> m ()

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

-- | This function demarshals a value from a string. This function calls
--   valueInit on the value argument, so it need not
--   be initialised beforehand.
--   
--   This function can handle char, uchar, boolean, int, uint, long, ulong,
--   enum, flags, float, double, string, Color, RGBA and
--   Adjustment type values. Support for Widget type values
--   is still to come.
--   
--   Upon errors False will be returned and error
--   will be assigned a GError from the
--   GTK_BUILDER_ERROR domain.
--   
--   Since: 2.12
builderValueFromString :: (HasCallStack, MonadIO m, IsBuilder a) => a -> GParamSpec -> Text -> m GValue

-- | 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 position is used to
--   allocate the baseline wrt the extra space available.
--   
--   Since: 3.10
boxSetBaselinePosition :: (HasCallStack, MonadIO m, IsBox a) => a -> BaselinePosition -> m ()

-- | A function used by assistantSetForwardPageFunc 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 AspectFrame
AspectFrame :: ManagedPtr AspectFrame -> AspectFrame

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

-- | Associates a shortcuts window with the application window, and sets up
--   an action with the name win.show-help-overlay to present it.
--   
--   window takes resposibility for destroying
--   helpOverlay.
--   
--   Since: 3.20
applicationWindowSetHelpOverlay :: (HasCallStack, MonadIO m, IsApplicationWindow a, IsShortcutsWindow b) => a -> Maybe b -> m ()

-- | Types of user actions that may be blocked by
--   applicationInhibit.
--   
--   Since: 3.4
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

-- | Returns the unique ID of the window. If the window has not yet been
--   added to a Application, returns 0.
--   
--   Since: 3.6
applicationWindowGetId :: (HasCallStack, MonadIO m, IsApplicationWindow a) => a -> m Word32

-- | Removes an inhibitor that has been established with
--   applicationInhibit. Inhibitors are also cleared when the
--   application exits.
--   
--   Since: 3.4
applicationUninhibit :: (HasCallStack, MonadIO m, IsApplication a) => a -> Word32 -> m ()

-- | Sets zero or more keyboard accelerators that will trigger the given
--   action. The first item in accels 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 accels.
--   
--   For the detailedActionName, see
--   actionParseDetailedName and actionPrintDetailedName.
--   
--   Since: 3.12
applicationSetAccelsForAction :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> [Text] -> m ()

-- | Installs an accelerator that will cause the named action to be
--   activated when the key combination specificed by
--   accelerator is pressed.
--   
--   accelerator must be a string that can be parsed by
--   acceleratorParse, e.g. "<Primary>q" or
--   “<Control><Alt>p”.
--   
--   actionName 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 GMenuModels passed to applicationSetAppMenu
--   and applicationSetMenubar, which is usually more convenient
--   than calling this function for each accelerator.
--   
--   Since: 3.4
applicationAddAccelerator :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> Text -> Maybe GVariant -> m ()

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

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

-- | 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
--   AppChooserButton::customItemActivated signal, to add a callback
--   for the activation of a particular custom item in the list. See also
--   appChooserButtonAppendSeparator.
--   
--   Since: 3.0
appChooserButtonAppendCustomItem :: (HasCallStack, MonadIO m, IsAppChooserButton a, IsIcon b) => a -> Text -> Text -> b -> m ()

-- | Memory-managed wrapper type.
newtype AppChooserButton
AppChooserButton :: ManagedPtr AppChooserButton -> AppChooserButton

-- | Appends a separator to the list of applications that is shown in the
--   popup.
--   
--   Since: 3.0
appChooserButtonAppendSeparator :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> m ()

-- | Reloads the list of applications.
--   
--   Since: 3.0
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 accelPath string will be stored in a
--   GQuark. Therefore, if you pass a static string, you
--   can save some memory by interning it first with
--   internStaticString.
--   
--   Since: 2.4
actionSetAccelPath :: (HasCallStack, MonadIO m, IsAction a) => a -> Text -> m ()

-- | Returns whether the action is effectively sensitive.
--   
--   Since: 2.4
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 actionIsSensitive
--   for that.
--   
--   Since: 2.4
actionGetSensitive :: (HasCallStack, MonadIO m, IsAction a) => a -> m Bool

-- | Returns whether the action is effectively visible.
--   
--   Since: 2.4
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 actionIsSensitive
--   for that.
--   
--   Since: 2.4
actionGetVisible :: (HasCallStack, MonadIO m, IsAction a) => a -> m Bool

-- | Sets the translation domain and uses dgettext for translating
--   the label and tooltip of
--   GtkActionEntrys added by
--   gtk_action_group_add_actions().
--   
--   If you’re not using gettext() for localization, see
--   actionGroupSetTranslateFunc.
--   
--   Since: 2.4
actionGroupSetTranslationDomain :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> Maybe Text -> m ()

-- | Sets a function to be used for translating the label
--   and tooltip of GtkActionEntrys added
--   by gtk_action_group_add_actions().
--   
--   If you’re using gettext(), it is enough to set the
--   translation domain with actionGroupSetTranslationDomain.
--   
--   Since: 2.4
actionGroupSetTranslateFunc :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> TranslateFunc -> m ()

-- | Memory-managed wrapper type.
newtype ActionBar
ActionBar :: ManagedPtr ActionBar -> ActionBar

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

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

-- | 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.
--   
--   Since: 2.4
actionActivate :: (HasCallStack, MonadIO m, IsAction a) => a -> m ()

-- | Sets the AccelGroup in which the accelerator for this action
--   will be installed.
--   
--   Since: 2.4
actionSetAccelGroup :: (HasCallStack, MonadIO m, IsAction a, IsAccelGroup b) => a -> Maybe b -> m ()

-- | Undoes the effect of one call to actionConnectAccelerator.
--   
--   Since: 2.4
actionDisconnectAccelerator :: (HasCallStack, MonadIO m, IsAction a) => a -> m ()

-- | Installs the accelerator for action if
--   action has an accel path and group. See
--   actionSetAccelPath and actionSetAccelGroup
--   
--   Since multiple proxies may independently trigger the installation of
--   the accelerator, the action counts the number of times
--   this function has been called and doesn’t remove the accelerator until
--   actionDisconnectAccelerator has been called as many times.
--   
--   Since: 2.4
actionConnectAccelerator :: (HasCallStack, MonadIO m, IsAction a) => a -> m ()

-- | Gets the related Action for activatable.
--   
--   Since: 2.16
activatableGetRelatedAction :: (HasCallStack, MonadIO m, IsActivatable a) => a -> m Action

-- | Memory-managed wrapper type.
newtype Accessible
Accessible :: ManagedPtr Accessible -> Accessible

-- | Changes the accelKey and accelMods
--   currently associated with accelPath. Due to conflicts
--   with other accelerators, a change may not always be possible,
--   replace 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 True return value.
--   
--   Note that accelPath string will be stored in a
--   GQuark. Therefore, if you pass a static string, you
--   can save some memory by interning it first with
--   internStaticString.
accelMapChangeEntry :: (HasCallStack, MonadIO m) => Text -> Word32 -> [ModifierType] -> Bool -> m Bool

-- | 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 accelMapForeach.
--   
--   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 ()

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

-- | Memory-managed wrapper type.
newtype AccelMap
AccelMap :: ManagedPtr AccelMap -> AccelMap

-- | Parses a file previously saved with accelMapSave for
--   accelerator specifications, and propagates them accordingly.
accelMapLoad :: (HasCallStack, MonadIO m) => [Char] -> m ()

-- | Undoes the last call to accelMapLockPath on this
--   accelPath. Refer to accelMapLockPath for
--   information about accelerator path locking.
--   
--   Since: 2.4
accelMapUnlockPath :: (HasCallStack, MonadIO m) => Text -> m ()

-- | Locks the given accelerator path. If the accelerator map doesn’t yet
--   contain an entry for accelPath, 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
--   accelMapUnlockPath. Refer to accelMapChangeEntry for
--   information about runtime accelerator changes.
--   
--   If called more than once, accelPath remains locked
--   until accelMapUnlockPath has been called an equivalent number
--   of times.
--   
--   Note that locking of individual accelerator paths is independent from
--   locking the AccelGroup containing them. For runtime accelerator
--   changes to be possible, both the accelerator path and its
--   AccelGroup have to be unlocked.
--   
--   Since: 2.4
accelMapLockPath :: (HasCallStack, MonadIO m) => Text -> m ()

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

-- | Manually sets a keyval and modifier mask as the accelerator rendered
--   by accelLabel.
--   
--   If a keyval and modifier are explicitly set then these values are used
--   regardless of any associated accel closure or widget.
--   
--   Providing an acceleratorKey of 0 removes the manual
--   setting.
--   
--   Since: 3.6
accelLabelSetAccel :: (HasCallStack, MonadIO m, IsAccelLabel a) => a -> Word32 -> [ModifierType] -> m ()

-- | Sets the widget to be monitored by this accelerator label. Passing
--   Nothing for accelWidget will dissociate
--   accelLabel from its current widget, if any.
accelLabelSetAccelWidget :: (HasCallStack, MonadIO m, IsAccelLabel a, IsWidget b) => a -> Maybe b -> m ()

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

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

-- | Locks the given accelerator group.
--   
--   Locking an acelerator group prevents the accelerators contained within
--   it to be changed during runtime. Refer to accelMapChangeEntry
--   about runtime accelerator changes.
--   
--   If called more than once, accelGroup remains locked
--   until accelGroupUnlock has been called an equivalent number of
--   times.
accelGroupLock :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> m ()

-- | Undoes the last call to accelGroupLock on this
--   accelGroup.
accelGroupUnlock :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> m ()

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

-- | Memory-managed wrapper type.
newtype AboutDialog
AboutDialog :: ManagedPtr AboutDialog -> AboutDialog

-- | Sets the license of the application showing the about
--   dialog from a list of known licenses.
--   
--   This function overrides the license set using
--   aboutDialogSetLicense.
--   
--   Since: 3.0
aboutDialogSetLicenseType :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> License -> m ()

-- | Sets the license information to be displayed in the secondary license
--   dialog. If license is Nothing, the license
--   button is hidden.
--   
--   Since: 2.6
aboutDialogSetLicense :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets an icon to be used as fallback for windows that haven't had
--   windowSetIcon called on them from a pixbuf.
--   
--   Since: 2.4
windowSetDefaultIcon :: (HasCallStack, MonadIO m, IsPixbuf a) => a -> m ()

-- | The GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID can be used to make a
--   TreeSortable use the default sort function.
--   
--   See also treeSortableSetSortColumnId
pattern TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID :: Int32

-- | The GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID can be used to make a
--   TreeSortable use no sorting.
--   
--   See also treeSortableSetSortColumnId
pattern TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID :: Int32

-- | These flags indicate various properties of a TreeModel.
--   
--   They are returned by treeModelGetFlags, and must be static for
--   the lifetime of the object. A more complete description of
--   GTK_TREE_MODEL_ITERS_PERSIST 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 TreeDragSource
TreeDragSource :: ManagedPtr TreeDragSource -> TreeDragSource

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

-- | Returns the ellipsize mode used for toolItem. Custom
--   subclasses of ToolItem should call this function to find out
--   how text should be ellipsized.
--   
--   Since: 2.20
toolItemGetEllipsizeMode :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m EllipsizeMode

-- | Returns the icon size used for toolItem. Custom
--   subclasses of ToolItem should call this function to find out
--   what size icons they should use.
--   
--   Since: 2.4
toolItemGetIconSize :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Int32

-- | Returns the orientation used for toolItem. Custom
--   subclasses of ToolItem should call this function to find out
--   what size icons they should use.
--   
--   Since: 2.4
toolItemGetOrientation :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Orientation

-- | Returns the relief style of toolItem. See
--   buttonSetRelief. Custom subclasses of ToolItem should
--   call this function in the handler of the
--   ToolItem::toolbar_reconfigured signal to find
--   out the relief style of buttons.
--   
--   Since: 2.4
toolItemGetReliefStyle :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m ReliefStyle

-- | Returns the toolbar style used for toolItem. Custom
--   subclasses of ToolItem should call this function in the handler
--   of the GtkToolItemtoolbar_reconfigured signal to find out in
--   what style the toolbar is displayed and change themselves accordingly
--   
--   Possibilities are: * ToolbarStyleBoth, meaning the tool item
--   should show both an icon and a label, stacked vertically *
--   ToolbarStyleIcons, meaning the toolbar shows only icons *
--   ToolbarStyleText, meaning the tool item should only show text *
--   ToolbarStyleBothHoriz, meaning the tool item should show both
--   an icon and a label, arranged horizontally
--   
--   Since: 2.4
toolItemGetToolbarStyle :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m ToolbarStyle

-- | Returns the text alignment used for toolItem. Custom
--   subclasses of ToolItem should call this function to find out
--   how text should be aligned.
--   
--   Since: 2.20
toolItemGetTextAlignment :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Float

-- | Returns the text orientation used for toolItem. Custom
--   subclasses of ToolItem should call this function to find out
--   how text should be orientated.
--   
--   Since: 2.20
toolItemGetTextOrientation :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Orientation

-- | Returns the size group used for labels in toolItem.
--   Custom subclasses of ToolItem should call this function and use
--   the size group for labels.
--   
--   Since: 2.20
toolItemGetTextSizeGroup :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m SizeGroup

-- | Sets filter as the current RecentFilter object
--   used by chooser to affect the displayed recently used
--   resources.
--   
--   Since: 2.10
recentChooserSetFilter :: (HasCallStack, MonadIO m, IsRecentChooser a, IsRecentFilter b) => a -> Maybe b -> m ()

-- | Gets the list of recently used resources in form of RecentInfo
--   objects.
--   
--   The return value of this function is affected by the “sort-type” and
--   “limit” properties of chooser.
--   
--   Since: 2.10
recentChooserGetItems :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m [RecentInfo]

-- | Gets the URI of the recently used resources.
--   
--   The return value of this function is affected by the “sort-type” and
--   “limit” properties of chooser.
--   
--   Since the returned array is Nothing terminated,
--   length may be Nothing.
--   
--   Since: 2.10
recentChooserGetUris :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m ([Text], CSize)

-- | Sets whether only local resources, that is resources using the file://
--   URI scheme, should be shown in the recently used resources selector.
--   If localOnly is True (the default) then the
--   shown resources are guaranteed to be accessible through the operating
--   system native file system.
--   
--   Since: 2.10
recentChooserSetLocalOnly :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Bool -> m ()

-- | Changes the sorting order of the recently used resources list
--   displayed by chooser.
--   
--   Since: 2.10
recentChooserSetSortType :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> RecentSortType -> m ()

-- | Sets the currently-selected font.
--   
--   Since: 3.2
fontChooserSetFont :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Text -> m ()

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

-- | 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
--   FileChooser::updatePreview signal, and call
--   fileChooserGetPreviewFilename or
--   fileChooserGetPreviewUri on each change. If you can display a
--   preview of the new file, update your widget and set the preview active
--   using fileChooserSetPreviewWidgetActive. 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.
--   
--   Since: 2.4
fileChooserSetPreviewWidget :: (HasCallStack, MonadIO m, IsFileChooser a, IsWidget b) => a -> b -> m ()

-- | Gets the filename that should be previewed in a custom preview widget.
--   See fileChooserSetPreviewWidget.
--   
--   Since: 2.4
fileChooserGetPreviewFilename :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe [Char])

-- | Gets the URI that should be previewed in a custom preview widget. See
--   fileChooserSetPreviewWidget.
--   
--   Since: 2.4
fileChooserGetPreviewUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe Text)

-- | Sets whether the preview widget set by
--   fileChooserSetPreviewWidget should be shown for the current
--   filename. When active 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
--   fileChooserSetPreviewWidget for more details.
--   
--   Since: 2.4
fileChooserSetPreviewWidgetActive :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | Sets whether the file chooser should display a stock label with the
--   name of the file that is being previewed; the default is True.
--   Applications that want to draw the whole preview area themselves
--   should set this to False and display the name themselves in
--   their preview widget.
--   
--   See also: fileChooserSetPreviewWidget
--   
--   Since: 2.4
fileChooserSetUsePreviewLabel :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | Selects a filename. If the file name isn’t in the current folder of
--   chooser, then the current folder of
--   chooser will be changed to the folder containing
--   filename.
--   
--   Since: 2.4
fileChooserSelectFilename :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> [Char] -> m Bool

-- | 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.
--   
--   Since: 2.4
fileChooserUnselectFilename :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> [Char] -> m ()

-- | 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.
--   
--   Since: 2.4
fileChooserGetFilename :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe [Char])

-- | Lists all the selected files and subfolders in the current folder of
--   chooser. The returned names are full absolute paths.
--   If files in the current folder cannot be represented as local
--   filenames they will be ignored. (See fileChooserGetUris)
--   
--   Since: 2.4
fileChooserGetFilenames :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m [[Char]]

-- | Selects the file to by uri. If the URI doesn’t refer
--   to a file in the current folder of chooser, then the
--   current folder of chooser will be changed to the
--   folder containing filename.
--   
--   Since: 2.4
fileChooserSelectUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m Bool

-- | Unselects the file referred to by uri. If the file is
--   not in the current directory, does not exist, or is otherwise not
--   currently selected, does nothing.
--   
--   Since: 2.4
fileChooserUnselectUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m ()

-- | 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.
--   
--   Since: 2.4
fileChooserGetUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe Text)

-- | Lists all the selected files and subfolders in the current folder of
--   chooser. The returned names are full absolute URIs.
--   
--   Since: 2.4
fileChooserGetUris :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m [Text]

-- | Sets the current folder for chooser 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.
--   
--   Since: 2.4
fileChooserSetCurrentFolder :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> [Char] -> m Bool

-- | Gets the current folder of chooser as a local
--   filename. See fileChooserSetCurrentFolder.
--   
--   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
--   FileChooserActionSelectFolder mode (e.g.
--   "/home/username/Documents/selected-folder/". To get the
--   currently-selected folder in that mode, use fileChooserGetUri
--   as the usual way to get the selection.
--   
--   Since: 2.4
fileChooserGetCurrentFolder :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe [Char])

-- | Sets the current folder for chooser 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.
--   
--   Since: 2.4
fileChooserSetCurrentFolderUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m Bool

-- | Gets the current folder of chooser as an URI. See
--   fileChooserSetCurrentFolderUri.
--   
--   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
--   FileChooserActionSelectFolder mode (e.g.
--   "file:///home/username/Documents/selected-folder/". To get the
--   currently-selected folder in that mode, use fileChooserGetUri
--   as the usual way to get the selection.
--   
--   Since: 2.4
fileChooserGetCurrentFolderUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe Text)

-- | Describes whether a FileChooser 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

-- | Sets whether a file chooser in FileChooserActionSave mode will
--   present a confirmation dialog if the user types a file name that
--   already exists. This is False by default.
--   
--   If set to True, the chooser will emit the
--   FileChooser::confirmOverwrite signal when appropriate.
--   
--   If all you need is the stock confirmation dialog, set this property to
--   True. You can override the way confirmation is done by actually
--   handling the FileChooser::confirmOverwrite signal; please refer
--   to its documentation for the details.
--   
--   Since: 2.8
fileChooserSetDoOverwriteConfirmation :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | Used as a return value of handlers for the
--   FileChooser::confirmOverwrite signal of a FileChooser.
--   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.
--   
--   Since: 2.8
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

-- | Selects an option in a 'choice' that has been added with
--   fileChooserAddChoice. For a boolean choice, the possible
--   options are "true" and "false".
--   
--   Since: 3.22
fileChooserSetChoice :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> Text -> m ()

-- | Gets the currently selected option in the 'choice' with the given ID.
--   
--   Since: 3.22
fileChooserGetChoice :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m Text

-- | Sets an application-supplied widget to provide extra options to the
--   user.
--   
--   Since: 2.4
fileChooserSetExtraWidget :: (HasCallStack, MonadIO m, IsFileChooser a, IsWidget b) => a -> b -> m ()

-- | 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
--   FileChooserActionSave but not if the action is
--   FileChooserActionOpen.
--   
--   Since: 2.4
fileChooserSetAction :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> FileChooserAction -> m ()

-- | Sets whether file choser will offer to create new folders. This is
--   only relevant if the action is not set to be
--   FileChooserActionOpen.
--   
--   Since: 2.18
fileChooserSetCreateFolders :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | 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.
--   
--   Since: 2.4
fileChooserSetFilter :: (HasCallStack, MonadIO m, IsFileChooser a, IsFileFilter b) => a -> b -> m ()

-- | Sets whether only local files can be selected in the file selector. If
--   localOnly is True (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
--   FileChooser, like fileChooserGetFilename, rather than
--   the URI functions like fileChooserGetUri,
--   
--   On some systems non-native files may still be available using the
--   native filesystem via a userspace filesystem (FUSE).
--   
--   Since: 2.4
fileChooserSetLocalOnly :: (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
--   FileChooserActionOpen or FileChooserActionSelectFolder.
--   
--   Since: 2.4
fileChooserSetSelectMultiple :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | Sets whether hidden files and folders are displayed in the file
--   selector.
--   
--   Since: 2.6
fileChooserSetShowHidden :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | Adds filter 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 chooser takes ownership of the filter,
--   so you have to ref and sink it if you want to keep a reference.
--   
--   Since: 2.4
fileChooserAddFilter :: (HasCallStack, MonadIO m, IsFileChooser a, IsFileFilter b) => a -> b -> m ()

-- | Removes filter from the list of filters that the user
--   can select between.
--   
--   Since: 2.4
fileChooserRemoveFilter :: (HasCallStack, MonadIO m, IsFileChooser a, IsFileFilter b) => a -> b -> 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.
--   
--   Since: 2.4
fileChooserAddShortcutFolderUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> 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.
--   
--   Since: 2.4
fileChooserAddShortcutFolder :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> [Char] -> m ()

-- | 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 fileChooserSetChoice before the dialog is shown,
--   and you can obtain the user-selected value in the response
--   signal handler using fileChooserGetChoice.
--   
--   Compare fileChooserSetExtraWidget.
--   
--   Since: 3.22
fileChooserAddChoice :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> Text -> Maybe [Text] -> Maybe [Text] -> m ()

-- | Sets filename 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
--   chooser is in FileChooserActionSave 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:
--   
--   
C code
--   
--   
--   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);
--     }
--   
--   
--   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.
--   
--   Since: 2.4
fileChooserSetFilename :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> [Char] -> m Bool

-- | Sets the file referred to by uri 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 chooser
--   is FileChooserActionSave 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:
--   
--   
C code
--   
--   
--   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);
--     }
--   
--   
--   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.
--   
--   Since: 2.4
fileChooserSetUri :: (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 name.
--   
--   If you want to preselect a particular existing file, you should use
--   fileChooserSetFilename or fileChooserSetUri instead.
--   Please see the documentation for those functions for an example of
--   using fileChooserSetCurrentName as well.
--   
--   Since: 2.4
fileChooserSetCurrentName :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m ()

-- | Unselects all the files in the current folder of a file chooser.
--   
--   Since: 2.4
fileChooserUnselectAll :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m ()

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

-- | Emits the CellEditable::removeWidget signal.
cellEditableRemoveWidget :: (HasCallStack, MonadIO m, IsCellEditable a) => a -> m ()

-- | Emits the CellEditable::editingDone signal.
cellEditableEditingDone :: (HasCallStack, MonadIO m, IsCellEditable a) => a -> m ()

-- | Starts editing the contents of this cell, through a
--   new CellEditable widget created by the
--   CellRendererClass.start_editing virtual
--   function.
cellRendererStartEditing :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> Maybe Event -> b -> Text -> Rectangle -> Rectangle -> [CellRendererState] -> m (Maybe CellEditable)

-- | Called when the builder finishes the parsing of a [GtkBuilder UI
--   definition][BUILDER-UI]. Note that this will be called once for each
--   time builderAddFromFile or builderAddFromString is
--   called on a builder.
--   
--   Since: 2.12
buildableParserFinished :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b) => a -> b -> m ()

-- | Sets the name of the buildable object.
--   
--   Since: 2.12
buildableSetName :: (HasCallStack, MonadIO m, IsBuildable a) => a -> Text -> m ()

-- | Memory-managed wrapper type.
newtype AppChooser
AppChooser :: ManagedPtr AppChooser -> AppChooser

-- | Specifies the name of the action with which this widget should be
--   associated. If actionName is Nothing 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 ApplicationWindow.
--   
--   Names are of the form “win.save” or “app.quit” for actions on the
--   containing ApplicationWindow or its associated
--   Application, respectively. This is the same form used for
--   actions in the Menu associated with the window.
--   
--   Since: 3.4
actionableSetActionName :: (HasCallStack, MonadIO m, IsActionable a) => a -> Maybe Text -> m ()

-- | Sets the target value of an actionable widget.
--   
--   If targetValue is Nothing 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 Actionable
--   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
--   Action 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).
--   
--   Since: 3.4
actionableSetActionTargetValue :: (HasCallStack, MonadIO m, IsActionable a) => a -> Maybe GVariant -> m ()

-- | 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 percentage
--   argument.
--   
--   Since: 2.14
testSliderSetPerc :: (HasCallStack, MonadIO m, IsWidget a) => a -> Double -> m ()

-- | Force registration of all core Gtk+ and Gdk object types. This allowes
--   to refer to any of those object types via typeFromName after
--   calling this function.
--   
--   Since: 2.14
testRegisterAllTypes :: (HasCallStack, MonadIO m) => m ()

-- | This function will search widget and all its
--   descendants for a GtkLabel widget with a text string matching
--   labelPattern. The labelPattern may
--   contain asterisks “*” and question marks “?” as placeholders,
--   g_pattern_match() 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 gtk_test_init() for more
--   details.
--   
--   Since: 2.14
testFindLabel :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m Widget

-- | This function will search siblings of baseWidget and
--   siblings of its ancestors for all widgets matching
--   widgetType. Of the matching widgets, the one that is
--   geometrically closest to baseWidget 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.
--   
--   Since: 2.14
testFindSibling :: (HasCallStack, MonadIO m, IsWidget a) => a -> GType -> m Widget

-- | This function will generate a button click (button
--   press and button release event) in the middle of the first GdkWindow
--   found that belongs to widget. For windowless widgets
--   like Button (which returns False from
--   widgetGetHasWindow), this will often be an input-only event
--   window. For other widgets, this is usually widget->window. Certain
--   caveats should be considered when using this function, in particular
--   because the mouse pointer is warped to the button click location, see
--   testSimulateButton for details.
--   
--   Since: 2.14
testWidgetClick :: (HasCallStack, MonadIO m, IsWidget a) => a -> Word32 -> [ModifierType] -> m Bool

-- | This function frees a target table as returned by
--   targetTableNewFromList
--   
--   Since: 2.10
targetTableFree :: (HasCallStack, MonadIO m) => [TargetEntry] -> m ()

-- | This function creates an TargetEntry array that contains the
--   same targets as the passed list. The returned table is
--   newly allocated and should be freed using targetTableFree when
--   no longer needed.
--   
--   Since: 2.10
targetTableNewFromList :: (HasCallStack, MonadIO m) => TargetList -> m [TargetEntry]

-- | Registers each of the stock items in items. If an item
--   already exists with the same stock ID as one of the
--   items, the old item gets replaced. The stock items are
--   copied, so GTK+ does not hold any pointer into items
--   and items can be freed. Use stockAddStatic if
--   items is persistent and GTK+ need not copy the array.
stockAdd :: (HasCallStack, MonadIO m) => [StockItem] -> m ()

-- | Same as stockAdd, but doesn’t copy items, so
--   items must persist until application exit.
stockAddStatic :: (HasCallStack, MonadIO m) => [StockItem] -> m ()

-- | A convenience function for launching the default application to show
--   the uri. Like showUriOnWindow, 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.
--   
--   Since: 2.14
showUri :: (HasCallStack, MonadIO m, IsScreen a) => Maybe a -> Text -> Word32 -> m ()

-- | Renders the icon in surface at the specified
--   x and y coordinates.
--   
--   Since: 3.10
renderIconSurface :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Surface -> Double -> Double -> m ()

-- | Priorities for path lookups. See also bindingSetAddPath.
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

-- | Parses a color in the format expected in a RC file. If
--   style is not Nothing, it will be consulted to
--   resolve references to symbolic colors.
--   
--   Since: 2.12
rcParseColorFull :: (HasCallStack, MonadIO m, IsRcStyle a) => Scanner -> Maybe a -> m (Word32, Color)

-- | Finds all matching RC styles for a given widget, composites them
--   together, and then creates a Style 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

-- | 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 mainDoEvent.
--   Depending on the type of event, existence of modal dialogs, grabs,
--   etc., the event may be propagated; if so, this function is used.
--   
--   propagateEvent calls widgetEvent on each widget it
--   decides to send the event to. So widgetEvent is the
--   lowest-level function; it simply emits the Widget::event and
--   possibly an event-specific signal on a widget. propagateEvent
--   is a bit higher-level, and mainDoEvent 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
--   windowInvalidateRect or widgetQueueDraw instead of
--   making up expose events.
propagateEvent :: (HasCallStack, MonadIO m, IsWidget a) => a -> Event -> 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 mainDoEvent so the event will
--   behave as if it were in the event queue. Don’t synthesize expose
--   events; instead, use windowInvalidateRect to invalidate a
--   region of the window.
widgetEvent :: (HasCallStack, MonadIO m, IsWidget a) => a -> Event -> m Bool

-- | Runs a page setup dialog, letting the user modify the values from
--   pageSetup. If the user cancels the dialog, the
--   returned PageSetup is identical to the passed in
--   pageSetup, 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 printRunPageSetupDialogAsync if this is a
--   problem.
--   
--   Since: 2.10
printRunPageSetupDialog :: (HasCallStack, MonadIO m, IsWindow a, IsPageSetup b, IsPrintSettings c) => Maybe a -> Maybe b -> c -> m PageSetup

-- | Runs a single iteration of the mainloop. If no events are available
--   either return or block depending on the value of
--   blocking.
mainIterationDo :: (HasCallStack, MonadIO m) => Bool -> m Bool

-- | Obtains a copy of the event currently being processed by GTK+.
--   
--   For example, if you are handling a Button::clicked signal, the
--   current event will be the EventButton that triggered the
--   clicked signal.
getCurrentEvent :: (HasCallStack, MonadIO m) => m (Maybe Event)

-- | Makes the innermost invocation of the main loop return when it regains
--   control.
mainQuit :: (HasCallStack, MonadIO m) => m ()

-- | This function does the same work as initCheck. Additionally, it
--   allows you to add your own commandline options, and it automatically
--   generates nicely formatted --help output. Note that your
--   program will be terminated after writing out the help output.
--   
--   Since: 2.6
initWithArgs :: (HasCallStack, MonadIO m) => Maybe [Text] -> Maybe Text -> [OptionEntry] -> Maybe Text -> m (Maybe [Text])

-- | Returns a OptionGroup for the commandline arguments recognized
--   by GTK+ and GDK.
--   
--   You should add this group to your OptionContext with
--   optionContextAddGroup, if you are using
--   optionContextParse to parse your commandline arguments.
--   
--   Since: 2.6
getOptionGroup :: (HasCallStack, MonadIO m) => Bool -> m OptionGroup

-- | Obtains the current default reading direction. See
--   widgetSetDefaultDirection.
widgetGetDefaultDirection :: (HasCallStack, MonadIO m) => m TextDirection

-- | All this function does it to return True.
--   
--   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...
--   
--   
A persistent window
--   
--   
C code
--   
--   
--   #include <gtk/gtk.h>
--   
--   int
--   main (int argc, char **argv)
--   {
--     GtkWidget *win, *but;
--     const char *text = "Close yourself. I mean it!";
--   
--     gtk_init (&argc, &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;
--   }
--   
true :: (HasCallStack, MonadIO m) => m Bool

-- | Sets the icon for a given drag from a named themed icon. See the docs
--   for IconTheme for more details. Note that the size of the icon
--   depends on the icon theme (the icon is loaded at the symbolic size
--   GTK_ICON_SIZE_DND), thus hotX and
--   hotY have to be used with care.
--   
--   Since: 2.8
dragSetIconName :: (HasCallStack, MonadIO m, IsDragContext a) => a -> Text -> Int32 -> Int32 -> m ()

-- | Removes a device grab from the given widget.
--   
--   You have to pair calls to deviceGrabAdd and
--   deviceGrabRemove.
--   
--   Since: 3.0
deviceGrabRemove :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> m ()

-- | Parses a string representing an accelerator, similarly to
--   acceleratorParse but handles keycodes as well. This is only
--   useful for system-level components, applications should use
--   acceleratorParse instead.
--   
--   If acceleratorCodes is given and the result stored in
--   it is non-Nothing, the result must be freed with free.
--   
--   If a keycode is present in the accelerator and no
--   acceleratorCodes is given, the parse will fail.
--   
--   If the parse fails, acceleratorKey,
--   acceleratorMods and acceleratorCodes
--   will be set to 0 (zero).
--   
--   Since: 3.4
acceleratorParseWithKeycode :: (HasCallStack, MonadIO m) => Text -> m (Word32, [Word32], [ModifierType])

-- | Converts an accelerator keyval and modifier mask into a string
--   parseable by acceleratorParse. For example, if you pass in
--   KEY_q and GDK_CONTROL_MASK, this function
--   returns “<Control>q”.
--   
--   If you need to display accelerators in the user interface, see
--   acceleratorGetLabel.
acceleratorName :: (HasCallStack, MonadIO m) => 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.
--   
--   Since: 2.6
acceleratorGetLabel :: (HasCallStack, MonadIO m) => Word32 -> [ModifierType] -> m Text

-- | 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 GDK_CONTROL_MASK |
--   GDK_SHIFT_MASK | GDK_MOD1_MASK |
--   GDK_SUPER_MASK | GDK_HYPER_MASK |
--   GDK_META_MASK. In other words, Control, Shift, Alt,
--   Super, Hyper and Meta. Other modifiers will by default be ignored by
--   AccelGroup.
--   
--   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 ()

-- | Like getBinaryAge, 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 getInterfaceAge, 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 LevelBar.
--   
--   Since: 3.20
pattern LEVEL_BAR_OFFSET_FULL :: Text

-- | The name used for the stock high offset included by LevelBar.
--   
--   Since: 3.6
pattern LEVEL_BAR_OFFSET_HIGH :: Text

-- | The name used for the stock low offset included by LevelBar.
--   
--   Since: 3.6
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

-- | No description available in the introspection data.
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.
--   
--   Since: 3.6
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.
--   
--   Since: 3.6
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

-- | No description available in the introspection data.
pattern PRINT_SETTINGS_WIN32_DRIVER_EXTRA :: Text

-- | No description available in the introspection data.
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 PRIORITY_REDRAW to avoid resizing a
--   widget which was just redrawn.
pattern PRIORITY_RESIZE :: Int32

-- | The “About” item.
--   
--   Since: 2.6
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.
--   
--   Since: 2.16
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.
--   
--   Since: 2.2
pattern STOCK_COLOR_PICKER :: Text

-- | The “Connect” icon.
--   
--   Since: 2.6
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.
--   
--   Since: 2.4
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.
--   
--   Since: 2.6
pattern STOCK_DIRECTORY :: Text

-- | The “Discard” item.
--   
--   Since: 2.12
pattern STOCK_DISCARD :: Text

-- | The “Disconnect” icon.
--   
--   Since: 2.6
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.
--   
--   Since: 2.6
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.
--   
--   Since: 2.6
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.
--   
--   Since: 2.8
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.
--   
--   Since: 2.4
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.
--   
--   Since: 2.4
pattern STOCK_INDENT :: Text

-- | The “Index” item and icon.
pattern STOCK_INDEX :: Text

-- | The “Info” item and icon.
--   
--   Since: 2.8
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.
--   
--   Since: 2.8
pattern STOCK_LEAVE_FULLSCREEN :: Text

-- | The “Media Forward” item and icon. The icon has an RTL variant.
--   
--   Since: 2.6
pattern STOCK_MEDIA_FORWARD :: Text

-- | The “Media Next” item and icon. The icon has an RTL variant.
--   
--   Since: 2.6
pattern STOCK_MEDIA_NEXT :: Text

-- | The “Media Pause” item and icon.
--   
--   Since: 2.6
pattern STOCK_MEDIA_PAUSE :: Text

-- | The “Media Play” item and icon. The icon has an RTL variant.
--   
--   Since: 2.6
pattern STOCK_MEDIA_PLAY :: Text

-- | The “Media Previous” item and icon. The icon has an RTL variant.
--   
--   Since: 2.6
pattern STOCK_MEDIA_PREVIOUS :: Text

-- | The “Media Record” item and icon.
--   
--   Since: 2.6
pattern STOCK_MEDIA_RECORD :: Text

-- | The “Media Rewind” item and icon. The icon has an RTL variant.
--   
--   Since: 2.6
pattern STOCK_MEDIA_REWIND :: Text

-- | The “Media Stop” item and icon.
--   
--   Since: 2.6
pattern STOCK_MEDIA_STOP :: Text

-- | The “Missing image” icon.
pattern STOCK_MISSING_IMAGE :: Text

-- | The “Network” item and icon.
--   
--   Since: 2.4
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.
--   
--   Since: 2.10
pattern STOCK_ORIENTATION_LANDSCAPE :: Text

-- | The “Portrait Orientation” item and icon.
--   
--   Since: 2.10
pattern STOCK_ORIENTATION_PORTRAIT :: Text

-- | The “Reverse Landscape Orientation” item and icon.
--   
--   Since: 2.10
pattern STOCK_ORIENTATION_REVERSE_LANDSCAPE :: Text

-- | The “Reverse Portrait Orientation” item and icon.
--   
--   Since: 2.10
pattern STOCK_ORIENTATION_REVERSE_PORTRAIT :: Text

-- | The “Page Setup” item and icon.
--   
--   Since: 2.14
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.
--   
--   Since: 2.14
pattern STOCK_PRINT_ERROR :: Text

-- | The “Print Paused” icon.
--   
--   Since: 2.14
pattern STOCK_PRINT_PAUSED :: Text

-- | The “Print Preview” item and icon.
pattern STOCK_PRINT_PREVIEW :: Text

-- | The “Print Report” icon.
--   
--   Since: 2.14
pattern STOCK_PRINT_REPORT :: Text

-- | The “Print Warning” icon.
--   
--   Since: 2.14
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.
--   
--   Since: 2.10
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.
--   
--   Since: 2.4
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.
--   
--   Since: 3.14
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.
--   
--   Since: 3.12
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.
--   
--   Since: 3.14
pattern STYLE_CLASS_FLAT :: Text

-- | A CSS class defining a frame delimiting content, such as Frame
--   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.
--   
--   Since: 3.16
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.
--   
--   Since: 3.14
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.
--   
--   Since: 3.16
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.
--   
--   Since: 3.12
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.
--   
--   Since: 3.14
pattern STYLE_CLASS_OVERSHOOT :: Text

-- | A CSS class for a pane separator, such as those in Paned.
--   
--   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.
--   
--   Since: 3.16
pattern STYLE_CLASS_PAPER :: Text

-- | A CSS class that matches popovers.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   Since: 3.14
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.
--   
--   Since: 3.14
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 Scale. left for vertical Scale.
--   
--   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 Scale, right for vertical
--   Scale.
--   
--   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.
--   
--   Since: 3.16
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.
--   
--   Since: 3.14
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.
--   
--   Since: 3.12
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.
--   
--   Since: 3.14
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.
--   
--   Since: 3.16
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.
--   
--   Since: 3.16
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
--   Paned.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   Since: 3.16
pattern STYLE_CLASS_WIDE :: Text

-- | A property holding the background color of rendered elements as a
--   RGBA.
pattern STYLE_PROPERTY_BACKGROUND_COLOR :: Text

-- | A property holding the element’s background as a Pattern.
pattern STYLE_PROPERTY_BACKGROUND_IMAGE :: Text

-- | A property holding the element’s border color as a RGBA.
pattern STYLE_PROPERTY_BORDER_COLOR :: Text

-- | A property holding the rendered element’s border radius in pixels as a
--   gint.
pattern STYLE_PROPERTY_BORDER_RADIUS :: Text

-- | A property holding the element’s border style as a BorderStyle.
pattern STYLE_PROPERTY_BORDER_STYLE :: Text

-- | A property holding the font properties used when rendering text as a
--   FontDescription.
pattern STYLE_PROPERTY_FONT :: Text

-- | The priority used for style information provided via Settings.
--   
--   This priority is higher than STYLE_PROVIDER_PRIORITY_THEME to
--   let settings override themes.
pattern STYLE_PROVIDER_PRIORITY_SETTINGS :: 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

-- | 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

-- | Error codes that identify various errors that can occur while using
--   Builder.
data BuilderError

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

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

-- | An attribute that is required by Builder was missing.
BuilderErrorMissingAttribute :: BuilderError

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

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

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

-- | Builder 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

-- | The role specifies the desired appearance of a ModelButton.
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

-- | 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 GTK_CELL_RENDERER_ACCEL_MODE_MODIFIER_TAP: Bare
--   modifiers mode
CellRendererAccelModeOther :: CellRendererAccelMode

-- | No description available in the introspection data.
CellRendererAccelModeModifierTap :: CellRendererAccelMode

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

-- | Error codes for GTK_CSS_PROVIDER_ERROR.
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 CSS
--   Grammar, but may contain extensions.
--   
--   More types might be added in the future as the parser incorporates
--   more features.
--   
--   Since: 3.2
data CssSectionType

-- | The section describes a complete document. This section time is the
--   only one where cssSectionGetParent might return Nothing.
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
--   <http://dev.w3.org/csswg/css3-animations/#keyframes CSS
--   Animations> 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 Widget::dragFailed 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.
--   
--   Since: 2.16
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 EventSequence in a Gesture.
--   
--   Since: 3.14
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 TreeView.
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

-- | These identify the various errors that can occur while calling
--   FileChooser 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
--   Settings:gtkImPreeditStyle
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
--   Settings:gtkImStatusStyle
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

-- | 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

-- | No description available in the introspection data.
data NotebookTab

-- | No description available in the introspection data.
NotebookTabFirst :: NotebookTab

-- | No description available in the introspection data.
NotebookTabLast :: NotebookTab

-- | Catch-all for unknown values
AnotherNotebookTab :: Int -> NotebookTab

-- | Represents the packing location Box children. (See:
--   VBox, HBox, and ButtonBox).
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 GesturePan
--   
--   Since: 3.14
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 bindingSetAddPath.
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.
--   
--   Since: 3.20
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

-- | 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 action parameter to printOperationRun
--   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

-- | These identify the various errors that can occur while calling
--   RecentChooser functions.
--   
--   Since: 2.10
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 RecentManager operations
--   
--   Since: 2.10
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.
--   
--   Since: 2.10
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
--   recentChooserSetSortFunc.
RecentSortTypeCustom :: RecentSortType

-- | Catch-all for unknown values
AnotherRecentSortType :: Int -> RecentSortType

-- | No description available in the introspection data.
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

-- | These enumeration values describe the possible transitions when the
--   child of a Revealer 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

-- | GtkShortcutType specifies the kind of shortcut that is being
--   described. More values may be added to this enumeration over time.
--   
--   Since: 3.20
data ShortcutType

-- | The shortcut is a keyboard accelerator. The
--   ShortcutsShortcut:accelerator 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 ShortcutsShortcut:icon 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 Stack 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
--   TextView::extendSelection signal to customize the selection.
--   
--   Since: 3.16
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

-- | 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

-- | Kinds of widget-specific help. Used by the showHelp signal.
data WidgetHelpType

-- | Tooltip.
WidgetHelpTypeTooltip :: WidgetHelpType

-- | What’s this.
WidgetHelpTypeWhatsThis :: WidgetHelpType

-- | Catch-all for unknown values
AnotherWidgetHelpType :: Int -> WidgetHelpType

-- | Catch exceptions of type RecentManagerError. This is a
--   specialized version of catchGErrorJustDomain.
catchRecentManagerError :: IO a -> (RecentManagerError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type RecentManagerError. This is a
--   specialized version of handleGErrorJustDomain.
handleRecentManagerError :: (RecentManagerError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Catch exceptions of type RecentChooserError. This is a
--   specialized version of catchGErrorJustDomain.
catchRecentChooserError :: IO a -> (RecentChooserError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type RecentChooserError. This is a
--   specialized version of handleGErrorJustDomain.
handleRecentChooserError :: (RecentChooserError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Catch exceptions of type PrintError. This is a specialized
--   version of catchGErrorJustDomain.
catchPrintError :: IO a -> (PrintError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type PrintError. This is a specialized
--   version of handleGErrorJustDomain.
handlePrintError :: (PrintError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Catch exceptions of type IconThemeError. This is a specialized
--   version of catchGErrorJustDomain.
catchIconThemeError :: IO a -> (IconThemeError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type IconThemeError. This is a specialized
--   version of handleGErrorJustDomain.
handleIconThemeError :: (IconThemeError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Catch exceptions of type FileChooserError. This is a
--   specialized version of catchGErrorJustDomain.
catchFileChooserError :: IO a -> (FileChooserError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type FileChooserError. This is a
--   specialized version of handleGErrorJustDomain.
handleFileChooserError :: (FileChooserError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Catch exceptions of type CssProviderError. This is a
--   specialized version of catchGErrorJustDomain.
catchCssProviderError :: IO a -> (CssProviderError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type CssProviderError. This is a
--   specialized version of handleGErrorJustDomain.
handleCssProviderError :: (CssProviderError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Catch exceptions of type BuilderError. This is a specialized
--   version of catchGErrorJustDomain.
catchBuilderError :: IO a -> (BuilderError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type BuilderError. This is a specialized
--   version of handleGErrorJustDomain.
handleBuilderError :: (BuilderError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | These options can be used to influence the display and behaviour of a
--   Calendar.
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 calendarSetDetailFunc.
CalendarDisplayOptionsShowDetails :: CalendarDisplayOptions

-- | Catch-all for unknown values
AnotherCalendarDisplayOptions :: Int -> CalendarDisplayOptions

-- | No description available in the introspection data.
data DebugFlag

-- | No description available in the introspection data.
DebugFlagMisc :: DebugFlag

-- | No description available in the introspection data.
DebugFlagPlugsocket :: DebugFlag

-- | No description available in the introspection data.
DebugFlagText :: DebugFlag

-- | No description available in the introspection data.
DebugFlagTree :: DebugFlag

-- | No description available in the introspection data.
DebugFlagUpdates :: DebugFlag

-- | No description available in the introspection data.
DebugFlagKeybindings :: DebugFlag

-- | No description available in the introspection data.
DebugFlagMultihead :: DebugFlag

-- | No description available in the introspection data.
DebugFlagModules :: DebugFlag

-- | No description available in the introspection data.
DebugFlagGeometry :: DebugFlag

-- | No description available in the introspection data.
DebugFlagIcontheme :: DebugFlag

-- | No description available in the introspection data.
DebugFlagPrinting :: DebugFlag

-- | No description available in the introspection data.
DebugFlagBuilder :: DebugFlag

-- | No description available in the introspection data.
DebugFlagSizeRequest :: DebugFlag

-- | No description available in the introspection data.
DebugFlagNoCssCache :: DebugFlag

-- | No description available in the introspection data.
DebugFlagBaselines :: DebugFlag

-- | No description available in the introspection data.
DebugFlagPixelCache :: DebugFlag

-- | No description available in the introspection data.
DebugFlagNoPixelCache :: DebugFlag

-- | No description available in the introspection data.
DebugFlagInteractive :: DebugFlag

-- | No description available in the introspection data.
DebugFlagTouchscreen :: DebugFlag

-- | No description available in the introspection data.
DebugFlagActions :: DebugFlag

-- | No description available in the introspection data.
DebugFlagResize :: DebugFlag

-- | No description available in the introspection data.
DebugFlagLayout :: DebugFlag

-- | Catch-all for unknown values
AnotherDebugFlag :: Int -> DebugFlag

-- | Describes the behavior of a EventControllerScroll.
--   
--   Since: 3.24
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 EventControllerScroll::decelerate 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 FileFilterInfo 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

-- | No description available in the introspection data.
FontChooserLevelVariations :: FontChooserLevel

-- | Allow selecting specific OpenType font features
FontChooserLevelFeatures :: FontChooserLevel

-- | Catch-all for unknown values
AnotherFontChooserLevel :: Int -> FontChooserLevel

-- | 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 InputPurpose of the entry.
--   
--   Some common sense is expected when using these flags - mixing
--   gTKINPUTHINTLOWERCASE with any of the uppercase hints
--   makes no sense.
--   
--   This enumeration may be extended in the future; input methods should
--   ignore unknown values.
--   
--   Since: 3.6
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 RecentFilterInfo 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 styleContextToString. New
--   values may be added to this enumeration.
data StyleContextPrintFlags

-- | No description available in the introspection data.
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 GTK_TEXT_SEARCH_VISIBLE_ONLY nor
--   GTK_TEXT_SEARCH_TEXT_ONLY 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

-- | Type class for types which can be safely cast to ColorChooser,
--   for instance with toColorChooser.
class (GObject o, IsDescendantOf ColorChooser o) => IsColorChooser o

-- | Cast to ColorChooser, for types for which this is known to be
--   safe. For general casts, use castTo.
toColorChooser :: (MonadIO m, IsColorChooser o) => o -> m 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.
--   
--   Since: 3.4
type ColorChooserColorActivatedCallback = RGBA -> IO ()

-- | Get the value of the “rgba” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get colorChooser #rgba
--   
getColorChooserRgba :: (MonadIO m, IsColorChooser o) => o -> m (Maybe RGBA)

-- | Set the value of the “rgba” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set colorChooser [ #rgba := value ]
--   
setColorChooserRgba :: (MonadIO m, IsColorChooser o) => o -> RGBA -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “rgba” property. This is rarely needed directly, but it is
--   used by new.
constructColorChooserRgba :: (IsColorChooser o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “use-alpha” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorChooser #useAlpha
--   
getColorChooserUseAlpha :: (MonadIO m, IsColorChooser o) => o -> m Bool

-- | Set the value of the “use-alpha” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set colorChooser [ #useAlpha := value ]
--   
setColorChooserUseAlpha :: (MonadIO m, IsColorChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-alpha” property. This is rarely needed directly, but it
--   is used by new.
constructColorChooserUseAlpha :: (IsColorChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Adds a palette to the color chooser. If orientation is
--   horizontal, the colors are grouped in rows, with
--   colorsPerLine colors in each row. If
--   horizontal is False, the colors are grouped in
--   columns instead.
--   
--   The default color palette of ColorChooserWidget 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 colors is Nothing, removes all previously
--   added palettes.
--   
--   Since: 3.4
colorChooserAddPalette :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> Orientation -> Int32 -> Maybe [RGBA] -> m ()

-- | Gets the currently-selected color.
--   
--   Since: 3.4
colorChooserGetRgba :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> m RGBA

-- | Returns whether the color chooser shows the alpha channel.
--   
--   Since: 3.4
colorChooserGetUseAlpha :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> m Bool

-- | Sets the color.
--   
--   Since: 3.4
colorChooserSetRgba :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> RGBA -> m ()

-- | Sets whether or not the color chooser should use the alpha channel.
--   
--   Since: 3.4
colorChooserSetUseAlpha :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> Bool -> m ()

-- | Connect a signal handler for the colorActivated signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on colorChooser #colorActivated callback
--   
onColorChooserColorActivated :: (IsColorChooser a, MonadIO m) => a -> ((?self :: a) => ColorChooserColorActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the colorActivated signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after colorChooser #colorActivated callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterColorChooserColorActivated :: (IsColorChooser a, MonadIO m) => a -> ((?self :: a) => ColorChooserColorActivatedCallback) -> m SignalHandlerId

-- | Type class for types which can be safely cast to Editable, for
--   instance with toEditable.
class (GObject o, IsDescendantOf Editable o) => IsEditable o

-- | Cast to Editable, for types for which this is known to be safe.
--   For general casts, use castTo.
toEditable :: (MonadIO m, IsEditable o) => o -> m 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 signalStopEmission, 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 signalStopEmission, it is possible to
--   modify the range of deleted text, or prevent it from being deleted
--   entirely. The startPos and endPos
--   parameters are interpreted as for editableDeleteText.
type EditableDeleteTextCallback = Int32 -> Int32 -> IO ()

-- | The changed signal is emitted at the end of a single
--   user-visible operation on the contents of the Editable.
--   
--   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 notifytext signals to be emitted).
type EditableChangedCallback = IO ()

-- | 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 ()

-- | Retrieves whether editable is editable. See
--   editableSetEditable.
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 endPos with
--   end. If no text was selected both will be identical and False
--   will be returned.
--   
--   Note that positions are specified in characters, not bytes.
editableGetSelectionBounds :: (HasCallStack, MonadIO m, IsEditable a) => a -> m (Bool, Int32, Int32)

-- | Inserts newTextLength bytes of newText
--   into the contents of the widget, at position position.
--   
--   Note that the position is in characters, not in bytes. The function
--   updates position 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 startPos up to, but not
--   including endPos. If endPos is
--   negative, then the characters selected are those characters from
--   startPos 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 ()

-- | 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 position is in characters, not
--   in bytes.
editableSetPosition :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> m ()

-- | Connect a signal handler for the changed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on editable #changed callback
--   
onEditableChanged :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after editable #changed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEditableChanged :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deleteText signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on editable #deleteText callback
--   
onEditableDeleteText :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableDeleteTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deleteText signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after editable #deleteText callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEditableDeleteText :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableDeleteTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertText signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on editable #insertText callback
--   
onEditableInsertText :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableInsertTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertText signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after editable #insertText callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEditableInsertText :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableInsertTextCallback) -> m SignalHandlerId

-- | Type class for types which can be safely cast to Orientable,
--   for instance with toOrientable.
class (GObject o, IsDescendantOf Orientable o) => IsOrientable o

-- | Cast to Orientable, for types for which this is known to be
--   safe. For general casts, use castTo.
toOrientable :: (MonadIO m, IsOrientable o) => o -> m Orientable

-- | Get the value of the “orientation” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get orientable #orientation
--   
getOrientableOrientation :: (MonadIO m, IsOrientable o) => o -> m Orientation

-- | Set the value of the “orientation” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set orientable [ #orientation := value ]
--   
setOrientableOrientation :: (MonadIO m, IsOrientable o) => o -> Orientation -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “orientation” property. This is rarely needed directly, but
--   it is used by new.
constructOrientableOrientation :: (IsOrientable o, MonadIO m) => Orientation -> m (GValueConstruct o)

-- | Retrieves the orientation of the orientable.
--   
--   Since: 2.16
orientableGetOrientation :: (HasCallStack, MonadIO m, IsOrientable a) => a -> m Orientation

-- | Sets the orientation of the orientable.
--   
--   Since: 2.16
orientableSetOrientation :: (HasCallStack, MonadIO m, IsOrientable a) => a -> Orientation -> m ()

-- | Type class for types which can be safely cast to Adjustment,
--   for instance with toAdjustment.
class (GObject o, IsDescendantOf Adjustment o) => IsAdjustment o

-- | Cast to Adjustment, for types for which this is known to be
--   safe. For general casts, use castTo.
toAdjustment :: (MonadIO m, IsAdjustment o) => o -> m Adjustment

-- | Emitted when the Adjustment:value property has been changed.
type AdjustmentValueChangedCallback = IO ()

-- | Emitted when one or more of the Adjustment properties have been
--   changed, other than the Adjustment:value property.
type AdjustmentChangedCallback = IO ()

-- | Connect a signal handler for the changed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on adjustment #changed callback
--   
onAdjustmentChanged :: (IsAdjustment a, MonadIO m) => a -> ((?self :: a) => AdjustmentChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after adjustment #changed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAdjustmentChanged :: (IsAdjustment a, MonadIO m) => a -> ((?self :: a) => AdjustmentChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the valueChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on adjustment #valueChanged callback
--   
onAdjustmentValueChanged :: (IsAdjustment a, MonadIO m) => a -> ((?self :: a) => AdjustmentValueChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the valueChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after adjustment #valueChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAdjustmentValueChanged :: (IsAdjustment a, MonadIO m) => a -> ((?self :: a) => AdjustmentValueChangedCallback) -> m SignalHandlerId

-- | Get the value of the “lower” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get adjustment #lower
--   
getAdjustmentLower :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “lower” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set adjustment [ #lower := value ]
--   
setAdjustmentLower :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “lower” property. This is rarely needed directly, but it is
--   used by new.
constructAdjustmentLower :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “page-increment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get adjustment #pageIncrement
--   
getAdjustmentPageIncrement :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “page-increment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set adjustment [ #pageIncrement := value ]
--   
setAdjustmentPageIncrement :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “page-increment” property. This is rarely needed directly,
--   but it is used by new.
constructAdjustmentPageIncrement :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “page-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get adjustment #pageSize
--   
getAdjustmentPageSize :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “page-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set adjustment [ #pageSize := value ]
--   
setAdjustmentPageSize :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “page-size” property. This is rarely needed directly, but it
--   is used by new.
constructAdjustmentPageSize :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “step-increment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get adjustment #stepIncrement
--   
getAdjustmentStepIncrement :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “step-increment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set adjustment [ #stepIncrement := value ]
--   
setAdjustmentStepIncrement :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “step-increment” property. This is rarely needed directly,
--   but it is used by new.
constructAdjustmentStepIncrement :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “upper” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get adjustment #upper
--   
getAdjustmentUpper :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “upper” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set adjustment [ #upper := value ]
--   
setAdjustmentUpper :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “upper” property. This is rarely needed directly, but it is
--   used by new.
constructAdjustmentUpper :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get adjustment #value
--   
getAdjustmentValue :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set adjustment [ #value := value ]
--   
setAdjustmentValue :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “value” property. This is rarely needed directly, but it is
--   used by new.
constructAdjustmentValue :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Creates a new Adjustment.
adjustmentNew :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> Double -> Double -> Double -> m Adjustment

-- | Emits a Adjustment::changed signal from the Adjustment.
--   This is typically called by the owner of the Adjustment after
--   it has changed any of the Adjustment properties other than the
--   value.
adjustmentChanged :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m ()

-- | Updates the Adjustment:value property to ensure that the range
--   between lower and upper is in the
--   current page (i.e. between Adjustment:value and
--   Adjustment:value + Adjustment:pageSize). If the range is
--   larger than the page size, then only the start of it will be in the
--   current page.
--   
--   A Adjustment::valueChanged signal will be emitted if the value
--   is changed.
adjustmentClampPage :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> Double -> m ()

-- | Retrieves the minimum value of the adjustment.
--   
--   Since: 2.14
adjustmentGetLower :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Gets the smaller of step increment and page increment.
--   
--   Since: 3.2
adjustmentGetMinimumIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Retrieves the page increment of the adjustment.
--   
--   Since: 2.14
adjustmentGetPageIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Retrieves the page size of the adjustment.
--   
--   Since: 2.14
adjustmentGetPageSize :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Retrieves the step increment of the adjustment.
--   
--   Since: 2.14
adjustmentGetStepIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Retrieves the maximum value of the adjustment.
--   
--   Since: 2.14
adjustmentGetUpper :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Gets the current value of the adjustment. See
--   adjustmentSetValue.
adjustmentGetValue :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Sets the page increment of the adjustment.
--   
--   See adjustmentSetLower about how to compress multiple emissions
--   of the Adjustment::changed signal when setting multiple
--   adjustment properties.
--   
--   Since: 2.14
adjustmentSetPageIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets the page size of the adjustment.
--   
--   See adjustmentSetLower about how to compress multiple emissions
--   of the GtkAdjustmentchanged signal when setting multiple
--   adjustment properties.
--   
--   Since: 2.14
adjustmentSetPageSize :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets the step increment of the adjustment.
--   
--   See adjustmentSetLower about how to compress multiple emissions
--   of the Adjustment::changed signal when setting multiple
--   adjustment properties.
--   
--   Since: 2.14
adjustmentSetStepIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets the maximum value of the adjustment.
--   
--   Note that values will be restricted by upper - page-size if
--   the page-size property is nonzero.
--   
--   See adjustmentSetLower about how to compress multiple emissions
--   of the Adjustment::changed signal when setting multiple
--   adjustment properties.
--   
--   Since: 2.14
adjustmentSetUpper :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Emits a Adjustment::valueChanged signal from the
--   Adjustment. This is typically called by the owner of the
--   Adjustment after it has changed the Adjustment:value
--   property.
adjustmentValueChanged :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m ()

-- | Type class for types which can be safely cast to EntryBuffer,
--   for instance with toEntryBuffer.
class (GObject o, IsDescendantOf EntryBuffer o) => IsEntryBuffer o

-- | Cast to EntryBuffer, for types for which this is known to be
--   safe. For general casts, use castTo.
toEntryBuffer :: (MonadIO m, IsEntryBuffer o) => o -> m EntryBuffer

-- | This signal is emitted after text is inserted into the buffer.
--   
--   Since: 2.18
type EntryBufferInsertedTextCallback = Word32 -> Text -> Word32 -> IO ()

-- | This signal is emitted after text is deleted from the buffer.
--   
--   Since: 2.18
type EntryBufferDeletedTextCallback = Word32 -> Word32 -> IO ()

-- | Connect a signal handler for the deletedText signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on entryBuffer #deletedText callback
--   
onEntryBufferDeletedText :: (IsEntryBuffer a, MonadIO m) => a -> ((?self :: a) => EntryBufferDeletedTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deletedText signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after entryBuffer #deletedText callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryBufferDeletedText :: (IsEntryBuffer a, MonadIO m) => a -> ((?self :: a) => EntryBufferDeletedTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertedText signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on entryBuffer #insertedText callback
--   
onEntryBufferInsertedText :: (IsEntryBuffer a, MonadIO m) => a -> ((?self :: a) => EntryBufferInsertedTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertedText signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after entryBuffer #insertedText callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryBufferInsertedText :: (IsEntryBuffer a, MonadIO m) => a -> ((?self :: a) => EntryBufferInsertedTextCallback) -> m SignalHandlerId

-- | Get the value of the “length” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entryBuffer #length
--   
getEntryBufferLength :: (MonadIO m, IsEntryBuffer o) => o -> m Word32

-- | Get the value of the “max-length” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entryBuffer #maxLength
--   
getEntryBufferMaxLength :: (MonadIO m, IsEntryBuffer o) => o -> m Int32

-- | Set the value of the “max-length” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entryBuffer [ #maxLength := value ]
--   
setEntryBufferMaxLength :: (MonadIO m, IsEntryBuffer o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “max-length” property. This is rarely needed directly, but it
--   is used by new.
constructEntryBufferMaxLength :: (IsEntryBuffer o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get entryBuffer #text
--   
getEntryBufferText :: (MonadIO m, IsEntryBuffer o) => o -> m Text

-- | Set the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set entryBuffer [ #text := value ]
--   
setEntryBufferText :: (MonadIO m, IsEntryBuffer o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text” property. This is rarely needed directly, but it is
--   used by new.
constructEntryBufferText :: (IsEntryBuffer o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “text” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #text
--   
clearEntryBufferText :: (MonadIO m, IsEntryBuffer o) => o -> m ()

-- | Create a new GtkEntryBuffer object.
--   
--   Optionally, specify initial text to set in the buffer.
--   
--   Since: 2.18
entryBufferNew :: (HasCallStack, MonadIO m) => Maybe Text -> Int32 -> m EntryBuffer

-- | Used when subclassing EntryBuffer
--   
--   Since: 2.18
entryBufferEmitDeletedText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Word32 -> Word32 -> m ()

-- | Used when subclassing EntryBuffer
--   
--   Since: 2.18
entryBufferEmitInsertedText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Word32 -> Text -> Word32 -> m ()

-- | Retrieves the length in bytes of the buffer. See
--   entryBufferGetLength.
--   
--   Since: 2.18
entryBufferGetBytes :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m CSize

-- | Type class for types which can be safely cast to
--   EntryIconAccessible, for instance with
--   toEntryIconAccessible.
class (GObject o, IsDescendantOf EntryIconAccessible o) => IsEntryIconAccessible o

-- | Memory-managed wrapper type.
newtype EntryIconAccessible
EntryIconAccessible :: ManagedPtr EntryIconAccessible -> EntryIconAccessible

-- | Cast to EntryIconAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toEntryIconAccessible :: (MonadIO m, IsEntryIconAccessible o) => o -> m EntryIconAccessible

-- | Type class for types which can be safely cast to IMContext, for
--   instance with toIMContext.
class (GObject o, IsDescendantOf IMContext o) => IsIMContext o

-- | Cast to IMContext, for types for which this is known to be
--   safe. For general casts, use castTo.
toIMContext :: (MonadIO m, IsIMContext o) => o -> m IMContext

-- | The retrieveSurrounding 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
--   iMContextSetSurrounding method.
type IMContextRetrieveSurroundingCallback = IO Bool

-- | The preeditStart signal is emitted when a new preediting
--   sequence starts.
type IMContextPreeditStartCallback = IO ()

-- | The preeditEnd signal is emitted when a preediting sequence has
--   been completed or canceled.
type IMContextPreeditEndCallback = IO ()

-- | The preeditChanged 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
--   iMContextGetPreeditString returns the empty string.
type IMContextPreeditChangedCallback = IO ()

-- | The deleteSurrounding 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 commit 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 ()

-- | Connect a signal handler for the commit signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on iMContext #commit callback
--   
onIMContextCommit :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextCommitCallback) -> m SignalHandlerId

-- | Connect a signal handler for the commit signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after iMContext #commit callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIMContextCommit :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextCommitCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deleteSurrounding signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on iMContext #deleteSurrounding callback
--   
onIMContextDeleteSurrounding :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextDeleteSurroundingCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deleteSurrounding signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after iMContext #deleteSurrounding callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIMContextDeleteSurrounding :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextDeleteSurroundingCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preeditChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on iMContext #preeditChanged callback
--   
onIMContextPreeditChanged :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preeditChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after iMContext #preeditChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIMContextPreeditChanged :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preeditEnd signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on iMContext #preeditEnd callback
--   
onIMContextPreeditEnd :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preeditEnd signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after iMContext #preeditEnd callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIMContextPreeditEnd :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preeditStart signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on iMContext #preeditStart callback
--   
onIMContextPreeditStart :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditStartCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preeditStart signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after iMContext #preeditStart callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIMContextPreeditStart :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditStartCallback) -> m SignalHandlerId

-- | Connect a signal handler for the retrieveSurrounding signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on iMContext #retrieveSurrounding callback
--   
onIMContextRetrieveSurrounding :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextRetrieveSurroundingCallback) -> m SignalHandlerId

-- | Connect a signal handler for the retrieveSurrounding signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after iMContext #retrieveSurrounding callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIMContextRetrieveSurrounding :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextRetrieveSurroundingCallback) -> m SignalHandlerId

-- | Get the value of the “input-hints” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iMContext #inputHints
--   
getIMContextInputHints :: (MonadIO m, IsIMContext o) => o -> m [InputHints]

-- | Set the value of the “input-hints” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iMContext [ #inputHints := value ]
--   
setIMContextInputHints :: (MonadIO m, IsIMContext o) => o -> [InputHints] -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “input-hints” property. This is rarely needed directly, but
--   it is used by new.
constructIMContextInputHints :: (IsIMContext o, MonadIO m) => [InputHints] -> m (GValueConstruct o)

-- | Get the value of the “input-purpose” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iMContext #inputPurpose
--   
getIMContextInputPurpose :: (MonadIO m, IsIMContext o) => o -> m InputPurpose

-- | Set the value of the “input-purpose” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iMContext [ #inputPurpose := value ]
--   
setIMContextInputPurpose :: (MonadIO m, IsIMContext o) => o -> InputPurpose -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “input-purpose” property. This is rarely needed directly, but
--   it is used by new.
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
--   GtkIMContextdelete_surrounding signal. Note that
--   offset and nChars are in characters
--   not in bytes which differs from the usage other places in
--   IMContext.
--   
--   In order to use this function, you should first call
--   iMContextGetSurrounding 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 ()

-- | 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 Window
--   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 whether the IM context should use the preedit string to display
--   feedback. If usePreedit 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 ()

-- | Type class for types which can be safely cast to
--   IMContextSimple, for instance with toIMContextSimple.
class (GObject o, IsDescendantOf IMContextSimple o) => IsIMContextSimple o

-- | Cast to IMContextSimple, for types for which this is known to
--   be safe. For general casts, use castTo.
toIMContextSimple :: (MonadIO m, IsIMContextSimple o) => o -> m IMContextSimple

-- | Creates a new IMContextSimple.
iMContextSimpleNew :: (HasCallStack, MonadIO m) => m IMContextSimple

-- | Adds an additional table from the X11 compose file.
iMContextSimpleAddComposeFile :: (HasCallStack, MonadIO m, IsIMContextSimple a) => a -> Text -> m ()

-- | Type class for types which can be safely cast to RcStyle, for
--   instance with toRcStyle.
class (GObject o, IsDescendantOf RcStyle o) => IsRcStyle o

-- | Cast to RcStyle, for types for which this is known to be safe.
--   For general casts, use castTo.
toRcStyle :: (MonadIO m, IsRcStyle o) => o -> m RcStyle

-- | Creates a new RcStyle with no fields set and a reference count
--   of 1.
rcStyleNew :: (HasCallStack, MonadIO m) => m RcStyle

-- | Makes a copy of the specified RcStyle. This function will
--   correctly copy an RC style that is a member of a class derived from
--   RcStyle.
rcStyleCopy :: (HasCallStack, MonadIO m, IsRcStyle a) => a -> m RcStyle

-- | Construct a AccelKey struct initialized to zero.
newZeroAccelKey :: MonadIO m => m AccelKey

-- | Get the value of the “accel_key” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get accelKey #accelKey
--   
getAccelKeyAccelKey :: MonadIO m => AccelKey -> m Word32

-- | Set the value of the “accel_key” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set accelKey [ #accelKey := value ]
--   
setAccelKeyAccelKey :: MonadIO m => AccelKey -> Word32 -> m ()

-- | Get the value of the “accel_mods” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get accelKey #accelMods
--   
getAccelKeyAccelMods :: MonadIO m => AccelKey -> m [ModifierType]

-- | Set the value of the “accel_mods” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set accelKey [ #accelMods := value ]
--   
setAccelKeyAccelMods :: MonadIO m => AccelKey -> [ModifierType] -> m ()

-- | Get the value of the “accel_flags” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get accelKey #accelFlags
--   
getAccelKeyAccelFlags :: MonadIO m => AccelKey -> m Word32

-- | Set the value of the “accel_flags” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set accelKey [ #accelFlags := value ]
--   
setAccelKeyAccelFlags :: MonadIO m => AccelKey -> Word32 -> m ()

-- | Construct a AccelGroupEntry struct initialized to zero.
newZeroAccelGroupEntry :: MonadIO m => m AccelGroupEntry

-- | Get the value of the “key” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get accelGroupEntry #key
--   
getAccelGroupEntryKey :: MonadIO m => AccelGroupEntry -> m AccelKey

-- | Get the value of the “closure” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get accelGroupEntry #closure
--   
getAccelGroupEntryClosure :: MonadIO m => AccelGroupEntry -> m (Maybe (GClosure ()))

-- | Set the value of the “closure” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set accelGroupEntry [ #closure := value ]
--   
setAccelGroupEntryClosure :: MonadIO m => AccelGroupEntry -> Ptr (GClosure ()) -> m ()

-- | Set the value of the “closure” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #closure
--   
clearAccelGroupEntryClosure :: MonadIO m => AccelGroupEntry -> m ()

-- | Get the value of the “accel_path_quark” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get accelGroupEntry #accelPathQuark
--   
getAccelGroupEntryAccelPathQuark :: MonadIO m => AccelGroupEntry -> m Word32

-- | Set the value of the “accel_path_quark” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set accelGroupEntry [ #accelPathQuark := value ]
--   
setAccelGroupEntryAccelPathQuark :: MonadIO m => AccelGroupEntry -> Word32 -> m ()

-- | Construct a ActionEntry struct initialized to zero.
newZeroActionEntry :: MonadIO m => m ActionEntry

-- | Get the value of the “name” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get actionEntry #name
--   
getActionEntryName :: MonadIO m => ActionEntry -> m (Maybe Text)

-- | Set the value of the “name” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set actionEntry [ #name := value ]
--   
setActionEntryName :: MonadIO m => ActionEntry -> CString -> m ()

-- | Set the value of the “name” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #name
--   
clearActionEntryName :: MonadIO m => ActionEntry -> m ()

-- | Get the value of the “stock_id” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get actionEntry #stockId
--   
getActionEntryStockId :: MonadIO m => ActionEntry -> m (Maybe Text)

-- | Set the value of the “stock_id” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set actionEntry [ #stockId := value ]
--   
setActionEntryStockId :: MonadIO m => ActionEntry -> CString -> m ()

-- | Set the value of the “stock_id” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #stockId
--   
clearActionEntryStockId :: MonadIO m => ActionEntry -> m ()

-- | Get the value of the “label” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get actionEntry #label
--   
getActionEntryLabel :: MonadIO m => ActionEntry -> m (Maybe Text)

-- | Set the value of the “label” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set actionEntry [ #label := value ]
--   
setActionEntryLabel :: MonadIO m => ActionEntry -> CString -> m ()

-- | Set the value of the “label” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #label
--   
clearActionEntryLabel :: MonadIO m => ActionEntry -> m ()

-- | Get the value of the “accelerator” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get actionEntry #accelerator
--   
getActionEntryAccelerator :: MonadIO m => ActionEntry -> m (Maybe Text)

-- | Set the value of the “accelerator” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set actionEntry [ #accelerator := value ]
--   
setActionEntryAccelerator :: MonadIO m => ActionEntry -> CString -> m ()

-- | Set the value of the “accelerator” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #accelerator
--   
clearActionEntryAccelerator :: MonadIO m => ActionEntry -> m ()

-- | Get the value of the “tooltip” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get actionEntry #tooltip
--   
getActionEntryTooltip :: MonadIO m => ActionEntry -> m (Maybe Text)

-- | Set the value of the “tooltip” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set actionEntry [ #tooltip := value ]
--   
setActionEntryTooltip :: MonadIO m => ActionEntry -> CString -> m ()

-- | Set the value of the “tooltip” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #tooltip
--   
clearActionEntryTooltip :: MonadIO m => ActionEntry -> m ()

-- | Get the value of the “callback” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get actionEntry #callback
--   
getActionEntryCallback :: MonadIO m => ActionEntry -> m (Maybe Callback)

-- | Set the value of the “callback” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set actionEntry [ #callback := value ]
--   
setActionEntryCallback :: MonadIO m => ActionEntry -> FunPtr C_Callback -> m ()

-- | Set the value of the “callback” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #callback
--   
clearActionEntryCallback :: MonadIO m => ActionEntry -> m ()

-- | Construct a BindingArg struct initialized to zero.
newZeroBindingArg :: MonadIO m => m BindingArg

-- | Get the value of the “arg_type” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get bindingArg #argType
--   
getBindingArgArgType :: MonadIO m => BindingArg -> m GType

-- | Set the value of the “arg_type” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set bindingArg [ #argType := value ]
--   
setBindingArgArgType :: MonadIO m => BindingArg -> GType -> m ()

-- | Memory-managed wrapper type.
newtype BindingSignal
BindingSignal :: ManagedPtr BindingSignal -> BindingSignal

-- | Construct a BindingSignal struct initialized to zero.
newZeroBindingSignal :: MonadIO m => m BindingSignal

-- | Get the value of the “next” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get bindingSignal #next
--   
getBindingSignalNext :: MonadIO m => BindingSignal -> m (Maybe BindingSignal)

-- | Set the value of the “next” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set bindingSignal [ #next := value ]
--   
setBindingSignalNext :: MonadIO m => BindingSignal -> Ptr BindingSignal -> m ()

-- | Set the value of the “next” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #next
--   
clearBindingSignalNext :: MonadIO m => BindingSignal -> m ()

-- | Get the value of the “signal_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get bindingSignal #signalName
--   
getBindingSignalSignalName :: MonadIO m => BindingSignal -> m (Maybe Text)

-- | Set the value of the “signal_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set bindingSignal [ #signalName := value ]
--   
setBindingSignalSignalName :: MonadIO m => BindingSignal -> CString -> m ()

-- | Set the value of the “signal_name” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #signalName
--   
clearBindingSignalSignalName :: MonadIO m => BindingSignal -> m ()

-- | Get the value of the “n_args” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get bindingSignal #nArgs
--   
getBindingSignalNArgs :: MonadIO m => BindingSignal -> m Word32

-- | Set the value of the “n_args” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set bindingSignal [ #nArgs := value ]
--   
setBindingSignalNArgs :: MonadIO m => BindingSignal -> Word32 -> m ()

-- | Memory-managed wrapper type.
newtype BindingEntry
BindingEntry :: ManagedPtr BindingEntry -> BindingEntry

-- | Construct a BindingEntry struct initialized to zero.
newZeroBindingEntry :: MonadIO m => m BindingEntry

-- | Get the value of the “keyval” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get bindingEntry #keyval
--   
getBindingEntryKeyval :: MonadIO m => BindingEntry -> m Word32

-- | Set the value of the “keyval” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set bindingEntry [ #keyval := value ]
--   
setBindingEntryKeyval :: MonadIO m => BindingEntry -> Word32 -> m ()

-- | Get the value of the “modifiers” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get bindingEntry #modifiers
--   
getBindingEntryModifiers :: MonadIO m => BindingEntry -> m [ModifierType]

-- | Set the value of the “modifiers” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set bindingEntry [ #modifiers := value ]
--   
setBindingEntryModifiers :: MonadIO m => BindingEntry -> [ModifierType] -> m ()

-- | Get the value of the “binding_set” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get bindingEntry #bindingSet
--   
getBindingEntryBindingSet :: MonadIO m => BindingEntry -> m (Maybe BindingSet)

-- | Set the value of the “binding_set” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set bindingEntry [ #bindingSet := value ]
--   
setBindingEntryBindingSet :: MonadIO m => BindingEntry -> Ptr BindingSet -> m ()

-- | Set the value of the “binding_set” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #bindingSet
--   
clearBindingEntryBindingSet :: MonadIO m => BindingEntry -> m ()

-- | Get the value of the “destroyed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get bindingEntry #destroyed
--   
getBindingEntryDestroyed :: MonadIO m => BindingEntry -> m Word32

-- | Set the value of the “destroyed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set bindingEntry [ #destroyed := value ]
--   
setBindingEntryDestroyed :: MonadIO m => BindingEntry -> Word32 -> m ()

-- | Get the value of the “in_emission” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get bindingEntry #inEmission
--   
getBindingEntryInEmission :: MonadIO m => BindingEntry -> m Word32

-- | Set the value of the “in_emission” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set bindingEntry [ #inEmission := value ]
--   
setBindingEntryInEmission :: MonadIO m => BindingEntry -> Word32 -> m ()

-- | Get the value of the “marks_unbound” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get bindingEntry #marksUnbound
--   
getBindingEntryMarksUnbound :: MonadIO m => BindingEntry -> m Word32

-- | Set the value of the “marks_unbound” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set bindingEntry [ #marksUnbound := value ]
--   
setBindingEntryMarksUnbound :: MonadIO m => BindingEntry -> Word32 -> m ()

-- | Get the value of the “set_next” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get bindingEntry #setNext
--   
getBindingEntrySetNext :: MonadIO m => BindingEntry -> m (Maybe BindingEntry)

-- | Set the value of the “set_next” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set bindingEntry [ #setNext := value ]
--   
setBindingEntrySetNext :: MonadIO m => BindingEntry -> Ptr BindingEntry -> m ()

-- | Set the value of the “set_next” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #setNext
--   
clearBindingEntrySetNext :: MonadIO m => BindingEntry -> m ()

-- | Get the value of the “hash_next” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get bindingEntry #hashNext
--   
getBindingEntryHashNext :: MonadIO m => BindingEntry -> m (Maybe BindingEntry)

-- | Set the value of the “hash_next” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set bindingEntry [ #hashNext := value ]
--   
setBindingEntryHashNext :: MonadIO m => BindingEntry -> Ptr BindingEntry -> m ()

-- | Set the value of the “hash_next” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #hashNext
--   
clearBindingEntryHashNext :: MonadIO m => BindingEntry -> m ()

-- | Get the value of the “signals” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get bindingEntry #signals
--   
getBindingEntrySignals :: MonadIO m => BindingEntry -> m (Maybe BindingSignal)

-- | Set the value of the “signals” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set bindingEntry [ #signals := value ]
--   
setBindingEntrySignals :: MonadIO m => BindingEntry -> Ptr BindingSignal -> m ()

-- | Set the value of the “signals” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #signals
--   
clearBindingEntrySignals :: MonadIO m => BindingEntry -> m ()

-- | Parses a signal description from signalDesc and
--   incorporates it into bindingSet.
--   
--   Signal descriptions may either bind a key combination to one or more
--   signals:
--   
--   
--   bind "key" {
--     "signalname" (param, ...)
--     ...
--   }
--   
--   
--   Or they may also unbind a key combination:
--   
--   
--   unbind "key"
--   
--   
--   Key combinations must be in a format that can be parsed by
--   acceleratorParse.
--   
--   Since: 3.0
bindingEntryAddSignalFromString :: (HasCallStack, MonadIO m) => BindingSet -> Text -> m TokenType

-- | Override or install a new key binding for keyval with
--   modifiers on bindingSet.
bindingEntryAddSignall :: (HasCallStack, MonadIO m) => BindingSet -> Word32 -> [ModifierType] -> Text -> [BindingArg] -> m ()

-- | Remove a binding previously installed via
--   gtk_binding_entry_add_signal() on
--   bindingSet.
bindingEntryRemove :: (HasCallStack, MonadIO m) => BindingSet -> Word32 -> [ModifierType] -> m ()

-- | Install a binding on bindingSet which causes key
--   lookups to be aborted, to prevent bindings from lower priority sets to
--   be activated.
--   
--   Since: 2.12
bindingEntrySkip :: (HasCallStack, MonadIO m) => BindingSet -> Word32 -> [ModifierType] -> m ()

-- | Construct a BindingSet struct initialized to zero.
newZeroBindingSet :: MonadIO m => m BindingSet

-- | Get the value of the “set_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get bindingSet #setName
--   
getBindingSetSetName :: MonadIO m => BindingSet -> m (Maybe Text)

-- | Set the value of the “set_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set bindingSet [ #setName := value ]
--   
setBindingSetSetName :: MonadIO m => BindingSet -> CString -> m ()

-- | Set the value of the “set_name” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #setName
--   
clearBindingSetSetName :: MonadIO m => BindingSet -> m ()

-- | Get the value of the “priority” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get bindingSet #priority
--   
getBindingSetPriority :: MonadIO m => BindingSet -> m Int32

-- | Set the value of the “priority” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set bindingSet [ #priority := value ]
--   
setBindingSetPriority :: MonadIO m => BindingSet -> Int32 -> m ()

-- | Get the value of the “widget_path_pspecs” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get bindingSet #widgetPathPspecs
--   
getBindingSetWidgetPathPspecs :: MonadIO m => BindingSet -> m [Ptr ()]

-- | Set the value of the “widget_path_pspecs” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set bindingSet [ #widgetPathPspecs := value ]
--   
setBindingSetWidgetPathPspecs :: MonadIO m => BindingSet -> Ptr (GSList (Ptr ())) -> m ()

-- | Set the value of the “widget_path_pspecs” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #widgetPathPspecs
--   
clearBindingSetWidgetPathPspecs :: MonadIO m => BindingSet -> m ()

-- | Get the value of the “widget_class_pspecs” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get bindingSet #widgetClassPspecs
--   
getBindingSetWidgetClassPspecs :: MonadIO m => BindingSet -> m [Ptr ()]

-- | Set the value of the “widget_class_pspecs” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set bindingSet [ #widgetClassPspecs := value ]
--   
setBindingSetWidgetClassPspecs :: MonadIO m => BindingSet -> Ptr (GSList (Ptr ())) -> m ()

-- | Set the value of the “widget_class_pspecs” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #widgetClassPspecs
--   
clearBindingSetWidgetClassPspecs :: MonadIO m => BindingSet -> m ()

-- | Get the value of the “class_branch_pspecs” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get bindingSet #classBranchPspecs
--   
getBindingSetClassBranchPspecs :: MonadIO m => BindingSet -> m [Ptr ()]

-- | Set the value of the “class_branch_pspecs” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set bindingSet [ #classBranchPspecs := value ]
--   
setBindingSetClassBranchPspecs :: MonadIO m => BindingSet -> Ptr (GSList (Ptr ())) -> m ()

-- | Set the value of the “class_branch_pspecs” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #classBranchPspecs
--   
clearBindingSetClassBranchPspecs :: MonadIO m => BindingSet -> m ()

-- | Get the value of the “entries” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get bindingSet #entries
--   
getBindingSetEntries :: MonadIO m => BindingSet -> m (Maybe BindingEntry)

-- | Set the value of the “entries” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set bindingSet [ #entries := value ]
--   
setBindingSetEntries :: MonadIO m => BindingSet -> Ptr BindingEntry -> m ()

-- | Set the value of the “entries” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #entries
--   
clearBindingSetEntries :: MonadIO m => BindingSet -> m ()

-- | Get the value of the “current” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get bindingSet #current
--   
getBindingSetCurrent :: MonadIO m => BindingSet -> m (Maybe BindingEntry)

-- | Set the value of the “current” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set bindingSet [ #current := value ]
--   
setBindingSetCurrent :: MonadIO m => BindingSet -> Ptr BindingEntry -> m ()

-- | Set the value of the “current” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #current
--   
clearBindingSetCurrent :: MonadIO m => BindingSet -> m ()

-- | Get the value of the “parsed” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get bindingSet #parsed
--   
getBindingSetParsed :: MonadIO m => BindingSet -> m Word32

-- | Set the value of the “parsed” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set bindingSet [ #parsed := value ]
--   
setBindingSetParsed :: MonadIO m => BindingSet -> Word32 -> m ()

-- | Find a key binding matching keyval and
--   modifiers within bindingSet and
--   activate the binding on object.
bindingSetActivate :: (HasCallStack, MonadIO m, IsObject a) => BindingSet -> Word32 -> [ModifierType] -> a -> m Bool

-- | Find a binding set by its globally unique name.
--   
--   The setName can either be a name used for
--   gtk_binding_set_new() or the type name of a class used
--   in gtk_binding_set_by_class().
bindingSetFind :: (HasCallStack, MonadIO m) => Text -> m (Maybe BindingSet)

-- | Construct a Border struct initialized to zero.
newZeroBorder :: MonadIO m => m Border

-- | Get the value of the “left” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get border #left
--   
getBorderLeft :: MonadIO m => Border -> m Int16

-- | Set the value of the “left” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set border [ #left := value ]
--   
setBorderLeft :: MonadIO m => Border -> Int16 -> m ()

-- | Get the value of the “right” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get border #right
--   
getBorderRight :: MonadIO m => Border -> m Int16

-- | Set the value of the “right” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set border [ #right := value ]
--   
setBorderRight :: MonadIO m => Border -> Int16 -> m ()

-- | Get the value of the “top” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get border #top
--   
getBorderTop :: MonadIO m => Border -> m Int16

-- | Set the value of the “top” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set border [ #top := value ]
--   
setBorderTop :: MonadIO m => Border -> Int16 -> m ()

-- | Get the value of the “bottom” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get border #bottom
--   
getBorderBottom :: MonadIO m => Border -> m Int16

-- | Set the value of the “bottom” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set border [ #bottom := value ]
--   
setBorderBottom :: MonadIO m => Border -> Int16 -> m ()

-- | Allocates a new Border-struct and initializes its elements to
--   zero.
--   
--   Since: 2.14
borderNew :: (HasCallStack, MonadIO m) => m Border

-- | Copies a Border-struct.
borderCopy :: (HasCallStack, MonadIO m) => Border -> m Border

-- | Type class for types which can be safely cast to Scrollable,
--   for instance with toScrollable.
class (GObject o, IsDescendantOf Scrollable o) => IsScrollable o

-- | Cast to Scrollable, for types for which this is known to be
--   safe. For general casts, use castTo.
toScrollable :: (MonadIO m, IsScrollable o) => o -> m Scrollable

-- | Get the value of the “hadjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrollable #hadjustment
--   
getScrollableHadjustment :: (MonadIO m, IsScrollable o) => o -> m Adjustment

-- | Set the value of the “hadjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrollable [ #hadjustment := value ]
--   
setScrollableHadjustment :: (MonadIO m, IsScrollable o, IsAdjustment a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “hadjustment” property. This is rarely needed directly, but
--   it is used by new.
constructScrollableHadjustment :: (IsScrollable o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Set the value of the “hadjustment” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #hadjustment
--   
clearScrollableHadjustment :: (MonadIO m, IsScrollable o) => o -> m ()

-- | Get the value of the “hscroll-policy” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrollable #hscrollPolicy
--   
getScrollableHscrollPolicy :: (MonadIO m, IsScrollable o) => o -> m ScrollablePolicy

-- | Set the value of the “hscroll-policy” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrollable [ #hscrollPolicy := value ]
--   
setScrollableHscrollPolicy :: (MonadIO m, IsScrollable o) => o -> ScrollablePolicy -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “hscroll-policy” property. This is rarely needed directly,
--   but it is used by new.
constructScrollableHscrollPolicy :: (IsScrollable o, MonadIO m) => ScrollablePolicy -> m (GValueConstruct o)

-- | Get the value of the “vadjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrollable #vadjustment
--   
getScrollableVadjustment :: (MonadIO m, IsScrollable o) => o -> m Adjustment

-- | Set the value of the “vadjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrollable [ #vadjustment := value ]
--   
setScrollableVadjustment :: (MonadIO m, IsScrollable o, IsAdjustment a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “vadjustment” property. This is rarely needed directly, but
--   it is used by new.
constructScrollableVadjustment :: (IsScrollable o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Set the value of the “vadjustment” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #vadjustment
--   
clearScrollableVadjustment :: (MonadIO m, IsScrollable o) => o -> m ()

-- | Get the value of the “vscroll-policy” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrollable #vscrollPolicy
--   
getScrollableVscrollPolicy :: (MonadIO m, IsScrollable o) => o -> m ScrollablePolicy

-- | Set the value of the “vscroll-policy” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrollable [ #vscrollPolicy := value ]
--   
setScrollableVscrollPolicy :: (MonadIO m, IsScrollable o) => o -> ScrollablePolicy -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “vscroll-policy” property. This is rarely needed directly,
--   but it is used by new.
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.
--   
--   Since: 3.16
scrollableGetBorder :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m (Bool, Border)

-- | Retrieves the Adjustment used for horizontal scrolling.
--   
--   Since: 3.0
scrollableGetHadjustment :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m Adjustment

-- | Gets the horizontal ScrollablePolicy.
--   
--   Since: 3.0
scrollableGetHscrollPolicy :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m ScrollablePolicy

-- | Retrieves the Adjustment used for vertical scrolling.
--   
--   Since: 3.0
scrollableGetVadjustment :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m Adjustment

-- | Gets the vertical ScrollablePolicy.
--   
--   Since: 3.0
scrollableGetVscrollPolicy :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m ScrollablePolicy

-- | Sets the horizontal adjustment of the Scrollable.
--   
--   Since: 3.0
scrollableSetHadjustment :: (HasCallStack, MonadIO m, IsScrollable a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Sets the ScrollablePolicy to determine whether horizontal
--   scrolling should start below the minimum width or below the natural
--   width.
--   
--   Since: 3.0
scrollableSetHscrollPolicy :: (HasCallStack, MonadIO m, IsScrollable a) => a -> ScrollablePolicy -> m ()

-- | Sets the vertical adjustment of the Scrollable.
--   
--   Since: 3.0
scrollableSetVadjustment :: (HasCallStack, MonadIO m, IsScrollable a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Sets the ScrollablePolicy to determine whether vertical
--   scrolling should start below the minimum height or below the natural
--   height.
--   
--   Since: 3.0
scrollableSetVscrollPolicy :: (HasCallStack, MonadIO m, IsScrollable a) => a -> ScrollablePolicy -> m ()

-- | Returns the offset in bytes from the start of the current line
--   returned via cssSectionGetEndLine. This value may change in
--   future invocations of this function if section is not
--   yet parsed completely. This will for example happen in the
--   GtkCssProviderparsingError signal. The end position and line
--   may be identical to the start position and line for sections which
--   failed to parse anything successfully.
--   
--   Since: 3.2
cssSectionGetEndPosition :: (HasCallStack, MonadIO m) => CssSection -> m Word32

-- | Gets the file that section was parsed from. If no such
--   file exists, for example because the CSS was loaded via
--   gtkCssProviderLoadFromData(), then Nothing is
--   returned.
--   
--   Since: 3.2
cssSectionGetFile :: (HasCallStack, MonadIO m) => CssSection -> m File

-- | Gets the type of information that section describes.
--   
--   Since: 3.2
cssSectionGetSectionType :: (HasCallStack, MonadIO m) => CssSection -> m CssSectionType

-- | Returns the offset in bytes from the start of the current line
--   returned via cssSectionGetStartLine.
--   
--   Since: 3.2
cssSectionGetStartPosition :: (HasCallStack, MonadIO m) => CssSection -> m Word32

-- | Increments the reference count on section.
--   
--   Since: 3.2
cssSectionRef :: (HasCallStack, MonadIO m) => CssSection -> m CssSection

-- | Decrements the reference count on section, freeing the
--   structure if the reference count reaches 0.
--   
--   Since: 3.2
cssSectionUnref :: (HasCallStack, MonadIO m) => CssSection -> m ()

-- | Construct a FileFilterInfo struct initialized to zero.
newZeroFileFilterInfo :: MonadIO m => m FileFilterInfo

-- | Get the value of the “contains” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileFilterInfo #contains
--   
getFileFilterInfoContains :: MonadIO m => FileFilterInfo -> m [FileFilterFlags]

-- | Set the value of the “contains” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileFilterInfo [ #contains := value ]
--   
setFileFilterInfoContains :: MonadIO m => FileFilterInfo -> [FileFilterFlags] -> m ()

-- | Get the value of the “filename” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileFilterInfo #filename
--   
getFileFilterInfoFilename :: MonadIO m => FileFilterInfo -> m (Maybe Text)

-- | Set the value of the “filename” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileFilterInfo [ #filename := value ]
--   
setFileFilterInfoFilename :: MonadIO m => FileFilterInfo -> CString -> m ()

-- | Set the value of the “filename” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #filename
--   
clearFileFilterInfoFilename :: MonadIO m => FileFilterInfo -> m ()

-- | Get the value of the “uri” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get fileFilterInfo #uri
--   
getFileFilterInfoUri :: MonadIO m => FileFilterInfo -> m (Maybe Text)

-- | Set the value of the “uri” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set fileFilterInfo [ #uri := value ]
--   
setFileFilterInfoUri :: MonadIO m => FileFilterInfo -> CString -> m ()

-- | Set the value of the “uri” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #uri
--   
clearFileFilterInfoUri :: MonadIO m => FileFilterInfo -> m ()

-- | Get the value of the “display_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileFilterInfo #displayName
--   
getFileFilterInfoDisplayName :: MonadIO m => FileFilterInfo -> m (Maybe Text)

-- | Set the value of the “display_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileFilterInfo [ #displayName := value ]
--   
setFileFilterInfoDisplayName :: MonadIO m => FileFilterInfo -> CString -> m ()

-- | Set the value of the “display_name” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #displayName
--   
clearFileFilterInfoDisplayName :: MonadIO m => FileFilterInfo -> m ()

-- | Get the value of the “mime_type” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileFilterInfo #mimeType
--   
getFileFilterInfoMimeType :: MonadIO m => FileFilterInfo -> m (Maybe Text)

-- | Set the value of the “mime_type” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileFilterInfo [ #mimeType := value ]
--   
setFileFilterInfoMimeType :: MonadIO m => FileFilterInfo -> CString -> m ()

-- | Set the value of the “mime_type” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #mimeType
--   
clearFileFilterInfoMimeType :: MonadIO m => FileFilterInfo -> m ()

-- | Memory-managed wrapper type.
newtype IMContextInfo
IMContextInfo :: ManagedPtr IMContextInfo -> IMContextInfo

-- | Construct a IMContextInfo struct initialized to zero.
newZeroIMContextInfo :: MonadIO m => m IMContextInfo

-- | Get the value of the “context_id” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iMContextInfo #contextId
--   
getIMContextInfoContextId :: MonadIO m => IMContextInfo -> m (Maybe Text)

-- | Set the value of the “context_id” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iMContextInfo [ #contextId := value ]
--   
setIMContextInfoContextId :: MonadIO m => IMContextInfo -> CString -> m ()

-- | Set the value of the “context_id” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #contextId
--   
clearIMContextInfoContextId :: MonadIO m => IMContextInfo -> m ()

-- | Get the value of the “context_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iMContextInfo #contextName
--   
getIMContextInfoContextName :: MonadIO m => IMContextInfo -> m (Maybe Text)

-- | Set the value of the “context_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iMContextInfo [ #contextName := value ]
--   
setIMContextInfoContextName :: MonadIO m => IMContextInfo -> CString -> m ()

-- | Set the value of the “context_name” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #contextName
--   
clearIMContextInfoContextName :: MonadIO m => IMContextInfo -> m ()

-- | Get the value of the “domain” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get iMContextInfo #domain
--   
getIMContextInfoDomain :: MonadIO m => IMContextInfo -> m (Maybe Text)

-- | Set the value of the “domain” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set iMContextInfo [ #domain := value ]
--   
setIMContextInfoDomain :: MonadIO m => IMContextInfo -> CString -> m ()

-- | Set the value of the “domain” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #domain
--   
clearIMContextInfoDomain :: MonadIO m => IMContextInfo -> m ()

-- | Get the value of the “domain_dirname” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iMContextInfo #domainDirname
--   
getIMContextInfoDomainDirname :: MonadIO m => IMContextInfo -> m (Maybe Text)

-- | Set the value of the “domain_dirname” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iMContextInfo [ #domainDirname := value ]
--   
setIMContextInfoDomainDirname :: MonadIO m => IMContextInfo -> CString -> m ()

-- | Set the value of the “domain_dirname” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #domainDirname
--   
clearIMContextInfoDomainDirname :: MonadIO m => IMContextInfo -> m ()

-- | Get the value of the “default_locales” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iMContextInfo #defaultLocales
--   
getIMContextInfoDefaultLocales :: MonadIO m => IMContextInfo -> m (Maybe Text)

-- | Set the value of the “default_locales” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iMContextInfo [ #defaultLocales := value ]
--   
setIMContextInfoDefaultLocales :: MonadIO m => IMContextInfo -> CString -> m ()

-- | Set the value of the “default_locales” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #defaultLocales
--   
clearIMContextInfoDefaultLocales :: MonadIO m => IMContextInfo -> m ()

-- | Creates a new IconSource. A IconSource contains a
--   Pixbuf (or image filename) that serves as the base image for
--   one or more of the icons in a IconSet, 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. IconSet contains a list of
--   IconSource from which it can derive specific icon variants in
--   the set.
--   
--   In the simplest case, IconSet contains one source pixbuf from
--   which it derives all variants. The convenience function
--   iconSetNewFromPixbuf 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
--   iconSetAddSource.
--   
--   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 source; 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 Nothing.
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 iconSourceSetDirectionWildcarded.
iconSourceGetDirectionWildcarded :: (HasCallStack, MonadIO m) => IconSource -> m Bool

-- | Retrieves the source filename, or Nothing 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 Nothing 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 Nothing 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 Style
--   render_icon() 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 iconSourceSetSizeWildcarded.
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 iconSourceSetStateWildcarded.
iconSourceGetStateWildcarded :: (HasCallStack, MonadIO m) => IconSource -> m Bool

-- | Sets the name of an image file to use as a base image when creating
--   icon variants for IconSet. 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 IconSet.
iconSourceSetIconName :: (HasCallStack, MonadIO m) => IconSource -> Maybe Text -> m ()

-- | Sets a pixbuf to use as a base image when creating icon variants for
--   IconSet.
iconSourceSetPixbuf :: (HasCallStack, MonadIO m, IsPixbuf a) => IconSource -> a -> m ()

-- | Memory-managed wrapper type.
newtype LabelSelectionInfo
LabelSelectionInfo :: ManagedPtr LabelSelectionInfo -> LabelSelectionInfo

-- | Memory-managed wrapper type.
newtype MountOperationHandlerIface_
MountOperationHandlerIface_ :: ManagedPtr MountOperationHandlerIface_ -> MountOperationHandlerIface_

-- | Construct a MountOperationHandlerIface_ struct initialized to
--   zero.
newZeroMountOperationHandlerIface_ :: MonadIO m => m MountOperationHandlerIface_

-- | Get the value of the “parent_iface” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get mountOperationHandlerIface_ #parentIface
--   
getMountOperationHandlerIface_ParentIface :: MonadIO m => MountOperationHandlerIface_ -> m TypeInterface

-- | Memory-managed wrapper type.
newtype MountOperationHandlerProxyClass_
MountOperationHandlerProxyClass_ :: ManagedPtr MountOperationHandlerProxyClass_ -> MountOperationHandlerProxyClass_

-- | Construct a MountOperationHandlerProxyClass_ struct initialized
--   to zero.
newZeroMountOperationHandlerProxyClass_ :: MonadIO m => m MountOperationHandlerProxyClass_

-- | Memory-managed wrapper type.
newtype MountOperationHandlerProxy_
MountOperationHandlerProxy_ :: ManagedPtr MountOperationHandlerProxy_ -> MountOperationHandlerProxy_

-- | Construct a MountOperationHandlerProxy_ struct initialized to
--   zero.
newZeroMountOperationHandlerProxy_ :: MonadIO m => m MountOperationHandlerProxy_

-- | Memory-managed wrapper type.
newtype MountOperationHandlerSkeletonClass_
MountOperationHandlerSkeletonClass_ :: ManagedPtr MountOperationHandlerSkeletonClass_ -> MountOperationHandlerSkeletonClass_

-- | Construct a MountOperationHandlerSkeletonClass_ struct
--   initialized to zero.
newZeroMountOperationHandlerSkeletonClass_ :: MonadIO m => m MountOperationHandlerSkeletonClass_

-- | Memory-managed wrapper type.
newtype MountOperationHandlerSkeleton_
MountOperationHandlerSkeleton_ :: ManagedPtr MountOperationHandlerSkeleton_ -> MountOperationHandlerSkeleton_

-- | Construct a MountOperationHandlerSkeleton_ struct initialized
--   to zero.
newZeroMountOperationHandlerSkeleton_ :: MonadIO m => m MountOperationHandlerSkeleton_

-- | Memory-managed wrapper type.
newtype MountOperationHandler_
MountOperationHandler_ :: ManagedPtr MountOperationHandler_ -> MountOperationHandler_

-- | Construct a PadActionEntry struct initialized to zero.
newZeroPadActionEntry :: MonadIO m => m PadActionEntry

-- | Get the value of the “type” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get padActionEntry #type
--   
getPadActionEntryType :: MonadIO m => PadActionEntry -> m PadActionType

-- | Set the value of the “type” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set padActionEntry [ #type := value ]
--   
setPadActionEntryType :: MonadIO m => PadActionEntry -> PadActionType -> m ()

-- | Get the value of the “index” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get padActionEntry #index
--   
getPadActionEntryIndex :: MonadIO m => PadActionEntry -> m Int32

-- | Set the value of the “index” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set padActionEntry [ #index := value ]
--   
setPadActionEntryIndex :: MonadIO m => PadActionEntry -> Int32 -> m ()

-- | Get the value of the “mode” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get padActionEntry #mode
--   
getPadActionEntryMode :: MonadIO m => PadActionEntry -> m Int32

-- | Set the value of the “mode” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set padActionEntry [ #mode := value ]
--   
setPadActionEntryMode :: MonadIO m => PadActionEntry -> Int32 -> m ()

-- | Get the value of the “label” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get padActionEntry #label
--   
getPadActionEntryLabel :: MonadIO m => PadActionEntry -> m (Maybe Text)

-- | Set the value of the “label” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set padActionEntry [ #label := value ]
--   
setPadActionEntryLabel :: MonadIO m => PadActionEntry -> CString -> m ()

-- | Set the value of the “label” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #label
--   
clearPadActionEntryLabel :: MonadIO m => PadActionEntry -> m ()

-- | Get the value of the “action_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get padActionEntry #actionName
--   
getPadActionEntryActionName :: MonadIO m => PadActionEntry -> m (Maybe Text)

-- | Set the value of the “action_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set padActionEntry [ #actionName := value ]
--   
setPadActionEntryActionName :: MonadIO m => PadActionEntry -> CString -> m ()

-- | Set the value of the “action_name” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #actionName
--   
clearPadActionEntryActionName :: MonadIO m => PadActionEntry -> m ()

-- | Memory-managed wrapper type.
newtype PageRange
PageRange :: ManagedPtr PageRange -> PageRange

-- | Construct a PageRange struct initialized to zero.
newZeroPageRange :: MonadIO m => m PageRange

-- | Get the value of the “start” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get pageRange #start
--   
getPageRangeStart :: MonadIO m => PageRange -> m Int32

-- | Set the value of the “start” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set pageRange [ #start := value ]
--   
setPageRangeStart :: MonadIO m => PageRange -> Int32 -> m ()

-- | Get the value of the “end” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get pageRange #end
--   
getPageRangeEnd :: MonadIO m => PageRange -> m Int32

-- | Set the value of the “end” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set pageRange [ #end := value ]
--   
setPageRangeEnd :: MonadIO m => PageRange -> Int32 -> m ()

-- | Creates a new PaperSize object by parsing a PWG
--   5101.1-2002 paper name.
--   
--   If name is Nothing, the default paper size is
--   returned, see paperSizeGetDefault.
--   
--   Since: 2.10
paperSizeNew :: (HasCallStack, MonadIO m) => Maybe Text -> m PaperSize

-- | Creates a new PaperSize object with the given parameters.
--   
--   Since: 2.10
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 paperSizeToGvariant.
--   
--   Since: 3.22
paperSizeNewFromGvariant :: (HasCallStack, MonadIO m) => GVariant -> m PaperSize

-- | Creates a new PaperSize object by using IPP information.
--   
--   If ippName is not a recognized paper name,
--   width and height are used to construct
--   a custom PaperSize object.
--   
--   Since: 3.16
paperSizeNewFromIpp :: (HasCallStack, MonadIO m) => Text -> Double -> Double -> m PaperSize

-- | Reads a paper size from the group groupName in the key
--   file keyFile.
--   
--   Since: 2.12
paperSizeNewFromKeyFile :: (HasCallStack, MonadIO m) => KeyFile -> Maybe Text -> m PaperSize

-- | Creates a new PaperSize object by using PPD information.
--   
--   If ppdName is not a recognized PPD paper name,
--   ppdDisplayName, width and
--   height are used to construct a custom PaperSize
--   object.
--   
--   Since: 2.10
paperSizeNewFromPpd :: (HasCallStack, MonadIO m) => Text -> Text -> Double -> Double -> m PaperSize

-- | Copies an existing PaperSize.
--   
--   Since: 2.10
paperSizeCopy :: (HasCallStack, MonadIO m) => PaperSize -> m PaperSize

-- | Gets the default bottom margin for the PaperSize.
--   
--   Since: 2.10
paperSizeGetDefaultBottomMargin :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the default left margin for the PaperSize.
--   
--   Since: 2.10
paperSizeGetDefaultLeftMargin :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the default right margin for the PaperSize.
--   
--   Since: 2.10
paperSizeGetDefaultRightMargin :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the default top margin for the PaperSize.
--   
--   Since: 2.10
paperSizeGetDefaultTopMargin :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the human-readable name of the PaperSize.
--   
--   Since: 2.10
paperSizeGetDisplayName :: (HasCallStack, MonadIO m) => PaperSize -> m Text

-- | Gets the paper height of the PaperSize, in units of
--   unit.
--   
--   Since: 2.10
paperSizeGetHeight :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the name of the PaperSize.
--   
--   Since: 2.10
paperSizeGetName :: (HasCallStack, MonadIO m) => PaperSize -> m Text

-- | Gets the PPD name of the PaperSize, which may be
--   Nothing.
--   
--   Since: 2.10
paperSizeGetPpdName :: (HasCallStack, MonadIO m) => PaperSize -> m Text

-- | Gets the paper width of the PaperSize, in units of
--   unit.
--   
--   Since: 2.10
paperSizeGetWidth :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Returns True if size is not a standard paper
--   size.
paperSizeIsCustom :: (HasCallStack, MonadIO m) => PaperSize -> m Bool

-- | Compares two PaperSize objects.
--   
--   Since: 2.10
paperSizeIsEqual :: (HasCallStack, MonadIO m) => PaperSize -> PaperSize -> m Bool

-- | Returns True if size is an IPP standard paper
--   size.
paperSizeIsIpp :: (HasCallStack, MonadIO m) => PaperSize -> m Bool

-- | Changes the dimensions of a size to
--   width x height.
--   
--   Since: 2.10
paperSizeSetSize :: (HasCallStack, MonadIO m) => PaperSize -> Double -> Double -> Unit -> m ()

-- | This function adds the paper size from size to
--   keyFile.
--   
--   Since: 2.12
paperSizeToKeyFile :: (HasCallStack, MonadIO m) => PaperSize -> KeyFile -> Text -> m ()

-- | Creates a list of known paper sizes.
--   
--   Since: 2.12
paperSizeGetPaperSizes :: (HasCallStack, MonadIO m) => Bool -> m [PaperSize]

-- | Type class for types which can be safely cast to PageSetup, for
--   instance with toPageSetup.
class (GObject o, IsDescendantOf PageSetup o) => IsPageSetup o

-- | Cast to PageSetup, for types for which this is known to be
--   safe. For general casts, use castTo.
toPageSetup :: (MonadIO m, IsPageSetup o) => o -> m PageSetup

-- | Creates a new PageSetup.
--   
--   Since: 2.10
pageSetupNew :: (HasCallStack, MonadIO m) => m PageSetup

-- | Reads the page setup from the file fileName. Returns a
--   new PageSetup object with the restored page setup, or
--   Nothing if an error occurred. See pageSetupToFile.
--   
--   Since: 2.12
pageSetupNewFromFile :: (HasCallStack, MonadIO m) => [Char] -> m PageSetup

-- | Desrialize a page setup from an a{sv} variant in the format produced
--   by pageSetupToGvariant.
--   
--   Since: 3.22
pageSetupNewFromGvariant :: (HasCallStack, MonadIO m) => GVariant -> m PageSetup

-- | Reads the page setup from the group groupName in the
--   key file keyFile. Returns a new PageSetup
--   object with the restored page setup, or Nothing if an error
--   occurred.
--   
--   Since: 2.12
pageSetupNewFromKeyFile :: (HasCallStack, MonadIO m) => KeyFile -> Maybe Text -> m PageSetup

-- | Copies a PageSetup.
--   
--   Since: 2.10
pageSetupCopy :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> m PageSetup

-- | Gets the bottom margin in units of unit.
--   
--   Since: 2.10
pageSetupGetBottomMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Gets the left margin in units of unit.
--   
--   Since: 2.10
pageSetupGetLeftMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Gets the page orientation of the PageSetup.
--   
--   Since: 2.10
pageSetupGetOrientation :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> m PageOrientation

-- | Gets the paper size of the PageSetup.
--   
--   Since: 2.10
pageSetupGetPaperSize :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> m PaperSize

-- | Gets the right margin in units of unit.
--   
--   Since: 2.10
pageSetupGetRightMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Gets the top margin in units of unit.
--   
--   Since: 2.10
pageSetupGetTopMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Reads the page setup from the file fileName. See
--   pageSetupToFile.
--   
--   Since: 2.14
pageSetupLoadFile :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> [Char] -> m ()

-- | Reads the page setup from the group groupName in the
--   key file keyFile.
--   
--   Since: 2.14
pageSetupLoadKeyFile :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> KeyFile -> Maybe Text -> m ()

-- | Sets the bottom margin of the PageSetup.
--   
--   Since: 2.10
pageSetupSetBottomMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Double -> Unit -> m ()

-- | Sets the left margin of the PageSetup.
--   
--   Since: 2.10
pageSetupSetLeftMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Double -> Unit -> m ()

-- | Sets the page orientation of the PageSetup.
--   
--   Since: 2.10
pageSetupSetOrientation :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> PageOrientation -> m ()

-- | Sets the paper size of the PageSetup without changing the
--   margins. See pageSetupSetPaperSizeAndDefaultMargins.
--   
--   Since: 2.10
pageSetupSetPaperSize :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> PaperSize -> m ()

-- | Sets the right margin of the PageSetup.
--   
--   Since: 2.10
pageSetupSetRightMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Double -> Unit -> m ()

-- | Sets the top margin of the PageSetup.
--   
--   Since: 2.10
pageSetupSetTopMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Double -> Unit -> m ()

-- | This function adds the page setup from setup to
--   keyFile.
--   
--   Since: 2.12
pageSetupToKeyFile :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> KeyFile -> Maybe Text -> m ()

-- | Type class for types which can be safely cast to PrintContext,
--   for instance with toPrintContext.
class (GObject o, IsDescendantOf PrintContext o) => IsPrintContext o

-- | Cast to PrintContext, for types for which this is known to be
--   safe. For general casts, use castTo.
toPrintContext :: (MonadIO m, IsPrintContext o) => o -> m PrintContext

-- | Creates a new Context that can be used with the
--   PrintContext.
--   
--   Since: 2.10
printContextCreatePangoContext :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Context

-- | Creates a new Layout that is suitable for use with the
--   PrintContext.
--   
--   Since: 2.10
printContextCreatePangoLayout :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Layout

-- | Obtains the horizontal resolution of the PrintContext, in dots
--   per inch.
--   
--   Since: 2.10
printContextGetDpiX :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Double

-- | Obtains the vertical resolution of the PrintContext, in dots
--   per inch.
--   
--   Since: 2.10
printContextGetDpiY :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Double

-- | Obtains the hardware printer margins of the PrintContext, in
--   units.
--   
--   Since: 2.20
printContextGetHardMargins :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m (Bool, Double, Double, Double, Double)

-- | Obtains the height of the PrintContext, in pixels.
--   
--   Since: 2.10
printContextGetHeight :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Double

-- | Obtains the PageSetup that determines the page dimensions of
--   the PrintContext.
--   
--   Since: 2.10
printContextGetPageSetup :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m PageSetup

-- | Returns a FontMap that is suitable for use with the
--   PrintContext.
--   
--   Since: 2.10
printContextGetPangoFontmap :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m FontMap

-- | Obtains the width of the PrintContext, in pixels.
--   
--   Since: 2.10
printContextGetWidth :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Double

-- | Type class for types which can be safely cast to
--   PrintOperationPreview, for instance with
--   toPrintOperationPreview.
class (GObject o, IsDescendantOf PrintOperationPreview o) => IsPrintOperationPreview o

-- | Cast to PrintOperationPreview, for types for which this is
--   known to be safe. For general casts, use castTo.
toPrintOperationPreview :: (MonadIO m, IsPrintOperationPreview o) => o -> m PrintOperationPreview

-- | The ready 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 gotPageSize signal is emitted once for each page that gets
--   rendered to the preview.
--   
--   A handler for this signal should update the context
--   according to pageSetup and set up a suitable cairo
--   context, using printContextSetCairoContext.
type PrintOperationPreviewGotPageSizeCallback = PrintContext -> PageSetup -> IO ()

-- | Connect a signal handler for the gotPageSize signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on printOperationPreview #gotPageSize callback
--   
onPrintOperationPreviewGotPageSize :: (IsPrintOperationPreview a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewGotPageSizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the gotPageSize signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after printOperationPreview #gotPageSize callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPrintOperationPreviewGotPageSize :: (IsPrintOperationPreview a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewGotPageSizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the ready signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on printOperationPreview #ready callback
--   
onPrintOperationPreviewReady :: (IsPrintOperationPreview a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewReadyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the ready signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after printOperationPreview #ready callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPrintOperationPreviewReady :: (IsPrintOperationPreview a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewReadyCallback) -> m SignalHandlerId

-- | Memory-managed wrapper type.
newtype RadioActionEntry
RadioActionEntry :: ManagedPtr RadioActionEntry -> RadioActionEntry

-- | Construct a RadioActionEntry struct initialized to zero.
newZeroRadioActionEntry :: MonadIO m => m RadioActionEntry

-- | Get the value of the “name” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get radioActionEntry #name
--   
getRadioActionEntryName :: MonadIO m => RadioActionEntry -> m (Maybe Text)

-- | Set the value of the “name” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set radioActionEntry [ #name := value ]
--   
setRadioActionEntryName :: MonadIO m => RadioActionEntry -> CString -> m ()

-- | Set the value of the “name” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #name
--   
clearRadioActionEntryName :: MonadIO m => RadioActionEntry -> m ()

-- | Get the value of the “stock_id” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get radioActionEntry #stockId
--   
getRadioActionEntryStockId :: MonadIO m => RadioActionEntry -> m (Maybe Text)

-- | Set the value of the “stock_id” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set radioActionEntry [ #stockId := value ]
--   
setRadioActionEntryStockId :: MonadIO m => RadioActionEntry -> CString -> m ()

-- | Set the value of the “stock_id” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #stockId
--   
clearRadioActionEntryStockId :: MonadIO m => RadioActionEntry -> m ()

-- | Get the value of the “label” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get radioActionEntry #label
--   
getRadioActionEntryLabel :: MonadIO m => RadioActionEntry -> m (Maybe Text)

-- | Set the value of the “label” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set radioActionEntry [ #label := value ]
--   
setRadioActionEntryLabel :: MonadIO m => RadioActionEntry -> CString -> m ()

-- | Set the value of the “label” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #label
--   
clearRadioActionEntryLabel :: MonadIO m => RadioActionEntry -> m ()

-- | Get the value of the “accelerator” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get radioActionEntry #accelerator
--   
getRadioActionEntryAccelerator :: MonadIO m => RadioActionEntry -> m (Maybe Text)

-- | Set the value of the “accelerator” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set radioActionEntry [ #accelerator := value ]
--   
setRadioActionEntryAccelerator :: MonadIO m => RadioActionEntry -> CString -> m ()

-- | Set the value of the “accelerator” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #accelerator
--   
clearRadioActionEntryAccelerator :: MonadIO m => RadioActionEntry -> m ()

-- | Get the value of the “tooltip” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get radioActionEntry #tooltip
--   
getRadioActionEntryTooltip :: MonadIO m => RadioActionEntry -> m (Maybe Text)

-- | Set the value of the “tooltip” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set radioActionEntry [ #tooltip := value ]
--   
setRadioActionEntryTooltip :: MonadIO m => RadioActionEntry -> CString -> m ()

-- | Set the value of the “tooltip” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #tooltip
--   
clearRadioActionEntryTooltip :: MonadIO m => RadioActionEntry -> m ()

-- | Get the value of the “value” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get radioActionEntry #value
--   
getRadioActionEntryValue :: MonadIO m => RadioActionEntry -> m Int32

-- | Set the value of the “value” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set radioActionEntry [ #value := value ]
--   
setRadioActionEntryValue :: MonadIO m => RadioActionEntry -> Int32 -> m ()

-- | Memory-managed wrapper type.
newtype RcContext
RcContext :: ManagedPtr RcContext -> RcContext

-- | Memory-managed wrapper type.
newtype RcProperty
RcProperty :: ManagedPtr RcProperty -> RcProperty

-- | Construct a RcProperty struct initialized to zero.
newZeroRcProperty :: MonadIO m => m RcProperty

-- | Get the value of the “type_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get rcProperty #typeName
--   
getRcPropertyTypeName :: MonadIO m => RcProperty -> m Word32

-- | Set the value of the “type_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set rcProperty [ #typeName := value ]
--   
setRcPropertyTypeName :: MonadIO m => RcProperty -> Word32 -> m ()

-- | Get the value of the “property_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get rcProperty #propertyName
--   
getRcPropertyPropertyName :: MonadIO m => RcProperty -> m Word32

-- | Set the value of the “property_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set rcProperty [ #propertyName := value ]
--   
setRcPropertyPropertyName :: MonadIO m => RcProperty -> Word32 -> m ()

-- | Get the value of the “origin” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get rcProperty #origin
--   
getRcPropertyOrigin :: MonadIO m => RcProperty -> m (Maybe Text)

-- | Set the value of the “origin” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set rcProperty [ #origin := value ]
--   
setRcPropertyOrigin :: MonadIO m => RcProperty -> CString -> m ()

-- | Set the value of the “origin” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #origin
--   
clearRcPropertyOrigin :: MonadIO m => RcProperty -> m ()

-- | Get the value of the “value” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get rcProperty #value
--   
getRcPropertyValue :: MonadIO m => RcProperty -> m (Maybe GValue)

-- | Set the value of the “value” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set rcProperty [ #value := value ]
--   
setRcPropertyValue :: MonadIO m => RcProperty -> Ptr GValue -> m ()

-- | Set the value of the “value” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #value
--   
clearRcPropertyValue :: MonadIO m => RcProperty -> m ()

-- | A RcPropertyParser for use with
--   settingsInstallPropertyParser or
--   gtk_widget_class_install_style_property_parser() which
--   parses borders in the form "{ left, right, top, bottom }" for
--   integers left, right, top and bottom.
rcPropertyParseBorder :: (HasCallStack, MonadIO m) => GParamSpec -> String -> GValue -> m Bool

-- | A RcPropertyParser for use with
--   settingsInstallPropertyParser or
--   gtk_widget_class_install_style_property_parser() which
--   parses a color given either by its name or in the form { red,
--   green, blue } 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 RcPropertyParser for use with
--   settingsInstallPropertyParser or
--   gtk_widget_class_install_style_property_parser() 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 RcPropertyParser for use with
--   settingsInstallPropertyParser or
--   gtk_widget_class_install_style_property_parser() which
--   parses flags.
--   
--   Flags can be specified by their name, their nickname or numerically.
--   Multiple flags can be specified in the form "( flag1 | flag2 | ...
--   )".
rcPropertyParseFlags :: (HasCallStack, MonadIO m) => GParamSpec -> String -> GValue -> m Bool

-- | A RcPropertyParser for use with
--   settingsInstallPropertyParser or
--   gtk_widget_class_install_style_property_parser() which
--   parses a requisition in the form "{ width, height }" for
--   integers width and height.
rcPropertyParseRequisition :: (HasCallStack, MonadIO m) => GParamSpec -> String -> GValue -> m Bool

-- | Construct a RecentData struct initialized to zero.
newZeroRecentData :: MonadIO m => m RecentData

-- | Get the value of the “display_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentData #displayName
--   
getRecentDataDisplayName :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “display_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentData [ #displayName := value ]
--   
setRecentDataDisplayName :: MonadIO m => RecentData -> CString -> m ()

-- | Set the value of the “display_name” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #displayName
--   
clearRecentDataDisplayName :: MonadIO m => RecentData -> m ()

-- | Get the value of the “description” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentData #description
--   
getRecentDataDescription :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “description” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentData [ #description := value ]
--   
setRecentDataDescription :: MonadIO m => RecentData -> CString -> m ()

-- | Set the value of the “description” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #description
--   
clearRecentDataDescription :: MonadIO m => RecentData -> m ()

-- | Get the value of the “mime_type” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentData #mimeType
--   
getRecentDataMimeType :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “mime_type” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentData [ #mimeType := value ]
--   
setRecentDataMimeType :: MonadIO m => RecentData -> CString -> m ()

-- | Set the value of the “mime_type” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #mimeType
--   
clearRecentDataMimeType :: MonadIO m => RecentData -> m ()

-- | Get the value of the “app_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentData #appName
--   
getRecentDataAppName :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “app_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentData [ #appName := value ]
--   
setRecentDataAppName :: MonadIO m => RecentData -> CString -> m ()

-- | Set the value of the “app_name” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #appName
--   
clearRecentDataAppName :: MonadIO m => RecentData -> m ()

-- | Get the value of the “app_exec” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentData #appExec
--   
getRecentDataAppExec :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “app_exec” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentData [ #appExec := value ]
--   
setRecentDataAppExec :: MonadIO m => RecentData -> CString -> m ()

-- | Set the value of the “app_exec” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #appExec
--   
clearRecentDataAppExec :: MonadIO m => RecentData -> m ()

-- | Get the value of the “groups” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get recentData #groups
--   
getRecentDataGroups :: MonadIO m => RecentData -> m (Maybe [Text])

-- | Set the value of the “groups” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set recentData [ #groups := value ]
--   
setRecentDataGroups :: MonadIO m => RecentData -> Ptr CString -> m ()

-- | Set the value of the “groups” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #groups
--   
clearRecentDataGroups :: MonadIO m => RecentData -> m ()

-- | Get the value of the “is_private” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentData #isPrivate
--   
getRecentDataIsPrivate :: MonadIO m => RecentData -> m Bool

-- | Set the value of the “is_private” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentData [ #isPrivate := value ]
--   
setRecentDataIsPrivate :: MonadIO m => RecentData -> Bool -> m ()

-- | Construct a RecentFilterInfo struct initialized to zero.
newZeroRecentFilterInfo :: MonadIO m => m RecentFilterInfo

-- | Get the value of the “contains” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentFilterInfo #contains
--   
getRecentFilterInfoContains :: MonadIO m => RecentFilterInfo -> m [RecentFilterFlags]

-- | Set the value of the “contains” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentFilterInfo [ #contains := value ]
--   
setRecentFilterInfoContains :: MonadIO m => RecentFilterInfo -> [RecentFilterFlags] -> m ()

-- | Get the value of the “uri” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get recentFilterInfo #uri
--   
getRecentFilterInfoUri :: MonadIO m => RecentFilterInfo -> m (Maybe Text)

-- | Set the value of the “uri” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set recentFilterInfo [ #uri := value ]
--   
setRecentFilterInfoUri :: MonadIO m => RecentFilterInfo -> CString -> m ()

-- | Set the value of the “uri” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #uri
--   
clearRecentFilterInfoUri :: MonadIO m => RecentFilterInfo -> m ()

-- | Get the value of the “display_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentFilterInfo #displayName
--   
getRecentFilterInfoDisplayName :: MonadIO m => RecentFilterInfo -> m (Maybe Text)

-- | Set the value of the “display_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentFilterInfo [ #displayName := value ]
--   
setRecentFilterInfoDisplayName :: MonadIO m => RecentFilterInfo -> CString -> m ()

-- | Set the value of the “display_name” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #displayName
--   
clearRecentFilterInfoDisplayName :: MonadIO m => RecentFilterInfo -> m ()

-- | Get the value of the “mime_type” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentFilterInfo #mimeType
--   
getRecentFilterInfoMimeType :: MonadIO m => RecentFilterInfo -> m (Maybe Text)

-- | Set the value of the “mime_type” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentFilterInfo [ #mimeType := value ]
--   
setRecentFilterInfoMimeType :: MonadIO m => RecentFilterInfo -> CString -> m ()

-- | Set the value of the “mime_type” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #mimeType
--   
clearRecentFilterInfoMimeType :: MonadIO m => RecentFilterInfo -> m ()

-- | Get the value of the “applications” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentFilterInfo #applications
--   
getRecentFilterInfoApplications :: MonadIO m => RecentFilterInfo -> m (Maybe [Text])

-- | Set the value of the “applications” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentFilterInfo [ #applications := value ]
--   
setRecentFilterInfoApplications :: MonadIO m => RecentFilterInfo -> Ptr CString -> m ()

-- | Set the value of the “applications” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #applications
--   
clearRecentFilterInfoApplications :: MonadIO m => RecentFilterInfo -> m ()

-- | Get the value of the “groups” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get recentFilterInfo #groups
--   
getRecentFilterInfoGroups :: MonadIO m => RecentFilterInfo -> m (Maybe [Text])

-- | Set the value of the “groups” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set recentFilterInfo [ #groups := value ]
--   
setRecentFilterInfoGroups :: MonadIO m => RecentFilterInfo -> Ptr CString -> m ()

-- | Set the value of the “groups” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #groups
--   
clearRecentFilterInfoGroups :: MonadIO m => RecentFilterInfo -> m ()

-- | Get the value of the “age” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get recentFilterInfo #age
--   
getRecentFilterInfoAge :: MonadIO m => RecentFilterInfo -> m Int32

-- | Set the value of the “age” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set recentFilterInfo [ #age := value ]
--   
setRecentFilterInfoAge :: MonadIO m => RecentFilterInfo -> Int32 -> m ()

-- | Creates a AppInfo for the specified RecentInfo
recentInfoCreateAppInfo :: (HasCallStack, MonadIO m) => RecentInfo -> Maybe Text -> m (Maybe AppInfo)

-- | Checks whether the resource pointed by info still
--   exists. At the moment this check is done only on resources pointing to
--   local files.
--   
--   Since: 2.10
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.
--   
--   Since: 2.10
recentInfoGetAdded :: (HasCallStack, MonadIO m) => RecentInfo -> m CTime

-- | Gets the number of days elapsed since the last update of the resource
--   pointed by info.
--   
--   Since: 2.10
recentInfoGetAge :: (HasCallStack, MonadIO m) => RecentInfo -> m Int32

-- | Gets the data regarding the application that has registered the
--   resource pointed by info.
--   
--   If the command line contains any escape characters defined inside the
--   storage specification, they will be expanded.
--   
--   Since: 2.10
recentInfoGetApplicationInfo :: (HasCallStack, MonadIO m) => RecentInfo -> Text -> m (Bool, Text, Word32, CTime)

-- | Retrieves the list of applications that have registered this resource.
--   
--   Since: 2.10
recentInfoGetApplications :: (HasCallStack, MonadIO m) => RecentInfo -> m ([Text], CSize)

-- | Gets the (short) description of the resource.
--   
--   Since: 2.10
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.
--   
--   Since: 2.10
recentInfoGetDisplayName :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Retrieves the icon associated to the resource MIME type.
--   
--   Since: 2.22
recentInfoGetGicon :: (HasCallStack, MonadIO m) => RecentInfo -> m (Maybe Icon)

-- | Returns all groups registered for the recently used item
--   info. The array of returned group names will be
--   Nothing terminated, so length might optionally be
--   Nothing.
--   
--   Since: 2.10
recentInfoGetGroups :: (HasCallStack, MonadIO m) => RecentInfo -> m ([Text], CSize)

-- | Retrieves the icon of size size associated to the
--   resource MIME type.
--   
--   Since: 2.10
recentInfoGetIcon :: (HasCallStack, MonadIO m) => RecentInfo -> Int32 -> m (Maybe Pixbuf)

-- | Gets the MIME type of the resource.
--   
--   Since: 2.10
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.
--   
--   Since: 2.10
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 True should only be displayed
--   by the applications that have registered them.
--   
--   Since: 2.10
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”.
--   
--   Since: 2.10
recentInfoGetShortName :: (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 recentInfoGetUri.
--   
--   Since: 2.10
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.
--   
--   Since: 2.10
recentInfoGetVisited :: (HasCallStack, MonadIO m) => RecentInfo -> m CTime

-- | Checks whether an application registered this resource using
--   appName.
--   
--   Since: 2.10
recentInfoHasApplication :: (HasCallStack, MonadIO m) => RecentInfo -> Text -> m Bool

-- | Checks whether groupName appears inside the groups
--   registered for the recently used item info.
--   
--   Since: 2.10
recentInfoHasGroup :: (HasCallStack, MonadIO m) => RecentInfo -> Text -> m Bool

-- | Checks whether the resource is local or not by looking at the scheme
--   of its URI.
--   
--   Since: 2.10
recentInfoIsLocal :: (HasCallStack, MonadIO m) => RecentInfo -> m Bool

-- | Gets the name of the last application that have registered the
--   recently used resource represented by info.
--   
--   Since: 2.10
recentInfoLastApplication :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Checks whether two RecentInfo-struct point to the same
--   resource.
--   
--   Since: 2.10
recentInfoMatch :: (HasCallStack, MonadIO m) => RecentInfo -> RecentInfo -> m Bool

-- | Increases the reference count of recentInfo by one.
--   
--   Since: 2.10
recentInfoRef :: (HasCallStack, MonadIO m) => RecentInfo -> m RecentInfo

-- | Type class for types which can be safely cast to RecentManager,
--   for instance with toRecentManager.
class (GObject o, IsDescendantOf RecentManager o) => IsRecentManager o

-- | Cast to RecentManager, for types for which this is known to be
--   safe. For general casts, use castTo.
toRecentManager :: (MonadIO m, IsRecentManager o) => o -> m RecentManager

-- | Emitted when the current recently used resources manager changes its
--   contents, either by calling recentManagerAddItem or by another
--   application.
--   
--   Since: 2.10
type RecentManagerChangedCallback = IO ()

-- | Connect a signal handler for the changed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on recentManager #changed callback
--   
onRecentManagerChanged :: (IsRecentManager a, MonadIO m) => a -> ((?self :: a) => RecentManagerChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after recentManager #changed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterRecentManagerChanged :: (IsRecentManager a, MonadIO m) => a -> ((?self :: a) => RecentManagerChangedCallback) -> m SignalHandlerId

-- | Get the value of the “filename” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentManager #filename
--   
getRecentManagerFilename :: (MonadIO m, IsRecentManager o) => o -> m (Maybe Text)

-- | Construct a GValueConstruct with valid value for the
--   “filename” property. This is rarely needed directly, but it
--   is used by new.
constructRecentManagerFilename :: (IsRecentManager o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “size” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get recentManager #size
--   
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 RecentManager
--   object monitors the recently used resources list, and emits the
--   “changed” signal each time something inside the list changes.
--   
--   RecentManager objects are expensive: be sure to create them
--   only when needed. You should use recentManagerGetDefault
--   instead.
--   
--   Since: 2.10
recentManagerNew :: (HasCallStack, MonadIO m) => m RecentManager

-- | Gets the list of recently used resources.
--   
--   Since: 2.10
recentManagerGetItems :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> m [RecentInfo]

-- | Checks whether there is a recently used resource registered with
--   uri inside the recent manager.
--   
--   Since: 2.10
recentManagerHasItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> m Bool

-- | Searches for a URI inside the recently used resources list, and
--   returns a RecentInfo-struct containing informations about the
--   resource like its MIME type, or its display name.
--   
--   Since: 2.10
recentManagerLookupItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> m (Maybe RecentInfo)

-- | Changes the location of a recently used resource from
--   uri to newUri.
--   
--   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.
--   
--   Since: 2.10
recentManagerMoveItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> Maybe Text -> m ()

-- | Purges every item from the recently used resources list.
--   
--   Since: 2.10
recentManagerPurgeItems :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> m Int32

-- | Removes a resource pointed by uri from the recently
--   used resources list handled by a recent manager.
--   
--   Since: 2.10
recentManagerRemoveItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> m ()

-- | Memory-managed wrapper type.
newtype RequestedSize
RequestedSize :: ManagedPtr RequestedSize -> RequestedSize

-- | Construct a RequestedSize struct initialized to zero.
newZeroRequestedSize :: MonadIO m => m RequestedSize

-- | Get the value of the “data” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get requestedSize #data
--   
getRequestedSizeData :: MonadIO m => RequestedSize -> m (Ptr ())

-- | Set the value of the “data” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set requestedSize [ #data := value ]
--   
setRequestedSizeData :: MonadIO m => RequestedSize -> Ptr () -> m ()

-- | Set the value of the “data” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #data
--   
clearRequestedSizeData :: MonadIO m => RequestedSize -> m ()

-- | Get the value of the “minimum_size” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get requestedSize #minimumSize
--   
getRequestedSizeMinimumSize :: MonadIO m => RequestedSize -> m Int32

-- | Set the value of the “minimum_size” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set requestedSize [ #minimumSize := value ]
--   
setRequestedSizeMinimumSize :: MonadIO m => RequestedSize -> Int32 -> m ()

-- | Get the value of the “natural_size” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get requestedSize #naturalSize
--   
getRequestedSizeNaturalSize :: MonadIO m => RequestedSize -> m Int32

-- | Set the value of the “natural_size” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set requestedSize [ #naturalSize := value ]
--   
setRequestedSizeNaturalSize :: MonadIO m => RequestedSize -> Int32 -> m ()

-- | Construct a Requisition struct initialized to zero.
newZeroRequisition :: MonadIO m => m Requisition

-- | Get the value of the “width” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get requisition #width
--   
getRequisitionWidth :: MonadIO m => Requisition -> m Int32

-- | Set the value of the “width” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set requisition [ #width := value ]
--   
setRequisitionWidth :: MonadIO m => Requisition -> Int32 -> m ()

-- | Get the value of the “height” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get requisition #height
--   
getRequisitionHeight :: MonadIO m => Requisition -> m Int32

-- | Set the value of the “height” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set requisition [ #height := value ]
--   
setRequisitionHeight :: MonadIO m => Requisition -> Int32 -> m ()

-- | Allocates a new Requisition-struct and initializes its elements
--   to zero.
--   
--   Since: 3.0
requisitionNew :: (HasCallStack, MonadIO m) => m Requisition

-- | Copies a Requisition.
requisitionCopy :: (HasCallStack, MonadIO m) => Requisition -> m Requisition

-- | Memory-managed wrapper type.
newtype SettingsValue
SettingsValue :: ManagedPtr SettingsValue -> SettingsValue

-- | Construct a SettingsValue struct initialized to zero.
newZeroSettingsValue :: MonadIO m => m SettingsValue

-- | Get the value of the “origin” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get settingsValue #origin
--   
getSettingsValueOrigin :: MonadIO m => SettingsValue -> m (Maybe Text)

-- | Set the value of the “origin” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set settingsValue [ #origin := value ]
--   
setSettingsValueOrigin :: MonadIO m => SettingsValue -> CString -> m ()

-- | Set the value of the “origin” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #origin
--   
clearSettingsValueOrigin :: MonadIO m => SettingsValue -> m ()

-- | Get the value of the “value” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get settingsValue #value
--   
getSettingsValueValue :: MonadIO m => SettingsValue -> m (Maybe GValue)

-- | Set the value of the “value” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set settingsValue [ #value := value ]
--   
setSettingsValueValue :: MonadIO m => SettingsValue -> Ptr GValue -> m ()

-- | Set the value of the “value” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #value
--   
clearSettingsValueValue :: MonadIO m => SettingsValue -> m ()

-- | Construct a StockItem struct initialized to zero.
newZeroStockItem :: MonadIO m => m StockItem

-- | Get the value of the “stock_id” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stockItem #stockId
--   
getStockItemStockId :: MonadIO m => StockItem -> m (Maybe Text)

-- | Set the value of the “stock_id” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set stockItem [ #stockId := value ]
--   
setStockItemStockId :: MonadIO m => StockItem -> CString -> m ()

-- | Set the value of the “stock_id” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #stockId
--   
clearStockItemStockId :: MonadIO m => StockItem -> m ()

-- | Get the value of the “label” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get stockItem #label
--   
getStockItemLabel :: MonadIO m => StockItem -> m (Maybe Text)

-- | Set the value of the “label” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set stockItem [ #label := value ]
--   
setStockItemLabel :: MonadIO m => StockItem -> CString -> m ()

-- | Set the value of the “label” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #label
--   
clearStockItemLabel :: MonadIO m => StockItem -> m ()

-- | Get the value of the “modifier” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stockItem #modifier
--   
getStockItemModifier :: MonadIO m => StockItem -> m [ModifierType]

-- | Set the value of the “modifier” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set stockItem [ #modifier := value ]
--   
setStockItemModifier :: MonadIO m => StockItem -> [ModifierType] -> m ()

-- | Get the value of the “keyval” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get stockItem #keyval
--   
getStockItemKeyval :: MonadIO m => StockItem -> m Word32

-- | Set the value of the “keyval” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set stockItem [ #keyval := value ]
--   
setStockItemKeyval :: MonadIO m => StockItem -> Word32 -> m ()

-- | Get the value of the “translation_domain” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stockItem #translationDomain
--   
getStockItemTranslationDomain :: MonadIO m => StockItem -> m (Maybe Text)

-- | Set the value of the “translation_domain” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set stockItem [ #translationDomain := value ]
--   
setStockItemTranslationDomain :: MonadIO m => StockItem -> CString -> m ()

-- | Set the value of the “translation_domain” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #translationDomain
--   
clearStockItemTranslationDomain :: MonadIO m => StockItem -> m ()

-- | Frees a stock item allocated on the heap, such as one returned by
--   gtk_stock_item_copy(). Also frees the fields inside
--   the stock item, if they are not Nothing.
stockItemFree :: (HasCallStack, MonadIO m) => StockItem -> m ()

-- | Memory-managed wrapper type.
newtype TableRowCol
TableRowCol :: ManagedPtr TableRowCol -> TableRowCol

-- | Construct a TableRowCol struct initialized to zero.
newZeroTableRowCol :: MonadIO m => m TableRowCol

-- | Get the value of the “requisition” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get tableRowCol #requisition
--   
getTableRowColRequisition :: MonadIO m => TableRowCol -> m Word16

-- | Set the value of the “requisition” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set tableRowCol [ #requisition := value ]
--   
setTableRowColRequisition :: MonadIO m => TableRowCol -> Word16 -> m ()

-- | Get the value of the “allocation” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get tableRowCol #allocation
--   
getTableRowColAllocation :: MonadIO m => TableRowCol -> m Word16

-- | Set the value of the “allocation” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set tableRowCol [ #allocation := value ]
--   
setTableRowColAllocation :: MonadIO m => TableRowCol -> Word16 -> m ()

-- | Get the value of the “spacing” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get tableRowCol #spacing
--   
getTableRowColSpacing :: MonadIO m => TableRowCol -> m Word16

-- | Set the value of the “spacing” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set tableRowCol [ #spacing := value ]
--   
setTableRowColSpacing :: MonadIO m => TableRowCol -> Word16 -> m ()

-- | Get the value of the “need_expand” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get tableRowCol #needExpand
--   
getTableRowColNeedExpand :: MonadIO m => TableRowCol -> m Word32

-- | Set the value of the “need_expand” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set tableRowCol [ #needExpand := value ]
--   
setTableRowColNeedExpand :: MonadIO m => TableRowCol -> Word32 -> m ()

-- | Get the value of the “need_shrink” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get tableRowCol #needShrink
--   
getTableRowColNeedShrink :: MonadIO m => TableRowCol -> m Word32

-- | Set the value of the “need_shrink” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set tableRowCol [ #needShrink := value ]
--   
setTableRowColNeedShrink :: MonadIO m => TableRowCol -> Word32 -> m ()

-- | Get the value of the “expand” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get tableRowCol #expand
--   
getTableRowColExpand :: MonadIO m => TableRowCol -> m Word32

-- | Set the value of the “expand” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set tableRowCol [ #expand := value ]
--   
setTableRowColExpand :: MonadIO m => TableRowCol -> Word32 -> m ()

-- | Get the value of the “shrink” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get tableRowCol #shrink
--   
getTableRowColShrink :: MonadIO m => TableRowCol -> m Word32

-- | Set the value of the “shrink” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set tableRowCol [ #shrink := value ]
--   
setTableRowColShrink :: MonadIO m => TableRowCol -> Word32 -> m ()

-- | Get the value of the “empty” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get tableRowCol #empty
--   
getTableRowColEmpty :: MonadIO m => TableRowCol -> m Word32

-- | Set the value of the “empty” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set tableRowCol [ #empty := value ]
--   
setTableRowColEmpty :: MonadIO m => TableRowCol -> Word32 -> m ()

-- | Construct a TargetEntry struct initialized to zero.
newZeroTargetEntry :: MonadIO m => m TargetEntry

-- | Get the value of the “target” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get targetEntry #target
--   
getTargetEntryTarget :: MonadIO m => TargetEntry -> m (Maybe Text)

-- | Set the value of the “target” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set targetEntry [ #target := value ]
--   
setTargetEntryTarget :: MonadIO m => TargetEntry -> CString -> m ()

-- | Set the value of the “target” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #target
--   
clearTargetEntryTarget :: MonadIO m => TargetEntry -> m ()

-- | Get the value of the “flags” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get targetEntry #flags
--   
getTargetEntryFlags :: MonadIO m => TargetEntry -> m Word32

-- | Set the value of the “flags” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set targetEntry [ #flags := value ]
--   
setTargetEntryFlags :: MonadIO m => TargetEntry -> Word32 -> m ()

-- | Get the value of the “info” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get targetEntry #info
--   
getTargetEntryInfo :: MonadIO m => TargetEntry -> m Word32

-- | Set the value of the “info” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set targetEntry [ #info := value ]
--   
setTargetEntryInfo :: MonadIO m => TargetEntry -> Word32 -> m ()

-- | Memory-managed wrapper type.
newtype TargetPair
TargetPair :: ManagedPtr TargetPair -> TargetPair

-- | Construct a TargetPair struct initialized to zero.
newZeroTargetPair :: MonadIO m => m TargetPair

-- | Get the value of the “target” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get targetPair #target
--   
getTargetPairTarget :: MonadIO m => TargetPair -> m Atom

-- | Get the value of the “flags” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get targetPair #flags
--   
getTargetPairFlags :: MonadIO m => TargetPair -> m Word32

-- | Set the value of the “flags” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set targetPair [ #flags := value ]
--   
setTargetPairFlags :: MonadIO m => TargetPair -> Word32 -> m ()

-- | Get the value of the “info” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get targetPair #info
--   
getTargetPairInfo :: MonadIO m => TargetPair -> m Word32

-- | Set the value of the “info” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set targetPair [ #info := value ]
--   
setTargetPairInfo :: MonadIO m => TargetPair -> Word32 -> m ()

-- | Memory-managed wrapper type.
newtype TextAppearance
TextAppearance :: ManagedPtr TextAppearance -> TextAppearance

-- | Construct a TextAppearance struct initialized to zero.
newZeroTextAppearance :: MonadIO m => m TextAppearance

-- | Get the value of the “bg_color” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAppearance #bgColor
--   
getTextAppearanceBgColor :: MonadIO m => TextAppearance -> m Color

-- | Get the value of the “fg_color” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAppearance #fgColor
--   
getTextAppearanceFgColor :: MonadIO m => TextAppearance -> m Color

-- | Get the value of the “rise” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get textAppearance #rise
--   
getTextAppearanceRise :: MonadIO m => TextAppearance -> m Int32

-- | Set the value of the “rise” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set textAppearance [ #rise := value ]
--   
setTextAppearanceRise :: MonadIO m => TextAppearance -> Int32 -> m ()

-- | Get the value of the “underline” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAppearance #underline
--   
getTextAppearanceUnderline :: MonadIO m => TextAppearance -> m Word32

-- | Set the value of the “underline” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAppearance [ #underline := value ]
--   
setTextAppearanceUnderline :: MonadIO m => TextAppearance -> Word32 -> m ()

-- | Get the value of the “strikethrough” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAppearance #strikethrough
--   
getTextAppearanceStrikethrough :: MonadIO m => TextAppearance -> m Word32

-- | Set the value of the “strikethrough” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAppearance [ #strikethrough := value ]
--   
setTextAppearanceStrikethrough :: MonadIO m => TextAppearance -> Word32 -> m ()

-- | Get the value of the “draw_bg” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get textAppearance #drawBg
--   
getTextAppearanceDrawBg :: MonadIO m => TextAppearance -> m Word32

-- | Set the value of the “draw_bg” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set textAppearance [ #drawBg := value ]
--   
setTextAppearanceDrawBg :: MonadIO m => TextAppearance -> Word32 -> m ()

-- | Get the value of the “inside_selection” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAppearance #insideSelection
--   
getTextAppearanceInsideSelection :: MonadIO m => TextAppearance -> m Word32

-- | Set the value of the “inside_selection” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAppearance [ #insideSelection := value ]
--   
setTextAppearanceInsideSelection :: MonadIO m => TextAppearance -> Word32 -> m ()

-- | Get the value of the “is_text” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get textAppearance #isText
--   
getTextAppearanceIsText :: MonadIO m => TextAppearance -> m Word32

-- | Set the value of the “is_text” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set textAppearance [ #isText := value ]
--   
setTextAppearanceIsText :: MonadIO m => TextAppearance -> Word32 -> m ()

-- | Construct a TextAttributes struct initialized to zero.
newZeroTextAttributes :: MonadIO m => m TextAttributes

-- | Get the value of the “appearance” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #appearance
--   
getTextAttributesAppearance :: MonadIO m => TextAttributes -> m TextAppearance

-- | Get the value of the “justification” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #justification
--   
getTextAttributesJustification :: MonadIO m => TextAttributes -> m Justification

-- | Set the value of the “justification” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #justification := value ]
--   
setTextAttributesJustification :: MonadIO m => TextAttributes -> Justification -> m ()

-- | Get the value of the “direction” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #direction
--   
getTextAttributesDirection :: MonadIO m => TextAttributes -> m TextDirection

-- | Set the value of the “direction” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #direction := value ]
--   
setTextAttributesDirection :: MonadIO m => TextAttributes -> TextDirection -> m ()

-- | Get the value of the “font” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get textAttributes #font
--   
getTextAttributesFont :: MonadIO m => TextAttributes -> m (Maybe FontDescription)

-- | Set the value of the “font” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set textAttributes [ #font := value ]
--   
setTextAttributesFont :: MonadIO m => TextAttributes -> Ptr FontDescription -> m ()

-- | Set the value of the “font” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #font
--   
clearTextAttributesFont :: MonadIO m => TextAttributes -> m ()

-- | Get the value of the “font_scale” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #fontScale
--   
getTextAttributesFontScale :: MonadIO m => TextAttributes -> m Double

-- | Set the value of the “font_scale” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #fontScale := value ]
--   
setTextAttributesFontScale :: MonadIO m => TextAttributes -> Double -> m ()

-- | Get the value of the “left_margin” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #leftMargin
--   
getTextAttributesLeftMargin :: MonadIO m => TextAttributes -> m Int32

-- | Set the value of the “left_margin” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #leftMargin := value ]
--   
setTextAttributesLeftMargin :: MonadIO m => TextAttributes -> Int32 -> m ()

-- | Get the value of the “right_margin” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #rightMargin
--   
getTextAttributesRightMargin :: MonadIO m => TextAttributes -> m Int32

-- | Set the value of the “right_margin” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #rightMargin := value ]
--   
setTextAttributesRightMargin :: MonadIO m => TextAttributes -> Int32 -> m ()

-- | Get the value of the “indent” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get textAttributes #indent
--   
getTextAttributesIndent :: MonadIO m => TextAttributes -> m Int32

-- | Set the value of the “indent” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #indent := value ]
--   
setTextAttributesIndent :: MonadIO m => TextAttributes -> Int32 -> m ()

-- | Get the value of the “pixels_above_lines” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #pixelsAboveLines
--   
getTextAttributesPixelsAboveLines :: MonadIO m => TextAttributes -> m Int32

-- | Set the value of the “pixels_above_lines” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #pixelsAboveLines := value ]
--   
setTextAttributesPixelsAboveLines :: MonadIO m => TextAttributes -> Int32 -> m ()

-- | Get the value of the “pixels_below_lines” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #pixelsBelowLines
--   
getTextAttributesPixelsBelowLines :: MonadIO m => TextAttributes -> m Int32

-- | Set the value of the “pixels_below_lines” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #pixelsBelowLines := value ]
--   
setTextAttributesPixelsBelowLines :: MonadIO m => TextAttributes -> Int32 -> m ()

-- | Get the value of the “pixels_inside_wrap” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #pixelsInsideWrap
--   
getTextAttributesPixelsInsideWrap :: MonadIO m => TextAttributes -> m Int32

-- | Set the value of the “pixels_inside_wrap” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #pixelsInsideWrap := value ]
--   
setTextAttributesPixelsInsideWrap :: MonadIO m => TextAttributes -> Int32 -> m ()

-- | Get the value of the “tabs” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get textAttributes #tabs
--   
getTextAttributesTabs :: MonadIO m => TextAttributes -> m (Maybe TabArray)

-- | Set the value of the “tabs” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set textAttributes [ #tabs := value ]
--   
setTextAttributesTabs :: MonadIO m => TextAttributes -> Ptr TabArray -> m ()

-- | Set the value of the “tabs” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #tabs
--   
clearTextAttributesTabs :: MonadIO m => TextAttributes -> m ()

-- | Get the value of the “wrap_mode” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #wrapMode
--   
getTextAttributesWrapMode :: MonadIO m => TextAttributes -> m WrapMode

-- | Set the value of the “wrap_mode” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #wrapMode := value ]
--   
setTextAttributesWrapMode :: MonadIO m => TextAttributes -> WrapMode -> m ()

-- | Get the value of the “language” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #language
--   
getTextAttributesLanguage :: MonadIO m => TextAttributes -> m (Maybe Language)

-- | Set the value of the “language” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #language := value ]
--   
setTextAttributesLanguage :: MonadIO m => TextAttributes -> Ptr Language -> m ()

-- | Set the value of the “language” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #language
--   
clearTextAttributesLanguage :: MonadIO m => TextAttributes -> m ()

-- | Get the value of the “invisible” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #invisible
--   
getTextAttributesInvisible :: MonadIO m => TextAttributes -> m Word32

-- | Set the value of the “invisible” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #invisible := value ]
--   
setTextAttributesInvisible :: MonadIO m => TextAttributes -> Word32 -> m ()

-- | Get the value of the “bg_full_height” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #bgFullHeight
--   
getTextAttributesBgFullHeight :: MonadIO m => TextAttributes -> m Word32

-- | Set the value of the “bg_full_height” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #bgFullHeight := value ]
--   
setTextAttributesBgFullHeight :: MonadIO m => TextAttributes -> Word32 -> m ()

-- | Get the value of the “editable” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #editable
--   
getTextAttributesEditable :: MonadIO m => TextAttributes -> m Word32

-- | Set the value of the “editable” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #editable := value ]
--   
setTextAttributesEditable :: MonadIO m => TextAttributes -> Word32 -> m ()

-- | Get the value of the “no_fallback” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #noFallback
--   
getTextAttributesNoFallback :: MonadIO m => TextAttributes -> m Word32

-- | Set the value of the “no_fallback” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #noFallback := value ]
--   
setTextAttributesNoFallback :: MonadIO m => TextAttributes -> Word32 -> m ()

-- | Get the value of the “letter_spacing” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textAttributes #letterSpacing
--   
getTextAttributesLetterSpacing :: MonadIO m => TextAttributes -> m Int32

-- | Set the value of the “letter_spacing” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textAttributes [ #letterSpacing := value ]
--   
setTextAttributesLetterSpacing :: MonadIO m => TextAttributes -> Int32 -> m ()

-- | Creates a TextAttributes, which describes a set of properties
--   on some text.
textAttributesNew :: (HasCallStack, MonadIO m) => m TextAttributes

-- | Copies src and returns a new TextAttributes.
textAttributesCopy :: (HasCallStack, MonadIO m) => TextAttributes -> m TextAttributes

-- | Copies the values from src to dest so
--   that dest has the same values as src.
--   Frees existing values in dest.
textAttributesCopyValues :: (HasCallStack, MonadIO m) => TextAttributes -> TextAttributes -> m ()

-- | Increments the reference count on values.
textAttributesRef :: (HasCallStack, MonadIO m) => TextAttributes -> m TextAttributes

-- | 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

-- | Construct a ToggleActionEntry struct initialized to zero.
newZeroToggleActionEntry :: MonadIO m => m ToggleActionEntry

-- | Get the value of the “name” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get toggleActionEntry #name
--   
getToggleActionEntryName :: MonadIO m => ToggleActionEntry -> m (Maybe Text)

-- | Set the value of the “name” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set toggleActionEntry [ #name := value ]
--   
setToggleActionEntryName :: MonadIO m => ToggleActionEntry -> CString -> m ()

-- | Set the value of the “name” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #name
--   
clearToggleActionEntryName :: MonadIO m => ToggleActionEntry -> m ()

-- | Get the value of the “stock_id” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toggleActionEntry #stockId
--   
getToggleActionEntryStockId :: MonadIO m => ToggleActionEntry -> m (Maybe Text)

-- | Set the value of the “stock_id” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toggleActionEntry [ #stockId := value ]
--   
setToggleActionEntryStockId :: MonadIO m => ToggleActionEntry -> CString -> m ()

-- | Set the value of the “stock_id” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #stockId
--   
clearToggleActionEntryStockId :: MonadIO m => ToggleActionEntry -> m ()

-- | Get the value of the “label” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get toggleActionEntry #label
--   
getToggleActionEntryLabel :: MonadIO m => ToggleActionEntry -> m (Maybe Text)

-- | Set the value of the “label” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set toggleActionEntry [ #label := value ]
--   
setToggleActionEntryLabel :: MonadIO m => ToggleActionEntry -> CString -> m ()

-- | Set the value of the “label” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #label
--   
clearToggleActionEntryLabel :: MonadIO m => ToggleActionEntry -> m ()

-- | Get the value of the “accelerator” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toggleActionEntry #accelerator
--   
getToggleActionEntryAccelerator :: MonadIO m => ToggleActionEntry -> m (Maybe Text)

-- | Set the value of the “accelerator” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toggleActionEntry [ #accelerator := value ]
--   
setToggleActionEntryAccelerator :: MonadIO m => ToggleActionEntry -> CString -> m ()

-- | Set the value of the “accelerator” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #accelerator
--   
clearToggleActionEntryAccelerator :: MonadIO m => ToggleActionEntry -> m ()

-- | Get the value of the “tooltip” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get toggleActionEntry #tooltip
--   
getToggleActionEntryTooltip :: MonadIO m => ToggleActionEntry -> m (Maybe Text)

-- | Set the value of the “tooltip” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set toggleActionEntry [ #tooltip := value ]
--   
setToggleActionEntryTooltip :: MonadIO m => ToggleActionEntry -> CString -> m ()

-- | Set the value of the “tooltip” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #tooltip
--   
clearToggleActionEntryTooltip :: MonadIO m => ToggleActionEntry -> m ()

-- | Get the value of the “callback” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toggleActionEntry #callback
--   
getToggleActionEntryCallback :: MonadIO m => ToggleActionEntry -> m (Maybe Callback)

-- | Set the value of the “callback” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toggleActionEntry [ #callback := value ]
--   
setToggleActionEntryCallback :: MonadIO m => ToggleActionEntry -> FunPtr C_Callback -> m ()

-- | Set the value of the “callback” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #callback
--   
clearToggleActionEntryCallback :: MonadIO m => ToggleActionEntry -> m ()

-- | Get the value of the “is_active” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toggleActionEntry #isActive
--   
getToggleActionEntryIsActive :: MonadIO m => ToggleActionEntry -> m Bool

-- | Set the value of the “is_active” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toggleActionEntry [ #isActive := value ]
--   
setToggleActionEntryIsActive :: MonadIO m => ToggleActionEntry -> Bool -> m ()

-- | Construct a TreeIter struct initialized to zero.
newZeroTreeIter :: MonadIO m => m TreeIter

-- | Get the value of the “stamp” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get treeIter #stamp
--   
getTreeIterStamp :: MonadIO m => TreeIter -> m Int32

-- | Set the value of the “stamp” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set treeIter [ #stamp := value ]
--   
setTreeIterStamp :: MonadIO m => TreeIter -> Int32 -> m ()

-- | Get the value of the “user_data” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeIter #userData
--   
getTreeIterUserData :: MonadIO m => TreeIter -> m (Ptr ())

-- | Set the value of the “user_data” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeIter [ #userData := value ]
--   
setTreeIterUserData :: MonadIO m => TreeIter -> Ptr () -> m ()

-- | Set the value of the “user_data” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #userData
--   
clearTreeIterUserData :: MonadIO m => TreeIter -> m ()

-- | Get the value of the “user_data2” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeIter #userData2
--   
getTreeIterUserData2 :: MonadIO m => TreeIter -> m (Ptr ())

-- | Set the value of the “user_data2” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeIter [ #userData2 := value ]
--   
setTreeIterUserData2 :: MonadIO m => TreeIter -> Ptr () -> m ()

-- | Set the value of the “user_data2” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #userData2
--   
clearTreeIterUserData2 :: MonadIO m => TreeIter -> m ()

-- | Get the value of the “user_data3” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeIter #userData3
--   
getTreeIterUserData3 :: MonadIO m => TreeIter -> m (Ptr ())

-- | Set the value of the “user_data3” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeIter [ #userData3 := value ]
--   
setTreeIterUserData3 :: MonadIO m => TreeIter -> Ptr () -> m ()

-- | Set the value of the “user_data3” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #userData3
--   
clearTreeIterUserData3 :: MonadIO m => TreeIter -> m ()

-- | Creates a new TreePath-struct. This refers to a row.
treePathNew :: (HasCallStack, MonadIO m) => m TreePath

-- | Creates a new TreePath-struct.
--   
--   The string representation of this path is “0”.
treePathNewFirst :: (HasCallStack, MonadIO m) => m TreePath

-- | Creates a new path with the given indices array of
--   length.
--   
--   Since: 3.12
treePathNewFromIndices :: (HasCallStack, MonadIO m) => [Int32] -> m TreePath

-- | Creates a new TreePath-struct initialized to
--   path.
--   
--   path 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, Nothing 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 a appears before b in a tree, then
--   -1 is returned. If b appears before a,
--   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 TreePath-struct as a copy of
--   path.
treePathCopy :: (HasCallStack, MonadIO m) => TreePath -> m TreePath

-- | Moves path to point to the first child of the current
--   path.
treePathDown :: (HasCallStack, MonadIO m) => TreePath -> m ()

-- | Returns the current depth of path.
treePathGetDepth :: (HasCallStack, MonadIO m) => TreePath -> m Int32

-- | Returns the current indices of path.
--   
--   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.
--   
--   Since: 3.0
treePathGetIndices :: (HasCallStack, MonadIO m) => TreePath -> m (Maybe [Int32])

-- | Returns True if descendant is a descendant of
--   path.
treePathIsAncestor :: (HasCallStack, MonadIO m) => TreePath -> TreePath -> m Bool

-- | Returns True if path is a descendant of
--   ancestor.
treePathIsDescendant :: (HasCallStack, MonadIO m) => TreePath -> TreePath -> m Bool

-- | Moves the path 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 path 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 path to point to its parent node, if it has
--   a parent.
treePathUp :: (HasCallStack, MonadIO m) => TreePath -> m Bool

-- | Type class for types which can be safely cast to Calendar, for
--   instance with toCalendar.
class (GObject o, IsDescendantOf Calendar o) => IsCalendar o

-- | Cast to Calendar, for types for which this is known to be safe.
--   For general casts, use castTo.
toCalendar :: (MonadIO m, IsCalendar o) => o -> m Calendar

-- | Type class for types which can be safely cast to FlowBox, for
--   instance with toFlowBox.
class (GObject o, IsDescendantOf FlowBox o) => IsFlowBox o

-- | Cast to FlowBox, for types for which this is known to be safe.
--   For general casts, use castTo.
toFlowBox :: (MonadIO m, IsFlowBox o) => o -> m FlowBox

-- | Type class for types which can be safely cast to FlowBoxChild,
--   for instance with toFlowBoxChild.
class (GObject o, IsDescendantOf FlowBoxChild o) => IsFlowBoxChild o

-- | Cast to FlowBoxChild, for types for which this is known to be
--   safe. For general casts, use castTo.
toFlowBoxChild :: (MonadIO m, IsFlowBoxChild o) => o -> m FlowBoxChild

-- | Type class for types which can be safely cast to IconView, for
--   instance with toIconView.
class (GObject o, IsDescendantOf IconView o) => IsIconView o

-- | Cast to IconView, for types for which this is known to be safe.
--   For general casts, use castTo.
toIconView :: (MonadIO m, IsIconView o) => o -> m IconView

-- | Type class for types which can be safely cast to ListBox, for
--   instance with toListBox.
class (GObject o, IsDescendantOf ListBox o) => IsListBox o

-- | Cast to ListBox, for types for which this is known to be safe.
--   For general casts, use castTo.
toListBox :: (MonadIO m, IsListBox o) => o -> m ListBox

-- | Type class for types which can be safely cast to ListBoxRow,
--   for instance with toListBoxRow.
class (GObject o, IsDescendantOf ListBoxRow o) => IsListBoxRow o

-- | Cast to ListBoxRow, for types for which this is known to be
--   safe. For general casts, use castTo.
toListBoxRow :: (MonadIO m, IsListBoxRow o) => o -> m ListBoxRow

-- | Type class for types which can be safely cast to Actionable,
--   for instance with toActionable.
class (GObject o, IsDescendantOf Actionable o) => IsActionable o

-- | Cast to Actionable, for types for which this is known to be
--   safe. For general casts, use castTo.
toActionable :: (MonadIO m, IsActionable o) => o -> m Actionable

-- | Type class for types which can be safely cast to Activatable,
--   for instance with toActivatable.
class (GObject o, IsDescendantOf Activatable o) => IsActivatable o

-- | Cast to Activatable, for types for which this is known to be
--   safe. For general casts, use castTo.
toActivatable :: (MonadIO m, IsActivatable o) => o -> m Activatable

-- | Type class for types which can be safely cast to Action, for
--   instance with toAction.
class (GObject o, IsDescendantOf Action o) => IsAction o

-- | Cast to Action, for types for which this is known to be safe.
--   For general casts, use castTo.
toAction :: (MonadIO m, IsAction o) => o -> m Action

-- | Type class for types which can be safely cast to ActionGroup,
--   for instance with toActionGroup.
class (GObject o, IsDescendantOf ActionGroup o) => IsActionGroup o

-- | Cast to ActionGroup, for types for which this is known to be
--   safe. For general casts, use castTo.
toActionGroup :: (MonadIO m, IsActionGroup o) => o -> m ActionGroup

-- | Type class for types which can be safely cast to Menu, for
--   instance with toMenu.
class (GObject o, IsDescendantOf Menu o) => IsMenu o

-- | Cast to Menu, for types for which this is known to be safe. For
--   general casts, use castTo.
toMenu :: (MonadIO m, IsMenu o) => o -> m Menu

-- | Type class for types which can be safely cast to MenuItem, for
--   instance with toMenuItem.
class (GObject o, IsDescendantOf MenuItem o) => IsMenuItem o

-- | Cast to MenuItem, for types for which this is known to be safe.
--   For general casts, use castTo.
toMenuItem :: (MonadIO m, IsMenuItem o) => o -> m MenuItem

-- | Type class for types which can be safely cast to MenuShell, for
--   instance with toMenuShell.
class (GObject o, IsDescendantOf MenuShell o) => IsMenuShell o

-- | Cast to MenuShell, for types for which this is known to be
--   safe. For general casts, use castTo.
toMenuShell :: (MonadIO m, IsMenuShell o) => o -> m MenuShell

-- | Type class for types which can be safely cast to Entry, for
--   instance with toEntry.
class (GObject o, IsDescendantOf Entry o) => IsEntry o

-- | Cast to Entry, for types for which this is known to be safe.
--   For general casts, use castTo.
toEntry :: (MonadIO m, IsEntry o) => o -> m Entry

-- | Type class for types which can be safely cast to
--   EntryCompletion, for instance with toEntryCompletion.
class (GObject o, IsDescendantOf EntryCompletion o) => IsEntryCompletion o

-- | Cast to EntryCompletion, for types for which this is known to
--   be safe. For general casts, use castTo.
toEntryCompletion :: (MonadIO m, IsEntryCompletion o) => o -> m EntryCompletion

-- | Type class for types which can be safely cast to TreeSelection,
--   for instance with toTreeSelection.
class (GObject o, IsDescendantOf TreeSelection o) => IsTreeSelection o

-- | Cast to TreeSelection, for types for which this is known to be
--   safe. For general casts, use castTo.
toTreeSelection :: (MonadIO m, IsTreeSelection o) => o -> m TreeSelection

-- | Type class for types which can be safely cast to TreeView, for
--   instance with toTreeView.
class (GObject o, IsDescendantOf TreeView o) => IsTreeView o

-- | Cast to TreeView, for types for which this is known to be safe.
--   For general casts, use castTo.
toTreeView :: (MonadIO m, IsTreeView o) => o -> m TreeView

-- | Type class for types which can be safely cast to CellLayout,
--   for instance with toCellLayout.
class (GObject o, IsDescendantOf CellLayout o) => IsCellLayout o

-- | Cast to CellLayout, for types for which this is known to be
--   safe. For general casts, use castTo.
toCellLayout :: (MonadIO m, IsCellLayout o) => o -> m CellLayout

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

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

-- | Type class for types which can be safely cast to CellArea, for
--   instance with toCellArea.
class (GObject o, IsDescendantOf CellArea o) => IsCellArea o

-- | Cast to CellArea, for types for which this is known to be safe.
--   For general casts, use castTo.
toCellArea :: (MonadIO m, IsCellArea o) => o -> m CellArea

-- | Type class for types which can be safely cast to
--   CellAreaContext, for instance with toCellAreaContext.
class (GObject o, IsDescendantOf CellAreaContext o) => IsCellAreaContext o

-- | Cast to CellAreaContext, for types for which this is known to
--   be safe. For general casts, use castTo.
toCellAreaContext :: (MonadIO m, IsCellAreaContext o) => o -> m CellAreaContext

-- | Type class for types which can be safely cast to CellEditable,
--   for instance with toCellEditable.
class (GObject o, IsDescendantOf CellEditable o) => IsCellEditable o

-- | Cast to CellEditable, for types for which this is known to be
--   safe. For general casts, use castTo.
toCellEditable :: (MonadIO m, IsCellEditable o) => o -> m CellEditable

-- | Type class for types which can be safely cast to Buildable, for
--   instance with toBuildable.
class (GObject o, IsDescendantOf Buildable o) => IsBuildable o

-- | Cast to Buildable, for types for which this is known to be
--   safe. For general casts, use castTo.
toBuildable :: (MonadIO m, IsBuildable o) => o -> m Buildable

-- | Type class for types which implement StyleProvider.
class (ManagedPtrNewtype o, IsDescendantOf StyleProvider o) => IsStyleProvider o

-- | Type class for types which can be safely cast to CellRenderer,
--   for instance with toCellRenderer.
class (GObject o, IsDescendantOf CellRenderer o) => IsCellRenderer o

-- | Cast to CellRenderer, for types for which this is known to be
--   safe. For general casts, use castTo.
toCellRenderer :: (MonadIO m, IsCellRenderer o) => o -> m CellRenderer

-- | Type class for types which can be safely cast to
--   TreeViewColumn, for instance with toTreeViewColumn.
class (GObject o, IsDescendantOf TreeViewColumn o) => IsTreeViewColumn o

-- | Cast to TreeViewColumn, for types for which this is known to be
--   safe. For general casts, use castTo.
toTreeViewColumn :: (MonadIO m, IsTreeViewColumn o) => o -> m TreeViewColumn

-- | Type class for types which can be safely cast to AccelGroup,
--   for instance with toAccelGroup.
class (GObject o, IsDescendantOf AccelGroup o) => IsAccelGroup o

-- | Cast to AccelGroup, for types for which this is known to be
--   safe. For general casts, use castTo.
toAccelGroup :: (MonadIO m, IsAccelGroup o) => o -> m AccelGroup

-- | Type class for types which can be safely cast to Application,
--   for instance with toApplication.
class (GObject o, IsDescendantOf Application o) => IsApplication o

-- | Cast to Application, for types for which this is known to be
--   safe. For general casts, use castTo.
toApplication :: (MonadIO m, IsApplication o) => o -> m Application

-- | Type class for types which can be safely cast to Bin, for
--   instance with toBin.
class (GObject o, IsDescendantOf Bin o) => IsBin o

-- | Cast to Bin, for types for which this is known to be safe. For
--   general casts, use castTo.
toBin :: (MonadIO m, IsBin o) => o -> m Bin

-- | Type class for types which can be safely cast to Builder, for
--   instance with toBuilder.
class (GObject o, IsDescendantOf Builder o) => IsBuilder o

-- | Cast to Builder, for types for which this is known to be safe.
--   For general casts, use castTo.
toBuilder :: (MonadIO m, IsBuilder o) => o -> m Builder

-- | Type class for types which can be safely cast to Clipboard, for
--   instance with toClipboard.
class (GObject o, IsDescendantOf Clipboard o) => IsClipboard o

-- | Cast to Clipboard, for types for which this is known to be
--   safe. For general casts, use castTo.
toClipboard :: (MonadIO m, IsClipboard o) => o -> m Clipboard

-- | Type class for types which can be safely cast to Container, for
--   instance with toContainer.
class (GObject o, IsDescendantOf Container o) => IsContainer o

-- | Cast to Container, for types for which this is known to be
--   safe. For general casts, use castTo.
toContainer :: (MonadIO m, IsContainer o) => o -> m Container

-- | Type class for types which can be safely cast to IconFactory,
--   for instance with toIconFactory.
class (GObject o, IsDescendantOf IconFactory o) => IsIconFactory o

-- | Cast to IconFactory, for types for which this is known to be
--   safe. For general casts, use castTo.
toIconFactory :: (MonadIO m, IsIconFactory o) => o -> m IconFactory

-- | Type class for types which can be safely cast to Settings, for
--   instance with toSettings.
class (GObject o, IsDescendantOf Settings o) => IsSettings o

-- | Cast to Settings, for types for which this is known to be safe.
--   For general casts, use castTo.
toSettings :: (MonadIO m, IsSettings o) => o -> m Settings

-- | Type class for types which can be safely cast to Style, for
--   instance with toStyle.
class (GObject o, IsDescendantOf Style o) => IsStyle o

-- | Cast to Style, for types for which this is known to be safe.
--   For general casts, use castTo.
toStyle :: (MonadIO m, IsStyle o) => o -> m Style

-- | Type class for types which can be safely cast to StyleContext,
--   for instance with toStyleContext.
class (GObject o, IsDescendantOf StyleContext o) => IsStyleContext o

-- | Cast to StyleContext, for types for which this is known to be
--   safe. For general casts, use castTo.
toStyleContext :: (MonadIO m, IsStyleContext o) => o -> m StyleContext

-- | Type class for types which can be safely cast to
--   StyleProperties, for instance with toStyleProperties.
class (GObject o, IsDescendantOf StyleProperties o) => IsStyleProperties o

-- | Cast to StyleProperties, for types for which this is known to
--   be safe. For general casts, use castTo.
toStyleProperties :: (MonadIO m, IsStyleProperties o) => o -> m StyleProperties

-- | Type class for types which can be safely cast to TextBuffer,
--   for instance with toTextBuffer.
class (GObject o, IsDescendantOf TextBuffer o) => IsTextBuffer o

-- | Cast to TextBuffer, for types for which this is known to be
--   safe. For general casts, use castTo.
toTextBuffer :: (MonadIO m, IsTextBuffer o) => o -> m TextBuffer

-- | Type class for types which can be safely cast to
--   TextChildAnchor, for instance with toTextChildAnchor.
class (GObject o, IsDescendantOf TextChildAnchor o) => IsTextChildAnchor o

-- | Cast to TextChildAnchor, for types for which this is known to
--   be safe. For general casts, use castTo.
toTextChildAnchor :: (MonadIO m, IsTextChildAnchor o) => o -> m TextChildAnchor

-- | Type class for types which can be safely cast to TextMark, for
--   instance with toTextMark.
class (GObject o, IsDescendantOf TextMark o) => IsTextMark o

-- | Cast to TextMark, for types for which this is known to be safe.
--   For general casts, use castTo.
toTextMark :: (MonadIO m, IsTextMark o) => o -> m TextMark

-- | Type class for types which can be safely cast to TextTag, for
--   instance with toTextTag.
class (GObject o, IsDescendantOf TextTag o) => IsTextTag o

-- | Cast to TextTag, for types for which this is known to be safe.
--   For general casts, use castTo.
toTextTag :: (MonadIO m, IsTextTag o) => o -> m TextTag

-- | Type class for types which can be safely cast to TextTagTable,
--   for instance with toTextTagTable.
class (GObject o, IsDescendantOf TextTagTable o) => IsTextTagTable o

-- | Cast to TextTagTable, for types for which this is known to be
--   safe. For general casts, use castTo.
toTextTagTable :: (MonadIO m, IsTextTagTable o) => o -> m TextTagTable

-- | Type class for types which can be safely cast to Tooltip, for
--   instance with toTooltip.
class (GObject o, IsDescendantOf Tooltip o) => IsTooltip o

-- | Cast to Tooltip, for types for which this is known to be safe.
--   For general casts, use castTo.
toTooltip :: (MonadIO m, IsTooltip o) => o -> m Tooltip

-- | Type class for types which can be safely cast to Widget, for
--   instance with toWidget.
class (GObject o, IsDescendantOf Widget o) => IsWidget o

-- | Cast to Widget, for types for which this is known to be safe.
--   For general casts, use castTo.
toWidget :: (MonadIO m, IsWidget o) => o -> m Widget

-- | Type class for types which can be safely cast to WindowGroup,
--   for instance with toWindowGroup.
class (GObject o, IsDescendantOf WindowGroup o) => IsWindowGroup o

-- | Cast to WindowGroup, for types for which this is known to be
--   safe. For general casts, use castTo.
toWindowGroup :: (MonadIO m, IsWindowGroup o) => o -> m WindowGroup

-- | Type for the callback on the (unwrapped) C side.
type C_AccelGroupActivate = Ptr AccelGroup -> Ptr Object -> Word32 -> CUInt -> IO CInt

-- | No description available in the introspection data.
--   
--   Since: 2.2
type AccelGroupFindFunc_WithClosures = AccelKey -> GClosure () -> Ptr () -> IO Bool

-- | No description available in the introspection data.
--   
--   Since: 2.2
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 ()

-- | No description available in the introspection data.
type ActionableInterfaceGetActionNameFieldCallback = Actionable -> IO Maybe Text

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

-- | No description available in the introspection data.
type ActionableInterfaceGetActionTargetValueFieldCallback = Actionable -> IO GVariant

-- | Type for the callback on the (unwrapped) C side.
type C_ActionableInterfaceGetActionTargetValueFieldCallback = Ptr Actionable -> IO Ptr GVariant

-- | No description available in the introspection data.
type ActionableInterfaceSetActionNameFieldCallback = Actionable -> Maybe Text -> IO ()

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

-- | No description available in the introspection data.
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 assistantSetForwardPageFunc 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 builderConnectSignals and
--   builderConnectSignalsFull 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.
--   
--   Since: 2.12
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 Nothing when no information
--   is available.
--   
--   Since: 2.14
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 Nothing when no information
--   is available.
--   
--   Since: 2.14
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 containerForeach.
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 CellArea, see
--   cellAreaForeachAlloc.
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 CellArea, see cellAreaForeach.
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 cellLayout’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
--   userDataOrOwner argument will not be used again.
type ClipboardClearFunc = Clipboard -> Ptr () -> 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 info parameter or by
--   checking the target field of selectionData. If the
--   data could successfully be converted into then it should be stored
--   into the selectionData object by calling
--   selectionDataSet (or related functions such as
--   selectionDataSetText). If no data is set, the requestor will be
--   informed that the attempt to get the data failed.
type ClipboardGetFunc = Clipboard -> SelectionData -> Word32 -> Ptr () -> 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
--   clipboardRequestImage are received, or when the request fails.
--   
--   Since: 2.6
type ClipboardImageReceivedFunc_WithClosures = Clipboard -> Maybe Pixbuf -> Ptr () -> IO ()

-- | A function to be called when the results of
--   clipboardRequestImage are received, or when the request fails.
--   
--   Since: 2.6
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
--   clipboardRequestContents are received, or when the request
--   fails.
type ClipboardReceivedFunc_WithClosures = Clipboard -> SelectionData -> Ptr () -> IO ()

-- | A function to be called when the results of
--   clipboardRequestContents 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
--   clipboardRequestRichText are received, or when the request
--   fails.
--   
--   Since: 2.10
type ClipboardRichTextReceivedFunc_WithClosures = Clipboard -> Atom -> Maybe Text -> CSize -> Ptr () -> IO ()

-- | A function to be called when the results of
--   clipboardRequestRichText are received, or when the request
--   fails.
--   
--   Since: 2.10
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
--   clipboardRequestTargets are received, or when the request
--   fails.
--   
--   Since: 2.4
type ClipboardTargetsReceivedFunc_WithClosures = Clipboard -> Maybe [Atom] -> Ptr () -> IO ()

-- | A function to be called when the results of
--   clipboardRequestTargets are received, or when the request
--   fails.
--   
--   Since: 2.4
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
--   clipboardRequestText are received, or when the request fails.
type ClipboardTextReceivedFunc_WithClosures = Clipboard -> Maybe Text -> Ptr () -> IO ()

-- | A function to be called when the results of
--   clipboardRequestText 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
--   clipboardRequestUris are received, or when the request fails.
--   
--   Since: 2.14
type ClipboardURIReceivedFunc_WithClosures = Clipboard -> [Text] -> Ptr () -> IO ()

-- | A function to be called when the results of
--   clipboardRequestUris are received, or when the request fails.
--   
--   Since: 2.14
type ClipboardURIReceivedFunc = Clipboard -> [Text] -> IO ()

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

-- | No description available in the introspection data.
type ColorSelectionChangePaletteFunc = [Color] -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ColorSelectionChangePaletteFunc = Ptr Color -> Int32 -> IO ()

-- | No description available in the introspection data.
--   
--   Since: 2.2
type ColorSelectionChangePaletteWithScreenFunc = Screen -> [Color] -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ColorSelectionChangePaletteWithScreenFunc = Ptr Screen -> Ptr Color -> Int32 -> IO ()

-- | No description available in the introspection data.
type ContainerClassAddFieldCallback = Container -> Widget -> IO ()

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

-- | No description available in the introspection data.
type ContainerClassCheckResizeFieldCallback = Container -> IO ()

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

-- | No description available in the introspection data.
type ContainerClassChildTypeFieldCallback = Container -> IO GType

-- | Type for the callback on the (unwrapped) C side.
type C_ContainerClassChildTypeFieldCallback = Ptr Container -> IO CGType

-- | No description available in the introspection data.
type ContainerClassCompositeNameFieldCallback = Container -> Widget -> IO Text

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

-- | No description available in the introspection data.
type ContainerClassForallFieldCallback_WithClosures = Container -> Bool -> Callback_WithClosures -> Ptr () -> IO ()

-- | No description available in the introspection data.
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 ()

-- | No description available in the introspection data.
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 ()

-- | No description available in the introspection data.
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

-- | No description available in the introspection data.
type ContainerClassRemoveFieldCallback = Container -> Widget -> IO ()

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

-- | No description available in the introspection data.
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 ()

-- | No description available in the introspection data.
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
--   iter matches a given key, and should
--   be displayed as a possible completion for key. Note
--   that key is normalized and case-folded (see
--   utf8Normalize and utf8Casefold). If this is not
--   appropriate, match functions have access to the unmodified key via
--   gtk_entry_get_text (GTK_ENTRY (gtk_entry_completion_get_entry
--   ())).
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
--   fileFilterAddCustom.
type FileFilterFunc_WithClosures = FileFilterInfo -> Ptr () -> IO Bool

-- | The type of function that is used with custom filters, see
--   fileFilterAddCustom.
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 ListModel with
--   flowBoxBindModel for each item that gets added to the model.
--   
--   Since: 3.18
type FlowBoxCreateWidgetFunc_WithClosures = Maybe Object -> Ptr () -> IO Widget

-- | Called for flow boxes that are bound to a ListModel with
--   flowBoxBindModel for each item that gets added to the model.
--   
--   Since: 3.18
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.
--   
--   Since: 3.12
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.
--   
--   Since: 3.12
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 flowBoxSelectedForeach. It will be called on
--   every selected child of the box.
--   
--   Since: 3.12
type FlowBoxForeachFunc_WithClosures = FlowBox -> FlowBoxChild -> Ptr () -> IO ()

-- | A function used by flowBoxSelectedForeach. It will be called on
--   every selected child of the box.
--   
--   Since: 3.12
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.
--   
--   Since: 3.12
type FlowBoxSortFunc_WithClosures = FlowBoxChild -> FlowBoxChild -> Ptr () -> IO Int32

-- | A function to compare two children to determine which should come
--   first.
--   
--   Since: 3.12
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 FontChooser. See fontChooserSetFilterFunc.
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 iconViewSelectedForeach 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 iconViewSelectedForeach 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 ListModel with
--   listBoxBindModel for each item that gets added to the model.
--   
--   Versions of GTK+ prior to 3.18 called widgetShowAll 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.
--   
--   Since: 3.16
type ListBoxCreateWidgetFunc_WithClosures = Object -> Ptr () -> IO Widget

-- | Called for list boxes that are bound to a ListModel with
--   listBoxBindModel for each item that gets added to the model.
--   
--   Versions of GTK+ prior to 3.18 called widgetShowAll 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.
--   
--   Since: 3.16
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.
--   
--   Since: 3.10
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.
--   
--   Since: 3.10
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 listBoxSelectedForeach. It will be called on
--   every selected child of the box.
--   
--   Since: 3.14
type ListBoxForeachFunc_WithClosures = ListBox -> ListBoxRow -> Ptr () -> IO ()

-- | A function used by listBoxSelectedForeach. It will be called on
--   every selected child of the box.
--   
--   Since: 3.14
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.
--   
--   Since: 3.10
type ListBoxSortFunc_WithClosures = ListBoxRow -> ListBoxRow -> Ptr () -> IO Int32

-- | Compare two rows to determine which should be first.
--   
--   Since: 3.10
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 row changes or which row is before
--   row changes this is called, which lets you update the
--   header on row. You may remove or set a new one via
--   listBoxRowSetHeader or just change the state of the current
--   header widget.
--   
--   Since: 3.10
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 menuAttachToWidget 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 menuPopup which controls
--   the positioning of the menu when it is displayed. The function sets
--   the x and y parameters to the
--   coordinates where the menu is to be drawn. To make the menu appear on
--   a different monitor than the mouse pointer, menuSetMonitor 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
--   gtk_module_display_init() function with this
--   prototype. GTK+ calls this function for each opened display.
--   
--   Since: 2.2
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
--   gtk_module_init() 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
--   printRunPageSetupDialogAsync.
--   
--   This function will be called when the page setup dialog is dismissed,
--   and also serves as destroy notify for data.
type PageSetupDoneFunc_WithClosures = PageSetup -> Ptr () -> IO ()

-- | The type of function that is passed to
--   printRunPageSetupDialogAsync.
--   
--   This function will be called when the page setup dialog is dismissed,
--   and also serves as destroy notify for data.
type PageSetupDoneFunc = PageSetup -> IO ()

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

-- | No description available in the introspection data.
type PrintSettingsFunc_WithClosures = Text -> Text -> Ptr () -> IO ()

-- | No description available in the introspection data.
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
--   recentFilterAddCustom.
type RecentFilterFunc_WithClosures = RecentFilterInfo -> Ptr () -> IO Bool

-- | The type of function that is used with custom filters, see
--   recentFilterAddCustom.
type RecentFilterFunc = RecentFilterInfo -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_RecentFilterFunc = Ptr RecentFilterInfo -> Ptr () -> IO CInt

-- | No description available in the introspection data.
type RecentSortFunc_WithClosures = RecentInfo -> RecentInfo -> Ptr () -> IO Int32

-- | No description available in the introspection data.
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

-- | No description available in the introspection data.
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 textBufferSerialize, and insert it at
--   iter.
type TextBufferDeserializeFunc_WithClosures = TextBuffer -> TextBuffer -> TextIter -> ByteString -> Bool -> Ptr () -> IO ()

-- | A function that is called to deserialize rich text that has been
--   serialized with textBufferSerialize, and insert it at
--   iter.
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

-- | No description available in the introspection data.
type TextCharPredicate_WithClosures = Char -> Ptr () -> IO Bool

-- | No description available in the introspection data.
type TextCharPredicate = Char -> IO Bool

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

-- | No description available in the introspection data.
type TextTagTableForeach_WithClosures = TextTag -> Ptr () -> IO ()

-- | No description available in the introspection data.
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
--   widgetAddTickCallback.
--   
--   Since: 3.8
type TickCallback_WithClosures = Widget -> FrameClock -> Ptr () -> IO Bool

-- | Callback type for adding a function to update animations. See
--   widgetAddTickCallback.
--   
--   Since: 3.8
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

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

-- | 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 treeModel, and render it to the
--   “text” attribute of “cell” by converting it to its written equivalent.
--   This is set by calling treeViewColumnSetCellDataFunc
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 ()

-- | No description available in the introspection data.
type TreeDestroyCountFunc_WithClosures = TreeView -> TreePath -> Int32 -> Ptr () -> IO ()

-- | No description available in the introspection data.
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 a sorts before b,
--   a sorts with b, or a
--   sorts after b respectively. If two iters compare as
--   equal, their order in the sorted model is undefined. In order to
--   ensure that the TreeSortable 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 model is a product catalogue, then a
--   compare function for the “price” column could be one which returns
--   price_of(@a) - price_of(@b).
type TreeIterCompareFunc_WithClosures = TreeModel -> TreeIter -> TreeIter -> Ptr () -> IO Int32

-- | A GtkTreeIterCompareFunc should return a negative integer, zero, or a
--   positive integer if a sorts before b,
--   a sorts with b, or a
--   sorts after b respectively. If two iters compare as
--   equal, their order in the sorted model is undefined. In order to
--   ensure that the TreeSortable 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 model is a product catalogue, then a
--   compare function for the “price” column could be one which returns
--   price_of(@a) - price_of(@b).
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 value with the display value for
--   the column column in the row indicated by
--   iter.
--   
--   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 value with the display value for
--   the column column in the row indicated by
--   iter.
--   
--   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
--   iter 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 treeModelForeach to iterate over
--   the rows in a tree model.
type TreeModelForeachFunc_WithClosures = TreeModel -> TreePath -> TreeIter -> Ptr () -> IO Bool

-- | Type of the callback passed to treeModelForeach 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 treeSelectionSelectedForeach 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 treeSelectionSelectedForeach 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 treeSelectionSetSelectFunction to filter
--   whether or not a row may be selected. It is called whenever a row's
--   state might change. A return value of True indicates to
--   selection that it is okay to change the selection.
type TreeSelectionFunc_WithClosures = TreeSelection -> TreeModel -> TreePath -> Bool -> Ptr () -> IO Bool

-- | A function used by treeSelectionSetSelectFunction to filter
--   whether or not a row may be selected. It is called whenever a row's
--   state might change. A return value of True indicates to
--   selection 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 column can be
--   dropped in a particular spot (as determined by
--   prevColumn and nextColumn). In left to
--   right locales, prevColumn is on the left of the
--   potential drop spot, and nextColumn is on the right.
--   In right to left mode, this is reversed. This function should return
--   True if the spot is a valid drop spot. Please note that
--   returning True 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 column can be
--   dropped in a particular spot (as determined by
--   prevColumn and nextColumn). In left to
--   right locales, prevColumn is on the left of the
--   potential drop spot, and nextColumn is on the right.
--   In right to left mode, this is reversed. This function should return
--   True if the spot is a valid drop spot. Please note that
--   returning True 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 treeViewMapExpandedRows.
type TreeViewMappingFunc_WithClosures = TreeView -> TreePath -> Ptr () -> IO ()

-- | Function used for treeViewMapExpandedRows.
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
--   iter should be rendered as a separator. A common way
--   to implement this is to have a boolean column in the model, whose
--   values the TreeViewRowSeparatorFunc 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 model
--   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 strcmp() 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

-- | No description available in the introspection data.
type TreeViewSearchPositionFunc_WithClosures = TreeView -> Widget -> Ptr () -> IO ()

-- | No description available in the introspection data.
type TreeViewSearchPositionFunc = TreeView -> Widget -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassAdjustBaselineAllocationFieldCallback = Widget -> Int32 -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassAdjustBaselineRequestFieldCallback = Widget -> Int32 -> Int32 -> IO ()

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

-- | No description available in the introspection data.
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 ()

-- | No description available in the introspection data.
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 ()

-- | No description available in the introspection data.
type WidgetClassButtonPressEventFieldCallback = Widget -> EventButton -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassButtonReleaseEventFieldCallback = Widget -> EventButton -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassCanActivateAccelFieldCallback = Widget -> Word32 -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassChildNotifyFieldCallback = Widget -> GParamSpec -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassCompositedChangedFieldCallback = Widget -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassComputeExpandFieldCallback = Widget -> Bool -> Bool -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassConfigureEventFieldCallback = Widget -> EventConfigure -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassDamageEventFieldCallback = Widget -> EventExpose -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassDeleteEventFieldCallback = Widget -> EventAny -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassDestroyEventFieldCallback = Widget -> EventAny -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassDestroyFieldCallback = Widget -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassDirectionChangedFieldCallback = Widget -> TextDirection -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassDispatchChildPropertiesChangedFieldCallback = Widget -> Word32 -> GParamSpec -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassDragBeginFieldCallback = Widget -> DragContext -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassDragDataDeleteFieldCallback = Widget -> DragContext -> IO ()

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

-- | No description available in the introspection data.
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 ()

-- | No description available in the introspection data.
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 ()

-- | No description available in the introspection data.
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

-- | No description available in the introspection data.
type WidgetClassDragEndFieldCallback = Widget -> DragContext -> IO ()

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

-- | No description available in the introspection data.
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

-- | No description available in the introspection data.
type WidgetClassDragLeaveFieldCallback = Widget -> DragContext -> Word32 -> IO ()

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

-- | No description available in the introspection data.
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

-- | No description available in the introspection data.
type WidgetClassDrawFieldCallback = Widget -> Context -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassEnterNotifyEventFieldCallback = Widget -> EventCrossing -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassEventFieldCallback = Widget -> Event -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassFocusFieldCallback = Widget -> DirectionType -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassFocusInEventFieldCallback = Widget -> EventFocus -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassFocusOutEventFieldCallback = Widget -> EventFocus -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassGetAccessibleFieldCallback = Widget -> IO Object

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

-- | No description available in the introspection data.
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 ()

-- | No description available in the introspection data.
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 ()

-- | No description available in the introspection data.
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 ()

-- | No description available in the introspection data.
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 ()

-- | No description available in the introspection data.
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 ()

-- | No description available in the introspection data.
type WidgetClassGetRequestModeFieldCallback = Widget -> IO SizeRequestMode

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

-- | No description available in the introspection data.
type WidgetClassGrabBrokenEventFieldCallback = Widget -> EventGrabBroken -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassGrabFocusFieldCallback = Widget -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassGrabNotifyFieldCallback = Widget -> Bool -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassHideFieldCallback = Widget -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassHierarchyChangedFieldCallback = Widget -> Widget -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassKeyPressEventFieldCallback = Widget -> EventKey -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassKeyReleaseEventFieldCallback = Widget -> EventKey -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassKeynavFailedFieldCallback = Widget -> DirectionType -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassLeaveNotifyEventFieldCallback = Widget -> EventCrossing -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassMapEventFieldCallback = Widget -> EventAny -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassMapFieldCallback = Widget -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassMnemonicActivateFieldCallback = Widget -> Bool -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassMotionNotifyEventFieldCallback = Widget -> EventMotion -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassMoveFocusFieldCallback = Widget -> DirectionType -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassParentSetFieldCallback = Widget -> Widget -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassPopupMenuFieldCallback = Widget -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassPropertyNotifyEventFieldCallback = Widget -> EventProperty -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassProximityInEventFieldCallback = Widget -> EventProximity -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassProximityOutEventFieldCallback = Widget -> EventProximity -> IO Bool

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

-- | No description available in the introspection data.
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

-- | No description available in the introspection data.
type WidgetClassQueueDrawRegionFieldCallback = Widget -> Region -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassRealizeFieldCallback = Widget -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassScreenChangedFieldCallback = Widget -> Screen -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassScrollEventFieldCallback = Widget -> EventScroll -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassSelectionClearEventFieldCallback = Widget -> EventSelection -> IO Bool

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

-- | No description available in the introspection data.
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 ()

-- | No description available in the introspection data.
type WidgetClassSelectionNotifyEventFieldCallback = Widget -> EventSelection -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassSelectionReceivedFieldCallback = Widget -> SelectionData -> Word32 -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassSelectionRequestEventFieldCallback = Widget -> EventSelection -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassShowAllFieldCallback = Widget -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassShowFieldCallback = Widget -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassShowHelpFieldCallback = Widget -> WidgetHelpType -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassSizeAllocateFieldCallback = Widget -> Rectangle -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassStateChangedFieldCallback = Widget -> StateType -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassStateFlagsChangedFieldCallback = Widget -> [StateFlags] -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassStyleSetFieldCallback = Widget -> Style -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassStyleUpdatedFieldCallback = Widget -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassTouchEventFieldCallback = Widget -> EventTouch -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassUnmapEventFieldCallback = Widget -> EventAny -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassUnmapFieldCallback = Widget -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassUnrealizeFieldCallback = Widget -> IO ()

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

-- | No description available in the introspection data.
type WidgetClassVisibilityNotifyEventFieldCallback = Widget -> EventVisibility -> IO Bool

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

-- | No description available in the introspection data.
type WidgetClassWindowStateEventFieldCallback = Widget -> EventWindowState -> IO Bool

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

-- | Generate a function pointer callable from C code, from a
--   C_AccelGroupActivate.
mk_AccelGroupActivate :: C_AccelGroupActivate -> IO (FunPtr C_AccelGroupActivate)

-- | Generate a function pointer callable from C code, from a
--   C_AccelGroupFindFunc.
mk_AccelGroupFindFunc :: C_AccelGroupFindFunc -> IO (FunPtr C_AccelGroupFindFunc)

-- | Generate a function pointer callable from C code, from a
--   C_AccelMapForeach.
mk_AccelMapForeach :: C_AccelMapForeach -> IO (FunPtr C_AccelMapForeach)

-- | Generate a function pointer callable from C code, from a
--   C_ActionableInterfaceGetActionNameFieldCallback.
mk_ActionableInterfaceGetActionNameFieldCallback :: C_ActionableInterfaceGetActionNameFieldCallback -> IO (FunPtr C_ActionableInterfaceGetActionNameFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_ActionableInterfaceGetActionTargetValueFieldCallback.
mk_ActionableInterfaceGetActionTargetValueFieldCallback :: C_ActionableInterfaceGetActionTargetValueFieldCallback -> IO (FunPtr C_ActionableInterfaceGetActionTargetValueFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_ActionableInterfaceSetActionNameFieldCallback.
mk_ActionableInterfaceSetActionNameFieldCallback :: C_ActionableInterfaceSetActionNameFieldCallback -> IO (FunPtr C_ActionableInterfaceSetActionNameFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_ActionableInterfaceSetActionTargetValueFieldCallback.
mk_ActionableInterfaceSetActionTargetValueFieldCallback :: C_ActionableInterfaceSetActionTargetValueFieldCallback -> IO (FunPtr C_ActionableInterfaceSetActionTargetValueFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_AssistantPageFunc.
mk_AssistantPageFunc :: C_AssistantPageFunc -> IO (FunPtr C_AssistantPageFunc)

-- | Generate a function pointer callable from C code, from a
--   C_BuilderConnectFunc.
mk_BuilderConnectFunc :: C_BuilderConnectFunc -> IO (FunPtr C_BuilderConnectFunc)

-- | Generate a function pointer callable from C code, from a
--   C_CalendarDetailFunc.
mk_CalendarDetailFunc :: C_CalendarDetailFunc -> IO (FunPtr C_CalendarDetailFunc)

-- | Generate a function pointer callable from C code, from a
--   C_CellAllocCallback.
mk_CellAllocCallback :: C_CellAllocCallback -> IO (FunPtr C_CellAllocCallback)

-- | Generate a function pointer callable from C code, from a
--   C_CellCallback.
mk_CellCallback :: C_CellCallback -> IO (FunPtr C_CellCallback)

-- | Generate a function pointer callable from C code, from a
--   C_CellLayoutDataFunc.
mk_CellLayoutDataFunc :: C_CellLayoutDataFunc -> IO (FunPtr C_CellLayoutDataFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ClipboardClearFunc.
mk_ClipboardClearFunc :: C_ClipboardClearFunc -> IO (FunPtr C_ClipboardClearFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ClipboardGetFunc.
mk_ClipboardGetFunc :: C_ClipboardGetFunc -> IO (FunPtr C_ClipboardGetFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ClipboardImageReceivedFunc.
mk_ClipboardImageReceivedFunc :: C_ClipboardImageReceivedFunc -> IO (FunPtr C_ClipboardImageReceivedFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ClipboardReceivedFunc.
mk_ClipboardReceivedFunc :: C_ClipboardReceivedFunc -> IO (FunPtr C_ClipboardReceivedFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ClipboardRichTextReceivedFunc.
mk_ClipboardRichTextReceivedFunc :: C_ClipboardRichTextReceivedFunc -> IO (FunPtr C_ClipboardRichTextReceivedFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ClipboardTargetsReceivedFunc.
mk_ClipboardTargetsReceivedFunc :: C_ClipboardTargetsReceivedFunc -> IO (FunPtr C_ClipboardTargetsReceivedFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ClipboardTextReceivedFunc.
mk_ClipboardTextReceivedFunc :: C_ClipboardTextReceivedFunc -> IO (FunPtr C_ClipboardTextReceivedFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ClipboardURIReceivedFunc.
mk_ClipboardURIReceivedFunc :: C_ClipboardURIReceivedFunc -> IO (FunPtr C_ClipboardURIReceivedFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ColorSelectionChangePaletteFunc.
mk_ColorSelectionChangePaletteFunc :: C_ColorSelectionChangePaletteFunc -> IO (FunPtr C_ColorSelectionChangePaletteFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ColorSelectionChangePaletteWithScreenFunc.
mk_ColorSelectionChangePaletteWithScreenFunc :: C_ColorSelectionChangePaletteWithScreenFunc -> IO (FunPtr C_ColorSelectionChangePaletteWithScreenFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ContainerClassAddFieldCallback.
mk_ContainerClassAddFieldCallback :: C_ContainerClassAddFieldCallback -> IO (FunPtr C_ContainerClassAddFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_ContainerClassCheckResizeFieldCallback.
mk_ContainerClassCheckResizeFieldCallback :: C_ContainerClassCheckResizeFieldCallback -> IO (FunPtr C_ContainerClassCheckResizeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_ContainerClassChildTypeFieldCallback.
mk_ContainerClassChildTypeFieldCallback :: C_ContainerClassChildTypeFieldCallback -> IO (FunPtr C_ContainerClassChildTypeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_ContainerClassCompositeNameFieldCallback.
mk_ContainerClassCompositeNameFieldCallback :: C_ContainerClassCompositeNameFieldCallback -> IO (FunPtr C_ContainerClassCompositeNameFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_ContainerClassForallFieldCallback.
mk_ContainerClassForallFieldCallback :: C_ContainerClassForallFieldCallback -> IO (FunPtr C_ContainerClassForallFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_ContainerClassGetChildPropertyFieldCallback.
mk_ContainerClassGetChildPropertyFieldCallback :: C_ContainerClassGetChildPropertyFieldCallback -> IO (FunPtr C_ContainerClassGetChildPropertyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_ContainerClassGetPathForChildFieldCallback.
mk_ContainerClassGetPathForChildFieldCallback :: C_ContainerClassGetPathForChildFieldCallback -> IO (FunPtr C_ContainerClassGetPathForChildFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_ContainerClassRemoveFieldCallback.
mk_ContainerClassRemoveFieldCallback :: C_ContainerClassRemoveFieldCallback -> IO (FunPtr C_ContainerClassRemoveFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_ContainerClassSetChildPropertyFieldCallback.
mk_ContainerClassSetChildPropertyFieldCallback :: C_ContainerClassSetChildPropertyFieldCallback -> IO (FunPtr C_ContainerClassSetChildPropertyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_ContainerClassSetFocusChildFieldCallback.
mk_ContainerClassSetFocusChildFieldCallback :: C_ContainerClassSetFocusChildFieldCallback -> IO (FunPtr C_ContainerClassSetFocusChildFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_EntryCompletionMatchFunc.
mk_EntryCompletionMatchFunc :: C_EntryCompletionMatchFunc -> IO (FunPtr C_EntryCompletionMatchFunc)

-- | Generate a function pointer callable from C code, from a
--   C_FileFilterFunc.
mk_FileFilterFunc :: C_FileFilterFunc -> IO (FunPtr C_FileFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   C_FlowBoxCreateWidgetFunc.
mk_FlowBoxCreateWidgetFunc :: C_FlowBoxCreateWidgetFunc -> IO (FunPtr C_FlowBoxCreateWidgetFunc)

-- | Generate a function pointer callable from C code, from a
--   C_FlowBoxFilterFunc.
mk_FlowBoxFilterFunc :: C_FlowBoxFilterFunc -> IO (FunPtr C_FlowBoxFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   C_FlowBoxForeachFunc.
mk_FlowBoxForeachFunc :: C_FlowBoxForeachFunc -> IO (FunPtr C_FlowBoxForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   C_FlowBoxSortFunc.
mk_FlowBoxSortFunc :: C_FlowBoxSortFunc -> IO (FunPtr C_FlowBoxSortFunc)

-- | Generate a function pointer callable from C code, from a
--   C_FontFilterFunc.
mk_FontFilterFunc :: C_FontFilterFunc -> IO (FunPtr C_FontFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   C_IconViewForeachFunc.
mk_IconViewForeachFunc :: C_IconViewForeachFunc -> IO (FunPtr C_IconViewForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   C_KeySnoopFunc.
mk_KeySnoopFunc :: C_KeySnoopFunc -> IO (FunPtr C_KeySnoopFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ListBoxCreateWidgetFunc.
mk_ListBoxCreateWidgetFunc :: C_ListBoxCreateWidgetFunc -> IO (FunPtr C_ListBoxCreateWidgetFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ListBoxFilterFunc.
mk_ListBoxFilterFunc :: C_ListBoxFilterFunc -> IO (FunPtr C_ListBoxFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ListBoxForeachFunc.
mk_ListBoxForeachFunc :: C_ListBoxForeachFunc -> IO (FunPtr C_ListBoxForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ListBoxSortFunc.
mk_ListBoxSortFunc :: C_ListBoxSortFunc -> IO (FunPtr C_ListBoxSortFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ListBoxUpdateHeaderFunc.
mk_ListBoxUpdateHeaderFunc :: C_ListBoxUpdateHeaderFunc -> IO (FunPtr C_ListBoxUpdateHeaderFunc)

-- | Generate a function pointer callable from C code, from a
--   C_MenuDetachFunc.
mk_MenuDetachFunc :: C_MenuDetachFunc -> IO (FunPtr C_MenuDetachFunc)

-- | Generate a function pointer callable from C code, from a
--   C_MenuPositionFunc.
mk_MenuPositionFunc :: C_MenuPositionFunc -> IO (FunPtr C_MenuPositionFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ModuleDisplayInitFunc.
mk_ModuleDisplayInitFunc :: C_ModuleDisplayInitFunc -> IO (FunPtr C_ModuleDisplayInitFunc)

-- | Generate a function pointer callable from C code, from a
--   C_ModuleInitFunc.
mk_ModuleInitFunc :: C_ModuleInitFunc -> IO (FunPtr C_ModuleInitFunc)

-- | Generate a function pointer callable from C code, from a
--   C_PageSetupDoneFunc.
mk_PageSetupDoneFunc :: C_PageSetupDoneFunc -> IO (FunPtr C_PageSetupDoneFunc)

-- | Generate a function pointer callable from C code, from a
--   C_PrintSettingsFunc.
mk_PrintSettingsFunc :: C_PrintSettingsFunc -> IO (FunPtr C_PrintSettingsFunc)

-- | Generate a function pointer callable from C code, from a
--   C_RcPropertyParser.
mk_RcPropertyParser :: C_RcPropertyParser -> IO (FunPtr C_RcPropertyParser)

-- | Generate a function pointer callable from C code, from a
--   C_RecentFilterFunc.
mk_RecentFilterFunc :: C_RecentFilterFunc -> IO (FunPtr C_RecentFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   C_RecentSortFunc.
mk_RecentSortFunc :: C_RecentSortFunc -> IO (FunPtr C_RecentSortFunc)

-- | Generate a function pointer callable from C code, from a
--   C_StylePropertyParser.
mk_StylePropertyParser :: C_StylePropertyParser -> IO (FunPtr C_StylePropertyParser)

-- | Generate a function pointer callable from C code, from a
--   C_TextBufferDeserializeFunc.
mk_TextBufferDeserializeFunc :: C_TextBufferDeserializeFunc -> IO (FunPtr C_TextBufferDeserializeFunc)

-- | Generate a function pointer callable from C code, from a
--   C_TextBufferSerializeFunc.
mk_TextBufferSerializeFunc :: C_TextBufferSerializeFunc -> IO (FunPtr C_TextBufferSerializeFunc)

-- | Generate a function pointer callable from C code, from a
--   C_TextCharPredicate.
mk_TextCharPredicate :: C_TextCharPredicate -> IO (FunPtr C_TextCharPredicate)

-- | Generate a function pointer callable from C code, from a
--   C_TextTagTableForeach.
mk_TextTagTableForeach :: C_TextTagTableForeach -> IO (FunPtr C_TextTagTableForeach)

-- | Generate a function pointer callable from C code, from a
--   C_TickCallback.
mk_TickCallback :: C_TickCallback -> IO (FunPtr C_TickCallback)

-- | Generate a function pointer callable from C code, from a
--   C_TreeCellDataFunc.
mk_TreeCellDataFunc :: C_TreeCellDataFunc -> IO (FunPtr C_TreeCellDataFunc)

-- | Generate a function pointer callable from C code, from a
--   C_TreeDestroyCountFunc.
mk_TreeDestroyCountFunc :: C_TreeDestroyCountFunc -> IO (FunPtr C_TreeDestroyCountFunc)

-- | Generate a function pointer callable from C code, from a
--   C_TreeIterCompareFunc.
mk_TreeIterCompareFunc :: C_TreeIterCompareFunc -> IO (FunPtr C_TreeIterCompareFunc)

-- | Generate a function pointer callable from C code, from a
--   C_TreeModelFilterModifyFunc.
mk_TreeModelFilterModifyFunc :: C_TreeModelFilterModifyFunc -> IO (FunPtr C_TreeModelFilterModifyFunc)

-- | Generate a function pointer callable from C code, from a
--   C_TreeModelFilterVisibleFunc.
mk_TreeModelFilterVisibleFunc :: C_TreeModelFilterVisibleFunc -> IO (FunPtr C_TreeModelFilterVisibleFunc)

-- | Generate a function pointer callable from C code, from a
--   C_TreeModelForeachFunc.
mk_TreeModelForeachFunc :: C_TreeModelForeachFunc -> IO (FunPtr C_TreeModelForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   C_TreeSelectionForeachFunc.
mk_TreeSelectionForeachFunc :: C_TreeSelectionForeachFunc -> IO (FunPtr C_TreeSelectionForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   C_TreeSelectionFunc.
mk_TreeSelectionFunc :: C_TreeSelectionFunc -> IO (FunPtr C_TreeSelectionFunc)

-- | Generate a function pointer callable from C code, from a
--   C_TreeViewColumnDropFunc.
mk_TreeViewColumnDropFunc :: C_TreeViewColumnDropFunc -> IO (FunPtr C_TreeViewColumnDropFunc)

-- | Generate a function pointer callable from C code, from a
--   C_TreeViewMappingFunc.
mk_TreeViewMappingFunc :: C_TreeViewMappingFunc -> IO (FunPtr C_TreeViewMappingFunc)

-- | Generate a function pointer callable from C code, from a
--   C_TreeViewRowSeparatorFunc.
mk_TreeViewRowSeparatorFunc :: C_TreeViewRowSeparatorFunc -> IO (FunPtr C_TreeViewRowSeparatorFunc)

-- | Generate a function pointer callable from C code, from a
--   C_TreeViewSearchEqualFunc.
mk_TreeViewSearchEqualFunc :: C_TreeViewSearchEqualFunc -> IO (FunPtr C_TreeViewSearchEqualFunc)

-- | Generate a function pointer callable from C code, from a
--   C_TreeViewSearchPositionFunc.
mk_TreeViewSearchPositionFunc :: C_TreeViewSearchPositionFunc -> IO (FunPtr C_TreeViewSearchPositionFunc)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassAdjustBaselineAllocationFieldCallback.
mk_WidgetClassAdjustBaselineAllocationFieldCallback :: C_WidgetClassAdjustBaselineAllocationFieldCallback -> IO (FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassAdjustBaselineRequestFieldCallback.
mk_WidgetClassAdjustBaselineRequestFieldCallback :: C_WidgetClassAdjustBaselineRequestFieldCallback -> IO (FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassAdjustSizeAllocationFieldCallback.
mk_WidgetClassAdjustSizeAllocationFieldCallback :: C_WidgetClassAdjustSizeAllocationFieldCallback -> IO (FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassAdjustSizeRequestFieldCallback.
mk_WidgetClassAdjustSizeRequestFieldCallback :: C_WidgetClassAdjustSizeRequestFieldCallback -> IO (FunPtr C_WidgetClassAdjustSizeRequestFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassButtonPressEventFieldCallback.
mk_WidgetClassButtonPressEventFieldCallback :: C_WidgetClassButtonPressEventFieldCallback -> IO (FunPtr C_WidgetClassButtonPressEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassButtonReleaseEventFieldCallback.
mk_WidgetClassButtonReleaseEventFieldCallback :: C_WidgetClassButtonReleaseEventFieldCallback -> IO (FunPtr C_WidgetClassButtonReleaseEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassCanActivateAccelFieldCallback.
mk_WidgetClassCanActivateAccelFieldCallback :: C_WidgetClassCanActivateAccelFieldCallback -> IO (FunPtr C_WidgetClassCanActivateAccelFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassChildNotifyFieldCallback.
mk_WidgetClassChildNotifyFieldCallback :: C_WidgetClassChildNotifyFieldCallback -> IO (FunPtr C_WidgetClassChildNotifyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassCompositedChangedFieldCallback.
mk_WidgetClassCompositedChangedFieldCallback :: C_WidgetClassCompositedChangedFieldCallback -> IO (FunPtr C_WidgetClassCompositedChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassComputeExpandFieldCallback.
mk_WidgetClassComputeExpandFieldCallback :: C_WidgetClassComputeExpandFieldCallback -> IO (FunPtr C_WidgetClassComputeExpandFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassConfigureEventFieldCallback.
mk_WidgetClassConfigureEventFieldCallback :: C_WidgetClassConfigureEventFieldCallback -> IO (FunPtr C_WidgetClassConfigureEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDamageEventFieldCallback.
mk_WidgetClassDamageEventFieldCallback :: C_WidgetClassDamageEventFieldCallback -> IO (FunPtr C_WidgetClassDamageEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDeleteEventFieldCallback.
mk_WidgetClassDeleteEventFieldCallback :: C_WidgetClassDeleteEventFieldCallback -> IO (FunPtr C_WidgetClassDeleteEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDestroyEventFieldCallback.
mk_WidgetClassDestroyEventFieldCallback :: C_WidgetClassDestroyEventFieldCallback -> IO (FunPtr C_WidgetClassDestroyEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDestroyFieldCallback.
mk_WidgetClassDestroyFieldCallback :: C_WidgetClassDestroyFieldCallback -> IO (FunPtr C_WidgetClassDestroyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDirectionChangedFieldCallback.
mk_WidgetClassDirectionChangedFieldCallback :: C_WidgetClassDirectionChangedFieldCallback -> IO (FunPtr C_WidgetClassDirectionChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDispatchChildPropertiesChangedFieldCallback.
mk_WidgetClassDispatchChildPropertiesChangedFieldCallback :: C_WidgetClassDispatchChildPropertiesChangedFieldCallback -> IO (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDragBeginFieldCallback.
mk_WidgetClassDragBeginFieldCallback :: C_WidgetClassDragBeginFieldCallback -> IO (FunPtr C_WidgetClassDragBeginFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDragDataDeleteFieldCallback.
mk_WidgetClassDragDataDeleteFieldCallback :: C_WidgetClassDragDataDeleteFieldCallback -> IO (FunPtr C_WidgetClassDragDataDeleteFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDragDataGetFieldCallback.
mk_WidgetClassDragDataGetFieldCallback :: C_WidgetClassDragDataGetFieldCallback -> IO (FunPtr C_WidgetClassDragDataGetFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDragDataReceivedFieldCallback.
mk_WidgetClassDragDataReceivedFieldCallback :: C_WidgetClassDragDataReceivedFieldCallback -> IO (FunPtr C_WidgetClassDragDataReceivedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDragDropFieldCallback.
mk_WidgetClassDragDropFieldCallback :: C_WidgetClassDragDropFieldCallback -> IO (FunPtr C_WidgetClassDragDropFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDragEndFieldCallback.
mk_WidgetClassDragEndFieldCallback :: C_WidgetClassDragEndFieldCallback -> IO (FunPtr C_WidgetClassDragEndFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDragFailedFieldCallback.
mk_WidgetClassDragFailedFieldCallback :: C_WidgetClassDragFailedFieldCallback -> IO (FunPtr C_WidgetClassDragFailedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDragLeaveFieldCallback.
mk_WidgetClassDragLeaveFieldCallback :: C_WidgetClassDragLeaveFieldCallback -> IO (FunPtr C_WidgetClassDragLeaveFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDragMotionFieldCallback.
mk_WidgetClassDragMotionFieldCallback :: C_WidgetClassDragMotionFieldCallback -> IO (FunPtr C_WidgetClassDragMotionFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassDrawFieldCallback.
mk_WidgetClassDrawFieldCallback :: C_WidgetClassDrawFieldCallback -> IO (FunPtr C_WidgetClassDrawFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassEnterNotifyEventFieldCallback.
mk_WidgetClassEnterNotifyEventFieldCallback :: C_WidgetClassEnterNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassEnterNotifyEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassEventFieldCallback.
mk_WidgetClassEventFieldCallback :: C_WidgetClassEventFieldCallback -> IO (FunPtr C_WidgetClassEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassFocusFieldCallback.
mk_WidgetClassFocusFieldCallback :: C_WidgetClassFocusFieldCallback -> IO (FunPtr C_WidgetClassFocusFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassFocusInEventFieldCallback.
mk_WidgetClassFocusInEventFieldCallback :: C_WidgetClassFocusInEventFieldCallback -> IO (FunPtr C_WidgetClassFocusInEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassFocusOutEventFieldCallback.
mk_WidgetClassFocusOutEventFieldCallback :: C_WidgetClassFocusOutEventFieldCallback -> IO (FunPtr C_WidgetClassFocusOutEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassGetAccessibleFieldCallback.
mk_WidgetClassGetAccessibleFieldCallback :: C_WidgetClassGetAccessibleFieldCallback -> IO (FunPtr C_WidgetClassGetAccessibleFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback.
mk_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassGetPreferredHeightFieldCallback.
mk_WidgetClassGetPreferredHeightFieldCallback :: C_WidgetClassGetPreferredHeightFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassGetPreferredHeightForWidthFieldCallback.
mk_WidgetClassGetPreferredHeightForWidthFieldCallback :: C_WidgetClassGetPreferredHeightForWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassGetPreferredWidthFieldCallback.
mk_WidgetClassGetPreferredWidthFieldCallback :: C_WidgetClassGetPreferredWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredWidthFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassGetPreferredWidthForHeightFieldCallback.
mk_WidgetClassGetPreferredWidthForHeightFieldCallback :: C_WidgetClassGetPreferredWidthForHeightFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassGetRequestModeFieldCallback.
mk_WidgetClassGetRequestModeFieldCallback :: C_WidgetClassGetRequestModeFieldCallback -> IO (FunPtr C_WidgetClassGetRequestModeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassGrabBrokenEventFieldCallback.
mk_WidgetClassGrabBrokenEventFieldCallback :: C_WidgetClassGrabBrokenEventFieldCallback -> IO (FunPtr C_WidgetClassGrabBrokenEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassGrabFocusFieldCallback.
mk_WidgetClassGrabFocusFieldCallback :: C_WidgetClassGrabFocusFieldCallback -> IO (FunPtr C_WidgetClassGrabFocusFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassGrabNotifyFieldCallback.
mk_WidgetClassGrabNotifyFieldCallback :: C_WidgetClassGrabNotifyFieldCallback -> IO (FunPtr C_WidgetClassGrabNotifyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassHideFieldCallback.
mk_WidgetClassHideFieldCallback :: C_WidgetClassHideFieldCallback -> IO (FunPtr C_WidgetClassHideFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassHierarchyChangedFieldCallback.
mk_WidgetClassHierarchyChangedFieldCallback :: C_WidgetClassHierarchyChangedFieldCallback -> IO (FunPtr C_WidgetClassHierarchyChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassKeyPressEventFieldCallback.
mk_WidgetClassKeyPressEventFieldCallback :: C_WidgetClassKeyPressEventFieldCallback -> IO (FunPtr C_WidgetClassKeyPressEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassKeyReleaseEventFieldCallback.
mk_WidgetClassKeyReleaseEventFieldCallback :: C_WidgetClassKeyReleaseEventFieldCallback -> IO (FunPtr C_WidgetClassKeyReleaseEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassKeynavFailedFieldCallback.
mk_WidgetClassKeynavFailedFieldCallback :: C_WidgetClassKeynavFailedFieldCallback -> IO (FunPtr C_WidgetClassKeynavFailedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassLeaveNotifyEventFieldCallback.
mk_WidgetClassLeaveNotifyEventFieldCallback :: C_WidgetClassLeaveNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassLeaveNotifyEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassMapEventFieldCallback.
mk_WidgetClassMapEventFieldCallback :: C_WidgetClassMapEventFieldCallback -> IO (FunPtr C_WidgetClassMapEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassMapFieldCallback.
mk_WidgetClassMapFieldCallback :: C_WidgetClassMapFieldCallback -> IO (FunPtr C_WidgetClassMapFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassMnemonicActivateFieldCallback.
mk_WidgetClassMnemonicActivateFieldCallback :: C_WidgetClassMnemonicActivateFieldCallback -> IO (FunPtr C_WidgetClassMnemonicActivateFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassMotionNotifyEventFieldCallback.
mk_WidgetClassMotionNotifyEventFieldCallback :: C_WidgetClassMotionNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassMotionNotifyEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassMoveFocusFieldCallback.
mk_WidgetClassMoveFocusFieldCallback :: C_WidgetClassMoveFocusFieldCallback -> IO (FunPtr C_WidgetClassMoveFocusFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassParentSetFieldCallback.
mk_WidgetClassParentSetFieldCallback :: C_WidgetClassParentSetFieldCallback -> IO (FunPtr C_WidgetClassParentSetFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassPopupMenuFieldCallback.
mk_WidgetClassPopupMenuFieldCallback :: C_WidgetClassPopupMenuFieldCallback -> IO (FunPtr C_WidgetClassPopupMenuFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassPropertyNotifyEventFieldCallback.
mk_WidgetClassPropertyNotifyEventFieldCallback :: C_WidgetClassPropertyNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassPropertyNotifyEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassProximityInEventFieldCallback.
mk_WidgetClassProximityInEventFieldCallback :: C_WidgetClassProximityInEventFieldCallback -> IO (FunPtr C_WidgetClassProximityInEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassProximityOutEventFieldCallback.
mk_WidgetClassProximityOutEventFieldCallback :: C_WidgetClassProximityOutEventFieldCallback -> IO (FunPtr C_WidgetClassProximityOutEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassQueryTooltipFieldCallback.
mk_WidgetClassQueryTooltipFieldCallback :: C_WidgetClassQueryTooltipFieldCallback -> IO (FunPtr C_WidgetClassQueryTooltipFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassQueueDrawRegionFieldCallback.
mk_WidgetClassQueueDrawRegionFieldCallback :: C_WidgetClassQueueDrawRegionFieldCallback -> IO (FunPtr C_WidgetClassQueueDrawRegionFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassRealizeFieldCallback.
mk_WidgetClassRealizeFieldCallback :: C_WidgetClassRealizeFieldCallback -> IO (FunPtr C_WidgetClassRealizeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassScreenChangedFieldCallback.
mk_WidgetClassScreenChangedFieldCallback :: C_WidgetClassScreenChangedFieldCallback -> IO (FunPtr C_WidgetClassScreenChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassScrollEventFieldCallback.
mk_WidgetClassScrollEventFieldCallback :: C_WidgetClassScrollEventFieldCallback -> IO (FunPtr C_WidgetClassScrollEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassSelectionClearEventFieldCallback.
mk_WidgetClassSelectionClearEventFieldCallback :: C_WidgetClassSelectionClearEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionClearEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassSelectionGetFieldCallback.
mk_WidgetClassSelectionGetFieldCallback :: C_WidgetClassSelectionGetFieldCallback -> IO (FunPtr C_WidgetClassSelectionGetFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassSelectionNotifyEventFieldCallback.
mk_WidgetClassSelectionNotifyEventFieldCallback :: C_WidgetClassSelectionNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionNotifyEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassSelectionReceivedFieldCallback.
mk_WidgetClassSelectionReceivedFieldCallback :: C_WidgetClassSelectionReceivedFieldCallback -> IO (FunPtr C_WidgetClassSelectionReceivedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassSelectionRequestEventFieldCallback.
mk_WidgetClassSelectionRequestEventFieldCallback :: C_WidgetClassSelectionRequestEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionRequestEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassShowAllFieldCallback.
mk_WidgetClassShowAllFieldCallback :: C_WidgetClassShowAllFieldCallback -> IO (FunPtr C_WidgetClassShowAllFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassShowFieldCallback.
mk_WidgetClassShowFieldCallback :: C_WidgetClassShowFieldCallback -> IO (FunPtr C_WidgetClassShowFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassShowHelpFieldCallback.
mk_WidgetClassShowHelpFieldCallback :: C_WidgetClassShowHelpFieldCallback -> IO (FunPtr C_WidgetClassShowHelpFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassSizeAllocateFieldCallback.
mk_WidgetClassSizeAllocateFieldCallback :: C_WidgetClassSizeAllocateFieldCallback -> IO (FunPtr C_WidgetClassSizeAllocateFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassStateChangedFieldCallback.
mk_WidgetClassStateChangedFieldCallback :: C_WidgetClassStateChangedFieldCallback -> IO (FunPtr C_WidgetClassStateChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassStateFlagsChangedFieldCallback.
mk_WidgetClassStateFlagsChangedFieldCallback :: C_WidgetClassStateFlagsChangedFieldCallback -> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassStyleSetFieldCallback.
mk_WidgetClassStyleSetFieldCallback :: C_WidgetClassStyleSetFieldCallback -> IO (FunPtr C_WidgetClassStyleSetFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassStyleUpdatedFieldCallback.
mk_WidgetClassStyleUpdatedFieldCallback :: C_WidgetClassStyleUpdatedFieldCallback -> IO (FunPtr C_WidgetClassStyleUpdatedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassTouchEventFieldCallback.
mk_WidgetClassTouchEventFieldCallback :: C_WidgetClassTouchEventFieldCallback -> IO (FunPtr C_WidgetClassTouchEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassUnmapEventFieldCallback.
mk_WidgetClassUnmapEventFieldCallback :: C_WidgetClassUnmapEventFieldCallback -> IO (FunPtr C_WidgetClassUnmapEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassUnmapFieldCallback.
mk_WidgetClassUnmapFieldCallback :: C_WidgetClassUnmapFieldCallback -> IO (FunPtr C_WidgetClassUnmapFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassUnrealizeFieldCallback.
mk_WidgetClassUnrealizeFieldCallback :: C_WidgetClassUnrealizeFieldCallback -> IO (FunPtr C_WidgetClassUnrealizeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassVisibilityNotifyEventFieldCallback.
mk_WidgetClassVisibilityNotifyEventFieldCallback :: C_WidgetClassVisibilityNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   C_WidgetClassWindowStateEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassWindowStateEventFieldCallback.
noWidgetClassWindowStateEventFieldCallback :: Maybe WidgetClassWindowStateEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassWindowStateEventFieldCallback :: MonadIO m => WidgetClassWindowStateEventFieldCallback -> m (GClosure C_WidgetClassWindowStateEventFieldCallback)

-- | Wrap a WidgetClassWindowStateEventFieldCallback into a
--   C_WidgetClassWindowStateEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassVisibilityNotifyEventFieldCallback.
noWidgetClassVisibilityNotifyEventFieldCallback :: Maybe WidgetClassVisibilityNotifyEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassVisibilityNotifyEventFieldCallback :: MonadIO m => WidgetClassVisibilityNotifyEventFieldCallback -> m (GClosure C_WidgetClassVisibilityNotifyEventFieldCallback)

-- | Wrap a WidgetClassVisibilityNotifyEventFieldCallback into a
--   C_WidgetClassVisibilityNotifyEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassUnrealizeFieldCallback.
noWidgetClassUnrealizeFieldCallback :: Maybe WidgetClassUnrealizeFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassUnrealizeFieldCallback :: MonadIO m => WidgetClassUnrealizeFieldCallback -> m (GClosure C_WidgetClassUnrealizeFieldCallback)

-- | Wrap a WidgetClassUnrealizeFieldCallback into a
--   C_WidgetClassUnrealizeFieldCallback.
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 Nothing :: Maybe
--   WidgetClassUnmapFieldCallback.
noWidgetClassUnmapFieldCallback :: Maybe WidgetClassUnmapFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassUnmapFieldCallback :: MonadIO m => WidgetClassUnmapFieldCallback -> m (GClosure C_WidgetClassUnmapFieldCallback)

-- | Wrap a WidgetClassUnmapFieldCallback into a
--   C_WidgetClassUnmapFieldCallback.
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 Nothing :: Maybe
--   WidgetClassUnmapEventFieldCallback.
noWidgetClassUnmapEventFieldCallback :: Maybe WidgetClassUnmapEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassUnmapEventFieldCallback :: MonadIO m => WidgetClassUnmapEventFieldCallback -> m (GClosure C_WidgetClassUnmapEventFieldCallback)

-- | Wrap a WidgetClassUnmapEventFieldCallback into a
--   C_WidgetClassUnmapEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassTouchEventFieldCallback.
noWidgetClassTouchEventFieldCallback :: Maybe WidgetClassTouchEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassTouchEventFieldCallback :: MonadIO m => WidgetClassTouchEventFieldCallback -> m (GClosure C_WidgetClassTouchEventFieldCallback)

-- | Wrap a WidgetClassTouchEventFieldCallback into a
--   C_WidgetClassTouchEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassStyleUpdatedFieldCallback.
noWidgetClassStyleUpdatedFieldCallback :: Maybe WidgetClassStyleUpdatedFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassStyleUpdatedFieldCallback :: MonadIO m => WidgetClassStyleUpdatedFieldCallback -> m (GClosure C_WidgetClassStyleUpdatedFieldCallback)

-- | Wrap a WidgetClassStyleUpdatedFieldCallback into a
--   C_WidgetClassStyleUpdatedFieldCallback.
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 Nothing :: Maybe
--   WidgetClassStyleSetFieldCallback.
noWidgetClassStyleSetFieldCallback :: Maybe WidgetClassStyleSetFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassStyleSetFieldCallback :: MonadIO m => WidgetClassStyleSetFieldCallback -> m (GClosure C_WidgetClassStyleSetFieldCallback)

-- | Wrap a WidgetClassStyleSetFieldCallback into a
--   C_WidgetClassStyleSetFieldCallback.
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 Nothing :: Maybe
--   WidgetClassStateFlagsChangedFieldCallback.
noWidgetClassStateFlagsChangedFieldCallback :: Maybe WidgetClassStateFlagsChangedFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassStateFlagsChangedFieldCallback :: MonadIO m => WidgetClassStateFlagsChangedFieldCallback -> m (GClosure C_WidgetClassStateFlagsChangedFieldCallback)

-- | Wrap a WidgetClassStateFlagsChangedFieldCallback into a
--   C_WidgetClassStateFlagsChangedFieldCallback.
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 Nothing :: Maybe
--   WidgetClassStateChangedFieldCallback.
noWidgetClassStateChangedFieldCallback :: Maybe WidgetClassStateChangedFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassStateChangedFieldCallback :: MonadIO m => WidgetClassStateChangedFieldCallback -> m (GClosure C_WidgetClassStateChangedFieldCallback)

-- | Wrap a WidgetClassStateChangedFieldCallback into a
--   C_WidgetClassStateChangedFieldCallback.
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 Nothing :: Maybe
--   WidgetClassSizeAllocateFieldCallback.
noWidgetClassSizeAllocateFieldCallback :: Maybe WidgetClassSizeAllocateFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassSizeAllocateFieldCallback :: MonadIO m => WidgetClassSizeAllocateFieldCallback -> m (GClosure C_WidgetClassSizeAllocateFieldCallback)

-- | Wrap a WidgetClassSizeAllocateFieldCallback into a
--   C_WidgetClassSizeAllocateFieldCallback.
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 Nothing :: Maybe
--   WidgetClassShowHelpFieldCallback.
noWidgetClassShowHelpFieldCallback :: Maybe WidgetClassShowHelpFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassShowHelpFieldCallback :: MonadIO m => WidgetClassShowHelpFieldCallback -> m (GClosure C_WidgetClassShowHelpFieldCallback)

-- | Wrap a WidgetClassShowHelpFieldCallback into a
--   C_WidgetClassShowHelpFieldCallback.
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 Nothing :: Maybe
--   WidgetClassShowFieldCallback.
noWidgetClassShowFieldCallback :: Maybe WidgetClassShowFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassShowFieldCallback :: MonadIO m => WidgetClassShowFieldCallback -> m (GClosure C_WidgetClassShowFieldCallback)

-- | Wrap a WidgetClassShowFieldCallback into a
--   C_WidgetClassShowFieldCallback.
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 Nothing :: Maybe
--   WidgetClassShowAllFieldCallback.
noWidgetClassShowAllFieldCallback :: Maybe WidgetClassShowAllFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassShowAllFieldCallback :: MonadIO m => WidgetClassShowAllFieldCallback -> m (GClosure C_WidgetClassShowAllFieldCallback)

-- | Wrap a WidgetClassShowAllFieldCallback into a
--   C_WidgetClassShowAllFieldCallback.
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 Nothing :: Maybe
--   WidgetClassSelectionRequestEventFieldCallback.
noWidgetClassSelectionRequestEventFieldCallback :: Maybe WidgetClassSelectionRequestEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassSelectionRequestEventFieldCallback :: MonadIO m => WidgetClassSelectionRequestEventFieldCallback -> m (GClosure C_WidgetClassSelectionRequestEventFieldCallback)

-- | Wrap a WidgetClassSelectionRequestEventFieldCallback into a
--   C_WidgetClassSelectionRequestEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassSelectionReceivedFieldCallback.
noWidgetClassSelectionReceivedFieldCallback :: Maybe WidgetClassSelectionReceivedFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassSelectionReceivedFieldCallback :: MonadIO m => WidgetClassSelectionReceivedFieldCallback -> m (GClosure C_WidgetClassSelectionReceivedFieldCallback)

-- | Wrap a WidgetClassSelectionReceivedFieldCallback into a
--   C_WidgetClassSelectionReceivedFieldCallback.
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 Nothing :: Maybe
--   WidgetClassSelectionNotifyEventFieldCallback.
noWidgetClassSelectionNotifyEventFieldCallback :: Maybe WidgetClassSelectionNotifyEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassSelectionNotifyEventFieldCallback :: MonadIO m => WidgetClassSelectionNotifyEventFieldCallback -> m (GClosure C_WidgetClassSelectionNotifyEventFieldCallback)

-- | Wrap a WidgetClassSelectionNotifyEventFieldCallback into a
--   C_WidgetClassSelectionNotifyEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassSelectionGetFieldCallback.
noWidgetClassSelectionGetFieldCallback :: Maybe WidgetClassSelectionGetFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassSelectionGetFieldCallback :: MonadIO m => WidgetClassSelectionGetFieldCallback -> m (GClosure C_WidgetClassSelectionGetFieldCallback)

-- | Wrap a WidgetClassSelectionGetFieldCallback into a
--   C_WidgetClassSelectionGetFieldCallback.
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 Nothing :: Maybe
--   WidgetClassSelectionClearEventFieldCallback.
noWidgetClassSelectionClearEventFieldCallback :: Maybe WidgetClassSelectionClearEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassSelectionClearEventFieldCallback :: MonadIO m => WidgetClassSelectionClearEventFieldCallback -> m (GClosure C_WidgetClassSelectionClearEventFieldCallback)

-- | Wrap a WidgetClassSelectionClearEventFieldCallback into a
--   C_WidgetClassSelectionClearEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassScrollEventFieldCallback.
noWidgetClassScrollEventFieldCallback :: Maybe WidgetClassScrollEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassScrollEventFieldCallback :: MonadIO m => WidgetClassScrollEventFieldCallback -> m (GClosure C_WidgetClassScrollEventFieldCallback)

-- | Wrap a WidgetClassScrollEventFieldCallback into a
--   C_WidgetClassScrollEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassScreenChangedFieldCallback.
noWidgetClassScreenChangedFieldCallback :: Maybe WidgetClassScreenChangedFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassScreenChangedFieldCallback :: MonadIO m => WidgetClassScreenChangedFieldCallback -> m (GClosure C_WidgetClassScreenChangedFieldCallback)

-- | Wrap a WidgetClassScreenChangedFieldCallback into a
--   C_WidgetClassScreenChangedFieldCallback.
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 Nothing :: Maybe
--   WidgetClassRealizeFieldCallback.
noWidgetClassRealizeFieldCallback :: Maybe WidgetClassRealizeFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassRealizeFieldCallback :: MonadIO m => WidgetClassRealizeFieldCallback -> m (GClosure C_WidgetClassRealizeFieldCallback)

-- | Wrap a WidgetClassRealizeFieldCallback into a
--   C_WidgetClassRealizeFieldCallback.
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 Nothing :: Maybe
--   WidgetClassQueueDrawRegionFieldCallback.
noWidgetClassQueueDrawRegionFieldCallback :: Maybe WidgetClassQueueDrawRegionFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassQueueDrawRegionFieldCallback :: MonadIO m => WidgetClassQueueDrawRegionFieldCallback -> m (GClosure C_WidgetClassQueueDrawRegionFieldCallback)

-- | Wrap a WidgetClassQueueDrawRegionFieldCallback into a
--   C_WidgetClassQueueDrawRegionFieldCallback.
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 Nothing :: Maybe
--   WidgetClassQueryTooltipFieldCallback.
noWidgetClassQueryTooltipFieldCallback :: Maybe WidgetClassQueryTooltipFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassQueryTooltipFieldCallback :: MonadIO m => WidgetClassQueryTooltipFieldCallback -> m (GClosure C_WidgetClassQueryTooltipFieldCallback)

-- | Wrap a WidgetClassQueryTooltipFieldCallback into a
--   C_WidgetClassQueryTooltipFieldCallback.
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 Nothing :: Maybe
--   WidgetClassProximityOutEventFieldCallback.
noWidgetClassProximityOutEventFieldCallback :: Maybe WidgetClassProximityOutEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassProximityOutEventFieldCallback :: MonadIO m => WidgetClassProximityOutEventFieldCallback -> m (GClosure C_WidgetClassProximityOutEventFieldCallback)

-- | Wrap a WidgetClassProximityOutEventFieldCallback into a
--   C_WidgetClassProximityOutEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassProximityInEventFieldCallback.
noWidgetClassProximityInEventFieldCallback :: Maybe WidgetClassProximityInEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassProximityInEventFieldCallback :: MonadIO m => WidgetClassProximityInEventFieldCallback -> m (GClosure C_WidgetClassProximityInEventFieldCallback)

-- | Wrap a WidgetClassProximityInEventFieldCallback into a
--   C_WidgetClassProximityInEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassPropertyNotifyEventFieldCallback.
noWidgetClassPropertyNotifyEventFieldCallback :: Maybe WidgetClassPropertyNotifyEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassPropertyNotifyEventFieldCallback :: MonadIO m => WidgetClassPropertyNotifyEventFieldCallback -> m (GClosure C_WidgetClassPropertyNotifyEventFieldCallback)

-- | Wrap a WidgetClassPropertyNotifyEventFieldCallback into a
--   C_WidgetClassPropertyNotifyEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassPopupMenuFieldCallback.
noWidgetClassPopupMenuFieldCallback :: Maybe WidgetClassPopupMenuFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassPopupMenuFieldCallback :: MonadIO m => WidgetClassPopupMenuFieldCallback -> m (GClosure C_WidgetClassPopupMenuFieldCallback)

-- | Wrap a WidgetClassPopupMenuFieldCallback into a
--   C_WidgetClassPopupMenuFieldCallback.
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 Nothing :: Maybe
--   WidgetClassParentSetFieldCallback.
noWidgetClassParentSetFieldCallback :: Maybe WidgetClassParentSetFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassParentSetFieldCallback :: MonadIO m => WidgetClassParentSetFieldCallback -> m (GClosure C_WidgetClassParentSetFieldCallback)

-- | Wrap a WidgetClassParentSetFieldCallback into a
--   C_WidgetClassParentSetFieldCallback.
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 Nothing :: Maybe
--   WidgetClassMoveFocusFieldCallback.
noWidgetClassMoveFocusFieldCallback :: Maybe WidgetClassMoveFocusFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassMoveFocusFieldCallback :: MonadIO m => WidgetClassMoveFocusFieldCallback -> m (GClosure C_WidgetClassMoveFocusFieldCallback)

-- | Wrap a WidgetClassMoveFocusFieldCallback into a
--   C_WidgetClassMoveFocusFieldCallback.
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 Nothing :: Maybe
--   WidgetClassMotionNotifyEventFieldCallback.
noWidgetClassMotionNotifyEventFieldCallback :: Maybe WidgetClassMotionNotifyEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassMotionNotifyEventFieldCallback :: MonadIO m => WidgetClassMotionNotifyEventFieldCallback -> m (GClosure C_WidgetClassMotionNotifyEventFieldCallback)

-- | Wrap a WidgetClassMotionNotifyEventFieldCallback into a
--   C_WidgetClassMotionNotifyEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassMnemonicActivateFieldCallback.
noWidgetClassMnemonicActivateFieldCallback :: Maybe WidgetClassMnemonicActivateFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassMnemonicActivateFieldCallback :: MonadIO m => WidgetClassMnemonicActivateFieldCallback -> m (GClosure C_WidgetClassMnemonicActivateFieldCallback)

-- | Wrap a WidgetClassMnemonicActivateFieldCallback into a
--   C_WidgetClassMnemonicActivateFieldCallback.
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 Nothing :: Maybe
--   WidgetClassMapFieldCallback.
noWidgetClassMapFieldCallback :: Maybe WidgetClassMapFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassMapFieldCallback :: MonadIO m => WidgetClassMapFieldCallback -> m (GClosure C_WidgetClassMapFieldCallback)

-- | Wrap a WidgetClassMapFieldCallback into a
--   C_WidgetClassMapFieldCallback.
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 Nothing :: Maybe
--   WidgetClassMapEventFieldCallback.
noWidgetClassMapEventFieldCallback :: Maybe WidgetClassMapEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassMapEventFieldCallback :: MonadIO m => WidgetClassMapEventFieldCallback -> m (GClosure C_WidgetClassMapEventFieldCallback)

-- | Wrap a WidgetClassMapEventFieldCallback into a
--   C_WidgetClassMapEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassLeaveNotifyEventFieldCallback.
noWidgetClassLeaveNotifyEventFieldCallback :: Maybe WidgetClassLeaveNotifyEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassLeaveNotifyEventFieldCallback :: MonadIO m => WidgetClassLeaveNotifyEventFieldCallback -> m (GClosure C_WidgetClassLeaveNotifyEventFieldCallback)

-- | Wrap a WidgetClassLeaveNotifyEventFieldCallback into a
--   C_WidgetClassLeaveNotifyEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassKeynavFailedFieldCallback.
noWidgetClassKeynavFailedFieldCallback :: Maybe WidgetClassKeynavFailedFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassKeynavFailedFieldCallback :: MonadIO m => WidgetClassKeynavFailedFieldCallback -> m (GClosure C_WidgetClassKeynavFailedFieldCallback)

-- | Wrap a WidgetClassKeynavFailedFieldCallback into a
--   C_WidgetClassKeynavFailedFieldCallback.
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 Nothing :: Maybe
--   WidgetClassKeyReleaseEventFieldCallback.
noWidgetClassKeyReleaseEventFieldCallback :: Maybe WidgetClassKeyReleaseEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassKeyReleaseEventFieldCallback :: MonadIO m => WidgetClassKeyReleaseEventFieldCallback -> m (GClosure C_WidgetClassKeyReleaseEventFieldCallback)

-- | Wrap a WidgetClassKeyReleaseEventFieldCallback into a
--   C_WidgetClassKeyReleaseEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassKeyPressEventFieldCallback.
noWidgetClassKeyPressEventFieldCallback :: Maybe WidgetClassKeyPressEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassKeyPressEventFieldCallback :: MonadIO m => WidgetClassKeyPressEventFieldCallback -> m (GClosure C_WidgetClassKeyPressEventFieldCallback)

-- | Wrap a WidgetClassKeyPressEventFieldCallback into a
--   C_WidgetClassKeyPressEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassHierarchyChangedFieldCallback.
noWidgetClassHierarchyChangedFieldCallback :: Maybe WidgetClassHierarchyChangedFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassHierarchyChangedFieldCallback :: MonadIO m => WidgetClassHierarchyChangedFieldCallback -> m (GClosure C_WidgetClassHierarchyChangedFieldCallback)

-- | Wrap a WidgetClassHierarchyChangedFieldCallback into a
--   C_WidgetClassHierarchyChangedFieldCallback.
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 Nothing :: Maybe
--   WidgetClassHideFieldCallback.
noWidgetClassHideFieldCallback :: Maybe WidgetClassHideFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassHideFieldCallback :: MonadIO m => WidgetClassHideFieldCallback -> m (GClosure C_WidgetClassHideFieldCallback)

-- | Wrap a WidgetClassHideFieldCallback into a
--   C_WidgetClassHideFieldCallback.
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 Nothing :: Maybe
--   WidgetClassGrabNotifyFieldCallback.
noWidgetClassGrabNotifyFieldCallback :: Maybe WidgetClassGrabNotifyFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassGrabNotifyFieldCallback :: MonadIO m => WidgetClassGrabNotifyFieldCallback -> m (GClosure C_WidgetClassGrabNotifyFieldCallback)

-- | Wrap a WidgetClassGrabNotifyFieldCallback into a
--   C_WidgetClassGrabNotifyFieldCallback.
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 Nothing :: Maybe
--   WidgetClassGrabFocusFieldCallback.
noWidgetClassGrabFocusFieldCallback :: Maybe WidgetClassGrabFocusFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassGrabFocusFieldCallback :: MonadIO m => WidgetClassGrabFocusFieldCallback -> m (GClosure C_WidgetClassGrabFocusFieldCallback)

-- | Wrap a WidgetClassGrabFocusFieldCallback into a
--   C_WidgetClassGrabFocusFieldCallback.
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 Nothing :: Maybe
--   WidgetClassGrabBrokenEventFieldCallback.
noWidgetClassGrabBrokenEventFieldCallback :: Maybe WidgetClassGrabBrokenEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassGrabBrokenEventFieldCallback :: MonadIO m => WidgetClassGrabBrokenEventFieldCallback -> m (GClosure C_WidgetClassGrabBrokenEventFieldCallback)

-- | Wrap a WidgetClassGrabBrokenEventFieldCallback into a
--   C_WidgetClassGrabBrokenEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassGetRequestModeFieldCallback.
noWidgetClassGetRequestModeFieldCallback :: Maybe WidgetClassGetRequestModeFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassGetRequestModeFieldCallback :: MonadIO m => WidgetClassGetRequestModeFieldCallback -> m (GClosure C_WidgetClassGetRequestModeFieldCallback)

-- | Wrap a WidgetClassGetRequestModeFieldCallback into a
--   C_WidgetClassGetRequestModeFieldCallback.
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 Nothing :: Maybe
--   WidgetClassGetPreferredWidthForHeightFieldCallback.
noWidgetClassGetPreferredWidthForHeightFieldCallback :: Maybe WidgetClassGetPreferredWidthForHeightFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassGetPreferredWidthForHeightFieldCallback :: MonadIO m => WidgetClassGetPreferredWidthForHeightFieldCallback -> m (GClosure C_WidgetClassGetPreferredWidthForHeightFieldCallback)

-- | Wrap a WidgetClassGetPreferredWidthForHeightFieldCallback into
--   a C_WidgetClassGetPreferredWidthForHeightFieldCallback.
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 Nothing :: Maybe
--   WidgetClassGetPreferredWidthFieldCallback.
noWidgetClassGetPreferredWidthFieldCallback :: Maybe WidgetClassGetPreferredWidthFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassGetPreferredWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredWidthFieldCallback)

-- | Wrap a WidgetClassGetPreferredWidthFieldCallback into a
--   C_WidgetClassGetPreferredWidthFieldCallback.
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 Nothing :: Maybe
--   WidgetClassGetPreferredHeightForWidthFieldCallback.
noWidgetClassGetPreferredHeightForWidthFieldCallback :: Maybe WidgetClassGetPreferredHeightForWidthFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassGetPreferredHeightForWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightForWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightForWidthFieldCallback)

-- | Wrap a WidgetClassGetPreferredHeightForWidthFieldCallback into
--   a C_WidgetClassGetPreferredHeightForWidthFieldCallback.
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 Nothing :: Maybe
--   WidgetClassGetPreferredHeightFieldCallback.
noWidgetClassGetPreferredHeightFieldCallback :: Maybe WidgetClassGetPreferredHeightFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassGetPreferredHeightFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightFieldCallback)

-- | Wrap a WidgetClassGetPreferredHeightFieldCallback into a
--   C_WidgetClassGetPreferredHeightFieldCallback.
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 Nothing :: Maybe
--   WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback.
noWidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: Maybe WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)

-- | Wrap a
--   WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
--   into a
--   C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback.
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 Nothing :: Maybe
--   WidgetClassGetAccessibleFieldCallback.
noWidgetClassGetAccessibleFieldCallback :: Maybe WidgetClassGetAccessibleFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassGetAccessibleFieldCallback :: MonadIO m => WidgetClassGetAccessibleFieldCallback -> m (GClosure C_WidgetClassGetAccessibleFieldCallback)

-- | Wrap a WidgetClassGetAccessibleFieldCallback into a
--   C_WidgetClassGetAccessibleFieldCallback.
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 Nothing :: Maybe
--   WidgetClassFocusOutEventFieldCallback.
noWidgetClassFocusOutEventFieldCallback :: Maybe WidgetClassFocusOutEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassFocusOutEventFieldCallback :: MonadIO m => WidgetClassFocusOutEventFieldCallback -> m (GClosure C_WidgetClassFocusOutEventFieldCallback)

-- | Wrap a WidgetClassFocusOutEventFieldCallback into a
--   C_WidgetClassFocusOutEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassFocusInEventFieldCallback.
noWidgetClassFocusInEventFieldCallback :: Maybe WidgetClassFocusInEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassFocusInEventFieldCallback :: MonadIO m => WidgetClassFocusInEventFieldCallback -> m (GClosure C_WidgetClassFocusInEventFieldCallback)

-- | Wrap a WidgetClassFocusInEventFieldCallback into a
--   C_WidgetClassFocusInEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassFocusFieldCallback.
noWidgetClassFocusFieldCallback :: Maybe WidgetClassFocusFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassFocusFieldCallback :: MonadIO m => WidgetClassFocusFieldCallback -> m (GClosure C_WidgetClassFocusFieldCallback)

-- | Wrap a WidgetClassFocusFieldCallback into a
--   C_WidgetClassFocusFieldCallback.
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 Nothing :: Maybe
--   WidgetClassEventFieldCallback.
noWidgetClassEventFieldCallback :: Maybe WidgetClassEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassEventFieldCallback :: MonadIO m => WidgetClassEventFieldCallback -> m (GClosure C_WidgetClassEventFieldCallback)

-- | Wrap a WidgetClassEventFieldCallback into a
--   C_WidgetClassEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassEnterNotifyEventFieldCallback.
noWidgetClassEnterNotifyEventFieldCallback :: Maybe WidgetClassEnterNotifyEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassEnterNotifyEventFieldCallback :: MonadIO m => WidgetClassEnterNotifyEventFieldCallback -> m (GClosure C_WidgetClassEnterNotifyEventFieldCallback)

-- | Wrap a WidgetClassEnterNotifyEventFieldCallback into a
--   C_WidgetClassEnterNotifyEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDrawFieldCallback.
noWidgetClassDrawFieldCallback :: Maybe WidgetClassDrawFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDrawFieldCallback :: MonadIO m => WidgetClassDrawFieldCallback -> m (GClosure C_WidgetClassDrawFieldCallback)

-- | Wrap a WidgetClassDrawFieldCallback into a
--   C_WidgetClassDrawFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDragMotionFieldCallback.
noWidgetClassDragMotionFieldCallback :: Maybe WidgetClassDragMotionFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDragMotionFieldCallback :: MonadIO m => WidgetClassDragMotionFieldCallback -> m (GClosure C_WidgetClassDragMotionFieldCallback)

-- | Wrap a WidgetClassDragMotionFieldCallback into a
--   C_WidgetClassDragMotionFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDragLeaveFieldCallback.
noWidgetClassDragLeaveFieldCallback :: Maybe WidgetClassDragLeaveFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDragLeaveFieldCallback :: MonadIO m => WidgetClassDragLeaveFieldCallback -> m (GClosure C_WidgetClassDragLeaveFieldCallback)

-- | Wrap a WidgetClassDragLeaveFieldCallback into a
--   C_WidgetClassDragLeaveFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDragFailedFieldCallback.
noWidgetClassDragFailedFieldCallback :: Maybe WidgetClassDragFailedFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDragFailedFieldCallback :: MonadIO m => WidgetClassDragFailedFieldCallback -> m (GClosure C_WidgetClassDragFailedFieldCallback)

-- | Wrap a WidgetClassDragFailedFieldCallback into a
--   C_WidgetClassDragFailedFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDragEndFieldCallback.
noWidgetClassDragEndFieldCallback :: Maybe WidgetClassDragEndFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDragEndFieldCallback :: MonadIO m => WidgetClassDragEndFieldCallback -> m (GClosure C_WidgetClassDragEndFieldCallback)

-- | Wrap a WidgetClassDragEndFieldCallback into a
--   C_WidgetClassDragEndFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDragDropFieldCallback.
noWidgetClassDragDropFieldCallback :: Maybe WidgetClassDragDropFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDragDropFieldCallback :: MonadIO m => WidgetClassDragDropFieldCallback -> m (GClosure C_WidgetClassDragDropFieldCallback)

-- | Wrap a WidgetClassDragDropFieldCallback into a
--   C_WidgetClassDragDropFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDragDataReceivedFieldCallback.
noWidgetClassDragDataReceivedFieldCallback :: Maybe WidgetClassDragDataReceivedFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDragDataReceivedFieldCallback :: MonadIO m => WidgetClassDragDataReceivedFieldCallback -> m (GClosure C_WidgetClassDragDataReceivedFieldCallback)

-- | Wrap a WidgetClassDragDataReceivedFieldCallback into a
--   C_WidgetClassDragDataReceivedFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDragDataGetFieldCallback.
noWidgetClassDragDataGetFieldCallback :: Maybe WidgetClassDragDataGetFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDragDataGetFieldCallback :: MonadIO m => WidgetClassDragDataGetFieldCallback -> m (GClosure C_WidgetClassDragDataGetFieldCallback)

-- | Wrap a WidgetClassDragDataGetFieldCallback into a
--   C_WidgetClassDragDataGetFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDragDataDeleteFieldCallback.
noWidgetClassDragDataDeleteFieldCallback :: Maybe WidgetClassDragDataDeleteFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDragDataDeleteFieldCallback :: MonadIO m => WidgetClassDragDataDeleteFieldCallback -> m (GClosure C_WidgetClassDragDataDeleteFieldCallback)

-- | Wrap a WidgetClassDragDataDeleteFieldCallback into a
--   C_WidgetClassDragDataDeleteFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDragBeginFieldCallback.
noWidgetClassDragBeginFieldCallback :: Maybe WidgetClassDragBeginFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDragBeginFieldCallback :: MonadIO m => WidgetClassDragBeginFieldCallback -> m (GClosure C_WidgetClassDragBeginFieldCallback)

-- | Wrap a WidgetClassDragBeginFieldCallback into a
--   C_WidgetClassDragBeginFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDispatchChildPropertiesChangedFieldCallback.
noWidgetClassDispatchChildPropertiesChangedFieldCallback :: Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDispatchChildPropertiesChangedFieldCallback :: MonadIO m => WidgetClassDispatchChildPropertiesChangedFieldCallback -> m (GClosure C_WidgetClassDispatchChildPropertiesChangedFieldCallback)

-- | Wrap a WidgetClassDispatchChildPropertiesChangedFieldCallback
--   into a
--   C_WidgetClassDispatchChildPropertiesChangedFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDirectionChangedFieldCallback.
noWidgetClassDirectionChangedFieldCallback :: Maybe WidgetClassDirectionChangedFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDirectionChangedFieldCallback :: MonadIO m => WidgetClassDirectionChangedFieldCallback -> m (GClosure C_WidgetClassDirectionChangedFieldCallback)

-- | Wrap a WidgetClassDirectionChangedFieldCallback into a
--   C_WidgetClassDirectionChangedFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDestroyFieldCallback.
noWidgetClassDestroyFieldCallback :: Maybe WidgetClassDestroyFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDestroyFieldCallback :: MonadIO m => WidgetClassDestroyFieldCallback -> m (GClosure C_WidgetClassDestroyFieldCallback)

-- | Wrap a WidgetClassDestroyFieldCallback into a
--   C_WidgetClassDestroyFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDestroyEventFieldCallback.
noWidgetClassDestroyEventFieldCallback :: Maybe WidgetClassDestroyEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDestroyEventFieldCallback :: MonadIO m => WidgetClassDestroyEventFieldCallback -> m (GClosure C_WidgetClassDestroyEventFieldCallback)

-- | Wrap a WidgetClassDestroyEventFieldCallback into a
--   C_WidgetClassDestroyEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDeleteEventFieldCallback.
noWidgetClassDeleteEventFieldCallback :: Maybe WidgetClassDeleteEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDeleteEventFieldCallback :: MonadIO m => WidgetClassDeleteEventFieldCallback -> m (GClosure C_WidgetClassDeleteEventFieldCallback)

-- | Wrap a WidgetClassDeleteEventFieldCallback into a
--   C_WidgetClassDeleteEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassDamageEventFieldCallback.
noWidgetClassDamageEventFieldCallback :: Maybe WidgetClassDamageEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassDamageEventFieldCallback :: MonadIO m => WidgetClassDamageEventFieldCallback -> m (GClosure C_WidgetClassDamageEventFieldCallback)

-- | Wrap a WidgetClassDamageEventFieldCallback into a
--   C_WidgetClassDamageEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassConfigureEventFieldCallback.
noWidgetClassConfigureEventFieldCallback :: Maybe WidgetClassConfigureEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassConfigureEventFieldCallback :: MonadIO m => WidgetClassConfigureEventFieldCallback -> m (GClosure C_WidgetClassConfigureEventFieldCallback)

-- | Wrap a WidgetClassConfigureEventFieldCallback into a
--   C_WidgetClassConfigureEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassComputeExpandFieldCallback.
noWidgetClassComputeExpandFieldCallback :: Maybe WidgetClassComputeExpandFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassComputeExpandFieldCallback :: MonadIO m => WidgetClassComputeExpandFieldCallback -> m (GClosure C_WidgetClassComputeExpandFieldCallback)

-- | Wrap a WidgetClassComputeExpandFieldCallback into a
--   C_WidgetClassComputeExpandFieldCallback.
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 Nothing :: Maybe
--   WidgetClassCompositedChangedFieldCallback.
noWidgetClassCompositedChangedFieldCallback :: Maybe WidgetClassCompositedChangedFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassCompositedChangedFieldCallback :: MonadIO m => WidgetClassCompositedChangedFieldCallback -> m (GClosure C_WidgetClassCompositedChangedFieldCallback)

-- | Wrap a WidgetClassCompositedChangedFieldCallback into a
--   C_WidgetClassCompositedChangedFieldCallback.
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 Nothing :: Maybe
--   WidgetClassChildNotifyFieldCallback.
noWidgetClassChildNotifyFieldCallback :: Maybe WidgetClassChildNotifyFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassChildNotifyFieldCallback :: MonadIO m => WidgetClassChildNotifyFieldCallback -> m (GClosure C_WidgetClassChildNotifyFieldCallback)

-- | Wrap a WidgetClassChildNotifyFieldCallback into a
--   C_WidgetClassChildNotifyFieldCallback.
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 Nothing :: Maybe
--   WidgetClassCanActivateAccelFieldCallback.
noWidgetClassCanActivateAccelFieldCallback :: Maybe WidgetClassCanActivateAccelFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassCanActivateAccelFieldCallback :: MonadIO m => WidgetClassCanActivateAccelFieldCallback -> m (GClosure C_WidgetClassCanActivateAccelFieldCallback)

-- | Wrap a WidgetClassCanActivateAccelFieldCallback into a
--   C_WidgetClassCanActivateAccelFieldCallback.
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 Nothing :: Maybe
--   WidgetClassButtonReleaseEventFieldCallback.
noWidgetClassButtonReleaseEventFieldCallback :: Maybe WidgetClassButtonReleaseEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassButtonReleaseEventFieldCallback :: MonadIO m => WidgetClassButtonReleaseEventFieldCallback -> m (GClosure C_WidgetClassButtonReleaseEventFieldCallback)

-- | Wrap a WidgetClassButtonReleaseEventFieldCallback into a
--   C_WidgetClassButtonReleaseEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassButtonPressEventFieldCallback.
noWidgetClassButtonPressEventFieldCallback :: Maybe WidgetClassButtonPressEventFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassButtonPressEventFieldCallback :: MonadIO m => WidgetClassButtonPressEventFieldCallback -> m (GClosure C_WidgetClassButtonPressEventFieldCallback)

-- | Wrap a WidgetClassButtonPressEventFieldCallback into a
--   C_WidgetClassButtonPressEventFieldCallback.
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 Nothing :: Maybe
--   WidgetClassAdjustSizeRequestFieldCallback.
noWidgetClassAdjustSizeRequestFieldCallback :: Maybe WidgetClassAdjustSizeRequestFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassAdjustSizeRequestFieldCallback :: MonadIO m => WidgetClassAdjustSizeRequestFieldCallback -> m (GClosure C_WidgetClassAdjustSizeRequestFieldCallback)

-- | Wrap a WidgetClassAdjustSizeRequestFieldCallback into a
--   C_WidgetClassAdjustSizeRequestFieldCallback.
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 Nothing :: Maybe
--   WidgetClassAdjustSizeAllocationFieldCallback.
noWidgetClassAdjustSizeAllocationFieldCallback :: Maybe WidgetClassAdjustSizeAllocationFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassAdjustSizeAllocationFieldCallback :: MonadIO m => WidgetClassAdjustSizeAllocationFieldCallback -> m (GClosure C_WidgetClassAdjustSizeAllocationFieldCallback)

-- | Wrap a WidgetClassAdjustSizeAllocationFieldCallback into a
--   C_WidgetClassAdjustSizeAllocationFieldCallback.
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 Nothing :: Maybe
--   WidgetClassAdjustBaselineRequestFieldCallback.
noWidgetClassAdjustBaselineRequestFieldCallback :: Maybe WidgetClassAdjustBaselineRequestFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassAdjustBaselineRequestFieldCallback :: MonadIO m => WidgetClassAdjustBaselineRequestFieldCallback -> m (GClosure C_WidgetClassAdjustBaselineRequestFieldCallback)

-- | Wrap a WidgetClassAdjustBaselineRequestFieldCallback into a
--   C_WidgetClassAdjustBaselineRequestFieldCallback.
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 Nothing :: Maybe
--   WidgetClassAdjustBaselineAllocationFieldCallback.
noWidgetClassAdjustBaselineAllocationFieldCallback :: Maybe WidgetClassAdjustBaselineAllocationFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_WidgetClassAdjustBaselineAllocationFieldCallback :: MonadIO m => WidgetClassAdjustBaselineAllocationFieldCallback -> m (GClosure C_WidgetClassAdjustBaselineAllocationFieldCallback)

-- | Wrap a WidgetClassAdjustBaselineAllocationFieldCallback into a
--   C_WidgetClassAdjustBaselineAllocationFieldCallback.
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 Nothing :: Maybe
--   TreeViewSearchPositionFunc.
noTreeViewSearchPositionFunc :: Maybe TreeViewSearchPositionFunc

-- | A convenience synonym for Nothing :: Maybe
--   TreeViewSearchPositionFunc_WithClosures.
noTreeViewSearchPositionFunc_WithClosures :: Maybe TreeViewSearchPositionFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeViewSearchPositionFunc :: TreeViewSearchPositionFunc -> TreeViewSearchPositionFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TreeViewSearchPositionFunc :: MonadIO m => TreeViewSearchPositionFunc -> m (GClosure C_TreeViewSearchPositionFunc)

-- | Wrap a TreeViewSearchPositionFunc into a
--   C_TreeViewSearchPositionFunc.
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 Nothing :: Maybe
--   TreeViewSearchEqualFunc.
noTreeViewSearchEqualFunc :: Maybe TreeViewSearchEqualFunc

-- | A convenience synonym for Nothing :: Maybe
--   TreeViewSearchEqualFunc_WithClosures.
noTreeViewSearchEqualFunc_WithClosures :: Maybe TreeViewSearchEqualFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeViewSearchEqualFunc :: TreeViewSearchEqualFunc -> TreeViewSearchEqualFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TreeViewSearchEqualFunc :: MonadIO m => TreeViewSearchEqualFunc -> m (GClosure C_TreeViewSearchEqualFunc)

-- | Wrap a TreeViewSearchEqualFunc into a
--   C_TreeViewSearchEqualFunc.
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 Nothing :: Maybe
--   TreeViewRowSeparatorFunc.
noTreeViewRowSeparatorFunc :: Maybe TreeViewRowSeparatorFunc

-- | A convenience synonym for Nothing :: Maybe
--   TreeViewRowSeparatorFunc_WithClosures.
noTreeViewRowSeparatorFunc_WithClosures :: Maybe TreeViewRowSeparatorFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeViewRowSeparatorFunc :: TreeViewRowSeparatorFunc -> TreeViewRowSeparatorFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TreeViewRowSeparatorFunc :: MonadIO m => TreeViewRowSeparatorFunc -> m (GClosure C_TreeViewRowSeparatorFunc)

-- | Wrap a TreeViewRowSeparatorFunc into a
--   C_TreeViewRowSeparatorFunc.
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 Nothing :: Maybe
--   TreeViewMappingFunc.
noTreeViewMappingFunc :: Maybe TreeViewMappingFunc

-- | A convenience synonym for Nothing :: Maybe
--   TreeViewMappingFunc_WithClosures.
noTreeViewMappingFunc_WithClosures :: Maybe TreeViewMappingFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeViewMappingFunc :: TreeViewMappingFunc -> TreeViewMappingFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TreeViewMappingFunc :: MonadIO m => TreeViewMappingFunc -> m (GClosure C_TreeViewMappingFunc)

-- | Wrap a TreeViewMappingFunc into a C_TreeViewMappingFunc.
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 Nothing :: Maybe
--   TreeViewColumnDropFunc.
noTreeViewColumnDropFunc :: Maybe TreeViewColumnDropFunc

-- | A convenience synonym for Nothing :: Maybe
--   TreeViewColumnDropFunc_WithClosures.
noTreeViewColumnDropFunc_WithClosures :: Maybe TreeViewColumnDropFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeViewColumnDropFunc :: TreeViewColumnDropFunc -> TreeViewColumnDropFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TreeViewColumnDropFunc :: MonadIO m => TreeViewColumnDropFunc -> m (GClosure C_TreeViewColumnDropFunc)

-- | Wrap a TreeViewColumnDropFunc into a
--   C_TreeViewColumnDropFunc.
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 Nothing :: Maybe
--   TreeSelectionFunc.
noTreeSelectionFunc :: Maybe TreeSelectionFunc

-- | A convenience synonym for Nothing :: Maybe
--   TreeSelectionFunc_WithClosures.
noTreeSelectionFunc_WithClosures :: Maybe TreeSelectionFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeSelectionFunc :: TreeSelectionFunc -> TreeSelectionFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TreeSelectionFunc :: MonadIO m => TreeSelectionFunc -> m (GClosure C_TreeSelectionFunc)

-- | Wrap a TreeSelectionFunc into a C_TreeSelectionFunc.
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 Nothing :: Maybe
--   TreeSelectionForeachFunc.
noTreeSelectionForeachFunc :: Maybe TreeSelectionForeachFunc

-- | A convenience synonym for Nothing :: Maybe
--   TreeSelectionForeachFunc_WithClosures.
noTreeSelectionForeachFunc_WithClosures :: Maybe TreeSelectionForeachFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeSelectionForeachFunc :: TreeSelectionForeachFunc -> TreeSelectionForeachFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TreeSelectionForeachFunc :: MonadIO m => TreeSelectionForeachFunc -> m (GClosure C_TreeSelectionForeachFunc)

-- | Wrap a TreeSelectionForeachFunc into a
--   C_TreeSelectionForeachFunc.
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 Nothing :: Maybe
--   TreeModelForeachFunc.
noTreeModelForeachFunc :: Maybe TreeModelForeachFunc

-- | A convenience synonym for Nothing :: Maybe
--   TreeModelForeachFunc_WithClosures.
noTreeModelForeachFunc_WithClosures :: Maybe TreeModelForeachFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeModelForeachFunc :: TreeModelForeachFunc -> TreeModelForeachFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TreeModelForeachFunc :: MonadIO m => TreeModelForeachFunc -> m (GClosure C_TreeModelForeachFunc)

-- | Wrap a TreeModelForeachFunc into a
--   C_TreeModelForeachFunc.
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 Nothing :: Maybe
--   TreeModelFilterVisibleFunc.
noTreeModelFilterVisibleFunc :: Maybe TreeModelFilterVisibleFunc

-- | A convenience synonym for Nothing :: Maybe
--   TreeModelFilterVisibleFunc_WithClosures.
noTreeModelFilterVisibleFunc_WithClosures :: Maybe TreeModelFilterVisibleFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeModelFilterVisibleFunc :: TreeModelFilterVisibleFunc -> TreeModelFilterVisibleFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TreeModelFilterVisibleFunc :: MonadIO m => TreeModelFilterVisibleFunc -> m (GClosure C_TreeModelFilterVisibleFunc)

-- | Wrap a TreeModelFilterVisibleFunc into a
--   C_TreeModelFilterVisibleFunc.
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 Nothing :: Maybe
--   TreeModelFilterModifyFunc.
noTreeModelFilterModifyFunc :: Maybe TreeModelFilterModifyFunc

-- | A convenience synonym for Nothing :: Maybe
--   TreeModelFilterModifyFunc_WithClosures.
noTreeModelFilterModifyFunc_WithClosures :: Maybe TreeModelFilterModifyFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeModelFilterModifyFunc :: TreeModelFilterModifyFunc -> TreeModelFilterModifyFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TreeModelFilterModifyFunc :: MonadIO m => TreeModelFilterModifyFunc -> m (GClosure C_TreeModelFilterModifyFunc)

-- | Wrap a TreeModelFilterModifyFunc into a
--   C_TreeModelFilterModifyFunc.
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 Nothing :: Maybe
--   TreeIterCompareFunc.
noTreeIterCompareFunc :: Maybe TreeIterCompareFunc

-- | A convenience synonym for Nothing :: Maybe
--   TreeIterCompareFunc_WithClosures.
noTreeIterCompareFunc_WithClosures :: Maybe TreeIterCompareFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeIterCompareFunc :: TreeIterCompareFunc -> TreeIterCompareFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TreeIterCompareFunc :: MonadIO m => TreeIterCompareFunc -> m (GClosure C_TreeIterCompareFunc)

-- | Wrap a TreeIterCompareFunc into a C_TreeIterCompareFunc.
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 Nothing :: Maybe
--   TreeDestroyCountFunc.
noTreeDestroyCountFunc :: Maybe TreeDestroyCountFunc

-- | A convenience synonym for Nothing :: Maybe
--   TreeDestroyCountFunc_WithClosures.
noTreeDestroyCountFunc_WithClosures :: Maybe TreeDestroyCountFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeDestroyCountFunc :: TreeDestroyCountFunc -> TreeDestroyCountFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TreeDestroyCountFunc :: MonadIO m => TreeDestroyCountFunc -> m (GClosure C_TreeDestroyCountFunc)

-- | Wrap a TreeDestroyCountFunc into a
--   C_TreeDestroyCountFunc.
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 Nothing :: Maybe
--   TreeCellDataFunc.
noTreeCellDataFunc :: Maybe TreeCellDataFunc

-- | A convenience synonym for Nothing :: Maybe
--   TreeCellDataFunc_WithClosures.
noTreeCellDataFunc_WithClosures :: Maybe TreeCellDataFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeCellDataFunc :: TreeCellDataFunc -> TreeCellDataFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TreeCellDataFunc :: MonadIO m => TreeCellDataFunc -> m (GClosure C_TreeCellDataFunc)

-- | Wrap a TreeCellDataFunc into a C_TreeCellDataFunc.
wrap_TreeCellDataFunc :: Maybe (Ptr (FunPtr C_TreeCellDataFunc)) -> TreeCellDataFunc_WithClosures -> C_TreeCellDataFunc

-- | A convenience synonym for Nothing :: Maybe
--   TranslateFunc_WithClosures.
noTranslateFunc_WithClosures :: Maybe TranslateFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TranslateFunc :: TranslateFunc -> TranslateFunc_WithClosures

-- | 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 Nothing :: Maybe
--   TickCallback.
noTickCallback :: Maybe TickCallback

-- | A convenience synonym for Nothing :: Maybe
--   TickCallback_WithClosures.
noTickCallback_WithClosures :: Maybe TickCallback_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TickCallback :: TickCallback -> TickCallback_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TickCallback :: MonadIO m => TickCallback -> m (GClosure C_TickCallback)

-- | Wrap a TickCallback into a C_TickCallback.
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 Nothing :: Maybe
--   TextTagTableForeach.
noTextTagTableForeach :: Maybe TextTagTableForeach

-- | A convenience synonym for Nothing :: Maybe
--   TextTagTableForeach_WithClosures.
noTextTagTableForeach_WithClosures :: Maybe TextTagTableForeach_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TextTagTableForeach :: TextTagTableForeach -> TextTagTableForeach_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TextTagTableForeach :: MonadIO m => TextTagTableForeach -> m (GClosure C_TextTagTableForeach)

-- | Wrap a TextTagTableForeach into a C_TextTagTableForeach.
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 Nothing :: Maybe
--   TextCharPredicate.
noTextCharPredicate :: Maybe TextCharPredicate

-- | A convenience synonym for Nothing :: Maybe
--   TextCharPredicate_WithClosures.
noTextCharPredicate_WithClosures :: Maybe TextCharPredicate_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TextCharPredicate :: TextCharPredicate -> TextCharPredicate_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TextCharPredicate :: MonadIO m => TextCharPredicate -> m (GClosure C_TextCharPredicate)

-- | Wrap a TextCharPredicate into a C_TextCharPredicate.
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 Nothing :: Maybe
--   TextBufferSerializeFunc.
noTextBufferSerializeFunc :: Maybe TextBufferSerializeFunc

-- | A convenience synonym for Nothing :: Maybe
--   TextBufferSerializeFunc_WithClosures.
noTextBufferSerializeFunc_WithClosures :: Maybe TextBufferSerializeFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TextBufferSerializeFunc :: TextBufferSerializeFunc -> TextBufferSerializeFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_TextBufferSerializeFunc :: MonadIO m => TextBufferSerializeFunc -> m (GClosure C_TextBufferSerializeFunc)

-- | Wrap a TextBufferSerializeFunc into a
--   C_TextBufferSerializeFunc.
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 Nothing :: Maybe
--   TextBufferDeserializeFunc.
noTextBufferDeserializeFunc :: Maybe TextBufferDeserializeFunc

-- | A convenience synonym for Nothing :: Maybe
--   TextBufferDeserializeFunc_WithClosures.
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 Nothing :: Maybe
--   StylePropertyParser.
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 Nothing :: Maybe
--   RecentSortFunc.
noRecentSortFunc :: Maybe RecentSortFunc

-- | A convenience synonym for Nothing :: Maybe
--   RecentSortFunc_WithClosures.
noRecentSortFunc_WithClosures :: Maybe RecentSortFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RecentSortFunc :: RecentSortFunc -> RecentSortFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_RecentSortFunc :: MonadIO m => RecentSortFunc -> m (GClosure C_RecentSortFunc)

-- | Wrap a RecentSortFunc into a C_RecentSortFunc.
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 Nothing :: Maybe
--   RecentFilterFunc.
noRecentFilterFunc :: Maybe RecentFilterFunc

-- | A convenience synonym for Nothing :: Maybe
--   RecentFilterFunc_WithClosures.
noRecentFilterFunc_WithClosures :: Maybe RecentFilterFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RecentFilterFunc :: RecentFilterFunc -> RecentFilterFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_RecentFilterFunc :: MonadIO m => RecentFilterFunc -> m (GClosure C_RecentFilterFunc)

-- | Wrap a RecentFilterFunc into a C_RecentFilterFunc.
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 Nothing :: Maybe
--   RcPropertyParser.
noRcPropertyParser :: Maybe RcPropertyParser

-- | Wrap the callback into a GClosure.
genClosure_RcPropertyParser :: MonadIO m => RcPropertyParser -> m (GClosure C_RcPropertyParser)

-- | Wrap a RcPropertyParser into a C_RcPropertyParser.
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 Nothing :: Maybe
--   PrintSettingsFunc.
noPrintSettingsFunc :: Maybe PrintSettingsFunc

-- | A convenience synonym for Nothing :: Maybe
--   PrintSettingsFunc_WithClosures.
noPrintSettingsFunc_WithClosures :: Maybe PrintSettingsFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_PrintSettingsFunc :: PrintSettingsFunc -> PrintSettingsFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_PrintSettingsFunc :: MonadIO m => PrintSettingsFunc -> m (GClosure C_PrintSettingsFunc)

-- | Wrap a PrintSettingsFunc into a C_PrintSettingsFunc.
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 Nothing :: Maybe
--   PageSetupDoneFunc.
noPageSetupDoneFunc :: Maybe PageSetupDoneFunc

-- | A convenience synonym for Nothing :: Maybe
--   PageSetupDoneFunc_WithClosures.
noPageSetupDoneFunc_WithClosures :: Maybe PageSetupDoneFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_PageSetupDoneFunc :: PageSetupDoneFunc -> PageSetupDoneFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_PageSetupDoneFunc :: MonadIO m => PageSetupDoneFunc -> m (GClosure C_PageSetupDoneFunc)

-- | Wrap a PageSetupDoneFunc into a C_PageSetupDoneFunc.
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 Nothing :: Maybe
--   ModuleInitFunc.
noModuleInitFunc :: Maybe ModuleInitFunc

-- | Wrap the callback into a GClosure.
genClosure_ModuleInitFunc :: MonadIO m => ModuleInitFunc -> m (GClosure C_ModuleInitFunc)

-- | Wrap a ModuleInitFunc into a C_ModuleInitFunc.
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 Nothing :: Maybe
--   ModuleDisplayInitFunc.
noModuleDisplayInitFunc :: Maybe ModuleDisplayInitFunc

-- | Wrap the callback into a GClosure.
genClosure_ModuleDisplayInitFunc :: MonadIO m => ModuleDisplayInitFunc -> m (GClosure C_ModuleDisplayInitFunc)

-- | Wrap a ModuleDisplayInitFunc into a
--   C_ModuleDisplayInitFunc.
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 Nothing :: Maybe
--   MenuPositionFunc.
noMenuPositionFunc :: Maybe MenuPositionFunc

-- | A convenience synonym for Nothing :: Maybe
--   MenuPositionFunc_WithClosures.
noMenuPositionFunc_WithClosures :: Maybe MenuPositionFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_MenuPositionFunc :: MenuPositionFunc -> MenuPositionFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_MenuPositionFunc :: MonadIO m => MenuPositionFunc -> m (GClosure C_MenuPositionFunc)

-- | Wrap a MenuPositionFunc into a C_MenuPositionFunc.
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 Nothing :: Maybe
--   MenuDetachFunc.
noMenuDetachFunc :: Maybe MenuDetachFunc

-- | Wrap the callback into a GClosure.
genClosure_MenuDetachFunc :: MonadIO m => MenuDetachFunc -> m (GClosure C_MenuDetachFunc)

-- | Wrap a MenuDetachFunc into a C_MenuDetachFunc.
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 Nothing :: Maybe
--   ListBoxUpdateHeaderFunc.
noListBoxUpdateHeaderFunc :: Maybe ListBoxUpdateHeaderFunc

-- | A convenience synonym for Nothing :: Maybe
--   ListBoxUpdateHeaderFunc_WithClosures.
noListBoxUpdateHeaderFunc_WithClosures :: Maybe ListBoxUpdateHeaderFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxUpdateHeaderFunc :: ListBoxUpdateHeaderFunc -> ListBoxUpdateHeaderFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_ListBoxUpdateHeaderFunc :: MonadIO m => ListBoxUpdateHeaderFunc -> m (GClosure C_ListBoxUpdateHeaderFunc)

-- | Wrap a ListBoxUpdateHeaderFunc into a
--   C_ListBoxUpdateHeaderFunc.
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 Nothing :: Maybe
--   ListBoxSortFunc.
noListBoxSortFunc :: Maybe ListBoxSortFunc

-- | A convenience synonym for Nothing :: Maybe
--   ListBoxSortFunc_WithClosures.
noListBoxSortFunc_WithClosures :: Maybe ListBoxSortFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxSortFunc :: ListBoxSortFunc -> ListBoxSortFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_ListBoxSortFunc :: MonadIO m => ListBoxSortFunc -> m (GClosure C_ListBoxSortFunc)

-- | Wrap a ListBoxSortFunc into a C_ListBoxSortFunc.
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 Nothing :: Maybe
--   ListBoxForeachFunc.
noListBoxForeachFunc :: Maybe ListBoxForeachFunc

-- | A convenience synonym for Nothing :: Maybe
--   ListBoxForeachFunc_WithClosures.
noListBoxForeachFunc_WithClosures :: Maybe ListBoxForeachFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxForeachFunc :: ListBoxForeachFunc -> ListBoxForeachFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_ListBoxForeachFunc :: MonadIO m => ListBoxForeachFunc -> m (GClosure C_ListBoxForeachFunc)

-- | Wrap a ListBoxForeachFunc into a C_ListBoxForeachFunc.
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 Nothing :: Maybe
--   ListBoxFilterFunc.
noListBoxFilterFunc :: Maybe ListBoxFilterFunc

-- | A convenience synonym for Nothing :: Maybe
--   ListBoxFilterFunc_WithClosures.
noListBoxFilterFunc_WithClosures :: Maybe ListBoxFilterFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxFilterFunc :: ListBoxFilterFunc -> ListBoxFilterFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_ListBoxFilterFunc :: MonadIO m => ListBoxFilterFunc -> m (GClosure C_ListBoxFilterFunc)

-- | Wrap a ListBoxFilterFunc into a C_ListBoxFilterFunc.
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 Nothing :: Maybe
--   ListBoxCreateWidgetFunc.
noListBoxCreateWidgetFunc :: Maybe ListBoxCreateWidgetFunc

-- | A convenience synonym for Nothing :: Maybe
--   ListBoxCreateWidgetFunc_WithClosures.
noListBoxCreateWidgetFunc_WithClosures :: Maybe ListBoxCreateWidgetFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxCreateWidgetFunc :: ListBoxCreateWidgetFunc -> ListBoxCreateWidgetFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_ListBoxCreateWidgetFunc :: MonadIO m => ListBoxCreateWidgetFunc -> m (GClosure C_ListBoxCreateWidgetFunc)

-- | Wrap a ListBoxCreateWidgetFunc into a
--   C_ListBoxCreateWidgetFunc.
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 Nothing :: Maybe
--   KeySnoopFunc.
noKeySnoopFunc :: Maybe KeySnoopFunc

-- | A convenience synonym for Nothing :: Maybe
--   KeySnoopFunc_WithClosures.
noKeySnoopFunc_WithClosures :: Maybe KeySnoopFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_KeySnoopFunc :: KeySnoopFunc -> KeySnoopFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_KeySnoopFunc :: MonadIO m => KeySnoopFunc -> m (GClosure C_KeySnoopFunc)

-- | Wrap a KeySnoopFunc into a C_KeySnoopFunc.
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 Nothing :: Maybe
--   IconViewForeachFunc.
noIconViewForeachFunc :: Maybe IconViewForeachFunc

-- | A convenience synonym for Nothing :: Maybe
--   IconViewForeachFunc_WithClosures.
noIconViewForeachFunc_WithClosures :: Maybe IconViewForeachFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_IconViewForeachFunc :: IconViewForeachFunc -> IconViewForeachFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_IconViewForeachFunc :: MonadIO m => IconViewForeachFunc -> m (GClosure C_IconViewForeachFunc)

-- | Wrap a IconViewForeachFunc into a C_IconViewForeachFunc.
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 Nothing :: Maybe
--   FontFilterFunc.
noFontFilterFunc :: Maybe FontFilterFunc

-- | A convenience synonym for Nothing :: Maybe
--   FontFilterFunc_WithClosures.
noFontFilterFunc_WithClosures :: Maybe FontFilterFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FontFilterFunc :: FontFilterFunc -> FontFilterFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_FontFilterFunc :: MonadIO m => FontFilterFunc -> m (GClosure C_FontFilterFunc)

-- | Wrap a FontFilterFunc into a C_FontFilterFunc.
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 Nothing :: Maybe
--   FlowBoxSortFunc.
noFlowBoxSortFunc :: Maybe FlowBoxSortFunc

-- | A convenience synonym for Nothing :: Maybe
--   FlowBoxSortFunc_WithClosures.
noFlowBoxSortFunc_WithClosures :: Maybe FlowBoxSortFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FlowBoxSortFunc :: FlowBoxSortFunc -> FlowBoxSortFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_FlowBoxSortFunc :: MonadIO m => FlowBoxSortFunc -> m (GClosure C_FlowBoxSortFunc)

-- | Wrap a FlowBoxSortFunc into a C_FlowBoxSortFunc.
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 Nothing :: Maybe
--   FlowBoxForeachFunc.
noFlowBoxForeachFunc :: Maybe FlowBoxForeachFunc

-- | A convenience synonym for Nothing :: Maybe
--   FlowBoxForeachFunc_WithClosures.
noFlowBoxForeachFunc_WithClosures :: Maybe FlowBoxForeachFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FlowBoxForeachFunc :: FlowBoxForeachFunc -> FlowBoxForeachFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_FlowBoxForeachFunc :: MonadIO m => FlowBoxForeachFunc -> m (GClosure C_FlowBoxForeachFunc)

-- | Wrap a FlowBoxForeachFunc into a C_FlowBoxForeachFunc.
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 Nothing :: Maybe
--   FlowBoxFilterFunc.
noFlowBoxFilterFunc :: Maybe FlowBoxFilterFunc

-- | A convenience synonym for Nothing :: Maybe
--   FlowBoxFilterFunc_WithClosures.
noFlowBoxFilterFunc_WithClosures :: Maybe FlowBoxFilterFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FlowBoxFilterFunc :: FlowBoxFilterFunc -> FlowBoxFilterFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_FlowBoxFilterFunc :: MonadIO m => FlowBoxFilterFunc -> m (GClosure C_FlowBoxFilterFunc)

-- | Wrap a FlowBoxFilterFunc into a C_FlowBoxFilterFunc.
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 Nothing :: Maybe
--   FlowBoxCreateWidgetFunc.
noFlowBoxCreateWidgetFunc :: Maybe FlowBoxCreateWidgetFunc

-- | A convenience synonym for Nothing :: Maybe
--   FlowBoxCreateWidgetFunc_WithClosures.
noFlowBoxCreateWidgetFunc_WithClosures :: Maybe FlowBoxCreateWidgetFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FlowBoxCreateWidgetFunc :: FlowBoxCreateWidgetFunc -> FlowBoxCreateWidgetFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_FlowBoxCreateWidgetFunc :: MonadIO m => FlowBoxCreateWidgetFunc -> m (GClosure C_FlowBoxCreateWidgetFunc)

-- | Wrap a FlowBoxCreateWidgetFunc into a
--   C_FlowBoxCreateWidgetFunc.
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 Nothing :: Maybe
--   FileFilterFunc.
noFileFilterFunc :: Maybe FileFilterFunc

-- | A convenience synonym for Nothing :: Maybe
--   FileFilterFunc_WithClosures.
noFileFilterFunc_WithClosures :: Maybe FileFilterFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FileFilterFunc :: FileFilterFunc -> FileFilterFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_FileFilterFunc :: MonadIO m => FileFilterFunc -> m (GClosure C_FileFilterFunc)

-- | Wrap a FileFilterFunc into a C_FileFilterFunc.
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 Nothing :: Maybe
--   EntryCompletionMatchFunc.
noEntryCompletionMatchFunc :: Maybe EntryCompletionMatchFunc

-- | A convenience synonym for Nothing :: Maybe
--   EntryCompletionMatchFunc_WithClosures.
noEntryCompletionMatchFunc_WithClosures :: Maybe EntryCompletionMatchFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_EntryCompletionMatchFunc :: EntryCompletionMatchFunc -> EntryCompletionMatchFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_EntryCompletionMatchFunc :: MonadIO m => EntryCompletionMatchFunc -> m (GClosure C_EntryCompletionMatchFunc)

-- | Wrap a EntryCompletionMatchFunc into a
--   C_EntryCompletionMatchFunc.
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 Nothing :: Maybe
--   ContainerClassSetFocusChildFieldCallback.
noContainerClassSetFocusChildFieldCallback :: Maybe ContainerClassSetFocusChildFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_ContainerClassSetFocusChildFieldCallback :: MonadIO m => ContainerClassSetFocusChildFieldCallback -> m (GClosure C_ContainerClassSetFocusChildFieldCallback)

-- | Wrap a ContainerClassSetFocusChildFieldCallback into a
--   C_ContainerClassSetFocusChildFieldCallback.
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 Nothing :: Maybe
--   ContainerClassSetChildPropertyFieldCallback.
noContainerClassSetChildPropertyFieldCallback :: Maybe ContainerClassSetChildPropertyFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_ContainerClassSetChildPropertyFieldCallback :: MonadIO m => ContainerClassSetChildPropertyFieldCallback -> m (GClosure C_ContainerClassSetChildPropertyFieldCallback)

-- | Wrap a ContainerClassSetChildPropertyFieldCallback into a
--   C_ContainerClassSetChildPropertyFieldCallback.
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 Nothing :: Maybe
--   ContainerClassRemoveFieldCallback.
noContainerClassRemoveFieldCallback :: Maybe ContainerClassRemoveFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_ContainerClassRemoveFieldCallback :: MonadIO m => ContainerClassRemoveFieldCallback -> m (GClosure C_ContainerClassRemoveFieldCallback)

-- | Wrap a ContainerClassRemoveFieldCallback into a
--   C_ContainerClassRemoveFieldCallback.
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 Nothing :: Maybe
--   ContainerClassGetPathForChildFieldCallback.
noContainerClassGetPathForChildFieldCallback :: Maybe ContainerClassGetPathForChildFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_ContainerClassGetPathForChildFieldCallback :: MonadIO m => ContainerClassGetPathForChildFieldCallback -> m (GClosure C_ContainerClassGetPathForChildFieldCallback)

-- | Wrap a ContainerClassGetPathForChildFieldCallback into a
--   C_ContainerClassGetPathForChildFieldCallback.
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 Nothing :: Maybe
--   ContainerClassGetChildPropertyFieldCallback.
noContainerClassGetChildPropertyFieldCallback :: Maybe ContainerClassGetChildPropertyFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_ContainerClassGetChildPropertyFieldCallback :: MonadIO m => ContainerClassGetChildPropertyFieldCallback -> m (GClosure C_ContainerClassGetChildPropertyFieldCallback)

-- | Wrap a ContainerClassGetChildPropertyFieldCallback into a
--   C_ContainerClassGetChildPropertyFieldCallback.
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 Nothing :: Maybe
--   ContainerClassForallFieldCallback.
noContainerClassForallFieldCallback :: Maybe ContainerClassForallFieldCallback

-- | A convenience synonym for Nothing :: Maybe
--   ContainerClassForallFieldCallback_WithClosures.
noContainerClassForallFieldCallback_WithClosures :: Maybe ContainerClassForallFieldCallback_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ContainerClassForallFieldCallback :: ContainerClassForallFieldCallback -> ContainerClassForallFieldCallback_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_ContainerClassForallFieldCallback :: MonadIO m => ContainerClassForallFieldCallback -> m (GClosure C_ContainerClassForallFieldCallback)

-- | Wrap a ContainerClassForallFieldCallback into a
--   C_ContainerClassForallFieldCallback.
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 Nothing :: Maybe
--   ContainerClassCompositeNameFieldCallback.
noContainerClassCompositeNameFieldCallback :: Maybe ContainerClassCompositeNameFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_ContainerClassCompositeNameFieldCallback :: MonadIO m => ContainerClassCompositeNameFieldCallback -> m (GClosure C_ContainerClassCompositeNameFieldCallback)

-- | Wrap a ContainerClassCompositeNameFieldCallback into a
--   C_ContainerClassCompositeNameFieldCallback.
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 Nothing :: Maybe
--   ContainerClassChildTypeFieldCallback.
noContainerClassChildTypeFieldCallback :: Maybe ContainerClassChildTypeFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_ContainerClassChildTypeFieldCallback :: MonadIO m => ContainerClassChildTypeFieldCallback -> m (GClosure C_ContainerClassChildTypeFieldCallback)

-- | Wrap a ContainerClassChildTypeFieldCallback into a
--   C_ContainerClassChildTypeFieldCallback.
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 Nothing :: Maybe
--   ContainerClassCheckResizeFieldCallback.
noContainerClassCheckResizeFieldCallback :: Maybe ContainerClassCheckResizeFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_ContainerClassCheckResizeFieldCallback :: MonadIO m => ContainerClassCheckResizeFieldCallback -> m (GClosure C_ContainerClassCheckResizeFieldCallback)

-- | Wrap a ContainerClassCheckResizeFieldCallback into a
--   C_ContainerClassCheckResizeFieldCallback.
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 Nothing :: Maybe
--   ContainerClassAddFieldCallback.
noContainerClassAddFieldCallback :: Maybe ContainerClassAddFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_ContainerClassAddFieldCallback :: MonadIO m => ContainerClassAddFieldCallback -> m (GClosure C_ContainerClassAddFieldCallback)

-- | Wrap a ContainerClassAddFieldCallback into a
--   C_ContainerClassAddFieldCallback.
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 Nothing :: Maybe
--   ColorSelectionChangePaletteWithScreenFunc.
noColorSelectionChangePaletteWithScreenFunc :: Maybe ColorSelectionChangePaletteWithScreenFunc

-- | Wrap the callback into a GClosure.
genClosure_ColorSelectionChangePaletteWithScreenFunc :: MonadIO m => ColorSelectionChangePaletteWithScreenFunc -> m (GClosure C_ColorSelectionChangePaletteWithScreenFunc)

-- | Wrap a ColorSelectionChangePaletteWithScreenFunc into a
--   C_ColorSelectionChangePaletteWithScreenFunc.
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 Nothing :: Maybe
--   ColorSelectionChangePaletteFunc.
noColorSelectionChangePaletteFunc :: Maybe ColorSelectionChangePaletteFunc

-- | Wrap the callback into a GClosure.
genClosure_ColorSelectionChangePaletteFunc :: MonadIO m => ColorSelectionChangePaletteFunc -> m (GClosure C_ColorSelectionChangePaletteFunc)

-- | Wrap a ColorSelectionChangePaletteFunc into a
--   C_ColorSelectionChangePaletteFunc.
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 Nothing :: Maybe
--   ClipboardURIReceivedFunc.
noClipboardURIReceivedFunc :: Maybe ClipboardURIReceivedFunc

-- | A convenience synonym for Nothing :: Maybe
--   ClipboardURIReceivedFunc_WithClosures.
noClipboardURIReceivedFunc_WithClosures :: Maybe ClipboardURIReceivedFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClipboardURIReceivedFunc :: ClipboardURIReceivedFunc -> ClipboardURIReceivedFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_ClipboardURIReceivedFunc :: MonadIO m => ClipboardURIReceivedFunc -> m (GClosure C_ClipboardURIReceivedFunc)

-- | Wrap a ClipboardURIReceivedFunc into a
--   C_ClipboardURIReceivedFunc.
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 Nothing :: Maybe
--   ClipboardTextReceivedFunc.
noClipboardTextReceivedFunc :: Maybe ClipboardTextReceivedFunc

-- | A convenience synonym for Nothing :: Maybe
--   ClipboardTextReceivedFunc_WithClosures.
noClipboardTextReceivedFunc_WithClosures :: Maybe ClipboardTextReceivedFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClipboardTextReceivedFunc :: ClipboardTextReceivedFunc -> ClipboardTextReceivedFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_ClipboardTextReceivedFunc :: MonadIO m => ClipboardTextReceivedFunc -> m (GClosure C_ClipboardTextReceivedFunc)

-- | Wrap a ClipboardTextReceivedFunc into a
--   C_ClipboardTextReceivedFunc.
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 Nothing :: Maybe
--   ClipboardTargetsReceivedFunc.
noClipboardTargetsReceivedFunc :: Maybe ClipboardTargetsReceivedFunc

-- | A convenience synonym for Nothing :: Maybe
--   ClipboardTargetsReceivedFunc_WithClosures.
noClipboardTargetsReceivedFunc_WithClosures :: Maybe ClipboardTargetsReceivedFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClipboardTargetsReceivedFunc :: ClipboardTargetsReceivedFunc -> ClipboardTargetsReceivedFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_ClipboardTargetsReceivedFunc :: MonadIO m => ClipboardTargetsReceivedFunc -> m (GClosure C_ClipboardTargetsReceivedFunc)

-- | Wrap a ClipboardTargetsReceivedFunc into a
--   C_ClipboardTargetsReceivedFunc.
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 Nothing :: Maybe
--   ClipboardRichTextReceivedFunc.
noClipboardRichTextReceivedFunc :: Maybe ClipboardRichTextReceivedFunc

-- | A convenience synonym for Nothing :: Maybe
--   ClipboardRichTextReceivedFunc_WithClosures.
noClipboardRichTextReceivedFunc_WithClosures :: Maybe ClipboardRichTextReceivedFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClipboardRichTextReceivedFunc :: ClipboardRichTextReceivedFunc -> ClipboardRichTextReceivedFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_ClipboardRichTextReceivedFunc :: MonadIO m => ClipboardRichTextReceivedFunc -> m (GClosure C_ClipboardRichTextReceivedFunc)

-- | Wrap a ClipboardRichTextReceivedFunc into a
--   C_ClipboardRichTextReceivedFunc.
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 Nothing :: Maybe
--   ClipboardReceivedFunc.
noClipboardReceivedFunc :: Maybe ClipboardReceivedFunc

-- | A convenience synonym for Nothing :: Maybe
--   ClipboardReceivedFunc_WithClosures.
noClipboardReceivedFunc_WithClosures :: Maybe ClipboardReceivedFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClipboardReceivedFunc :: ClipboardReceivedFunc -> ClipboardReceivedFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_ClipboardReceivedFunc :: MonadIO m => ClipboardReceivedFunc -> m (GClosure C_ClipboardReceivedFunc)

-- | Wrap a ClipboardReceivedFunc into a
--   C_ClipboardReceivedFunc.
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 Nothing :: Maybe
--   ClipboardImageReceivedFunc.
noClipboardImageReceivedFunc :: Maybe ClipboardImageReceivedFunc

-- | A convenience synonym for Nothing :: Maybe
--   ClipboardImageReceivedFunc_WithClosures.
noClipboardImageReceivedFunc_WithClosures :: Maybe ClipboardImageReceivedFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClipboardImageReceivedFunc :: ClipboardImageReceivedFunc -> ClipboardImageReceivedFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_ClipboardImageReceivedFunc :: MonadIO m => ClipboardImageReceivedFunc -> m (GClosure C_ClipboardImageReceivedFunc)

-- | Wrap a ClipboardImageReceivedFunc into a
--   C_ClipboardImageReceivedFunc.
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 Nothing :: Maybe
--   ClipboardGetFunc.
noClipboardGetFunc :: Maybe ClipboardGetFunc

-- | Wrap the callback into a GClosure.
genClosure_ClipboardGetFunc :: MonadIO m => ClipboardGetFunc -> m (GClosure C_ClipboardGetFunc)

-- | Wrap a ClipboardGetFunc into a C_ClipboardGetFunc.
wrap_ClipboardGetFunc :: Maybe (Ptr (FunPtr C_ClipboardGetFunc)) -> ClipboardGetFunc -> 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 Nothing :: Maybe
--   ClipboardClearFunc.
noClipboardClearFunc :: Maybe ClipboardClearFunc

-- | Wrap the callback into a GClosure.
genClosure_ClipboardClearFunc :: MonadIO m => ClipboardClearFunc -> m (GClosure C_ClipboardClearFunc)

-- | Wrap a ClipboardClearFunc into a C_ClipboardClearFunc.
wrap_ClipboardClearFunc :: Maybe (Ptr (FunPtr C_ClipboardClearFunc)) -> ClipboardClearFunc -> 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 Nothing :: Maybe
--   CellLayoutDataFunc.
noCellLayoutDataFunc :: Maybe CellLayoutDataFunc

-- | A convenience synonym for Nothing :: Maybe
--   CellLayoutDataFunc_WithClosures.
noCellLayoutDataFunc_WithClosures :: Maybe CellLayoutDataFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_CellLayoutDataFunc :: CellLayoutDataFunc -> CellLayoutDataFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_CellLayoutDataFunc :: MonadIO m => CellLayoutDataFunc -> m (GClosure C_CellLayoutDataFunc)

-- | Wrap a CellLayoutDataFunc into a C_CellLayoutDataFunc.
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 Nothing :: Maybe
--   CellCallback.
noCellCallback :: Maybe CellCallback

-- | A convenience synonym for Nothing :: Maybe
--   CellCallback_WithClosures.
noCellCallback_WithClosures :: Maybe CellCallback_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_CellCallback :: CellCallback -> CellCallback_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_CellCallback :: MonadIO m => CellCallback -> m (GClosure C_CellCallback)

-- | Wrap a CellCallback into a C_CellCallback.
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 Nothing :: Maybe
--   CellAllocCallback.
noCellAllocCallback :: Maybe CellAllocCallback

-- | A convenience synonym for Nothing :: Maybe
--   CellAllocCallback_WithClosures.
noCellAllocCallback_WithClosures :: Maybe CellAllocCallback_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_CellAllocCallback :: CellAllocCallback -> CellAllocCallback_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_CellAllocCallback :: MonadIO m => CellAllocCallback -> m (GClosure C_CellAllocCallback)

-- | Wrap a CellAllocCallback into a C_CellAllocCallback.
wrap_CellAllocCallback :: Maybe (Ptr (FunPtr C_CellAllocCallback)) -> CellAllocCallback_WithClosures -> C_CellAllocCallback

-- | A convenience synonym for Nothing :: Maybe
--   Callback_WithClosures.
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 Nothing :: Maybe
--   CalendarDetailFunc.
noCalendarDetailFunc :: Maybe CalendarDetailFunc

-- | A convenience synonym for Nothing :: Maybe
--   CalendarDetailFunc_WithClosures.
noCalendarDetailFunc_WithClosures :: Maybe CalendarDetailFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_CalendarDetailFunc :: CalendarDetailFunc -> CalendarDetailFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_CalendarDetailFunc :: MonadIO m => CalendarDetailFunc -> m (GClosure C_CalendarDetailFunc)

-- | Wrap a CalendarDetailFunc into a C_CalendarDetailFunc.
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 Nothing :: Maybe
--   BuilderConnectFunc.
noBuilderConnectFunc :: Maybe BuilderConnectFunc

-- | A convenience synonym for Nothing :: Maybe
--   BuilderConnectFunc_WithClosures.
noBuilderConnectFunc_WithClosures :: Maybe BuilderConnectFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_BuilderConnectFunc :: BuilderConnectFunc -> BuilderConnectFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_BuilderConnectFunc :: MonadIO m => BuilderConnectFunc -> m (GClosure C_BuilderConnectFunc)

-- | Wrap a BuilderConnectFunc into a C_BuilderConnectFunc.
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 Nothing :: Maybe
--   AssistantPageFunc.
noAssistantPageFunc :: Maybe AssistantPageFunc

-- | A convenience synonym for Nothing :: Maybe
--   AssistantPageFunc_WithClosures.
noAssistantPageFunc_WithClosures :: Maybe AssistantPageFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_AssistantPageFunc :: AssistantPageFunc -> AssistantPageFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_AssistantPageFunc :: MonadIO m => AssistantPageFunc -> m (GClosure C_AssistantPageFunc)

-- | Wrap a AssistantPageFunc into a C_AssistantPageFunc.
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 Nothing :: Maybe
--   ActionableInterfaceSetActionTargetValueFieldCallback.
noActionableInterfaceSetActionTargetValueFieldCallback :: Maybe ActionableInterfaceSetActionTargetValueFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_ActionableInterfaceSetActionTargetValueFieldCallback :: MonadIO m => ActionableInterfaceSetActionTargetValueFieldCallback -> m (GClosure C_ActionableInterfaceSetActionTargetValueFieldCallback)

-- | Wrap a ActionableInterfaceSetActionTargetValueFieldCallback
--   into a C_ActionableInterfaceSetActionTargetValueFieldCallback.
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 Nothing :: Maybe
--   ActionableInterfaceSetActionNameFieldCallback.
noActionableInterfaceSetActionNameFieldCallback :: Maybe ActionableInterfaceSetActionNameFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_ActionableInterfaceSetActionNameFieldCallback :: MonadIO m => ActionableInterfaceSetActionNameFieldCallback -> m (GClosure C_ActionableInterfaceSetActionNameFieldCallback)

-- | Wrap a ActionableInterfaceSetActionNameFieldCallback into a
--   C_ActionableInterfaceSetActionNameFieldCallback.
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 Nothing :: Maybe
--   ActionableInterfaceGetActionTargetValueFieldCallback.
noActionableInterfaceGetActionTargetValueFieldCallback :: Maybe ActionableInterfaceGetActionTargetValueFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_ActionableInterfaceGetActionTargetValueFieldCallback :: MonadIO m => ActionableInterfaceGetActionTargetValueFieldCallback -> m (GClosure C_ActionableInterfaceGetActionTargetValueFieldCallback)

-- | Wrap a ActionableInterfaceGetActionTargetValueFieldCallback
--   into a C_ActionableInterfaceGetActionTargetValueFieldCallback.
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 Nothing :: Maybe
--   ActionableInterfaceGetActionNameFieldCallback.
noActionableInterfaceGetActionNameFieldCallback :: Maybe ActionableInterfaceGetActionNameFieldCallback

-- | Wrap the callback into a GClosure.
genClosure_ActionableInterfaceGetActionNameFieldCallback :: MonadIO m => ActionableInterfaceGetActionNameFieldCallback -> m (GClosure C_ActionableInterfaceGetActionNameFieldCallback)

-- | Wrap a ActionableInterfaceGetActionNameFieldCallback into a
--   C_ActionableInterfaceGetActionNameFieldCallback.
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 Nothing :: Maybe
--   AccelMapForeach.
noAccelMapForeach :: Maybe AccelMapForeach

-- | Wrap the callback into a GClosure.
genClosure_AccelMapForeach :: MonadIO m => AccelMapForeach -> m (GClosure C_AccelMapForeach)

-- | Wrap a AccelMapForeach into a C_AccelMapForeach.
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 Nothing :: Maybe
--   AccelGroupFindFunc.
noAccelGroupFindFunc :: Maybe AccelGroupFindFunc

-- | A convenience synonym for Nothing :: Maybe
--   AccelGroupFindFunc_WithClosures.
noAccelGroupFindFunc_WithClosures :: Maybe AccelGroupFindFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_AccelGroupFindFunc :: AccelGroupFindFunc -> AccelGroupFindFunc_WithClosures

-- | Wrap the callback into a GClosure.
genClosure_AccelGroupFindFunc :: MonadIO m => AccelGroupFindFunc -> m (GClosure C_AccelGroupFindFunc)

-- | Wrap a AccelGroupFindFunc into a C_AccelGroupFindFunc.
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 Nothing :: Maybe
--   AccelGroupActivate.
noAccelGroupActivate :: Maybe AccelGroupActivate

-- | Wrap the callback into a GClosure.
genClosure_AccelGroupActivate :: MonadIO m => AccelGroupActivate -> m (GClosure C_AccelGroupActivate)

-- | Wrap a AccelGroupActivate into a C_AccelGroupActivate.
wrap_AccelGroupActivate :: Maybe (Ptr (FunPtr C_AccelGroupActivate)) -> AccelGroupActivate -> C_AccelGroupActivate

-- | Returns an empty widget path.
--   
--   Since: 3.0
widgetPathNew :: (HasCallStack, MonadIO m) => m WidgetPath

-- | Appends the data from widget to the widget hierarchy
--   represented by path. This function is a shortcut for
--   adding information from widget to the given
--   path. This includes setting the name or adding the
--   style classes from widget.
--   
--   Since: 3.2
widgetPathAppendForWidget :: (HasCallStack, MonadIO m, IsWidget a) => WidgetPath -> a -> m Int32

-- | Appends a widget type with all its siblings to the widget hierarchy
--   represented by path. Using this function instead of
--   widgetPathAppendType will allow the CSS theming to use sibling
--   matches in selectors and apply :nth-child() pseudo
--   classes. In turn, it requires a lot more care in widget
--   implementations as widgets need to make sure to call
--   widgetResetStyle on all involved widgets when the
--   siblings path changes.
--   
--   Since: 3.2
widgetPathAppendWithSiblings :: (HasCallStack, MonadIO m) => WidgetPath -> WidgetPath -> Word32 -> m Int32

-- | Returns a copy of path
--   
--   Since: 3.0
widgetPathCopy :: (HasCallStack, MonadIO m) => WidgetPath -> m WidgetPath

-- | Decrements the reference count on path, freeing the
--   structure if the reference count reaches 0.
--   
--   Since: 3.0
widgetPathFree :: (HasCallStack, MonadIO m) => WidgetPath -> m ()

-- | Returns the topmost object type, that is, the object type this path is
--   representing.
--   
--   Since: 3.0
widgetPathGetObjectType :: (HasCallStack, MonadIO m) => WidgetPath -> m GType

-- | Returns True if any of the parents of the widget represented in
--   path is of type type, or any subtype
--   of it.
--   
--   Since: 3.0
widgetPathHasParent :: (HasCallStack, MonadIO m) => WidgetPath -> GType -> m Bool

-- | Returns True if the widget type represented by this path is
--   type, or a subtype of it.
--   
--   Since: 3.0
widgetPathIsType :: (HasCallStack, MonadIO m) => WidgetPath -> GType -> m Bool

-- | Adds the class name to the widget at position
--   pos in the hierarchy defined in path.
--   See styleContextAddClass.
--   
--   Since: 3.0
widgetPathIterAddClass :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m ()

-- | Adds the region name to the widget at position
--   pos in the hierarchy defined in path.
--   See styleContextAddRegion.
--   
--   Region names must only contain lowercase letters and “-”, starting
--   always with a lowercase letter.
--   
--   Since: 3.0
widgetPathIterAddRegion :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> [RegionFlags] -> m ()

-- | Removes all classes from the widget at position pos in
--   the hierarchy defined in path.
--   
--   Since: 3.0
widgetPathIterClearClasses :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m ()

-- | Removes all regions from the widget at position pos in
--   the hierarchy defined in path.
--   
--   Since: 3.0
widgetPathIterClearRegions :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m ()

-- | Returns the name corresponding to the widget found at the position
--   pos in the widget hierarchy defined by
--   path
widgetPathIterGetName :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m (Maybe Text)

-- | Returns the object name that is at position pos in the
--   widget hierarchy defined in path.
--   
--   Since: 3.20
widgetPathIterGetObjectName :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m (Maybe Text)

-- | Returns the object GType that is at position
--   pos in the widget hierarchy defined in
--   path.
--   
--   Since: 3.0
widgetPathIterGetObjectType :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m GType

-- | Returns the index into the list of siblings for the element at
--   pos as returned by widgetPathIterGetSiblings.
--   If that function would return Nothing because the element at
--   pos has no siblings, this function will return 0.
widgetPathIterGetSiblingIndex :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m Word32

-- | Returns the state flags corresponding to the widget found at the
--   position pos in the widget hierarchy defined by
--   path
--   
--   Since: 3.14
widgetPathIterGetState :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m [StateFlags]

-- | See widgetPathIterHasClass. This is a version that operates
--   with GQuarks.
--   
--   Since: 3.0
widgetPathIterHasQclass :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Word32 -> m Bool

-- | See widgetPathIterHasName. This is a version that operates on
--   GQuarks.
--   
--   Since: 3.0
widgetPathIterHasQname :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Word32 -> m Bool

-- | See widgetPathIterHasRegion. This is a version that operates
--   with GQuarks.
--   
--   Since: 3.0
widgetPathIterHasQregion :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Word32 -> m (Bool, [RegionFlags])

-- | Returns a list with all the class names defined for the widget at
--   position pos in the hierarchy defined in
--   path.
--   
--   Since: 3.0
widgetPathIterListClasses :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m [Text]

-- | Returns a list with all the region names defined for the widget at
--   position pos in the hierarchy defined in
--   path.
--   
--   Since: 3.0
widgetPathIterListRegions :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m [Text]

-- | Removes the class name from the widget at position
--   pos in the hierarchy defined in path.
--   
--   Since: 3.0
widgetPathIterRemoveClass :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m ()

-- | Removes the region name from the widget at position
--   pos in the hierarchy defined in path.
--   
--   Since: 3.0
widgetPathIterRemoveRegion :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m ()

-- | Sets the widget name for the widget found at position
--   pos in the widget hierarchy defined by
--   path.
--   
--   Since: 3.0
widgetPathIterSetName :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m ()

-- | Sets the object name for a given position in the widget hierarchy
--   defined by path.
--   
--   When set, the object name overrides the object type when matching CSS.
--   
--   Since: 3.20
widgetPathIterSetObjectName :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Maybe Text -> m ()

-- | Sets the object type for a given position in the widget hierarchy
--   defined by path.
--   
--   Since: 3.0
widgetPathIterSetObjectType :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> GType -> m ()

-- | Sets the widget name for the widget found at position
--   pos in the widget hierarchy defined by
--   path.
--   
--   If you want to update just a single state flag, you need to do this
--   manually, as this function updates all state flags.
--   
--   
Setting a flag
--   
--   
C code
--   
--   
--   gtk_widget_path_iter_set_state (path, pos, gtk_widget_path_iter_get_state (path, pos) | flag);
--   
--   
--   
Unsetting a flag
--   
--   
C code
--   
--   
--   gtk_widget_path_iter_set_state (path, pos, gtk_widget_path_iter_get_state (path, pos) & ~flag);
--   
--   
--   Since: 3.14
widgetPathIterSetState :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> [StateFlags] -> m ()

-- | Returns the number of Widget GTypes between the
--   represented widget and its topmost container.
--   
--   Since: 3.0
widgetPathLength :: (HasCallStack, MonadIO m) => WidgetPath -> m Int32

-- | Prepends a widget type to the widget hierachy represented by
--   path.
--   
--   Since: 3.0
widgetPathPrependType :: (HasCallStack, MonadIO m) => WidgetPath -> GType -> m ()

-- | Increments the reference count on path.
--   
--   Since: 3.2
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
--   g_print() the path or dump it in a gdb session.
--   
--   Since: 3.2
widgetPathToString :: (HasCallStack, MonadIO m) => WidgetPath -> m Text

-- | Decrements the reference count on path, freeing the
--   structure if the reference count reaches 0.
--   
--   Since: 3.2
widgetPathUnref :: (HasCallStack, MonadIO m) => WidgetPath -> m ()

-- | Construct a TextIter struct initialized to zero.
newZeroTextIter :: MonadIO m => m TextIter

-- | Assigns the value of other to iter.
--   This function is not useful in applications, because iterators can be
--   assigned with GtkTextIter i = j;. The function is used by
--   language bindings.
--   
--   Since: 3.2
textIterAssign :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m ()

-- | Moves count characters backward, if possible (if
--   count 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
--   False is returned. If count is 0, the function
--   does nothing and returns False.
textIterBackwardChars :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves up to count cursor positions. See
--   textIterForwardCursorPosition for details.
textIterBackwardCursorPositions :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Same as textIterForwardFindChar, but goes backward from
--   iter.
textIterBackwardFindChar :: (HasCallStack, MonadIO m) => TextIter -> TextCharPredicate -> Maybe TextIter -> m Bool

-- | Moves iter to the start of the previous line. Returns
--   True if iter could be moved; i.e. if
--   iter was at character offset 0, this function returns
--   False. Therefore if iter was already on line 0,
--   but not at the start of the line, iter is snapped to
--   the start of the line and the function returns True. (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 count lines backward, if possible (if
--   count 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
--   False is returned. If count is 0, the function
--   does nothing and returns False. If count is
--   negative, moves forward by 0 - count lines.
textIterBackwardLines :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Same as textIterForwardSearch, but moves backward.
--   
--   matchEnd will never be set to a TextIter
--   located after iter, even if there is a possible
--   matchStart before or at iter.
textIterBackwardSearch :: (HasCallStack, MonadIO m) => TextIter -> Text -> [TextSearchFlags] -> Maybe TextIter -> m (Bool, TextIter, TextIter)

-- | Calls textIterBackwardSentenceStart up to count
--   times, or until it returns False. If count 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 TextTag
--   tag, or to the next toggle of any tag if
--   tag is Nothing. If no matching tag toggles are
--   found, returns False, otherwise True. Does not return
--   toggles located at iter, only toggles before
--   iter. Sets iter 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 iter forward to the previous visible cursor
--   position. See textIterBackwardCursorPosition for details.
--   
--   Since: 2.4
textIterBackwardVisibleCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves up to count visible cursor positions. See
--   textIterBackwardCursorPosition for details.
--   
--   Since: 2.4
textIterBackwardVisibleCursorPositions :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves iter to the start of the previous visible line.
--   Returns True if iter could be moved; i.e. if
--   iter was at character offset 0, this function returns
--   False. Therefore if iter was already on line 0,
--   but not at the start of the line, iter is snapped to
--   the start of the line and the function returns True. (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.)
--   
--   Since: 2.8
textIterBackwardVisibleLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves count visible lines backward, if possible (if
--   count 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
--   False is returned. If count is 0, the function
--   does nothing and returns False. If count is
--   negative, moves forward by 0 - count lines.
--   
--   Since: 2.8
textIterBackwardVisibleLines :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Calls textIterBackwardVisibleWordStart up to
--   count times.
--   
--   Since: 2.4
textIterBackwardVisibleWordStarts :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Calls textIterBackwardWordStart up to count
--   times.
textIterBackwardWordStarts :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Creates a dynamically-allocated copy of an iterator. This function is
--   not useful in applications, because iterators can be copied with a
--   simple assignment (GtkTextIter i = j;). The function is used
--   by language bindings.
textIterCopy :: (HasCallStack, MonadIO m) => TextIter -> m TextIter

-- | Returns whether the character at iter is within an
--   editable region of text. Non-editable text is “locked” and can’t be
--   changed by the user via TextView. This function is simply a
--   convenience wrapper around textIterGetAttributes. If no tags
--   applied to this text affect editability,
--   defaultSetting will be returned.
--   
--   You don’t want to use this function to decide whether text can be
--   inserted at iter, because for insertion you don’t want
--   to know whether the char at iter is inside an editable
--   range, you want to know whether a new character inserted at
--   iter would be inside an editable range. Use
--   textIterCanInsert to handle this case.
textIterEditable :: (HasCallStack, MonadIO m) => TextIter -> Bool -> m Bool

-- | Returns True if iter 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 iter 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

-- | Determines whether iter 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
--   textIterCompare.
textIterEqual :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Bool

-- | Moves count characters if possible (if
--   count 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 iter is different from its
--   original position, and dereferenceable (the last iterator in the
--   buffer is not dereferenceable). If count is 0, the
--   function does nothing and returns False.
textIterForwardChars :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves up to count cursor positions. See
--   textIterForwardCursorPosition for details.
textIterForwardCursorPositions :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves iter 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 False. Otherwise,
--   returns True.
textIterForwardLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves count lines forward, if possible (if
--   count 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
--   False is returned. If count is 0, the function
--   does nothing and returns False. If count is
--   negative, moves backward by 0 - count lines.
textIterForwardLines :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Calls textIterForwardSentenceEnd count times
--   (or until textIterForwardSentenceEnd returns False). If
--   count is negative, moves backward instead of forward.
textIterForwardSentenceEnds :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves iter forward to the “end iterator,” which points
--   one past the last valid character in the buffer.
--   textIterGetChar 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 iter 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 False.
textIterForwardToLineEnd :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves forward to the next toggle (on or off) of the TextTag
--   tag, or to the next toggle of any tag if
--   tag is Nothing. If no matching tag toggles are
--   found, returns False, otherwise True. Does not return
--   toggles located at iter, only toggles after
--   iter. Sets iter 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 iter forward to the next visible cursor
--   position. See textIterForwardCursorPosition for details.
--   
--   Since: 2.4
textIterForwardVisibleCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves up to count visible cursor positions. See
--   textIterForwardCursorPosition for details.
--   
--   Since: 2.4
textIterForwardVisibleCursorPositions :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves iter to the start of the next visible line.
--   Returns True if there was a next line to move to, and
--   False if iter was simply moved to the end of
--   the buffer and is now not dereferenceable, or if iter
--   was already at the end of the buffer.
--   
--   Since: 2.8
textIterForwardVisibleLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves count visible lines forward, if possible (if
--   count 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
--   False is returned. If count is 0, the function
--   does nothing and returns False. If count is
--   negative, moves backward by 0 - count lines.
--   
--   Since: 2.8
textIterForwardVisibleLines :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Calls textIterForwardVisibleWordEnd up to count
--   times.
--   
--   Since: 2.4
textIterForwardVisibleWordEnds :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Calls textIterForwardWordEnd up to count times.
textIterForwardWordEnds :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Returns the TextBuffer this iterator is associated with.
textIterGetBuffer :: (HasCallStack, MonadIO m) => TextIter -> m TextBuffer

-- | Returns the number of bytes in the line containing
--   iter, including the paragraph delimiters.
textIterGetBytesInLine :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | Returns the number of characters in the line containing
--   iter, including the paragraph delimiters.
textIterGetCharsInLine :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | If the location at iter contains a child anchor, the
--   anchor is returned (with no new reference count added). Otherwise,
--   Nothing is returned.
textIterGetChildAnchor :: (HasCallStack, MonadIO m) => TextIter -> m TextChildAnchor

-- | A convenience wrapper around textIterGetAttributes, which
--   returns the language in effect at iter. If no tags
--   affecting language apply to iter, the return value is
--   identical to that of getDefaultLanguage.
textIterGetLanguage :: (HasCallStack, MonadIO m) => TextIter -> m Language

-- | Returns the line number containing the iterator. Lines in a
--   TextBuffer 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 TextBuffer 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 a list of all TextMark 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
--   TextBuffer has an offset, starting with 0 for the first
--   character in the buffer. Use textBufferGetIterAtOffset to
--   convert an offset back into an iterator.
textIterGetOffset :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | If the element at iter is a pixbuf, the pixbuf is
--   returned (with no new reference count added). Otherwise,
--   Nothing is returned.
textIterGetPixbuf :: (HasCallStack, MonadIO m) => TextIter -> m Pixbuf

-- | Returns a list of tags that apply to iter, in
--   ascending order of priority (highest-priority tags are last). The
--   TextTag 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 a list of TextTag that are toggled on or off at this
--   point. (If toggledOn is True, the list contains
--   tags that are toggled on.) If a tag is toggled on at
--   iter, then some non-empty range of characters
--   following iter has that tag applied to it. If a tag is
--   toggled off, then some non-empty range following iter
--   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
--   iter, 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 iter, not counting characters that are invisible
--   due to tags with the “invisible” flag toggled on.
textIterGetVisibleLineOffset :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | Like textIterGetSlice, but invisible text is not included.
--   Invisible text is usually invisible because a TextTag with the
--   “invisible” attribute turned on has been applied to it.
textIterGetVisibleSlice :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Text

-- | Like textIterGetText, but invisible text is not included.
--   Invisible text is usually invisible because a TextTag with the
--   “invisible” attribute turned on has been applied to it.
textIterGetVisibleText :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Text

-- | Determines whether iter 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 iter 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 textIterStartsWord returns True, then this
--   function returns True too, since iter points to
--   the first character of the word.
textIterInsideWord :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | See textIterForwardCursorPosition or LogAttr or
--   break for details on what a cursor position is.
textIterIsCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Returns True if iter is the first iterator in
--   the buffer, that is if iter has a character offset of
--   0.
textIterIsStart :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Swaps the value of first and second if
--   second comes before first in the
--   buffer. That is, ensures that first and
--   second 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 textIterInRange, that expect a pre-sorted
--   range.
textIterOrder :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m ()

-- | Moves iterator iter to the start of the line
--   lineNumber. If lineNumber is negative
--   or larger than the number of lines in the buffer, moves
--   iter to the start of the last line in the buffer.
textIterSetLine :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Sets iter to point to charOffset.
--   charOffset counts from the start of the entire text
--   buffer, starting with 0.
textIterSetOffset :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Like textIterSetLineIndex, 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 textIterSetLineOffset, 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 True if iter begins a paragraph, i.e.
--   if textIterGetLineOffset would return 0. However this function
--   is potentially more efficient than textIterGetLineOffset
--   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 iter 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

-- | This is equivalent to (textIterStartsTag ||
--   textIterEndsTag), i.e. it tells you whether a range with
--   tag applied to it begins or ends at
--   iter.
textIterTogglesTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

-- | Creates a new TargetList from an array of TargetEntry.
targetListNew :: (HasCallStack, MonadIO m) => Maybe [TargetEntry] -> m TargetList

-- | Appends another target to a TargetList.
targetListAdd :: (HasCallStack, MonadIO m) => TargetList -> Atom -> Word32 -> Word32 -> m ()

-- | Prepends a table of TargetEntry to a target list.
targetListAddTable :: (HasCallStack, MonadIO m) => TargetList -> [TargetEntry] -> m ()

-- | Looks up a given target in a TargetList.
targetListFind :: (HasCallStack, MonadIO m) => TargetList -> Atom -> m (Bool, Word32)

-- | Increases the reference count of a TargetList 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 TargetList 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
--   color. A factor < 1.0 would resolve to a more
--   transparent color, while > 1.0 would resolve to a more opaque
--   color.
--   
--   Since: 3.0
symbolicColorNewAlpha :: (HasCallStack, MonadIO m) => SymbolicColor -> Double -> m SymbolicColor

-- | Creates a symbolic color pointing to a literal color.
--   
--   Since: 3.0
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 color1, while a factor of
--   1 would resolve to color2.
--   
--   Since: 3.0
symbolicColorNewMix :: (HasCallStack, MonadIO m) => SymbolicColor -> SymbolicColor -> Double -> m SymbolicColor

-- | Creates a symbolic color pointing to an unresolved named color. See
--   styleContextLookupColor and stylePropertiesLookupColor.
--   
--   Since: 3.0
symbolicColorNewName :: (HasCallStack, MonadIO m) => Text -> m SymbolicColor

-- | Creates a symbolic color defined as a shade of another color. A factor
--   > 1.0 would resolve to a brighter color, while < 1.0 would
--   resolve to a darker color.
--   
--   Since: 3.0
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.
--   
--   Since: 3.4
symbolicColorNewWin32 :: (HasCallStack, MonadIO m) => Text -> Int32 -> m SymbolicColor

-- | Increases the reference count of color
--   
--   Since: 3.0
symbolicColorRef :: (HasCallStack, MonadIO m) => SymbolicColor -> m SymbolicColor

-- | If color is resolvable, resolvedColor
--   will be filled in with the resolved color, and True will be
--   returned. Generally, if color can’t be resolved, it is
--   due to it being defined on top of a named color that doesn’t exist in
--   props.
--   
--   When props is Nothing, resolving of named
--   colors will fail, so if your color is or references
--   such a color, this function will return False.
--   
--   Since: 3.0
symbolicColorResolve :: (HasCallStack, MonadIO m, IsStyleProperties a) => SymbolicColor -> Maybe a -> m (Bool, RGBA)

-- | Converts the given color 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 color, freeing its
--   memory if the reference count reaches 0.
--   
--   Since: 3.0
symbolicColorUnref :: (HasCallStack, MonadIO m) => SymbolicColor -> m ()

-- | Retrieves the data type of the selection.
--   
--   Since: 2.14
selectionDataGetDataType :: (HasCallStack, MonadIO m) => SelectionData -> m Atom

-- | Retrieves the raw data of the selection along with its length.
--   
--   Since: 3.0
selectionDataGetData :: (HasCallStack, MonadIO m) => SelectionData -> m ByteString

-- | Retrieves the display of the selection.
--   
--   Since: 2.14
selectionDataGetDisplay :: (HasCallStack, MonadIO m) => SelectionData -> m Display

-- | Retrieves the format of the selection.
--   
--   Since: 2.14
selectionDataGetFormat :: (HasCallStack, MonadIO m) => SelectionData -> m Int32

-- | Retrieves the length of the raw data of the selection.
--   
--   Since: 2.14
selectionDataGetLength :: (HasCallStack, MonadIO m) => SelectionData -> m Int32

-- | Gets the contents of the selection data as a Pixbuf.
--   
--   Since: 2.6
selectionDataGetPixbuf :: (HasCallStack, MonadIO m) => SelectionData -> m (Maybe Pixbuf)

-- | Retrieves the selection Atom of the selection data.
--   
--   Since: 2.16
selectionDataGetSelection :: (HasCallStack, MonadIO m) => SelectionData -> m Atom

-- | Retrieves the target of the selection.
--   
--   Since: 2.14
selectionDataGetTarget :: (HasCallStack, MonadIO m) => SelectionData -> m Atom

-- | Gets the contents of selectionData 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.
--   
--   Since: 2.6
selectionDataGetUris :: (HasCallStack, MonadIO m) => SelectionData -> m [Text]

-- | Sets the contents of the selection from a Pixbuf The pixbuf is
--   converted to the form determined by
--   selectionData->target.
--   
--   Since: 2.6
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
--   selectionData->target.
--   
--   Since 3.24.37, this may involve using the FileTransfer portal to send
--   files between sandboxed apps.
--   
--   Since: 2.6
selectionDataSetUris :: (HasCallStack, MonadIO m) => SelectionData -> [Text] -> m Bool

-- | Given a SelectionData object holding a list of targets,
--   determines if any of the targets in targets can be
--   used to provide a Pixbuf.
--   
--   Since: 2.6
selectionDataTargetsIncludeImage :: (HasCallStack, MonadIO m) => SelectionData -> Bool -> m Bool

-- | Given a SelectionData object holding a list of targets,
--   determines if any of the targets in targets can be
--   used to provide rich text.
--   
--   Since: 2.10
selectionDataTargetsIncludeRichText :: (HasCallStack, MonadIO m, IsTextBuffer a) => SelectionData -> a -> m Bool

-- | Given a SelectionData object holding a list of targets,
--   determines if any of the targets in targets can be
--   used to provide text.
selectionDataTargetsIncludeText :: (HasCallStack, MonadIO m) => SelectionData -> m Bool

-- | Given a SelectionData object holding a list of targets,
--   determines if any of the targets in targets can be
--   used to provide a list or URIs.
--   
--   Since: 2.10
selectionDataTargetsIncludeUri :: (HasCallStack, MonadIO m) => SelectionData -> m Bool

-- | Creates a new IconSet. A IconSet represents a single
--   icon in various sizes and widget states. It can provide a
--   Pixbuf for a given size and state on request, and automatically
--   caches some of the rendered Pixbuf objects.
--   
--   Normally you would use widgetRenderIconPixbuf instead of using
--   IconSet directly. The one case where you’d use IconSet
--   is to create application-specific icon sets to place in a
--   IconFactory.
iconSetNew :: (HasCallStack, MonadIO m) => m IconSet

-- | Copies iconSet 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 free.
iconSetGetSizes :: (HasCallStack, MonadIO m) => IconSet -> m [Int32]

-- | Increments the reference count on iconSet.
iconSetRef :: (HasCallStack, MonadIO m) => IconSet -> m IconSet

-- | Renders an icon using renderIconPixbuf. In most cases,
--   widgetRenderIconPixbuf is better, since it automatically
--   provides most of the arguments from the current widget settings. This
--   function never returns Nothing; if the icon can’t be rendered
--   (perhaps because an image file fails to load), a default "missing
--   image" icon will be returned instead.
--   
--   Since: 3.0
iconSetRenderIconPixbuf :: (HasCallStack, MonadIO m, IsStyleContext a) => IconSet -> a -> Int32 -> m Pixbuf

-- | Renders an icon using renderIconPixbuf and converts it to a
--   cairo surface.
--   
--   This function never returns Nothing; if the icon can’t be
--   rendered (perhaps because an image file fails to load), a default
--   "missing image" icon will be returned instead.
--   
--   Since: 3.10
iconSetRenderIconSurface :: (HasCallStack, MonadIO m, IsStyleContext a, IsWindow b) => IconSet -> a -> Int32 -> Int32 -> Maybe b -> m Surface

-- | Decrements the reference count on iconSet, and frees
--   memory if the reference count reaches 0.
iconSetUnref :: (HasCallStack, MonadIO m) => IconSet -> m ()

-- | Creates a new WindowGroup object. Grabs added with
--   widgetGrabAdd only affect windows within the same
--   WindowGroup.
windowGroupNew :: (HasCallStack, MonadIO m) => m WindowGroup

-- | Adds a window to a WindowGroup.
windowGroupAddWindow :: (HasCallStack, MonadIO m, IsWindowGroup a, IsWindow b) => a -> b -> m ()

-- | Returns the current grab widget for device, or
--   Nothing if none.
--   
--   Since: 3.0
windowGroupGetCurrentDeviceGrab :: (HasCallStack, MonadIO m, IsWindowGroup a, IsDevice b) => a -> b -> m (Maybe Widget)

-- | Gets the current grab widget of the given group, see
--   widgetGrabAdd.
--   
--   Since: 2.22
windowGroupGetCurrentGrab :: (HasCallStack, MonadIO m, IsWindowGroup a) => a -> m Widget

-- | Returns a list of the GtkWindows that belong to
--   windowGroup.
--   
--   Since: 2.14
windowGroupListWindows :: (HasCallStack, MonadIO m, IsWindowGroup a) => a -> m [Window]

-- | Removes a window from a WindowGroup.
windowGroupRemoveWindow :: (HasCallStack, MonadIO m, IsWindowGroup a, IsWindow b) => a -> b -> m ()

-- | This signal is emitted whenever the currently focused widget in this
--   window changes.
--   
--   Since: 2.24
type WindowSetFocusCallback = Maybe Widget -> IO ()

-- | The keysChanged signal gets emitted when the set of
--   accelerators or mnemonics that are associated with
--   window changes.
type WindowKeysChangedCallback = IO ()

-- | The enableDebugging signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user enables or
--   disables interactive debugging. When toggle is
--   True, interactive debugging is toggled on or off, when it is
--   False, 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 activateFocus signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user activates
--   the currently focused widget of window.
type WindowActivateFocusCallback = IO ()

-- | The activateDefault signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user activates
--   the default widget of window.
type WindowActivateDefaultCallback = IO ()

-- | Connect a signal handler for the activateDefault signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on window #activateDefault callback
--   
onWindowActivateDefault :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateDefaultCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activateDefault signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after window #activateDefault callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWindowActivateDefault :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateDefaultCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activateFocus signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on window #activateFocus callback
--   
onWindowActivateFocus :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activateFocus signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after window #activateFocus callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWindowActivateFocus :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the enableDebugging signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on window #enableDebugging callback
--   
onWindowEnableDebugging :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowEnableDebuggingCallback) -> m SignalHandlerId

-- | Connect a signal handler for the enableDebugging signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after window #enableDebugging callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWindowEnableDebugging :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowEnableDebuggingCallback) -> m SignalHandlerId

-- | Connect a signal handler for the keysChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on window #keysChanged callback
--   
onWindowKeysChanged :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowKeysChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the keysChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after window #keysChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWindowKeysChanged :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowKeysChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the setFocus signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on window #setFocus callback
--   
onWindowSetFocus :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowSetFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the setFocus signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after window #setFocus callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWindowSetFocus :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowSetFocusCallback) -> m SignalHandlerId

-- | Get the value of the “accept-focus” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #acceptFocus
--   
getWindowAcceptFocus :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “accept-focus” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #acceptFocus := value ]
--   
setWindowAcceptFocus :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accept-focus” property. This is rarely needed directly, but
--   it is used by new.
constructWindowAcceptFocus :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “application” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #application
--   
getWindowApplication :: (MonadIO m, IsWindow o) => o -> m (Maybe Application)

-- | Set the value of the “application” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #application := value ]
--   
setWindowApplication :: (MonadIO m, IsWindow o, IsApplication a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “application” property. This is rarely needed directly, but
--   it is used by new.
constructWindowApplication :: (IsWindow o, MonadIO m, IsApplication a) => a -> m (GValueConstruct o)

-- | Set the value of the “application” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #application
--   
clearWindowApplication :: (MonadIO m, IsWindow o) => o -> m ()

-- | Get the value of the “attached-to” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #attachedTo
--   
getWindowAttachedTo :: (MonadIO m, IsWindow o) => o -> m (Maybe Widget)

-- | Set the value of the “attached-to” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #attachedTo := value ]
--   
setWindowAttachedTo :: (MonadIO m, IsWindow o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “attached-to” property. This is rarely needed directly, but
--   it is used by new.
constructWindowAttachedTo :: (IsWindow o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “attached-to” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #attachedTo
--   
clearWindowAttachedTo :: (MonadIO m, IsWindow o) => o -> m ()

-- | Get the value of the “decorated” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #decorated
--   
getWindowDecorated :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “decorated” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #decorated := value ]
--   
setWindowDecorated :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “decorated” property. This is rarely needed directly, but it
--   is used by new.
constructWindowDecorated :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “default-height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #defaultHeight
--   
getWindowDefaultHeight :: (MonadIO m, IsWindow o) => o -> m Int32

-- | Set the value of the “default-height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #defaultHeight := value ]
--   
setWindowDefaultHeight :: (MonadIO m, IsWindow o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “default-height” property. This is rarely needed directly,
--   but it is used by new.
constructWindowDefaultHeight :: (IsWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “default-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #defaultWidth
--   
getWindowDefaultWidth :: (MonadIO m, IsWindow o) => o -> m Int32

-- | Set the value of the “default-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #defaultWidth := value ]
--   
setWindowDefaultWidth :: (MonadIO m, IsWindow o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “default-width” property. This is rarely needed directly, but
--   it is used by new.
constructWindowDefaultWidth :: (IsWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “deletable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #deletable
--   
getWindowDeletable :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “deletable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #deletable := value ]
--   
setWindowDeletable :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “deletable” property. This is rarely needed directly, but it
--   is used by new.
constructWindowDeletable :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “destroy-with-parent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #destroyWithParent
--   
getWindowDestroyWithParent :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “destroy-with-parent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #destroyWithParent := value ]
--   
setWindowDestroyWithParent :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “destroy-with-parent” property. This is rarely needed
--   directly, but it is used by new.
constructWindowDestroyWithParent :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “focus-on-map” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #focusOnMap
--   
getWindowFocusOnMap :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “focus-on-map” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #focusOnMap := value ]
--   
setWindowFocusOnMap :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “focus-on-map” property. This is rarely needed directly, but
--   it is used by new.
constructWindowFocusOnMap :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “focus-visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #focusVisible
--   
getWindowFocusVisible :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “focus-visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #focusVisible := value ]
--   
setWindowFocusVisible :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “focus-visible” property. This is rarely needed directly, but
--   it is used by new.
constructWindowFocusVisible :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gravity” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #gravity
--   
getWindowGravity :: (MonadIO m, IsWindow o) => o -> m Gravity

-- | Set the value of the “gravity” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #gravity := value ]
--   
setWindowGravity :: (MonadIO m, IsWindow o) => o -> Gravity -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gravity” property. This is rarely needed directly, but it is
--   used by new.
constructWindowGravity :: (IsWindow o, MonadIO m) => Gravity -> m (GValueConstruct o)

-- | Get the value of the “has-resize-grip” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #hasResizeGrip
--   
getWindowHasResizeGrip :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “has-resize-grip” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #hasResizeGrip := value ]
--   
setWindowHasResizeGrip :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-resize-grip” property. This is rarely needed directly,
--   but it is used by new.
constructWindowHasResizeGrip :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “has-toplevel-focus” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #hasToplevelFocus
--   
getWindowHasToplevelFocus :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Get the value of the “hide-titlebar-when-maximized” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get window #hideTitlebarWhenMaximized
--   
getWindowHideTitlebarWhenMaximized :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “hide-titlebar-when-maximized” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set window [ #hideTitlebarWhenMaximized := value ]
--   
setWindowHideTitlebarWhenMaximized :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “hide-titlebar-when-maximized” property. This is rarely
--   needed directly, but it is used by new.
constructWindowHideTitlebarWhenMaximized :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “icon” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get window #icon
--   
getWindowIcon :: (MonadIO m, IsWindow o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “icon” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set window [ #icon := value ]
--   
setWindowIcon :: (MonadIO m, IsWindow o, IsPixbuf a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon” property. This is rarely needed directly, but it is
--   used by new.
constructWindowIcon :: (IsWindow o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “icon” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #icon
--   
clearWindowIcon :: (MonadIO m, IsWindow o) => o -> m ()

-- | Get the value of the “icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #iconName
--   
getWindowIconName :: (MonadIO m, IsWindow o) => o -> m (Maybe Text)

-- | Set the value of the “icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #iconName := value ]
--   
setWindowIconName :: (MonadIO m, IsWindow o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-name” property. This is rarely needed directly, but it
--   is used by new.
constructWindowIconName :: (IsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “icon-name” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #iconName
--   
clearWindowIconName :: (MonadIO m, IsWindow o) => o -> m ()

-- | Get the value of the “is-active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #isActive
--   
getWindowIsActive :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Get the value of the “is-maximized” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #isMaximized
--   
getWindowIsMaximized :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Get the value of the “mnemonics-visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #mnemonicsVisible
--   
getWindowMnemonicsVisible :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “mnemonics-visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #mnemonicsVisible := value ]
--   
setWindowMnemonicsVisible :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “mnemonics-visible” property. This is rarely needed directly,
--   but it is used by new.
constructWindowMnemonicsVisible :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “modal” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #modal
--   
getWindowModal :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “modal” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #modal := value ]
--   
setWindowModal :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “modal” property. This is rarely needed directly, but it is
--   used by new.
constructWindowModal :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “resizable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #resizable
--   
getWindowResizable :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “resizable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #resizable := value ]
--   
setWindowResizable :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “resizable” property. This is rarely needed directly, but it
--   is used by new.
constructWindowResizable :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “resize-grip-visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #resizeGripVisible
--   
getWindowResizeGripVisible :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Get the value of the “role” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get window #role
--   
getWindowRole :: (MonadIO m, IsWindow o) => o -> m (Maybe Text)

-- | Set the value of the “role” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set window [ #role := value ]
--   
setWindowRole :: (MonadIO m, IsWindow o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “role” property. This is rarely needed directly, but it is
--   used by new.
constructWindowRole :: (IsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “screen” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #screen
--   
getWindowScreen :: (MonadIO m, IsWindow o) => o -> m Screen

-- | Set the value of the “screen” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #screen := value ]
--   
setWindowScreen :: (MonadIO m, IsWindow o, IsScreen a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “screen” property. This is rarely needed directly, but it is
--   used by new.
constructWindowScreen :: (IsWindow o, MonadIO m, IsScreen a) => a -> m (GValueConstruct o)

-- | Get the value of the “skip-pager-hint” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #skipPagerHint
--   
getWindowSkipPagerHint :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “skip-pager-hint” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #skipPagerHint := value ]
--   
setWindowSkipPagerHint :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “skip-pager-hint” property. This is rarely needed directly,
--   but it is used by new.
constructWindowSkipPagerHint :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “skip-taskbar-hint” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #skipTaskbarHint
--   
getWindowSkipTaskbarHint :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “skip-taskbar-hint” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #skipTaskbarHint := value ]
--   
setWindowSkipTaskbarHint :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “skip-taskbar-hint” property. This is rarely needed directly,
--   but it is used by new.
constructWindowSkipTaskbarHint :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Set the value of the “startup-id” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #startupId := value ]
--   
setWindowStartupId :: (MonadIO m, IsWindow o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “startup-id” property. This is rarely needed directly, but it
--   is used by new.
constructWindowStartupId :: (IsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #title
--   
getWindowTitle :: (MonadIO m, IsWindow o) => o -> m (Maybe Text)

-- | Set the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #title := value ]
--   
setWindowTitle :: (MonadIO m, IsWindow o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “title” property. This is rarely needed directly, but it is
--   used by new.
constructWindowTitle :: (IsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “transient-for” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #transientFor
--   
getWindowTransientFor :: (MonadIO m, IsWindow o) => o -> m (Maybe Window)

-- | Set the value of the “transient-for” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #transientFor := value ]
--   
setWindowTransientFor :: (MonadIO m, IsWindow o, IsWindow a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “transient-for” property. This is rarely needed directly, but
--   it is used by new.
constructWindowTransientFor :: (IsWindow o, MonadIO m, IsWindow a) => a -> m (GValueConstruct o)

-- | Set the value of the “transient-for” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #transientFor
--   
clearWindowTransientFor :: (MonadIO m, IsWindow o) => o -> m ()

-- | Get the value of the “type” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get window #type
--   
getWindowType :: (MonadIO m, IsWindow o) => o -> m WindowType

-- | Construct a GValueConstruct with valid value for the
--   “type” property. This is rarely needed directly, but it is
--   used by new.
constructWindowType :: (IsWindow o, MonadIO m) => WindowType -> m (GValueConstruct o)

-- | Get the value of the “type-hint” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #typeHint
--   
getWindowTypeHint :: (MonadIO m, IsWindow o) => o -> m WindowTypeHint

-- | Set the value of the “type-hint” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #typeHint := value ]
--   
setWindowTypeHint :: (MonadIO m, IsWindow o) => o -> WindowTypeHint -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “type-hint” property. This is rarely needed directly, but it
--   is used by new.
constructWindowTypeHint :: (IsWindow o, MonadIO m) => WindowTypeHint -> m (GValueConstruct o)

-- | Get the value of the “urgency-hint” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #urgencyHint
--   
getWindowUrgencyHint :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “urgency-hint” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #urgencyHint := value ]
--   
setWindowUrgencyHint :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “urgency-hint” property. This is rarely needed directly, but
--   it is used by new.
constructWindowUrgencyHint :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “window-position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get window #windowPosition
--   
getWindowWindowPosition :: (MonadIO m, IsWindow o) => o -> m WindowPosition

-- | Set the value of the “window-position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set window [ #windowPosition := value ]
--   
setWindowWindowPosition :: (MonadIO m, IsWindow o) => o -> WindowPosition -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “window-position” property. This is rarely needed directly,
--   but it is used by new.
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 Window. This is
--   normally called by the default key_press_event 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.
--   
--   Since: 2.4
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.
--   
--   Since: 3.10
windowClose :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Gets the Application associated with the window (if any).
--   
--   Since: 3.0
windowGetApplication :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Application)

-- | Fetches the attach widget for this window. See
--   windowSetAttachedTo.
--   
--   Since: 3.4
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 windowSetDecorated.
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 window. See
--   windowSetDefault for more details.
--   
--   Since: 2.14
windowGetDefaultWidget :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Widget)

-- | Returns whether the window has been set to have a close button via
--   windowSetDeletable.
--   
--   Since: 2.10
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 windowSetGravity.
windowGetGravity :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Gravity

-- | Determines whether the window may have a resize grip.
--   
--   Since: 3.0
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 ().
--   
--   Since: 3.4
windowGetHideTitlebarWhenMaximized :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Gets the value set by windowSetIcon (or if you've called
--   windowSetIconList, 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 windowSetIconList. 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
--   windowSetIconName.
--   
--   Since: 2.6
windowGetIconName :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Text)

-- | Returns the mnemonic modifier for this window. See
--   windowSetMnemonicModifier.
windowGetMnemonicModifier :: (HasCallStack, MonadIO m, IsWindow a) => a -> m [ModifierType]

-- | Gets the value of the Window:mnemonicsVisible property.
--   
--   Since: 2.20
windowGetMnemonicsVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns whether the window is modal. See windowSetModal.
windowGetModal :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Fetches the requested opacity for this window. See
--   windowSetOpacity.
--   
--   Since: 2.12
windowGetOpacity :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Double

-- | Gets the value set by windowSetResizable.
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 Rectangle.
--   
--   Since: 3.0
windowGetResizeGripArea :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Bool, Rectangle)

-- | Returns the role of the window. See windowSetRole for further
--   explanation.
windowGetRole :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Text)

-- | Gets the value set by windowSetSkipPagerHint.
--   
--   Since: 2.2
windowGetSkipPagerHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Gets the value set by windowSetSkipTaskbarHint
--   
--   Since: 2.2
windowGetSkipTaskbarHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Retrieves the title of the window. See windowSetTitle.
windowGetTitle :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Text)

-- | Returns the custom titlebar that has been set with
--   windowSetTitlebar.
--   
--   Since: 3.16
windowGetTitlebar :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Widget)

-- | Fetches the transient parent for this window. See
--   windowSetTransientFor.
windowGetTransientFor :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Window)

-- | Gets the value set by windowSetUrgencyHint
--   
--   Since: 2.8
windowGetUrgencyHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns whether window has an explicit window group.
windowHasGroup :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Retrieves the current maximized state of window.
--   
--   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 windowMaximize
--   or windowUnmaximize.
--   
--   Since: 3.12
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

-- | 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 window is hidden, this function calls
--   widgetShow 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 windowPresent 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.
--   
--   Since: 2.8
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 event.
--   This is normally called by the default key_press_event and
--   key_release_event 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.
--   
--   Since: 2.4
windowPropagateKeyEvent :: (HasCallStack, MonadIO m, IsWindow a) => a -> EventKey -> m Bool

-- | Reverses the effects of windowAddAccelGroup.
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 window, 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 ()

-- | Like windowResize, but width and
--   height are interpreted in terms of the base size and
--   increment set with gtk_window_set_geometry_hints.
--   
--   Since: 3.0
windowResizeToGeometry :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> m ()

-- | Sets or unsets the Application associated with the window.
--   
--   The application will be kept alive for at least as long as it has any
--   windows associated with it (see applicationHold 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 application to Nothing.
--   
--   This is equivalent to calling applicationRemoveWindow and/or
--   applicationAddWindow on the old/new applications as relevant.
--   
--   Since: 3.0
windowSetApplication :: (HasCallStack, MonadIO m, IsWindow a, IsApplication b) => a -> Maybe b -> m ()

-- | Like windowSetDefaultSize, but width and
--   height are interpreted in terms of the base size and
--   increment set with gtk_window_set_geometry_hints.
--   
--   Since: 3.0
windowSetDefaultGeometry :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> m ()

-- | If focus is not the current focus widget, and is
--   focusable, sets it as the focus widget for the window. If
--   focus is Nothing, 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 widgetGrabFocus instead of
--   this function.
windowSetFocus :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the Window:focusVisible property.
--   
--   Since: 3.2
windowSetFocusVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets whether window has a corner resize grip.
--   
--   Note that the resize grip is only shown if the window is actually
--   resizable and not maximized. Use windowResizeGripIsVisible to
--   find out if the resize grip is currently shown.
--   
--   Since: 3.0
windowSetHasResizeGrip :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Tells GTK+ whether to drop its extra reference to the window when
--   widgetDestroy 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.
--   
--   Since: 3.0
windowSetHasUserRefCount :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | If setting is True, then window
--   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 windowSetTitlebar are not
--   affected by this. The application is in full control of their content
--   and visibility anyway.
--   
--   Since: 3.4
windowSetHideTitlebarWhenMaximized :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets the icon for window. Warns on failure if
--   err is Nothing.
--   
--   This function is equivalent to calling windowSetIcon with a
--   pixbuf created by loading the image from filename.
--   
--   Since: 2.2
windowSetIconFromFile :: (HasCallStack, MonadIO m, IsWindow a) => a -> [Char] -> m ()

-- | Sets the Window:mnemonicsVisible property.
--   
--   Since: 2.20
windowSetMnemonicsVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets the Screen where the window is displayed;
--   if the window is already mapped, it will be unmapped, and then
--   remapped on the new screen.
--   
--   Since: 2.2
windowSetScreen :: (HasCallStack, MonadIO m, IsWindow a, IsScreen b) => a -> 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 windowSetRole
--   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 windowSetDefaultIconList. The list is a
--   copy and should be freed with g_list_free(), 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
--   windowSetDefaultIconName. The returned string is owned by GTK+
--   and should not be modified. It is only valid until the next call to
--   windowSetDefaultIconName.
--   
--   Since: 2.16
windowGetDefaultIconName :: (HasCallStack, MonadIO m) => m Text

-- | By default, after showing the first Window, GTK+ calls
--   notifyStartupComplete. 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.
--   
--   Since: 2.2
windowSetAutoStartupNotification :: (HasCallStack, MonadIO m) => Bool -> m ()

-- | Sets an icon to be used as fallback for windows that haven't had
--   windowSetIconList called on them from a file on disk. Warns on
--   failure if err is Nothing.
--   
--   Since: 2.2
windowSetDefaultIconFromFile :: (HasCallStack, MonadIO m) => [Char] -> m ()

-- | Opens or closes the [interactive debugger][interactive-debugging],
--   which offers access to the widget hierarchy of the application and to
--   useful debugging tools.
--   
--   Since: 3.14
windowSetInteractiveDebugging :: (HasCallStack, MonadIO m) => Bool -> m ()

-- | The windowStateEvent will be emitted when the state of the
--   toplevel window associated to the widget changes.
--   
--   To receive this signal the Window associated to the widget
--   needs to enable the GDK_STRUCTURE_MASK mask. GDK will
--   enable this mask automatically for all new windows.
type WidgetWindowStateEventCallback = EventWindowState -> IO Bool

-- | The visibilityNotifyEvent will be emitted when the
--   widget's window is obscured or unobscured.
--   
--   To receive this signal the Window associated to the widget
--   needs to enable the GDK_VISIBILITY_NOTIFY_MASK mask.
type WidgetVisibilityNotifyEventCallback = EventVisibility -> IO Bool

-- | The unrealize signal is emitted when the Window
--   associated with widget is destroyed, which means that
--   widgetUnrealize has been called or the widget has been unmapped
--   (that is, it is going to be hidden).
type WidgetUnrealizeCallback = IO ()

-- | The unmapEvent signal will be emitted when the
--   widget's window is unmapped. A window is unmapped when
--   it becomes invisible on the screen.
--   
--   To receive this signal, the Window associated to the widget
--   needs to enable the GDK_STRUCTURE_MASK mask. GDK will
--   enable this mask automatically for all new windows.
type WidgetUnmapEventCallback = EventAny -> IO Bool

-- | The unmap signal is emitted when widget 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 unmap 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 ()

-- | No description available in the introspection data.
type WidgetTouchEventCallback = Event -> IO Bool

-- | The styleUpdated signal is a convenience signal that is emitted
--   when the StyleContext::changed signal is emitted on the
--   widget's associated StyleContext as returned by
--   widgetGetStyleContext.
--   
--   Note that style-modifying functions like widgetOverrideColor
--   also cause this signal to be emitted.
--   
--   Since: 3.0
type WidgetStyleUpdatedCallback = IO ()

-- | The styleSet signal is emitted when a new style has been set on
--   a widget. Note that style-modifying functions like
--   widgetModifyBase also cause this signal to be emitted.
--   
--   Note that this signal is emitted for changes to the deprecated
--   Style. To track changes to the StyleContext associated
--   with a widget, use the Widget::styleUpdated signal.
type WidgetStyleSetCallback = Maybe Style -> IO ()

-- | The stateFlagsChanged signal is emitted when the widget state
--   changes, see widgetGetStateFlags.
--   
--   Since: 3.0
type WidgetStateFlagsChangedCallback = [StateFlags] -> IO ()

-- | The stateChanged signal is emitted when the widget state
--   changes. See widgetGetState.
type WidgetStateChangedCallback = StateType -> IO ()

-- | No description available in the introspection data.
type WidgetSizeAllocateCallback = Rectangle -> IO ()

-- | No description available in the introspection data.
type WidgetShowHelpCallback = WidgetHelpType -> IO Bool

-- | The show signal is emitted when widget is
--   shown, for example with widgetShow.
type WidgetShowCallback = IO ()

-- | The selectionRequestEvent signal will be emitted when another
--   client requests ownership of the selection owned by the
--   widget's window.
type WidgetSelectionRequestEventCallback = EventSelection -> IO Bool

-- | No description available in the introspection data.
type WidgetSelectionReceivedCallback = SelectionData -> Word32 -> IO ()

-- | No description available in the introspection data.
type WidgetSelectionNotifyEventCallback = EventSelection -> IO Bool

-- | No description available in the introspection data.
type WidgetSelectionGetCallback = SelectionData -> Word32 -> Word32 -> IO ()

-- | The selectionClearEvent signal will be emitted when the the
--   widget's window has lost ownership of a selection.
type WidgetSelectionClearEventCallback = EventSelection -> IO Bool

-- | The scrollEvent 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 Window associated to the widget
--   needs to enable the GDK_SCROLL_MASK mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetScrollEventCallback = EventScroll -> IO Bool

-- | The screenChanged signal gets emitted when the screen of a
--   widget has changed.
type WidgetScreenChangedCallback = Maybe Screen -> IO ()

-- | The realize signal is emitted when widget is
--   associated with a Window, which means that widgetRealize
--   has been called or the widget has been mapped (that is, it is going to
--   be drawn).
type WidgetRealizeCallback = IO ()

-- | Emitted when Widget:hasTooltip is True and the hover
--   timeout has expired with the cursor hovering "above"
--   widget; or emitted when widget got
--   focus in keyboard mode.
--   
--   Using the given coordinates, the signal handler should determine
--   whether a tooltip should be shown for widget. If this
--   is the case True should be returned, False otherwise.
--   Note that if keyboardMode is True, the values
--   of x and y are undefined and should
--   not be used.
--   
--   The signal handler is free to manipulate tooltip with
--   the therefore destined function calls.
--   
--   Since: 2.12
type WidgetQueryTooltipCallback = Int32 -> Int32 -> Bool -> Tooltip -> IO Bool

-- | To receive this signal the Window associated to the widget
--   needs to enable the GDK_PROXIMITY_OUT_MASK mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetProximityOutEventCallback = EventProximity -> IO Bool

-- | To receive this signal the Window associated to the widget
--   needs to enable the GDK_PROXIMITY_IN_MASK mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetProximityInEventCallback = EventProximity -> IO Bool

-- | The propertyNotifyEvent signal will be emitted when a property
--   on the widget's window has been changed or deleted.
--   
--   To receive this signal, the Window associated to the widget
--   needs to enable the GDK_PROPERTY_CHANGE_MASK 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 Entry
--   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 parentSet signal is emitted when a new parent has been set
--   on a widget.
type WidgetParentSetCallback = Maybe Widget -> IO ()

-- | No description available in the introspection data.
type WidgetMoveFocusCallback = DirectionType -> IO ()

-- | The motionNotifyEvent signal is emitted when the pointer moves
--   over the widget's Window.
--   
--   To receive this signal, the Window associated to the widget
--   needs to enable the GDK_POINTER_MOTION_MASK 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 widget
--   if groupCycling is False, or just makes
--   widget grab focus if groupCycling is
--   True.
type WidgetMnemonicActivateCallback = Bool -> IO Bool

-- | The mapEvent signal will be emitted when the
--   widget's window is mapped. A window is mapped when it
--   becomes visible on the screen.
--   
--   To receive this signal, the Window associated to the widget
--   needs to enable the GDK_STRUCTURE_MASK mask. GDK will
--   enable this mask automatically for all new windows.
type WidgetMapEventCallback = EventAny -> IO Bool

-- | The map signal is emitted when widget is going
--   to be mapped, that is when the widget is visible (which is controlled
--   with widgetSetVisible) and all its parents up to the toplevel
--   widget are also visible. Once the map has occurred,
--   Widget::mapEvent will be emitted.
--   
--   The map 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 Widget::unmap.
type WidgetMapCallback = IO ()

-- | The leaveNotifyEvent will be emitted when the pointer leaves
--   the widget's window.
--   
--   To receive this signal, the Window associated to the widget
--   needs to enable the GDK_LEAVE_NOTIFY_MASK 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
--   widgetKeynavFailed for details.
--   
--   Since: 2.12
type WidgetKeynavFailedCallback = DirectionType -> IO Bool

-- | The keyReleaseEvent signal is emitted when a key is released.
--   
--   To receive this signal, the Window associated to the widget
--   needs to enable the GDK_KEY_RELEASE_MASK mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetKeyReleaseEventCallback = EventKey -> IO Bool

-- | The keyPressEvent 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 Window associated to the widget
--   needs to enable the GDK_KEY_PRESS_MASK mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetKeyPressEventCallback = EventKey -> IO Bool

-- | The hierarchyChanged signal is emitted when the anchored state
--   of a widget changes. A widget is “anchored” when its toplevel ancestor
--   is a Window. This signal is emitted when a widget changes from
--   un-anchored to anchored or vice-versa.
type WidgetHierarchyChangedCallback = Maybe Widget -> IO ()

-- | The hide signal is emitted when widget is
--   hidden, for example with widgetHide.
type WidgetHideCallback = IO ()

-- | The grabNotify 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 widgetGrabAdd when the topmost grab
--   widget in the grab stack of its window group is not its ancestor.
type WidgetGrabNotifyCallback = Bool -> IO ()

-- | No description available in the introspection data.
type WidgetGrabFocusCallback = IO ()

-- | Emitted when a pointer or keyboard grab on a window belonging to
--   widget 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.
--   
--   Since: 2.8
type WidgetGrabBrokenEventCallback = EventGrabBroken -> IO Bool

-- | The focusOutEvent signal will be emitted when the keyboard
--   focus leaves the widget's window.
--   
--   To receive this signal, the Window associated to the widget
--   needs to enable the GDK_FOCUS_CHANGE_MASK mask.
type WidgetFocusOutEventCallback = EventFocus -> IO Bool

-- | The focusInEvent signal will be emitted when the keyboard focus
--   enters the widget's window.
--   
--   To receive this signal, the Window associated to the widget
--   needs to enable the GDK_FOCUS_CHANGE_MASK mask.
type WidgetFocusInEventCallback = EventFocus -> IO Bool

-- | No description available in the introspection data.
type WidgetFocusCallback = DirectionType -> IO Bool

-- | After the emission of the Widget::event signal and (optionally)
--   the second more specific signal, eventAfter 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 event signal, another, more
--   specific, signal that matches the type of event delivered (e.g.
--   Widget::keyPressEvent) and finally a generic
--   Widget::eventAfter signal.
type WidgetEventCallback = Event -> IO Bool

-- | The enterNotifyEvent will be emitted when the pointer enters
--   the widget's window.
--   
--   To receive this signal, the Window associated to the widget
--   needs to enable the GDK_ENTER_NOTIFY_MASK 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
--   widget's top left corner must be painted at the origin
--   of the passed in context and be sized to the values returned by
--   widgetGetAllocatedWidth and widgetGetAllocatedHeight.
--   
--   Signal handlers connected to this signal can modify the cairo context
--   passed as cr in any way they like and don't need to
--   restore it. The signal emission takes care of calling
--   cairo_save() before and
--   cairo_restore() after invoking the handler.
--   
--   The signal handler will get a cr 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
--   cairoGetClipRectangle, or they can get a finer-grained
--   representation of the dirty region with
--   cairo_copy_clip_rectangle_list().
--   
--   Since: 3.0
type WidgetDrawCallback = Context -> IO Bool

-- | The dragMotion 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 False and no further
--   processing is necessary. Otherwise, the handler returns True.
--   In this case, the handler is responsible for providing the necessary
--   information for displaying feedback to the user, by calling
--   dragStatus.
--   
--   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
--   widgetDragGetData and defer the dragStatus call to the
--   Widget::dragDataReceived handler. Note that you must pass
--   GTK_DEST_DEFAULT_DROP,
--   GTK_DEST_DEFAULT_MOTION or
--   GTK_DEST_DEFAULT_ALL to widgetDragDestSet 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 Widget::dragLeave and if not, treat the drag-motion
--   signal as an "enter" signal. Upon an "enter", the handler will
--   typically highlight the drop site with widgetDragHighlight.
--   
--   
C code
--   
--   
--   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->drag_highlight)
--      {
--        private_data->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->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->suggested_action)
--      {
--        private_data->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->suggested_action,
--                           time);
--      }
--     else
--      {
--        // accept the drop
--      }
--   }
--   
type WidgetDragMotionCallback = DragContext -> Int32 -> Int32 -> Word32 -> IO Bool

-- | The dragLeave 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 Widget::dragMotion, e.g. undo
--   highlighting with widgetDragUnhighlight.
--   
--   Likewise, the Widget::dragLeave signal is also emitted before
--   the dragDrop signal, for instance to allow cleaning up of a
--   preview item created in the Widget::dragMotion signal handler.
type WidgetDragLeaveCallback = DragContext -> Word32 -> IO ()

-- | The dragFailed 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 True is
--   the failure has been already handled (not showing the default "drag
--   operation failed" animation), otherwise it returns False.
--   
--   Since: 2.12
type WidgetDragFailedCallback = DragContext -> DragResult -> IO Bool

-- | The dragEnd 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 Widget::dragBegin.
type WidgetDragEndCallback = DragContext -> IO ()

-- | The dragDrop 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 False and no further processing is
--   necessary. Otherwise, the handler returns True. In this case,
--   the handler must ensure that dragFinish is called to let the
--   source know that the drop is done. The call to dragFinish can
--   be done either directly or in a Widget::dragDataReceived
--   handler which gets triggered by calling widgetDragGetData to
--   receive the data for one or more of the supported targets.
type WidgetDragDropCallback = DragContext -> Int32 -> Int32 -> Word32 -> IO Bool

-- | The dragDataReceived 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 dragStatus and not finish the drag. If the
--   data was received in response to a Widget::dragDrop 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
--   dragFinish, setting the success 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 dragStatus or
--   dragFinish.
--   
--   The handler may inspect the selected action with
--   dragContextGetSelectedAction before calling dragFinish,
--   e.g. to implement DragActionAsk as shown in the following
--   example:
--   
--   
C code
--   
--   
--   void
--   drag_data_received (GtkWidget          *widget,
--                       GdkDragContext     *context,
--                       gint                x,
--                       gint                y,
--                       GtkSelectionData   *data,
--                       guint               info,
--                       guint               time)
--   {
--     if ((data->length >= 0) && (data->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);
--    }
--   
type WidgetDragDataReceivedCallback = DragContext -> Int32 -> Int32 -> SelectionData -> Word32 -> Word32 -> IO ()

-- | The dragDataGet 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 data with the data in
--   the format which is indicated by info. See
--   selectionDataSet and selectionDataSetText.
type WidgetDragDataGetCallback = DragContext -> SelectionData -> Word32 -> Word32 -> IO ()

-- | The dragDataDelete signal is emitted on the drag source when a
--   drag with the action DragActionMove 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 dragBegin 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. widgetDragSourceSetIconPixbuf.
--   
--   Note that some widgets set up a drag icon in the default handler of
--   this signal, so you may have to use
--   g_signal_connect_after() to override what the default
--   handler did.
type WidgetDragBeginCallback = DragContext -> IO ()

-- | The directionChanged signal is emitted when the text direction
--   of a widget changes.
type WidgetDirectionChangedCallback = TextDirection -> IO ()

-- | The destroyEvent signal is emitted when a Window 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 Window associated to the widget
--   needs to enable the GDK_STRUCTURE_MASK 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 deleteEvent signal is emitted if a user requests that a
--   toplevel window is closed. The default handler for this signal
--   destroys the window. Connecting widgetHideOnDelete 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 widget
--   gets drawn into. The region/area members of the event shows what area
--   of the redirected drawable was drawn into.
--   
--   Since: 2.14
type WidgetDamageEventCallback = EventExpose -> IO Bool

-- | The configureEvent signal will be emitted when the size,
--   position or stacking of the widget's window has
--   changed.
--   
--   To receive this signal, the Window associated to the widget
--   needs to enable the GDK_STRUCTURE_MASK mask. GDK will
--   enable this mask automatically for all new windows.
type WidgetConfigureEventCallback = EventConfigure -> IO Bool

-- | The compositedChanged signal is emitted when the composited
--   status of widgets screen changes. See
--   screenIsComposited.
type WidgetCompositedChangedCallback = IO ()

-- | The childNotify 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 signalId can currently be activated. This signal is
--   present to allow applications and derived widgets to override the
--   default Widget handling for determining whether an accelerator
--   can be activated.
type WidgetCanActivateAccelCallback = Word32 -> IO Bool

-- | The buttonReleaseEvent signal will be emitted when a button
--   (typically from a mouse) is released.
--   
--   To receive this signal, the Window associated to the widget
--   needs to enable the GDK_BUTTON_RELEASE_MASK mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetButtonReleaseEventCallback = EventButton -> IO Bool

-- | The buttonPressEvent signal will be emitted when a button
--   (typically from a mouse) is pressed.
--   
--   To receive this signal, the Window associated to the widget
--   needs to enable the GDK_BUTTON_PRESS_MASK mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetButtonPressEventCallback = EventButton -> IO Bool

-- | No description available in the introspection data.
type WidgetAccelClosuresChangedCallback = IO ()

-- | Connect a signal handler for the accelClosuresChanged signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on widget #accelClosuresChanged callback
--   
onWidgetAccelClosuresChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetAccelClosuresChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the accelClosuresChanged signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after widget #accelClosuresChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetAccelClosuresChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetAccelClosuresChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the buttonPressEvent signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #buttonPressEvent callback
--   
onWidgetButtonPressEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetButtonPressEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the buttonPressEvent signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #buttonPressEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetButtonPressEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetButtonPressEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the buttonReleaseEvent signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #buttonReleaseEvent callback
--   
onWidgetButtonReleaseEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetButtonReleaseEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the buttonReleaseEvent signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #buttonReleaseEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetButtonReleaseEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetButtonReleaseEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the canActivateAccel signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #canActivateAccel callback
--   
onWidgetCanActivateAccel :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetCanActivateAccelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the canActivateAccel signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #canActivateAccel callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetCanActivateAccel :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetCanActivateAccelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the childNotify signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #childNotify callback
--   
--   
--   This signal admits a optional parameter detail. If it's not
--   Nothing, we will connect to “child-notify::detail”
--   instead.
onWidgetChildNotify :: (IsWidget a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => WidgetChildNotifyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the childNotify signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #childNotify callback
--   
--   
--   This signal admits a optional parameter detail. If it's not
--   Nothing, we will connect to “child-notify::detail”
--   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
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetChildNotify :: (IsWidget a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => WidgetChildNotifyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the compositedChanged signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #compositedChanged callback
--   
onWidgetCompositedChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetCompositedChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the compositedChanged signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #compositedChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetCompositedChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetCompositedChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the configureEvent signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #configureEvent callback
--   
onWidgetConfigureEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetConfigureEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the configureEvent signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #configureEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetConfigureEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetConfigureEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the damageEvent signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #damageEvent callback
--   
onWidgetDamageEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDamageEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the damageEvent signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #damageEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDamageEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDamageEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deleteEvent signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #deleteEvent callback
--   
onWidgetDeleteEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDeleteEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deleteEvent signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #deleteEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDeleteEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDeleteEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the destroy signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #destroy callback
--   
onWidgetDestroy :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDestroyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the destroy signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #destroy callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDestroy :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDestroyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the destroyEvent signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #destroyEvent callback
--   
onWidgetDestroyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDestroyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the destroyEvent signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #destroyEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDestroyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDestroyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the directionChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #directionChanged callback
--   
onWidgetDirectionChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDirectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the directionChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #directionChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDirectionChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDirectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragBegin signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #dragBegin callback
--   
onWidgetDragBegin :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragBegin signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #dragBegin callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDragBegin :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragDataDelete signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #dragDataDelete callback
--   
onWidgetDragDataDelete :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDataDeleteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragDataDelete signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #dragDataDelete callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDragDataDelete :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDataDeleteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragDataGet signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #dragDataGet callback
--   
onWidgetDragDataGet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDataGetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragDataGet signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #dragDataGet callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDragDataGet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDataGetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragDataReceived signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #dragDataReceived callback
--   
onWidgetDragDataReceived :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDataReceivedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragDataReceived signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #dragDataReceived callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDragDataReceived :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDataReceivedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragDrop signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #dragDrop callback
--   
onWidgetDragDrop :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDropCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragDrop signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #dragDrop callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDragDrop :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDropCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragEnd signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #dragEnd callback
--   
onWidgetDragEnd :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragEnd signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #dragEnd callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDragEnd :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragFailed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #dragFailed callback
--   
onWidgetDragFailed :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragFailedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragFailed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #dragFailed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDragFailed :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragFailedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragLeave signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #dragLeave callback
--   
onWidgetDragLeave :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragLeave signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #dragLeave callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDragLeave :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragMotion signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #dragMotion callback
--   
onWidgetDragMotion :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragMotion signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #dragMotion callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDragMotion :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the draw signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on widget #draw callback
--   
onWidgetDraw :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDrawCallback) -> m SignalHandlerId

-- | Connect a signal handler for the draw signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #draw callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetDraw :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDrawCallback) -> m SignalHandlerId

-- | Connect a signal handler for the enterNotifyEvent signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #enterNotifyEvent callback
--   
onWidgetEnterNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetEnterNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the enterNotifyEvent signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #enterNotifyEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetEnterNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetEnterNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the event signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on widget #event callback
--   
onWidgetEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the event signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #event callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the eventAfter signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #eventAfter callback
--   
onWidgetEventAfter :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetEventAfterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the eventAfter signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #eventAfter callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetEventAfter :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetEventAfterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the focus signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on widget #focus callback
--   
onWidgetFocus :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the focus signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #focus callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetFocus :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the focusInEvent signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #focusInEvent callback
--   
onWidgetFocusInEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetFocusInEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the focusInEvent signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #focusInEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetFocusInEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetFocusInEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the focusOutEvent signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #focusOutEvent callback
--   
onWidgetFocusOutEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetFocusOutEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the focusOutEvent signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #focusOutEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetFocusOutEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetFocusOutEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the grabBrokenEvent signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #grabBrokenEvent callback
--   
onWidgetGrabBrokenEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetGrabBrokenEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the grabBrokenEvent signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #grabBrokenEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetGrabBrokenEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetGrabBrokenEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the grabFocus signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #grabFocus callback
--   
onWidgetGrabFocus :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetGrabFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the grabFocus signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #grabFocus callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetGrabFocus :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetGrabFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the grabNotify signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #grabNotify callback
--   
onWidgetGrabNotify :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetGrabNotifyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the grabNotify signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #grabNotify callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetGrabNotify :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetGrabNotifyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the hide signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on widget #hide callback
--   
onWidgetHide :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetHideCallback) -> m SignalHandlerId

-- | Connect a signal handler for the hide signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #hide callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetHide :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetHideCallback) -> m SignalHandlerId

-- | Connect a signal handler for the hierarchyChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #hierarchyChanged callback
--   
onWidgetHierarchyChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetHierarchyChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the hierarchyChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #hierarchyChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetHierarchyChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetHierarchyChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the keyPressEvent signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #keyPressEvent callback
--   
onWidgetKeyPressEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetKeyPressEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the keyPressEvent signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #keyPressEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetKeyPressEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetKeyPressEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the keyReleaseEvent signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #keyReleaseEvent callback
--   
onWidgetKeyReleaseEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetKeyReleaseEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the keyReleaseEvent signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #keyReleaseEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetKeyReleaseEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetKeyReleaseEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the keynavFailed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #keynavFailed callback
--   
onWidgetKeynavFailed :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetKeynavFailedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the keynavFailed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #keynavFailed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetKeynavFailed :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetKeynavFailedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the leaveNotifyEvent signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #leaveNotifyEvent callback
--   
onWidgetLeaveNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetLeaveNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the leaveNotifyEvent signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #leaveNotifyEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetLeaveNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetLeaveNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the map signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on widget #map callback
--   
onWidgetMap :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMapCallback) -> m SignalHandlerId

-- | Connect a signal handler for the map signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #map callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetMap :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMapCallback) -> m SignalHandlerId

-- | Connect a signal handler for the mapEvent signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #mapEvent callback
--   
onWidgetMapEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMapEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the mapEvent signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #mapEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetMapEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMapEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the mnemonicActivate signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #mnemonicActivate callback
--   
onWidgetMnemonicActivate :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMnemonicActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the mnemonicActivate signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #mnemonicActivate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetMnemonicActivate :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMnemonicActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the motionNotifyEvent signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #motionNotifyEvent callback
--   
onWidgetMotionNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMotionNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the motionNotifyEvent signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #motionNotifyEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetMotionNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMotionNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveFocus signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #moveFocus callback
--   
onWidgetMoveFocus :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMoveFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveFocus signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #moveFocus callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetMoveFocus :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMoveFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the parentSet signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #parentSet callback
--   
onWidgetParentSet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetParentSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the parentSet signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #parentSet callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetParentSet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetParentSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the popupMenu signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #popupMenu callback
--   
onWidgetPopupMenu :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetPopupMenuCallback) -> m SignalHandlerId

-- | Connect a signal handler for the popupMenu signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #popupMenu callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetPopupMenu :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetPopupMenuCallback) -> m SignalHandlerId

-- | Connect a signal handler for the propertyNotifyEvent signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #propertyNotifyEvent callback
--   
onWidgetPropertyNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetPropertyNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the propertyNotifyEvent signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #propertyNotifyEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetPropertyNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetPropertyNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the proximityInEvent signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #proximityInEvent callback
--   
onWidgetProximityInEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetProximityInEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the proximityInEvent signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #proximityInEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetProximityInEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetProximityInEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the proximityOutEvent signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #proximityOutEvent callback
--   
onWidgetProximityOutEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetProximityOutEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the proximityOutEvent signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #proximityOutEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetProximityOutEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetProximityOutEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the queryTooltip signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #queryTooltip callback
--   
onWidgetQueryTooltip :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetQueryTooltipCallback) -> m SignalHandlerId

-- | Connect a signal handler for the queryTooltip signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #queryTooltip callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetQueryTooltip :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetQueryTooltipCallback) -> m SignalHandlerId

-- | Connect a signal handler for the realize signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #realize callback
--   
onWidgetRealize :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetRealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the realize signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #realize callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetRealize :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetRealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the screenChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #screenChanged callback
--   
onWidgetScreenChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetScreenChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the screenChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #screenChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetScreenChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetScreenChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the scrollEvent signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #scrollEvent callback
--   
onWidgetScrollEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetScrollEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the scrollEvent signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #scrollEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetScrollEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetScrollEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionClearEvent signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #selectionClearEvent callback
--   
onWidgetSelectionClearEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionClearEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionClearEvent signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #selectionClearEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetSelectionClearEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionClearEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionGet signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #selectionGet callback
--   
onWidgetSelectionGet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionGetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionGet signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #selectionGet callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetSelectionGet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionGetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionNotifyEvent signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on widget #selectionNotifyEvent callback
--   
onWidgetSelectionNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionNotifyEvent signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after widget #selectionNotifyEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetSelectionNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionReceived signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #selectionReceived callback
--   
onWidgetSelectionReceived :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionReceivedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionReceived signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #selectionReceived callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetSelectionReceived :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionReceivedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionRequestEvent signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on widget #selectionRequestEvent callback
--   
onWidgetSelectionRequestEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionRequestEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionRequestEvent signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after widget #selectionRequestEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetSelectionRequestEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionRequestEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the show signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on widget #show callback
--   
onWidgetShow :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetShowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the show signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #show callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetShow :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetShowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showHelp signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #showHelp callback
--   
onWidgetShowHelp :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetShowHelpCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showHelp signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #showHelp callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetShowHelp :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetShowHelpCallback) -> m SignalHandlerId

-- | Connect a signal handler for the sizeAllocate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #sizeAllocate callback
--   
onWidgetSizeAllocate :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSizeAllocateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the sizeAllocate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #sizeAllocate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetSizeAllocate :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSizeAllocateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the stateChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #stateChanged callback
--   
onWidgetStateChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStateChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the stateChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #stateChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetStateChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStateChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the stateFlagsChanged signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #stateFlagsChanged callback
--   
onWidgetStateFlagsChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStateFlagsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the stateFlagsChanged signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #stateFlagsChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetStateFlagsChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStateFlagsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the styleSet signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #styleSet callback
--   
onWidgetStyleSet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStyleSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the styleSet signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #styleSet callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetStyleSet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStyleSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the styleUpdated signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #styleUpdated callback
--   
onWidgetStyleUpdated :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStyleUpdatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the styleUpdated signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #styleUpdated callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetStyleUpdated :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStyleUpdatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the touchEvent signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #touchEvent callback
--   
onWidgetTouchEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetTouchEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the touchEvent signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #touchEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetTouchEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetTouchEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unmap signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on widget #unmap callback
--   
onWidgetUnmap :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnmapCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unmap signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #unmap callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetUnmap :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnmapCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unmapEvent signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #unmapEvent callback
--   
onWidgetUnmapEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnmapEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unmapEvent signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #unmapEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetUnmapEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnmapEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unrealize signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on widget #unrealize callback
--   
onWidgetUnrealize :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnrealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unrealize signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after widget #unrealize callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetUnrealize :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnrealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the visibilityNotifyEvent signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on widget #visibilityNotifyEvent callback
--   
onWidgetVisibilityNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetVisibilityNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the visibilityNotifyEvent signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after widget #visibilityNotifyEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetVisibilityNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetVisibilityNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the windowStateEvent signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on widget #windowStateEvent callback
--   
onWidgetWindowStateEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetWindowStateEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the windowStateEvent signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after widget #windowStateEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterWidgetWindowStateEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetWindowStateEventCallback) -> m SignalHandlerId

-- | Get the value of the “app-paintable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #appPaintable
--   
getWidgetAppPaintable :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “app-paintable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #appPaintable := value ]
--   
setWidgetAppPaintable :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “app-paintable” property. This is rarely needed directly, but
--   it is used by new.
constructWidgetAppPaintable :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “can-default” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #canDefault
--   
getWidgetCanDefault :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “can-default” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #canDefault := value ]
--   
setWidgetCanDefault :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “can-default” property. This is rarely needed directly, but
--   it is used by new.
constructWidgetCanDefault :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “can-focus” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #canFocus
--   
getWidgetCanFocus :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “can-focus” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #canFocus := value ]
--   
setWidgetCanFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “can-focus” property. This is rarely needed directly, but it
--   is used by new.
constructWidgetCanFocus :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “composite-child” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #compositeChild
--   
getWidgetCompositeChild :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Get the value of the “double-buffered” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #doubleBuffered
--   
getWidgetDoubleBuffered :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “double-buffered” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #doubleBuffered := value ]
--   
setWidgetDoubleBuffered :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “double-buffered” property. This is rarely needed directly,
--   but it is used by new.
constructWidgetDoubleBuffered :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “events” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #events
--   
getWidgetEvents :: (MonadIO m, IsWidget o) => o -> m [EventMask]

-- | Set the value of the “events” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #events := value ]
--   
setWidgetEvents :: (MonadIO m, IsWidget o) => o -> [EventMask] -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “events” property. This is rarely needed directly, but it is
--   used by new.
constructWidgetEvents :: (IsWidget o, MonadIO m) => [EventMask] -> m (GValueConstruct o)

-- | Get the value of the “expand” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #expand
--   
getWidgetExpand :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “expand” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #expand := value ]
--   
setWidgetExpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “expand” property. This is rarely needed directly, but it is
--   used by new.
constructWidgetExpand :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “focus-on-click” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #focusOnClick
--   
getWidgetFocusOnClick :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “focus-on-click” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #focusOnClick := value ]
--   
setWidgetFocusOnClick :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “focus-on-click” property. This is rarely needed directly,
--   but it is used by new.
constructWidgetFocusOnClick :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “halign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #halign
--   
getWidgetHalign :: (MonadIO m, IsWidget o) => o -> m Align

-- | Set the value of the “halign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #halign := value ]
--   
setWidgetHalign :: (MonadIO m, IsWidget o) => o -> Align -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “halign” property. This is rarely needed directly, but it is
--   used by new.
constructWidgetHalign :: (IsWidget o, MonadIO m) => Align -> m (GValueConstruct o)

-- | Get the value of the “has-default” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #hasDefault
--   
getWidgetHasDefault :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “has-default” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #hasDefault := value ]
--   
setWidgetHasDefault :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-default” property. This is rarely needed directly, but
--   it is used by new.
constructWidgetHasDefault :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “has-focus” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #hasFocus
--   
getWidgetHasFocus :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “has-focus” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #hasFocus := value ]
--   
setWidgetHasFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-focus” property. This is rarely needed directly, but it
--   is used by new.
constructWidgetHasFocus :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “has-tooltip” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #hasTooltip
--   
getWidgetHasTooltip :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “has-tooltip” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #hasTooltip := value ]
--   
setWidgetHasTooltip :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-tooltip” property. This is rarely needed directly, but
--   it is used by new.
constructWidgetHasTooltip :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “height-request” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #heightRequest
--   
getWidgetHeightRequest :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “height-request” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #heightRequest := value ]
--   
setWidgetHeightRequest :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “height-request” property. This is rarely needed directly,
--   but it is used by new.
constructWidgetHeightRequest :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “hexpand” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #hexpand
--   
getWidgetHexpand :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “hexpand” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #hexpand := value ]
--   
setWidgetHexpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “hexpand” property. This is rarely needed directly, but it is
--   used by new.
constructWidgetHexpand :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “hexpand-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #hexpandSet
--   
getWidgetHexpandSet :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “hexpand-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #hexpandSet := value ]
--   
setWidgetHexpandSet :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “hexpand-set” property. This is rarely needed directly, but
--   it is used by new.
constructWidgetHexpandSet :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “is-focus” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #isFocus
--   
getWidgetIsFocus :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “is-focus” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #isFocus := value ]
--   
setWidgetIsFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “is-focus” property. This is rarely needed directly, but it
--   is used by new.
constructWidgetIsFocus :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #margin
--   
getWidgetMargin :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #margin := value ]
--   
setWidgetMargin :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “margin” property. This is rarely needed directly, but it is
--   used by new.
constructWidgetMargin :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “margin-bottom” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #marginBottom
--   
getWidgetMarginBottom :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “margin-bottom” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #marginBottom := value ]
--   
setWidgetMarginBottom :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “margin-bottom” property. This is rarely needed directly, but
--   it is used by new.
constructWidgetMarginBottom :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “margin-end” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #marginEnd
--   
getWidgetMarginEnd :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “margin-end” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #marginEnd := value ]
--   
setWidgetMarginEnd :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “margin-end” property. This is rarely needed directly, but it
--   is used by new.
constructWidgetMarginEnd :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “margin-left” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #marginLeft
--   
getWidgetMarginLeft :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “margin-left” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #marginLeft := value ]
--   
setWidgetMarginLeft :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “margin-left” property. This is rarely needed directly, but
--   it is used by new.
constructWidgetMarginLeft :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “margin-right” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #marginRight
--   
getWidgetMarginRight :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “margin-right” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #marginRight := value ]
--   
setWidgetMarginRight :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “margin-right” property. This is rarely needed directly, but
--   it is used by new.
constructWidgetMarginRight :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “margin-start” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #marginStart
--   
getWidgetMarginStart :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “margin-start” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #marginStart := value ]
--   
setWidgetMarginStart :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “margin-start” property. This is rarely needed directly, but
--   it is used by new.
constructWidgetMarginStart :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “margin-top” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #marginTop
--   
getWidgetMarginTop :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “margin-top” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #marginTop := value ]
--   
setWidgetMarginTop :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “margin-top” property. This is rarely needed directly, but it
--   is used by new.
constructWidgetMarginTop :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “name” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get widget #name
--   
getWidgetName :: (MonadIO m, IsWidget o) => o -> m Text

-- | Set the value of the “name” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set widget [ #name := value ]
--   
setWidgetName :: (MonadIO m, IsWidget o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “name” property. This is rarely needed directly, but it is
--   used by new.
constructWidgetName :: (IsWidget o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “no-show-all” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #noShowAll
--   
getWidgetNoShowAll :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “no-show-all” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #noShowAll := value ]
--   
setWidgetNoShowAll :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “no-show-all” property. This is rarely needed directly, but
--   it is used by new.
constructWidgetNoShowAll :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “opacity” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #opacity
--   
getWidgetOpacity :: (MonadIO m, IsWidget o) => o -> m Double

-- | Set the value of the “opacity” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #opacity := value ]
--   
setWidgetOpacity :: (MonadIO m, IsWidget o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “opacity” property. This is rarely needed directly, but it is
--   used by new.
constructWidgetOpacity :: (IsWidget o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “parent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #parent
--   
getWidgetParent :: (MonadIO m, IsWidget o) => o -> m (Maybe Container)

-- | Set the value of the “parent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #parent := value ]
--   
setWidgetParent :: (MonadIO m, IsWidget o, IsContainer a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “parent” property. This is rarely needed directly, but it is
--   used by new.
constructWidgetParent :: (IsWidget o, MonadIO m, IsContainer a) => a -> m (GValueConstruct o)

-- | Set the value of the “parent” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #parent
--   
clearWidgetParent :: (MonadIO m, IsWidget o) => o -> m ()

-- | Get the value of the “receives-default” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #receivesDefault
--   
getWidgetReceivesDefault :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “receives-default” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #receivesDefault := value ]
--   
setWidgetReceivesDefault :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “receives-default” property. This is rarely needed directly,
--   but it is used by new.
constructWidgetReceivesDefault :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “scale-factor” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #scaleFactor
--   
getWidgetScaleFactor :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Get the value of the “sensitive” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #sensitive
--   
getWidgetSensitive :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “sensitive” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #sensitive := value ]
--   
setWidgetSensitive :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “sensitive” property. This is rarely needed directly, but it
--   is used by new.
constructWidgetSensitive :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #style
--   
getWidgetStyle :: (MonadIO m, IsWidget o) => o -> m Style

-- | Set the value of the “style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #style := value ]
--   
setWidgetStyle :: (MonadIO m, IsWidget o, IsStyle a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “style” property. This is rarely needed directly, but it is
--   used by new.
constructWidgetStyle :: (IsWidget o, MonadIO m, IsStyle a) => a -> m (GValueConstruct o)

-- | Set the value of the “style” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #style
--   
clearWidgetStyle :: (MonadIO m, IsWidget o) => o -> m ()

-- | Get the value of the “tooltip-markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #tooltipMarkup
--   
getWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> m (Maybe Text)

-- | Set the value of the “tooltip-markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #tooltipMarkup := value ]
--   
setWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tooltip-markup” property. This is rarely needed directly,
--   but it is used by new.
constructWidgetTooltipMarkup :: (IsWidget o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “tooltip-markup” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #tooltipMarkup
--   
clearWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> m ()

-- | Get the value of the “tooltip-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #tooltipText
--   
getWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> m (Maybe Text)

-- | Set the value of the “tooltip-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #tooltipText := value ]
--   
setWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tooltip-text” property. This is rarely needed directly, but
--   it is used by new.
constructWidgetTooltipText :: (IsWidget o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “tooltip-text” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #tooltipText
--   
clearWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> m ()

-- | Get the value of the “valign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #valign
--   
getWidgetValign :: (MonadIO m, IsWidget o) => o -> m Align

-- | Set the value of the “valign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #valign := value ]
--   
setWidgetValign :: (MonadIO m, IsWidget o) => o -> Align -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “valign” property. This is rarely needed directly, but it is
--   used by new.
constructWidgetValign :: (IsWidget o, MonadIO m) => Align -> m (GValueConstruct o)

-- | Get the value of the “vexpand” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #vexpand
--   
getWidgetVexpand :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “vexpand” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #vexpand := value ]
--   
setWidgetVexpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “vexpand” property. This is rarely needed directly, but it is
--   used by new.
constructWidgetVexpand :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “vexpand-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #vexpandSet
--   
getWidgetVexpandSet :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “vexpand-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #vexpandSet := value ]
--   
setWidgetVexpandSet :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “vexpand-set” property. This is rarely needed directly, but
--   it is used by new.
constructWidgetVexpandSet :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #visible
--   
getWidgetVisible :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #visible := value ]
--   
setWidgetVisible :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible” property. This is rarely needed directly, but it is
--   used by new.
constructWidgetVisible :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “width-request” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #widthRequest
--   
getWidgetWidthRequest :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “width-request” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widget [ #widthRequest := value ]
--   
setWidgetWidthRequest :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “width-request” property. This is rarely needed directly, but
--   it is used by new.
constructWidgetWidthRequest :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “window” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widget #window
--   
getWidgetWindow :: (MonadIO m, IsWidget o) => o -> m (Maybe Window)

-- | Determines whether an accelerator that activates the signal identified
--   by signalId can currently be activated. This is done
--   by emitting the Widget::canActivateAccel signal on
--   widget; 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.
--   
--   Since: 2.4
widgetCanActivateAccel :: (HasCallStack, MonadIO m, IsWidget a) => a -> Word32 -> m Bool

-- | Same as widgetPath, but always uses the name of a widget’s
--   type, never uses a custom name set with widgetSetName.
widgetClassPath :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Word32, Text, Text)

-- | Creates a new Layout with the appropriate font map, font
--   description, and base direction for drawing text for this widget.
--   
--   If you keep a Layout created in this way around, you need to
--   re-create it when the widget Context is replaced. This can be
--   tracked by using the Widget::screenChanged signal on the
--   widget.
widgetCreatePangoLayout :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Text -> m Layout

-- | Returns True if device has been shadowed by a
--   GTK+ device grab on another widget, so it would stop sending events to
--   widget. This may be used in the
--   Widget::grabNotify signal to check for specific devices. See
--   deviceGrabAdd.
--   
--   Since: 3.0
widgetDeviceIsShadowed :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> m Bool

-- | This function is equivalent to widgetDragBeginWithCoordinates,
--   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 (startX,
--   startY) and ending at (currentX,
--   currentY) 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 SelectionData to the target
--   list of the drag destination. The targets are added with
--   info = 0. If you need another value, use
--   targetListAddImageTargets and
--   widgetDragDestSetTargetList.
--   
--   Since: 2.6
widgetDragDestAddImageTargets :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Add the text targets supported by SelectionData to the target
--   list of the drag destination. The targets are added with
--   info = 0. If you need another value, use
--   targetListAddTextTargets and
--   widgetDragDestSetTargetList.
--   
--   Since: 2.6
widgetDragDestAddTextTargets :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Add the URI targets supported by SelectionData to the target
--   list of the drag destination. The targets are added with
--   info = 0. If you need another value, use
--   targetListAddUriTargets and widgetDragDestSetTargetList.
--   
--   Since: 2.6
widgetDragDestAddUriTargets :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Returns whether the widget has been configured to always emit
--   Widget::dragMotion signals.
--   
--   Since: 2.10
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 ()

-- | Tells the widget to emit Widget::dragMotion and
--   Widget::dragLeave events regardless of the targets and the
--   DestDefaultsMotion flag.
--   
--   This may be used when a widget wants to do generic actions regardless
--   of the targets that the source offers.
--   
--   Since: 2.10
widgetDragDestSetTrackMotion :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Clears information about a drop destination set with
--   widgetDragDestSet. The widget will no longer receive
--   notification of drags.
widgetDragDestUnset :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Add the writable image targets supported by SelectionData to
--   the target list of the drag source. The targets are added with
--   info = 0. If you need another value, use
--   targetListAddImageTargets and
--   widgetDragSourceSetTargetList.
--   
--   Since: 2.6
widgetDragSourceAddImageTargets :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Add the text targets supported by SelectionData to the target
--   list of the drag source. The targets are added with
--   info = 0. If you need another value, use
--   targetListAddTextTargets and
--   widgetDragSourceSetTargetList.
--   
--   Since: 2.6
widgetDragSourceAddTextTargets :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Add the URI targets supported by SelectionData to the target
--   list of the drag source. The targets are added with
--   info = 0. If you need another value, use
--   targetListAddUriTargets and
--   widgetDragSourceSetTargetList.
--   
--   Since: 2.6
widgetDragSourceAddUriTargets :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Gets the list of targets this widget can provide for drag-and-drop.
--   
--   Since: 2.4
widgetDragSourceGetTargetList :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe TargetList)

-- | Sets the icon that will be used for drags from a particular source to
--   icon. See the docs for IconTheme for more
--   details.
--   
--   Since: 3.2
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 IconTheme for more details.
--   
--   Since: 2.8
widgetDragSourceSetIconName :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> 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 ()

-- | Undoes the effects of widgetDragSourceSet.
widgetDragSourceUnset :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Ensures that widget has a style
--   (widget->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 ()

-- | Returns the accessible object that describes the widget to an
--   assistive technology.
--   
--   If accessibility support is not available, this Object instance
--   may be a no-op. Likewise, if no class-specific Object
--   implementation is available for the widget instance in question, it
--   will inherit an Object implementation from the first ancestor
--   class for which such an implementation is defined.
--   
--   The documentation of the ATK library contains more information
--   about accessible objects and their uses.
widgetGetAccessible :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Object

-- | Retrieves the ActionGroup that was registered using
--   prefix. The resulting ActionGroup may have been
--   registered to widget or any Widget in its
--   ancestry.
--   
--   If no action group was found matching prefix, then
--   Nothing is returned.
--   
--   Since: 3.16
widgetGetActionGroup :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m (Maybe ActionGroup)

-- | Returns the baseline that has currently been allocated to
--   widget. This function is intended to be used when
--   implementing handlers for the Widget::draw function, and when
--   allocating child widgets in
--   Widget::size_allocate.
--   
--   Since: 3.10
widgetGetAllocatedBaseline :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Retrieves the widget’s allocated size.
--   
--   This function returns the last values passed to
--   widgetSizeAllocateWithBaseline. The value differs from the size
--   returned in widgetGetAllocation in that functions like
--   widgetSetHalign can adjust the allocation, but not the value
--   returned by this function.
--   
--   If a widget is not visible, its allocated size is 0.
--   
--   Since: 3.20
widgetGetAllocatedSize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Rectangle, Int32)

-- | Determines whether the application intends to draw on the widget in an
--   Widget::draw handler.
--   
--   See widgetSetAppPaintable
--   
--   Since: 2.18
widgetGetAppPaintable :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines whether widget can be a default widget. See
--   widgetSetCanDefault.
--   
--   Since: 2.18
widgetGetCanDefault :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines whether widget can own the input focus. See
--   widgetSetCanFocus.
--   
--   Since: 2.18
widgetGetCanFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | This function is only for use in widget implementations. Obtains
--   widget->requisition, unless someone has forced a
--   particular geometry on the widget (e.g. with
--   widgetSetSizeRequest), in which case it returns that geometry
--   instead of the widget's requisition.
--   
--   This function differs from widgetSizeRequest in that it
--   retrieves the last size request value from
--   widget->requisition, while widgetSizeRequest
--   actually calls the "size_request" method on widget to
--   compute the size request and fill in
--   widget->requisition, and only then returns
--   widget->requisition.
--   
--   Because this function does not call the “size_request” method, it can
--   only be used when you know that widget->requisition
--   is up-to-date, that is, widgetSizeRequest has been called since
--   the last time a resize was queued. In general, only container
--   implementations have this information; applications should use
--   widgetSizeRequest.
widgetGetChildRequisition :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Requisition

-- | Gets the value set with widgetSetChildVisible. 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 widget'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 widgetGetAllocation.
--   
--   Since: 3.14
widgetGetClip :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Rectangle

-- | Returns the clipboard object for the given selection to be used with
--   widget. widget must have a
--   Display associated with it, so must be attached to a toplevel
--   window.
--   
--   Since: 2.2
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 device can interact with
--   widget and its children. See
--   widgetSetDeviceEnabled.
--   
--   Since: 3.0
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
--   device operates on it.
--   
--   Since: 3.0
widgetGetDeviceEvents :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> m [EventMask]

-- | Get the Display 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 Window 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.
--   
--   Since: 2.2
widgetGetDisplay :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Display

-- | Determines whether the widget is double buffered.
--   
--   See widgetSetDoubleBuffered
--   
--   Since: 2.18
widgetGetDoubleBuffered :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Returns the event mask (see EventMask) 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 widgetSetEvents or
--   widgetAddEvents, and the event mask necessary to cater for
--   every EventController 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 widgetSetFocusOnClick.
--   
--   Since: 3.20
widgetGetFocusOnClick :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the font map that has been set with widgetSetFontMap.
--   
--   Since: 3.18
widgetGetFontMap :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe FontMap)

-- | Returns the FontOptions used for Pango rendering. When not set,
--   the defaults font options for the Screen will be used.
--   
--   Since: 3.18
widgetGetFontOptions :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe FontOptions)

-- | Gets the value of the Widget:halign property.
--   
--   For backwards compatibility reasons this method will never return
--   AlignBaseline, but instead it will convert it to
--   AlignFill. 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
--   Widget:hasTooltip for more information.
--   
--   Since: 2.12
widgetGetHasTooltip :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Whether the widget is mapped.
--   
--   Since: 2.20
widgetGetMapped :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the value of the Widget:marginBottom property.
--   
--   Since: 3.0
widgetGetMarginBottom :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Gets the value of the Widget:marginEnd property.
--   
--   Since: 3.12
widgetGetMarginEnd :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Gets the value of the Widget:marginLeft property.
--   
--   Since: 3.0
widgetGetMarginLeft :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Gets the value of the Widget:marginRight property.
--   
--   Since: 3.0
widgetGetMarginRight :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Gets the value of the Widget:marginStart property.
--   
--   Since: 3.12
widgetGetMarginStart :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Gets the value of the Widget:marginTop property.
--   
--   Since: 3.0
widgetGetMarginTop :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Returns the modifier mask the widget’s windowing
--   system backend uses for a particular purpose.
--   
--   See keymapGetModifierMask.
--   
--   Since: 3.4
widgetGetModifierMask :: (HasCallStack, MonadIO m, IsWidget a) => a -> ModifierIntent -> m [ModifierType]

-- | Returns the current value of the Widget:noShowAll property,
--   which determines whether calls to widgetShowAll will affect
--   this widget.
--   
--   Since: 2.4
widgetGetNoShowAll :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Fetches the requested opacity for this widget. See
--   widgetSetOpacity.
--   
--   Since: 3.8
widgetGetOpacity :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Double

-- | Returns the parent container of widget.
widgetGetParent :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Widget)

-- | Returns the WidgetPath representing widget, 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 widget->window coordinates for widgets
--   that return True for widgetGetHasWindow; and are
--   relative to widget->allocation.x,
--   widget->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
--   GtkWidgetClassadjust_size_request virtual method and by any
--   GtkSizeGroups 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.
--   
--   Since: 3.0
widgetGetPreferredHeight :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Int32, Int32)

-- | Retrieves a widget’s minimum and natural height if it would be given
--   the specified width.
--   
--   The returned request will be modified by the
--   GtkWidgetClassadjust_size_request virtual method and by any
--   GtkSizeGroups 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.
--   
--   Since: 3.0
widgetGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m (Int32, Int32)

-- | 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
--   GtkWidgetClassadjust_size_request virtual method and by any
--   GtkSizeGroups 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.
--   
--   Since: 3.0
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 height.
--   
--   The returned request will be modified by the
--   GtkWidgetClassadjust_size_request virtual method and by any
--   GtkSizeGroups 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.
--   
--   Since: 3.0
widgetGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m (Int32, Int32)

-- | Determines whether widget is realized.
--   
--   Since: 2.20
widgetGetRealized :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines whether widget is always treated as the
--   default widget within its toplevel when it has the focus, even if
--   another widget is the default.
--   
--   See widgetSetReceivesDefault.
--   
--   Since: 2.18
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.
--   
--   Bin 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.
--   
--   Since: 3.0
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
--   widgetQueueResize instead of widgetQueueDraw).
--   
--   Normally, widgetSizeRequest should be used.
--   
--   Since: 2.20
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 Window at the top.
--   
--   The root window is useful for such purposes as creating a popup
--   Window 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.
--   
--   Since: 2.2
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 windowGetScaleFactor.
--   
--   Since: 3.10
widgetGetScaleFactor :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Returns the widget’s sensitivity (in the sense of returning the value
--   that has been set using widgetSetSensitive).
--   
--   The effective sensitivity of a widget is however determined by both
--   its own and its parent widget’s sensitivity. See
--   widgetIsSensitive.
--   
--   Since: 2.18
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 Widget is
--   attached to a toplevel, since the settings object is specific to a
--   particular Screen.
widgetGetSettings :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Settings

-- | Gets the size request that was explicitly set for the widget using
--   widgetSetSizeRequest. A value of -1 stored in
--   width or height indicates that that
--   dimension has not been set explicitly and the natural requisition of
--   the widget will be used instead. See widgetSetSizeRequest. To
--   get the size a widget will actually request, call
--   widgetGetPreferredSize instead of this function.
widgetGetSizeRequest :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Int32, Int32)

-- | Simply an accessor function that returns
--   widget->style.
widgetGetStyle :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Style

-- | Returns True if widget is multiple pointer
--   aware. See widgetSetSupportMultidevice for more information.
widgetGetSupportMultidevice :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the contents of the tooltip for widget.
--   
--   Since: 2.12
widgetGetTooltipMarkup :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Text)

-- | Gets the contents of the tooltip for widget.
--   
--   Since: 2.12
widgetGetTooltipText :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Text)

-- | Returns the Window of the current tooltip. This can be the
--   GtkWindow created by default, or the custom tooltip window set using
--   widgetSetTooltipWindow.
--   
--   Since: 2.12
widgetGetTooltipWindow :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Window

-- | Gets the value of the Widget:valign property.
--   
--   For backwards compatibility reasons this method will never return
--   AlignBaseline, but instead it will convert it to
--   AlignFill. If your widget want to support baseline aligned
--   children it must use widgetGetValignWithBaseline, or
--   g_object_get (widget, "valign", &value, NULL), which will
--   also report the true value.
widgetGetValign :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Align

-- | Gets whether widgetSetVexpand has been used to explicitly set
--   the expand flag on this widget.
--   
--   See widgetGetHexpandSet for more detail.
widgetGetVexpandSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the visual that will be used to render widget.
widgetGetVisual :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Visual

-- | Determines whether widget is the current default
--   widget within its toplevel. See widgetSetCanDefault.
--   
--   Since: 2.18
widgetHasDefault :: (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 widgetGrabAdd.
--   
--   Since: 2.18
widgetHasGrab :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines if the widget style has been looked up through the rc
--   mechanism.
--   
--   Since: 2.20
widgetHasRcStyle :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Checks whether there is a Screen 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.
--   
--   Since: 2.2
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
--   draw handlers that takes into account whether focus indication
--   should currently be shown in the toplevel window of
--   widget. See windowGetFocusVisible for more
--   information about focus indication.
--   
--   To find out if the widget has the global input focus, use
--   widgetHasFocus.
--   
--   Since: 3.2
widgetHasVisibleFocus :: (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
--   windowInputShapeCombineRegion for more information.
--   
--   Since: 3.0
widgetInputShapeCombineRegion :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Region -> m ()

-- | Computes the intersection of a widget’s area and
--   area, storing the intersection in
--   intersection, and returns True if there was an
--   intersection. intersection may be Nothing 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 widget is a toplevel widget.
--   
--   Currently only Window and Invisible (and out-of-process
--   GtkPlugs) are toplevel widgets. Toplevel widgets have
--   no parent widget.
--   
--   Since: 2.18
widgetIsToplevel :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Lists the closures used by widget for accelerator
--   group connections with accelGroupConnectByPath or
--   accelGroupConnect. The closures can be used to monitor
--   accelerator changes on widget, by connecting to the
--   gtkAccelGroupaccelChanged signal of the
--   AccelGroup of a closure which can be found out with
--   accelGroupFromAccelClosure.
widgetListAccelClosures :: (HasCallStack, MonadIO m, IsWidget a) => a -> m [GClosure b]

-- | Retrieves a Nothing-terminated array of strings containing the
--   prefixes of ActionGroup's available to widget.
--   
--   Since: 3.16
widgetListActionPrefixes :: (HasCallStack, MonadIO m, IsWidget a) => a -> m [Text]

-- | 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 Widget::mnemonicActivate signal.
widgetMnemonicActivate :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m Bool

-- | This function is only for use in widget implementations.
--   
--   Flags the widget for a rerun of the GtkWidgetClasssize_allocate
--   function. Use this function instead of widgetQueueResize when
--   the widget's size request didn't change but it wants
--   to reposition its contents.
--   
--   An example user of this function is widgetSetHalign.
--   
--   Since: 3.20
widgetQueueAllocate :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Mark widget as needing to recompute its expand flags.
--   Call this function when setting legacy expand child properties on the
--   child of a container.
--   
--   See widgetComputeExpand.
widgetQueueComputeExpand :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | This function works like widgetQueueResize, except that the
--   widget is not invalidated.
--   
--   Since: 2.4
widgetQueueResizeNoRedraw :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Computes the intersection of a widget’s area and
--   region, returning the intersection. The result may be
--   empty, use cairo_region_is_empty() to check.
widgetRegionIntersect :: (HasCallStack, MonadIO m, IsWidget a) => a -> Region -> m Region

-- | Removes an accelerator from widget, previously
--   installed with widgetAddAccelerator.
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 widgetListMnemonicLabels). The widget must have previously
--   been added to the list with widgetAddMnemonicLabel.
--   
--   Since: 2.4
widgetRemoveMnemonicLabel :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m ()

-- | Moves a widget from one Container 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 widget 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 (widgetGetHasWindow is False),
--   and that is normally done using containerPropagateDraw.
--   
--   If you want to force an area of a window to be redrawn, use
--   windowInvalidateRect or windowInvalidateRegion. To cause
--   the redraw to be done immediately, follow that call with a call to
--   windowProcessUpdates.
widgetSendExpose :: (HasCallStack, MonadIO m, IsWidget a) => a -> Event -> m Int32

-- | Sends the focus change event to widget
--   
--   This function is not meant to be used by applications. The only time
--   it should be used is when it is necessary for a Widget 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
--   TreeView.
--   
--   An example of its usage is:
--   
--   
C code
--   
--   
--   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
--   
--   fevent->focus_change.type = GDK_FOCUS_CHANGE;
--   fevent->focus_change.in = TRUE;
--   fevent->focus_change.window = _gtk_widget_get_window (widget);
--   if (fevent->focus_change.window != NULL)
--     g_object_ref (fevent->focus_change.window);
--   
--   gtk_widget_send_focus_change (widget, fevent);
--   
--   gdk_event_free (event);
--   
--   
--   Since: 2.20
widgetSendFocusChange :: (HasCallStack, MonadIO m, IsWidget a) => a -> Event -> m Bool

-- | 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
--   widgetSetAllocation (or after chaining up to the parent class),
--   because that function resets the clip.
--   
--   The clip set should be the area that widget draws on.
--   If widget is a Container, the area must contain
--   all children's clips.
--   
--   If this function is not called by widget during a
--   sizeAllocate handler, the clip will be set to
--   widget's allocation.
--   
--   Since: 3.14
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 widgetPushCompositeChild.
widgetSetCompositeName :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m ()

-- | Sets the FontOptions used for Pango rendering in this widget.
--   When not set, the default font options for the Screen will be
--   used.
--   
--   Since: 3.18
widgetSetFontOptions :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe FontOptions -> m ()

-- | Marks the widget as being mapped.
--   
--   This function should only ever be called in a derived widget's “map”
--   or “unmap” implementation.
--   
--   Since: 2.20
widgetSetMapped :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the bottom margin of widget. See the
--   Widget:marginBottom property.
--   
--   Since: 3.0
widgetSetMarginBottom :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets the end margin of widget. See the
--   Widget:marginEnd property.
--   
--   Since: 3.12
widgetSetMarginEnd :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets the left margin of widget. See the
--   Widget:marginLeft property.
--   
--   Since: 3.0
widgetSetMarginLeft :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets the right margin of widget. See the
--   Widget:marginRight property.
--   
--   Since: 3.0
widgetSetMarginRight :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets the start margin of widget. See the
--   Widget:marginStart property.
--   
--   Since: 3.12
widgetSetMarginStart :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets the top margin of widget. See the
--   Widget:marginTop property.
--   
--   Since: 3.0
widgetSetMarginTop :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets the Widget:noShowAll property, which determines whether
--   calls to widgetShowAll will affect this widget.
--   
--   This is mostly for use in constructing widget hierarchies with
--   externally controlled visibility, see UIManager.
--   
--   Since: 2.4
widgetSetNoShowAll :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets a non default parent window for widget.
--   
--   For Window classes, setting a parentWindow
--   effects whether the window is a toplevel window or can be embedded
--   into other widgets.
--   
--   For Window 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 GdkWindows for the widget
--   have been created and registered.
--   
--   This function should only ever be called in a derived widget's
--   “realize” or “unrealize” implementation.
--   
--   Since: 2.20
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 True 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 widgetGetHasWindow is False
--   setting this flag to False 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 widget->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 vertical alignment of widget. See the
--   Widget:valign property.
widgetSetValign :: (HasCallStack, MonadIO m, IsWidget a) => a -> Align -> m ()

-- | Sets whether the vexpand flag (see widgetGetVexpand) will be
--   used.
--   
--   See widgetSetHexpandSet for more detail.
widgetSetVexpandSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the visual that should be used for by widget and its children for
--   creating GdkWindows. The visual must be on the same
--   Screen as returned by widgetGetScreen, so handling the
--   Widget::screenChanged signal is necessary.
--   
--   Setting a new visual will not cause
--   widget to recreate its windows, so you should call
--   this function before widget 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 Widget::realize implementation. The
--   window passed is usually either new window created
--   with windowNew, or the window of its parent widget as returned
--   by widgetGetParentWindow.
--   
--   Widgets must indicate whether they will create their own Window
--   by calling widgetSetHasWindow. This is usually done in the
--   widget’s init() function.
--   
--   Note that this function does not add any reference to
--   window.
--   
--   Since: 2.18
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 windowShapeCombineRegion for more
--   information.
--   
--   Since: 3.0
widgetShapeCombineRegion :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Region -> m ()

-- | Shows a widget. If the widget is an unmapped toplevel widget (i.e. a
--   Window 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 attaches the widget’s Style to the widget's
--   Window. It is a replacement for
--   
--   
--   widget->style = gtk_style_attach (widget->style, widget->window);
--   
--   
--   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
--   Widget) would attach the style itself.
--   
--   Since: 2.20
widgetStyleAttach :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Gets the value of a style property of widget.
widgetStyleGetProperty :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> GValue -> m ()

-- | Translate coordinates relative to srcWidget’s
--   allocation to coordinates relative to destWidget’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
--   widget is located. See
--   tooltipTriggerTooltipQuery for more information.
--   
--   Since: 2.12
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 for use in widget implementations. Turns off flag
--   values for the current widget state (insensitive, prelighted, etc.).
--   See widgetSetStateFlags.
--   
--   Since: 3.0
widgetUnsetStateFlags :: (HasCallStack, MonadIO m, IsWidget a) => a -> [StateFlags] -> m ()

-- | Returns the default style used by all widgets initially.
widgetGetDefaultStyle :: (HasCallStack, MonadIO m) => m Style

-- | Replaces the widget packed into the tooltip with
--   customWidget. customWidget does not
--   get destroyed when the tooltip goes away. By default a box with a
--   Image and Label is embedded in the tooltip, which can be
--   configured using tooltipSetMarkup and tooltipSetIcon.
--   
--   Since: 2.12
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 the
--   icon indicated by gicon with the size indicated by
--   size. If gicon is Nothing, the
--   image will be hidden.
--   
--   Since: 2.20
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 iconName with the size indicated by
--   size. If iconName is Nothing,
--   the image will be hidden.
--   
--   Since: 2.14
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 stockId with the size
--   indicated by size. If stockId is
--   Nothing, the image will be hidden.
--   
--   Since: 2.12
tooltipSetIconFromStock :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe Text -> Int32 -> m ()

-- | No description available in the introspection data.
type TextTagTableTagRemovedCallback = TextTag -> IO ()

-- | No description available in the introspection data.
type TextTagTableTagChangedCallback = TextTag -> Bool -> IO ()

-- | No description available in the introspection data.
type TextTagTableTagAddedCallback = TextTag -> IO ()

-- | Connect a signal handler for the tagAdded signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textTagTable #tagAdded callback
--   
onTextTagTableTagAdded :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the tagAdded signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textTagTable #tagAdded callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextTagTableTagAdded :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the tagChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textTagTable #tagChanged callback
--   
onTextTagTableTagChanged :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the tagChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textTagTable #tagChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextTagTableTagChanged :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the tagRemoved signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textTagTable #tagRemoved callback
--   
onTextTagTableTagRemoved :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagRemovedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the tagRemoved signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textTagTable #tagRemoved callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextTagTableTagRemoved :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagRemovedCallback) -> m SignalHandlerId

-- | Creates a new TextTagTable. 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.
--   
--   tag 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 TextBuffer has
--   table 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 ()

-- | The event signal is emitted when an event occurs on a region of
--   the buffer marked with this tag.
type TextTagEventCallback = Object -> Event -> TextIter -> IO Bool

-- | Connect a signal handler for the event signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on textTag #event callback
--   
onTextTagEvent :: (IsTextTag a, MonadIO m) => a -> ((?self :: a) => TextTagEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the event signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textTag #event callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextTagEvent :: (IsTextTag a, MonadIO m) => a -> ((?self :: a) => TextTagEventCallback) -> m SignalHandlerId

-- | Get the value of the “accumulative-margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #accumulativeMargin
--   
getTextTagAccumulativeMargin :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “accumulative-margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #accumulativeMargin := value ]
--   
setTextTagAccumulativeMargin :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accumulative-margin” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagAccumulativeMargin :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Set the value of the “background” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #background := value ]
--   
setTextTagBackground :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagBackground :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “background” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #background
--   
clearTextTagBackground :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “background-full-height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #backgroundFullHeight
--   
getTextTagBackgroundFullHeight :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “background-full-height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #backgroundFullHeight := value ]
--   
setTextTagBackgroundFullHeight :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background-full-height” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagBackgroundFullHeight :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “background-full-height-set” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get textTag #backgroundFullHeightSet
--   
getTextTagBackgroundFullHeightSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “background-full-height-set” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #backgroundFullHeightSet := value ]
--   
setTextTagBackgroundFullHeightSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background-full-height-set” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagBackgroundFullHeightSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “background-gdk” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #backgroundGdk
--   
getTextTagBackgroundGdk :: (MonadIO m, IsTextTag o) => o -> m (Maybe Color)

-- | Set the value of the “background-gdk” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #backgroundGdk := value ]
--   
setTextTagBackgroundGdk :: (MonadIO m, IsTextTag o) => o -> Color -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background-gdk” property. This is rarely needed directly,
--   but it is used by new.
constructTextTagBackgroundGdk :: (IsTextTag o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Set the value of the “background-gdk” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #backgroundGdk
--   
clearTextTagBackgroundGdk :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “background-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #backgroundRgba
--   
getTextTagBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “background-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #backgroundRgba := value ]
--   
setTextTagBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background-rgba” property. This is rarely needed directly,
--   but it is used by new.
constructTextTagBackgroundRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “background-rgba” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #backgroundRgba
--   
clearTextTagBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “background-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #backgroundSet
--   
getTextTagBackgroundSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “background-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #backgroundSet := value ]
--   
setTextTagBackgroundSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background-set” property. This is rarely needed directly,
--   but it is used by new.
constructTextTagBackgroundSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “direction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #direction
--   
getTextTagDirection :: (MonadIO m, IsTextTag o) => o -> m TextDirection

-- | Set the value of the “direction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #direction := value ]
--   
setTextTagDirection :: (MonadIO m, IsTextTag o) => o -> TextDirection -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “direction” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagDirection :: (IsTextTag o, MonadIO m) => TextDirection -> m (GValueConstruct o)

-- | Get the value of the “editable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #editable
--   
getTextTagEditable :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “editable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #editable := value ]
--   
setTextTagEditable :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “editable” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagEditable :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “editable-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #editableSet
--   
getTextTagEditableSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “editable-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #editableSet := value ]
--   
setTextTagEditableSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “editable-set” property. This is rarely needed directly, but
--   it is used by new.
constructTextTagEditableSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “fallback” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #fallback
--   
getTextTagFallback :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “fallback” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #fallback := value ]
--   
setTextTagFallback :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “fallback” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagFallback :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “fallback-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #fallbackSet
--   
getTextTagFallbackSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “fallback-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #fallbackSet := value ]
--   
setTextTagFallbackSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “fallback-set” property. This is rarely needed directly, but
--   it is used by new.
constructTextTagFallbackSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “family” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #family
--   
getTextTagFamily :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Set the value of the “family” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #family := value ]
--   
setTextTagFamily :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “family” property. This is rarely needed directly, but it is
--   used by new.
constructTextTagFamily :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “family” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #family
--   
clearTextTagFamily :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “family-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #familySet
--   
getTextTagFamilySet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “family-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #familySet := value ]
--   
setTextTagFamilySet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “family-set” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagFamilySet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “font” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get textTag #font
--   
getTextTagFont :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Set the value of the “font” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set textTag [ #font := value ]
--   
setTextTagFont :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “font” property. This is rarely needed directly, but it is
--   used by new.
constructTextTagFont :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “font” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #font
--   
clearTextTagFont :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “font-desc” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #fontDesc
--   
getTextTagFontDesc :: (MonadIO m, IsTextTag o) => o -> m (Maybe FontDescription)

-- | Set the value of the “font-desc” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #fontDesc := value ]
--   
setTextTagFontDesc :: (MonadIO m, IsTextTag o) => o -> FontDescription -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “font-desc” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagFontDesc :: (IsTextTag o, MonadIO m) => FontDescription -> m (GValueConstruct o)

-- | Set the value of the “font-desc” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #fontDesc
--   
clearTextTagFontDesc :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “font-features” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #fontFeatures
--   
getTextTagFontFeatures :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Set the value of the “font-features” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #fontFeatures := value ]
--   
setTextTagFontFeatures :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “font-features” property. This is rarely needed directly, but
--   it is used by new.
constructTextTagFontFeatures :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “font-features” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #fontFeatures
--   
clearTextTagFontFeatures :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “font-features-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #fontFeaturesSet
--   
getTextTagFontFeaturesSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “font-features-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #fontFeaturesSet := value ]
--   
setTextTagFontFeaturesSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “font-features-set” property. This is rarely needed directly,
--   but it is used by new.
constructTextTagFontFeaturesSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Set the value of the “foreground” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #foreground := value ]
--   
setTextTagForeground :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “foreground” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagForeground :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “foreground” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #foreground
--   
clearTextTagForeground :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “foreground-gdk” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #foregroundGdk
--   
getTextTagForegroundGdk :: (MonadIO m, IsTextTag o) => o -> m (Maybe Color)

-- | Set the value of the “foreground-gdk” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #foregroundGdk := value ]
--   
setTextTagForegroundGdk :: (MonadIO m, IsTextTag o) => o -> Color -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “foreground-gdk” property. This is rarely needed directly,
--   but it is used by new.
constructTextTagForegroundGdk :: (IsTextTag o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Set the value of the “foreground-gdk” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #foregroundGdk
--   
clearTextTagForegroundGdk :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “foreground-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #foregroundRgba
--   
getTextTagForegroundRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “foreground-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #foregroundRgba := value ]
--   
setTextTagForegroundRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “foreground-rgba” property. This is rarely needed directly,
--   but it is used by new.
constructTextTagForegroundRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “foreground-rgba” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #foregroundRgba
--   
clearTextTagForegroundRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “foreground-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #foregroundSet
--   
getTextTagForegroundSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “foreground-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #foregroundSet := value ]
--   
setTextTagForegroundSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “foreground-set” property. This is rarely needed directly,
--   but it is used by new.
constructTextTagForegroundSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “indent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #indent
--   
getTextTagIndent :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “indent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #indent := value ]
--   
setTextTagIndent :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “indent” property. This is rarely needed directly, but it is
--   used by new.
constructTextTagIndent :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “indent-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #indentSet
--   
getTextTagIndentSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “indent-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #indentSet := value ]
--   
setTextTagIndentSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “indent-set” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagIndentSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “invisible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #invisible
--   
getTextTagInvisible :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “invisible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #invisible := value ]
--   
setTextTagInvisible :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “invisible” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagInvisible :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “invisible-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #invisibleSet
--   
getTextTagInvisibleSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “invisible-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #invisibleSet := value ]
--   
setTextTagInvisibleSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “invisible-set” property. This is rarely needed directly, but
--   it is used by new.
constructTextTagInvisibleSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “justification” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #justification
--   
getTextTagJustification :: (MonadIO m, IsTextTag o) => o -> m Justification

-- | Set the value of the “justification” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #justification := value ]
--   
setTextTagJustification :: (MonadIO m, IsTextTag o) => o -> Justification -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “justification” property. This is rarely needed directly, but
--   it is used by new.
constructTextTagJustification :: (IsTextTag o, MonadIO m) => Justification -> m (GValueConstruct o)

-- | Get the value of the “justification-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #justificationSet
--   
getTextTagJustificationSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “justification-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #justificationSet := value ]
--   
setTextTagJustificationSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “justification-set” property. This is rarely needed directly,
--   but it is used by new.
constructTextTagJustificationSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “language” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #language
--   
getTextTagLanguage :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Set the value of the “language” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #language := value ]
--   
setTextTagLanguage :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “language” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagLanguage :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “language” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #language
--   
clearTextTagLanguage :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “language-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #languageSet
--   
getTextTagLanguageSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “language-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #languageSet := value ]
--   
setTextTagLanguageSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “language-set” property. This is rarely needed directly, but
--   it is used by new.
constructTextTagLanguageSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “left-margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #leftMargin
--   
getTextTagLeftMargin :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “left-margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #leftMargin := value ]
--   
setTextTagLeftMargin :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “left-margin” property. This is rarely needed directly, but
--   it is used by new.
constructTextTagLeftMargin :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “left-margin-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #leftMarginSet
--   
getTextTagLeftMarginSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “left-margin-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #leftMarginSet := value ]
--   
setTextTagLeftMarginSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “left-margin-set” property. This is rarely needed directly,
--   but it is used by new.
constructTextTagLeftMarginSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “letter-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #letterSpacing
--   
getTextTagLetterSpacing :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “letter-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #letterSpacing := value ]
--   
setTextTagLetterSpacing :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “letter-spacing” property. This is rarely needed directly,
--   but it is used by new.
constructTextTagLetterSpacing :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “letter-spacing-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #letterSpacingSet
--   
getTextTagLetterSpacingSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “letter-spacing-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #letterSpacingSet := value ]
--   
setTextTagLetterSpacingSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “letter-spacing-set” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagLetterSpacingSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “name” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get textTag #name
--   
getTextTagName :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Construct a GValueConstruct with valid value for the
--   “name” property. This is rarely needed directly, but it is
--   used by new.
constructTextTagName :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “paragraph-background” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #paragraphBackground := value ]
--   
setTextTagParagraphBackground :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “paragraph-background” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagParagraphBackground :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “paragraph-background” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #paragraphBackground
--   
clearTextTagParagraphBackground :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “paragraph-background-gdk” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get textTag #paragraphBackgroundGdk
--   
getTextTagParagraphBackgroundGdk :: (MonadIO m, IsTextTag o) => o -> m (Maybe Color)

-- | Set the value of the “paragraph-background-gdk” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #paragraphBackgroundGdk := value ]
--   
setTextTagParagraphBackgroundGdk :: (MonadIO m, IsTextTag o) => o -> Color -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “paragraph-background-gdk” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagParagraphBackgroundGdk :: (IsTextTag o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Set the value of the “paragraph-background-gdk” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #paragraphBackgroundGdk
--   
clearTextTagParagraphBackgroundGdk :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “paragraph-background-rgba” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get textTag #paragraphBackgroundRgba
--   
getTextTagParagraphBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “paragraph-background-rgba” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #paragraphBackgroundRgba := value ]
--   
setTextTagParagraphBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “paragraph-background-rgba” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagParagraphBackgroundRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “paragraph-background-rgba” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #paragraphBackgroundRgba
--   
clearTextTagParagraphBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “paragraph-background-set” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get textTag #paragraphBackgroundSet
--   
getTextTagParagraphBackgroundSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “paragraph-background-set” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #paragraphBackgroundSet := value ]
--   
setTextTagParagraphBackgroundSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “paragraph-background-set” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagParagraphBackgroundSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “pixels-above-lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #pixelsAboveLines
--   
getTextTagPixelsAboveLines :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “pixels-above-lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #pixelsAboveLines := value ]
--   
setTextTagPixelsAboveLines :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixels-above-lines” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagPixelsAboveLines :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “pixels-above-lines-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #pixelsAboveLinesSet
--   
getTextTagPixelsAboveLinesSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “pixels-above-lines-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #pixelsAboveLinesSet := value ]
--   
setTextTagPixelsAboveLinesSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixels-above-lines-set” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagPixelsAboveLinesSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “pixels-below-lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #pixelsBelowLines
--   
getTextTagPixelsBelowLines :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “pixels-below-lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #pixelsBelowLines := value ]
--   
setTextTagPixelsBelowLines :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixels-below-lines” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagPixelsBelowLines :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “pixels-below-lines-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #pixelsBelowLinesSet
--   
getTextTagPixelsBelowLinesSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “pixels-below-lines-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #pixelsBelowLinesSet := value ]
--   
setTextTagPixelsBelowLinesSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixels-below-lines-set” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagPixelsBelowLinesSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “pixels-inside-wrap” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #pixelsInsideWrap
--   
getTextTagPixelsInsideWrap :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “pixels-inside-wrap” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #pixelsInsideWrap := value ]
--   
setTextTagPixelsInsideWrap :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixels-inside-wrap” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagPixelsInsideWrap :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “pixels-inside-wrap-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #pixelsInsideWrapSet
--   
getTextTagPixelsInsideWrapSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “pixels-inside-wrap-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #pixelsInsideWrapSet := value ]
--   
setTextTagPixelsInsideWrapSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixels-inside-wrap-set” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagPixelsInsideWrapSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “right-margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #rightMargin
--   
getTextTagRightMargin :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “right-margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #rightMargin := value ]
--   
setTextTagRightMargin :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “right-margin” property. This is rarely needed directly, but
--   it is used by new.
constructTextTagRightMargin :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “right-margin-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #rightMarginSet
--   
getTextTagRightMarginSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “right-margin-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #rightMarginSet := value ]
--   
setTextTagRightMarginSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “right-margin-set” property. This is rarely needed directly,
--   but it is used by new.
constructTextTagRightMarginSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “rise” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get textTag #rise
--   
getTextTagRise :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “rise” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set textTag [ #rise := value ]
--   
setTextTagRise :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “rise” property. This is rarely needed directly, but it is
--   used by new.
constructTextTagRise :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “rise-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #riseSet
--   
getTextTagRiseSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “rise-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #riseSet := value ]
--   
setTextTagRiseSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “rise-set” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagRiseSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “scale” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #scale
--   
getTextTagScale :: (MonadIO m, IsTextTag o) => o -> m Double

-- | Set the value of the “scale” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #scale := value ]
--   
setTextTagScale :: (MonadIO m, IsTextTag o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “scale” property. This is rarely needed directly, but it is
--   used by new.
constructTextTagScale :: (IsTextTag o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “scale-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #scaleSet
--   
getTextTagScaleSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “scale-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #scaleSet := value ]
--   
setTextTagScaleSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “scale-set” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagScaleSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “size” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get textTag #size
--   
getTextTagSize :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “size” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set textTag [ #size := value ]
--   
setTextTagSize :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “size” property. This is rarely needed directly, but it is
--   used by new.
constructTextTagSize :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “size-points” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #sizePoints
--   
getTextTagSizePoints :: (MonadIO m, IsTextTag o) => o -> m Double

-- | Set the value of the “size-points” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #sizePoints := value ]
--   
setTextTagSizePoints :: (MonadIO m, IsTextTag o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “size-points” property. This is rarely needed directly, but
--   it is used by new.
constructTextTagSizePoints :: (IsTextTag o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “size-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #sizeSet
--   
getTextTagSizeSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “size-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #sizeSet := value ]
--   
setTextTagSizeSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “size-set” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagSizeSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “stretch” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #stretch
--   
getTextTagStretch :: (MonadIO m, IsTextTag o) => o -> m Stretch

-- | Set the value of the “stretch” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #stretch := value ]
--   
setTextTagStretch :: (MonadIO m, IsTextTag o) => o -> Stretch -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “stretch” property. This is rarely needed directly, but it is
--   used by new.
constructTextTagStretch :: (IsTextTag o, MonadIO m) => Stretch -> m (GValueConstruct o)

-- | Get the value of the “stretch-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #stretchSet
--   
getTextTagStretchSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “stretch-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #stretchSet := value ]
--   
setTextTagStretchSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “stretch-set” property. This is rarely needed directly, but
--   it is used by new.
constructTextTagStretchSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “strikethrough” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #strikethrough
--   
getTextTagStrikethrough :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “strikethrough” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #strikethrough := value ]
--   
setTextTagStrikethrough :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “strikethrough” property. This is rarely needed directly, but
--   it is used by new.
constructTextTagStrikethrough :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “strikethrough-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #strikethroughRgba
--   
getTextTagStrikethroughRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “strikethrough-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #strikethroughRgba := value ]
--   
setTextTagStrikethroughRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “strikethrough-rgba” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagStrikethroughRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “strikethrough-rgba” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #strikethroughRgba
--   
clearTextTagStrikethroughRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “strikethrough-rgba-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #strikethroughRgbaSet
--   
getTextTagStrikethroughRgbaSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “strikethrough-rgba-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #strikethroughRgbaSet := value ]
--   
setTextTagStrikethroughRgbaSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “strikethrough-rgba-set” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagStrikethroughRgbaSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “strikethrough-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #strikethroughSet
--   
getTextTagStrikethroughSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “strikethrough-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #strikethroughSet := value ]
--   
setTextTagStrikethroughSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “strikethrough-set” property. This is rarely needed directly,
--   but it is used by new.
constructTextTagStrikethroughSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #style
--   
getTextTagStyle :: (MonadIO m, IsTextTag o) => o -> m Style

-- | Set the value of the “style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #style := value ]
--   
setTextTagStyle :: (MonadIO m, IsTextTag o) => o -> Style -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “style” property. This is rarely needed directly, but it is
--   used by new.
constructTextTagStyle :: (IsTextTag o, MonadIO m) => Style -> m (GValueConstruct o)

-- | Get the value of the “style-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #styleSet
--   
getTextTagStyleSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “style-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #styleSet := value ]
--   
setTextTagStyleSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “style-set” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagStyleSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “tabs” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get textTag #tabs
--   
getTextTagTabs :: (MonadIO m, IsTextTag o) => o -> m (Maybe TabArray)

-- | Set the value of the “tabs” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set textTag [ #tabs := value ]
--   
setTextTagTabs :: (MonadIO m, IsTextTag o) => o -> TabArray -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tabs” property. This is rarely needed directly, but it is
--   used by new.
constructTextTagTabs :: (IsTextTag o, MonadIO m) => TabArray -> m (GValueConstruct o)

-- | Set the value of the “tabs” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #tabs
--   
clearTextTagTabs :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “tabs-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #tabsSet
--   
getTextTagTabsSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “tabs-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #tabsSet := value ]
--   
setTextTagTabsSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tabs-set” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagTabsSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “underline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #underline
--   
getTextTagUnderline :: (MonadIO m, IsTextTag o) => o -> m Underline

-- | Set the value of the “underline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #underline := value ]
--   
setTextTagUnderline :: (MonadIO m, IsTextTag o) => o -> Underline -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “underline” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagUnderline :: (IsTextTag o, MonadIO m) => Underline -> m (GValueConstruct o)

-- | Get the value of the “underline-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #underlineRgba
--   
getTextTagUnderlineRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “underline-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #underlineRgba := value ]
--   
setTextTagUnderlineRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “underline-rgba” property. This is rarely needed directly,
--   but it is used by new.
constructTextTagUnderlineRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “underline-rgba” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #underlineRgba
--   
clearTextTagUnderlineRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “underline-rgba-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #underlineRgbaSet
--   
getTextTagUnderlineRgbaSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “underline-rgba-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #underlineRgbaSet := value ]
--   
setTextTagUnderlineRgbaSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “underline-rgba-set” property. This is rarely needed
--   directly, but it is used by new.
constructTextTagUnderlineRgbaSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “underline-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #underlineSet
--   
getTextTagUnderlineSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “underline-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #underlineSet := value ]
--   
setTextTagUnderlineSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “underline-set” property. This is rarely needed directly, but
--   it is used by new.
constructTextTagUnderlineSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “variant” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #variant
--   
getTextTagVariant :: (MonadIO m, IsTextTag o) => o -> m Variant

-- | Set the value of the “variant” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #variant := value ]
--   
setTextTagVariant :: (MonadIO m, IsTextTag o) => o -> Variant -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “variant” property. This is rarely needed directly, but it is
--   used by new.
constructTextTagVariant :: (IsTextTag o, MonadIO m) => Variant -> m (GValueConstruct o)

-- | Get the value of the “variant-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #variantSet
--   
getTextTagVariantSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “variant-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #variantSet := value ]
--   
setTextTagVariantSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “variant-set” property. This is rarely needed directly, but
--   it is used by new.
constructTextTagVariantSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “weight” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #weight
--   
getTextTagWeight :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “weight” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #weight := value ]
--   
setTextTagWeight :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “weight” property. This is rarely needed directly, but it is
--   used by new.
constructTextTagWeight :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “weight-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #weightSet
--   
getTextTagWeightSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “weight-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #weightSet := value ]
--   
setTextTagWeightSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “weight-set” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagWeightSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “wrap-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #wrapMode
--   
getTextTagWrapMode :: (MonadIO m, IsTextTag o) => o -> m WrapMode

-- | Set the value of the “wrap-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #wrapMode := value ]
--   
setTextTagWrapMode :: (MonadIO m, IsTextTag o) => o -> WrapMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “wrap-mode” property. This is rarely needed directly, but it
--   is used by new.
constructTextTagWrapMode :: (IsTextTag o, MonadIO m) => WrapMode -> m (GValueConstruct o)

-- | Get the value of the “wrap-mode-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textTag #wrapModeSet
--   
getTextTagWrapModeSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “wrap-mode-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textTag [ #wrapModeSet := value ]
--   
setTextTagWrapModeSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “wrap-mode-set” property. This is rarely needed directly, but
--   it is used by new.
constructTextTagWrapModeSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a TextTag. Configure the tag using object arguments,
--   i.e. using g_object_set().
textTagNew :: (HasCallStack, MonadIO m) => Maybe Text -> m TextTag

-- | Emits the TextTagTable::tagChanged signal on the
--   TextTagTable where the tag is included.
--   
--   The signal is already emitted when setting a TextTag property.
--   This function is useful for a TextTag subclass.
--   
--   Since: 3.20
textTagChanged :: (HasCallStack, MonadIO m, IsTextTag a) => a -> Bool -> m ()

-- | Emits the “event” signal on the TextTag.
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 TextTag. Valid priorities start at 0 and
--   go to one less than textTagTableGetSize. 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
--   gtk_text_buffer_create_tag(), which adds the tag to
--   the buffer’s table automatically.
textTagSetPriority :: (HasCallStack, MonadIO m, IsTextTag a) => a -> Int32 -> m ()

-- | Get the value of the “left-gravity” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textMark #leftGravity
--   
getTextMarkLeftGravity :: (MonadIO m, IsTextMark o) => o -> m Bool

-- | Construct a GValueConstruct with valid value for the
--   “left-gravity” property. This is rarely needed directly, but
--   it is used by new.
constructTextMarkLeftGravity :: (IsTextMark o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “name” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get textMark #name
--   
getTextMarkName :: (MonadIO m, IsTextMark o) => o -> m (Maybe Text)

-- | Construct a GValueConstruct with valid value for the
--   “name” property. This is rarely needed directly, but it is
--   used by new.
constructTextMarkName :: (IsTextMark o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Creates a text mark. Add it to a buffer using
--   textBufferAddMark. If name is Nothing,
--   the mark is anonymous; otherwise, the mark can be retrieved by name
--   using textBufferGetMark. 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
--   (leftGravity = False), 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).
--   
--   Since: 2.12
textMarkNew :: (HasCallStack, MonadIO m) => Maybe Text -> Bool -> m TextMark

-- | Gets the buffer this mark is located inside, or Nothing 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 True 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 mark; 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
--   objectRef) 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 g_list_free().
textChildAnchorGetWidgets :: (HasCallStack, MonadIO m, IsTextChildAnchor a) => a -> m [Widget]

-- | The removeTag signal is emitted to remove all occurrences of
--   tag from a range of text in a TextBuffer.
--   Removal actually occurs in the default handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the start and end iters (or
--   has to revalidate them).
--   
--   See also: textBufferRemoveTag.
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 textBufferPasteClipboard for more details.
--   
--   Since: 2.16
type TextBufferPasteDoneCallback = Clipboard -> IO ()

-- | The modifiedChanged signal is emitted when the modified bit of
--   a TextBuffer flips.
--   
--   See also: textBufferSetModified.
type TextBufferModifiedChangedCallback = IO ()

-- | The markSet signal is emitted as notification after a
--   TextMark is set.
--   
--   See also: textBufferCreateMark, textBufferMoveMark.
type TextBufferMarkSetCallback = TextIter -> TextMark -> IO ()

-- | The markDeleted signal is emitted as notification after a
--   TextMark is deleted.
--   
--   See also: textBufferDeleteMark.
type TextBufferMarkDeletedCallback = TextMark -> IO ()

-- | The insertText signal is emitted to insert text in a
--   TextBuffer. Insertion actually occurs in the default handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the location iter (or has to revalidate
--   it). The default signal handler revalidates it to point to the end of
--   the inserted text.
--   
--   See also: textBufferInsert, textBufferInsertRange.
type TextBufferInsertTextCallback = TextIter -> Text -> Int32 -> IO ()

-- | The insertPixbuf signal is emitted to insert a Pixbuf in
--   a TextBuffer. Insertion actually occurs in the default handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the location iter (or has to revalidate
--   it). The default signal handler revalidates it to be placed after the
--   inserted pixbuf.
--   
--   See also: textBufferInsertPixbuf.
type TextBufferInsertPixbufCallback = TextIter -> Pixbuf -> IO ()

-- | The insertChildAnchor signal is emitted to insert a
--   TextChildAnchor in a TextBuffer. Insertion actually
--   occurs in the default handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the location iter (or has to revalidate
--   it). The default signal handler revalidates it to be placed after the
--   inserted anchor.
--   
--   See also: textBufferInsertChildAnchor.
type TextBufferInsertChildAnchorCallback = TextIter -> TextChildAnchor -> IO ()

-- | The endUserAction signal is emitted at the end of a single
--   user-visible operation on the TextBuffer.
--   
--   See also: textBufferEndUserAction,
--   textBufferInsertInteractive,
--   textBufferInsertRangeInteractive,
--   textBufferDeleteInteractive, textBufferBackspace,
--   textBufferDeleteSelection, textBufferBackspace.
type TextBufferEndUserActionCallback = IO ()

-- | The deleteRange signal is emitted to delete a range from a
--   TextBuffer.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the start and end iters (or
--   has to revalidate them). The default signal handler revalidates the
--   start and end iters to both point to
--   the location where text was deleted. Handlers which run after the
--   default handler (see g_signal_connect_after()) do not
--   have access to the deleted text.
--   
--   See also: textBufferDelete.
type TextBufferDeleteRangeCallback = TextIter -> TextIter -> IO ()

-- | The changed signal is emitted when the content of a
--   TextBuffer has changed.
type TextBufferChangedCallback = IO ()

-- | The beginUserAction signal is emitted at the beginning of a
--   single user-visible operation on a TextBuffer.
--   
--   See also: textBufferBeginUserAction,
--   textBufferInsertInteractive,
--   textBufferInsertRangeInteractive,
--   textBufferDeleteInteractive, textBufferBackspace,
--   textBufferDeleteSelection.
type TextBufferBeginUserActionCallback = IO ()

-- | The applyTag signal is emitted to apply a tag to a range of
--   text in a TextBuffer. Applying actually occurs in the default
--   handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the start and end iters (or
--   has to revalidate them).
--   
--   See also: textBufferApplyTag,
--   gtk_text_buffer_insert_with_tags(),
--   textBufferInsertRange.
type TextBufferApplyTagCallback = TextTag -> TextIter -> TextIter -> IO ()

-- | Connect a signal handler for the applyTag signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textBuffer #applyTag callback
--   
onTextBufferApplyTag :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferApplyTagCallback) -> m SignalHandlerId

-- | Connect a signal handler for the applyTag signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textBuffer #applyTag callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextBufferApplyTag :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferApplyTagCallback) -> m SignalHandlerId

-- | Connect a signal handler for the beginUserAction signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on textBuffer #beginUserAction callback
--   
onTextBufferBeginUserAction :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferBeginUserActionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the beginUserAction signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after textBuffer #beginUserAction callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextBufferBeginUserAction :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferBeginUserActionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textBuffer #changed callback
--   
onTextBufferChanged :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textBuffer #changed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextBufferChanged :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deleteRange signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textBuffer #deleteRange callback
--   
onTextBufferDeleteRange :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferDeleteRangeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deleteRange signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textBuffer #deleteRange callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextBufferDeleteRange :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferDeleteRangeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the endUserAction signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on textBuffer #endUserAction callback
--   
onTextBufferEndUserAction :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferEndUserActionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the endUserAction signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after textBuffer #endUserAction callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextBufferEndUserAction :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferEndUserActionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertChildAnchor signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on textBuffer #insertChildAnchor callback
--   
onTextBufferInsertChildAnchor :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertChildAnchorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertChildAnchor signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after textBuffer #insertChildAnchor callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextBufferInsertChildAnchor :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertChildAnchorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertPixbuf signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textBuffer #insertPixbuf callback
--   
onTextBufferInsertPixbuf :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertPixbufCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertPixbuf signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textBuffer #insertPixbuf callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextBufferInsertPixbuf :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertPixbufCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertText signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textBuffer #insertText callback
--   
onTextBufferInsertText :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertText signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textBuffer #insertText callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextBufferInsertText :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the markDeleted signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textBuffer #markDeleted callback
--   
onTextBufferMarkDeleted :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferMarkDeletedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the markDeleted signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textBuffer #markDeleted callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextBufferMarkDeleted :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferMarkDeletedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the markSet signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textBuffer #markSet callback
--   
onTextBufferMarkSet :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferMarkSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the markSet signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textBuffer #markSet callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextBufferMarkSet :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferMarkSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the modifiedChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on textBuffer #modifiedChanged callback
--   
onTextBufferModifiedChanged :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferModifiedChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the modifiedChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after textBuffer #modifiedChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextBufferModifiedChanged :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferModifiedChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pasteDone signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textBuffer #pasteDone callback
--   
onTextBufferPasteDone :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferPasteDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pasteDone signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textBuffer #pasteDone callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextBufferPasteDone :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferPasteDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the removeTag signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textBuffer #removeTag callback
--   
onTextBufferRemoveTag :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferRemoveTagCallback) -> m SignalHandlerId

-- | Connect a signal handler for the removeTag signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textBuffer #removeTag callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextBufferRemoveTag :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferRemoveTagCallback) -> m SignalHandlerId

-- | Get the value of the “copy-target-list” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textBuffer #copyTargetList
--   
getTextBufferCopyTargetList :: (MonadIO m, IsTextBuffer o) => o -> m TargetList

-- | Get the value of the “cursor-position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textBuffer #cursorPosition
--   
getTextBufferCursorPosition :: (MonadIO m, IsTextBuffer o) => o -> m Int32

-- | Get the value of the “has-selection” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textBuffer #hasSelection
--   
getTextBufferHasSelection :: (MonadIO m, IsTextBuffer o) => o -> m Bool

-- | Get the value of the “paste-target-list” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textBuffer #pasteTargetList
--   
getTextBufferPasteTargetList :: (MonadIO m, IsTextBuffer o) => o -> m TargetList

-- | Get the value of the “tag-table” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textBuffer #tagTable
--   
getTextBufferTagTable :: (MonadIO m, IsTextBuffer o) => o -> m TextTagTable

-- | Construct a GValueConstruct with valid value for the
--   “tag-table” property. This is rarely needed directly, but it
--   is used by new.
constructTextBufferTagTable :: (IsTextBuffer o, MonadIO m, IsTextTagTable a) => a -> m (GValueConstruct o)

-- | Get the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get textBuffer #text
--   
getTextBufferText :: (MonadIO m, IsTextBuffer o) => o -> m (Maybe Text)

-- | Set the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set textBuffer [ #text := value ]
--   
setTextBufferText :: (MonadIO m, IsTextBuffer o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text” property. This is rarely needed directly, but it is
--   used by new.
constructTextBufferText :: (IsTextBuffer o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “text” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #text
--   
clearTextBufferText :: (MonadIO m, IsTextBuffer o) => o -> m ()

-- | Creates a new text buffer.
textBufferNew :: (HasCallStack, MonadIO m, IsTextTagTable a) => Maybe a -> m TextBuffer

-- | Calls textTagTableLookup on the buffer’s tag table to get a
--   TextTag, then calls textBufferApplyTag.
textBufferApplyTagByName :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> TextIter -> TextIter -> m ()

-- | Copies the currently-selected text to a clipboard.
textBufferCopyClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> m ()

-- | 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 the mark named name; the mark must exist. See
--   textBufferDeleteMark for details.
textBufferDeleteMarkByName :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> m ()

-- | This function deserializes rich text in format format
--   and inserts it at iter.
--   
--   formats to be used must be registered using
--   textBufferRegisterDeserializeFormat or
--   textBufferRegisterDeserializeTagset beforehand.
--   
--   Since: 2.10
textBufferDeserialize :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b) => a -> b -> Atom -> TextIter -> ByteString -> m ()

-- | This functions returns the value set with
--   textBufferDeserializeSetCanCreateTags
--   
--   Since: 2.10
textBufferDeserializeGetCanCreateTags :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Atom -> m Bool

-- | Retrieves the first and last iterators in the buffer, i.e. the entire
--   buffer lies within the range
--   [start,end).
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 buffer using
--   textBufferRegisterDeserializeFormat or
--   textBufferRegisterDeserializeTagset
--   
--   Since: 2.10
textBufferGetDeserializeFormats :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m [Atom]

-- | Initializes iter with the “end iterator,” one past the
--   last valid character in the text buffer. If dereferenced with
--   textIterGetChar, the end iterator has a character value of 0.
--   The entire buffer lies in the range from the first position in the
--   buffer (call textBufferGetStartIter 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.
--   
--   Since: 2.10
textBufferGetHasSelection :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m Bool

-- | Returns the mark that represents the cursor (insertion point).
--   Equivalent to calling textBufferGetMark 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 anchor within
--   buffer.
textBufferGetIterAtChildAnchor :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextChildAnchor b) => a -> b -> m TextIter

-- | Initializes iter to the start of the given line. If
--   lineNumber is greater than the number of lines in the
--   buffer, the end iterator is returned.
textBufferGetIterAtLine :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> m TextIter

-- | Obtains an iterator pointing to byteIndex within the
--   given line. byteIndex 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 lineNumber is greater than
--   the number of lines in the buffer, the end iterator is
--   returned. And if byteIndex 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 charOffset 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 lineNumber is greater than
--   the number of lines in the buffer, the end iterator is
--   returned. And if charOffset 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 iter with the current position of
--   mark.
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
--   textBufferSetModified set the modification flag to
--   False. 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 textBufferGetMark to get the mark named
--   “selection_bound”, but very slightly more efficient, and involves less
--   typing.
--   
--   The currently-selected text in buffer 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. textBufferGetSelectionBounds 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

-- | This function returns the rich text serialize formats registered with
--   buffer using textBufferRegisterSerializeFormat
--   or textBufferRegisterSerializeTagset
--   
--   Since: 2.10
textBufferGetSerializeFormats :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m [Atom]

-- | Get the TextTagTable associated with this buffer.
textBufferGetTagTable :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextTagTable

-- | Simply calls textBufferInsert, using the current cursor
--   position as the insertion point.
textBufferInsertAtCursor :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> Int32 -> m ()

-- | Calls textBufferInsertInteractive at the cursor position.
--   
--   defaultEditable indicates the editability of text that
--   doesn't have a tag affecting editability applied to it. Typically the
--   result of textViewGetEditable is appropriate here.
textBufferInsertInteractiveAtCursor :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> Int32 -> Bool -> m Bool

-- | Inserts the text in markup at position
--   iter. markup will be inserted in its
--   entirety and must be nul-terminated and valid UTF-8. Emits the
--   TextBuffer::insertText signal, possibly multiple times;
--   insertion actually occurs in the default handler for the signal.
--   iter will point to the end of the inserted text on
--   return.
--   
--   Since: 3.16
textBufferInsertMarkup :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> Text -> Int32 -> m ()

-- | Moves the mark named name (which must exist) to
--   location where. See textBufferMoveMark for
--   details.
textBufferMoveMarkByName :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> TextIter -> m ()

-- | This function moves the “insert” and “selection_bound” marks
--   simultaneously. If you move them to the same place in two steps with
--   textBufferMoveMark, 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 ()

-- | Removes all tags in the range between start and
--   end. 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 Clipboard added with
--   textBufferAddSelectionClipboard.
textBufferRemoveSelectionClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> m ()

-- | Calls textTagTableLookup on the buffer’s tag table to get a
--   TextTag, then calls textBufferRemoveTag.
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
--   textBufferMoveMark, 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.
--   
--   Since: 2.4
textBufferSelectRange :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> m ()

-- | Deletes current contents of buffer, and inserts
--   text instead. If len is -1,
--   text must be nul-terminated. text 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 textBufferRegisterDeserializeFormat or
--   textBufferRegisterDeserializeTagset.
--   
--   Since: 2.10
textBufferUnregisterDeserializeFormat :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Atom -> m ()

-- | This function unregisters a rich text format that was previously
--   registered using textBufferRegisterSerializeFormat or
--   textBufferRegisterSerializeTagset
--   
--   Since: 2.10
textBufferUnregisterSerializeFormat :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Atom -> m ()

-- | Returns a newly created StyleProperties
stylePropertiesNew :: (HasCallStack, MonadIO m) => m StyleProperties

-- | Clears all style information from props.
stylePropertiesClear :: (HasCallStack, MonadIO m, IsStyleProperties a) => a -> m ()

-- | Gets a style property from props for the given state.
--   When done with value, valueUnset needs to be
--   called to free any allocated memory.
--   
--   Since: 3.0
stylePropertiesGetProperty :: (HasCallStack, MonadIO m, IsStyleProperties a) => a -> Text -> [StateFlags] -> m (Bool, GValue)

-- | Maps color so it can be referenced by
--   name. See stylePropertiesLookupColor
--   
--   Since: 3.0
stylePropertiesMapColor :: (HasCallStack, MonadIO m, IsStyleProperties a) => a -> Text -> SymbolicColor -> m ()

-- | Merges into props all the style information contained
--   in propsToMerge. If replace is
--   True, the values will be overwritten, if it is False,
--   the older values will prevail.
--   
--   Since: 3.0
stylePropertiesMerge :: (HasCallStack, MonadIO m, IsStyleProperties a, IsStyleProperties b) => a -> b -> Bool -> m ()

-- | Sets a styling property in props.
--   
--   Since: 3.0
stylePropertiesSetProperty :: (HasCallStack, MonadIO m, IsStyleProperties a) => a -> Text -> [StateFlags] -> GValue -> m ()

-- | Unsets a style property in props.
--   
--   Since: 3.0
stylePropertiesUnsetProperty :: (HasCallStack, MonadIO m, IsStyleProperties a) => a -> Text -> [StateFlags] -> m ()

-- | The changed signal is emitted when there is a change in the
--   StyleContext.
--   
--   For a StyleContext returned by widgetGetStyleContext,
--   the Widget::styleUpdated signal/vfunc might be more convenient
--   to use.
--   
--   This signal is useful when using the theming layer standalone.
--   
--   Since: 3.0
type StyleContextChangedCallback = IO ()

-- | Connect a signal handler for the changed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on styleContext #changed callback
--   
onStyleContextChanged :: (IsStyleContext a, MonadIO m) => a -> ((?self :: a) => StyleContextChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after styleContext #changed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterStyleContextChanged :: (IsStyleContext a, MonadIO m) => a -> ((?self :: a) => StyleContextChangedCallback) -> m SignalHandlerId

-- | Get the value of the “direction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get styleContext #direction
--   
getStyleContextDirection :: (MonadIO m, IsStyleContext o) => o -> m TextDirection

-- | Set the value of the “direction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set styleContext [ #direction := value ]
--   
setStyleContextDirection :: (MonadIO m, IsStyleContext o) => o -> TextDirection -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “direction” property. This is rarely needed directly, but it
--   is used by new.
constructStyleContextDirection :: (IsStyleContext o, MonadIO m) => TextDirection -> m (GValueConstruct o)

-- | Get the value of the “paint-clock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get styleContext #paintClock
--   
getStyleContextPaintClock :: (MonadIO m, IsStyleContext o) => o -> m (Maybe FrameClock)

-- | Set the value of the “paint-clock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set styleContext [ #paintClock := value ]
--   
setStyleContextPaintClock :: (MonadIO m, IsStyleContext o, IsFrameClock a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “paint-clock” property. This is rarely needed directly, but
--   it is used by new.
constructStyleContextPaintClock :: (IsStyleContext o, MonadIO m, IsFrameClock a) => a -> m (GValueConstruct o)

-- | Set the value of the “paint-clock” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #paintClock
--   
clearStyleContextPaintClock :: (MonadIO m, IsStyleContext o) => o -> m ()

-- | Get the value of the “parent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get styleContext #parent
--   
getStyleContextParent :: (MonadIO m, IsStyleContext o) => o -> m (Maybe StyleContext)

-- | Set the value of the “parent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set styleContext [ #parent := value ]
--   
setStyleContextParent :: (MonadIO m, IsStyleContext o, IsStyleContext a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “parent” property. This is rarely needed directly, but it is
--   used by new.
constructStyleContextParent :: (IsStyleContext o, MonadIO m, IsStyleContext a) => a -> m (GValueConstruct o)

-- | Set the value of the “parent” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #parent
--   
clearStyleContextParent :: (MonadIO m, IsStyleContext o) => o -> m ()

-- | Get the value of the “screen” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get styleContext #screen
--   
getStyleContextScreen :: (MonadIO m, IsStyleContext o) => o -> m Screen

-- | Set the value of the “screen” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set styleContext [ #screen := value ]
--   
setStyleContextScreen :: (MonadIO m, IsStyleContext o, IsScreen a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “screen” property. This is rarely needed directly, but it is
--   used by new.
constructStyleContextScreen :: (IsStyleContext o, MonadIO m, IsScreen a) => a -> m (GValueConstruct o)

-- | Creates a standalone StyleContext, this style context won’t be
--   attached to any widget, so you may want to call
--   styleContextSetPath yourself.
--   
--   This function is only useful when using the theming layer separated
--   from GTK+, if you are using StyleContext to theme
--   GtkWidgets, use widgetGetStyleContext in order
--   to get a style context ready to theme the widget.
styleContextNew :: (HasCallStack, MonadIO m) => m StyleContext

-- | Stops all running animations for regionId and all
--   animatable regions underneath.
--   
--   A Nothing regionId will stop all ongoing
--   animations in context, when dealing with a
--   StyleContext obtained through widgetGetStyleContext,
--   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.
--   
--   Since: 3.0
styleContextCancelAnimations :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Ptr () -> m ()

-- | Gets the border for a given state as a Border.
--   
--   See styleContextGetProperty and
--   STYLE_PROPERTY_BORDER_WIDTH for details.
--   
--   Since: 3.0
styleContextGetBorder :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m Border

-- | Gets the border color for a given state.
--   
--   Since: 3.0
styleContextGetBorderColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m RGBA

-- | Gets the foreground color for a given state.
--   
--   See styleContextGetProperty and STYLE_PROPERTY_COLOR for
--   details.
--   
--   Since: 3.0
styleContextGetColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m RGBA

-- | Returns the widget direction used for rendering.
--   
--   Since: 3.0
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 StyleContext::changed
--   signal happens.
--   
--   Since: 3.0
styleContextGetFont :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m FontDescription

-- | Returns the FrameClock to which context is
--   attached.
--   
--   Since: 3.8
styleContextGetFrameClock :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m (Maybe FrameClock)

-- | Returns the sides where rendered elements connect visually with
--   others.
--   
--   Since: 3.0
styleContextGetJunctionSides :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m [JunctionSides]

-- | Gets the margin for a given state as a Border. See
--   gtk_style_property_get() and
--   STYLE_PROPERTY_MARGIN for details.
--   
--   Since: 3.0
styleContextGetMargin :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m Border

-- | Gets the parent context set via styleContextSetParent. See that
--   function for details.
--   
--   Since: 3.4
styleContextGetParent :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m (Maybe StyleContext)

-- | Returns the widget path used for style matching.
--   
--   Since: 3.0
styleContextGetPath :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m WidgetPath

-- | Returns the scale used for assets.
--   
--   Since: 3.10
styleContextGetScale :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m Int32

-- | Returns the Screen to which context is
--   attached.
styleContextGetScreen :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m Screen

-- | Queries the location in the CSS where property was
--   defined for the current context. Note that the state
--   to be queried is taken from styleContextGetState.
--   
--   If the location is not available, Nothing will be returned. The
--   location might not be available for various reasons, such as the
--   property being overridden, property 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 Nothing.
styleContextGetSection :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m (Maybe CssSection)

-- | Gets the value for a widget style property.
--   
--   When value is no longer needed, valueUnset must
--   be called to free any allocated memory.
styleContextGetStyleProperty :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> GValue -> m ()

-- | Returns True if context currently has defined
--   the given class name.
--   
--   Since: 3.0
styleContextHasClass :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m Bool

-- | Returns True if context has the region defined.
--   If flagsReturn is not Nothing, it is set to the
--   flags affecting the region.
--   
--   Since: 3.0
styleContextHasRegion :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m (Bool, [RegionFlags])

-- | Invalidates context style information, so it will be
--   reconstructed again. It is useful if you modify the
--   context and need the new information immediately.
--   
--   Since: 3.0
styleContextInvalidate :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m ()

-- | Returns the list of classes currently defined in
--   context.
--   
--   Since: 3.0
styleContextListClasses :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m [Text]

-- | Returns the list of regions currently defined in
--   context.
--   
--   Since: 3.0
styleContextListRegions :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m [Text]

-- | Looks up stockId in the icon factories associated to
--   context and the default icon factory, returning an
--   icon set if found, otherwise Nothing.
styleContextLookupIconSet :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m (Maybe IconSet)

-- | Removes provider from the style providers list in
--   context.
--   
--   Since: 3.0
styleContextRemoveProvider :: (HasCallStack, MonadIO m, IsStyleContext a, IsStyleProvider b) => a -> b -> m ()

-- | Removes a region from context.
--   
--   Since: 3.0
styleContextRemoveRegion :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m ()

-- | This function is analogous to windowScroll, and should be
--   called together with it so the invalidation areas for any ongoing
--   animation are scrolled together with it.
--   
--   Since: 3.0
styleContextScrollAnimations :: (HasCallStack, MonadIO m, IsStyleContext a, IsWindow b) => a -> b -> Int32 -> Int32 -> m ()

-- | Sets the background of window to the background
--   pattern or color specified in context for its current
--   state.
--   
--   Since: 3.0
styleContextSetBackground :: (HasCallStack, MonadIO m, IsStyleContext a, IsWindow b) => a -> b -> m ()

-- | Sets the reading direction for rendering purposes.
--   
--   If you are using a StyleContext returned from
--   widgetGetStyleContext, you do not need to call this yourself.
--   
--   Since: 3.0
styleContextSetDirection :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> TextDirection -> m ()

-- | Attaches context to the given frame clock.
--   
--   The frame clock is used for the timing of animations.
--   
--   If you are using a StyleContext returned from
--   widgetGetStyleContext, you do not need to call this yourself.
--   
--   Since: 3.8
styleContextSetFrameClock :: (HasCallStack, MonadIO m, IsStyleContext a, IsFrameClock b) => a -> b -> m ()

-- | Sets the sides where rendered elements (mostly through
--   renderFrame) 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.
--   
--   Since: 3.0
styleContextSetJunctionSides :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [JunctionSides] -> m ()

-- | Sets the scale to use when getting image assets for the style.
--   
--   Since: 3.10
styleContextSetScale :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Int32 -> m ()

-- | Attaches context to the given screen.
--   
--   The screen is used to add style information from “global” style
--   providers, such as the screen’s Settings instance.
--   
--   If you are using a StyleContext returned from
--   widgetGetStyleContext, you do not need to call this yourself.
--   
--   Since: 3.0
styleContextSetScreen :: (HasCallStack, MonadIO m, IsStyleContext a, IsScreen b) => a -> b -> m ()

-- | Returns True if there is a transition animation running for the
--   current region (see styleContextPushAnimatableRegion).
--   
--   If progress is not Nothing, 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 state
--   is being set and from 1 to 0 when it’s being unset.
--   
--   Since: 3.0
styleContextStateIsRunning :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> StateType -> m (Bool, Double)

-- | Removes provider from the global style providers list
--   in screen.
--   
--   Since: 3.0
styleContextRemoveProviderForScreen :: (HasCallStack, MonadIO m, IsScreen a, IsStyleProvider b) => a -> b -> m ()

-- | This function recomputes the styles for all widgets under a particular
--   Screen. 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 Settings object.
--   
--   Since: 3.0
styleContextResetWidgets :: (HasCallStack, MonadIO m, IsScreen a) => a -> m ()

-- | 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 Style. This
--   signal provides a convenient place to free such cached objects.
--   
--   Since: 2.4
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.
--   
--   Since: 2.4
type StyleRealizeCallback = IO ()

-- | Connect a signal handler for the realize signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on style #realize callback
--   
onStyleRealize :: (IsStyle a, MonadIO m) => a -> ((?self :: a) => StyleRealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the realize signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after style #realize callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterStyleRealize :: (IsStyle a, MonadIO m) => a -> ((?self :: a) => StyleRealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unrealize signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on style #unrealize callback
--   
onStyleUnrealize :: (IsStyle a, MonadIO m) => a -> ((?self :: a) => StyleUnrealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unrealize signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after style #unrealize callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterStyleUnrealize :: (IsStyle a, MonadIO m) => a -> ((?self :: a) => StyleUnrealizeCallback) -> m SignalHandlerId

-- | Get the value of the “context” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get style #context
--   
getStyleContext :: (MonadIO m, IsStyle o) => o -> m (Maybe StyleContext)

-- | Construct a GValueConstruct with valid value for the
--   “context” property. This is rarely needed directly, but it is
--   used by new.
constructStyleContext :: (IsStyle o, MonadIO m, IsStyleContext a) => a -> m (GValueConstruct o)

-- | Creates a new Style.
styleNew :: (HasCallStack, MonadIO m) => m Style

-- | No description available in the introspection data.
styleApplyDefaultBackground :: (HasCallStack, MonadIO m, IsStyle a, IsWindow b) => a -> Context -> b -> StateType -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Creates a copy of the passed in Style 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
--   gtk_style_attach().
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.
--   
--   Since: 2.16
styleGetStyleProperty :: (HasCallStack, MonadIO m, IsStyle a) => a -> GType -> Text -> m GValue

-- | Returns whether style has an associated
--   StyleContext.
--   
--   Since: 3.0
styleHasContext :: (HasCallStack, MonadIO m, IsStyle a) => a -> m Bool

-- | Looks up colorName in the style’s logical color
--   mappings, filling in color and returning True
--   if found, otherwise returning False. Do not cache the found
--   mapping, because it depends on the Style and might change when
--   a theme switch occurs.
--   
--   Since: 2.10
styleLookupColor :: (HasCallStack, MonadIO m, IsStyle a) => a -> Text -> m (Bool, Color)

-- | Sets the background of window to the background color
--   or pixmap specified by style for the given state.
styleSetBackground :: (HasCallStack, MonadIO m, IsStyle a, IsWindow b) => a -> b -> StateType -> m ()

-- | Get the value of the “gtk-alternative-button-order” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkAlternativeButtonOrder
--   
getSettingsGtkAlternativeButtonOrder :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-alternative-button-order” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkAlternativeButtonOrder := value ]
--   
setSettingsGtkAlternativeButtonOrder :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-alternative-button-order” property. This is rarely
--   needed directly, but it is used by new.
constructSettingsGtkAlternativeButtonOrder :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-alternative-sort-arrows” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkAlternativeSortArrows
--   
getSettingsGtkAlternativeSortArrows :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-alternative-sort-arrows” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkAlternativeSortArrows := value ]
--   
setSettingsGtkAlternativeSortArrows :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-alternative-sort-arrows” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkAlternativeSortArrows :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-application-prefer-dark-theme”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkApplicationPreferDarkTheme
--   
getSettingsGtkApplicationPreferDarkTheme :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-application-prefer-dark-theme”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkApplicationPreferDarkTheme := value ]
--   
setSettingsGtkApplicationPreferDarkTheme :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-application-prefer-dark-theme” property. This is rarely
--   needed directly, but it is used by new.
constructSettingsGtkApplicationPreferDarkTheme :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-auto-mnemonics” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkAutoMnemonics
--   
getSettingsGtkAutoMnemonics :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-auto-mnemonics” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkAutoMnemonics := value ]
--   
setSettingsGtkAutoMnemonics :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-auto-mnemonics” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkAutoMnemonics :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-button-images” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkButtonImages
--   
getSettingsGtkButtonImages :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-button-images” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkButtonImages := value ]
--   
setSettingsGtkButtonImages :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-button-images” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkButtonImages :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-can-change-accels” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkCanChangeAccels
--   
getSettingsGtkCanChangeAccels :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-can-change-accels” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkCanChangeAccels := value ]
--   
setSettingsGtkCanChangeAccels :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-can-change-accels” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkCanChangeAccels :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-color-palette” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkColorPalette
--   
getSettingsGtkColorPalette :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-color-palette” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkColorPalette := value ]
--   
setSettingsGtkColorPalette :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-color-palette” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkColorPalette :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-color-palette” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkColorPalette
--   
clearSettingsGtkColorPalette :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-color-scheme” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkColorScheme
--   
getSettingsGtkColorScheme :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-color-scheme” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkColorScheme := value ]
--   
setSettingsGtkColorScheme :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-color-scheme” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkColorScheme :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-color-scheme” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkColorScheme
--   
clearSettingsGtkColorScheme :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-cursor-aspect-ratio” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkCursorAspectRatio
--   
getSettingsGtkCursorAspectRatio :: (MonadIO m, IsSettings o) => o -> m Float

-- | Set the value of the “gtk-cursor-aspect-ratio” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkCursorAspectRatio := value ]
--   
setSettingsGtkCursorAspectRatio :: (MonadIO m, IsSettings o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-cursor-aspect-ratio” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkCursorAspectRatio :: (IsSettings o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “gtk-cursor-blink” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkCursorBlink
--   
getSettingsGtkCursorBlink :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-cursor-blink” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkCursorBlink := value ]
--   
setSettingsGtkCursorBlink :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-cursor-blink” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkCursorBlink :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-cursor-blink-time” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkCursorBlinkTime
--   
getSettingsGtkCursorBlinkTime :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-cursor-blink-time” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkCursorBlinkTime := value ]
--   
setSettingsGtkCursorBlinkTime :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-cursor-blink-time” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkCursorBlinkTime :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-cursor-blink-timeout” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkCursorBlinkTimeout
--   
getSettingsGtkCursorBlinkTimeout :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-cursor-blink-timeout” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkCursorBlinkTimeout := value ]
--   
setSettingsGtkCursorBlinkTimeout :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-cursor-blink-timeout” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkCursorBlinkTimeout :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-cursor-theme-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkCursorThemeName
--   
getSettingsGtkCursorThemeName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-cursor-theme-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkCursorThemeName := value ]
--   
setSettingsGtkCursorThemeName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-cursor-theme-name” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkCursorThemeName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-cursor-theme-name” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkCursorThemeName
--   
clearSettingsGtkCursorThemeName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-cursor-theme-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkCursorThemeSize
--   
getSettingsGtkCursorThemeSize :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-cursor-theme-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkCursorThemeSize := value ]
--   
setSettingsGtkCursorThemeSize :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-cursor-theme-size” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkCursorThemeSize :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-decoration-layout” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkDecorationLayout
--   
getSettingsGtkDecorationLayout :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-decoration-layout” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkDecorationLayout := value ]
--   
setSettingsGtkDecorationLayout :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-decoration-layout” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkDecorationLayout :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-decoration-layout” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkDecorationLayout
--   
clearSettingsGtkDecorationLayout :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-dialogs-use-header” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkDialogsUseHeader
--   
getSettingsGtkDialogsUseHeader :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-dialogs-use-header” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkDialogsUseHeader := value ]
--   
setSettingsGtkDialogsUseHeader :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-dialogs-use-header” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkDialogsUseHeader :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-dnd-drag-threshold” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkDndDragThreshold
--   
getSettingsGtkDndDragThreshold :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-dnd-drag-threshold” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkDndDragThreshold := value ]
--   
setSettingsGtkDndDragThreshold :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-dnd-drag-threshold” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkDndDragThreshold :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-double-click-distance” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkDoubleClickDistance
--   
getSettingsGtkDoubleClickDistance :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-double-click-distance” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkDoubleClickDistance := value ]
--   
setSettingsGtkDoubleClickDistance :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-double-click-distance” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkDoubleClickDistance :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-double-click-time” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkDoubleClickTime
--   
getSettingsGtkDoubleClickTime :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-double-click-time” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkDoubleClickTime := value ]
--   
setSettingsGtkDoubleClickTime :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-double-click-time” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkDoubleClickTime :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-enable-accels” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkEnableAccels
--   
getSettingsGtkEnableAccels :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-enable-accels” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkEnableAccels := value ]
--   
setSettingsGtkEnableAccels :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-enable-accels” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkEnableAccels :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-enable-animations” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkEnableAnimations
--   
getSettingsGtkEnableAnimations :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-enable-animations” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkEnableAnimations := value ]
--   
setSettingsGtkEnableAnimations :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-enable-animations” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkEnableAnimations :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-enable-event-sounds” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkEnableEventSounds
--   
getSettingsGtkEnableEventSounds :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-enable-event-sounds” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkEnableEventSounds := value ]
--   
setSettingsGtkEnableEventSounds :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-enable-event-sounds” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkEnableEventSounds :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-enable-input-feedback-sounds”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkEnableInputFeedbackSounds
--   
getSettingsGtkEnableInputFeedbackSounds :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-enable-input-feedback-sounds”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkEnableInputFeedbackSounds := value ]
--   
setSettingsGtkEnableInputFeedbackSounds :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-enable-input-feedback-sounds” property. This is rarely
--   needed directly, but it is used by new.
constructSettingsGtkEnableInputFeedbackSounds :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-enable-mnemonics” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkEnableMnemonics
--   
getSettingsGtkEnableMnemonics :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-enable-mnemonics” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkEnableMnemonics := value ]
--   
setSettingsGtkEnableMnemonics :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-enable-mnemonics” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkEnableMnemonics :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-enable-primary-paste” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkEnablePrimaryPaste
--   
getSettingsGtkEnablePrimaryPaste :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-enable-primary-paste” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkEnablePrimaryPaste := value ]
--   
setSettingsGtkEnablePrimaryPaste :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-enable-primary-paste” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkEnablePrimaryPaste :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-enable-tooltips” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkEnableTooltips
--   
getSettingsGtkEnableTooltips :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-enable-tooltips” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkEnableTooltips := value ]
--   
setSettingsGtkEnableTooltips :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-enable-tooltips” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkEnableTooltips :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-entry-password-hint-timeout”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkEntryPasswordHintTimeout
--   
getSettingsGtkEntryPasswordHintTimeout :: (MonadIO m, IsSettings o) => o -> m Word32

-- | Set the value of the “gtk-entry-password-hint-timeout”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkEntryPasswordHintTimeout := value ]
--   
setSettingsGtkEntryPasswordHintTimeout :: (MonadIO m, IsSettings o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-entry-password-hint-timeout” property. This is rarely
--   needed directly, but it is used by new.
constructSettingsGtkEntryPasswordHintTimeout :: (IsSettings o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-entry-select-on-focus” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkEntrySelectOnFocus
--   
getSettingsGtkEntrySelectOnFocus :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-entry-select-on-focus” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkEntrySelectOnFocus := value ]
--   
setSettingsGtkEntrySelectOnFocus :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-entry-select-on-focus” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkEntrySelectOnFocus :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-error-bell” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkErrorBell
--   
getSettingsGtkErrorBell :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-error-bell” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkErrorBell := value ]
--   
setSettingsGtkErrorBell :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-error-bell” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkErrorBell :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-fallback-icon-theme” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkFallbackIconTheme
--   
getSettingsGtkFallbackIconTheme :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-fallback-icon-theme” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkFallbackIconTheme := value ]
--   
setSettingsGtkFallbackIconTheme :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-fallback-icon-theme” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkFallbackIconTheme :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-fallback-icon-theme” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkFallbackIconTheme
--   
clearSettingsGtkFallbackIconTheme :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-file-chooser-backend” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkFileChooserBackend
--   
getSettingsGtkFileChooserBackend :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-file-chooser-backend” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkFileChooserBackend := value ]
--   
setSettingsGtkFileChooserBackend :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-file-chooser-backend” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkFileChooserBackend :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-file-chooser-backend” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkFileChooserBackend
--   
clearSettingsGtkFileChooserBackend :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-font-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkFontName
--   
getSettingsGtkFontName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-font-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkFontName := value ]
--   
setSettingsGtkFontName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-font-name” property. This is rarely needed directly, but
--   it is used by new.
constructSettingsGtkFontName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-font-name” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkFontName
--   
clearSettingsGtkFontName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-fontconfig-timestamp” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkFontconfigTimestamp
--   
getSettingsGtkFontconfigTimestamp :: (MonadIO m, IsSettings o) => o -> m Word32

-- | Set the value of the “gtk-fontconfig-timestamp” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkFontconfigTimestamp := value ]
--   
setSettingsGtkFontconfigTimestamp :: (MonadIO m, IsSettings o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-fontconfig-timestamp” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkFontconfigTimestamp :: (IsSettings o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-icon-sizes” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkIconSizes
--   
getSettingsGtkIconSizes :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-icon-sizes” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkIconSizes := value ]
--   
setSettingsGtkIconSizes :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-icon-sizes” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkIconSizes :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-icon-sizes” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkIconSizes
--   
clearSettingsGtkIconSizes :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-icon-theme-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkIconThemeName
--   
getSettingsGtkIconThemeName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-icon-theme-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkIconThemeName := value ]
--   
setSettingsGtkIconThemeName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-icon-theme-name” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkIconThemeName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-icon-theme-name” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkIconThemeName
--   
clearSettingsGtkIconThemeName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-im-module” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkImModule
--   
getSettingsGtkImModule :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-im-module” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkImModule := value ]
--   
setSettingsGtkImModule :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-im-module” property. This is rarely needed directly, but
--   it is used by new.
constructSettingsGtkImModule :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-im-module” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkImModule
--   
clearSettingsGtkImModule :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-im-preedit-style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkImPreeditStyle
--   
getSettingsGtkImPreeditStyle :: (MonadIO m, IsSettings o) => o -> m IMPreeditStyle

-- | Set the value of the “gtk-im-preedit-style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkImPreeditStyle := value ]
--   
setSettingsGtkImPreeditStyle :: (MonadIO m, IsSettings o) => o -> IMPreeditStyle -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-im-preedit-style” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkImPreeditStyle :: (IsSettings o, MonadIO m) => IMPreeditStyle -> m (GValueConstruct o)

-- | Get the value of the “gtk-im-status-style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkImStatusStyle
--   
getSettingsGtkImStatusStyle :: (MonadIO m, IsSettings o) => o -> m IMStatusStyle

-- | Set the value of the “gtk-im-status-style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkImStatusStyle := value ]
--   
setSettingsGtkImStatusStyle :: (MonadIO m, IsSettings o) => o -> IMStatusStyle -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-im-status-style” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkImStatusStyle :: (IsSettings o, MonadIO m) => IMStatusStyle -> m (GValueConstruct o)

-- | Get the value of the “gtk-key-theme-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkKeyThemeName
--   
getSettingsGtkKeyThemeName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-key-theme-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkKeyThemeName := value ]
--   
setSettingsGtkKeyThemeName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-key-theme-name” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkKeyThemeName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-key-theme-name” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkKeyThemeName
--   
clearSettingsGtkKeyThemeName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-keynav-cursor-only” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkKeynavCursorOnly
--   
getSettingsGtkKeynavCursorOnly :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-keynav-cursor-only” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkKeynavCursorOnly := value ]
--   
setSettingsGtkKeynavCursorOnly :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-keynav-cursor-only” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkKeynavCursorOnly :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-keynav-use-caret” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkKeynavUseCaret
--   
getSettingsGtkKeynavUseCaret :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-keynav-use-caret” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkKeynavUseCaret := value ]
--   
setSettingsGtkKeynavUseCaret :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-keynav-use-caret” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkKeynavUseCaret :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-keynav-wrap-around” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkKeynavWrapAround
--   
getSettingsGtkKeynavWrapAround :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-keynav-wrap-around” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkKeynavWrapAround := value ]
--   
setSettingsGtkKeynavWrapAround :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-keynav-wrap-around” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkKeynavWrapAround :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-label-select-on-focus” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkLabelSelectOnFocus
--   
getSettingsGtkLabelSelectOnFocus :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-label-select-on-focus” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkLabelSelectOnFocus := value ]
--   
setSettingsGtkLabelSelectOnFocus :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-label-select-on-focus” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkLabelSelectOnFocus :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-long-press-time” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkLongPressTime
--   
getSettingsGtkLongPressTime :: (MonadIO m, IsSettings o) => o -> m Word32

-- | Set the value of the “gtk-long-press-time” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkLongPressTime := value ]
--   
setSettingsGtkLongPressTime :: (MonadIO m, IsSettings o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-long-press-time” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkLongPressTime :: (IsSettings o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-menu-bar-accel” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkMenuBarAccel
--   
getSettingsGtkMenuBarAccel :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-menu-bar-accel” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkMenuBarAccel := value ]
--   
setSettingsGtkMenuBarAccel :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-menu-bar-accel” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkMenuBarAccel :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-menu-bar-accel” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkMenuBarAccel
--   
clearSettingsGtkMenuBarAccel :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-menu-bar-popup-delay” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkMenuBarPopupDelay
--   
getSettingsGtkMenuBarPopupDelay :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-menu-bar-popup-delay” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkMenuBarPopupDelay := value ]
--   
setSettingsGtkMenuBarPopupDelay :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-menu-bar-popup-delay” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkMenuBarPopupDelay :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-menu-images” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkMenuImages
--   
getSettingsGtkMenuImages :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-menu-images” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkMenuImages := value ]
--   
setSettingsGtkMenuImages :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-menu-images” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkMenuImages :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-menu-popdown-delay” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkMenuPopdownDelay
--   
getSettingsGtkMenuPopdownDelay :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-menu-popdown-delay” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkMenuPopdownDelay := value ]
--   
setSettingsGtkMenuPopdownDelay :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-menu-popdown-delay” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkMenuPopdownDelay :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-menu-popup-delay” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkMenuPopupDelay
--   
getSettingsGtkMenuPopupDelay :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-menu-popup-delay” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkMenuPopupDelay := value ]
--   
setSettingsGtkMenuPopupDelay :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-menu-popup-delay” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkMenuPopupDelay :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-modules” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkModules
--   
getSettingsGtkModules :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-modules” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkModules := value ]
--   
setSettingsGtkModules :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-modules” property. This is rarely needed directly, but
--   it is used by new.
constructSettingsGtkModules :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-modules” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkModules
--   
clearSettingsGtkModules :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-overlay-scrolling” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkOverlayScrolling
--   
getSettingsGtkOverlayScrolling :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-overlay-scrolling” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkOverlayScrolling := value ]
--   
setSettingsGtkOverlayScrolling :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-overlay-scrolling” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkOverlayScrolling :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-primary-button-warps-slider”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkPrimaryButtonWarpsSlider
--   
getSettingsGtkPrimaryButtonWarpsSlider :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-primary-button-warps-slider”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkPrimaryButtonWarpsSlider := value ]
--   
setSettingsGtkPrimaryButtonWarpsSlider :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-primary-button-warps-slider” property. This is rarely
--   needed directly, but it is used by new.
constructSettingsGtkPrimaryButtonWarpsSlider :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-print-backends” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkPrintBackends
--   
getSettingsGtkPrintBackends :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-print-backends” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkPrintBackends := value ]
--   
setSettingsGtkPrintBackends :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-print-backends” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkPrintBackends :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-print-backends” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkPrintBackends
--   
clearSettingsGtkPrintBackends :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-print-preview-command” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkPrintPreviewCommand
--   
getSettingsGtkPrintPreviewCommand :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-print-preview-command” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkPrintPreviewCommand := value ]
--   
setSettingsGtkPrintPreviewCommand :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-print-preview-command” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkPrintPreviewCommand :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-print-preview-command” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkPrintPreviewCommand
--   
clearSettingsGtkPrintPreviewCommand :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-recent-files-enabled” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkRecentFilesEnabled
--   
getSettingsGtkRecentFilesEnabled :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-recent-files-enabled” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkRecentFilesEnabled := value ]
--   
setSettingsGtkRecentFilesEnabled :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-recent-files-enabled” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkRecentFilesEnabled :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-recent-files-limit” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkRecentFilesLimit
--   
getSettingsGtkRecentFilesLimit :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-recent-files-limit” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkRecentFilesLimit := value ]
--   
setSettingsGtkRecentFilesLimit :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-recent-files-limit” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkRecentFilesLimit :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-recent-files-max-age” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkRecentFilesMaxAge
--   
getSettingsGtkRecentFilesMaxAge :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-recent-files-max-age” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkRecentFilesMaxAge := value ]
--   
setSettingsGtkRecentFilesMaxAge :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-recent-files-max-age” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkRecentFilesMaxAge :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-scrolled-window-placement”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkScrolledWindowPlacement
--   
getSettingsGtkScrolledWindowPlacement :: (MonadIO m, IsSettings o) => o -> m CornerType

-- | Set the value of the “gtk-scrolled-window-placement”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkScrolledWindowPlacement := value ]
--   
setSettingsGtkScrolledWindowPlacement :: (MonadIO m, IsSettings o) => o -> CornerType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-scrolled-window-placement” property. This is rarely
--   needed directly, but it is used by new.
constructSettingsGtkScrolledWindowPlacement :: (IsSettings o, MonadIO m) => CornerType -> m (GValueConstruct o)

-- | Get the value of the “gtk-shell-shows-app-menu” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkShellShowsAppMenu
--   
getSettingsGtkShellShowsAppMenu :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-shell-shows-app-menu” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkShellShowsAppMenu := value ]
--   
setSettingsGtkShellShowsAppMenu :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-shell-shows-app-menu” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkShellShowsAppMenu :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-shell-shows-desktop” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkShellShowsDesktop
--   
getSettingsGtkShellShowsDesktop :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-shell-shows-desktop” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkShellShowsDesktop := value ]
--   
setSettingsGtkShellShowsDesktop :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-shell-shows-desktop” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkShellShowsDesktop :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-shell-shows-menubar” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkShellShowsMenubar
--   
getSettingsGtkShellShowsMenubar :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-shell-shows-menubar” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkShellShowsMenubar := value ]
--   
setSettingsGtkShellShowsMenubar :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-shell-shows-menubar” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkShellShowsMenubar :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-show-input-method-menu” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkShowInputMethodMenu
--   
getSettingsGtkShowInputMethodMenu :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-show-input-method-menu” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkShowInputMethodMenu := value ]
--   
setSettingsGtkShowInputMethodMenu :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-show-input-method-menu” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkShowInputMethodMenu :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-show-unicode-menu” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkShowUnicodeMenu
--   
getSettingsGtkShowUnicodeMenu :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-show-unicode-menu” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkShowUnicodeMenu := value ]
--   
setSettingsGtkShowUnicodeMenu :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-show-unicode-menu” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkShowUnicodeMenu :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-sound-theme-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkSoundThemeName
--   
getSettingsGtkSoundThemeName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-sound-theme-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkSoundThemeName := value ]
--   
setSettingsGtkSoundThemeName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-sound-theme-name” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkSoundThemeName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-sound-theme-name” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkSoundThemeName
--   
clearSettingsGtkSoundThemeName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-split-cursor” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkSplitCursor
--   
getSettingsGtkSplitCursor :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-split-cursor” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkSplitCursor := value ]
--   
setSettingsGtkSplitCursor :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-split-cursor” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkSplitCursor :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-theme-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkThemeName
--   
getSettingsGtkThemeName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-theme-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkThemeName := value ]
--   
setSettingsGtkThemeName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-theme-name” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkThemeName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-theme-name” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkThemeName
--   
clearSettingsGtkThemeName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-timeout-expand” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkTimeoutExpand
--   
getSettingsGtkTimeoutExpand :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-timeout-expand” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkTimeoutExpand := value ]
--   
setSettingsGtkTimeoutExpand :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-timeout-expand” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkTimeoutExpand :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-timeout-initial” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkTimeoutInitial
--   
getSettingsGtkTimeoutInitial :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-timeout-initial” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkTimeoutInitial := value ]
--   
setSettingsGtkTimeoutInitial :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-timeout-initial” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkTimeoutInitial :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-timeout-repeat” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkTimeoutRepeat
--   
getSettingsGtkTimeoutRepeat :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-timeout-repeat” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkTimeoutRepeat := value ]
--   
setSettingsGtkTimeoutRepeat :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-timeout-repeat” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkTimeoutRepeat :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-titlebar-double-click” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkTitlebarDoubleClick
--   
getSettingsGtkTitlebarDoubleClick :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-titlebar-double-click” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkTitlebarDoubleClick := value ]
--   
setSettingsGtkTitlebarDoubleClick :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-titlebar-double-click” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkTitlebarDoubleClick :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-titlebar-double-click” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkTitlebarDoubleClick
--   
clearSettingsGtkTitlebarDoubleClick :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-titlebar-middle-click” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkTitlebarMiddleClick
--   
getSettingsGtkTitlebarMiddleClick :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-titlebar-middle-click” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkTitlebarMiddleClick := value ]
--   
setSettingsGtkTitlebarMiddleClick :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-titlebar-middle-click” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkTitlebarMiddleClick :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-titlebar-middle-click” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkTitlebarMiddleClick
--   
clearSettingsGtkTitlebarMiddleClick :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-titlebar-right-click” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkTitlebarRightClick
--   
getSettingsGtkTitlebarRightClick :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-titlebar-right-click” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkTitlebarRightClick := value ]
--   
setSettingsGtkTitlebarRightClick :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-titlebar-right-click” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkTitlebarRightClick :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-titlebar-right-click” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkTitlebarRightClick
--   
clearSettingsGtkTitlebarRightClick :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-toolbar-icon-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkToolbarIconSize
--   
getSettingsGtkToolbarIconSize :: (MonadIO m, IsSettings o) => o -> m IconSize

-- | Set the value of the “gtk-toolbar-icon-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkToolbarIconSize := value ]
--   
setSettingsGtkToolbarIconSize :: (MonadIO m, IsSettings o) => o -> IconSize -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-toolbar-icon-size” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkToolbarIconSize :: (IsSettings o, MonadIO m) => IconSize -> m (GValueConstruct o)

-- | Get the value of the “gtk-toolbar-style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkToolbarStyle
--   
getSettingsGtkToolbarStyle :: (MonadIO m, IsSettings o) => o -> m ToolbarStyle

-- | Set the value of the “gtk-toolbar-style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkToolbarStyle := value ]
--   
setSettingsGtkToolbarStyle :: (MonadIO m, IsSettings o) => o -> ToolbarStyle -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-toolbar-style” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkToolbarStyle :: (IsSettings o, MonadIO m) => ToolbarStyle -> m (GValueConstruct o)

-- | Get the value of the “gtk-tooltip-browse-mode-timeout”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkTooltipBrowseModeTimeout
--   
getSettingsGtkTooltipBrowseModeTimeout :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-tooltip-browse-mode-timeout”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkTooltipBrowseModeTimeout := value ]
--   
setSettingsGtkTooltipBrowseModeTimeout :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-tooltip-browse-mode-timeout” property. This is rarely
--   needed directly, but it is used by new.
constructSettingsGtkTooltipBrowseModeTimeout :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-tooltip-browse-timeout” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkTooltipBrowseTimeout
--   
getSettingsGtkTooltipBrowseTimeout :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-tooltip-browse-timeout” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkTooltipBrowseTimeout := value ]
--   
setSettingsGtkTooltipBrowseTimeout :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-tooltip-browse-timeout” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkTooltipBrowseTimeout :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-tooltip-timeout” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkTooltipTimeout
--   
getSettingsGtkTooltipTimeout :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-tooltip-timeout” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkTooltipTimeout := value ]
--   
setSettingsGtkTooltipTimeout :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-tooltip-timeout” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkTooltipTimeout :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-touchscreen-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkTouchscreenMode
--   
getSettingsGtkTouchscreenMode :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “gtk-touchscreen-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkTouchscreenMode := value ]
--   
setSettingsGtkTouchscreenMode :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-touchscreen-mode” property. This is rarely needed
--   directly, but it is used by new.
constructSettingsGtkTouchscreenMode :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gtk-visible-focus” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkVisibleFocus
--   
getSettingsGtkVisibleFocus :: (MonadIO m, IsSettings o) => o -> m PolicyType

-- | Set the value of the “gtk-visible-focus” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkVisibleFocus := value ]
--   
setSettingsGtkVisibleFocus :: (MonadIO m, IsSettings o) => o -> PolicyType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-visible-focus” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkVisibleFocus :: (IsSettings o, MonadIO m) => PolicyType -> m (GValueConstruct o)

-- | Get the value of the “gtk-xft-antialias” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkXftAntialias
--   
getSettingsGtkXftAntialias :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-xft-antialias” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkXftAntialias := value ]
--   
setSettingsGtkXftAntialias :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-xft-antialias” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkXftAntialias :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-xft-dpi” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkXftDpi
--   
getSettingsGtkXftDpi :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-xft-dpi” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkXftDpi := value ]
--   
setSettingsGtkXftDpi :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-xft-dpi” property. This is rarely needed directly, but
--   it is used by new.
constructSettingsGtkXftDpi :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-xft-hinting” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkXftHinting
--   
getSettingsGtkXftHinting :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “gtk-xft-hinting” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkXftHinting := value ]
--   
setSettingsGtkXftHinting :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-xft-hinting” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkXftHinting :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “gtk-xft-hintstyle” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkXftHintstyle
--   
getSettingsGtkXftHintstyle :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-xft-hintstyle” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkXftHintstyle := value ]
--   
setSettingsGtkXftHintstyle :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-xft-hintstyle” property. This is rarely needed directly,
--   but it is used by new.
constructSettingsGtkXftHintstyle :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-xft-hintstyle” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkXftHintstyle
--   
clearSettingsGtkXftHintstyle :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “gtk-xft-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get settings #gtkXftRgba
--   
getSettingsGtkXftRgba :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “gtk-xft-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set settings [ #gtkXftRgba := value ]
--   
setSettingsGtkXftRgba :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gtk-xft-rgba” property. This is rarely needed directly, but
--   it is used by new.
constructSettingsGtkXftRgba :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “gtk-xft-rgba” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #gtkXftRgba
--   
clearSettingsGtkXftRgba :: (MonadIO m, IsSettings o) => o -> m ()

-- | Undoes the effect of calling g_object_set() to install
--   an application-specific value for a setting. After this call, the
--   setting will again follow the session-wide value for this setting.
--   
--   Since: 3.20
settingsResetProperty :: (HasCallStack, MonadIO m, IsSettings a) => a -> Text -> m ()

-- | No description available in the introspection data.
settingsSetDoubleProperty :: (HasCallStack, MonadIO m, IsSettings a) => a -> Text -> Double -> Text -> m ()

-- | No description available in the introspection data.
settingsSetLongProperty :: (HasCallStack, MonadIO m, IsSettings a) => a -> Text -> CLong -> Text -> m ()

-- | No description available in the introspection data.
settingsSetPropertyValue :: (HasCallStack, MonadIO m, IsSettings a) => a -> Text -> SettingsValue -> m ()

-- | No description available in the introspection data.
settingsSetStringProperty :: (HasCallStack, MonadIO m, IsSettings a) => a -> Text -> Text -> Text -> m ()

-- | Gets the Settings object for the default GDK screen, creating
--   it if necessary. See settingsGetForScreen.
settingsGetDefault :: (HasCallStack, MonadIO m) => m (Maybe Settings)

-- | No description available in the introspection data.
settingsInstallProperty :: (HasCallStack, MonadIO m) => GParamSpec -> m ()

-- | Creates a new IconFactory. An icon factory manages a collection
--   of GtkIconSets; a IconSet manages a set of
--   variants of a particular icon (i.e. a IconSet 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 Style has a list of GtkIconFactorys
--   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 iconFactoryAddDefault and
--   iconFactoryRemoveDefault. 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 stockId in the icon factory, returning an
--   icon set if found, otherwise Nothing. For display to the user,
--   you should use styleLookupIconSet on the Style 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

-- | Looks for an icon in the list of default icon factories. For display
--   to the user, you should use styleLookupIconSet on the
--   Style 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

-- | No description available in the introspection data.
type ContainerSetFocusChildCallback = Widget -> IO ()

-- | No description available in the introspection data.
type ContainerRemoveCallback = Widget -> IO ()

-- | No description available in the introspection data.
type ContainerCheckResizeCallback = IO ()

-- | No description available in the introspection data.
type ContainerAddCallback = Widget -> IO ()

-- | Connect a signal handler for the add signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on container #add callback
--   
onContainerAdd :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerAddCallback) -> m SignalHandlerId

-- | Connect a signal handler for the add signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after container #add callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterContainerAdd :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerAddCallback) -> m SignalHandlerId

-- | Connect a signal handler for the checkResize signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on container #checkResize callback
--   
onContainerCheckResize :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerCheckResizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the checkResize signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after container #checkResize callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterContainerCheckResize :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerCheckResizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the remove signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on container #remove callback
--   
onContainerRemove :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerRemoveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the remove signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after container #remove callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterContainerRemove :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerRemoveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the setFocusChild signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on container #setFocusChild callback
--   
onContainerSetFocusChild :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerSetFocusChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the setFocusChild signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after container #setFocusChild callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterContainerSetFocusChild :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerSetFocusChildCallback) -> m SignalHandlerId

-- | Get the value of the “border-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get container #borderWidth
--   
getContainerBorderWidth :: (MonadIO m, IsContainer o) => o -> m Word32

-- | Set the value of the “border-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set container [ #borderWidth := value ]
--   
setContainerBorderWidth :: (MonadIO m, IsContainer o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “border-width” property. This is rarely needed directly, but
--   it is used by new.
constructContainerBorderWidth :: (IsContainer o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Set the value of the “child” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set container [ #child := value ]
--   
setContainerChild :: (MonadIO m, IsContainer o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “child” property. This is rarely needed directly, but it is
--   used by new.
constructContainerChild :: (IsContainer o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “child” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #child
--   
clearContainerChild :: (MonadIO m, IsContainer o) => o -> m ()

-- | Get the value of the “resize-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get container #resizeMode
--   
getContainerResizeMode :: (MonadIO m, IsContainer o) => o -> m ResizeMode

-- | Set the value of the “resize-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set container [ #resizeMode := value ]
--   
setContainerResizeMode :: (MonadIO m, IsContainer o) => o -> ResizeMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “resize-mode” property. This is rarely needed directly, but
--   it is used by new.
constructContainerResizeMode :: (IsContainer o, MonadIO m) => ResizeMode -> m (GValueConstruct o)

-- | No description available in the introspection data.
containerCheckResize :: (HasCallStack, MonadIO m, IsContainer a) => a -> m ()

-- | Gets the value of a child property for child and
--   container.
containerChildGetProperty :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> b -> Text -> GValue -> m ()

-- | Emits a Widget::childNotify signal for the [child
--   property][child-properties] specified by pspec on the
--   child.
--   
--   This is an analogue of objectNotifyByPspec for child
--   properties.
--   
--   Since: 3.18
containerChildNotifyByPspec :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> b -> GParamSpec -> m ()

-- | Sets a child property for child and
--   container.
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 G_TYPE_NONE to indicate that
--   no more children can be added, e.g. for a Paned which already
--   has two children.
containerChildType :: (HasCallStack, MonadIO m, IsContainer a) => a -> m GType

-- | Retrieves the border width of the container. See
--   containerSetBorderWidth.
containerGetBorderWidth :: (HasCallStack, MonadIO m, IsContainer a) => a -> m Word32

-- | Returns the container’s non-internal children. See
--   containerForall 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 Nothing in focusableWidgets and
--   returns False.
containerGetFocusChain :: (HasCallStack, MonadIO m, IsContainer a) => a -> m (Bool, [Widget])

-- | Returns the current focus child widget inside
--   container. This is not the currently focused widget.
--   That can be obtained by calling windowGetFocus.
--   
--   Since: 2.14
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
--   containerSetFocusVadjustment.
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

-- | No description available in the introspection data.
containerResizeChildren :: (HasCallStack, MonadIO m, IsContainer a) => a -> m ()

-- | Sets, or unsets if child is Nothing, the
--   focused child of container.
--   
--   This function emits the GtkContainerset_focus_child signal of
--   container. Implementations of Container 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 widgetGrabFocus to manually set the focus to a specific
--   widget.
containerSetFocusChild :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the reallocateRedraws 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
--   containerSetFocusChain.
containerUnsetFocusChain :: (HasCallStack, MonadIO m, IsContainer a) => a -> m ()

-- | The ownerChange signal is emitted when GTK+ receives an event
--   that indicates that the ownership of the selection associated with
--   clipboard has changed.
--   
--   Since: 2.6
type ClipboardOwnerChangeCallback = EventOwnerChange -> IO ()

-- | Connect a signal handler for the ownerChange signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on clipboard #ownerChange callback
--   
onClipboardOwnerChange :: (IsClipboard a, MonadIO m) => a -> ((?self :: a) => ClipboardOwnerChangeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the ownerChange signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after clipboard #ownerChange callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterClipboardOwnerChange :: (IsClipboard a, MonadIO m) => a -> ((?self :: a) => ClipboardOwnerChangeCallback) -> m SignalHandlerId

-- | Gets the Display associated with clipboard
--   
--   Since: 2.2
clipboardGetDisplay :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m Display

-- | If the clipboard contents callbacks were set with
--   gtk_clipboard_set_with_owner(), and the
--   gtk_clipboard_set_with_data() or clipboardClear
--   has not subsequently called, returns the owner set by
--   gtk_clipboard_set_with_owner().
clipboardGetOwner :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m (Maybe Object)

-- | Gets the selection that this clipboard is for.
--   
--   Since: 3.22
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.
--   
--   Since: 2.6
clipboardSetCanStore :: (HasCallStack, MonadIO m, IsClipboard a) => a -> Maybe [TargetEntry] -> m ()

-- | Sets the contents of the clipboard to the given Pixbuf. GTK+
--   will take responsibility for responding for requests for the image,
--   and for converting the image into the requested format.
--   
--   Since: 2.6
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.
--   
--   Since: 2.6
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)

-- | Returns a list of targets that are present on the clipboard, or
--   Nothing if there aren’t any targets available. The returned
--   list must be freed with free. This function waits for the data
--   to be received using the main loop, so events, timeouts, etc, may be
--   dispatched during the wait.
--   
--   Since: 2.4
clipboardWaitForTargets :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m (Bool, [Atom])

-- | 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
--   clipboardWaitForImage since it doesn’t need to retrieve the
--   actual image data.
--   
--   Since: 2.6
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
--   clipboardWaitForRichText since it doesn’t need to retrieve the
--   actual text.
--   
--   Since: 2.10
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.
--   
--   Since: 2.6
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
--   clipboardWaitForText 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
--   clipboardWaitForUris since it doesn’t need to retrieve the
--   actual URI data.
--   
--   Since: 2.14
clipboardWaitIsUrisAvailable :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m Bool

-- | Returns the clipboard object for the given selection. See
--   clipboardGetForDisplay 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.
--   
--   Since: 3.16
clipboardGetDefault :: (HasCallStack, MonadIO m, IsDisplay a) => a -> m Clipboard

-- | Get the value of the “translation-domain” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get builder #translationDomain
--   
getBuilderTranslationDomain :: (MonadIO m, IsBuilder o) => o -> m Text

-- | Set the value of the “translation-domain” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set builder [ #translationDomain := value ]
--   
setBuilderTranslationDomain :: (MonadIO m, IsBuilder o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “translation-domain” property. This is rarely needed
--   directly, but it is used by new.
constructBuilderTranslationDomain :: (IsBuilder o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “translation-domain” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #translationDomain
--   
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
--   builderAddFromFile, builderAddFromResource or
--   builderAddFromString in order to merge multiple UI descriptions
--   into a single builder.
--   
--   Most users will probably want to use builderNewFromFile,
--   builderNewFromResource or builderNewFromString.
--   
--   Since: 2.12
builderNew :: (HasCallStack, MonadIO m) => m Builder

-- | Parses a file containing a [GtkBuilder UI definition][BUILDER-UI]
--   building only the requested objects and merges them with the current
--   contents of builder.
--   
--   Upon errors 0 will be returned and error will be
--   assigned a GError from the GTK_BUILDER_ERROR,
--   G_MARKUP_ERROR or G_FILE_ERROR domain.
--   
--   If you are adding an object that depends on an object that is not its
--   child (for instance a TreeView that depends on its
--   TreeModel), you have to explicitly list all of them in
--   objectIds.
--   
--   Since: 2.14
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 builder.
--   
--   Upon errors 0 will be returned and error will be
--   assigned a GError from the GTK_BUILDER_ERROR,
--   G_MARKUP_ERROR or G_RESOURCE_ERROR
--   domain.
--   
--   If you are adding an object that depends on an object that is not its
--   child (for instance a TreeView that depends on its
--   TreeModel), you have to explicitly list all of them in
--   objectIds.
--   
--   Since: 3.4
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 builder.
--   
--   Upon errors 0 will be returned and error will be
--   assigned a GError from the GTK_BUILDER_ERROR or
--   G_MARKUP_ERROR domain.
--   
--   If you are adding an object that depends on an object that is not its
--   child (for instance a TreeView that depends on its
--   TreeModel), you have to explicitly list all of them in
--   objectIds.
--   
--   Since: 2.14
builderAddObjectsFromString :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> CSize -> [Text] -> m Word32

-- | Add object to the builder object pool
--   so it can be referenced just like any other object built by builder.
--   
--   Since: 3.8
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 Application associated with the builder.
--   
--   The Application 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
--   applicationGetDefault. If you want to use another application
--   for constructing proxies, use builderSetApplication.
--   
--   Since: 3.10
builderGetApplication :: (HasCallStack, MonadIO m, IsBuilder a) => a -> m (Maybe Application)

-- | Gets the object named name. Note that this function
--   does not increment the reference count of the returned object.
--   
--   Since: 2.12
builderGetObject :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> m (Maybe Object)

-- | Gets all objects that have been constructed by
--   builder. Note that this function does not increment
--   the reference counts of the returned objects.
--   
--   Since: 2.12
builderGetObjects :: (HasCallStack, MonadIO m, IsBuilder a) => a -> m [Object]

-- | Gets the translation domain of builder.
--   
--   Since: 2.12
builderGetTranslationDomain :: (HasCallStack, MonadIO m, IsBuilder a) => a -> m Text

-- | Looks up a type by name, using the virtual function that
--   Builder has for that purpose. This is mainly used when
--   implementing the Buildable interface on a type.
--   
--   Since: 2.12
builderGetTypeFromName :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> m GType

-- | Sets the translation domain of builder. See
--   Builder:translationDomain.
--   
--   Since: 2.12
builderSetTranslationDomain :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Maybe Text -> m ()

-- | Like builderValueFromString, this function demarshals a value
--   from a string, but takes a GType instead of ParamSpec.
--   This function calls valueInit on the value
--   argument, so it need not be initialised beforehand.
--   
--   Upon errors False will be returned and error
--   will be assigned a GError from the
--   GTK_BUILDER_ERROR domain.
--   
--   Since: 2.12
builderValueFromStringType :: (HasCallStack, MonadIO m, IsBuilder a) => a -> GType -> Text -> m GValue

-- | Gets the child of the Bin, or Nothing 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)

-- | Emitted when a Window is removed from
--   application, either as a side-effect of being
--   destroyed or explicitly through applicationRemoveWindow.
--   
--   Since: 3.2
type ApplicationWindowRemovedCallback = Window -> IO ()

-- | Emitted when a Window is added to application
--   through applicationAddWindow.
--   
--   Since: 3.2
type ApplicationWindowAddedCallback = Window -> IO ()

-- | Emitted when the session manager is about to end the session, only if
--   Application::register-session is True.
--   Applications can connect to this signal and call
--   applicationInhibit with ApplicationInhibitFlagsLogout to
--   delay the end of the session until state has been saved.
--   
--   Since: 3.24.8
type ApplicationQueryEndCallback = IO ()

-- | Connect a signal handler for the queryEnd signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on application #queryEnd callback
--   
onApplicationQueryEnd :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationQueryEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the queryEnd signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after application #queryEnd callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterApplicationQueryEnd :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationQueryEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the windowAdded signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on application #windowAdded callback
--   
onApplicationWindowAdded :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationWindowAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the windowAdded signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after application #windowAdded callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterApplicationWindowAdded :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationWindowAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the windowRemoved signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on application #windowRemoved callback
--   
onApplicationWindowRemoved :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationWindowRemovedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the windowRemoved signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after application #windowRemoved callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterApplicationWindowRemoved :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationWindowRemovedCallback) -> m SignalHandlerId

-- | Get the value of the “active-window” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get application #activeWindow
--   
getApplicationActiveWindow :: (MonadIO m, IsApplication o) => o -> m (Maybe Window)

-- | Get the value of the “app-menu” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get application #appMenu
--   
getApplicationAppMenu :: (MonadIO m, IsApplication o) => o -> m (Maybe MenuModel)

-- | Set the value of the “app-menu” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set application [ #appMenu := value ]
--   
setApplicationAppMenu :: (MonadIO m, IsApplication o, IsMenuModel a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “app-menu” property. This is rarely needed directly, but it
--   is used by new.
constructApplicationAppMenu :: (IsApplication o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “app-menu” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #appMenu
--   
clearApplicationAppMenu :: (MonadIO m, IsApplication o) => o -> m ()

-- | Get the value of the “menubar” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get application #menubar
--   
getApplicationMenubar :: (MonadIO m, IsApplication o) => o -> m MenuModel

-- | Set the value of the “menubar” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set application [ #menubar := value ]
--   
setApplicationMenubar :: (MonadIO m, IsApplication o, IsMenuModel a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “menubar” property. This is rarely needed directly, but it is
--   used by new.
constructApplicationMenubar :: (IsApplication o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “menubar” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #menubar
--   
clearApplicationMenubar :: (MonadIO m, IsApplication o) => o -> m ()

-- | Get the value of the “register-session” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get application #registerSession
--   
getApplicationRegisterSession :: (MonadIO m, IsApplication o) => o -> m Bool

-- | Set the value of the “register-session” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set application [ #registerSession := value ]
--   
setApplicationRegisterSession :: (MonadIO m, IsApplication o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “register-session” property. This is rarely needed directly,
--   but it is used by new.
constructApplicationRegisterSession :: (IsApplication o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “screensaver-active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get application #screensaverActive
--   
getApplicationScreensaverActive :: (MonadIO m, IsApplication o) => o -> m Bool

-- | Creates a new Application instance.
--   
--   When using Application, it is not necessary to call init
--   manually. It is called as soon as the application gets registered as
--   the primary instance.
--   
--   Concretely, init is called in the default handler for the
--   Application::startup signal. Therefore, Application
--   subclasses should chain up in their Application::startup
--   handler before using any GTK+ API.
--   
--   Note that commandline arguments are not passed to init. All
--   GTK+ functionality that is available via commandline arguments can
--   also be achieved by setting suitable environment variables such as
--   G_DEBUG, so this should not be a big problem. If you
--   absolutely must support GTK+ commandline arguments, you can explicitly
--   call init before creating the application instance.
--   
--   If non-Nothing, the application ID must be valid. See
--   applicationIdIsValid.
--   
--   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.
--   
--   Since: 3.0
applicationNew :: (HasCallStack, MonadIO m) => Maybe Text -> [ApplicationFlags] -> m (Maybe Application)

-- | Gets the accelerators that are currently associated with the given
--   action.
--   
--   Since: 3.12
applicationGetAccelsForAction :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> m [Text]

-- | Returns the list of actions (possibly empty) that
--   accel 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. Nothing is never returned.
--   
--   It is a programmer error to pass an invalid accelerator string. If you
--   are unsure, check it with acceleratorParse first.
--   
--   Since: 3.14
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.
--   
--   Since: 3.6
applicationGetActiveWindow :: (HasCallStack, MonadIO m, IsApplication a) => a -> m (Maybe Window)

-- | Returns the menu model that has been set with
--   applicationSetAppMenu.
--   
--   Since: 3.4
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.
--   
--   Since: 3.14
applicationGetMenuById :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> m Menu

-- | Returns the menu model that has been set with
--   applicationSetMenubar.
--   
--   Since: 3.4
applicationGetMenubar :: (HasCallStack, MonadIO m, IsApplication a) => a -> m MenuModel

-- | Returns the ApplicationWindow with the given ID.
--   
--   The ID of a ApplicationWindow can be retrieved with
--   applicationWindowGetId.
--   
--   Since: 3.6
applicationGetWindowById :: (HasCallStack, MonadIO m, IsApplication a) => a -> Word32 -> m (Maybe Window)

-- | Gets a list of the GtkWindows associated with
--   application.
--   
--   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.
--   
--   Since: 3.0
applicationGetWindows :: (HasCallStack, MonadIO m, IsApplication a) => a -> m [Window]

-- | Determines if any of the actions specified in flags
--   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).
--   
--   Since: 3.4
applicationIsInhibited :: (HasCallStack, MonadIO m, IsApplication a) => a -> [ApplicationInhibitFlags] -> m Bool

-- | Lists the detailed action names which have associated accelerators.
--   See applicationSetAccelsForAction.
--   
--   Since: 3.12
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 True then the application should call
--   applicationSetAppMenu with the contents of an application menu,
--   which will be shown by the desktop environment. If it returns
--   False 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 applicationSetAppMenu 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 False 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
--   applicationSetAppMenu anyway, then this menu will be replaced
--   with your own.
--   
--   Since: 3.14
applicationPrefersAppMenu :: (HasCallStack, MonadIO m, IsApplication a) => a -> m Bool

-- | Removes an accelerator that has been previously added with
--   applicationAddAccelerator.
--   
--   Since: 3.4
applicationRemoveAccelerator :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> Maybe GVariant -> m ()

-- | The accel-changed signal is emitted when an entry is added to or
--   removed from the accel group.
--   
--   Widgets like AccelLabel which display an associated accelerator
--   should connect to this signal, and rebuild their visual representation
--   if the accelClosure is theirs.
type AccelGroupAccelChangedCallback = Word32 -> [ModifierType] -> GClosure () -> IO ()

-- | The accel-activate signal is an implementation detail of
--   AccelGroup and not meant to be used by applications.
type AccelGroupAccelActivateCallback = Object -> Word32 -> [ModifierType] -> IO Bool

-- | Connect a signal handler for the accelActivate signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on accelGroup #accelActivate callback
--   
--   
--   This signal admits a optional parameter detail. If it's not
--   Nothing, we will connect to “accel-activate::detail”
--   instead.
onAccelGroupAccelActivate :: (IsAccelGroup a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AccelGroupAccelActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the accelActivate signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after accelGroup #accelActivate callback
--   
--   
--   This signal admits a optional parameter detail. If it's not
--   Nothing, we will connect to “accel-activate::detail”
--   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
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAccelGroupAccelActivate :: (IsAccelGroup a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AccelGroupAccelActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the accelChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on accelGroup #accelChanged callback
--   
--   
--   This signal admits a optional parameter detail. If it's not
--   Nothing, we will connect to “accel-changed::detail”
--   instead.
onAccelGroupAccelChanged :: (IsAccelGroup a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AccelGroupAccelChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the accelChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after accelGroup #accelChanged callback
--   
--   
--   This signal admits a optional parameter detail. If it's not
--   Nothing, we will connect to “accel-changed::detail”
--   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
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAccelGroupAccelChanged :: (IsAccelGroup a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AccelGroupAccelChangedCallback) -> m SignalHandlerId

-- | Get the value of the “is-locked” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get accelGroup #isLocked
--   
getAccelGroupIsLocked :: (MonadIO m, IsAccelGroup o) => o -> m Bool

-- | Get the value of the “modifier-mask” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get accelGroup #modifierMask
--   
getAccelGroupModifierMask :: (MonadIO m, IsAccelGroup o) => o -> m [ModifierType]

-- | Creates a new AccelGroup.
accelGroupNew :: (HasCallStack, MonadIO m) => m AccelGroup

-- | Finds the first accelerator in accelGroup that matches
--   accelKey and accelMods, and activates
--   it.
accelGroupActivate :: (HasCallStack, MonadIO m, IsAccelGroup a, IsObject b) => a -> Word32 -> b -> Word32 -> [ModifierType] -> m Bool

-- | Removes an accelerator previously installed through
--   accelGroupConnect.
--   
--   Since 2.20 closure can be Nothing.
accelGroupDisconnect :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> Maybe (GClosure b) -> m Bool

-- | Removes an accelerator previously installed through
--   accelGroupConnect.
accelGroupDisconnectKey :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> Word32 -> [ModifierType] -> m Bool

-- | Finds the first entry in an accelerator group for which
--   findFunc returns True and returns its
--   AccelKey.
accelGroupFind :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> AccelGroupFindFunc -> m AccelKey

-- | Locks are added and removed using accelGroupLock and
--   accelGroupUnlock.
--   
--   Since: 2.14
accelGroupGetIsLocked :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> m Bool

-- | Gets a ModifierType representing the mask for this
--   accelGroup. For example,
--   GDK_CONTROL_MASK, GDK_SHIFT_MASK, etc.
--   
--   Since: 2.14
accelGroupGetModifierMask :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> m [ModifierType]

-- | Queries an accelerator group for all entries matching
--   accelKey and accelMods.
accelGroupQuery :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> Word32 -> [ModifierType] -> m (Maybe [AccelGroupEntry])

-- | 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 path 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 ()

-- | Creates a new TreeModel, with childModel as the
--   child_model and root as the virtual root.
--   
--   Since: 2.4
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 iter with the first iterator in the tree
--   (the one at the path "0") and returns True. Returns
--   False if the tree is empty.
treeModelGetIterFirst :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m (Bool, TreeIter)

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

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

-- | Returns a newly-created TreePath-struct referenced by
--   iter.
--   
--   This path should be freed with treePathFree.
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.
--   
--   Since: 2.2
treeModelGetStringFromIter :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m Text

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

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

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

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

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

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

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

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

-- | Emits the TreeModel::rowDeleted signal on
--   treeModel.
--   
--   This should be called by models after a row has been removed. The
--   location pointed to by path 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 TreeModel::rowHasChildToggled signal on
--   treeModel. 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 TreeModel::rowInserted signal on
--   treeModel.
treeModelRowInserted :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> TreeIter -> m ()

-- | Emits the TreeModel::rows-reordered signal on
--   treeModel.
--   
--   This should be called by models when their rows have been reordered.
--   
--   Since: 3.10
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
--   treeModelRefNode.
--   
--   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 rowChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on treeModel #rowChanged callback
--   
onTreeModelRowChanged :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowChangedCallback) -> m SignalHandlerId

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

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

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

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

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

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

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

-- | No description available in the introspection data.
type TreeViewColumnClickedCallback = IO ()

-- | Connect a signal handler for the clicked signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on treeViewColumn #clicked callback
--   
onTreeViewColumnClicked :: (IsTreeViewColumn a, MonadIO m) => a -> ((?self :: a) => TreeViewColumnClickedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the clicked signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after treeViewColumn #clicked callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewColumnClicked :: (IsTreeViewColumn a, MonadIO m) => a -> ((?self :: a) => TreeViewColumnClickedCallback) -> m SignalHandlerId

-- | Get the value of the “alignment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #alignment
--   
getTreeViewColumnAlignment :: (MonadIO m, IsTreeViewColumn o) => o -> m Float

-- | Set the value of the “alignment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #alignment := value ]
--   
setTreeViewColumnAlignment :: (MonadIO m, IsTreeViewColumn o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “alignment” property. This is rarely needed directly, but it
--   is used by new.
constructTreeViewColumnAlignment :: (IsTreeViewColumn o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “cell-area” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #cellArea
--   
getTreeViewColumnCellArea :: (MonadIO m, IsTreeViewColumn o) => o -> m (Maybe CellArea)

-- | Construct a GValueConstruct with valid value for the
--   “cell-area” property. This is rarely needed directly, but it
--   is used by new.
constructTreeViewColumnCellArea :: (IsTreeViewColumn o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “clickable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #clickable
--   
getTreeViewColumnClickable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “clickable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #clickable := value ]
--   
setTreeViewColumnClickable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “clickable” property. This is rarely needed directly, but it
--   is used by new.
constructTreeViewColumnClickable :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “expand” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #expand
--   
getTreeViewColumnExpand :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “expand” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #expand := value ]
--   
setTreeViewColumnExpand :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “expand” property. This is rarely needed directly, but it is
--   used by new.
constructTreeViewColumnExpand :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “fixed-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #fixedWidth
--   
getTreeViewColumnFixedWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “fixed-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #fixedWidth := value ]
--   
setTreeViewColumnFixedWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “fixed-width” property. This is rarely needed directly, but
--   it is used by new.
constructTreeViewColumnFixedWidth :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “max-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #maxWidth
--   
getTreeViewColumnMaxWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “max-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #maxWidth := value ]
--   
setTreeViewColumnMaxWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “max-width” property. This is rarely needed directly, but it
--   is used by new.
constructTreeViewColumnMaxWidth :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “min-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #minWidth
--   
getTreeViewColumnMinWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “min-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #minWidth := value ]
--   
setTreeViewColumnMinWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “min-width” property. This is rarely needed directly, but it
--   is used by new.
constructTreeViewColumnMinWidth :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “reorderable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #reorderable
--   
getTreeViewColumnReorderable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “reorderable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #reorderable := value ]
--   
setTreeViewColumnReorderable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “reorderable” property. This is rarely needed directly, but
--   it is used by new.
constructTreeViewColumnReorderable :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “resizable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #resizable
--   
getTreeViewColumnResizable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “resizable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #resizable := value ]
--   
setTreeViewColumnResizable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “resizable” property. This is rarely needed directly, but it
--   is used by new.
constructTreeViewColumnResizable :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “sizing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #sizing
--   
getTreeViewColumnSizing :: (MonadIO m, IsTreeViewColumn o) => o -> m TreeViewColumnSizing

-- | Set the value of the “sizing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #sizing := value ]
--   
setTreeViewColumnSizing :: (MonadIO m, IsTreeViewColumn o) => o -> TreeViewColumnSizing -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “sizing” property. This is rarely needed directly, but it is
--   used by new.
constructTreeViewColumnSizing :: (IsTreeViewColumn o, MonadIO m) => TreeViewColumnSizing -> m (GValueConstruct o)

-- | Get the value of the “sort-column-id” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #sortColumnId
--   
getTreeViewColumnSortColumnId :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “sort-column-id” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #sortColumnId := value ]
--   
setTreeViewColumnSortColumnId :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “sort-column-id” property. This is rarely needed directly,
--   but it is used by new.
constructTreeViewColumnSortColumnId :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “sort-indicator” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #sortIndicator
--   
getTreeViewColumnSortIndicator :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “sort-indicator” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #sortIndicator := value ]
--   
setTreeViewColumnSortIndicator :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “sort-indicator” property. This is rarely needed directly,
--   but it is used by new.
constructTreeViewColumnSortIndicator :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “sort-order” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #sortOrder
--   
getTreeViewColumnSortOrder :: (MonadIO m, IsTreeViewColumn o) => o -> m SortType

-- | Set the value of the “sort-order” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #sortOrder := value ]
--   
setTreeViewColumnSortOrder :: (MonadIO m, IsTreeViewColumn o) => o -> SortType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “sort-order” property. This is rarely needed directly, but it
--   is used by new.
constructTreeViewColumnSortOrder :: (IsTreeViewColumn o, MonadIO m) => SortType -> m (GValueConstruct o)

-- | Get the value of the “spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #spacing
--   
getTreeViewColumnSpacing :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #spacing := value ]
--   
setTreeViewColumnSpacing :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “spacing” property. This is rarely needed directly, but it is
--   used by new.
constructTreeViewColumnSpacing :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #title
--   
getTreeViewColumnTitle :: (MonadIO m, IsTreeViewColumn o) => o -> m Text

-- | Set the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #title := value ]
--   
setTreeViewColumnTitle :: (MonadIO m, IsTreeViewColumn o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “title” property. This is rarely needed directly, but it is
--   used by new.
constructTreeViewColumnTitle :: (IsTreeViewColumn o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #visible
--   
getTreeViewColumnVisible :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #visible := value ]
--   
setTreeViewColumnVisible :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible” property. This is rarely needed directly, but it is
--   used by new.
constructTreeViewColumnVisible :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #widget
--   
getTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o) => o -> m (Maybe Widget)

-- | Set the value of the “widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeViewColumn [ #widget := value ]
--   
setTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “widget” property. This is rarely needed directly, but it is
--   used by new.
constructTreeViewColumnWidget :: (IsTreeViewColumn o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “widget” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #widget
--   
clearTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o) => o -> m ()

-- | Get the value of the “width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #width
--   
getTreeViewColumnWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Get the value of the “x-offset” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeViewColumn #xOffset
--   
getTreeViewColumnXOffset :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Creates a new TreeViewColumn.
treeViewColumnNew :: (HasCallStack, MonadIO m) => m TreeViewColumn

-- | Creates a new TreeViewColumn using area to
--   render its cells.
--   
--   Since: 3.0
treeViewColumnNewWithArea :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m TreeViewColumn

-- | Adds an attribute mapping to the list in treeColumn.
--   The column is the column of the model to get a value
--   from, and the attribute is the parameter on
--   cellRenderer 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 CellRendererText 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, startPos and
--   width are not changed and False 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 TreeView.
treeViewColumnCellGetSize :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Maybe Rectangle -> m (Int32, Int32, Int32, Int32)

-- | Returns True if any of the cells packed into the
--   treeColumn are visible. For this to be meaningful, you
--   must first initialize the cells with
--   treeViewColumnCellSetCellData
treeViewColumnCellIsVisible :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Unsets all the mappings on all renderers on the
--   treeColumn.
treeViewColumnClear :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m ()

-- | Clears all existing attributes previously set with
--   gtk_tree_view_column_set_attributes().
treeViewColumnClearAttributes :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> m ()

-- | Emits the “clicked” signal on the column. This function will only work
--   if treeColumn is clickable.
treeViewColumnClicked :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m ()

-- | Sets the current keyboard focus to be at cell, if the
--   column contains 2 or more editable and activatable cells.
--   
--   Since: 2.2
treeViewColumnFocusCell :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> m ()

-- | Returns the current x alignment of treeColumn. 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
--   
--   Since: 3.0
treeViewColumnGetButton :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Widget

-- | Returns True if the user can click on the header for the
--   column.
treeViewColumnGetClickable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Returns True if the column expands to fill available space.
--   
--   Since: 2.4
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
--   treeViewColumnGetWidth.
treeViewColumnGetFixedWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Returns the maximum width in pixels of the treeColumn,
--   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 treeColumn,
--   or -1 if no minimum width is set.
treeViewColumnGetMinWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Returns True if the treeColumn can be reordered
--   by the user.
treeViewColumnGetReorderable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Returns True if the treeColumn can be resized
--   by the end user.
treeViewColumnGetResizable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Returns the current type of treeColumn.
treeViewColumnGetSizing :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m TreeViewColumnSizing

-- | Gets the logical sortColumnId that the model sorts on
--   when this column is selected for sorting. See
--   treeViewColumnSetSortColumnId.
treeViewColumnGetSortColumnId :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Gets the value set by treeViewColumnSetSortIndicator.
treeViewColumnGetSortIndicator :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Gets the value set by treeViewColumnSetSortOrder.
treeViewColumnGetSortOrder :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m SortType

-- | Returns the spacing of treeColumn.
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 TreeView wherein treeColumn has
--   been inserted. If column is currently not inserted in
--   any tree view, Nothing is returned.
--   
--   Since: 2.12
treeViewColumnGetTreeView :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m (Maybe Widget)

-- | Returns True if treeColumn is visible.
treeViewColumnGetVisible :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Returns the Widget in the button on the column header. If a
--   custom widget has not been set then Nothing is returned.
treeViewColumnGetWidget :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m (Maybe Widget)

-- | Returns the current X offset of treeColumn in pixels.
--   
--   Since: 3.2
treeViewColumnGetXOffset :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Adds the cell to end of the column. If
--   expand is False, then the cell
--   is allocated no more space than it needs. Any unused space is divided
--   evenly between cells for which expand is True.
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.
--   
--   Since: 2.8
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 clickable is
--   True. 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 True.
--   If no column has this option set, then the last column gets all extra
--   space. By default, every column is created with this False.
--   
--   Along with “fixed-width”, the “expand” property changes when the
--   column is resized by the user.
--   
--   Since: 2.4
treeViewColumnSetExpand :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | If fixedWidth is not -1, sets the fixed width of
--   treeColumn; otherwise unsets it. The effective value
--   of fixedWidth 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
--   GTK_TREE_VIEW_COLUMN_GROW_ONLY or
--   GTK_TREE_VIEW_COLUMN_AUTOSIZE, setting a fixed width
--   overrides the automatically calculated width. Note that
--   fixedWidth 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 treeColumn. If
--   maxWidth 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 treeColumn. If
--   minWidth is -1, then the minimum width is unset.
treeViewColumnSetMinWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Int32 -> m ()

-- | If reorderable is True, then the column can be
--   reordered by the end user dragging the header.
treeViewColumnSetReorderable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | If resizable is True, then the user can
--   explicitly resize the column by grabbing the outer edge of the column
--   button. If resizable is True and sizing mode of the column is
--   GTK_TREE_VIEW_COLUMN_AUTOSIZE, then the sizing mode is
--   changed to GTK_TREE_VIEW_COLUMN_GROW_ONLY.
treeViewColumnSetResizable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | Sets the growth behavior of treeColumn to
--   type.
treeViewColumnSetSizing :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> TreeViewColumnSizing -> m ()

-- | Sets the spacing field of treeColumn, 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 treeColumn. 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 treeColumn.
treeViewColumnSetVisible :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | Sets the widget in the header to be widget. If widget
--   is Nothing, then the header button is set with a Label
--   set to the title of treeColumn.
treeViewColumnSetWidget :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsWidget b) => a -> Maybe b -> m ()

-- | This signal gets emitted when a cell starts to be edited. The intended
--   use of this signal is to do special setup on editable,
--   e.g. adding a EntryCompletion or setting up additional columns
--   in a ComboBox.
--   
--   See cellEditableStartEditing for information on the lifecycle
--   of the editable and a way to do setup that doesn’t
--   depend on the renderer.
--   
--   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 editable before doing any
--   specific setup, as in the following example:
--   
--   
C code
--   
--   
--   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);
--       }
--   }
--   
--   
--   Since: 2.6
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: cellRendererStopEditing.
--   
--   Since: 2.4
type CellRendererEditingCanceledCallback = IO ()

-- | Connect a signal handler for the editingCanceled signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on cellRenderer #editingCanceled callback
--   
onCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> ((?self :: a) => CellRendererEditingCanceledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the editingCanceled signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after cellRenderer #editingCanceled callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> ((?self :: a) => CellRendererEditingCanceledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the editingStarted signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on cellRenderer #editingStarted callback
--   
onCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> ((?self :: a) => CellRendererEditingStartedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the editingStarted signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after cellRenderer #editingStarted callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> ((?self :: a) => CellRendererEditingStartedCallback) -> m SignalHandlerId

-- | Set the value of the “cell-background” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #cellBackground := value ]
--   
setCellRendererCellBackground :: (MonadIO m, IsCellRenderer o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “cell-background” property. This is rarely needed directly,
--   but it is used by new.
constructCellRendererCellBackground :: (IsCellRenderer o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “cell-background” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #cellBackground
--   
clearCellRendererCellBackground :: (MonadIO m, IsCellRenderer o) => o -> m ()

-- | Get the value of the “cell-background-gdk” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRenderer #cellBackgroundGdk
--   
getCellRendererCellBackgroundGdk :: (MonadIO m, IsCellRenderer o) => o -> m (Maybe Color)

-- | Set the value of the “cell-background-gdk” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #cellBackgroundGdk := value ]
--   
setCellRendererCellBackgroundGdk :: (MonadIO m, IsCellRenderer o) => o -> Color -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “cell-background-gdk” property. This is rarely needed
--   directly, but it is used by new.
constructCellRendererCellBackgroundGdk :: (IsCellRenderer o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Set the value of the “cell-background-gdk” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #cellBackgroundGdk
--   
clearCellRendererCellBackgroundGdk :: (MonadIO m, IsCellRenderer o) => o -> m ()

-- | Get the value of the “cell-background-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRenderer #cellBackgroundRgba
--   
getCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> m (Maybe RGBA)

-- | Set the value of the “cell-background-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #cellBackgroundRgba := value ]
--   
setCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> RGBA -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “cell-background-rgba” property. This is rarely needed
--   directly, but it is used by new.
constructCellRendererCellBackgroundRgba :: (IsCellRenderer o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “cell-background-rgba” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #cellBackgroundRgba
--   
clearCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> m ()

-- | Get the value of the “cell-background-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRenderer #cellBackgroundSet
--   
getCellRendererCellBackgroundSet :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “cell-background-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #cellBackgroundSet := value ]
--   
setCellRendererCellBackgroundSet :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “cell-background-set” property. This is rarely needed
--   directly, but it is used by new.
constructCellRendererCellBackgroundSet :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “editing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRenderer #editing
--   
getCellRendererEditing :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Get the value of the “height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRenderer #height
--   
getCellRendererHeight :: (MonadIO m, IsCellRenderer o) => o -> m Int32

-- | Set the value of the “height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #height := value ]
--   
setCellRendererHeight :: (MonadIO m, IsCellRenderer o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “height” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererHeight :: (IsCellRenderer o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “is-expanded” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRenderer #isExpanded
--   
getCellRendererIsExpanded :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “is-expanded” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #isExpanded := value ]
--   
setCellRendererIsExpanded :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “is-expanded” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererIsExpanded :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “is-expander” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRenderer #isExpander
--   
getCellRendererIsExpander :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “is-expander” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #isExpander := value ]
--   
setCellRendererIsExpander :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “is-expander” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererIsExpander :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “mode” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get cellRenderer #mode
--   
getCellRendererMode :: (MonadIO m, IsCellRenderer o) => o -> m CellRendererMode

-- | Set the value of the “mode” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #mode := value ]
--   
setCellRendererMode :: (MonadIO m, IsCellRenderer o) => o -> CellRendererMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “mode” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererMode :: (IsCellRenderer o, MonadIO m) => CellRendererMode -> m (GValueConstruct o)

-- | Get the value of the “sensitive” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRenderer #sensitive
--   
getCellRendererSensitive :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “sensitive” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #sensitive := value ]
--   
setCellRendererSensitive :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “sensitive” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererSensitive :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRenderer #visible
--   
getCellRendererVisible :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #visible := value ]
--   
setCellRendererVisible :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererVisible :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRenderer #width
--   
getCellRendererWidth :: (MonadIO m, IsCellRenderer o) => o -> m Int32

-- | Set the value of the “width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #width := value ]
--   
setCellRendererWidth :: (MonadIO m, IsCellRenderer o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “width” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererWidth :: (IsCellRenderer o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRenderer #xalign
--   
getCellRendererXalign :: (MonadIO m, IsCellRenderer o) => o -> m Float

-- | Set the value of the “xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #xalign := value ]
--   
setCellRendererXalign :: (MonadIO m, IsCellRenderer o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “xalign” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererXalign :: (IsCellRenderer o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “xpad” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get cellRenderer #xpad
--   
getCellRendererXpad :: (MonadIO m, IsCellRenderer o) => o -> m Word32

-- | Set the value of the “xpad” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #xpad := value ]
--   
setCellRendererXpad :: (MonadIO m, IsCellRenderer o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “xpad” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererXpad :: (IsCellRenderer o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRenderer #yalign
--   
getCellRendererYalign :: (MonadIO m, IsCellRenderer o) => o -> m Float

-- | Set the value of the “yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #yalign := value ]
--   
setCellRendererYalign :: (MonadIO m, IsCellRenderer o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “yalign” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererYalign :: (IsCellRenderer o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “ypad” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get cellRenderer #ypad
--   
getCellRendererYpad :: (MonadIO m, IsCellRenderer o) => o -> m Word32

-- | Set the value of the “ypad” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set cellRenderer [ #ypad := value ]
--   
setCellRendererYpad :: (MonadIO m, IsCellRenderer o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “ypad” property. This is rarely needed directly, but it is
--   used by new.
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,
--   CellRendererToggle 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 cell inside
--   cellArea. Used for finding the appropriate edit and
--   focus rectangle.
--   
--   Since: 3.0
cellRendererGetAlignedArea :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> [CellRendererState] -> Rectangle -> m Rectangle

-- | Fills in xalign and yalign with the
--   appropriate values of cell.
--   
--   Since: 2.18
cellRendererGetAlignment :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m (Float, Float)

-- | Fills in width and height with the
--   appropriate size of cell.
cellRendererGetFixedSize :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m (Int32, Int32)

-- | Fills in xpad and ypad with the
--   appropriate values of cell.
--   
--   Since: 2.18
cellRendererGetPadding :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m (Int32, Int32)

-- | Retreives a renderer’s natural size when rendered to
--   widget.
--   
--   Since: 3.0
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 widget with the specified
--   width.
--   
--   Since: 3.0
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.
--   
--   Since: 3.0
cellRendererGetPreferredSize :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> m (Requisition, Requisition)

-- | Retreives a renderer’s natural size when rendered to
--   widget.
--   
--   Since: 3.0
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 widget with the specified
--   height.
--   
--   Since: 3.0
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.
--   
--   Since: 3.0
cellRendererGetRequestMode :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m SizeRequestMode

-- | Returns the cell renderer’s sensitivity.
--   
--   Since: 2.18
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
--   cellRendererRender. If cellArea is not
--   Nothing, fills in the x and y offsets (if set) of the cell
--   relative to this location.
--   
--   Please note that the values set in width and
--   height, as well as those in xOffset
--   and yOffset 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 StateFlags, based on the
--   cell renderer and widget sensitivity, and the given
--   CellRendererState.
--   
--   Since: 3.0
cellRendererGetState :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => Maybe a -> Maybe b -> [CellRendererState] -> m [StateFlags]

-- | Returns the cell renderer’s visibility.
--   
--   Since: 2.18
cellRendererGetVisible :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m Bool

-- | Checks whether the cell renderer can do something when activated.
--   
--   Since: 3.0
cellRendererIsActivatable :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m Bool

-- | Sets the renderer’s alignment within its available space.
--   
--   Since: 2.18
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.
--   
--   Since: 2.18
cellRendererSetPadding :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Int32 -> Int32 -> m ()

-- | Sets the cell renderer’s sensitivity.
--   
--   Since: 2.18
cellRendererSetSensitive :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Bool -> m ()

-- | Sets the cell renderer’s visibility.
--   
--   Since: 2.18
cellRendererSetVisible :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Bool -> m ()

-- | Returns the IconFactory defined to be in use for
--   path, or Nothing if none is defined.
--   
--   Since: 3.0
styleProviderGetIconFactory :: (HasCallStack, MonadIO m, IsStyleProvider a) => a -> WidgetPath -> m (Maybe IconFactory)

-- | Returns the style settings affecting a widget defined by
--   path, or Nothing if provider
--   doesn’t contemplate styling path.
--   
--   Since: 3.0
styleProviderGetStyle :: (HasCallStack, MonadIO m, IsStyleProvider a) => a -> WidgetPath -> m (Maybe StyleProperties)

-- | Looks up a widget style property as defined by
--   provider for the widget represented by
--   path.
--   
--   Since: 3.0
styleProviderGetStyleProperty :: (HasCallStack, MonadIO m, IsStyleProvider a) => a -> WidgetPath -> [StateFlags] -> GParamSpec -> m (Bool, GValue)

-- | Adds a child to buildable. type is an
--   optional string describing how the child should be added.
--   
--   Since: 2.12
buildableAddChild :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b, IsObject c) => a -> b -> c -> Maybe Text -> m ()

-- | Constructs a child of buildable with the name
--   name.
--   
--   Builder calls this function if a “constructor” has been
--   specified in the UI definition.
--   
--   Since: 2.12
buildableConstructChild :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b) => a -> b -> Text -> m Object

-- | This is similar to buildableParserFinished but is called once
--   for each custom tag handled by the buildable.
--   
--   Since: 2.12
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.
--   
--   Since: 2.12
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 <child>.
--   
--   Since: 2.12
buildableCustomTagStart :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b, IsObject c) => a -> b -> Maybe c -> Text -> m (Bool, MarkupParser, Ptr ())

-- | Get the internal child called childname of the
--   buildable object.
--   
--   Since: 2.12
buildableGetInternalChild :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b) => a -> b -> Text -> m Object

-- | Gets the name of the buildable object.
--   
--   Builder sets the name based on the [GtkBuilder UI
--   definition][BUILDER-UI] used to construct the
--   buildable.
--   
--   Since: 2.12
buildableGetName :: (HasCallStack, MonadIO m, IsBuildable a) => a -> m Text

-- | Sets the property name name to value
--   on the buildable object.
--   
--   Since: 2.12
buildableSetBuildableProperty :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b) => a -> b -> Text -> GValue -> m ()

-- | This signal is meant to indicate that the cell is finished editing,
--   and the cellEditable widget is being removed and may
--   subsequently be destroyed.
--   
--   Implementations of CellEditable are responsible for emitting
--   this signal when they are done editing. It must be emitted after the
--   CellEditable::editingDone signal, to give the cell renderer a
--   chance to update the cell's value before the widget is removed.
--   
--   cellEditableRemoveWidget is a convenience method for emitting
--   CellEditable::removeWidget.
type CellEditableRemoveWidgetCallback = IO ()

-- | This signal is a sign for the cell renderer to update its value from
--   the cellEditable.
--   
--   Implementations of CellEditable are responsible for emitting
--   this signal when they are done editing, e.g. Entry emits this
--   signal when the user presses Enter. Typical things to do in a handler
--   for editingDone are to capture the edited value, disconnect the
--   cellEditable from signals on the CellRenderer,
--   etc.
--   
--   cellEditableEditingDone is a convenience method for emitting
--   CellEditable::editingDone.
type CellEditableEditingDoneCallback = IO ()

-- | Get the value of the “editing-canceled” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellEditable #editingCanceled
--   
getCellEditableEditingCanceled :: (MonadIO m, IsCellEditable o) => o -> m Bool

-- | Set the value of the “editing-canceled” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellEditable [ #editingCanceled := value ]
--   
setCellEditableEditingCanceled :: (MonadIO m, IsCellEditable o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “editing-canceled” property. This is rarely needed directly,
--   but it is used by new.
constructCellEditableEditingCanceled :: (IsCellEditable o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Connect a signal handler for the editingDone signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on cellEditable #editingDone callback
--   
onCellEditableEditingDone :: (IsCellEditable a, MonadIO m) => a -> ((?self :: a) => CellEditableEditingDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the editingDone signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after cellEditable #editingDone callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCellEditableEditingDone :: (IsCellEditable a, MonadIO m) => a -> ((?self :: a) => CellEditableEditingDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the removeWidget signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on cellEditable #removeWidget callback
--   
onCellEditableRemoveWidget :: (IsCellEditable a, MonadIO m) => a -> ((?self :: a) => CellEditableRemoveWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the removeWidget signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after cellEditable #removeWidget callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCellEditableRemoveWidget :: (IsCellEditable a, MonadIO m) => a -> ((?self :: a) => CellEditableRemoveWidgetCallback) -> m SignalHandlerId

-- | Get the value of the “area” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get cellAreaContext #area
--   
getCellAreaContextArea :: (MonadIO m, IsCellAreaContext o) => o -> m CellArea

-- | Construct a GValueConstruct with valid value for the
--   “area” property. This is rarely needed directly, but it is
--   used by new.
constructCellAreaContextArea :: (IsCellAreaContext o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “minimum-height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellAreaContext #minimumHeight
--   
getCellAreaContextMinimumHeight :: (MonadIO m, IsCellAreaContext o) => o -> m Int32

-- | Get the value of the “minimum-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellAreaContext #minimumWidth
--   
getCellAreaContextMinimumWidth :: (MonadIO m, IsCellAreaContext o) => o -> m Int32

-- | Get the value of the “natural-height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellAreaContext #naturalHeight
--   
getCellAreaContextNaturalHeight :: (MonadIO m, IsCellAreaContext o) => o -> m Int32

-- | Get the value of the “natural-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellAreaContext #naturalWidth
--   
getCellAreaContextNaturalWidth :: (MonadIO m, IsCellAreaContext o) => o -> m Int32

-- | Allocates a width and/or a height for all rows which are to be
--   rendered with context.
--   
--   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 TreeView when
--   TreeView:fixedHeightMode is enabled.
--   
--   Since 3.0
cellAreaContextAllocate :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> Int32 -> m ()

-- | Fetches the current allocation size for context.
--   
--   If the context was not allocated in width or height, or if the context
--   was recently reset with cellAreaContextReset, the returned
--   value will be -1.
--   
--   Since: 3.0
cellAreaContextGetAllocation :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m (Int32, Int32)

-- | Fetches the CellArea this context 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 CellAreaContextClass.allocate()
--   time it’s important to know details about any cell spacing that the
--   CellArea is configured with in order to compute a proper
--   allocation.
--   
--   Since: 3.0
cellAreaContextGetArea :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m CellArea

-- | Gets the accumulative preferred height for width for
--   all rows which have been requested for the same said
--   width with this context.
--   
--   After cellAreaContextReset is called and/or before ever
--   requesting the size of a CellArea, the returned values are -1.
--   
--   Since: 3.0
cellAreaContextGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> m (Int32, Int32)

-- | Gets the accumulative preferred width for height for
--   all rows which have been requested for the same said
--   height with this context.
--   
--   After cellAreaContextReset is called and/or before ever
--   requesting the size of a CellArea, the returned values are -1.
--   
--   Since: 3.0
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 CellAreaContext implementations during the
--   request process over a series of TreeModel rows to
--   progressively push the requested height over a series of
--   cellAreaGetPreferredHeight requests.
--   
--   Since: 3.0
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 CellAreaContext implementations during the
--   request process over a series of TreeModel rows to
--   progressively push the requested width over a series of
--   cellAreaGetPreferredWidth requests.
--   
--   Since: 3.0
cellAreaContextPushPreferredWidth :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> Int32 -> m ()

-- | Indicates that editing finished on renderer and that
--   editable should be removed from the owning
--   cell-layouting widget.
--   
--   Since: 3.0
type CellAreaRemoveEditableCallback = CellRenderer -> CellEditable -> IO ()

-- | Indicates that focus changed on this area. 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.
--   
--   Since: 3.0
type CellAreaFocusChangedCallback = CellRenderer -> Text -> IO ()

-- | This signal is emitted whenever applying attributes to
--   area from model
--   
--   Since: 3.0
type CellAreaApplyAttributesCallback = TreeModel -> TreeIter -> Bool -> Bool -> IO ()

-- | Indicates that editing has started on renderer and
--   that editable should be added to the owning
--   cell-layouting widget at cellArea.
--   
--   Since: 3.0
type CellAreaAddEditableCallback = CellRenderer -> CellEditable -> Rectangle -> Text -> IO ()

-- | Connect a signal handler for the addEditable signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on cellArea #addEditable callback
--   
onCellAreaAddEditable :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaAddEditableCallback) -> m SignalHandlerId

-- | Connect a signal handler for the addEditable signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after cellArea #addEditable callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCellAreaAddEditable :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaAddEditableCallback) -> m SignalHandlerId

-- | Connect a signal handler for the applyAttributes signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on cellArea #applyAttributes callback
--   
onCellAreaApplyAttributes :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaApplyAttributesCallback) -> m SignalHandlerId

-- | Connect a signal handler for the applyAttributes signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after cellArea #applyAttributes callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCellAreaApplyAttributes :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaApplyAttributesCallback) -> m SignalHandlerId

-- | Connect a signal handler for the focusChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on cellArea #focusChanged callback
--   
onCellAreaFocusChanged :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaFocusChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the focusChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after cellArea #focusChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCellAreaFocusChanged :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaFocusChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the removeEditable signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on cellArea #removeEditable callback
--   
onCellAreaRemoveEditable :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaRemoveEditableCallback) -> m SignalHandlerId

-- | Connect a signal handler for the removeEditable signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after cellArea #removeEditable callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCellAreaRemoveEditable :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaRemoveEditableCallback) -> m SignalHandlerId

-- | Get the value of the “edit-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellArea #editWidget
--   
getCellAreaEditWidget :: (MonadIO m, IsCellArea o) => o -> m CellEditable

-- | Get the value of the “edited-cell” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellArea #editedCell
--   
getCellAreaEditedCell :: (MonadIO m, IsCellArea o) => o -> m CellRenderer

-- | Get the value of the “focus-cell” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellArea #focusCell
--   
getCellAreaFocusCell :: (MonadIO m, IsCellArea o) => o -> m CellRenderer

-- | Set the value of the “focus-cell” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellArea [ #focusCell := value ]
--   
setCellAreaFocusCell :: (MonadIO m, IsCellArea o, IsCellRenderer a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “focus-cell” property. This is rarely needed directly, but it
--   is used by new.
constructCellAreaFocusCell :: (IsCellArea o, MonadIO m, IsCellRenderer a) => a -> m (GValueConstruct o)

-- | Activates area, 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.
--   
--   Since: 3.0
cellAreaActivate :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Rectangle -> [CellRendererState] -> Bool -> m Bool

-- | This is used by CellArea subclasses when handling events to
--   activate cells, the base CellArea class activates cells for
--   keyboard events for free in its own
--   GtkCellArea->activate() implementation.
--   
--   Since: 3.0
cellAreaActivateCell :: (HasCallStack, MonadIO m, IsCellArea a, IsWidget b, IsCellRenderer c) => a -> b -> c -> Event -> Rectangle -> [CellRendererState] -> m Bool

-- | Adds renderer to area with the default
--   child cell properties.
--   
--   Since: 3.0
cellAreaAdd :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m ()

-- | Connects an attribute to apply values from
--   column for the TreeModel in use.
--   
--   Since: 3.0
cellAreaAttributeConnect :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> Text -> Int32 -> m ()

-- | Disconnects attribute for the renderer
--   in area so that attribute will no longer be updated
--   with values from the model.
--   
--   Since: 3.0
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.
--   
--   Since: 3.14
cellAreaAttributeGetColumn :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> Text -> m Int32

-- | Gets the value of a cell property for renderer in
--   area.
--   
--   Since: 3.0
cellAreaCellGetProperty :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> Text -> GValue -> m ()

-- | Sets a cell property for renderer in
--   area.
--   
--   Since: 3.0
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, IconView 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. IconView 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.
--   
--   Since: 3.0
cellAreaCopyContext :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b) => a -> b -> m CellAreaContext

-- | Creates a CellAreaContext to be used with area
--   for all purposes. CellAreaContext 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 CellAreaContext which was used
--   to request the size of those rows of data).
--   
--   Since: 3.0
cellAreaCreateContext :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m CellAreaContext

-- | Delegates event handling to a CellArea.
--   
--   Since: 3.0
cellAreaEvent :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Event -> Rectangle -> [CellRendererState] -> m Int32

-- | This should be called by the area’s owning layout
--   widget when focus is to be passed to area, or moved
--   within area for a given direction and
--   row data.
--   
--   Implementing CellArea classes should implement this method to
--   receive and navigate focus in its own way particular to how it lays
--   out cells.
--   
--   Since: 3.0
cellAreaFocus :: (HasCallStack, MonadIO m, IsCellArea a) => a -> DirectionType -> m Bool

-- | Derives the allocation of renderer inside
--   area if area were to be renderered in
--   cellArea.
--   
--   Since: 3.0
cellAreaGetCellAllocation :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c, IsCellRenderer d) => a -> b -> c -> d -> Rectangle -> m Rectangle

-- | Gets the CellRenderer at x and
--   y coordinates inside area and
--   optionally returns the full cell allocation for it inside
--   cellArea.
--   
--   Since: 3.0
cellAreaGetCellAtPosition :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Rectangle -> Int32 -> Int32 -> m (CellRenderer, Rectangle)

-- | Gets the current TreePath string for the currently applied
--   TreeIter, this is implicitly updated when
--   cellAreaApplyAttributes is called and can be used to interact
--   with renderers from CellArea subclasses.
--   
--   Since: 3.0
cellAreaGetCurrentPathString :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m Text

-- | Retrieves the currently focused cell for area
--   
--   Since: 3.0
cellAreaGetFocusCell :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m CellRenderer

-- | Gets the CellRenderer which is expected to be focusable for
--   which renderer is, or may be a sibling.
--   
--   This is handy for CellArea 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.
--   
--   Since: 3.0
cellAreaGetFocusFromSibling :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m (Maybe CellRenderer)

-- | Gets the focus sibling cell renderers for renderer.
--   
--   Since: 3.0
cellAreaGetFocusSiblings :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m [CellRenderer]

-- | Gets whether the area prefers a height-for-width layout or a
--   width-for-height layout.
--   
--   Since: 3.0
cellAreaGetRequestMode :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m SizeRequestMode

-- | Checks if area contains renderer.
--   
--   Since: 3.0
cellAreaHasRenderer :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m Bool

-- | Returns whether the area can do anything when activated, after
--   applying new attributes to area.
--   
--   Since: 3.0
cellAreaIsActivatable :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m Bool

-- | Returns whether sibling is one of
--   renderer’s focus siblings (see
--   cellAreaAddFocusSibling).
--   
--   Since: 3.0
cellAreaIsFocusSibling :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b, IsCellRenderer c) => a -> b -> c -> m Bool

-- | Removes renderer from area.
--   
--   Since: 3.0
cellAreaRemove :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m ()

-- | Removes sibling from renderer’s focus
--   sibling list (see cellAreaAddFocusSibling).
--   
--   Since: 3.0
cellAreaRemoveFocusSibling :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b, IsCellRenderer c) => a -> b -> c -> m ()

-- | Renders area’s cells according to
--   area’s layout onto widget at the given
--   coordinates.
--   
--   Since: 3.0
cellAreaRender :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Context -> Rectangle -> Rectangle -> [CellRendererState] -> Bool -> m ()

-- | Explicitly sets the currently focused cell to
--   renderer.
--   
--   This is generally called by implementations of
--   CellAreaClass.focus() or
--   CellAreaClass.event(), however it can also be
--   used to implement functions such as treeViewSetCursorOnCell.
--   
--   Since: 3.0
cellAreaSetFocusCell :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m ()

-- | Explicitly stops the editing of the currently edited cell.
--   
--   If canceled is True, the currently edited cell
--   renderer will emit the editingCanceled signal, otherwise the
--   the editingDone signal will be emitted on the current edit
--   widget.
--   
--   See cellAreaGetEditedCell and cellAreaGetEditWidget.
--   
--   Since: 3.0
cellAreaStopEditing :: (HasCallStack, MonadIO m, IsCellArea a) => a -> Bool -> m ()

-- | Adds an attribute mapping to the list in cellLayout.
--   
--   The column is the column of the model to get a value
--   from, and the attribute is the parameter on
--   cell 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 CellRendererText get its values from column 2.
--   
--   Since: 2.4
cellLayoutAddAttribute :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Text -> Int32 -> m ()

-- | Clears all existing attributes previously set with
--   gtk_cell_layout_set_attributes().
--   
--   Since: 2.4
cellLayoutClearAttributes :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> m ()

-- | Returns the underlying CellArea which might be
--   cellLayout if called on a CellArea or might be
--   Nothing if no CellArea is used by
--   cellLayout.
--   
--   Since: 3.0
cellLayoutGetArea :: (HasCallStack, MonadIO m, IsCellLayout a) => a -> m (Maybe CellArea)

-- | Returns the cell renderers which have been added to
--   cellLayout.
--   
--   Since: 2.12
cellLayoutGetCells :: (HasCallStack, MonadIO m, IsCellLayout a) => a -> m [CellRenderer]

-- | Adds the cell to the end of
--   cellLayout. If expand is False,
--   then the cell is allocated no more space than it
--   needs. Any unused space is divided evenly between cells for which
--   expand is True.
--   
--   Note that reusing the same cell renderer is not supported.
--   
--   Since: 2.4
cellLayoutPackEnd :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Bool -> m ()

-- | Packs the cell into the beginning of
--   cellLayout. If expand is False,
--   then the cell is allocated no more space than it
--   needs. Any unused space is divided evenly between cells for which
--   expand is True.
--   
--   Note that reusing the same cell renderer is not supported.
--   
--   Since: 2.4
cellLayoutPackStart :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Bool -> m ()

-- | Re-inserts cell at position.
--   
--   Note that cell has already to be packed into
--   cellLayout for this to function properly.
--   
--   Since: 2.4
cellLayoutReorder :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Int32 -> m ()

-- | No description available in the introspection data.
type TreeViewUnselectAllCallback = IO Bool

-- | No description available in the introspection data.
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

-- | No description available in the introspection data.
type TreeViewStartInteractiveSearchCallback = IO Bool

-- | No description available in the introspection data.
type TreeViewSelectCursorRowCallback = Bool -> IO Bool

-- | No description available in the introspection data.
type TreeViewSelectCursorParentCallback = IO Bool

-- | No description available in the introspection data.
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
--   treeViewRowActivated is called, when the user double clicks a
--   treeview row with the "activate-on-single-click" property set to
--   False, or when the user single clicks a row when the
--   "activate-on-single-click" property set to True. 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 tree widget conceptual
--   overview as well as TreeSelection.
type TreeViewRowActivatedCallback = TreePath -> TreeViewColumn -> IO ()

-- | The TreeView::moveCursor 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
--   g_signal_emit_by_name() if they need to control the
--   cursor programmatically. In contrast to treeViewSetCursor and
--   treeViewSetCursorOnCell when moving horizontally
--   TreeView::moveCursor does not reset the current selection.
type TreeViewMoveCursorCallback = MovementStep -> Int32 -> IO Bool

-- | No description available in the introspection data.
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 ()

-- | Connect a signal handler for the columnsChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on treeView #columnsChanged callback
--   
onTreeViewColumnsChanged :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewColumnsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the columnsChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after treeView #columnsChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewColumnsChanged :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewColumnsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cursorChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on treeView #cursorChanged callback
--   
onTreeViewCursorChanged :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewCursorChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cursorChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after treeView #cursorChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewCursorChanged :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewCursorChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the expandCollapseCursorRow
--   signal, to be run before the default handler. When overloading
--   is enabled, this is equivalent to
--   
--   
--   on treeView #expandCollapseCursorRow callback
--   
onTreeViewExpandCollapseCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewExpandCollapseCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the expandCollapseCursorRow
--   signal, to be run after the default handler. When overloading
--   is enabled, this is equivalent to
--   
--   
--   after treeView #expandCollapseCursorRow callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewExpandCollapseCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewExpandCollapseCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCursor signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on treeView #moveCursor callback
--   
onTreeViewMoveCursor :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCursor signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after treeView #moveCursor callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewMoveCursor :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the rowActivated signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on treeView #rowActivated callback
--   
onTreeViewRowActivated :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the rowActivated signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after treeView #rowActivated callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewRowActivated :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the rowCollapsed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on treeView #rowCollapsed callback
--   
onTreeViewRowCollapsed :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowCollapsedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the rowCollapsed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after treeView #rowCollapsed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewRowCollapsed :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowCollapsedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the rowExpanded signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on treeView #rowExpanded callback
--   
onTreeViewRowExpanded :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowExpandedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the rowExpanded signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after treeView #rowExpanded callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewRowExpanded :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowExpandedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectAll signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on treeView #selectAll callback
--   
onTreeViewSelectAll :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectAll signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after treeView #selectAll callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewSelectAll :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectCursorParent signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on treeView #selectCursorParent callback
--   
onTreeViewSelectCursorParent :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectCursorParentCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectCursorParent signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after treeView #selectCursorParent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewSelectCursorParent :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectCursorParentCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectCursorRow signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on treeView #selectCursorRow callback
--   
onTreeViewSelectCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectCursorRow signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after treeView #selectCursorRow callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewSelectCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the startInteractiveSearch signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on treeView #startInteractiveSearch callback
--   
onTreeViewStartInteractiveSearch :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewStartInteractiveSearchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the startInteractiveSearch signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after treeView #startInteractiveSearch callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewStartInteractiveSearch :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewStartInteractiveSearchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the testCollapseRow signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on treeView #testCollapseRow callback
--   
onTreeViewTestCollapseRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewTestCollapseRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the testCollapseRow signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after treeView #testCollapseRow callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewTestCollapseRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewTestCollapseRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the testExpandRow signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on treeView #testExpandRow callback
--   
onTreeViewTestExpandRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewTestExpandRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the testExpandRow signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after treeView #testExpandRow callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewTestExpandRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewTestExpandRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleCursorRow signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on treeView #toggleCursorRow callback
--   
onTreeViewToggleCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewToggleCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleCursorRow signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after treeView #toggleCursorRow callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewToggleCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewToggleCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unselectAll signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on treeView #unselectAll callback
--   
onTreeViewUnselectAll :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewUnselectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unselectAll signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after treeView #unselectAll callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeViewUnselectAll :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewUnselectAllCallback) -> m SignalHandlerId

-- | Get the value of the “activate-on-single-click” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get treeView #activateOnSingleClick
--   
getTreeViewActivateOnSingleClick :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “activate-on-single-click” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #activateOnSingleClick := value ]
--   
setTreeViewActivateOnSingleClick :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “activate-on-single-click” property. This is rarely needed
--   directly, but it is used by new.
constructTreeViewActivateOnSingleClick :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “enable-grid-lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #enableGridLines
--   
getTreeViewEnableGridLines :: (MonadIO m, IsTreeView o) => o -> m TreeViewGridLines

-- | Set the value of the “enable-grid-lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #enableGridLines := value ]
--   
setTreeViewEnableGridLines :: (MonadIO m, IsTreeView o) => o -> TreeViewGridLines -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “enable-grid-lines” property. This is rarely needed directly,
--   but it is used by new.
constructTreeViewEnableGridLines :: (IsTreeView o, MonadIO m) => TreeViewGridLines -> m (GValueConstruct o)

-- | Get the value of the “enable-search” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #enableSearch
--   
getTreeViewEnableSearch :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “enable-search” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #enableSearch := value ]
--   
setTreeViewEnableSearch :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “enable-search” property. This is rarely needed directly, but
--   it is used by new.
constructTreeViewEnableSearch :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “enable-tree-lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #enableTreeLines
--   
getTreeViewEnableTreeLines :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “enable-tree-lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #enableTreeLines := value ]
--   
setTreeViewEnableTreeLines :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “enable-tree-lines” property. This is rarely needed directly,
--   but it is used by new.
constructTreeViewEnableTreeLines :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “expander-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #expanderColumn
--   
getTreeViewExpanderColumn :: (MonadIO m, IsTreeView o) => o -> m TreeViewColumn

-- | Set the value of the “expander-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #expanderColumn := value ]
--   
setTreeViewExpanderColumn :: (MonadIO m, IsTreeView o, IsTreeViewColumn a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “expander-column” property. This is rarely needed directly,
--   but it is used by new.
constructTreeViewExpanderColumn :: (IsTreeView o, MonadIO m, IsTreeViewColumn a) => a -> m (GValueConstruct o)

-- | Set the value of the “expander-column” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #expanderColumn
--   
clearTreeViewExpanderColumn :: (MonadIO m, IsTreeView o) => o -> m ()

-- | Get the value of the “fixed-height-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #fixedHeightMode
--   
getTreeViewFixedHeightMode :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “fixed-height-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #fixedHeightMode := value ]
--   
setTreeViewFixedHeightMode :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “fixed-height-mode” property. This is rarely needed directly,
--   but it is used by new.
constructTreeViewFixedHeightMode :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “headers-clickable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #headersClickable
--   
getTreeViewHeadersClickable :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “headers-clickable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #headersClickable := value ]
--   
setTreeViewHeadersClickable :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “headers-clickable” property. This is rarely needed directly,
--   but it is used by new.
constructTreeViewHeadersClickable :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “headers-visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #headersVisible
--   
getTreeViewHeadersVisible :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “headers-visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #headersVisible := value ]
--   
setTreeViewHeadersVisible :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “headers-visible” property. This is rarely needed directly,
--   but it is used by new.
constructTreeViewHeadersVisible :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “hover-expand” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #hoverExpand
--   
getTreeViewHoverExpand :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “hover-expand” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #hoverExpand := value ]
--   
setTreeViewHoverExpand :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “hover-expand” property. This is rarely needed directly, but
--   it is used by new.
constructTreeViewHoverExpand :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “hover-selection” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #hoverSelection
--   
getTreeViewHoverSelection :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “hover-selection” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #hoverSelection := value ]
--   
setTreeViewHoverSelection :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “hover-selection” property. This is rarely needed directly,
--   but it is used by new.
constructTreeViewHoverSelection :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “level-indentation” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #levelIndentation
--   
getTreeViewLevelIndentation :: (MonadIO m, IsTreeView o) => o -> m Int32

-- | Set the value of the “level-indentation” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #levelIndentation := value ]
--   
setTreeViewLevelIndentation :: (MonadIO m, IsTreeView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “level-indentation” property. This is rarely needed directly,
--   but it is used by new.
constructTreeViewLevelIndentation :: (IsTreeView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #model
--   
getTreeViewModel :: (MonadIO m, IsTreeView o) => o -> m (Maybe TreeModel)

-- | Set the value of the “model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #model := value ]
--   
setTreeViewModel :: (MonadIO m, IsTreeView o, IsTreeModel a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “model” property. This is rarely needed directly, but it is
--   used by new.
constructTreeViewModel :: (IsTreeView o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “model” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #model
--   
clearTreeViewModel :: (MonadIO m, IsTreeView o) => o -> m ()

-- | Get the value of the “reorderable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #reorderable
--   
getTreeViewReorderable :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “reorderable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #reorderable := value ]
--   
setTreeViewReorderable :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “reorderable” property. This is rarely needed directly, but
--   it is used by new.
constructTreeViewReorderable :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “rubber-banding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #rubberBanding
--   
getTreeViewRubberBanding :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “rubber-banding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #rubberBanding := value ]
--   
setTreeViewRubberBanding :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “rubber-banding” property. This is rarely needed directly,
--   but it is used by new.
constructTreeViewRubberBanding :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “rules-hint” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #rulesHint
--   
getTreeViewRulesHint :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “rules-hint” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #rulesHint := value ]
--   
setTreeViewRulesHint :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “rules-hint” property. This is rarely needed directly, but it
--   is used by new.
constructTreeViewRulesHint :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “search-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #searchColumn
--   
getTreeViewSearchColumn :: (MonadIO m, IsTreeView o) => o -> m Int32

-- | Set the value of the “search-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #searchColumn := value ]
--   
setTreeViewSearchColumn :: (MonadIO m, IsTreeView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “search-column” property. This is rarely needed directly, but
--   it is used by new.
constructTreeViewSearchColumn :: (IsTreeView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “show-expanders” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #showExpanders
--   
getTreeViewShowExpanders :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “show-expanders” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #showExpanders := value ]
--   
setTreeViewShowExpanders :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-expanders” property. This is rarely needed directly,
--   but it is used by new.
constructTreeViewShowExpanders :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “tooltip-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeView #tooltipColumn
--   
getTreeViewTooltipColumn :: (MonadIO m, IsTreeView o) => o -> m Int32

-- | Set the value of the “tooltip-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #tooltipColumn := value ]
--   
setTreeViewTooltipColumn :: (MonadIO m, IsTreeView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tooltip-column” property. This is rarely needed directly,
--   but it is used by new.
constructTreeViewTooltipColumn :: (IsTreeView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Set the value of the “ubuntu-almost-fixed-height-mode”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   set treeView [ #ubuntuAlmostFixedHeightMode := value ]
--   
setTreeViewUbuntuAlmostFixedHeightMode :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “ubuntu-almost-fixed-height-mode” property. This is rarely
--   needed directly, but it is used by new.
constructTreeViewUbuntuAlmostFixedHeightMode :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new TreeView widget.
treeViewNew :: (HasCallStack, MonadIO m) => m TreeView

-- | Creates a new TreeView widget with the model initialized to
--   model.
treeViewNewWithModel :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m TreeView

-- | Appends column to the list of columns. If
--   treeView has “fixed_height” mode enabled, then
--   column 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
--   treeView.
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).
--   
--   Since: 2.12
treeViewConvertBinWindowToTreeCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Converts bin_window coordinates (see treeViewGetBinWindow) to
--   widget relative coordinates.
--   
--   Since: 2.12
treeViewConvertBinWindowToWidgetCoords :: (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.
--   
--   Since: 2.12
treeViewConvertTreeToWidgetCoords :: (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).
--   
--   Since: 2.12
treeViewConvertWidgetToTreeCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Creates a Surface representation of the row at
--   path. This image is used for a drag icon.
treeViewCreateRowDragIcon :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreePath -> m Surface

-- | Recursively expands all nodes in the treeView.
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 path. This will also expand all
--   parent rows of path as necessary.
--   
--   Since: 2.2
treeViewExpandToPath :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreePath -> m ()

-- | Gets the setting set by treeViewSetActivateOnSingleClick.
--   
--   Since: 3.8
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 path and the column specified by
--   column. If path is Nothing, or
--   points to a node not found in the tree, the y and
--   height fields of the rectangle will be filled with 0.
--   If column is Nothing, the x and
--   width fields will be filled with 0. The returned
--   rectangle is equivalent to the backgroundArea passed
--   to cellRendererRender. These background areas tile to cover the
--   entire bin window. Contrast with the cellArea,
--   returned by treeViewGetCellArea, 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

-- | Gets the TreeViewColumn at the given position in the
--   tree_view.
treeViewGetColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> m (Maybe TreeViewColumn)

-- | Returns a List of all the TreeViewColumn s currently in
--   treeView. The returned list must be freed with
--   g_list_free ().
treeViewGetColumns :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m [TreeViewColumn]

-- | Fills in path and focusColumn with the
--   current path and focus column. If the cursor isn’t currently set, then
--   *path will be Nothing. If no column currently
--   has focus, then *focusColumn will be Nothing.
--   
--   The returned TreePath must be freed with treePathFree
--   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.
--   dragX and dragY are expected to be in
--   widget coordinates. This function is only meaningful if
--   treeView is realized. Therefore this function will
--   always return False if treeView 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
--   treeView.
--   
--   Since: 2.10
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
--   treeView.
--   
--   Since: 2.6
treeViewGetFixedHeightMode :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns which grid lines are enabled in treeView.
--   
--   Since: 2.10
treeViewGetGridLines :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m TreeViewGridLines

-- | Gets the Adjustment currently being used for the horizontal
--   aspect.
treeViewGetHadjustment :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Adjustment

-- | Returns whether all header columns are clickable.
--   
--   Since: 2.10
treeViewGetHeadersClickable :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns True if the headers on the treeView are
--   visible.
treeViewGetHeadersVisible :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns whether hover expansion mode is turned on for
--   treeView.
--   
--   Since: 2.6
treeViewGetHoverExpand :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns whether hover selection mode is turned on for
--   treeView.
--   
--   Since: 2.6
treeViewGetHoverSelection :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns the amount, in pixels, of extra indentation for child levels
--   in treeView.
--   
--   Since: 2.12
treeViewGetLevelIndentation :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Int32

-- | Returns the model the TreeView is based on. Returns
--   Nothing if the model is unset.
treeViewGetModel :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Maybe TreeModel)

-- | Queries the number of columns in the given treeView.
--   
--   Since: 3.4
treeViewGetNColumns :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Word32

-- | Retrieves whether the user can reorder the tree via drag-and-drop. See
--   treeViewSetReorderable.
treeViewGetReorderable :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns whether rubber banding is turned on for
--   treeView. If the selection mode is
--   GTK_SELECTION_MULTIPLE, rubber banding will allow the
--   user to select multiple rows by dragging the mouse.
--   
--   Since: 2.10
treeViewGetRubberBanding :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Gets the setting set by treeViewSetRulesHint.
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 Entry which is currently in use as interactive
--   search entry for treeView. In case the built-in entry
--   is being used, Nothing will be returned.
--   
--   Since: 2.10
treeViewGetSearchEntry :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Entry

-- | Gets the TreeSelection associated with
--   treeView.
treeViewGetSelection :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m TreeSelection

-- | Returns whether or not expanders are drawn in
--   treeView.
--   
--   Since: 2.12
treeViewGetShowExpanders :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns the column of treeView’s model which is being
--   used for displaying tooltips on treeView’s rows.
--   
--   Since: 2.12
treeViewGetTooltipColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Int32

-- | This function is supposed to be used in a Widget::queryTooltip
--   signal handler for TreeView. The x,
--   y and keyboardTip 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 (True) or not (False) for mouse
--   tooltips. For keyboard tooltips the row returned will be the cursor
--   row. When True, then any of model,
--   path and iter which have been provided
--   will be set to point to that row and the corresponding model.
--   x and y will always be converted to be
--   relative to treeView’s bin_window if
--   keyboardTooltip is False.
--   
--   Since: 2.12
treeViewGetTooltipContext :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> Bool -> m (Bool, Int32, Int32, Maybe TreeModel, TreePath, TreeIter)

-- | Gets the Adjustment currently being used for the vertical
--   aspect.
treeViewGetVadjustment :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Adjustment

-- | Sets startPath and endPath to be the
--   first and last visible path. Note that there may be invisible paths in
--   between.
--   
--   The paths should be freed with treePathFree after use.
--   
--   Since: 2.8
treeViewGetVisibleRange :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Bool, TreePath, TreePath)

-- | Fills visibleRect with the currently-visible region of
--   the buffer, in tree coordinates. Convert to bin_window coordinates
--   with treeViewConvertTreeToBinWindowCoords. 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 column into the
--   treeView at position. If
--   position is -1, then the column is inserted at the
--   end. If treeView has “fixed_height” mode enabled, then
--   column 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
--   TreeView with the given cell renderer and a
--   TreeCellDataFunc to set cell renderer attributes (normally
--   using data from the model). See also
--   treeViewColumnSetCellDataFunc, treeViewColumnPackStart.
--   If treeView 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 (x, y) in
--   treeView 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 x and y coordinate that are
--   provided must be relative to bin_window coordinates. That is,
--   x and y must come from an event on
--   treeView where event->window ==
--   gtk_tree_view_get_bin_window ().
--   
--   For converting widget coordinates (eg. the ones you get from
--   GtkWidgetqueryTooltip), please see
--   treeViewConvertWidgetToBinWindowCoords.
--   
--   The path, column,
--   cellX and cellY arguments will be
--   filled in likewise as for treeViewGetPathAtPos. Please see
--   treeViewGetPathAtPos for more information.
--   
--   Since: 3.0
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
--   treeView.
--   
--   Since: 2.12
treeViewIsRubberBandingActive :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Moves column to be after to
--   baseColumn. If baseColumn is
--   Nothing, then column is placed in the first
--   position.
treeViewMoveColumnAfter :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsTreeViewColumn c) => a -> b -> Maybe c -> m ()

-- | Removes column from treeView.
treeViewRemoveColumn :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> b -> m Int32

-- | Returns True if the node pointed to by path is
--   expanded in treeView.
treeViewRowExpanded :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreePath -> m Bool

-- | Scrolls the tree view such that the top-left corner of the visible
--   area is treeX, treeY, where
--   treeX and treeY are specified in tree
--   coordinates. The treeView must be realized before this
--   function is called. If it isn't, you probably want to be using
--   treeViewScrollToCell.
--   
--   If either treeX or treeY are -1, then
--   that direction isn’t scrolled.
treeViewScrollToPoint :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> 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 func are: the
--   treeView, the TreeViewColumn being dragged, the
--   two TreeViewColumn s determining the drop spot, and
--   userData. If either of the TreeViewColumn
--   arguments for the drop spot are Nothing, then they indicate an
--   edge. If func is set to be Nothing, then
--   treeView reverts to the default behavior of allowing
--   all columns to be dropped everywhere.
treeViewSetColumnDragFunction :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreeViewColumnDropFunc -> 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 path
--   is Nothing, an existing highlight is removed.
treeViewSetDragDestRow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreePath -> TreeViewDropPosition -> m ()

-- | If enableSearch 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 False, 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
--   treeView. This does not have any visible effects for
--   lists.
--   
--   Since: 2.10
treeViewSetEnableTreeLines :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets the column to draw the expander arrow at. It must be in
--   treeView. If column is Nothing,
--   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 treeView.
--   Fixed height mode speeds up TreeView 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 TreeViewColumnSizingFixed.
--   
--   Since: 2.6
treeViewSetFixedHeightMode :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets which grid lines to draw in treeView.
--   
--   Since: 2.10
treeViewSetGridLines :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreeViewGridLines -> m ()

-- | Sets the Adjustment 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
--   treeView. Hover expansion makes rows expand or
--   collapse if the pointer moves over them.
--   
--   Since: 2.6
treeViewSetHoverExpand :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Enables or disables the hover selection mode of
--   treeView. Hover selection makes the selected row
--   follow the pointer. Currently, this works only for the selection modes
--   SelectionModeSingle and SelectionModeBrowse.
--   
--   Since: 2.6
treeViewSetHoverSelection :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets the model for a TreeView. If the treeView
--   already has a model set, it will remove it before setting the new
--   model. If model is Nothing, then it will unset
--   the old model.
treeViewSetModel :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeModel b) => a -> Maybe b -> 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
--   Nothing, no separators are drawn. This is the default value.
--   
--   Since: 2.6
treeViewSetRowSeparatorFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreeViewRowSeparatorFunc -> m ()

-- | Enables or disables rubber banding in treeView. If the
--   selection mode is GTK_SELECTION_MULTIPLE, rubber
--   banding will allow the user to select multiple rows by dragging the
--   mouse.
--   
--   Since: 2.10
treeViewSetRubberBanding :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets the entry which the interactive search code will use for this
--   treeView. This is useful when you want to provide a
--   search entry in our interface at all time at a fixed position. Passing
--   Nothing for entry will make the interactive
--   search code use the built-in popup entry again.
--   
--   Since: 2.10
treeViewSetSearchEntry :: (HasCallStack, MonadIO m, IsTreeView a, IsEntry b) => a -> Maybe b -> m ()

-- | Sets the function to use when positioning the search dialog.
--   
--   Since: 2.10
treeViewSetSearchPositionFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreeViewSearchPositionFunc -> m ()

-- | Sets whether to draw and enable expanders and indent child rows in
--   treeView. 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 treeViewSetLevelIndentation. This does not have any
--   visible effects for lists.
--   
--   Since: 2.12
treeViewSetShowExpanders :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets the Adjustment for the current vertical aspect.
treeViewSetVadjustment :: (HasCallStack, MonadIO m, IsTreeView a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Undoes the effect of treeViewEnableModelDragDest. Calling this
--   method sets TreeView:reorderable to False.
treeViewUnsetRowsDragDest :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ()

-- | Undoes the effect of treeViewEnableModelDragSource. Calling
--   this method sets TreeView:reorderable to False.
treeViewUnsetRowsDragSource :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ()

-- | 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 ()

-- | Connect a signal handler for the changed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on treeSelection #changed callback
--   
onTreeSelectionChanged :: (IsTreeSelection a, MonadIO m) => a -> ((?self :: a) => TreeSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after treeSelection #changed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeSelectionChanged :: (IsTreeSelection a, MonadIO m) => a -> ((?self :: a) => TreeSelectionChangedCallback) -> m SignalHandlerId

-- | Get the value of the “mode” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get treeSelection #mode
--   
getTreeSelectionMode :: (MonadIO m, IsTreeSelection o) => o -> m SelectionMode

-- | Set the value of the “mode” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set treeSelection [ #mode := value ]
--   
setTreeSelectionMode :: (MonadIO m, IsTreeSelection o) => o -> SelectionMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “mode” property. This is rarely needed directly, but it is
--   used by new.
constructTreeSelectionMode :: (IsTreeSelection o, MonadIO m) => SelectionMode -> m (GValueConstruct o)

-- | Returns the number of rows that have been selected in
--   tree.
--   
--   Since: 2.2
treeSelectionCountSelectedRows :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m Int32

-- | Gets the selection mode for selection. See
--   treeSelectionSetMode.
treeSelectionGetMode :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m SelectionMode

-- | Sets iter to the currently selected node, if
--   selection is set to SelectionModeSingle or
--   SelectionModeBrowse.
--   
--   The iter argument may be Nothing if you just
--   want to test if selection has any selected nodes.
--   
--   The model argument is filled with the current model as
--   a convenience.
--   
--   This function will not work with SelectionModeMultiple. See
--   treeSelectionGetSelectedRows instead.
treeSelectionGetSelected :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m (Bool, TreeModel, TreeIter)

-- | Returns the tree view associated with selection.
treeSelectionGetTreeView :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m TreeView

-- | Returns True if the row at iter is currently
--   selected.
treeSelectionIterIsSelected :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreeIter -> m Bool

-- | Returns True if the row pointed to by path is
--   currently selected. If path does not point to a valid
--   location, False is returned
treeSelectionPathIsSelected :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> m Bool

-- | Selects all the nodes. selection must be set to
--   GTK_SELECTION_MULTIPLE 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 path.
treeSelectionSelectPath :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> m ()

-- | Selects a range of nodes, determined by startPath and
--   endPath inclusive. selection must be
--   set to GTK_SELECTION_MULTIPLE mode.
treeSelectionSelectRange :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> TreePath -> 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 path.
treeSelectionUnselectPath :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> m ()

-- | Unselects a range of nodes, determined by startPath
--   and endPath inclusive.
--   
--   Since: 2.2
treeSelectionUnselectRange :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> TreePath -> m ()

-- | Gets emitted when the filter model has zero number of rows in
--   completion_complete method. (In other words when GtkEntryCompletion is
--   out of suggestions)
--   
--   Since: 3.14
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 iter.
--   
--   Note that model is the model that was passed to
--   entryCompletionSetModel.
--   
--   Since: 2.4
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 prefix into the entry - e.g. the
--   entry used in the FileChooser inserts only the part of the
--   prefix up to the next '/'.
--   
--   Since: 2.6
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
--   iter.
--   
--   Note that model is the model that was passed to
--   entryCompletionSetModel.
--   
--   Since: 2.12
type EntryCompletionCursorOnMatchCallback = TreeModel -> TreeIter -> IO Bool

-- | Gets emitted when an action is activated.
--   
--   Since: 2.4
type EntryCompletionActionActivatedCallback = Int32 -> IO ()

-- | Connect a signal handler for the actionActivated signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on entryCompletion #actionActivated callback
--   
onEntryCompletionActionActivated :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionActionActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the actionActivated signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after entryCompletion #actionActivated callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryCompletionActionActivated :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionActionActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cursorOnMatch signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on entryCompletion #cursorOnMatch callback
--   
onEntryCompletionCursorOnMatch :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionCursorOnMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cursorOnMatch signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after entryCompletion #cursorOnMatch callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryCompletionCursorOnMatch :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionCursorOnMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertPrefix signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on entryCompletion #insertPrefix callback
--   
onEntryCompletionInsertPrefix :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionInsertPrefixCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertPrefix signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after entryCompletion #insertPrefix callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryCompletionInsertPrefix :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionInsertPrefixCallback) -> m SignalHandlerId

-- | Connect a signal handler for the matchSelected signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on entryCompletion #matchSelected callback
--   
onEntryCompletionMatchSelected :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionMatchSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the matchSelected signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after entryCompletion #matchSelected callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryCompletionMatchSelected :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionMatchSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the noMatches signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on entryCompletion #noMatches callback
--   
onEntryCompletionNoMatches :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionNoMatchesCallback) -> m SignalHandlerId

-- | Connect a signal handler for the noMatches signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after entryCompletion #noMatches callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryCompletionNoMatches :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionNoMatchesCallback) -> m SignalHandlerId

-- | Get the value of the “cell-area” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entryCompletion #cellArea
--   
getEntryCompletionCellArea :: (MonadIO m, IsEntryCompletion o) => o -> m (Maybe CellArea)

-- | Construct a GValueConstruct with valid value for the
--   “cell-area” property. This is rarely needed directly, but it
--   is used by new.
constructEntryCompletionCellArea :: (IsEntryCompletion o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “inline-completion” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entryCompletion #inlineCompletion
--   
getEntryCompletionInlineCompletion :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “inline-completion” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entryCompletion [ #inlineCompletion := value ]
--   
setEntryCompletionInlineCompletion :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “inline-completion” property. This is rarely needed directly,
--   but it is used by new.
constructEntryCompletionInlineCompletion :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “inline-selection” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entryCompletion #inlineSelection
--   
getEntryCompletionInlineSelection :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “inline-selection” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entryCompletion [ #inlineSelection := value ]
--   
setEntryCompletionInlineSelection :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “inline-selection” property. This is rarely needed directly,
--   but it is used by new.
constructEntryCompletionInlineSelection :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “minimum-key-length” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entryCompletion #minimumKeyLength
--   
getEntryCompletionMinimumKeyLength :: (MonadIO m, IsEntryCompletion o) => o -> m Int32

-- | Set the value of the “minimum-key-length” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entryCompletion [ #minimumKeyLength := value ]
--   
setEntryCompletionMinimumKeyLength :: (MonadIO m, IsEntryCompletion o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “minimum-key-length” property. This is rarely needed
--   directly, but it is used by new.
constructEntryCompletionMinimumKeyLength :: (IsEntryCompletion o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entryCompletion #model
--   
getEntryCompletionModel :: (MonadIO m, IsEntryCompletion o) => o -> m (Maybe TreeModel)

-- | Set the value of the “model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entryCompletion [ #model := value ]
--   
setEntryCompletionModel :: (MonadIO m, IsEntryCompletion o, IsTreeModel a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “model” property. This is rarely needed directly, but it is
--   used by new.
constructEntryCompletionModel :: (IsEntryCompletion o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “model” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #model
--   
clearEntryCompletionModel :: (MonadIO m, IsEntryCompletion o) => o -> m ()

-- | Get the value of the “popup-completion” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entryCompletion #popupCompletion
--   
getEntryCompletionPopupCompletion :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “popup-completion” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entryCompletion [ #popupCompletion := value ]
--   
setEntryCompletionPopupCompletion :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “popup-completion” property. This is rarely needed directly,
--   but it is used by new.
constructEntryCompletionPopupCompletion :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “popup-set-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entryCompletion #popupSetWidth
--   
getEntryCompletionPopupSetWidth :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “popup-set-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entryCompletion [ #popupSetWidth := value ]
--   
setEntryCompletionPopupSetWidth :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “popup-set-width” property. This is rarely needed directly,
--   but it is used by new.
constructEntryCompletionPopupSetWidth :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “popup-single-match” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entryCompletion #popupSingleMatch
--   
getEntryCompletionPopupSingleMatch :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “popup-single-match” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entryCompletion [ #popupSingleMatch := value ]
--   
setEntryCompletionPopupSingleMatch :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “popup-single-match” property. This is rarely needed
--   directly, but it is used by new.
constructEntryCompletionPopupSingleMatch :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “text-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entryCompletion #textColumn
--   
getEntryCompletionTextColumn :: (MonadIO m, IsEntryCompletion o) => o -> m Int32

-- | Set the value of the “text-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entryCompletion [ #textColumn := value ]
--   
setEntryCompletionTextColumn :: (MonadIO m, IsEntryCompletion o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text-column” property. This is rarely needed directly, but
--   it is used by new.
constructEntryCompletionTextColumn :: (IsEntryCompletion o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new EntryCompletion object.
--   
--   Since: 2.4
entryCompletionNew :: (HasCallStack, MonadIO m) => m EntryCompletion

-- | Creates a new EntryCompletion object using the specified
--   area to layout cells in the underlying
--   TreeViewColumn for the drop-down menu.
--   
--   Since: 3.0
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.
--   
--   Since: 2.4
entryCompletionComplete :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m ()

-- | Computes the common prefix that is shared by all rows in
--   completion that start with key. If no
--   row matches key, Nothing will be returned. Note
--   that a text column must have been set for this function to work, see
--   entryCompletionSetTextColumn for details.
--   
--   Since: 3.4
entryCompletionComputePrefix :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Text -> m (Maybe Text)

-- | Deletes the action at index_ from
--   completion’s action list.
--   
--   Note that index_ is a relative position and the
--   position of an action may have changed since it was inserted.
--   
--   Since: 2.4
entryCompletionDeleteAction :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Int32 -> m ()

-- | Get the original text entered by the user that triggered the
--   completion or Nothing if there’s no completion ongoing.
--   
--   Since: 2.12
entryCompletionGetCompletionPrefix :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Text

-- | Gets the entry completion has been attached to.
--   
--   Since: 2.4
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.
--   
--   Since: 2.6
entryCompletionGetInlineCompletion :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Bool

-- | Returns True if inline-selection mode is turned on.
--   
--   Since: 2.12
entryCompletionGetInlineSelection :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Bool

-- | Returns the minimum key length as set for completion.
--   
--   Since: 2.4
entryCompletionGetMinimumKeyLength :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Int32

-- | Returns the model the EntryCompletion is using as data source.
--   Returns Nothing if the model is unset.
--   
--   Since: 2.4
entryCompletionGetModel :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m (Maybe TreeModel)

-- | Returns whether the completions should be presented in a popup window.
--   
--   Since: 2.6
entryCompletionGetPopupCompletion :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Bool

-- | Returns whether the completion popup window will be resized to the
--   width of the entry.
--   
--   Since: 2.8
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.
--   
--   Since: 2.8
entryCompletionGetPopupSingleMatch :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Bool

-- | Returns the column in the model of completion to get
--   strings from.
--   
--   Since: 2.6
entryCompletionGetTextColumn :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Int32

-- | Inserts an action in completion’s action item list at
--   position index_ with text text. If you
--   want the action item to have markup, use
--   entryCompletionInsertActionMarkup.
--   
--   Note that index_ is a relative position in the list of
--   actions and the position of an action can change when deleting a
--   different action.
--   
--   Since: 2.4
entryCompletionInsertActionText :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Int32 -> Text -> m ()

-- | Requests a prefix insertion.
--   
--   Since: 2.6
entryCompletionInsertPrefix :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m ()

-- | Sets whether the common prefix of the possible completions should be
--   automatically inserted in the entry.
--   
--   Since: 2.6
entryCompletionSetInlineCompletion :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Bool -> m ()

-- | Sets whether it is possible to cycle through the possible completions
--   inside the entry.
--   
--   Since: 2.12
entryCompletionSetInlineSelection :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Bool -> m ()

-- | Requires the length of the search key for completion
--   to be at least length. 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).
--   
--   Since: 2.4
entryCompletionSetMinimumKeyLength :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Int32 -> m ()

-- | Sets whether the completions should be presented in a popup window.
--   
--   Since: 2.6
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.
--   
--   Since: 2.8
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 False if you
--   are using [inline completion][GtkEntryCompletion--inline-completion].
--   
--   Since: 2.8
entryCompletionSetPopupSingleMatch :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Bool -> m ()

-- | The toggleOverwrite 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 ()

-- | No description available in the introspection data.
type EntryToggleDirectionCallback = 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.
--   
--   Since: 2.20
type EntryPreeditChangedCallback = Text -> IO ()

-- | The populatePopup 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 widget, which will be a
--   Menu in this case.
--   
--   If Entry:populateAll is True, this signal will also be
--   emitted to populate touch popups. In this case, widget
--   will be a different container, e.g. a Toolbar. The signal
--   handler should not make assumptions about the type of
--   widget.
type EntryPopulatePopupCallback = Widget -> IO ()

-- | The pasteClipboard 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 moveCursor signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates a
--   cursor movement. If the cursor is not visible in
--   entry, this signal causes the viewport to be moved
--   instead.
--   
--   Applications should not connect to it, but may emit it with
--   g_signal_emit_by_name() 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. * Arrow keys move by individual characters/lines *
--   Ctrl-arrow key combinations move by words/paragraphs * Home/End keys
--   move to the ends of the buffer
type EntryMoveCursorCallback = MovementStep -> Int32 -> Bool -> IO ()

-- | The insertEmoji signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to present the Emoji
--   chooser for the entry.
--   
--   The default bindings for this signal are Ctrl-. and Ctrl-;
--   
--   Since: 3.22.27
type EntryInsertEmojiCallback = IO ()

-- | The insertAtCursor 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 iconRelease signal is emitted on the button release from a
--   mouse click over an activatable icon.
--   
--   Since: 2.16
type EntryIconReleaseCallback = EntryIconPosition -> Event -> IO ()

-- | The iconPress signal is emitted when an activatable icon is
--   clicked.
--   
--   Since: 2.16
type EntryIconPressCallback = EntryIconPosition -> Event -> IO ()

-- | The deleteFromCursor signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates a
--   text deletion.
--   
--   If the type is DeleteTypeChars, 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 cutClipboard 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 copyClipboard 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 backspace 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 activate 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 ()

-- | Connect a signal handler for the activate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on entry #activate callback
--   
onEntryActivate :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after entry #activate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryActivate :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the backspace signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on entry #backspace callback
--   
onEntryBackspace :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryBackspaceCallback) -> m SignalHandlerId

-- | Connect a signal handler for the backspace signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after entry #backspace callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryBackspace :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryBackspaceCallback) -> m SignalHandlerId

-- | Connect a signal handler for the copyClipboard signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on entry #copyClipboard callback
--   
onEntryCopyClipboard :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the copyClipboard signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after entry #copyClipboard callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryCopyClipboard :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cutClipboard signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on entry #cutClipboard callback
--   
onEntryCutClipboard :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryCutClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cutClipboard signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after entry #cutClipboard callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryCutClipboard :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryCutClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deleteFromCursor signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on entry #deleteFromCursor callback
--   
onEntryDeleteFromCursor :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryDeleteFromCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deleteFromCursor signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after entry #deleteFromCursor callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryDeleteFromCursor :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryDeleteFromCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the iconPress signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on entry #iconPress callback
--   
onEntryIconPress :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryIconPressCallback) -> m SignalHandlerId

-- | Connect a signal handler for the iconPress signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after entry #iconPress callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryIconPress :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryIconPressCallback) -> m SignalHandlerId

-- | Connect a signal handler for the iconRelease signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on entry #iconRelease callback
--   
onEntryIconRelease :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryIconReleaseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the iconRelease signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after entry #iconRelease callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryIconRelease :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryIconReleaseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertAtCursor signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on entry #insertAtCursor callback
--   
onEntryInsertAtCursor :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryInsertAtCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertAtCursor signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after entry #insertAtCursor callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryInsertAtCursor :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryInsertAtCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertEmoji signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on entry #insertEmoji callback
--   
onEntryInsertEmoji :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryInsertEmojiCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertEmoji signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after entry #insertEmoji callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryInsertEmoji :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryInsertEmojiCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCursor signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on entry #moveCursor callback
--   
onEntryMoveCursor :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCursor signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after entry #moveCursor callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryMoveCursor :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pasteClipboard signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on entry #pasteClipboard callback
--   
onEntryPasteClipboard :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryPasteClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pasteClipboard signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after entry #pasteClipboard callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryPasteClipboard :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryPasteClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the populatePopup signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on entry #populatePopup callback
--   
onEntryPopulatePopup :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the populatePopup signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after entry #populatePopup callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryPopulatePopup :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preeditChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on entry #preeditChanged callback
--   
onEntryPreeditChanged :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preeditChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after entry #preeditChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryPreeditChanged :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleDirection signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on entry #toggleDirection callback
--   
onEntryToggleDirection :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryToggleDirectionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleDirection signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after entry #toggleDirection callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryToggleDirection :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryToggleDirectionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleOverwrite signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on entry #toggleOverwrite callback
--   
onEntryToggleOverwrite :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryToggleOverwriteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleOverwrite signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after entry #toggleOverwrite callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEntryToggleOverwrite :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryToggleOverwriteCallback) -> m SignalHandlerId

-- | Get the value of the “activates-default” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #activatesDefault
--   
getEntryActivatesDefault :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “activates-default” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #activatesDefault := value ]
--   
setEntryActivatesDefault :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “activates-default” property. This is rarely needed directly,
--   but it is used by new.
constructEntryActivatesDefault :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “attributes” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #attributes
--   
getEntryAttributes :: (MonadIO m, IsEntry o) => o -> m (Maybe AttrList)

-- | Set the value of the “attributes” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #attributes := value ]
--   
setEntryAttributes :: (MonadIO m, IsEntry o) => o -> AttrList -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “attributes” property. This is rarely needed directly, but it
--   is used by new.
constructEntryAttributes :: (IsEntry o, MonadIO m) => AttrList -> m (GValueConstruct o)

-- | Get the value of the “buffer” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #buffer
--   
getEntryBuffer :: (MonadIO m, IsEntry o) => o -> m EntryBuffer

-- | Set the value of the “buffer” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #buffer := value ]
--   
setEntryBuffer :: (MonadIO m, IsEntry o, IsEntryBuffer a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “buffer” property. This is rarely needed directly, but it is
--   used by new.
constructEntryBuffer :: (IsEntry o, MonadIO m, IsEntryBuffer a) => a -> m (GValueConstruct o)

-- | Get the value of the “caps-lock-warning” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #capsLockWarning
--   
getEntryCapsLockWarning :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “caps-lock-warning” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #capsLockWarning := value ]
--   
setEntryCapsLockWarning :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “caps-lock-warning” property. This is rarely needed directly,
--   but it is used by new.
constructEntryCapsLockWarning :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “completion” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #completion
--   
getEntryCompletion :: (MonadIO m, IsEntry o) => o -> m EntryCompletion

-- | Set the value of the “completion” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #completion := value ]
--   
setEntryCompletion :: (MonadIO m, IsEntry o, IsEntryCompletion a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “completion” property. This is rarely needed directly, but it
--   is used by new.
constructEntryCompletion :: (IsEntry o, MonadIO m, IsEntryCompletion a) => a -> m (GValueConstruct o)

-- | Set the value of the “completion” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #completion
--   
clearEntryCompletion :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “cursor-position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #cursorPosition
--   
getEntryCursorPosition :: (MonadIO m, IsEntry o) => o -> m Int32

-- | Get the value of the “editable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #editable
--   
getEntryEditable :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “editable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #editable := value ]
--   
setEntryEditable :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “editable” property. This is rarely needed directly, but it
--   is used by new.
constructEntryEditable :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “enable-emoji-completion” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #enableEmojiCompletion
--   
getEntryEnableEmojiCompletion :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “enable-emoji-completion” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #enableEmojiCompletion := value ]
--   
setEntryEnableEmojiCompletion :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “enable-emoji-completion” property. This is rarely needed
--   directly, but it is used by new.
constructEntryEnableEmojiCompletion :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “has-frame” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #hasFrame
--   
getEntryHasFrame :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “has-frame” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #hasFrame := value ]
--   
setEntryHasFrame :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-frame” property. This is rarely needed directly, but it
--   is used by new.
constructEntryHasFrame :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “im-module” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #imModule
--   
getEntryImModule :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “im-module” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #imModule := value ]
--   
setEntryImModule :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “im-module” property. This is rarely needed directly, but it
--   is used by new.
constructEntryImModule :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “im-module” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #imModule
--   
clearEntryImModule :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “inner-border” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #innerBorder
--   
getEntryInnerBorder :: (MonadIO m, IsEntry o) => o -> m (Maybe Border)

-- | Set the value of the “inner-border” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #innerBorder := value ]
--   
setEntryInnerBorder :: (MonadIO m, IsEntry o) => o -> Border -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “inner-border” property. This is rarely needed directly, but
--   it is used by new.
constructEntryInnerBorder :: (IsEntry o, MonadIO m) => Border -> m (GValueConstruct o)

-- | Set the value of the “inner-border” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #innerBorder
--   
clearEntryInnerBorder :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “input-hints” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #inputHints
--   
getEntryInputHints :: (MonadIO m, IsEntry o) => o -> m [InputHints]

-- | Set the value of the “input-hints” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #inputHints := value ]
--   
setEntryInputHints :: (MonadIO m, IsEntry o) => o -> [InputHints] -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “input-hints” property. This is rarely needed directly, but
--   it is used by new.
constructEntryInputHints :: (IsEntry o, MonadIO m) => [InputHints] -> m (GValueConstruct o)

-- | Get the value of the “input-purpose” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #inputPurpose
--   
getEntryInputPurpose :: (MonadIO m, IsEntry o) => o -> m InputPurpose

-- | Set the value of the “input-purpose” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #inputPurpose := value ]
--   
setEntryInputPurpose :: (MonadIO m, IsEntry o) => o -> InputPurpose -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “input-purpose” property. This is rarely needed directly, but
--   it is used by new.
constructEntryInputPurpose :: (IsEntry o, MonadIO m) => InputPurpose -> m (GValueConstruct o)

-- | Get the value of the “invisible-char” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #invisibleChar
--   
getEntryInvisibleChar :: (MonadIO m, IsEntry o) => o -> m Word32

-- | Set the value of the “invisible-char” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #invisibleChar := value ]
--   
setEntryInvisibleChar :: (MonadIO m, IsEntry o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “invisible-char” property. This is rarely needed directly,
--   but it is used by new.
constructEntryInvisibleChar :: (IsEntry o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “invisible-char-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #invisibleCharSet
--   
getEntryInvisibleCharSet :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “invisible-char-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #invisibleCharSet := value ]
--   
setEntryInvisibleCharSet :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “invisible-char-set” property. This is rarely needed
--   directly, but it is used by new.
constructEntryInvisibleCharSet :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “max-length” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #maxLength
--   
getEntryMaxLength :: (MonadIO m, IsEntry o) => o -> m Int32

-- | Set the value of the “max-length” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #maxLength := value ]
--   
setEntryMaxLength :: (MonadIO m, IsEntry o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “max-length” property. This is rarely needed directly, but it
--   is used by new.
constructEntryMaxLength :: (IsEntry o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “max-width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #maxWidthChars
--   
getEntryMaxWidthChars :: (MonadIO m, IsEntry o) => o -> m Int32

-- | Set the value of the “max-width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #maxWidthChars := value ]
--   
setEntryMaxWidthChars :: (MonadIO m, IsEntry o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “max-width-chars” property. This is rarely needed directly,
--   but it is used by new.
constructEntryMaxWidthChars :: (IsEntry o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “overwrite-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #overwriteMode
--   
getEntryOverwriteMode :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “overwrite-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #overwriteMode := value ]
--   
setEntryOverwriteMode :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “overwrite-mode” property. This is rarely needed directly,
--   but it is used by new.
constructEntryOverwriteMode :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “placeholder-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #placeholderText
--   
getEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> m Text

-- | Set the value of the “placeholder-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #placeholderText := value ]
--   
setEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “placeholder-text” property. This is rarely needed directly,
--   but it is used by new.
constructEntryPlaceholderText :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “placeholder-text” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #placeholderText
--   
clearEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “populate-all” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #populateAll
--   
getEntryPopulateAll :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “populate-all” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #populateAll := value ]
--   
setEntryPopulateAll :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “populate-all” property. This is rarely needed directly, but
--   it is used by new.
constructEntryPopulateAll :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “primary-icon-activatable” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get entry #primaryIconActivatable
--   
getEntryPrimaryIconActivatable :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “primary-icon-activatable” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #primaryIconActivatable := value ]
--   
setEntryPrimaryIconActivatable :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “primary-icon-activatable” property. This is rarely needed
--   directly, but it is used by new.
constructEntryPrimaryIconActivatable :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “primary-icon-gicon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #primaryIconGicon
--   
getEntryPrimaryIconGicon :: (MonadIO m, IsEntry o) => o -> m (Maybe Icon)

-- | Set the value of the “primary-icon-gicon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #primaryIconGicon := value ]
--   
setEntryPrimaryIconGicon :: (MonadIO m, IsEntry o, IsIcon a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “primary-icon-gicon” property. This is rarely needed
--   directly, but it is used by new.
constructEntryPrimaryIconGicon :: (IsEntry o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “primary-icon-gicon” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #primaryIconGicon
--   
clearEntryPrimaryIconGicon :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “primary-icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #primaryIconName
--   
getEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “primary-icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #primaryIconName := value ]
--   
setEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “primary-icon-name” property. This is rarely needed directly,
--   but it is used by new.
constructEntryPrimaryIconName :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “primary-icon-name” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #primaryIconName
--   
clearEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “primary-icon-pixbuf” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #primaryIconPixbuf
--   
getEntryPrimaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “primary-icon-pixbuf” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #primaryIconPixbuf := value ]
--   
setEntryPrimaryIconPixbuf :: (MonadIO m, IsEntry o, IsPixbuf a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “primary-icon-pixbuf” property. This is rarely needed
--   directly, but it is used by new.
constructEntryPrimaryIconPixbuf :: (IsEntry o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “primary-icon-pixbuf” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #primaryIconPixbuf
--   
clearEntryPrimaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “primary-icon-sensitive” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #primaryIconSensitive
--   
getEntryPrimaryIconSensitive :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “primary-icon-sensitive” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #primaryIconSensitive := value ]
--   
setEntryPrimaryIconSensitive :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “primary-icon-sensitive” property. This is rarely needed
--   directly, but it is used by new.
constructEntryPrimaryIconSensitive :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “primary-icon-stock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #primaryIconStock
--   
getEntryPrimaryIconStock :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “primary-icon-stock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #primaryIconStock := value ]
--   
setEntryPrimaryIconStock :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “primary-icon-stock” property. This is rarely needed
--   directly, but it is used by new.
constructEntryPrimaryIconStock :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “primary-icon-stock” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #primaryIconStock
--   
clearEntryPrimaryIconStock :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “primary-icon-storage-type” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get entry #primaryIconStorageType
--   
getEntryPrimaryIconStorageType :: (MonadIO m, IsEntry o) => o -> m ImageType

-- | Get the value of the “primary-icon-tooltip-markup” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get entry #primaryIconTooltipMarkup
--   
getEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “primary-icon-tooltip-markup” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #primaryIconTooltipMarkup := value ]
--   
setEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “primary-icon-tooltip-markup” property. This is rarely needed
--   directly, but it is used by new.
constructEntryPrimaryIconTooltipMarkup :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “primary-icon-tooltip-markup” property
--   to Nothing. When overloading is enabled, this is
--   equivalent to
--   
--   
--   clear #primaryIconTooltipMarkup
--   
clearEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “primary-icon-tooltip-text” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get entry #primaryIconTooltipText
--   
getEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “primary-icon-tooltip-text” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #primaryIconTooltipText := value ]
--   
setEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “primary-icon-tooltip-text” property. This is rarely needed
--   directly, but it is used by new.
constructEntryPrimaryIconTooltipText :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “primary-icon-tooltip-text” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #primaryIconTooltipText
--   
clearEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “progress-fraction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #progressFraction
--   
getEntryProgressFraction :: (MonadIO m, IsEntry o) => o -> m Double

-- | Set the value of the “progress-fraction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #progressFraction := value ]
--   
setEntryProgressFraction :: (MonadIO m, IsEntry o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “progress-fraction” property. This is rarely needed directly,
--   but it is used by new.
constructEntryProgressFraction :: (IsEntry o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “progress-pulse-step” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #progressPulseStep
--   
getEntryProgressPulseStep :: (MonadIO m, IsEntry o) => o -> m Double

-- | Set the value of the “progress-pulse-step” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #progressPulseStep := value ]
--   
setEntryProgressPulseStep :: (MonadIO m, IsEntry o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “progress-pulse-step” property. This is rarely needed
--   directly, but it is used by new.
constructEntryProgressPulseStep :: (IsEntry o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “scroll-offset” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #scrollOffset
--   
getEntryScrollOffset :: (MonadIO m, IsEntry o) => o -> m Int32

-- | Get the value of the “secondary-icon-activatable” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get entry #secondaryIconActivatable
--   
getEntrySecondaryIconActivatable :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “secondary-icon-activatable” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #secondaryIconActivatable := value ]
--   
setEntrySecondaryIconActivatable :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “secondary-icon-activatable” property. This is rarely needed
--   directly, but it is used by new.
constructEntrySecondaryIconActivatable :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “secondary-icon-gicon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #secondaryIconGicon
--   
getEntrySecondaryIconGicon :: (MonadIO m, IsEntry o) => o -> m (Maybe Icon)

-- | Set the value of the “secondary-icon-gicon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #secondaryIconGicon := value ]
--   
setEntrySecondaryIconGicon :: (MonadIO m, IsEntry o, IsIcon a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “secondary-icon-gicon” property. This is rarely needed
--   directly, but it is used by new.
constructEntrySecondaryIconGicon :: (IsEntry o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “secondary-icon-gicon” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #secondaryIconGicon
--   
clearEntrySecondaryIconGicon :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “secondary-icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #secondaryIconName
--   
getEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “secondary-icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #secondaryIconName := value ]
--   
setEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “secondary-icon-name” property. This is rarely needed
--   directly, but it is used by new.
constructEntrySecondaryIconName :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “secondary-icon-name” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #secondaryIconName
--   
clearEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “secondary-icon-pixbuf” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #secondaryIconPixbuf
--   
getEntrySecondaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “secondary-icon-pixbuf” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #secondaryIconPixbuf := value ]
--   
setEntrySecondaryIconPixbuf :: (MonadIO m, IsEntry o, IsPixbuf a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “secondary-icon-pixbuf” property. This is rarely needed
--   directly, but it is used by new.
constructEntrySecondaryIconPixbuf :: (IsEntry o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “secondary-icon-pixbuf” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #secondaryIconPixbuf
--   
clearEntrySecondaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “secondary-icon-sensitive” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get entry #secondaryIconSensitive
--   
getEntrySecondaryIconSensitive :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “secondary-icon-sensitive” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #secondaryIconSensitive := value ]
--   
setEntrySecondaryIconSensitive :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “secondary-icon-sensitive” property. This is rarely needed
--   directly, but it is used by new.
constructEntrySecondaryIconSensitive :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “secondary-icon-stock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #secondaryIconStock
--   
getEntrySecondaryIconStock :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “secondary-icon-stock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #secondaryIconStock := value ]
--   
setEntrySecondaryIconStock :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “secondary-icon-stock” property. This is rarely needed
--   directly, but it is used by new.
constructEntrySecondaryIconStock :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “secondary-icon-stock” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #secondaryIconStock
--   
clearEntrySecondaryIconStock :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “secondary-icon-storage-type” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get entry #secondaryIconStorageType
--   
getEntrySecondaryIconStorageType :: (MonadIO m, IsEntry o) => o -> m ImageType

-- | Get the value of the “secondary-icon-tooltip-markup”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   get entry #secondaryIconTooltipMarkup
--   
getEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “secondary-icon-tooltip-markup”
--   property. When overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #secondaryIconTooltipMarkup := value ]
--   
setEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “secondary-icon-tooltip-markup” property. This is rarely
--   needed directly, but it is used by new.
constructEntrySecondaryIconTooltipMarkup :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “secondary-icon-tooltip-markup” property
--   to Nothing. When overloading is enabled, this is
--   equivalent to
--   
--   
--   clear #secondaryIconTooltipMarkup
--   
clearEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “secondary-icon-tooltip-text” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get entry #secondaryIconTooltipText
--   
getEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “secondary-icon-tooltip-text” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #secondaryIconTooltipText := value ]
--   
setEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “secondary-icon-tooltip-text” property. This is rarely needed
--   directly, but it is used by new.
constructEntrySecondaryIconTooltipText :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “secondary-icon-tooltip-text” property
--   to Nothing. When overloading is enabled, this is
--   equivalent to
--   
--   
--   clear #secondaryIconTooltipText
--   
clearEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “selection-bound” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #selectionBound
--   
getEntrySelectionBound :: (MonadIO m, IsEntry o) => o -> m Int32

-- | Get the value of the “shadow-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #shadowType
--   
getEntryShadowType :: (MonadIO m, IsEntry o) => o -> m ShadowType

-- | Set the value of the “shadow-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #shadowType := value ]
--   
setEntryShadowType :: (MonadIO m, IsEntry o) => o -> ShadowType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “shadow-type” property. This is rarely needed directly, but
--   it is used by new.
constructEntryShadowType :: (IsEntry o, MonadIO m) => ShadowType -> m (GValueConstruct o)

-- | Get the value of the “show-emoji-icon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #showEmojiIcon
--   
getEntryShowEmojiIcon :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “show-emoji-icon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #showEmojiIcon := value ]
--   
setEntryShowEmojiIcon :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-emoji-icon” property. This is rarely needed directly,
--   but it is used by new.
constructEntryShowEmojiIcon :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “tabs” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get entry #tabs
--   
getEntryTabs :: (MonadIO m, IsEntry o) => o -> m (Maybe TabArray)

-- | Set the value of the “tabs” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set entry [ #tabs := value ]
--   
setEntryTabs :: (MonadIO m, IsEntry o) => o -> TabArray -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tabs” property. This is rarely needed directly, but it is
--   used by new.
constructEntryTabs :: (IsEntry o, MonadIO m) => TabArray -> m (GValueConstruct o)

-- | Get the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get entry #text
--   
getEntryText :: (MonadIO m, IsEntry o) => o -> m Text

-- | Set the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set entry [ #text := value ]
--   
setEntryText :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text” property. This is rarely needed directly, but it is
--   used by new.
constructEntryText :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “text-length” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #textLength
--   
getEntryTextLength :: (MonadIO m, IsEntry o) => o -> m Word32

-- | Get the value of the “truncate-multiline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #truncateMultiline
--   
getEntryTruncateMultiline :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “truncate-multiline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #truncateMultiline := value ]
--   
setEntryTruncateMultiline :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “truncate-multiline” property. This is rarely needed
--   directly, but it is used by new.
constructEntryTruncateMultiline :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “visibility” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #visibility
--   
getEntryVisibility :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “visibility” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #visibility := value ]
--   
setEntryVisibility :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visibility” property. This is rarely needed directly, but it
--   is used by new.
constructEntryVisibility :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #widthChars
--   
getEntryWidthChars :: (MonadIO m, IsEntry o) => o -> m Int32

-- | Set the value of the “width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #widthChars := value ]
--   
setEntryWidthChars :: (MonadIO m, IsEntry o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “width-chars” property. This is rarely needed directly, but
--   it is used by new.
constructEntryWidthChars :: (IsEntry o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get entry #xalign
--   
getEntryXalign :: (MonadIO m, IsEntry o) => o -> m Float

-- | Set the value of the “xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set entry [ #xalign := value ]
--   
setEntryXalign :: (MonadIO m, IsEntry o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “xalign” property. This is rarely needed directly, but it is
--   used by new.
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.
--   
--   Since: 2.18
entryNewWithBuffer :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m Entry

-- | Retrieves the value set by entrySetActivatesDefault.
entryGetActivatesDefault :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool

-- | Gets the value set by entrySetAlignment.
--   
--   Since: 2.4
entryGetAlignment :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Float

-- | Gets the attribute list that was set on the entry using
--   entrySetAttributes, if any.
--   
--   Since: 3.6
entryGetAttributes :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe AttrList)

-- | Get the EntryBuffer object which holds the text for this
--   widget.
--   
--   Since: 2.18
entryGetBuffer :: (HasCallStack, MonadIO m, IsEntry a) => a -> m EntryBuffer

-- | Returns the auxiliary completion object currently in use by
--   entry.
--   
--   Since: 2.4
entryGetCompletion :: (HasCallStack, MonadIO m, IsEntry a) => a -> m EntryCompletion

-- | Retrieves the horizontal cursor adjustment for the entry. See
--   entrySetCursorHadjustment.
--   
--   Since: 2.12
entryGetCursorHadjustment :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe Adjustment)

-- | Gets the value set by entrySetHasFrame.
entryGetHasFrame :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool

-- | Returns whether the icon is activatable.
--   
--   Since: 2.16
entryGetIconActivatable :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Bool

-- | Finds the icon at the given position and return its index. The
--   position’s coordinates are relative to the entry’s top
--   left corner. If x, y doesn’t lie
--   inside an icon, -1 is returned. This function is intended for use in a
--   Widget::queryTooltip signal handler.
--   
--   Since: 2.16
entryGetIconAtPos :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> Int32 -> m Int32

-- | Retrieves the Icon used for the icon, or Nothing if
--   there is no icon or if the icon was set by some other method (e.g., by
--   stock, pixbuf, or icon name).
--   
--   Since: 2.16
entryGetIconGicon :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Icon)

-- | Retrieves the icon name used for the icon, or Nothing if there
--   is no icon or if the icon was set by some other method (e.g., by
--   pixbuf, stock or gicon).
--   
--   Since: 2.16
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
--   Pixbuf, a Icon, a stock item, or an icon name.
--   
--   Since: 2.16
entryGetIconPixbuf :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Pixbuf)

-- | Returns whether the icon appears sensitive or insensitive.
--   
--   Since: 2.16
entryGetIconSensitive :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Bool

-- | Retrieves the stock id used for the icon, or Nothing if there
--   is no icon or if the icon was set by some other method (e.g., by
--   pixbuf, icon name or gicon).
--   
--   Since: 2.16
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
--   ImageTypeEmpty.
--   
--   Since: 2.16
entryGetIconStorageType :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m ImageType

-- | Gets the contents of the tooltip on the icon at the specified position
--   in entry.
--   
--   Since: 2.16
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 entry.
--   
--   Since: 2.16
entryGetIconTooltipText :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Text)

-- | This function returns the entry’s Entry:innerBorder property.
--   See entrySetInnerBorder for more information.
--   
--   Since: 2.10
entryGetInnerBorder :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe Border)

-- | Gets the value of the Entry:inputHints property.
--   
--   Since: 3.6
entryGetInputHints :: (HasCallStack, MonadIO m, IsEntry a) => a -> m [InputHints]

-- | Gets the value of the Entry:inputPurpose property.
--   
--   Since: 3.6
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
--   entrySetInvisibleChar.
entryGetInvisibleChar :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Char

-- | Retrieves the maximum allowed length of the text in
--   entry. See entrySetMaxLength.
--   
--   This is equivalent to getting entry's
--   EntryBuffer and calling entryBufferGetMaxLength on it.
entryGetMaxLength :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Int32

-- | Retrieves the desired maximum width of entry, in
--   characters. See entrySetMaxWidthChars.
--   
--   Since: 3.12
entryGetMaxWidthChars :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Int32

-- | Gets the value set by entrySetOverwriteMode.
--   
--   Since: 2.14
entryGetOverwriteMode :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool

-- | Retrieves the text that will be displayed when entry
--   is empty and unfocused
--   
--   Since: 3.2
entryGetPlaceholderText :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Text

-- | Returns the current fraction of the task that’s been completed. See
--   entrySetProgressFraction.
--   
--   Since: 2.16
entryGetProgressFraction :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Double

-- | Retrieves the pulse step set with entrySetProgressPulseStep.
--   
--   Since: 2.16
entryGetProgressPulseStep :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Double

-- | Gets the tabstops that were set on the entry using
--   entrySetTabs, if any.
--   
--   Since: 3.10
entryGetTabs :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe TabArray)

-- | Retrieves the current length of the text in entry.
--   
--   This is equivalent to getting entry's
--   EntryBuffer and calling entryBufferGetLength on it.
--   
--   Since: 2.14
entryGetTextLength :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Word16

-- | Retrieves whether the text in entry is visible. See
--   entrySetVisibility.
entryGetVisibility :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool

-- | Gets the value set by entrySetWidthChars.
entryGetWidthChars :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Int32

-- | Causes entry to have keyboard focus.
--   
--   It behaves like widgetGrabFocus, 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.
--   
--   Since: 3.16
entryGrabFocusWithoutSelecting :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()

-- | Allow the Entry input method to internally handle key press and
--   release events. If this function returns True, then no further
--   processing should be done for this key event. See
--   iMContextFilterKeypress.
--   
--   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 Entry. See
--   textViewResetImContext for an example of use.
--   
--   Since: 2.22
entryImContextFilterKeypress :: (HasCallStack, MonadIO m, IsEntry a) => a -> EventKey -> m Bool

-- | 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.
--   
--   Since: 2.22
entryResetImContext :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()

-- | Set the EntryBuffer object which holds the text for this
--   widget.
--   
--   Since: 2.18
entrySetBuffer :: (HasCallStack, MonadIO m, IsEntry a, IsEntryBuffer b) => a -> b -> m ()

-- | Sets completion to be the auxiliary completion object
--   to use with entry. All further configuration of the
--   completion mechanism is done on completion using the
--   EntryCompletion API. Completion is disabled if
--   completion is set to Nothing.
--   
--   Since: 2.4
entrySetCompletion :: (HasCallStack, MonadIO m, IsEntry a, IsEntryCompletion b) => a -> Maybe b -> m ()

-- | Sets whether the icon is activatable.
--   
--   Since: 2.16
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
--   Widget::dragDataGet (or possibly Widget::dragDataDelete)
--   signal, and use entryGetCurrentIconDragSource 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
--   Widget::dragBegin signal to set a different icon. Note that you
--   have to use g_signal_connect_after() to ensure that
--   your signal handler gets executed after the default handler.
--   
--   Since: 2.16
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 icon is Nothing, no icon will be shown in
--   the specified position.
--   
--   Since: 2.16
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 iconName is Nothing, no icon will be shown
--   in the specified position.
--   
--   Since: 2.16
entrySetIconFromIconName :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

-- | Sets the icon shown in the specified position using a pixbuf.
--   
--   If pixbuf is Nothing, no icon will be shown in
--   the specified position.
--   
--   Since: 2.16
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 stockId is Nothing, no icon will be shown in
--   the specified position.
--   
--   Since: 2.16
entrySetIconFromStock :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

-- | Sets the sensitivity for the specified icon.
--   
--   Since: 2.16
entrySetIconSensitive :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Bool -> m ()

-- | Sets the Entry:inputHints property, which allows input methods
--   to fine-tune their behaviour.
--   
--   Since: 3.6
entrySetInputHints :: (HasCallStack, MonadIO m, IsEntry a) => a -> [InputHints] -> m ()

-- | Sets the Entry:inputPurpose property which can be used by
--   on-screen keyboards and other input methods to adjust their behaviour.
--   
--   Since: 3.6
entrySetInputPurpose :: (HasCallStack, MonadIO m, IsEntry a) => a -> InputPurpose -> m ()

-- | Sets text to be displayed in entry when it is empty
--   and unfocused. This can be used to give a visual hint of the expected
--   contents of the Entry.
--   
--   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.
--   
--   Since: 3.2
entrySetPlaceholderText :: (HasCallStack, MonadIO m, IsEntry a) => a -> Maybe Text -> m ()

-- | Sets the text in the widget to the given value, replacing the current
--   contents.
--   
--   See entryBufferSetText.
entrySetText :: (HasCallStack, MonadIO m, IsEntry a) => a -> Text -> m ()

-- | Unsets the invisible char previously set with
--   entrySetInvisibleChar. So that the default invisible char is
--   used again.
--   
--   Since: 2.16
entryUnsetInvisibleChar :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()

-- | This signal is emitted when a selection has been completed within a
--   menu shell.
type MenuShellSelectionDoneCallback = IO ()

-- | The moveSelected signal is emitted to move the selection to
--   another item.
--   
--   Since: 2.12
type MenuShellMoveSelectedCallback = Int32 -> IO Bool

-- | An keybinding signal which moves the current menu item in the
--   direction specified by direction.
type MenuShellMoveCurrentCallback = MenuDirectionType -> IO ()

-- | The insert signal is emitted when a new MenuItem is
--   added to a MenuShell. A separate signal is used instead of
--   GtkContaineradd because of the need for an additional position
--   parameter.
--   
--   The inverse of this signal is the GtkContainerremoved signal.
--   
--   Since: 3.2
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
--   direction.
type MenuShellCycleFocusCallback = DirectionType -> IO ()

-- | An action signal which cancels the selection within the menu shell.
--   Causes the MenuShell::selectionDone signal to be emitted.
type MenuShellCancelCallback = IO ()

-- | An action signal that activates the current menu item within the menu
--   shell.
type MenuShellActivateCurrentCallback = Bool -> IO ()

-- | Connect a signal handler for the activateCurrent signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on menuShell #activateCurrent callback
--   
onMenuShellActivateCurrent :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellActivateCurrentCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activateCurrent signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after menuShell #activateCurrent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuShellActivateCurrent :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellActivateCurrentCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cancel signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on menuShell #cancel callback
--   
onMenuShellCancel :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cancel signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after menuShell #cancel callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuShellCancel :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cycleFocus signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on menuShell #cycleFocus callback
--   
onMenuShellCycleFocus :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellCycleFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cycleFocus signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after menuShell #cycleFocus callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuShellCycleFocus :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellCycleFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deactivate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on menuShell #deactivate callback
--   
onMenuShellDeactivate :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellDeactivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deactivate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after menuShell #deactivate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuShellDeactivate :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellDeactivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insert signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on menuShell #insert callback
--   
onMenuShellInsert :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellInsertCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insert signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after menuShell #insert callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuShellInsert :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellInsertCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCurrent signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on menuShell #moveCurrent callback
--   
onMenuShellMoveCurrent :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellMoveCurrentCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCurrent signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after menuShell #moveCurrent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuShellMoveCurrent :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellMoveCurrentCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveSelected signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on menuShell #moveSelected callback
--   
onMenuShellMoveSelected :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellMoveSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveSelected signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after menuShell #moveSelected callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuShellMoveSelected :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellMoveSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionDone signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on menuShell #selectionDone callback
--   
onMenuShellSelectionDone :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellSelectionDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionDone signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after menuShell #selectionDone callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuShellSelectionDone :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellSelectionDoneCallback) -> m SignalHandlerId

-- | Get the value of the “take-focus” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menuShell #takeFocus
--   
getMenuShellTakeFocus :: (MonadIO m, IsMenuShell o) => o -> m Bool

-- | Set the value of the “take-focus” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menuShell [ #takeFocus := value ]
--   
setMenuShellTakeFocus :: (MonadIO m, IsMenuShell o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “take-focus” property. This is rarely needed directly, but it
--   is used by new.
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 MenuItem 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 MenuShell and a
--   MenuModel.
--   
--   The contents of shell are removed and then refilled
--   with menu items according to model. When
--   model changes, shell is updated.
--   Calling this function twice on shell with different
--   model will cause the first binding to be replaced with
--   a binding to the new model. If model is Nothing
--   then any previous binding is undone and all children are removed.
--   
--   withSeparators 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 actionNamespace is non-Nothing then the
--   effect is as if all actions mentioned in the model
--   have their names prefixed with the namespace, plus a dot. For example,
--   if the action “quit” is mentioned and actionNamespace
--   is “app” then the effective action name is “app.quit”.
--   
--   This function uses Actionable 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
--   MenuShell outside of a ApplicationWindow, then you will
--   need to attach your own action group to the widget hierarchy using
--   widgetInsertActionGroup. 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 MenuModel.
--   
--   For most cases you are probably better off using
--   menuNewFromModel or menuBarNewFromModel or just directly
--   passing the MenuModel to applicationSetAppMenu or
--   applicationSetMenubar.
--   
--   Since: 3.6
menuShellBindModel :: (HasCallStack, MonadIO m, IsMenuShell a, IsMenuModel b) => a -> Maybe b -> Maybe Text -> Bool -> m ()

-- | Cancels the selection within the menu shell.
--   
--   Since: 2.4
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 Menu or
--   MenuBar from which it was opened up.
--   
--   Since: 3.0
menuShellGetParentShell :: (HasCallStack, MonadIO m, IsMenuShell a) => a -> m Widget

-- | Gets the currently selected item.
--   
--   Since: 3.0
menuShellGetSelectedItem :: (HasCallStack, MonadIO m, IsMenuShell a) => a -> m Widget

-- | Returns True if the menu shell will take the keyboard focus on
--   popup.
--   
--   Since: 2.8
menuShellGetTakeFocus :: (HasCallStack, MonadIO m, IsMenuShell a) => a -> m Bool

-- | Adds a new MenuItem to the menu shell’s item list at the
--   position indicated by position.
menuShellInsert :: (HasCallStack, MonadIO m, IsMenuShell a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Adds a new MenuItem 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.
--   
--   Since: 2.2
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 takeFocus is True (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 takeFocus to False is useful only for
--   special applications like virtual keyboard implementations which
--   should not take keyboard focus.
--   
--   The takeFocus 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 takeFocus property of
--   the submenu needs to be set explicitly.
--   
--   Note that setting it to False 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 takeFocus set
--   to False should not display mnemonics or accelerators, since it
--   cannot be guaranteed that they will work.
--   
--   See also keyboardGrab
--   
--   Since: 2.8
menuShellSetTakeFocus :: (HasCallStack, MonadIO m, IsMenuShell a) => a -> Bool -> m ()

-- | No description available in the introspection data.
type MenuItemToggleSizeRequestCallback = Ptr () -> IO ()

-- | No description available in the introspection data.
type MenuItemToggleSizeAllocateCallback = Int32 -> IO ()

-- | No description available in the introspection data.
type MenuItemSelectCallback = IO ()

-- | No description available in the introspection data.
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
--   MenuItem::activate.
type MenuItemActivateItemCallback = IO ()

-- | Emitted when the item is activated.
type MenuItemActivateCallback = IO ()

-- | Connect a signal handler for the activate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on menuItem #activate callback
--   
onMenuItemActivate :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after menuItem #activate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuItemActivate :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activateItem signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on menuItem #activateItem callback
--   
onMenuItemActivateItem :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemActivateItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activateItem signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after menuItem #activateItem callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuItemActivateItem :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemActivateItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deselect signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on menuItem #deselect callback
--   
onMenuItemDeselect :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemDeselectCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deselect signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after menuItem #deselect callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuItemDeselect :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemDeselectCallback) -> m SignalHandlerId

-- | Connect a signal handler for the select signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on menuItem #select callback
--   
onMenuItemSelect :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemSelectCallback) -> m SignalHandlerId

-- | Connect a signal handler for the select signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after menuItem #select callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuItemSelect :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemSelectCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleSizeAllocate signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on menuItem #toggleSizeAllocate callback
--   
onMenuItemToggleSizeAllocate :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemToggleSizeAllocateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleSizeAllocate signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after menuItem #toggleSizeAllocate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuItemToggleSizeAllocate :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemToggleSizeAllocateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleSizeRequest signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on menuItem #toggleSizeRequest callback
--   
onMenuItemToggleSizeRequest :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemToggleSizeRequestCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleSizeRequest signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after menuItem #toggleSizeRequest callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuItemToggleSizeRequest :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemToggleSizeRequestCallback) -> m SignalHandlerId

-- | Get the value of the “accel-path” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menuItem #accelPath
--   
getMenuItemAccelPath :: (MonadIO m, IsMenuItem o) => o -> m (Maybe Text)

-- | Set the value of the “accel-path” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menuItem [ #accelPath := value ]
--   
setMenuItemAccelPath :: (MonadIO m, IsMenuItem o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accel-path” property. This is rarely needed directly, but it
--   is used by new.
constructMenuItemAccelPath :: (IsMenuItem o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “accel-path” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #accelPath
--   
clearMenuItemAccelPath :: (MonadIO m, IsMenuItem o) => o -> m ()

-- | Get the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menuItem #label
--   
getMenuItemLabel :: (MonadIO m, IsMenuItem o) => o -> m Text

-- | Set the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menuItem [ #label := value ]
--   
setMenuItemLabel :: (MonadIO m, IsMenuItem o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label” property. This is rarely needed directly, but it is
--   used by new.
constructMenuItemLabel :: (IsMenuItem o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “right-justified” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menuItem #rightJustified
--   
getMenuItemRightJustified :: (MonadIO m, IsMenuItem o) => o -> m Bool

-- | Set the value of the “right-justified” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menuItem [ #rightJustified := value ]
--   
setMenuItemRightJustified :: (MonadIO m, IsMenuItem o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “right-justified” property. This is rarely needed directly,
--   but it is used by new.
constructMenuItemRightJustified :: (IsMenuItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “submenu” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menuItem #submenu
--   
getMenuItemSubmenu :: (MonadIO m, IsMenuItem o) => o -> m (Maybe Menu)

-- | Set the value of the “submenu” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menuItem [ #submenu := value ]
--   
setMenuItemSubmenu :: (MonadIO m, IsMenuItem o, IsMenu a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “submenu” property. This is rarely needed directly, but it is
--   used by new.
constructMenuItemSubmenu :: (IsMenuItem o, MonadIO m, IsMenu a) => a -> m (GValueConstruct o)

-- | Set the value of the “submenu” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #submenu
--   
clearMenuItemSubmenu :: (MonadIO m, IsMenuItem o) => o -> m ()

-- | Get the value of the “use-underline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menuItem #useUnderline
--   
getMenuItemUseUnderline :: (MonadIO m, IsMenuItem o) => o -> m Bool

-- | Set the value of the “use-underline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menuItem [ #useUnderline := value ]
--   
setMenuItemUseUnderline :: (MonadIO m, IsMenuItem o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-underline” property. This is rarely needed directly, but
--   it is used by new.
constructMenuItemUseUnderline :: (IsMenuItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new MenuItem.
menuItemNew :: (HasCallStack, MonadIO m) => m MenuItem

-- | Creates a new MenuItem whose child is a Label.
menuItemNewWithLabel :: (HasCallStack, MonadIO m) => Text -> m MenuItem

-- | Creates a new MenuItem containing a label.
--   
--   The label will be created using labelNewWithMnemonic, so
--   underscores in label indicate the mnemonic for the
--   menu item.
menuItemNewWithMnemonic :: (HasCallStack, MonadIO m) => Text -> m MenuItem

-- | Emits the MenuItem::activate signal on the given item
menuItemActivate :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m ()

-- | Emits the MenuItem::deselect signal on the given item.
menuItemDeselect :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m ()

-- | Retrieve the accelerator path that was previously set on
--   menuItem.
--   
--   See menuItemSetAccelPath for details.
--   
--   Since: 2.14
menuItemGetAccelPath :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m (Maybe Text)

-- | Sets text on the menuItem label
--   
--   Since: 2.16
menuItemGetLabel :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m Text

-- | Returns whether the menuItem reserves space for the
--   submenu indicator, regardless if it has a submenu or not.
--   
--   Since: 3.0
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
--   menuItemSetSubmenu.
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.
--   
--   Since: 2.16
menuItemGetUseUnderline :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m Bool

-- | Emits the MenuItem::select signal on the given item.
menuItemSelect :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m ()

-- | Sets whether the menuItem 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.
--   
--   Since: 3.0
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 ()

-- | If true, an underline in the text indicates the next character should
--   be used for the mnemonic accelerator key.
--   
--   Since: 2.16
menuItemSetUseUnderline :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Bool -> m ()

-- | Emits the MenuItem::toggleSizeAllocate signal on the given
--   item.
menuItemToggleSizeAllocate :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Int32 -> m ()

-- | Emits the MenuItem::toggleSizeRequest signal on the given item.
menuItemToggleSizeRequest :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Int32 -> m Int32

-- | Emitted when the position of menu is finalized after
--   being popped up using gtk_menu_popup_at_rect (),
--   gtk_menu_popup_at_widget (), or gtk_menu_popup_at_pointer ().
--   
--   menu might be flipped over the anchor rectangle in
--   order to keep it on-screen, in which case flippedX and
--   flippedY will be set to True accordingly.
--   
--   flippedRect is the ideal position of
--   menu after any possible flipping, but before any
--   possible sliding. finalRect is
--   flippedRect, but possibly translated in the case that
--   flipping is still ineffective in keeping menu
--   on-screen.
--   
--   
--   The blue menu is menu's ideal position, the green menu
--   is flippedRect, and the red menu is
--   finalRect.
--   
--   See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (),
--   gtk_menu_popup_at_pointer (), Menu:anchorHints,
--   Menu:rectAnchorDx, Menu:rectAnchorDy, and
--   Menu:menuTypeHint.
--   
--   Since: 3.22
type MenuPoppedUpCallback = Ptr () -> Ptr () -> Bool -> Bool -> IO ()

-- | No description available in the introspection data.
type MenuMoveScrollCallback = ScrollType -> IO ()

-- | Connect a signal handler for the moveScroll signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on menu #moveScroll callback
--   
onMenuMoveScroll :: (IsMenu a, MonadIO m) => a -> ((?self :: a) => MenuMoveScrollCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveScroll signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after menu #moveScroll callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuMoveScroll :: (IsMenu a, MonadIO m) => a -> ((?self :: a) => MenuMoveScrollCallback) -> m SignalHandlerId

-- | Connect a signal handler for the poppedUp signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on menu #poppedUp callback
--   
onMenuPoppedUp :: (IsMenu a, MonadIO m) => a -> ((?self :: a) => MenuPoppedUpCallback) -> m SignalHandlerId

-- | Connect a signal handler for the poppedUp signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after menu #poppedUp callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuPoppedUp :: (IsMenu a, MonadIO m) => a -> ((?self :: a) => MenuPoppedUpCallback) -> m SignalHandlerId

-- | Get the value of the “accel-group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menu #accelGroup
--   
getMenuAccelGroup :: (MonadIO m, IsMenu o) => o -> m AccelGroup

-- | Set the value of the “accel-group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menu [ #accelGroup := value ]
--   
setMenuAccelGroup :: (MonadIO m, IsMenu o, IsAccelGroup a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accel-group” property. This is rarely needed directly, but
--   it is used by new.
constructMenuAccelGroup :: (IsMenu o, MonadIO m, IsAccelGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “accel-group” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #accelGroup
--   
clearMenuAccelGroup :: (MonadIO m, IsMenu o) => o -> m ()

-- | Get the value of the “accel-path” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menu #accelPath
--   
getMenuAccelPath :: (MonadIO m, IsMenu o) => o -> m Text

-- | Set the value of the “accel-path” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menu [ #accelPath := value ]
--   
setMenuAccelPath :: (MonadIO m, IsMenu o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accel-path” property. This is rarely needed directly, but it
--   is used by new.
constructMenuAccelPath :: (IsMenu o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “accel-path” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #accelPath
--   
clearMenuAccelPath :: (MonadIO m, IsMenu o) => o -> m ()

-- | Get the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menu #active
--   
getMenuActive :: (MonadIO m, IsMenu o) => o -> m Int32

-- | Set the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menu [ #active := value ]
--   
setMenuActive :: (MonadIO m, IsMenu o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “active” property. This is rarely needed directly, but it is
--   used by new.
constructMenuActive :: (IsMenu o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “anchor-hints” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menu #anchorHints
--   
getMenuAnchorHints :: (MonadIO m, IsMenu o) => o -> m [AnchorHints]

-- | Set the value of the “anchor-hints” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menu [ #anchorHints := value ]
--   
setMenuAnchorHints :: (MonadIO m, IsMenu o) => o -> [AnchorHints] -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “anchor-hints” property. This is rarely needed directly, but
--   it is used by new.
constructMenuAnchorHints :: (IsMenu o, MonadIO m) => [AnchorHints] -> m (GValueConstruct o)

-- | Get the value of the “attach-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menu #attachWidget
--   
getMenuAttachWidget :: (MonadIO m, IsMenu o) => o -> m Widget

-- | Set the value of the “attach-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menu [ #attachWidget := value ]
--   
setMenuAttachWidget :: (MonadIO m, IsMenu o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “attach-widget” property. This is rarely needed directly, but
--   it is used by new.
constructMenuAttachWidget :: (IsMenu o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “attach-widget” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #attachWidget
--   
clearMenuAttachWidget :: (MonadIO m, IsMenu o) => o -> m ()

-- | Get the value of the “menu-type-hint” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menu #menuTypeHint
--   
getMenuMenuTypeHint :: (MonadIO m, IsMenu o) => o -> m WindowTypeHint

-- | Set the value of the “menu-type-hint” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menu [ #menuTypeHint := value ]
--   
setMenuMenuTypeHint :: (MonadIO m, IsMenu o) => o -> WindowTypeHint -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “menu-type-hint” property. This is rarely needed directly,
--   but it is used by new.
constructMenuMenuTypeHint :: (IsMenu o, MonadIO m) => WindowTypeHint -> m (GValueConstruct o)

-- | Get the value of the “monitor” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menu #monitor
--   
getMenuMonitor :: (MonadIO m, IsMenu o) => o -> m Int32

-- | Set the value of the “monitor” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menu [ #monitor := value ]
--   
setMenuMonitor :: (MonadIO m, IsMenu o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “monitor” property. This is rarely needed directly, but it is
--   used by new.
constructMenuMonitor :: (IsMenu o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “rect-anchor-dx” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menu #rectAnchorDx
--   
getMenuRectAnchorDx :: (MonadIO m, IsMenu o) => o -> m Int32

-- | Set the value of the “rect-anchor-dx” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menu [ #rectAnchorDx := value ]
--   
setMenuRectAnchorDx :: (MonadIO m, IsMenu o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “rect-anchor-dx” property. This is rarely needed directly,
--   but it is used by new.
constructMenuRectAnchorDx :: (IsMenu o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “rect-anchor-dy” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menu #rectAnchorDy
--   
getMenuRectAnchorDy :: (MonadIO m, IsMenu o) => o -> m Int32

-- | Set the value of the “rect-anchor-dy” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menu [ #rectAnchorDy := value ]
--   
setMenuRectAnchorDy :: (MonadIO m, IsMenu o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “rect-anchor-dy” property. This is rarely needed directly,
--   but it is used by new.
constructMenuRectAnchorDy :: (IsMenu o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “reserve-toggle-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menu #reserveToggleSize
--   
getMenuReserveToggleSize :: (MonadIO m, IsMenu o) => o -> m Bool

-- | Set the value of the “reserve-toggle-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menu [ #reserveToggleSize := value ]
--   
setMenuReserveToggleSize :: (MonadIO m, IsMenu o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “reserve-toggle-size” property. This is rarely needed
--   directly, but it is used by new.
constructMenuReserveToggleSize :: (IsMenu o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “tearoff-state” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menu #tearoffState
--   
getMenuTearoffState :: (MonadIO m, IsMenu o) => o -> m Bool

-- | Set the value of the “tearoff-state” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menu [ #tearoffState := value ]
--   
setMenuTearoffState :: (MonadIO m, IsMenu o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tearoff-state” property. This is rarely needed directly, but
--   it is used by new.
constructMenuTearoffState :: (IsMenu o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “tearoff-title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menu #tearoffTitle
--   
getMenuTearoffTitle :: (MonadIO m, IsMenu o) => o -> m (Maybe Text)

-- | Set the value of the “tearoff-title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menu [ #tearoffTitle := value ]
--   
setMenuTearoffTitle :: (MonadIO m, IsMenu o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tearoff-title” property. This is rarely needed directly, but
--   it is used by new.
constructMenuTearoffTitle :: (IsMenu o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “tearoff-title” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #tearoffTitle
--   
clearMenuTearoffTitle :: (MonadIO m, IsMenu o) => o -> m ()

-- | Creates a new Menu
menuNew :: (HasCallStack, MonadIO m) => m Menu

-- | Adds a new MenuItem to a (table) menu. The number of “cells”
--   that an item will occupy is specified by leftAttach,
--   rightAttach, topAttach and
--   bottomAttach. 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 menuDetach.
--   
--   Since: 2.4
menuAttach :: (HasCallStack, MonadIO m, IsMenu a, IsWidget b) => a -> b -> Word32 -> Word32 -> Word32 -> Word32 -> m ()

-- | Gets the AccelGroup which holds global accelerators for the
--   menu. See menuSetAccelGroup.
menuGetAccelGroup :: (HasCallStack, MonadIO m, IsMenu a) => a -> m AccelGroup

-- | Retrieves the accelerator path set on the menu.
--   
--   Since: 2.14
menuGetAccelPath :: (HasCallStack, MonadIO m, IsMenu a) => a -> m Text

-- | Returns the selected menu item from the menu. This is used by the
--   ComboBox.
menuGetActive :: (HasCallStack, MonadIO m, IsMenu a) => a -> m Widget

-- | Returns the Widget 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.
--   
--   Since: 2.14
menuGetMonitor :: (HasCallStack, MonadIO m, IsMenu a) => a -> m Int32

-- | Returns whether the menu reserves space for toggles and icons,
--   regardless of their actual presence.
--   
--   Since: 2.18
menuGetReserveToggleSize :: (HasCallStack, MonadIO m, IsMenu a) => a -> m Bool

-- | Returns whether the menu is torn off. See menuSetTearoffState.
menuGetTearoffState :: (HasCallStack, MonadIO m, IsMenu a) => a -> m Bool

-- | Returns the title of the menu. See menuSetTitle.
menuGetTitle :: (HasCallStack, MonadIO m, IsMenu a) => a -> m Text

-- | Places menu on the given monitor.
--   
--   Since: 3.22
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 menu 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.
--   
--   menu will be positioned at the pointer associated with
--   triggerEvent.
--   
--   Properties that influence the behaviour of this function are
--   Menu:anchorHints, Menu:rectAnchorDx,
--   Menu:rectAnchorDy, and Menu:menuTypeHint. Connect to the
--   Menu::poppedUp signal to find out how it was actually
--   positioned.
--   
--   Since: 3.22
menuPopupAtPointer :: (HasCallStack, MonadIO m, IsMenu a) => a -> Maybe Event -> m ()

-- | Displays menu 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.
--   
--   menu will be positioned at rect,
--   aligning their anchor points. rect is relative to the
--   top-left corner of rectWindow.
--   rectAnchor and menuAnchor determine
--   anchor points on rect and menu to pin
--   together. menu can optionally be offset by
--   Menu:rectAnchorDx and Menu:rectAnchorDy.
--   
--   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
--   Menu:anchorHints and Menu:menuTypeHint. Connect to the
--   Menu::poppedUp signal to find out how it was actually
--   positioned.
--   
--   Since: 3.22
menuPopupAtRect :: (HasCallStack, MonadIO m, IsMenu a, IsWindow b) => a -> b -> Rectangle -> Gravity -> Gravity -> Maybe Event -> m ()

-- | Displays menu 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.
--   
--   
--   menu will be positioned at widget,
--   aligning their anchor points. widgetAnchor and
--   menuAnchor determine anchor points on
--   widget and menu to pin together.
--   menu can optionally be offset by
--   Menu:rectAnchorDx and Menu:rectAnchorDy.
--   
--   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
--   Menu:anchorHints and Menu:menuTypeHint. Connect to the
--   Menu::poppedUp signal to find out how it was actually
--   positioned.
--   
--   Since: 3.22
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 Nothing for the
--   parentMenuShell, parentMenuItem,
--   func, data and destroy
--   parameters. The default menu positioning function will position the
--   menu at the current position of device (or its
--   corresponding pointer).
--   
--   The button 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, button should be 0.
--   
--   The activateTime 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, getCurrentEventTime
--   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.
--   
--   Since: 3.0
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 child to a new position in the
--   list of menu 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
--   ComboBox 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.
--   
--   Since: 2.18
menuSetReserveToggleSize :: (HasCallStack, MonadIO m, IsMenu a) => a -> Bool -> m ()

-- | Sets the Screen on which the menu will be displayed.
--   
--   Since: 2.2
menuSetScreen :: (HasCallStack, MonadIO m, IsMenu a, IsScreen b) => a -> Maybe b -> m ()

-- | Returns a list of the menus which are attached to this widget. This
--   list is owned by GTK+ and must not be modified.
--   
--   Since: 2.6
menuGetForAttachWidget :: (HasCallStack, MonadIO m, IsWidget a) => a -> m [Widget]

-- | The preActivate signal is emitted just before the
--   action in the actionGroup is activated
--   
--   This is intended for UIManager to proxy the signal and provide
--   global notification just before any action is activated.
--   
--   Since: 2.4
type ActionGroupPreActivateCallback = Action -> IO ()

-- | The postActivate signal is emitted just after the
--   action in the actionGroup is activated
--   
--   This is intended for UIManager to proxy the signal and provide
--   global notification just after any action is activated.
--   
--   Since: 2.4
type ActionGroupPostActivateCallback = Action -> IO ()

-- | The disconnectProxy signal is emitted after disconnecting a
--   proxy from an action in the group.
--   
--   UIManager proxies the signal and provides global notification
--   just before any action is connected to a proxy, which is probably more
--   convenient to use.
--   
--   Since: 2.4
type ActionGroupDisconnectProxyCallback = Action -> Widget -> IO ()

-- | The connectProxy 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.
--   
--   UIManager proxies the signal and provides global notification
--   just before any action is connected to a proxy, which is probably more
--   convenient to use.
--   
--   Since: 2.4
type ActionGroupConnectProxyCallback = Action -> Widget -> IO ()

-- | Connect a signal handler for the connectProxy signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on actionGroup #connectProxy callback
--   
onActionGroupConnectProxy :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupConnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the connectProxy signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after actionGroup #connectProxy callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterActionGroupConnectProxy :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupConnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the disconnectProxy signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on actionGroup #disconnectProxy callback
--   
onActionGroupDisconnectProxy :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupDisconnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the disconnectProxy signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after actionGroup #disconnectProxy callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterActionGroupDisconnectProxy :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupDisconnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the postActivate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on actionGroup #postActivate callback
--   
onActionGroupPostActivate :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupPostActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the postActivate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after actionGroup #postActivate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterActionGroupPostActivate :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupPostActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preActivate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on actionGroup #preActivate callback
--   
onActionGroupPreActivate :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupPreActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preActivate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after actionGroup #preActivate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterActionGroupPreActivate :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupPreActivateCallback) -> m SignalHandlerId

-- | Get the value of the “accel-group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get actionGroup #accelGroup
--   
getActionGroupAccelGroup :: (MonadIO m, IsActionGroup o) => o -> m AccelGroup

-- | Set the value of the “accel-group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set actionGroup [ #accelGroup := value ]
--   
setActionGroupAccelGroup :: (MonadIO m, IsActionGroup o, IsAccelGroup a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accel-group” property. This is rarely needed directly, but
--   it is used by new.
constructActionGroupAccelGroup :: (IsActionGroup o, MonadIO m, IsAccelGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “accel-group” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #accelGroup
--   
clearActionGroupAccelGroup :: (MonadIO m, IsActionGroup o) => o -> m ()

-- | Get the value of the “name” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get actionGroup #name
--   
getActionGroupName :: (MonadIO m, IsActionGroup o) => o -> m Text

-- | Construct a GValueConstruct with valid value for the
--   “name” property. This is rarely needed directly, but it is
--   used by new.
constructActionGroupName :: (IsActionGroup o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “sensitive” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get actionGroup #sensitive
--   
getActionGroupSensitive :: (MonadIO m, IsActionGroup o) => o -> m Bool

-- | Set the value of the “sensitive” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set actionGroup [ #sensitive := value ]
--   
setActionGroupSensitive :: (MonadIO m, IsActionGroup o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “sensitive” property. This is rarely needed directly, but it
--   is used by new.
constructActionGroupSensitive :: (IsActionGroup o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get actionGroup #visible
--   
getActionGroupVisible :: (MonadIO m, IsActionGroup o) => o -> m Bool

-- | Set the value of the “visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set actionGroup [ #visible := value ]
--   
setActionGroupVisible :: (MonadIO m, IsActionGroup o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible” property. This is rarely needed directly, but it is
--   used by new.
constructActionGroupVisible :: (IsActionGroup o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new ActionGroup object. The name of the action group
--   is used when associating [keybindings][Action-Accel] with the actions.
--   
--   Since: 2.4
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 actionSetAccelPath, or use
--   gtk_action_group_add_action_with_accel (..., NULL).
--   
--   Since: 2.4
actionGroupAddAction :: (HasCallStack, MonadIO m, IsActionGroup a, IsAction b) => a -> b -> m ()

-- | Gets the accelerator group.
--   
--   Since: 3.6
actionGroupGetAccelGroup :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> m AccelGroup

-- | Looks up an action in the action group by name.
--   
--   Since: 2.4
actionGroupGetAction :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> Text -> m (Maybe Action)

-- | Gets the name of the action group.
--   
--   Since: 2.4
actionGroupGetName :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> m Text

-- | Returns True if the group is sensitive. The constituent actions
--   can only be logically sensitive (see actionIsSensitive) if they
--   are sensitive (see actionGetSensitive) and their group is
--   sensitive.
--   
--   Since: 2.4
actionGroupGetSensitive :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> m Bool

-- | Returns True if the group is visible. The constituent actions
--   can only be logically visible (see actionIsVisible) if they are
--   visible (see actionGetVisible) and their group is visible.
--   
--   Since: 2.4
actionGroupGetVisible :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> m Bool

-- | Lists the actions in the action group.
--   
--   Since: 2.4
actionGroupListActions :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> m [Action]

-- | Removes an action object from the action group.
--   
--   Since: 2.4
actionGroupRemoveAction :: (HasCallStack, MonadIO m, IsActionGroup a, IsAction b) => a -> b -> m ()

-- | Sets the accelerator group to be used by every action in this group.
--   
--   Since: 3.6
actionGroupSetAccelGroup :: (HasCallStack, MonadIO m, IsActionGroup a, IsAccelGroup b) => a -> Maybe b -> m ()

-- | Changes the sensitivity of actionGroup
--   
--   Since: 2.4
actionGroupSetSensitive :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> Bool -> m ()

-- | Changes the visible of actionGroup.
--   
--   Since: 2.4
actionGroupSetVisible :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> Bool -> m ()

-- | Translates a string using the function set with
--   actionGroupSetTranslateFunc. This is mainly intended for
--   language bindings.
--   
--   Since: 2.6
actionGroupTranslateString :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> Text -> m Text

-- | The "activate" signal is emitted when the action is activated.
--   
--   Since: 2.4
type ActionActivateCallback = IO ()

-- | Connect a signal handler for the activate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on action #activate callback
--   
onActionActivate :: (IsAction a, MonadIO m) => a -> ((?self :: a) => ActionActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after action #activate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterActionActivate :: (IsAction a, MonadIO m) => a -> ((?self :: a) => ActionActivateCallback) -> m SignalHandlerId

-- | Get the value of the “action-group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #actionGroup
--   
getActionActionGroup :: (MonadIO m, IsAction o) => o -> m (Maybe ActionGroup)

-- | Set the value of the “action-group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #actionGroup := value ]
--   
setActionActionGroup :: (MonadIO m, IsAction o, IsActionGroup a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “action-group” property. This is rarely needed directly, but
--   it is used by new.
constructActionActionGroup :: (IsAction o, MonadIO m, IsActionGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “action-group” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #actionGroup
--   
clearActionActionGroup :: (MonadIO m, IsAction o) => o -> m ()

-- | Get the value of the “always-show-image” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #alwaysShowImage
--   
getActionAlwaysShowImage :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “always-show-image” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #alwaysShowImage := value ]
--   
setActionAlwaysShowImage :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “always-show-image” property. This is rarely needed directly,
--   but it is used by new.
constructActionAlwaysShowImage :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gicon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #gicon
--   
getActionGicon :: (MonadIO m, IsAction o) => o -> m Icon

-- | Set the value of the “gicon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #gicon := value ]
--   
setActionGicon :: (MonadIO m, IsAction o, IsIcon a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gicon” property. This is rarely needed directly, but it is
--   used by new.
constructActionGicon :: (IsAction o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Get the value of the “hide-if-empty” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #hideIfEmpty
--   
getActionHideIfEmpty :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “hide-if-empty” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #hideIfEmpty := value ]
--   
setActionHideIfEmpty :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “hide-if-empty” property. This is rarely needed directly, but
--   it is used by new.
constructActionHideIfEmpty :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #iconName
--   
getActionIconName :: (MonadIO m, IsAction o) => o -> m Text

-- | Set the value of the “icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #iconName := value ]
--   
setActionIconName :: (MonadIO m, IsAction o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-name” property. This is rarely needed directly, but it
--   is used by new.
constructActionIconName :: (IsAction o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “is-important” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #isImportant
--   
getActionIsImportant :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “is-important” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #isImportant := value ]
--   
setActionIsImportant :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “is-important” property. This is rarely needed directly, but
--   it is used by new.
constructActionIsImportant :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #label
--   
getActionLabel :: (MonadIO m, IsAction o) => o -> m Text

-- | Set the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #label := value ]
--   
setActionLabel :: (MonadIO m, IsAction o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label” property. This is rarely needed directly, but it is
--   used by new.
constructActionLabel :: (IsAction o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “name” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get action #name
--   
getActionName :: (MonadIO m, IsAction o) => o -> m Text

-- | Construct a GValueConstruct with valid value for the
--   “name” property. This is rarely needed directly, but it is
--   used by new.
constructActionName :: (IsAction o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “sensitive” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #sensitive
--   
getActionSensitive :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “sensitive” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #sensitive := value ]
--   
setActionSensitive :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “sensitive” property. This is rarely needed directly, but it
--   is used by new.
constructActionSensitive :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “short-label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #shortLabel
--   
getActionShortLabel :: (MonadIO m, IsAction o) => o -> m Text

-- | Set the value of the “short-label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #shortLabel := value ]
--   
setActionShortLabel :: (MonadIO m, IsAction o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “short-label” property. This is rarely needed directly, but
--   it is used by new.
constructActionShortLabel :: (IsAction o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “stock-id” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #stockId
--   
getActionStockId :: (MonadIO m, IsAction o) => o -> m Text

-- | Set the value of the “stock-id” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #stockId := value ]
--   
setActionStockId :: (MonadIO m, IsAction o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “stock-id” property. This is rarely needed directly, but it
--   is used by new.
constructActionStockId :: (IsAction o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “tooltip” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #tooltip
--   
getActionTooltip :: (MonadIO m, IsAction o) => o -> m Text

-- | Set the value of the “tooltip” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #tooltip := value ]
--   
setActionTooltip :: (MonadIO m, IsAction o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tooltip” property. This is rarely needed directly, but it is
--   used by new.
constructActionTooltip :: (IsAction o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #visible
--   
getActionVisible :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #visible := value ]
--   
setActionVisible :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible” property. This is rarely needed directly, but it is
--   used by new.
constructActionVisible :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “visible-horizontal” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #visibleHorizontal
--   
getActionVisibleHorizontal :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “visible-horizontal” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #visibleHorizontal := value ]
--   
setActionVisibleHorizontal :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible-horizontal” property. This is rarely needed
--   directly, but it is used by new.
constructActionVisibleHorizontal :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “visible-overflown” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #visibleOverflown
--   
getActionVisibleOverflown :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “visible-overflown” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #visibleOverflown := value ]
--   
setActionVisibleOverflown :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible-overflown” property. This is rarely needed directly,
--   but it is used by new.
constructActionVisibleOverflown :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “visible-vertical” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get action #visibleVertical
--   
getActionVisibleVertical :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “visible-vertical” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set action [ #visibleVertical := value ]
--   
setActionVisibleVertical :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible-vertical” property. This is rarely needed directly,
--   but it is used by new.
constructActionVisibleVertical :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new Action object. To add the action to a
--   ActionGroup and set the accelerator for the action, call
--   actionGroupAddActionWithAccel. See the [UI Definition
--   section][XML-UI] for information on allowed action names.
--   
--   Since: 2.4
actionNew :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> m Action

-- | Disable activation signals from the action
--   
--   This is needed when updating the state of your proxy
--   Activatable widget could result in calling
--   actionActivate, this is a convenience function to avoid
--   recursing in those cases (updating toggle state for instance).
--   
--   Since: 2.16
actionBlockActivate :: (HasCallStack, MonadIO m, IsAction a) => a -> m ()

-- | This function is intended for use by action implementations to create
--   icons displayed in the proxy widgets.
--   
--   Since: 2.4
actionCreateIcon :: (HasCallStack, MonadIO m, IsAction a) => a -> Int32 -> m Widget

-- | If action provides a Menu widget as a submenu
--   for the menu item or the toolbar item it creates, this function
--   returns an instance of that menu.
--   
--   Since: 2.12
actionCreateMenu :: (HasCallStack, MonadIO m, IsAction a) => a -> m Widget

-- | Creates a menu item widget that proxies for the given action.
--   
--   Since: 2.4
actionCreateMenuItem :: (HasCallStack, MonadIO m, IsAction a) => a -> m Widget

-- | Creates a toolbar item widget that proxies for the given action.
--   
--   Since: 2.4
actionCreateToolItem :: (HasCallStack, MonadIO m, IsAction a) => a -> m Widget

-- | Returns the accel closure for this action.
--   
--   Since: 2.8
actionGetAccelClosure :: (HasCallStack, MonadIO m, IsAction a) => a -> m (GClosure b)

-- | Returns the accel path for this action.
--   
--   Since: 2.6
actionGetAccelPath :: (HasCallStack, MonadIO m, IsAction a) => a -> m Text

-- | Returns whether action's menu item proxies will always
--   show their image, if available.
--   
--   Since: 2.20
actionGetAlwaysShowImage :: (HasCallStack, MonadIO m, IsAction a) => a -> m Bool

-- | Gets the gicon of action.
--   
--   Since: 2.16
actionGetGicon :: (HasCallStack, MonadIO m, IsAction a) => a -> m Icon

-- | Gets the icon name of action.
--   
--   Since: 2.16
actionGetIconName :: (HasCallStack, MonadIO m, IsAction a) => a -> m Text

-- | Checks whether action is important or not
--   
--   Since: 2.16
actionGetIsImportant :: (HasCallStack, MonadIO m, IsAction a) => a -> m Bool

-- | Gets the label text of action.
--   
--   Since: 2.16
actionGetLabel :: (HasCallStack, MonadIO m, IsAction a) => a -> m Text

-- | Returns the name of the action.
--   
--   Since: 2.4
actionGetName :: (HasCallStack, MonadIO m, IsAction a) => a -> m Text

-- | Returns the proxy widgets for an action. See also
--   activatableGetRelatedAction.
--   
--   Since: 2.4
actionGetProxies :: (HasCallStack, MonadIO m, IsAction a) => a -> m [Widget]

-- | Gets the short label text of action.
--   
--   Since: 2.16
actionGetShortLabel :: (HasCallStack, MonadIO m, IsAction a) => a -> m Text

-- | Gets the stock id of action.
--   
--   Since: 2.16
actionGetStockId :: (HasCallStack, MonadIO m, IsAction a) => a -> m Text

-- | Gets the tooltip text of action.
--   
--   Since: 2.16
actionGetTooltip :: (HasCallStack, MonadIO m, IsAction a) => a -> m Text

-- | Checks whether action is visible when horizontal
--   
--   Since: 2.16
actionGetVisibleHorizontal :: (HasCallStack, MonadIO m, IsAction a) => a -> m Bool

-- | Checks whether action is visible when horizontal
--   
--   Since: 2.16
actionGetVisibleVertical :: (HasCallStack, MonadIO m, IsAction a) => a -> m Bool

-- | Sets whether action's menu item proxies will ignore
--   the Settings:gtkMenuImages setting and always show their image,
--   if available.
--   
--   Use this if the menu item would be useless or hard to use without
--   their image.
--   
--   Since: 2.20
actionSetAlwaysShowImage :: (HasCallStack, MonadIO m, IsAction a) => a -> Bool -> m ()

-- | Sets the icon of action.
--   
--   Since: 2.16
actionSetGicon :: (HasCallStack, MonadIO m, IsAction a, IsIcon b) => a -> b -> m ()

-- | Sets the icon name on action
--   
--   Since: 2.16
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.
--   
--   Since: 2.16
actionSetIsImportant :: (HasCallStack, MonadIO m, IsAction a) => a -> Bool -> m ()

-- | Sets the label of action.
--   
--   Since: 2.16
actionSetLabel :: (HasCallStack, MonadIO m, IsAction a) => a -> Text -> m ()

-- | Sets the :sensitive property of the action to
--   sensitive. Note that this doesn’t necessarily mean
--   effective sensitivity. See actionIsSensitive for that.
--   
--   Since: 2.6
actionSetSensitive :: (HasCallStack, MonadIO m, IsAction a) => a -> Bool -> m ()

-- | Sets a shorter label text on action.
--   
--   Since: 2.16
actionSetShortLabel :: (HasCallStack, MonadIO m, IsAction a) => a -> Text -> m ()

-- | Sets the stock id on action
--   
--   Since: 2.16
actionSetStockId :: (HasCallStack, MonadIO m, IsAction a) => a -> Text -> m ()

-- | Sets the tooltip text on action
--   
--   Since: 2.16
actionSetTooltip :: (HasCallStack, MonadIO m, IsAction a) => a -> Text -> m ()

-- | Sets the :visible property of the action to visible.
--   Note that this doesn’t necessarily mean effective visibility. See
--   actionIsVisible for that.
--   
--   Since: 2.6
actionSetVisible :: (HasCallStack, MonadIO m, IsAction a) => a -> Bool -> m ()

-- | Sets whether action is visible when horizontal
--   
--   Since: 2.16
actionSetVisibleHorizontal :: (HasCallStack, MonadIO m, IsAction a) => a -> Bool -> m ()

-- | Sets whether action is visible when vertical
--   
--   Since: 2.16
actionSetVisibleVertical :: (HasCallStack, MonadIO m, IsAction a) => a -> Bool -> m ()

-- | Reenable activation signals from the action
--   
--   Since: 2.16
actionUnblockActivate :: (HasCallStack, MonadIO m, IsAction a) => a -> m ()

-- | Get the value of the “related-action” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get activatable #relatedAction
--   
getActivatableRelatedAction :: (MonadIO m, IsActivatable o) => o -> m Action

-- | Set the value of the “related-action” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set activatable [ #relatedAction := value ]
--   
setActivatableRelatedAction :: (MonadIO m, IsActivatable o, IsAction a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “related-action” property. This is rarely needed directly,
--   but it is used by new.
constructActivatableRelatedAction :: (IsActivatable o, MonadIO m, IsAction a) => a -> m (GValueConstruct o)

-- | Get the value of the “use-action-appearance” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get activatable #useActionAppearance
--   
getActivatableUseActionAppearance :: (MonadIO m, IsActivatable o) => o -> m Bool

-- | Set the value of the “use-action-appearance” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set activatable [ #useActionAppearance := value ]
--   
setActivatableUseActionAppearance :: (MonadIO m, IsActivatable o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-action-appearance” property. This is rarely needed
--   directly, but it is used by new.
constructActivatableUseActionAppearance :: (IsActivatable o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | This is a utility function for Activatable implementors.
--   
--   When implementing Activatable you must call this when handling
--   changes of the Activatable:relatedAction, and you must also use
--   this to break references in
--   Object->dispose().
--   
--   This function adds a reference to the currently set related action for
--   you, it also makes sure the
--   Activatable->update() method is called when
--   the related Action properties change and registers to the
--   action’s proxy list.
--   
--   
--   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.
--   
--   
--   Since: 2.16
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.
--   
--   Since: 2.16
activatableGetUseActionAppearance :: (HasCallStack, MonadIO m, IsActivatable a) => a -> m Bool

-- | Sets the related action on the activatable object.
--   
--   
--   t'GI.Gtk.Interfaces.Activatable.Activatable' implementors need to handle the [Activatable:relatedAction]("GI.Gtk.Interfaces.Activatable#g:attr:relatedAction")
--   property and call 'GI.Gtk.Interfaces.Activatable.activatableDoSetRelatedAction' when it changes.
--   
--   
--   Since: 2.16
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
--   
--   
--   t'GI.Gtk.Interfaces.Activatable.Activatable' implementors need to handle the
--   [Activatable:useActionAppearance]("GI.Gtk.Interfaces.Activatable#g:attr:useActionAppearance") property and call
--   'GI.Gtk.Interfaces.Activatable.activatableSyncActionProperties' to update /@activatable@/
--   if needed.
--   
--   
--   Since: 2.16
activatableSetUseActionAppearance :: (HasCallStack, MonadIO m, IsActivatable a) => a -> Bool -> m ()

-- | This is called to update the activatable completely, this is called
--   internally when the Activatable:relatedAction property is set
--   or unset and by the implementing class when
--   Activatable:useActionAppearance changes.
--   
--   Since: 2.16
activatableSyncActionProperties :: (HasCallStack, MonadIO m, IsActivatable a, IsAction b) => a -> Maybe b -> m ()

-- | Get the value of the “action-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get actionable #actionName
--   
getActionableActionName :: (MonadIO m, IsActionable o) => o -> m (Maybe Text)

-- | Set the value of the “action-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set actionable [ #actionName := value ]
--   
setActionableActionName :: (MonadIO m, IsActionable o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “action-name” property. This is rarely needed directly, but
--   it is used by new.
constructActionableActionName :: (IsActionable o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “action-name” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #actionName
--   
clearActionableActionName :: (MonadIO m, IsActionable o) => o -> m ()

-- | Get the value of the “action-target” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get actionable #actionTarget
--   
getActionableActionTarget :: (MonadIO m, IsActionable o) => o -> m (Maybe GVariant)

-- | Set the value of the “action-target” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set actionable [ #actionTarget := value ]
--   
setActionableActionTarget :: (MonadIO m, IsActionable o) => o -> GVariant -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “action-target” property. This is rarely needed directly, but
--   it is used by new.
constructActionableActionTarget :: (IsActionable o, MonadIO m) => GVariant -> m (GValueConstruct o)

-- | Set the value of the “action-target” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #actionTarget
--   
clearActionableActionTarget :: (MonadIO m, IsActionable o) => o -> m ()

-- | Gets the action name for actionable.
--   
--   See actionableSetActionName for more information.
--   
--   Since: 3.4
actionableGetActionName :: (HasCallStack, MonadIO m, IsActionable a) => a -> m (Maybe Text)

-- | Gets the current target value of actionable.
--   
--   See actionableSetActionTargetValue for more information.
--   
--   Since: 3.4
actionableGetActionTargetValue :: (HasCallStack, MonadIO m, IsActionable a) => a -> m GVariant

-- | Sets the action-name and associated string target value of an
--   actionable widget.
--   
--   detailedActionName is a string in the format accepted
--   by actionParseDetailedName.
--   
--   (Note that prior to version 3.22.25, this function is only usable for
--   actions with a simple "s" target, and
--   detailedActionName must be of the form
--   "action::target" where action is the action name and
--   target is the string to use as the target.)
--   
--   Since: 3.4
actionableSetDetailedActionName :: (HasCallStack, MonadIO m, IsActionable a) => a -> Text -> m ()

-- | 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 ListBox::rowActivated signal on the row’s parent
--   ListBox.
--   
--   Since: 3.10
type ListBoxRowActivateCallback = IO ()

-- | Connect a signal handler for the activate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on listBoxRow #activate callback
--   
onListBoxRowActivate :: (IsListBoxRow a, MonadIO m) => a -> ((?self :: a) => ListBoxRowActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after listBoxRow #activate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterListBoxRowActivate :: (IsListBoxRow a, MonadIO m) => a -> ((?self :: a) => ListBoxRowActivateCallback) -> m SignalHandlerId

-- | Get the value of the “activatable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get listBoxRow #activatable
--   
getListBoxRowActivatable :: (MonadIO m, IsListBoxRow o) => o -> m Bool

-- | Set the value of the “activatable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set listBoxRow [ #activatable := value ]
--   
setListBoxRowActivatable :: (MonadIO m, IsListBoxRow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “activatable” property. This is rarely needed directly, but
--   it is used by new.
constructListBoxRowActivatable :: (IsListBoxRow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “selectable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get listBoxRow #selectable
--   
getListBoxRowSelectable :: (MonadIO m, IsListBoxRow o) => o -> m Bool

-- | Set the value of the “selectable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set listBoxRow [ #selectable := value ]
--   
setListBoxRowSelectable :: (MonadIO m, IsListBoxRow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “selectable” property. This is rarely needed directly, but it
--   is used by new.
constructListBoxRowSelectable :: (IsListBoxRow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new ListBoxRow, to be used as a child of a
--   ListBox.
--   
--   Since: 3.10
listBoxRowNew :: (HasCallStack, MonadIO m) => m ListBoxRow

-- | Gets the value of the ListBoxRow:activatable property for this
--   row.
--   
--   Since: 3.14
listBoxRowGetActivatable :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m Bool

-- | Gets the current index of the row in its
--   ListBox container.
--   
--   Since: 3.10
listBoxRowGetIndex :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m Int32

-- | Gets the value of the ListBoxRow:selectable property for this
--   row.
--   
--   Since: 3.14
listBoxRowGetSelectable :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m Bool

-- | Returns whether the child is currently selected in its ListBox
--   container.
--   
--   Since: 3.14
listBoxRowIsSelected :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m Bool

-- | Set the ListBoxRow:activatable property for this row.
--   
--   Since: 3.14
listBoxRowSetActivatable :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> Bool -> m ()

-- | Set the ListBoxRow:selectable property for this row.
--   
--   Since: 3.14
listBoxRowSetSelectable :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> Bool -> m ()

-- | The unselectAll 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.
--   
--   Since: 3.14
type ListBoxUnselectAllCallback = IO ()

-- | No description available in the introspection data.
type ListBoxToggleCursorRowCallback = IO ()

-- | The selectedRowsChanged signal is emitted when the set of
--   selected rows changes.
--   
--   Since: 3.14
type ListBoxSelectedRowsChangedCallback = IO ()

-- | The selectAll 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.
--   
--   Since: 3.14
type ListBoxSelectAllCallback = IO ()

-- | The rowSelected signal is emitted when a new row is selected,
--   or (with a Nothing row) when the selection is
--   cleared.
--   
--   When the box is using
--   GTK_SELECTION_MULTIPLE, this signal will not give you
--   the full picture of selection changes, and you should use the
--   ListBox::selectedRowsChanged signal instead.
--   
--   Since: 3.10
type ListBoxRowSelectedCallback = Maybe ListBoxRow -> IO ()

-- | The rowActivated signal is emitted when a row has been
--   activated by the user.
--   
--   Since: 3.10
type ListBoxRowActivatedCallback = ListBoxRow -> IO ()

-- | No description available in the introspection data.
type ListBoxMoveCursorCallback = MovementStep -> Int32 -> IO ()

-- | No description available in the introspection data.
type ListBoxActivateCursorRowCallback = IO ()

-- | Connect a signal handler for the activateCursorRow signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on listBox #activateCursorRow callback
--   
onListBoxActivateCursorRow :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxActivateCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activateCursorRow signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after listBox #activateCursorRow callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterListBoxActivateCursorRow :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxActivateCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCursor signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on listBox #moveCursor callback
--   
onListBoxMoveCursor :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCursor signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after listBox #moveCursor callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterListBoxMoveCursor :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the rowActivated signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on listBox #rowActivated callback
--   
onListBoxRowActivated :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxRowActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the rowActivated signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after listBox #rowActivated callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterListBoxRowActivated :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxRowActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the rowSelected signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on listBox #rowSelected callback
--   
onListBoxRowSelected :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxRowSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the rowSelected signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after listBox #rowSelected callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterListBoxRowSelected :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxRowSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectAll signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on listBox #selectAll callback
--   
onListBoxSelectAll :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectAll signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after listBox #selectAll callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterListBoxSelectAll :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectedRowsChanged signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on listBox #selectedRowsChanged callback
--   
onListBoxSelectedRowsChanged :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxSelectedRowsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectedRowsChanged signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after listBox #selectedRowsChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterListBoxSelectedRowsChanged :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxSelectedRowsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleCursorRow signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on listBox #toggleCursorRow callback
--   
onListBoxToggleCursorRow :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxToggleCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleCursorRow signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after listBox #toggleCursorRow callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterListBoxToggleCursorRow :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxToggleCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unselectAll signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on listBox #unselectAll callback
--   
onListBoxUnselectAll :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxUnselectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unselectAll signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after listBox #unselectAll callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterListBoxUnselectAll :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxUnselectAllCallback) -> m SignalHandlerId

-- | Get the value of the “activate-on-single-click” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get listBox #activateOnSingleClick
--   
getListBoxActivateOnSingleClick :: (MonadIO m, IsListBox o) => o -> m Bool

-- | Set the value of the “activate-on-single-click” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set listBox [ #activateOnSingleClick := value ]
--   
setListBoxActivateOnSingleClick :: (MonadIO m, IsListBox o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “activate-on-single-click” property. This is rarely needed
--   directly, but it is used by new.
constructListBoxActivateOnSingleClick :: (IsListBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “selection-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get listBox #selectionMode
--   
getListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> m SelectionMode

-- | Set the value of the “selection-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set listBox [ #selectionMode := value ]
--   
setListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> SelectionMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “selection-mode” property. This is rarely needed directly,
--   but it is used by new.
constructListBoxSelectionMode :: (IsListBox o, MonadIO m) => SelectionMode -> m (GValueConstruct o)

-- | Creates a new ListBox container.
--   
--   Since: 3.10
listBoxNew :: (HasCallStack, MonadIO m) => m ListBox

-- | If a row has previously been highlighted via
--   listBoxDragHighlightRow it will have the highlight removed.
--   
--   Since: 3.10
listBoxDragUnhighlightRow :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Returns whether rows activate on single clicks.
--   
--   Since: 3.10
listBoxGetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsListBox a) => a -> m Bool

-- | Gets the adjustment (if any) that the widget uses to for vertical
--   scrolling.
--   
--   Since: 3.10
listBoxGetAdjustment :: (HasCallStack, MonadIO m, IsListBox a) => a -> m Adjustment

-- | Gets the n-th child in the list (not counting headers). If
--   index_ is negative or larger than the number of items
--   in the list, Nothing is returned.
--   
--   Since: 3.10
listBoxGetRowAtIndex :: (HasCallStack, MonadIO m, IsListBox a) => a -> Int32 -> m (Maybe ListBoxRow)

-- | Gets the row at the y position.
--   
--   Since: 3.10
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 listBoxSelectedForeach to find all selected rows.
--   
--   Since: 3.10
listBoxGetSelectedRow :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ListBoxRow

-- | Creates a list of all selected children.
--   
--   Since: 3.14
listBoxGetSelectedRows :: (HasCallStack, MonadIO m, IsListBox a) => a -> m [ListBoxRow]

-- | Gets the selection mode of the listbox.
--   
--   Since: 3.10
listBoxGetSelectionMode :: (HasCallStack, MonadIO m, IsListBox a) => a -> m SelectionMode

-- | 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 containerAdd.
--   
--   Since: 3.10
listBoxPrepend :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> b -> m ()

-- | Select all children of box, if the selection mode
--   allows it.
--   
--   Since: 3.14
listBoxSelectAll :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Make row the currently selected row.
--   
--   Since: 3.10
listBoxSelectRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> Maybe b -> m ()

-- | If single is True, rows will be activated when
--   you click on them, otherwise you need to double-click.
--   
--   Since: 3.10
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 box is packed inside a
--   ScrolledWindow the adjustment from that will be picked up
--   automatically, so there is no need to manually do that.
--   
--   Since: 3.10
listBoxSetAdjustment :: (HasCallStack, MonadIO m, IsListBox a, IsAdjustment b) => a -> Maybe b -> m ()

-- | By setting a filter function on the box 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 filterFunc will be called for each row after the
--   call, and it will continue to be called each time a row changes (via
--   listBoxRowChanged) or when listBoxInvalidateFilter is
--   called.
--   
--   Note that using a filter function is incompatible with using a model
--   (see listBoxBindModel).
--   
--   Since: 3.10
listBoxSetFilterFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxFilterFunc -> m ()

-- | By setting a header function on the box 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 updateHeader can look at the current header widget
--   using listBoxRowGetHeader and either update the state of the
--   widget as needed, or set a new one using listBoxRowSetHeader.
--   If no header is needed, set the header to Nothing.
--   
--   Note that you may get many calls updateHeader 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 updateHeader function will be called for each row
--   after the call, and it will continue to be called each time a row
--   changes (via listBoxRowChanged) and when the row before changes
--   (either by listBoxRowChanged on the previous row, or when the
--   previous row becomes a different row). It is also called for all rows
--   when listBoxInvalidateHeaders is called.
--   
--   Since: 3.10
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.
--   
--   Since: 3.10
listBoxSetPlaceholder :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets how selection works in the listbox. See SelectionMode for
--   details.
--   
--   Since: 3.10
listBoxSetSelectionMode :: (HasCallStack, MonadIO m, IsListBox a) => a -> SelectionMode -> m ()

-- | By setting a sort function on the box one can
--   dynamically reorder the rows of the list, based on the contents of the
--   rows.
--   
--   The sortFunc will be called for each row after the
--   call, and will continue to be called each time a row changes (via
--   listBoxRowChanged) and when listBoxInvalidateSort is
--   called.
--   
--   Note that using a sort function is incompatible with using a model
--   (see listBoxBindModel).
--   
--   Since: 3.10
listBoxSetSortFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxSortFunc -> m ()

-- | Unselect all children of box, if the selection mode
--   allows it.
--   
--   Since: 3.14
listBoxUnselectAll :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Unselects a single row of box, if the selection mode
--   allows it.
--   
--   Since: 3.14
listBoxUnselectRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> b -> m ()

-- | A [keybinding signal][GtkBindingSignal] which gets emitted when the
--   user unselects all items.
--   
--   Applications should not connect to it, but may emit it with
--   g_signal_emit_by_name() 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
--   g_signal_emit_by_name() if they need to control
--   selection programmatically.
--   
--   There is no default binding for this signal is Ctrl-Space.
type IconViewToggleCursorItemCallback = IO ()

-- | The selectionChanged 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
--   g_signal_emit_by_name() 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
--   g_signal_emit_by_name() if they need to control
--   selection programmatically.
--   
--   The default binding for this signal is Ctrl-a.
type IconViewSelectAllCallback = IO ()

-- | The moveCursor 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
--   g_signal_emit_by_name() if they need to control the
--   cursor programmatically.
--   
--   The default bindings for this signal include * Arrow keys which move
--   by individual steps * Home/End keys which move to the first/last item
--   * PageUp/PageDown which move by "pages" All of these will extend the
--   selection when combined with the Shift modifier.
type IconViewMoveCursorCallback = MovementStep -> Int32 -> IO Bool

-- | The itemActivated signal is emitted when the method
--   iconViewItemActivated is called, when the user double clicks an
--   item with the "activate-on-single-click" property set to False,
--   or when the user single clicks an item when the
--   "activate-on-single-click" property set to True. 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
--   g_signal_emit_by_name() if they need to control
--   activation programmatically.
--   
--   The default bindings for this signal are Space, Return and Enter.
type IconViewActivateCursorItemCallback = IO Bool

-- | Connect a signal handler for the activateCursorItem signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on iconView #activateCursorItem callback
--   
onIconViewActivateCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewActivateCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activateCursorItem signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after iconView #activateCursorItem callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIconViewActivateCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewActivateCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the itemActivated signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on iconView #itemActivated callback
--   
onIconViewItemActivated :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewItemActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the itemActivated signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after iconView #itemActivated callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIconViewItemActivated :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewItemActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCursor signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on iconView #moveCursor callback
--   
onIconViewMoveCursor :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCursor signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after iconView #moveCursor callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIconViewMoveCursor :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectAll signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on iconView #selectAll callback
--   
onIconViewSelectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectAll signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after iconView #selectAll callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIconViewSelectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectCursorItem signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on iconView #selectCursorItem callback
--   
onIconViewSelectCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectCursorItem signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after iconView #selectCursorItem callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIconViewSelectCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on iconView #selectionChanged callback
--   
onIconViewSelectionChanged :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after iconView #selectionChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIconViewSelectionChanged :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleCursorItem signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on iconView #toggleCursorItem callback
--   
onIconViewToggleCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewToggleCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleCursorItem signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after iconView #toggleCursorItem callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIconViewToggleCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewToggleCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unselectAll signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on iconView #unselectAll callback
--   
onIconViewUnselectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewUnselectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unselectAll signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after iconView #unselectAll callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIconViewUnselectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewUnselectAllCallback) -> m SignalHandlerId

-- | Get the value of the “activate-on-single-click” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get iconView #activateOnSingleClick
--   
getIconViewActivateOnSingleClick :: (MonadIO m, IsIconView o) => o -> m Bool

-- | Set the value of the “activate-on-single-click” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #activateOnSingleClick := value ]
--   
setIconViewActivateOnSingleClick :: (MonadIO m, IsIconView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “activate-on-single-click” property. This is rarely needed
--   directly, but it is used by new.
constructIconViewActivateOnSingleClick :: (IsIconView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “cell-area” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #cellArea
--   
getIconViewCellArea :: (MonadIO m, IsIconView o) => o -> m (Maybe CellArea)

-- | Construct a GValueConstruct with valid value for the
--   “cell-area” property. This is rarely needed directly, but it
--   is used by new.
constructIconViewCellArea :: (IsIconView o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “column-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #columnSpacing
--   
getIconViewColumnSpacing :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “column-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #columnSpacing := value ]
--   
setIconViewColumnSpacing :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “column-spacing” property. This is rarely needed directly,
--   but it is used by new.
constructIconViewColumnSpacing :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “columns” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #columns
--   
getIconViewColumns :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “columns” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #columns := value ]
--   
setIconViewColumns :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “columns” property. This is rarely needed directly, but it is
--   used by new.
constructIconViewColumns :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “item-orientation” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #itemOrientation
--   
getIconViewItemOrientation :: (MonadIO m, IsIconView o) => o -> m Orientation

-- | Set the value of the “item-orientation” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #itemOrientation := value ]
--   
setIconViewItemOrientation :: (MonadIO m, IsIconView o) => o -> Orientation -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “item-orientation” property. This is rarely needed directly,
--   but it is used by new.
constructIconViewItemOrientation :: (IsIconView o, MonadIO m) => Orientation -> m (GValueConstruct o)

-- | Get the value of the “item-padding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #itemPadding
--   
getIconViewItemPadding :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “item-padding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #itemPadding := value ]
--   
setIconViewItemPadding :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “item-padding” property. This is rarely needed directly, but
--   it is used by new.
constructIconViewItemPadding :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “item-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #itemWidth
--   
getIconViewItemWidth :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “item-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #itemWidth := value ]
--   
setIconViewItemWidth :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “item-width” property. This is rarely needed directly, but it
--   is used by new.
constructIconViewItemWidth :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #margin
--   
getIconViewMargin :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #margin := value ]
--   
setIconViewMargin :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “margin” property. This is rarely needed directly, but it is
--   used by new.
constructIconViewMargin :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “markup-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #markupColumn
--   
getIconViewMarkupColumn :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “markup-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #markupColumn := value ]
--   
setIconViewMarkupColumn :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “markup-column” property. This is rarely needed directly, but
--   it is used by new.
constructIconViewMarkupColumn :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #model
--   
getIconViewModel :: (MonadIO m, IsIconView o) => o -> m (Maybe TreeModel)

-- | Set the value of the “model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #model := value ]
--   
setIconViewModel :: (MonadIO m, IsIconView o, IsTreeModel a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “model” property. This is rarely needed directly, but it is
--   used by new.
constructIconViewModel :: (IsIconView o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “model” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #model
--   
clearIconViewModel :: (MonadIO m, IsIconView o) => o -> m ()

-- | Get the value of the “pixbuf-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #pixbufColumn
--   
getIconViewPixbufColumn :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “pixbuf-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #pixbufColumn := value ]
--   
setIconViewPixbufColumn :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixbuf-column” property. This is rarely needed directly, but
--   it is used by new.
constructIconViewPixbufColumn :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “reorderable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #reorderable
--   
getIconViewReorderable :: (MonadIO m, IsIconView o) => o -> m Bool

-- | Set the value of the “reorderable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #reorderable := value ]
--   
setIconViewReorderable :: (MonadIO m, IsIconView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “reorderable” property. This is rarely needed directly, but
--   it is used by new.
constructIconViewReorderable :: (IsIconView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “row-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #rowSpacing
--   
getIconViewRowSpacing :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “row-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #rowSpacing := value ]
--   
setIconViewRowSpacing :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “row-spacing” property. This is rarely needed directly, but
--   it is used by new.
constructIconViewRowSpacing :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “selection-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #selectionMode
--   
getIconViewSelectionMode :: (MonadIO m, IsIconView o) => o -> m SelectionMode

-- | Set the value of the “selection-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #selectionMode := value ]
--   
setIconViewSelectionMode :: (MonadIO m, IsIconView o) => o -> SelectionMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “selection-mode” property. This is rarely needed directly,
--   but it is used by new.
constructIconViewSelectionMode :: (IsIconView o, MonadIO m) => SelectionMode -> m (GValueConstruct o)

-- | Get the value of the “spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #spacing
--   
getIconViewSpacing :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #spacing := value ]
--   
setIconViewSpacing :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “spacing” property. This is rarely needed directly, but it is
--   used by new.
constructIconViewSpacing :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “text-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #textColumn
--   
getIconViewTextColumn :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “text-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #textColumn := value ]
--   
setIconViewTextColumn :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text-column” property. This is rarely needed directly, but
--   it is used by new.
constructIconViewTextColumn :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “tooltip-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get iconView #tooltipColumn
--   
getIconViewTooltipColumn :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “tooltip-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set iconView [ #tooltipColumn := value ]
--   
setIconViewTooltipColumn :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tooltip-column” property. This is rarely needed directly,
--   but it is used by new.
constructIconViewTooltipColumn :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new IconView widget
--   
--   Since: 2.6
iconViewNew :: (HasCallStack, MonadIO m) => m IconView

-- | Creates a new IconView widget using the specified
--   area to layout cells inside the icons.
--   
--   Since: 3.0
iconViewNewWithArea :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m IconView

-- | Creates a new IconView widget with the model
--   model.
--   
--   Since: 2.6
iconViewNewWithModel :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m IconView

-- | Creates a Surface representation of the item at
--   path. This image is used for a drag icon.
--   
--   Since: 2.8
iconViewCreateDragIcon :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m Surface

-- | Gets the setting set by iconViewSetActivateOnSingleClick.
--   
--   Since: 3.8
iconViewGetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Bool

-- | Fills the bounding rectangle in widget coordinates for the cell
--   specified by path and cell. If
--   cell is Nothing the main cell area is used.
--   
--   This function is only valid if iconView is realized.
--   
--   Since: 3.6
iconViewGetCellRect :: (HasCallStack, MonadIO m, IsIconView a, IsCellRenderer b) => a -> TreePath -> Maybe b -> m (Bool, Rectangle)

-- | Returns the value of the columnSpacing property.
--   
--   Since: 2.6
iconViewGetColumnSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the value of the columns property.
--   
--   Since: 2.6
iconViewGetColumns :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Fills in path and cell with the
--   current cursor path and cell. If the cursor isn’t currently set, then
--   *path will be Nothing. If no cell currently has
--   focus, then *cell will be Nothing.
--   
--   The returned TreePath must be freed with treePathFree.
--   
--   Since: 2.8
iconViewGetCursor :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (Bool, TreePath, CellRenderer)

-- | Determines the destination item for a given position.
--   
--   Since: 2.8
iconViewGetDestItemAtPos :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m (Bool, TreePath, IconViewDropPosition)

-- | Gets information about the item that is highlighted for feedback.
--   
--   Since: 2.8
iconViewGetDragDestItem :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (TreePath, IconViewDropPosition)

-- | Gets the column in which the item path is currently
--   displayed. Column numbers start at 0.
--   
--   Since: 2.22
iconViewGetItemColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m Int32

-- | Returns the value of the itemOrientation property which
--   determines whether the labels are drawn beside the icons instead of
--   below.
--   
--   Since: 2.6
iconViewGetItemOrientation :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Orientation

-- | Returns the value of the itemPadding property.
--   
--   Since: 2.18
iconViewGetItemPadding :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Gets the row in which the item path is currently
--   displayed. Row numbers start at 0.
--   
--   Since: 2.22
iconViewGetItemRow :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m Int32

-- | Returns the value of the itemWidth property.
--   
--   Since: 2.6
iconViewGetItemWidth :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the value of the margin property.
--   
--   Since: 2.6
iconViewGetMargin :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the column with markup text for iconView.
--   
--   Since: 2.6
iconViewGetMarkupColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the model the IconView is based on. Returns
--   Nothing if the model is unset.
--   
--   Since: 2.6
iconViewGetModel :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (Maybe TreeModel)

-- | Returns the column with pixbufs for iconView.
--   
--   Since: 2.6
iconViewGetPixbufColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Retrieves whether the user can reorder the list via drag-and-drop. See
--   iconViewSetReorderable.
--   
--   Since: 2.8
iconViewGetReorderable :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Bool

-- | Returns the value of the rowSpacing property.
--   
--   Since: 2.6
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
--   GtkTreeRowReferences. To do this, you can use
--   treeRowReferenceNew.
--   
--   To free the return value, use:
--   
--   
C code
--   
--   
--   g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
--   
--   
--   Since: 2.6
iconViewGetSelectedItems :: (HasCallStack, MonadIO m, IsIconView a) => a -> m [TreePath]

-- | Gets the selection mode of the iconView.
--   
--   Since: 2.6
iconViewGetSelectionMode :: (HasCallStack, MonadIO m, IsIconView a) => a -> m SelectionMode

-- | Returns the value of the spacing property.
--   
--   Since: 2.6
iconViewGetSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the column with text for iconView.
--   
--   Since: 2.6
iconViewGetTextColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the column of iconView’s model which is being
--   used for displaying tooltips on iconView’s rows.
--   
--   Since: 2.12
iconViewGetTooltipColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | This function is supposed to be used in a Widget::queryTooltip
--   signal handler for IconView. The x,
--   y and keyboardTip 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 (True) or not (False) for mouse
--   tooltips. For keyboard tooltips the item returned will be the cursor
--   item. When True, then any of model,
--   path and iter which have been provided
--   will be set to point to that row and the corresponding model.
--   x and y will always be converted to be
--   relative to iconView’s bin_window if
--   keyboardTooltip is False.
--   
--   Since: 2.12
iconViewGetTooltipContext :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> Bool -> m (Bool, Int32, Int32, TreeModel, TreePath, TreeIter)

-- | Sets startPath and endPath to be the
--   first and last visible path. Note that there may be invisible paths in
--   between.
--   
--   Both paths should be freed with treePathFree after use.
--   
--   Since: 2.8
iconViewGetVisibleRange :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (Bool, TreePath, TreePath)

-- | Returns True if the icon pointed to by path is
--   currently selected. If path does not point to a valid
--   location, False is returned.
--   
--   Since: 2.6
iconViewPathIsSelected :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m Bool

-- | Moves the alignments of iconView to the position
--   specified by path. rowAlign determines
--   where the row is placed, and colAlign determines where
--   column 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 useAlign is False, 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 path
--   is a valid row on the model. If the model changes before the
--   iconView is realized, the centered path will be
--   modified to reflect this change.
--   
--   Since: 2.8
iconViewScrollToPath :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> Bool -> Float -> Float -> m ()

-- | Selects all the icons. iconView must has its selection
--   mode set to GTK_SELECTION_MULTIPLE.
--   
--   Since: 2.6
iconViewSelectAll :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ()

-- | Selects the row at path.
--   
--   Since: 2.6
iconViewSelectPath :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m ()

-- | Sets the columnSpacing property which specifies the space which
--   is inserted between the columns of the icon view.
--   
--   Since: 2.6
iconViewSetColumnSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the columns property which determines in how many columns
--   the icons are arranged. If columns is -1, the number
--   of columns will be chosen automatically to fill the available area.
--   
--   Since: 2.6
iconViewSetColumns :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the current keyboard focus to be at path, and
--   selects it. This is useful when you want to focus the user’s attention
--   on a particular item. If cell is not Nothing,
--   then focus is given to the cell specified by it. Additionally, if
--   startEditing is True, then editing should be
--   started in the specified cell.
--   
--   This function is often followed by gtk_widget_grab_focus
--   (icon_view) in order to give keyboard focus to the widget. Please
--   note that editing can only happen when the widget is realized.
--   
--   Since: 2.8
iconViewSetCursor :: (HasCallStack, MonadIO m, IsIconView a, IsCellRenderer b) => a -> TreePath -> Maybe b -> Bool -> m ()

-- | Sets the item that is highlighted for feedback.
--   
--   Since: 2.8
iconViewSetDragDestItem :: (HasCallStack, MonadIO m, IsIconView a) => a -> Maybe TreePath -> IconViewDropPosition -> m ()

-- | Sets the itemOrientation property which determines whether the
--   labels are drawn beside the icons instead of below.
--   
--   Since: 2.6
iconViewSetItemOrientation :: (HasCallStack, MonadIO m, IsIconView a) => a -> Orientation -> m ()

-- | Sets the IconView:itemPadding property which specifies the
--   padding around each of the icon view’s items.
--   
--   Since: 2.18
iconViewSetItemPadding :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the itemWidth 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.
--   
--   Since: 2.6
iconViewSetItemWidth :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the margin property which specifies the space which is
--   inserted at the top, bottom, left and right of the icon view.
--   
--   Since: 2.6
iconViewSetMargin :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the column with markup information for iconView
--   to be column. The markup column must be of type
--   G_TYPE_STRING. If the markup column is set to
--   something, it overrides the text column set by
--   iconViewSetTextColumn.
--   
--   Since: 2.6
iconViewSetMarkupColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the model for a IconView. If the iconView
--   already has a model set, it will remove it before setting the new
--   model. If model is Nothing, then it will unset
--   the old model.
--   
--   Since: 2.6
iconViewSetModel :: (HasCallStack, MonadIO m, IsIconView a, IsTreeModel b) => a -> Maybe b -> m ()

-- | Sets the column with pixbufs for iconView to be
--   column. The pixbuf column must be of type
--   GDK_TYPE_PIXBUF
--   
--   Since: 2.6
iconViewSetPixbufColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the rowSpacing property which specifies the space which is
--   inserted between the rows of the icon view.
--   
--   Since: 2.6
iconViewSetRowSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the selection mode of the iconView.
--   
--   Since: 2.6
iconViewSetSelectionMode :: (HasCallStack, MonadIO m, IsIconView a) => a -> SelectionMode -> m ()

-- | Sets the spacing property which specifies the space which is
--   inserted between the cells (i.e. the icon and the text) of an item.
--   
--   Since: 2.6
iconViewSetSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the tip area of tooltip to the area which
--   cell occupies in the item pointed to by
--   path. See also tooltipSetTipArea.
--   
--   See also iconViewSetTooltipColumn for a simpler alternative.
--   
--   Since: 2.12
iconViewSetTooltipCell :: (HasCallStack, MonadIO m, IsIconView a, IsTooltip b, IsCellRenderer c) => a -> b -> TreePath -> Maybe c -> m ()

-- | Sets the tip area of tooltip to be the area covered by
--   the item at path. See also
--   iconViewSetTooltipColumn for a simpler alternative. See also
--   tooltipSetTipArea.
--   
--   Since: 2.12
iconViewSetTooltipItem :: (HasCallStack, MonadIO m, IsIconView a, IsTooltip b) => a -> b -> TreePath -> m ()

-- | Unselects all the icons.
--   
--   Since: 2.6
iconViewUnselectAll :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ()

-- | Unselects the row at path.
--   
--   Since: 2.6
iconViewUnselectPath :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m ()

-- | Undoes the effect of iconViewEnableModelDragDest. Calling this
--   method sets IconView:reorderable to False.
--   
--   Since: 2.8
iconViewUnsetModelDragDest :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ()

-- | Undoes the effect of iconViewEnableModelDragSource. Calling
--   this method sets IconView:reorderable to False.
--   
--   Since: 2.8
iconViewUnsetModelDragSource :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ()

-- | The activate signal is emitted when the user activates a child
--   widget in a FlowBox, 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 ()

-- | Connect a signal handler for the activate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on flowBoxChild #activate callback
--   
onFlowBoxChildActivate :: (IsFlowBoxChild a, MonadIO m) => a -> ((?self :: a) => FlowBoxChildActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after flowBoxChild #activate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFlowBoxChildActivate :: (IsFlowBoxChild a, MonadIO m) => a -> ((?self :: a) => FlowBoxChildActivateCallback) -> m SignalHandlerId

-- | Creates a new FlowBoxChild, to be used as a child of a
--   FlowBox.
--   
--   Since: 3.12
flowBoxChildNew :: (HasCallStack, MonadIO m) => m FlowBoxChild

-- | Gets the current index of the child in its
--   FlowBox container.
--   
--   Since: 3.12
flowBoxChildGetIndex :: (HasCallStack, MonadIO m, IsFlowBoxChild a) => a -> m Int32

-- | Returns whether the child is currently selected in its
--   FlowBox container.
--   
--   Since: 3.12
flowBoxChildIsSelected :: (HasCallStack, MonadIO m, IsFlowBoxChild a) => a -> m Bool

-- | The unselectAll 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 toggleCursorChild 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 selectedChildrenChanged signal is emitted when the set of
--   selected children changes.
--   
--   Use flowBoxSelectedForeach or flowBoxGetSelectedChildren
--   to obtain the selected children.
type FlowBoxSelectedChildrenChangedCallback = IO ()

-- | The selectAll 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 moveCursor 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
--   g_signal_emit_by_name() 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. * Arrow keys move by individual children * Home/End
--   keys move to the ends of the box * PageUp/PageDown keys move
--   vertically by pages
type FlowBoxMoveCursorCallback = MovementStep -> Int32 -> IO Bool

-- | The childActivated signal is emitted when a child has been
--   activated by the user.
type FlowBoxChildActivatedCallback = FlowBoxChild -> IO ()

-- | The activateCursorChild signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user activates
--   the box.
type FlowBoxActivateCursorChildCallback = IO ()

-- | Connect a signal handler for the activateCursorChild signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on flowBox #activateCursorChild callback
--   
onFlowBoxActivateCursorChild :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxActivateCursorChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activateCursorChild signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after flowBox #activateCursorChild callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFlowBoxActivateCursorChild :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxActivateCursorChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the childActivated signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on flowBox #childActivated callback
--   
onFlowBoxChildActivated :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxChildActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the childActivated signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after flowBox #childActivated callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFlowBoxChildActivated :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxChildActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCursor signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on flowBox #moveCursor callback
--   
onFlowBoxMoveCursor :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCursor signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after flowBox #moveCursor callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFlowBoxMoveCursor :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectAll signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on flowBox #selectAll callback
--   
onFlowBoxSelectAll :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectAll signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after flowBox #selectAll callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFlowBoxSelectAll :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectedChildrenChanged
--   signal, to be run before the default handler. When overloading
--   is enabled, this is equivalent to
--   
--   
--   on flowBox #selectedChildrenChanged callback
--   
onFlowBoxSelectedChildrenChanged :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxSelectedChildrenChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectedChildrenChanged
--   signal, to be run after the default handler. When overloading
--   is enabled, this is equivalent to
--   
--   
--   after flowBox #selectedChildrenChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFlowBoxSelectedChildrenChanged :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxSelectedChildrenChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleCursorChild signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on flowBox #toggleCursorChild callback
--   
onFlowBoxToggleCursorChild :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxToggleCursorChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleCursorChild signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after flowBox #toggleCursorChild callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFlowBoxToggleCursorChild :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxToggleCursorChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unselectAll signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on flowBox #unselectAll callback
--   
onFlowBoxUnselectAll :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxUnselectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unselectAll signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after flowBox #unselectAll callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFlowBoxUnselectAll :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxUnselectAllCallback) -> m SignalHandlerId

-- | Get the value of the “activate-on-single-click” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get flowBox #activateOnSingleClick
--   
getFlowBoxActivateOnSingleClick :: (MonadIO m, IsFlowBox o) => o -> m Bool

-- | Set the value of the “activate-on-single-click” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set flowBox [ #activateOnSingleClick := value ]
--   
setFlowBoxActivateOnSingleClick :: (MonadIO m, IsFlowBox o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “activate-on-single-click” property. This is rarely needed
--   directly, but it is used by new.
constructFlowBoxActivateOnSingleClick :: (IsFlowBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “column-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get flowBox #columnSpacing
--   
getFlowBoxColumnSpacing :: (MonadIO m, IsFlowBox o) => o -> m Word32

-- | Set the value of the “column-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set flowBox [ #columnSpacing := value ]
--   
setFlowBoxColumnSpacing :: (MonadIO m, IsFlowBox o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “column-spacing” property. This is rarely needed directly,
--   but it is used by new.
constructFlowBoxColumnSpacing :: (IsFlowBox o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “homogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get flowBox #homogeneous
--   
getFlowBoxHomogeneous :: (MonadIO m, IsFlowBox o) => o -> m Bool

-- | Set the value of the “homogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set flowBox [ #homogeneous := value ]
--   
setFlowBoxHomogeneous :: (MonadIO m, IsFlowBox o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “homogeneous” property. This is rarely needed directly, but
--   it is used by new.
constructFlowBoxHomogeneous :: (IsFlowBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “max-children-per-line” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get flowBox #maxChildrenPerLine
--   
getFlowBoxMaxChildrenPerLine :: (MonadIO m, IsFlowBox o) => o -> m Word32

-- | Set the value of the “max-children-per-line” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set flowBox [ #maxChildrenPerLine := value ]
--   
setFlowBoxMaxChildrenPerLine :: (MonadIO m, IsFlowBox o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “max-children-per-line” property. This is rarely needed
--   directly, but it is used by new.
constructFlowBoxMaxChildrenPerLine :: (IsFlowBox o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “min-children-per-line” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get flowBox #minChildrenPerLine
--   
getFlowBoxMinChildrenPerLine :: (MonadIO m, IsFlowBox o) => o -> m Word32

-- | Set the value of the “min-children-per-line” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set flowBox [ #minChildrenPerLine := value ]
--   
setFlowBoxMinChildrenPerLine :: (MonadIO m, IsFlowBox o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “min-children-per-line” property. This is rarely needed
--   directly, but it is used by new.
constructFlowBoxMinChildrenPerLine :: (IsFlowBox o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “row-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get flowBox #rowSpacing
--   
getFlowBoxRowSpacing :: (MonadIO m, IsFlowBox o) => o -> m Word32

-- | Set the value of the “row-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set flowBox [ #rowSpacing := value ]
--   
setFlowBoxRowSpacing :: (MonadIO m, IsFlowBox o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “row-spacing” property. This is rarely needed directly, but
--   it is used by new.
constructFlowBoxRowSpacing :: (IsFlowBox o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “selection-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get flowBox #selectionMode
--   
getFlowBoxSelectionMode :: (MonadIO m, IsFlowBox o) => o -> m SelectionMode

-- | Set the value of the “selection-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set flowBox [ #selectionMode := value ]
--   
setFlowBoxSelectionMode :: (MonadIO m, IsFlowBox o) => o -> SelectionMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “selection-mode” property. This is rarely needed directly,
--   but it is used by new.
constructFlowBoxSelectionMode :: (IsFlowBox o, MonadIO m) => SelectionMode -> m (GValueConstruct o)

-- | Creates a GtkFlowBox.
--   
--   Since: 3.12
flowBoxNew :: (HasCallStack, MonadIO m) => m FlowBox

-- | Returns whether children activate on single clicks.
--   
--   Since: 3.12
flowBoxGetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Bool

-- | Gets the nth child in the box.
--   
--   Since: 3.12
flowBoxGetChildAtIndex :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Int32 -> m (Maybe FlowBoxChild)

-- | Gets the child in the (x, y) position.
--   
--   Since: 3.22.6
flowBoxGetChildAtPos :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Int32 -> Int32 -> m (Maybe FlowBoxChild)

-- | Gets the horizontal spacing.
--   
--   Since: 3.12
flowBoxGetColumnSpacing :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Word32

-- | Returns whether the box is homogeneous (all children are the same
--   size). See boxSetHomogeneous.
--   
--   Since: 3.12
flowBoxGetHomogeneous :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Bool

-- | Gets the maximum number of children per line.
--   
--   Since: 3.12
flowBoxGetMaxChildrenPerLine :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Word32

-- | Gets the minimum number of children per line.
--   
--   Since: 3.12
flowBoxGetMinChildrenPerLine :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Word32

-- | Gets the vertical spacing.
--   
--   Since: 3.12
flowBoxGetRowSpacing :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Word32

-- | Gets the selection mode of box.
--   
--   Since: 3.12
flowBoxGetSelectionMode :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m SelectionMode

-- | Select all children of box, if the selection mode
--   allows it.
--   
--   Since: 3.12
flowBoxSelectAll :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m ()

-- | Selects a single child of box, if the selection mode
--   allows it.
--   
--   Since: 3.12
flowBoxSelectChild :: (HasCallStack, MonadIO m, IsFlowBox a, IsFlowBoxChild b) => a -> b -> m ()

-- | If single is True, children will be activated
--   when you click on them, otherwise you need to double-click.
--   
--   Since: 3.12
flowBoxSetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Bool -> m ()

-- | Sets the horizontal space to add between children. See the
--   FlowBox:columnSpacing property.
--   
--   Since: 3.12
flowBoxSetColumnSpacing :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Word32 -> m ()

-- | By setting a filter function on the box 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 filterFunc will be called for each child after the
--   call, and it will continue to be called each time a child changes (via
--   flowBoxChildChanged) or when flowBoxInvalidateFilter is
--   called.
--   
--   Note that using a filter function is incompatible with using a model
--   (see flowBoxBindModel).
--   
--   Since: 3.12
flowBoxSetFilterFunc :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Maybe FlowBoxFilterFunc -> m ()

-- | Sets the FlowBox:homogeneous property of box,
--   controlling whether or not all children of box are
--   given equal space in the box.
--   
--   Since: 3.12
flowBoxSetHomogeneous :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Bool -> m ()

-- | Sets the maximum number of children to request and allocate space for
--   in box’s orientation.
--   
--   Setting the maximum number of children per line limits the overall
--   natural size request to be no more than nChildren
--   children long in the given orientation.
--   
--   Since: 3.12
flowBoxSetMaxChildrenPerLine :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Word32 -> m ()

-- | Sets the minimum number of children to line up in
--   box’s orientation before flowing.
--   
--   Since: 3.12
flowBoxSetMinChildrenPerLine :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Word32 -> m ()

-- | Sets the vertical space to add between children. See the
--   FlowBox:rowSpacing property.
--   
--   Since: 3.12
flowBoxSetRowSpacing :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Word32 -> m ()

-- | Sets how selection works in box. See
--   SelectionMode for details.
--   
--   Since: 3.12
flowBoxSetSelectionMode :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> SelectionMode -> m ()

-- | By setting a sort function on the box, one can
--   dynamically reorder the children of the box, based on the contents of
--   the children.
--   
--   The sortFunc will be called for each child after the
--   call, and will continue to be called each time a child changes (via
--   flowBoxChildChanged) and when flowBoxInvalidateSort is
--   called.
--   
--   Note that using a sort function is incompatible with using a model
--   (see flowBoxBindModel).
--   
--   Since: 3.12
flowBoxSetSortFunc :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Maybe FlowBoxSortFunc -> m ()

-- | Unselect all children of box, if the selection mode
--   allows it.
--   
--   Since: 3.12
flowBoxUnselectAll :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m ()

-- | Unselects a single child of box, if the selection mode
--   allows it.
--   
--   Since: 3.12
flowBoxUnselectChild :: (HasCallStack, MonadIO m, IsFlowBox a, IsFlowBoxChild b) => a -> b -> m ()

-- | 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 ()

-- | Connect a signal handler for the daySelected signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on calendar #daySelected callback
--   
onCalendarDaySelected :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarDaySelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the daySelected signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after calendar #daySelected callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCalendarDaySelected :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarDaySelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the daySelectedDoubleClick signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on calendar #daySelectedDoubleClick callback
--   
onCalendarDaySelectedDoubleClick :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarDaySelectedDoubleClickCallback) -> m SignalHandlerId

-- | Connect a signal handler for the daySelectedDoubleClick signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after calendar #daySelectedDoubleClick callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCalendarDaySelectedDoubleClick :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarDaySelectedDoubleClickCallback) -> m SignalHandlerId

-- | Connect a signal handler for the monthChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on calendar #monthChanged callback
--   
onCalendarMonthChanged :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarMonthChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the monthChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after calendar #monthChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCalendarMonthChanged :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarMonthChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the nextMonth signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on calendar #nextMonth callback
--   
onCalendarNextMonth :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarNextMonthCallback) -> m SignalHandlerId

-- | Connect a signal handler for the nextMonth signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after calendar #nextMonth callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCalendarNextMonth :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarNextMonthCallback) -> m SignalHandlerId

-- | Connect a signal handler for the nextYear signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on calendar #nextYear callback
--   
onCalendarNextYear :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarNextYearCallback) -> m SignalHandlerId

-- | Connect a signal handler for the nextYear signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after calendar #nextYear callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCalendarNextYear :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarNextYearCallback) -> m SignalHandlerId

-- | Connect a signal handler for the prevMonth signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on calendar #prevMonth callback
--   
onCalendarPrevMonth :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarPrevMonthCallback) -> m SignalHandlerId

-- | Connect a signal handler for the prevMonth signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after calendar #prevMonth callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCalendarPrevMonth :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarPrevMonthCallback) -> m SignalHandlerId

-- | Connect a signal handler for the prevYear signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on calendar #prevYear callback
--   
onCalendarPrevYear :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarPrevYearCallback) -> m SignalHandlerId

-- | Connect a signal handler for the prevYear signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after calendar #prevYear callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCalendarPrevYear :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarPrevYearCallback) -> m SignalHandlerId

-- | Get the value of the “day” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get calendar #day
--   
getCalendarDay :: (MonadIO m, IsCalendar o) => o -> m Int32

-- | Set the value of the “day” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set calendar [ #day := value ]
--   
setCalendarDay :: (MonadIO m, IsCalendar o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “day” property. This is rarely needed directly, but it is
--   used by new.
constructCalendarDay :: (IsCalendar o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “detail-height-rows” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get calendar #detailHeightRows
--   
getCalendarDetailHeightRows :: (MonadIO m, IsCalendar o) => o -> m Int32

-- | Set the value of the “detail-height-rows” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set calendar [ #detailHeightRows := value ]
--   
setCalendarDetailHeightRows :: (MonadIO m, IsCalendar o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “detail-height-rows” property. This is rarely needed
--   directly, but it is used by new.
constructCalendarDetailHeightRows :: (IsCalendar o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “detail-width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get calendar #detailWidthChars
--   
getCalendarDetailWidthChars :: (MonadIO m, IsCalendar o) => o -> m Int32

-- | Set the value of the “detail-width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set calendar [ #detailWidthChars := value ]
--   
setCalendarDetailWidthChars :: (MonadIO m, IsCalendar o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “detail-width-chars” property. This is rarely needed
--   directly, but it is used by new.
constructCalendarDetailWidthChars :: (IsCalendar o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “month” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get calendar #month
--   
getCalendarMonth :: (MonadIO m, IsCalendar o) => o -> m Int32

-- | Set the value of the “month” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set calendar [ #month := value ]
--   
setCalendarMonth :: (MonadIO m, IsCalendar o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “month” property. This is rarely needed directly, but it is
--   used by new.
constructCalendarMonth :: (IsCalendar o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “no-month-change” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get calendar #noMonthChange
--   
getCalendarNoMonthChange :: (MonadIO m, IsCalendar o) => o -> m Bool

-- | Set the value of the “no-month-change” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set calendar [ #noMonthChange := value ]
--   
setCalendarNoMonthChange :: (MonadIO m, IsCalendar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “no-month-change” property. This is rarely needed directly,
--   but it is used by new.
constructCalendarNoMonthChange :: (IsCalendar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-day-names” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get calendar #showDayNames
--   
getCalendarShowDayNames :: (MonadIO m, IsCalendar o) => o -> m Bool

-- | Set the value of the “show-day-names” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set calendar [ #showDayNames := value ]
--   
setCalendarShowDayNames :: (MonadIO m, IsCalendar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-day-names” property. This is rarely needed directly,
--   but it is used by new.
constructCalendarShowDayNames :: (IsCalendar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-details” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get calendar #showDetails
--   
getCalendarShowDetails :: (MonadIO m, IsCalendar o) => o -> m Bool

-- | Set the value of the “show-details” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set calendar [ #showDetails := value ]
--   
setCalendarShowDetails :: (MonadIO m, IsCalendar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-details” property. This is rarely needed directly, but
--   it is used by new.
constructCalendarShowDetails :: (IsCalendar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-heading” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get calendar #showHeading
--   
getCalendarShowHeading :: (MonadIO m, IsCalendar o) => o -> m Bool

-- | Set the value of the “show-heading” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set calendar [ #showHeading := value ]
--   
setCalendarShowHeading :: (MonadIO m, IsCalendar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-heading” property. This is rarely needed directly, but
--   it is used by new.
constructCalendarShowHeading :: (IsCalendar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-week-numbers” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get calendar #showWeekNumbers
--   
getCalendarShowWeekNumbers :: (MonadIO m, IsCalendar o) => o -> m Bool

-- | Set the value of the “show-week-numbers” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set calendar [ #showWeekNumbers := value ]
--   
setCalendarShowWeekNumbers :: (MonadIO m, IsCalendar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-week-numbers” property. This is rarely needed directly,
--   but it is used by new.
constructCalendarShowWeekNumbers :: (IsCalendar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “year” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get calendar #year
--   
getCalendarYear :: (MonadIO m, IsCalendar o) => o -> m Int32

-- | Set the value of the “year” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set calendar [ #year := value ]
--   
setCalendarYear :: (MonadIO m, IsCalendar o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “year” property. This is rarely needed directly, but it is
--   used by new.
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 Calendar.
calendarGetDate :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m (Word32, Word32, Word32)

-- | Returns if the day of the calendar is
--   already marked.
--   
--   Since: 3.0
calendarGetDayIsMarked :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Word32 -> m Bool

-- | Queries the height of detail cells, in rows. See
--   Calendar:detailWidthChars.
--   
--   Since: 2.14
calendarGetDetailHeightRows :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m Int32

-- | Queries the width of detail cells, in characters. See
--   Calendar:detailWidthChars.
--   
--   Since: 2.14
calendarGetDetailWidthChars :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m Int32

-- | Returns the current display options of calendar.
--   
--   Since: 2.4
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
--   Calendar:detailHeightRows.
--   
--   Since: 2.14
calendarSetDetailHeightRows :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Int32 -> m ()

-- | Updates the width of detail cells. See
--   Calendar:detailWidthChars.
--   
--   Since: 2.14
calendarSetDetailWidthChars :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Int32 -> m ()

-- | Sets display options (whether to display the heading and the month
--   headings).
--   
--   Since: 2.4
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 WidgetClass struct initialized to zero.
newZeroWidgetClass :: MonadIO m => m WidgetClass

-- | Get the value of the “parent_class” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #parentClass
--   
getWidgetClassParentClass :: MonadIO m => WidgetClass -> m InitiallyUnownedClass

-- | Get the value of the “activate_signal” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #activateSignal
--   
getWidgetClassActivateSignal :: MonadIO m => WidgetClass -> m Word32

-- | Set the value of the “activate_signal” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #activateSignal := value ]
--   
setWidgetClassActivateSignal :: MonadIO m => WidgetClass -> Word32 -> m ()

-- | Get the value of the “dispatch_child_properties_changed”
--   field. When overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #dispatchChildPropertiesChanged
--   
getWidgetClassDispatchChildPropertiesChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback)

-- | Set the value of the “dispatch_child_properties_changed”
--   field. When overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #dispatchChildPropertiesChanged := value ]
--   
setWidgetClassDispatchChildPropertiesChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback -> m ()

-- | Set the value of the “dispatch_child_properties_changed”
--   field to Nothing. When overloading is enabled, this is
--   equivalent to
--   
--   
--   clear #dispatchChildPropertiesChanged
--   
clearWidgetClassDispatchChildPropertiesChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “destroy” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get widgetClass #destroy
--   
getWidgetClassDestroy :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)

-- | Set the value of the “destroy” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #destroy := value ]
--   
setWidgetClassDestroy :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()

-- | Set the value of the “destroy” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #destroy
--   
clearWidgetClassDestroy :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “show” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get widgetClass #show
--   
getWidgetClassShow :: MonadIO m => WidgetClass -> m (Maybe WidgetClassShowFieldCallback)

-- | Set the value of the “show” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set widgetClass [ #show := value ]
--   
setWidgetClassShow :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()

-- | Set the value of the “show” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #show
--   
clearWidgetClassShow :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “show_all” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #showAll
--   
getWidgetClassShowAll :: MonadIO m => WidgetClass -> m (Maybe WidgetClassShowAllFieldCallback)

-- | Set the value of the “show_all” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #showAll := value ]
--   
setWidgetClassShowAll :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassShowAllFieldCallback -> m ()

-- | Set the value of the “show_all” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #showAll
--   
clearWidgetClassShowAll :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “hide” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get widgetClass #hide
--   
getWidgetClassHide :: MonadIO m => WidgetClass -> m (Maybe WidgetClassHideFieldCallback)

-- | Set the value of the “hide” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set widgetClass [ #hide := value ]
--   
setWidgetClassHide :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassHideFieldCallback -> m ()

-- | Set the value of the “hide” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #hide
--   
clearWidgetClassHide :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “map” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get widgetClass #map
--   
getWidgetClassMap :: MonadIO m => WidgetClass -> m (Maybe WidgetClassMapFieldCallback)

-- | Set the value of the “map” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set widgetClass [ #map := value ]
--   
setWidgetClassMap :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassMapFieldCallback -> m ()

-- | Set the value of the “map” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #map
--   
clearWidgetClassMap :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “unmap” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get widgetClass #unmap
--   
getWidgetClassUnmap :: MonadIO m => WidgetClass -> m (Maybe WidgetClassUnmapFieldCallback)

-- | Set the value of the “unmap” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #unmap := value ]
--   
setWidgetClassUnmap :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassUnmapFieldCallback -> m ()

-- | Set the value of the “unmap” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #unmap
--   
clearWidgetClassUnmap :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “realize” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get widgetClass #realize
--   
getWidgetClassRealize :: MonadIO m => WidgetClass -> m (Maybe WidgetClassRealizeFieldCallback)

-- | Set the value of the “realize” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #realize := value ]
--   
setWidgetClassRealize :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassRealizeFieldCallback -> m ()

-- | Set the value of the “realize” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #realize
--   
clearWidgetClassRealize :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “unrealize” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #unrealize
--   
getWidgetClassUnrealize :: MonadIO m => WidgetClass -> m (Maybe WidgetClassUnrealizeFieldCallback)

-- | Set the value of the “unrealize” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #unrealize := value ]
--   
setWidgetClassUnrealize :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassUnrealizeFieldCallback -> m ()

-- | Set the value of the “unrealize” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #unrealize
--   
clearWidgetClassUnrealize :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “size_allocate” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #sizeAllocate
--   
getWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSizeAllocateFieldCallback)

-- | Set the value of the “size_allocate” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #sizeAllocate := value ]
--   
setWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSizeAllocateFieldCallback -> m ()

-- | Set the value of the “size_allocate” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #sizeAllocate
--   
clearWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “state_changed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #stateChanged
--   
getWidgetClassStateChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassStateChangedFieldCallback)

-- | Set the value of the “state_changed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #stateChanged := value ]
--   
setWidgetClassStateChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassStateChangedFieldCallback -> m ()

-- | Set the value of the “state_changed” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #stateChanged
--   
clearWidgetClassStateChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “state_flags_changed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #stateFlagsChanged
--   
getWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassStateFlagsChangedFieldCallback)

-- | Set the value of the “state_flags_changed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #stateFlagsChanged := value ]
--   
setWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()

-- | Set the value of the “state_flags_changed” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #stateFlagsChanged
--   
clearWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “parent_set” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #parentSet
--   
getWidgetClassParentSet :: MonadIO m => WidgetClass -> m (Maybe WidgetClassParentSetFieldCallback)

-- | Set the value of the “parent_set” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #parentSet := value ]
--   
setWidgetClassParentSet :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassParentSetFieldCallback -> m ()

-- | Set the value of the “parent_set” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #parentSet
--   
clearWidgetClassParentSet :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “hierarchy_changed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #hierarchyChanged
--   
getWidgetClassHierarchyChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassHierarchyChangedFieldCallback)

-- | Set the value of the “hierarchy_changed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #hierarchyChanged := value ]
--   
setWidgetClassHierarchyChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassHierarchyChangedFieldCallback -> m ()

-- | Set the value of the “hierarchy_changed” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #hierarchyChanged
--   
clearWidgetClassHierarchyChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “style_set” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #styleSet
--   
getWidgetClassStyleSet :: MonadIO m => WidgetClass -> m (Maybe WidgetClassStyleSetFieldCallback)

-- | Set the value of the “style_set” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #styleSet := value ]
--   
setWidgetClassStyleSet :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassStyleSetFieldCallback -> m ()

-- | Set the value of the “style_set” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #styleSet
--   
clearWidgetClassStyleSet :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “direction_changed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #directionChanged
--   
getWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDirectionChangedFieldCallback)

-- | Set the value of the “direction_changed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #directionChanged := value ]
--   
setWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDirectionChangedFieldCallback -> m ()

-- | Set the value of the “direction_changed” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #directionChanged
--   
clearWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “grab_notify” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #grabNotify
--   
getWidgetClassGrabNotify :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGrabNotifyFieldCallback)

-- | Set the value of the “grab_notify” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #grabNotify := value ]
--   
setWidgetClassGrabNotify :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGrabNotifyFieldCallback -> m ()

-- | Set the value of the “grab_notify” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #grabNotify
--   
clearWidgetClassGrabNotify :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “child_notify” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #childNotify
--   
getWidgetClassChildNotify :: MonadIO m => WidgetClass -> m (Maybe WidgetClassChildNotifyFieldCallback)

-- | Set the value of the “child_notify” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #childNotify := value ]
--   
setWidgetClassChildNotify :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassChildNotifyFieldCallback -> m ()

-- | Set the value of the “child_notify” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #childNotify
--   
clearWidgetClassChildNotify :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “draw” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get widgetClass #draw
--   
getWidgetClassDraw :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDrawFieldCallback)

-- | Set the value of the “draw” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set widgetClass [ #draw := value ]
--   
setWidgetClassDraw :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDrawFieldCallback -> m ()

-- | Set the value of the “draw” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #draw
--   
clearWidgetClassDraw :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “get_request_mode” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #getRequestMode
--   
getWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetRequestModeFieldCallback)

-- | Set the value of the “get_request_mode” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #getRequestMode := value ]
--   
setWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetRequestModeFieldCallback -> m ()

-- | Set the value of the “get_request_mode” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #getRequestMode
--   
clearWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “get_preferred_height” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #getPreferredHeight
--   
getWidgetClassGetPreferredHeight :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetPreferredHeightFieldCallback)

-- | Set the value of the “get_preferred_height” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #getPreferredHeight := value ]
--   
setWidgetClassGetPreferredHeight :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetPreferredHeightFieldCallback -> m ()

-- | Set the value of the “get_preferred_height” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #getPreferredHeight
--   
clearWidgetClassGetPreferredHeight :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “get_preferred_width_for_height” field.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #getPreferredWidthForHeight
--   
getWidgetClassGetPreferredWidthForHeight :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetPreferredWidthForHeightFieldCallback)

-- | Set the value of the “get_preferred_width_for_height” field.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #getPreferredWidthForHeight := value ]
--   
setWidgetClassGetPreferredWidthForHeight :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback -> m ()

-- | Set the value of the “get_preferred_width_for_height” field
--   to Nothing. When overloading is enabled, this is
--   equivalent to
--   
--   
--   clear #getPreferredWidthForHeight
--   
clearWidgetClassGetPreferredWidthForHeight :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “get_preferred_width” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #getPreferredWidth
--   
getWidgetClassGetPreferredWidth :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetPreferredWidthFieldCallback)

-- | Set the value of the “get_preferred_width” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #getPreferredWidth := value ]
--   
setWidgetClassGetPreferredWidth :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetPreferredWidthFieldCallback -> m ()

-- | Set the value of the “get_preferred_width” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #getPreferredWidth
--   
clearWidgetClassGetPreferredWidth :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “get_preferred_height_for_width” field.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #getPreferredHeightForWidth
--   
getWidgetClassGetPreferredHeightForWidth :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetPreferredHeightForWidthFieldCallback)

-- | Set the value of the “get_preferred_height_for_width” field.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #getPreferredHeightForWidth := value ]
--   
setWidgetClassGetPreferredHeightForWidth :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback -> m ()

-- | Set the value of the “get_preferred_height_for_width” field
--   to Nothing. When overloading is enabled, this is
--   equivalent to
--   
--   
--   clear #getPreferredHeightForWidth
--   
clearWidgetClassGetPreferredHeightForWidth :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “mnemonic_activate” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #mnemonicActivate
--   
getWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> m (Maybe WidgetClassMnemonicActivateFieldCallback)

-- | Set the value of the “mnemonic_activate” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #mnemonicActivate := value ]
--   
setWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> m ()

-- | Set the value of the “mnemonic_activate” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #mnemonicActivate
--   
clearWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “grab_focus” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #grabFocus
--   
getWidgetClassGrabFocus :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGrabFocusFieldCallback)

-- | Set the value of the “grab_focus” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #grabFocus := value ]
--   
setWidgetClassGrabFocus :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGrabFocusFieldCallback -> m ()

-- | Set the value of the “grab_focus” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #grabFocus
--   
clearWidgetClassGrabFocus :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “focus” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get widgetClass #focus
--   
getWidgetClassFocus :: MonadIO m => WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)

-- | Set the value of the “focus” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #focus := value ]
--   
setWidgetClassFocus :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()

-- | Set the value of the “focus” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #focus
--   
clearWidgetClassFocus :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “move_focus” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #moveFocus
--   
getWidgetClassMoveFocus :: MonadIO m => WidgetClass -> m (Maybe WidgetClassMoveFocusFieldCallback)

-- | Set the value of the “move_focus” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #moveFocus := value ]
--   
setWidgetClassMoveFocus :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassMoveFocusFieldCallback -> m ()

-- | Set the value of the “move_focus” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #moveFocus
--   
clearWidgetClassMoveFocus :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “keynav_failed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #keynavFailed
--   
getWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> m (Maybe WidgetClassKeynavFailedFieldCallback)

-- | Set the value of the “keynav_failed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #keynavFailed := value ]
--   
setWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassKeynavFailedFieldCallback -> m ()

-- | Set the value of the “keynav_failed” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #keynavFailed
--   
clearWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “event” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get widgetClass #event
--   
getWidgetClassEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassEventFieldCallback)

-- | Set the value of the “event” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #event := value ]
--   
setWidgetClassEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassEventFieldCallback -> m ()

-- | Set the value of the “event” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #event
--   
clearWidgetClassEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “button_press_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #buttonPressEvent
--   
getWidgetClassButtonPressEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassButtonPressEventFieldCallback)

-- | Set the value of the “button_press_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #buttonPressEvent := value ]
--   
setWidgetClassButtonPressEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassButtonPressEventFieldCallback -> m ()

-- | Set the value of the “button_press_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #buttonPressEvent
--   
clearWidgetClassButtonPressEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “button_release_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #buttonReleaseEvent
--   
getWidgetClassButtonReleaseEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassButtonReleaseEventFieldCallback)

-- | Set the value of the “button_release_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #buttonReleaseEvent := value ]
--   
setWidgetClassButtonReleaseEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassButtonReleaseEventFieldCallback -> m ()

-- | Set the value of the “button_release_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #buttonReleaseEvent
--   
clearWidgetClassButtonReleaseEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “scroll_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #scrollEvent
--   
getWidgetClassScrollEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassScrollEventFieldCallback)

-- | Set the value of the “scroll_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #scrollEvent := value ]
--   
setWidgetClassScrollEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassScrollEventFieldCallback -> m ()

-- | Set the value of the “scroll_event” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #scrollEvent
--   
clearWidgetClassScrollEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “motion_notify_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #motionNotifyEvent
--   
getWidgetClassMotionNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassMotionNotifyEventFieldCallback)

-- | Set the value of the “motion_notify_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #motionNotifyEvent := value ]
--   
setWidgetClassMotionNotifyEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassMotionNotifyEventFieldCallback -> m ()

-- | Set the value of the “motion_notify_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #motionNotifyEvent
--   
clearWidgetClassMotionNotifyEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “delete_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #deleteEvent
--   
getWidgetClassDeleteEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDeleteEventFieldCallback)

-- | Set the value of the “delete_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #deleteEvent := value ]
--   
setWidgetClassDeleteEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDeleteEventFieldCallback -> m ()

-- | Set the value of the “delete_event” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #deleteEvent
--   
clearWidgetClassDeleteEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “destroy_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #destroyEvent
--   
getWidgetClassDestroyEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDestroyEventFieldCallback)

-- | Set the value of the “destroy_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #destroyEvent := value ]
--   
setWidgetClassDestroyEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDestroyEventFieldCallback -> m ()

-- | Set the value of the “destroy_event” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #destroyEvent
--   
clearWidgetClassDestroyEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “key_press_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #keyPressEvent
--   
getWidgetClassKeyPressEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassKeyPressEventFieldCallback)

-- | Set the value of the “key_press_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #keyPressEvent := value ]
--   
setWidgetClassKeyPressEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassKeyPressEventFieldCallback -> m ()

-- | Set the value of the “key_press_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #keyPressEvent
--   
clearWidgetClassKeyPressEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “key_release_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #keyReleaseEvent
--   
getWidgetClassKeyReleaseEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassKeyReleaseEventFieldCallback)

-- | Set the value of the “key_release_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #keyReleaseEvent := value ]
--   
setWidgetClassKeyReleaseEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassKeyReleaseEventFieldCallback -> m ()

-- | Set the value of the “key_release_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #keyReleaseEvent
--   
clearWidgetClassKeyReleaseEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “enter_notify_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #enterNotifyEvent
--   
getWidgetClassEnterNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassEnterNotifyEventFieldCallback)

-- | Set the value of the “enter_notify_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #enterNotifyEvent := value ]
--   
setWidgetClassEnterNotifyEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassEnterNotifyEventFieldCallback -> m ()

-- | Set the value of the “enter_notify_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #enterNotifyEvent
--   
clearWidgetClassEnterNotifyEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “leave_notify_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #leaveNotifyEvent
--   
getWidgetClassLeaveNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassLeaveNotifyEventFieldCallback)

-- | Set the value of the “leave_notify_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #leaveNotifyEvent := value ]
--   
setWidgetClassLeaveNotifyEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassLeaveNotifyEventFieldCallback -> m ()

-- | Set the value of the “leave_notify_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #leaveNotifyEvent
--   
clearWidgetClassLeaveNotifyEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “configure_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #configureEvent
--   
getWidgetClassConfigureEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassConfigureEventFieldCallback)

-- | Set the value of the “configure_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #configureEvent := value ]
--   
setWidgetClassConfigureEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassConfigureEventFieldCallback -> m ()

-- | Set the value of the “configure_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #configureEvent
--   
clearWidgetClassConfigureEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “focus_in_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #focusInEvent
--   
getWidgetClassFocusInEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassFocusInEventFieldCallback)

-- | Set the value of the “focus_in_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #focusInEvent := value ]
--   
setWidgetClassFocusInEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassFocusInEventFieldCallback -> m ()

-- | Set the value of the “focus_in_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #focusInEvent
--   
clearWidgetClassFocusInEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “focus_out_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #focusOutEvent
--   
getWidgetClassFocusOutEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassFocusOutEventFieldCallback)

-- | Set the value of the “focus_out_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #focusOutEvent := value ]
--   
setWidgetClassFocusOutEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassFocusOutEventFieldCallback -> m ()

-- | Set the value of the “focus_out_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #focusOutEvent
--   
clearWidgetClassFocusOutEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “map_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #mapEvent
--   
getWidgetClassMapEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassMapEventFieldCallback)

-- | Set the value of the “map_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #mapEvent := value ]
--   
setWidgetClassMapEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassMapEventFieldCallback -> m ()

-- | Set the value of the “map_event” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #mapEvent
--   
clearWidgetClassMapEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “unmap_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #unmapEvent
--   
getWidgetClassUnmapEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassUnmapEventFieldCallback)

-- | Set the value of the “unmap_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #unmapEvent := value ]
--   
setWidgetClassUnmapEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassUnmapEventFieldCallback -> m ()

-- | Set the value of the “unmap_event” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #unmapEvent
--   
clearWidgetClassUnmapEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “property_notify_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #propertyNotifyEvent
--   
getWidgetClassPropertyNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassPropertyNotifyEventFieldCallback)

-- | Set the value of the “property_notify_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #propertyNotifyEvent := value ]
--   
setWidgetClassPropertyNotifyEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassPropertyNotifyEventFieldCallback -> m ()

-- | Set the value of the “property_notify_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #propertyNotifyEvent
--   
clearWidgetClassPropertyNotifyEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “selection_clear_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #selectionClearEvent
--   
getWidgetClassSelectionClearEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSelectionClearEventFieldCallback)

-- | Set the value of the “selection_clear_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #selectionClearEvent := value ]
--   
setWidgetClassSelectionClearEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSelectionClearEventFieldCallback -> m ()

-- | Set the value of the “selection_clear_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #selectionClearEvent
--   
clearWidgetClassSelectionClearEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “selection_request_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #selectionRequestEvent
--   
getWidgetClassSelectionRequestEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSelectionRequestEventFieldCallback)

-- | Set the value of the “selection_request_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #selectionRequestEvent := value ]
--   
setWidgetClassSelectionRequestEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSelectionRequestEventFieldCallback -> m ()

-- | Set the value of the “selection_request_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #selectionRequestEvent
--   
clearWidgetClassSelectionRequestEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “selection_notify_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #selectionNotifyEvent
--   
getWidgetClassSelectionNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSelectionNotifyEventFieldCallback)

-- | Set the value of the “selection_notify_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #selectionNotifyEvent := value ]
--   
setWidgetClassSelectionNotifyEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSelectionNotifyEventFieldCallback -> m ()

-- | Set the value of the “selection_notify_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #selectionNotifyEvent
--   
clearWidgetClassSelectionNotifyEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “proximity_in_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #proximityInEvent
--   
getWidgetClassProximityInEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassProximityInEventFieldCallback)

-- | Set the value of the “proximity_in_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #proximityInEvent := value ]
--   
setWidgetClassProximityInEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassProximityInEventFieldCallback -> m ()

-- | Set the value of the “proximity_in_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #proximityInEvent
--   
clearWidgetClassProximityInEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “proximity_out_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #proximityOutEvent
--   
getWidgetClassProximityOutEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassProximityOutEventFieldCallback)

-- | Set the value of the “proximity_out_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #proximityOutEvent := value ]
--   
setWidgetClassProximityOutEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassProximityOutEventFieldCallback -> m ()

-- | Set the value of the “proximity_out_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #proximityOutEvent
--   
clearWidgetClassProximityOutEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “visibility_notify_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #visibilityNotifyEvent
--   
getWidgetClassVisibilityNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassVisibilityNotifyEventFieldCallback)

-- | Set the value of the “visibility_notify_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #visibilityNotifyEvent := value ]
--   
setWidgetClassVisibilityNotifyEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback -> m ()

-- | Set the value of the “visibility_notify_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #visibilityNotifyEvent
--   
clearWidgetClassVisibilityNotifyEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “window_state_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #windowStateEvent
--   
getWidgetClassWindowStateEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassWindowStateEventFieldCallback)

-- | Set the value of the “window_state_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #windowStateEvent := value ]
--   
setWidgetClassWindowStateEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassWindowStateEventFieldCallback -> m ()

-- | Set the value of the “window_state_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #windowStateEvent
--   
clearWidgetClassWindowStateEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “damage_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #damageEvent
--   
getWidgetClassDamageEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDamageEventFieldCallback)

-- | Set the value of the “damage_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #damageEvent := value ]
--   
setWidgetClassDamageEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDamageEventFieldCallback -> m ()

-- | Set the value of the “damage_event” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #damageEvent
--   
clearWidgetClassDamageEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “grab_broken_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #grabBrokenEvent
--   
getWidgetClassGrabBrokenEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGrabBrokenEventFieldCallback)

-- | Set the value of the “grab_broken_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #grabBrokenEvent := value ]
--   
setWidgetClassGrabBrokenEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGrabBrokenEventFieldCallback -> m ()

-- | Set the value of the “grab_broken_event” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #grabBrokenEvent
--   
clearWidgetClassGrabBrokenEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “selection_get” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #selectionGet
--   
getWidgetClassSelectionGet :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSelectionGetFieldCallback)

-- | Set the value of the “selection_get” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #selectionGet := value ]
--   
setWidgetClassSelectionGet :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSelectionGetFieldCallback -> m ()

-- | Set the value of the “selection_get” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #selectionGet
--   
clearWidgetClassSelectionGet :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “selection_received” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #selectionReceived
--   
getWidgetClassSelectionReceived :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSelectionReceivedFieldCallback)

-- | Set the value of the “selection_received” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #selectionReceived := value ]
--   
setWidgetClassSelectionReceived :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSelectionReceivedFieldCallback -> m ()

-- | Set the value of the “selection_received” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #selectionReceived
--   
clearWidgetClassSelectionReceived :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “drag_begin” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #dragBegin
--   
getWidgetClassDragBegin :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragBeginFieldCallback)

-- | Set the value of the “drag_begin” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #dragBegin := value ]
--   
setWidgetClassDragBegin :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragBeginFieldCallback -> m ()

-- | Set the value of the “drag_begin” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #dragBegin
--   
clearWidgetClassDragBegin :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “drag_end” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #dragEnd
--   
getWidgetClassDragEnd :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragEndFieldCallback)

-- | Set the value of the “drag_end” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #dragEnd := value ]
--   
setWidgetClassDragEnd :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragEndFieldCallback -> m ()

-- | Set the value of the “drag_end” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #dragEnd
--   
clearWidgetClassDragEnd :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “drag_data_get” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #dragDataGet
--   
getWidgetClassDragDataGet :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragDataGetFieldCallback)

-- | Set the value of the “drag_data_get” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #dragDataGet := value ]
--   
setWidgetClassDragDataGet :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragDataGetFieldCallback -> m ()

-- | Set the value of the “drag_data_get” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #dragDataGet
--   
clearWidgetClassDragDataGet :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “drag_data_delete” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #dragDataDelete
--   
getWidgetClassDragDataDelete :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragDataDeleteFieldCallback)

-- | Set the value of the “drag_data_delete” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #dragDataDelete := value ]
--   
setWidgetClassDragDataDelete :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragDataDeleteFieldCallback -> m ()

-- | Set the value of the “drag_data_delete” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #dragDataDelete
--   
clearWidgetClassDragDataDelete :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “drag_leave” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #dragLeave
--   
getWidgetClassDragLeave :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragLeaveFieldCallback)

-- | Set the value of the “drag_leave” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #dragLeave := value ]
--   
setWidgetClassDragLeave :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragLeaveFieldCallback -> m ()

-- | Set the value of the “drag_leave” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #dragLeave
--   
clearWidgetClassDragLeave :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “drag_motion” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #dragMotion
--   
getWidgetClassDragMotion :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragMotionFieldCallback)

-- | Set the value of the “drag_motion” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #dragMotion := value ]
--   
setWidgetClassDragMotion :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragMotionFieldCallback -> m ()

-- | Set the value of the “drag_motion” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #dragMotion
--   
clearWidgetClassDragMotion :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “drag_drop” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #dragDrop
--   
getWidgetClassDragDrop :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragDropFieldCallback)

-- | Set the value of the “drag_drop” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #dragDrop := value ]
--   
setWidgetClassDragDrop :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragDropFieldCallback -> m ()

-- | Set the value of the “drag_drop” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #dragDrop
--   
clearWidgetClassDragDrop :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “drag_data_received” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #dragDataReceived
--   
getWidgetClassDragDataReceived :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragDataReceivedFieldCallback)

-- | Set the value of the “drag_data_received” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #dragDataReceived := value ]
--   
setWidgetClassDragDataReceived :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragDataReceivedFieldCallback -> m ()

-- | Set the value of the “drag_data_received” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #dragDataReceived
--   
clearWidgetClassDragDataReceived :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “drag_failed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #dragFailed
--   
getWidgetClassDragFailed :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragFailedFieldCallback)

-- | Set the value of the “drag_failed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #dragFailed := value ]
--   
setWidgetClassDragFailed :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragFailedFieldCallback -> m ()

-- | Set the value of the “drag_failed” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #dragFailed
--   
clearWidgetClassDragFailed :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “popup_menu” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #popupMenu
--   
getWidgetClassPopupMenu :: MonadIO m => WidgetClass -> m (Maybe WidgetClassPopupMenuFieldCallback)

-- | Set the value of the “popup_menu” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #popupMenu := value ]
--   
setWidgetClassPopupMenu :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassPopupMenuFieldCallback -> m ()

-- | Set the value of the “popup_menu” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #popupMenu
--   
clearWidgetClassPopupMenu :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “show_help” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #showHelp
--   
getWidgetClassShowHelp :: MonadIO m => WidgetClass -> m (Maybe WidgetClassShowHelpFieldCallback)

-- | Set the value of the “show_help” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #showHelp := value ]
--   
setWidgetClassShowHelp :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassShowHelpFieldCallback -> m ()

-- | Set the value of the “show_help” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #showHelp
--   
clearWidgetClassShowHelp :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “get_accessible” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #getAccessible
--   
getWidgetClassGetAccessible :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetAccessibleFieldCallback)

-- | Set the value of the “get_accessible” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #getAccessible := value ]
--   
setWidgetClassGetAccessible :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetAccessibleFieldCallback -> m ()

-- | Set the value of the “get_accessible” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #getAccessible
--   
clearWidgetClassGetAccessible :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “screen_changed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #screenChanged
--   
getWidgetClassScreenChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassScreenChangedFieldCallback)

-- | Set the value of the “screen_changed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #screenChanged := value ]
--   
setWidgetClassScreenChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassScreenChangedFieldCallback -> m ()

-- | Set the value of the “screen_changed” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #screenChanged
--   
clearWidgetClassScreenChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “can_activate_accel” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #canActivateAccel
--   
getWidgetClassCanActivateAccel :: MonadIO m => WidgetClass -> m (Maybe WidgetClassCanActivateAccelFieldCallback)

-- | Set the value of the “can_activate_accel” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #canActivateAccel := value ]
--   
setWidgetClassCanActivateAccel :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassCanActivateAccelFieldCallback -> m ()

-- | Set the value of the “can_activate_accel” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #canActivateAccel
--   
clearWidgetClassCanActivateAccel :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “composited_changed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #compositedChanged
--   
getWidgetClassCompositedChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassCompositedChangedFieldCallback)

-- | Set the value of the “composited_changed” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #compositedChanged := value ]
--   
setWidgetClassCompositedChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassCompositedChangedFieldCallback -> m ()

-- | Set the value of the “composited_changed” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #compositedChanged
--   
clearWidgetClassCompositedChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “query_tooltip” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #queryTooltip
--   
getWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> m (Maybe WidgetClassQueryTooltipFieldCallback)

-- | Set the value of the “query_tooltip” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #queryTooltip := value ]
--   
setWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassQueryTooltipFieldCallback -> m ()

-- | Set the value of the “query_tooltip” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #queryTooltip
--   
clearWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “compute_expand” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #computeExpand
--   
getWidgetClassComputeExpand :: MonadIO m => WidgetClass -> m (Maybe WidgetClassComputeExpandFieldCallback)

-- | Set the value of the “compute_expand” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #computeExpand := value ]
--   
setWidgetClassComputeExpand :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassComputeExpandFieldCallback -> m ()

-- | Set the value of the “compute_expand” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #computeExpand
--   
clearWidgetClassComputeExpand :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “adjust_size_request” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #adjustSizeRequest
--   
getWidgetClassAdjustSizeRequest :: MonadIO m => WidgetClass -> m (Maybe WidgetClassAdjustSizeRequestFieldCallback)

-- | Set the value of the “adjust_size_request” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #adjustSizeRequest := value ]
--   
setWidgetClassAdjustSizeRequest :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassAdjustSizeRequestFieldCallback -> m ()

-- | Set the value of the “adjust_size_request” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #adjustSizeRequest
--   
clearWidgetClassAdjustSizeRequest :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “adjust_size_allocation” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #adjustSizeAllocation
--   
getWidgetClassAdjustSizeAllocation :: MonadIO m => WidgetClass -> m (Maybe WidgetClassAdjustSizeAllocationFieldCallback)

-- | Set the value of the “adjust_size_allocation” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #adjustSizeAllocation := value ]
--   
setWidgetClassAdjustSizeAllocation :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback -> m ()

-- | Set the value of the “adjust_size_allocation” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #adjustSizeAllocation
--   
clearWidgetClassAdjustSizeAllocation :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “style_updated” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #styleUpdated
--   
getWidgetClassStyleUpdated :: MonadIO m => WidgetClass -> m (Maybe WidgetClassStyleUpdatedFieldCallback)

-- | Set the value of the “style_updated” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #styleUpdated := value ]
--   
setWidgetClassStyleUpdated :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassStyleUpdatedFieldCallback -> m ()

-- | Set the value of the “style_updated” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #styleUpdated
--   
clearWidgetClassStyleUpdated :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “touch_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #touchEvent
--   
getWidgetClassTouchEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassTouchEventFieldCallback)

-- | Set the value of the “touch_event” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #touchEvent := value ]
--   
setWidgetClassTouchEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassTouchEventFieldCallback -> m ()

-- | Set the value of the “touch_event” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #touchEvent
--   
clearWidgetClassTouchEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the
--   “get_preferred_height_and_baseline_for_width” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #getPreferredHeightAndBaselineForWidth
--   
getWidgetClassGetPreferredHeightAndBaselineForWidth :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)

-- | Set the value of the
--   “get_preferred_height_and_baseline_for_width” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #getPreferredHeightAndBaselineForWidth := value ]
--   
setWidgetClassGetPreferredHeightAndBaselineForWidth :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> m ()

-- | Set the value of the
--   “get_preferred_height_and_baseline_for_width” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #getPreferredHeightAndBaselineForWidth
--   
clearWidgetClassGetPreferredHeightAndBaselineForWidth :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “adjust_baseline_request” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #adjustBaselineRequest
--   
getWidgetClassAdjustBaselineRequest :: MonadIO m => WidgetClass -> m (Maybe WidgetClassAdjustBaselineRequestFieldCallback)

-- | Set the value of the “adjust_baseline_request” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #adjustBaselineRequest := value ]
--   
setWidgetClassAdjustBaselineRequest :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback -> m ()

-- | Set the value of the “adjust_baseline_request” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #adjustBaselineRequest
--   
clearWidgetClassAdjustBaselineRequest :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “adjust_baseline_allocation” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #adjustBaselineAllocation
--   
getWidgetClassAdjustBaselineAllocation :: MonadIO m => WidgetClass -> m (Maybe WidgetClassAdjustBaselineAllocationFieldCallback)

-- | Set the value of the “adjust_baseline_allocation” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #adjustBaselineAllocation := value ]
--   
setWidgetClassAdjustBaselineAllocation :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback -> m ()

-- | Set the value of the “adjust_baseline_allocation” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #adjustBaselineAllocation
--   
clearWidgetClassAdjustBaselineAllocation :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “queue_draw_region” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get widgetClass #queueDrawRegion
--   
getWidgetClassQueueDrawRegion :: MonadIO m => WidgetClass -> m (Maybe WidgetClassQueueDrawRegionFieldCallback)

-- | Set the value of the “queue_draw_region” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set widgetClass [ #queueDrawRegion := value ]
--   
setWidgetClassQueueDrawRegion :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassQueueDrawRegionFieldCallback -> m ()

-- | Set the value of the “queue_draw_region” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #queueDrawRegion
--   
clearWidgetClassQueueDrawRegion :: MonadIO m => WidgetClass -> m ()

-- | Declares a callbackSymbol to handle
--   callbackName from the template XML defined for
--   widgetType. See builderAddCallbackSymbol.
--   
--   Note that this must be called from a composite widget classes class
--   initializer after calling widgetClassSetTemplate.
--   
--   Since: 3.10
widgetClassBindTemplateCallbackFull :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> Callback -> m ()

-- | Finds a style property of a widget class by name.
--   
--   Since: 2.2
widgetClassFindStyleProperty :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> m GParamSpec

-- | Gets the name used by this class for matching in CSS code. See
--   widgetClassSetCssName for details.
--   
--   Since: 3.20
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 pspec.
widgetClassInstallStyleProperty :: (HasCallStack, MonadIO m) => WidgetClass -> GParamSpec -> m ()

-- | Sets the default Role to be set on accessibles created for
--   widgets of widgetClass. Accessibles may decide to not
--   honor this setting if their role reporting is more refined. Calls to
--   widgetClassSetAccessibleType will reset this value.
--   
--   In cases where you want more fine-grained control over the role of
--   accessibles created for widgetClass, you should
--   provide your own accessible type and use
--   widgetClassSetAccessibleType instead.
--   
--   If role is ATK_ROLE_INVALID, 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.
--   
--   Since: 3.2
widgetClassSetAccessibleRole :: (HasCallStack, MonadIO m) => WidgetClass -> Role -> m ()

-- | For use in language bindings, this will override the default
--   BuilderConnectFunc 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 widgetClassSetTemplate.
--   
--   Since: 3.10
widgetClassSetConnectFunc :: (HasCallStack, MonadIO m) => WidgetClass -> BuilderConnectFunc -> m ()

-- | Construct a ContainerClass struct initialized to zero.
newZeroContainerClass :: MonadIO m => m ContainerClass

-- | Get the value of the “parent_class” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get containerClass #parentClass
--   
getContainerClassParentClass :: MonadIO m => ContainerClass -> m WidgetClass

-- | Get the value of the “add” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get containerClass #add
--   
getContainerClassAdd :: MonadIO m => ContainerClass -> m (Maybe ContainerClassAddFieldCallback)

-- | Set the value of the “add” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set containerClass [ #add := value ]
--   
setContainerClassAdd :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassAddFieldCallback -> m ()

-- | Set the value of the “add” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #add
--   
clearContainerClassAdd :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “remove” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get containerClass #remove
--   
getContainerClassRemove :: MonadIO m => ContainerClass -> m (Maybe ContainerClassRemoveFieldCallback)

-- | Set the value of the “remove” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set containerClass [ #remove := value ]
--   
setContainerClassRemove :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassRemoveFieldCallback -> m ()

-- | Set the value of the “remove” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #remove
--   
clearContainerClassRemove :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “check_resize” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get containerClass #checkResize
--   
getContainerClassCheckResize :: MonadIO m => ContainerClass -> m (Maybe ContainerClassCheckResizeFieldCallback)

-- | Set the value of the “check_resize” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set containerClass [ #checkResize := value ]
--   
setContainerClassCheckResize :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassCheckResizeFieldCallback -> m ()

-- | Set the value of the “check_resize” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #checkResize
--   
clearContainerClassCheckResize :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “forall” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get containerClass #forall
--   
getContainerClassForall :: MonadIO m => ContainerClass -> m (Maybe ContainerClassForallFieldCallback_WithClosures)

-- | Set the value of the “forall” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set containerClass [ #forall := value ]
--   
setContainerClassForall :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassForallFieldCallback -> m ()

-- | Set the value of the “forall” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #forall
--   
clearContainerClassForall :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “set_focus_child” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get containerClass #setFocusChild
--   
getContainerClassSetFocusChild :: MonadIO m => ContainerClass -> m (Maybe ContainerClassSetFocusChildFieldCallback)

-- | Set the value of the “set_focus_child” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set containerClass [ #setFocusChild := value ]
--   
setContainerClassSetFocusChild :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassSetFocusChildFieldCallback -> m ()

-- | Set the value of the “set_focus_child” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #setFocusChild
--   
clearContainerClassSetFocusChild :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “child_type” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get containerClass #childType
--   
getContainerClassChildType :: MonadIO m => ContainerClass -> m (Maybe ContainerClassChildTypeFieldCallback)

-- | Set the value of the “child_type” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set containerClass [ #childType := value ]
--   
setContainerClassChildType :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassChildTypeFieldCallback -> m ()

-- | Set the value of the “child_type” field to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #childType
--   
clearContainerClassChildType :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “composite_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get containerClass #compositeName
--   
getContainerClassCompositeName :: MonadIO m => ContainerClass -> m (Maybe ContainerClassCompositeNameFieldCallback)

-- | Set the value of the “composite_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set containerClass [ #compositeName := value ]
--   
setContainerClassCompositeName :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassCompositeNameFieldCallback -> m ()

-- | Set the value of the “composite_name” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #compositeName
--   
clearContainerClassCompositeName :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “set_child_property” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get containerClass #setChildProperty
--   
getContainerClassSetChildProperty :: MonadIO m => ContainerClass -> m (Maybe ContainerClassSetChildPropertyFieldCallback)

-- | Set the value of the “set_child_property” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set containerClass [ #setChildProperty := value ]
--   
setContainerClassSetChildProperty :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassSetChildPropertyFieldCallback -> m ()

-- | Set the value of the “set_child_property” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #setChildProperty
--   
clearContainerClassSetChildProperty :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “get_child_property” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get containerClass #getChildProperty
--   
getContainerClassGetChildProperty :: MonadIO m => ContainerClass -> m (Maybe ContainerClassGetChildPropertyFieldCallback)

-- | Set the value of the “get_child_property” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set containerClass [ #getChildProperty := value ]
--   
setContainerClassGetChildProperty :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassGetChildPropertyFieldCallback -> m ()

-- | Set the value of the “get_child_property” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #getChildProperty
--   
clearContainerClassGetChildProperty :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “get_path_for_child” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get containerClass #getPathForChild
--   
getContainerClassGetPathForChild :: MonadIO m => ContainerClass -> m (Maybe ContainerClassGetPathForChildFieldCallback)

-- | Set the value of the “get_path_for_child” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set containerClass [ #getPathForChild := value ]
--   
setContainerClassGetPathForChild :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassGetPathForChildFieldCallback -> m ()

-- | Set the value of the “get_path_for_child” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #getPathForChild
--   
clearContainerClassGetPathForChild :: MonadIO m => ContainerClass -> m ()

-- | Finds a child property of a container class by name.
containerClassFindChildProperty :: (HasCallStack, MonadIO m) => ContainerClass -> Text -> m (Maybe GParamSpec)

-- | Installs a child property on a container class.
containerClassInstallChildProperty :: (HasCallStack, MonadIO m) => ContainerClass -> Word32 -> GParamSpec -> m ()

-- | Memory-managed wrapper type.
newtype ActionableInterface
ActionableInterface :: ManagedPtr ActionableInterface -> ActionableInterface

-- | Construct a ActionableInterface struct initialized to zero.
newZeroActionableInterface :: MonadIO m => m ActionableInterface

-- | Get the value of the “get_action_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get actionableInterface #getActionName
--   
getActionableInterfaceGetActionName :: MonadIO m => ActionableInterface -> m (Maybe ActionableInterfaceGetActionNameFieldCallback)

-- | Set the value of the “get_action_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set actionableInterface [ #getActionName := value ]
--   
setActionableInterfaceGetActionName :: MonadIO m => ActionableInterface -> FunPtr C_ActionableInterfaceGetActionNameFieldCallback -> m ()

-- | Set the value of the “get_action_name” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #getActionName
--   
clearActionableInterfaceGetActionName :: MonadIO m => ActionableInterface -> m ()

-- | Get the value of the “set_action_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get actionableInterface #setActionName
--   
getActionableInterfaceSetActionName :: MonadIO m => ActionableInterface -> m (Maybe ActionableInterfaceSetActionNameFieldCallback)

-- | Set the value of the “set_action_name” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set actionableInterface [ #setActionName := value ]
--   
setActionableInterfaceSetActionName :: MonadIO m => ActionableInterface -> FunPtr C_ActionableInterfaceSetActionNameFieldCallback -> m ()

-- | Set the value of the “set_action_name” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #setActionName
--   
clearActionableInterfaceSetActionName :: MonadIO m => ActionableInterface -> m ()

-- | Get the value of the “get_action_target_value” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get actionableInterface #getActionTargetValue
--   
getActionableInterfaceGetActionTargetValue :: MonadIO m => ActionableInterface -> m (Maybe ActionableInterfaceGetActionTargetValueFieldCallback)

-- | Set the value of the “get_action_target_value” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set actionableInterface [ #getActionTargetValue := value ]
--   
setActionableInterfaceGetActionTargetValue :: MonadIO m => ActionableInterface -> FunPtr C_ActionableInterfaceGetActionTargetValueFieldCallback -> m ()

-- | Set the value of the “get_action_target_value” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #getActionTargetValue
--   
clearActionableInterfaceGetActionTargetValue :: MonadIO m => ActionableInterface -> m ()

-- | Get the value of the “set_action_target_value” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get actionableInterface #setActionTargetValue
--   
getActionableInterfaceSetActionTargetValue :: MonadIO m => ActionableInterface -> m (Maybe ActionableInterfaceSetActionTargetValueFieldCallback)

-- | Set the value of the “set_action_target_value” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set actionableInterface [ #setActionTargetValue := value ]
--   
setActionableInterfaceSetActionTargetValue :: MonadIO m => ActionableInterface -> FunPtr C_ActionableInterfaceSetActionTargetValueFieldCallback -> m ()

-- | Set the value of the “set_action_target_value” field to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #setActionTargetValue
--   
clearActionableInterfaceSetActionTargetValue :: MonadIO m => ActionableInterface -> m ()

-- | Type class for types which can be safely cast to PrintSettings,
--   for instance with toPrintSettings.
class (GObject o, IsDescendantOf PrintSettings o) => IsPrintSettings o

-- | Cast to PrintSettings, for types for which this is known to be
--   safe. For general casts, use castTo.
toPrintSettings :: (MonadIO m, IsPrintSettings o) => o -> m PrintSettings

-- | Creates a new PrintSettings object.
--   
--   Since: 2.10
printSettingsNew :: (HasCallStack, MonadIO m) => m PrintSettings

-- | Reads the print settings from fileName. Returns a new
--   PrintSettings object with the restored settings, or
--   Nothing if an error occurred. If the file could not be loaded
--   then error is set to either a FileError or KeyFileError.
--   See printSettingsToFile.
--   
--   Since: 2.12
printSettingsNewFromFile :: (HasCallStack, MonadIO m) => [Char] -> m PrintSettings

-- | Deserialize print settings from an a{sv} variant in the format
--   produced by printSettingsToGvariant.
--   
--   Since: 3.22
printSettingsNewFromGvariant :: (HasCallStack, MonadIO m) => GVariant -> m PrintSettings

-- | Reads the print settings from the group groupName in
--   keyFile. Returns a new PrintSettings object
--   with the restored settings, or Nothing if an error occurred. If
--   the file could not be loaded then error is set to either a
--   FileError or KeyFileError.
--   
--   Since: 2.12
printSettingsNewFromKeyFile :: (HasCallStack, MonadIO m) => KeyFile -> Maybe Text -> m PrintSettings

-- | Copies a PrintSettings object.
--   
--   Since: 2.10
printSettingsCopy :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PrintSettings

-- | Calls func for each key-value pair of
--   settings.
--   
--   Since: 2.10
printSettingsForeach :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PrintSettingsFunc -> m ()

-- | Looks up the string value associated with key.
--   
--   Since: 2.10
printSettingsGet :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m Text

-- | Returns the boolean represented by the value that is associated with
--   key.
--   
--   The string “true” represents True, any other string
--   False.
--   
--   Since: 2.10
printSettingsGetBool :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m Bool

-- | Gets the value of PRINT_SETTINGS_COLLATE.
--   
--   Since: 2.10
printSettingsGetCollate :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Bool

-- | Gets the value of PRINT_SETTINGS_DEFAULT_SOURCE.
--   
--   Since: 2.10
printSettingsGetDefaultSource :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Text

-- | Gets the value of PRINT_SETTINGS_DITHER.
--   
--   Since: 2.10
printSettingsGetDither :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Text

-- | Returns the double value associated with key, or 0.
--   
--   Since: 2.10
printSettingsGetDouble :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m Double

-- | Returns the floating point number represented by the value that is
--   associated with key, or defaultVal if
--   the value does not represent a floating point number.
--   
--   Floating point numbers are parsed with asciiStrtod.
--   
--   Since: 2.10
printSettingsGetDoubleWithDefault :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Double -> m Double

-- | Gets the value of PRINT_SETTINGS_DUPLEX.
--   
--   Since: 2.10
printSettingsGetDuplex :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PrintDuplex

-- | Gets the value of PRINT_SETTINGS_FINISHINGS.
--   
--   Since: 2.10
printSettingsGetFinishings :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Text

-- | Returns the integer value of key, or 0.
--   
--   Since: 2.10
printSettingsGetInt :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m Int32

-- | Returns the value of key, interpreted as an integer,
--   or the default value.
--   
--   Since: 2.10
printSettingsGetIntWithDefault :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Int32 -> m Int32

-- | Returns the value associated with key, interpreted as
--   a length. The returned value is converted to units.
--   
--   Since: 2.10
printSettingsGetLength :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Unit -> m Double

-- | Gets the value of PRINT_SETTINGS_MEDIA_TYPE.
--   
--   The set of media types is defined in PWG 5101.1-2002 PWG.
--   
--   Since: 2.10
printSettingsGetMediaType :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Text

-- | Gets the value of PRINT_SETTINGS_N_COPIES.
--   
--   Since: 2.10
printSettingsGetNCopies :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of PRINT_SETTINGS_NUMBER_UP.
--   
--   Since: 2.10
printSettingsGetNumberUp :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of PRINT_SETTINGS_NUMBER_UP_LAYOUT.
--   
--   Since: 2.14
printSettingsGetNumberUpLayout :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m NumberUpLayout

-- | Get the value of PRINT_SETTINGS_ORIENTATION, converted to a
--   PageOrientation.
--   
--   Since: 2.10
printSettingsGetOrientation :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PageOrientation

-- | Gets the value of PRINT_SETTINGS_OUTPUT_BIN.
--   
--   Since: 2.10
printSettingsGetOutputBin :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Text

-- | Gets the value of PRINT_SETTINGS_PAGE_RANGES.
--   
--   Since: 2.10
printSettingsGetPageRanges :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m [PageRange]

-- | Gets the value of PRINT_SETTINGS_PAGE_SET.
--   
--   Since: 2.10
printSettingsGetPageSet :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PageSet

-- | Gets the value of PRINT_SETTINGS_PAPER_HEIGHT, converted to
--   unit.
--   
--   Since: 2.10
printSettingsGetPaperHeight :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Unit -> m Double

-- | Gets the value of PRINT_SETTINGS_PAPER_FORMAT, converted to a
--   PaperSize.
--   
--   Since: 2.10
printSettingsGetPaperSize :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PaperSize

-- | Gets the value of PRINT_SETTINGS_PAPER_WIDTH, converted to
--   unit.
--   
--   Since: 2.10
printSettingsGetPaperWidth :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Unit -> m Double

-- | Gets the value of PRINT_SETTINGS_PRINT_PAGES.
--   
--   Since: 2.10
printSettingsGetPrintPages :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PrintPages

-- | Convenience function to obtain the value of
--   PRINT_SETTINGS_PRINTER.
--   
--   Since: 2.10
printSettingsGetPrinter :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Text

-- | Gets the value of PRINT_SETTINGS_PRINTER_LPI.
--   
--   Since: 2.16
printSettingsGetPrinterLpi :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Double

-- | Gets the value of PRINT_SETTINGS_QUALITY.
--   
--   Since: 2.10
printSettingsGetQuality :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PrintQuality

-- | Gets the value of PRINT_SETTINGS_RESOLUTION.
--   
--   Since: 2.10
printSettingsGetResolution :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of PRINT_SETTINGS_RESOLUTION_X.
--   
--   Since: 2.16
printSettingsGetResolutionX :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of PRINT_SETTINGS_RESOLUTION_Y.
--   
--   Since: 2.16
printSettingsGetResolutionY :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of PRINT_SETTINGS_REVERSE.
--   
--   Since: 2.10
printSettingsGetReverse :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Bool

-- | Gets the value of PRINT_SETTINGS_SCALE.
--   
--   Since: 2.10
printSettingsGetScale :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Double

-- | Gets the value of PRINT_SETTINGS_USE_COLOR.
--   
--   Since: 2.10
printSettingsGetUseColor :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Bool

-- | Returns True, if a value is associated with
--   key.
--   
--   Since: 2.10
printSettingsHasKey :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m Bool

-- | Reads the print settings from fileName. If the file
--   could not be loaded then error is set to either a FileError or
--   KeyFileError. See printSettingsToFile.
--   
--   Since: 2.14
printSettingsLoadFile :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> [Char] -> m ()

-- | Reads the print settings from the group groupName in
--   keyFile. If the file could not be loaded then error is
--   set to either a FileError or KeyFileError.
--   
--   Since: 2.14
printSettingsLoadKeyFile :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> KeyFile -> Maybe Text -> m ()

-- | Associates value with key.
--   
--   Since: 2.10
printSettingsSet :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Maybe Text -> m ()

-- | Sets key to a boolean value.
--   
--   Since: 2.10
printSettingsSetBool :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Bool -> m ()

-- | Sets the value of PRINT_SETTINGS_COLLATE.
--   
--   Since: 2.10
printSettingsSetCollate :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Bool -> m ()

-- | Sets the value of PRINT_SETTINGS_DEFAULT_SOURCE.
--   
--   Since: 2.10
printSettingsSetDefaultSource :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets the value of PRINT_SETTINGS_DITHER.
--   
--   Since: 2.10
printSettingsSetDither :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets key to a double value.
--   
--   Since: 2.10
printSettingsSetDouble :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Double -> m ()

-- | Sets the value of PRINT_SETTINGS_FINISHINGS.
--   
--   Since: 2.10
printSettingsSetFinishings :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets key to an integer value.
--   
--   Since: 2.10
printSettingsSetInt :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Int32 -> m ()

-- | Associates a length in units of unit with
--   key.
--   
--   Since: 2.10
printSettingsSetLength :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Double -> Unit -> m ()

-- | Sets the value of PRINT_SETTINGS_MEDIA_TYPE.
--   
--   The set of media types is defined in PWG 5101.1-2002 PWG.
--   
--   Since: 2.10
printSettingsSetMediaType :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets the value of PRINT_SETTINGS_N_COPIES.
--   
--   Since: 2.10
printSettingsSetNCopies :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Int32 -> m ()

-- | Sets the value of PRINT_SETTINGS_NUMBER_UP.
--   
--   Since: 2.10
printSettingsSetNumberUp :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Int32 -> m ()

-- | Sets the value of PRINT_SETTINGS_NUMBER_UP_LAYOUT.
--   
--   Since: 2.14
printSettingsSetNumberUpLayout :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> NumberUpLayout -> m ()

-- | Sets the value of PRINT_SETTINGS_OUTPUT_BIN.
--   
--   Since: 2.10
printSettingsSetOutputBin :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets the value of PRINT_SETTINGS_PAGE_RANGES.
--   
--   Since: 2.10
printSettingsSetPageRanges :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> [PageRange] -> m ()

-- | Sets the value of PRINT_SETTINGS_PAGE_SET.
--   
--   Since: 2.10
printSettingsSetPageSet :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PageSet -> m ()

-- | Sets the value of PRINT_SETTINGS_PAPER_HEIGHT.
--   
--   Since: 2.10
printSettingsSetPaperHeight :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Double -> Unit -> m ()

-- | Sets the value of PRINT_SETTINGS_PAPER_FORMAT,
--   PRINT_SETTINGS_PAPER_WIDTH and
--   PRINT_SETTINGS_PAPER_HEIGHT.
--   
--   Since: 2.10
printSettingsSetPaperSize :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PaperSize -> m ()

-- | Sets the value of PRINT_SETTINGS_PRINT_PAGES.
--   
--   Since: 2.10
printSettingsSetPrintPages :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PrintPages -> m ()

-- | Convenience function to set PRINT_SETTINGS_PRINTER to
--   printer.
--   
--   Since: 2.10
printSettingsSetPrinter :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets the value of PRINT_SETTINGS_PRINTER_LPI.
--   
--   Since: 2.16
printSettingsSetPrinterLpi :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Double -> m ()

-- | Sets the values of PRINT_SETTINGS_RESOLUTION,
--   PRINT_SETTINGS_RESOLUTION_X and
--   PRINT_SETTINGS_RESOLUTION_Y.
--   
--   Since: 2.10
printSettingsSetResolution :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Int32 -> m ()

-- | Sets the values of PRINT_SETTINGS_RESOLUTION,
--   PRINT_SETTINGS_RESOLUTION_X and
--   PRINT_SETTINGS_RESOLUTION_Y.
--   
--   Since: 2.16
printSettingsSetResolutionXy :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Int32 -> Int32 -> m ()

-- | Sets the value of PRINT_SETTINGS_REVERSE.
--   
--   Since: 2.10
printSettingsSetReverse :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Bool -> m ()

-- | Sets the value of PRINT_SETTINGS_SCALE.
--   
--   Since: 2.10
printSettingsSetScale :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Double -> m ()

-- | Sets the value of PRINT_SETTINGS_USE_COLOR.
--   
--   Since: 2.10
printSettingsSetUseColor :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Bool -> m ()

-- | This function adds the print settings from settings to
--   keyFile.
--   
--   Since: 2.12
printSettingsToKeyFile :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> KeyFile -> Maybe Text -> m ()

-- | Removes any value associated with key. This has the
--   same effect as setting the value to Nothing.
--   
--   Since: 2.10
printSettingsUnset :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Type class for types which can be safely cast to AccelMap, for
--   instance with toAccelMap.
class (GObject o, IsDescendantOf AccelMap o) => IsAccelMap o

-- | Cast to AccelMap, for types for which this is known to be safe.
--   For general casts, use castTo.
toAccelMap :: (MonadIO m, IsAccelMap o) => o -> m 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::accel_path.
--   
--   Since: 2.4
type AccelMapChangedCallback = Text -> Word32 -> [ModifierType] -> IO ()

-- | Connect a signal handler for the changed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on accelMap #changed callback
--   
--   
--   This signal admits a optional parameter detail. If it's not
--   Nothing, we will connect to “changed::detail”
--   instead.
onAccelMapChanged :: (IsAccelMap a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AccelMapChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after accelMap #changed callback
--   
--   
--   This signal admits a optional parameter detail. If it's not
--   Nothing, we will connect to “changed::detail”
--   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
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAccelMapChanged :: (IsAccelMap a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AccelMapChangedCallback) -> m SignalHandlerId

-- | Gets the singleton global AccelMap object. This object is
--   useful only for notification of changes to the accelerator map via the
--   changed signal; it isn’t a parameter to the other accelerator
--   map functions.
--   
--   Since: 2.4
accelMapGet :: (HasCallStack, MonadIO m) => m AccelMap

-- | Filedescriptor variant of accelMapLoad.
--   
--   Note that the file descriptor will not be closed by this function.
accelMapLoadFd :: (HasCallStack, MonadIO m) => Int32 -> m ()

-- | Scanner variant of accelMapLoad.
accelMapLoadScanner :: (HasCallStack, MonadIO m) => Scanner -> m ()

-- | Looks up the accelerator entry for accelPath and fills
--   in key.
accelMapLookupEntry :: (HasCallStack, MonadIO m) => Text -> m (Bool, AccelKey)

-- | Filedescriptor variant of accelMapSave.
--   
--   Note that the file descriptor will not be closed by this function.
accelMapSaveFd :: (HasCallStack, MonadIO m) => Int32 -> m ()

-- | Copies a TreeRowReference.
--   
--   Since: 2.2
treeRowReferenceCopy :: (HasCallStack, MonadIO m) => TreeRowReference -> m TreeRowReference

-- | Free’s reference. reference may be
--   Nothing
treeRowReferenceFree :: (HasCallStack, MonadIO m) => Maybe TreeRowReference -> m ()

-- | Returns the model that the row reference is monitoring.
--   
--   Since: 2.8
treeRowReferenceGetModel :: (HasCallStack, MonadIO m) => TreeRowReference -> m TreeModel

-- | Returns a path that the row reference currently points to, or
--   Nothing if the path pointed to is no longer valid.
treeRowReferenceGetPath :: (HasCallStack, MonadIO m) => TreeRowReference -> m (Maybe TreePath)

-- | Returns True if the reference is
--   non-Nothing and refers to a current valid path.
treeRowReferenceValid :: (HasCallStack, MonadIO m) => Maybe TreeRowReference -> m Bool

-- | Type class for types which can be safely cast to TreeSortable,
--   for instance with toTreeSortable.
class (GObject o, IsDescendantOf TreeSortable o) => IsTreeSortable o

-- | Cast to TreeSortable, for types for which this is known to be
--   safe. For general casts, use castTo.
toTreeSortable :: (MonadIO m, IsTreeSortable o) => o -> m TreeSortable

-- | The sortColumnChanged signal is emitted when the sort column or
--   sort order of sortable is changed. The signal is
--   emitted before the contents of sortable are resorted.
type TreeSortableSortColumnChangedCallback = IO ()

-- | Fills in sortColumnId and order with
--   the current sort column and the order. It returns True unless
--   the sortColumnId is
--   TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
--   TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
treeSortableGetSortColumnId :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> m (Bool, Int32, SortType)

-- | Returns True 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
--   sortFunc. If the current sort column id of
--   sortable is
--   TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort
--   using this function.
--   
--   If sortFunc is Nothing, 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 sortable is
--   TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be
--   unsorted.
treeSortableSetDefaultSortFunc :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> TreeIterCompareFunc -> m ()

-- | Emits a TreeSortable::sortColumnChanged signal on
--   sortable.
treeSortableSortColumnChanged :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> m ()

-- | Connect a signal handler for the sortColumnChanged signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on treeSortable #sortColumnChanged callback
--   
onTreeSortableSortColumnChanged :: (IsTreeSortable a, MonadIO m) => a -> ((?self :: a) => TreeSortableSortColumnChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the sortColumnChanged signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after treeSortable #sortColumnChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTreeSortableSortColumnChanged :: (IsTreeSortable a, MonadIO m) => a -> ((?self :: a) => TreeSortableSortColumnChangedCallback) -> m SignalHandlerId

-- | Type class for types which can be safely cast to FontChooser,
--   for instance with toFontChooser.
class (GObject o, IsDescendantOf FontChooser o) => IsFontChooser o

-- | Cast to FontChooser, for types for which this is known to be
--   safe. For general casts, use castTo.
toFontChooser :: (MonadIO m, IsFontChooser o) => o -> m FontChooser

-- | 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 ()

-- | Get the value of the “font” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get fontChooser #font
--   
getFontChooserFont :: (MonadIO m, IsFontChooser o) => o -> m (Maybe Text)

-- | Set the value of the “font” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set fontChooser [ #font := value ]
--   
setFontChooserFont :: (MonadIO m, IsFontChooser o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “font” property. This is rarely needed directly, but it is
--   used by new.
constructFontChooserFont :: (IsFontChooser o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “font-desc” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontChooser #fontDesc
--   
getFontChooserFontDesc :: (MonadIO m, IsFontChooser o) => o -> m (Maybe FontDescription)

-- | Set the value of the “font-desc” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fontChooser [ #fontDesc := value ]
--   
setFontChooserFontDesc :: (MonadIO m, IsFontChooser o) => o -> FontDescription -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “font-desc” property. This is rarely needed directly, but it
--   is used by new.
constructFontChooserFontDesc :: (IsFontChooser o, MonadIO m) => FontDescription -> m (GValueConstruct o)

-- | Get the value of the “font-features” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontChooser #fontFeatures
--   
getFontChooserFontFeatures :: (MonadIO m, IsFontChooser o) => o -> m (Maybe Text)

-- | Get the value of the “language” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontChooser #language
--   
getFontChooserLanguage :: (MonadIO m, IsFontChooser o) => o -> m (Maybe Text)

-- | Set the value of the “language” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fontChooser [ #language := value ]
--   
setFontChooserLanguage :: (MonadIO m, IsFontChooser o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “language” property. This is rarely needed directly, but it
--   is used by new.
constructFontChooserLanguage :: (IsFontChooser o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “level” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontChooser #level
--   
getFontChooserLevel :: (MonadIO m, IsFontChooser o) => o -> m [FontChooserLevel]

-- | Set the value of the “level” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fontChooser [ #level := value ]
--   
setFontChooserLevel :: (MonadIO m, IsFontChooser o) => o -> [FontChooserLevel] -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “level” property. This is rarely needed directly, but it is
--   used by new.
constructFontChooserLevel :: (IsFontChooser o, MonadIO m) => [FontChooserLevel] -> m (GValueConstruct o)

-- | Get the value of the “preview-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontChooser #previewText
--   
getFontChooserPreviewText :: (MonadIO m, IsFontChooser o) => o -> m (Maybe Text)

-- | Set the value of the “preview-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fontChooser [ #previewText := value ]
--   
setFontChooserPreviewText :: (MonadIO m, IsFontChooser o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “preview-text” property. This is rarely needed directly, but
--   it is used by new.
constructFontChooserPreviewText :: (IsFontChooser o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “show-preview-entry” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontChooser #showPreviewEntry
--   
getFontChooserShowPreviewEntry :: (MonadIO m, IsFontChooser o) => o -> m Bool

-- | Set the value of the “show-preview-entry” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fontChooser [ #showPreviewEntry := value ]
--   
setFontChooserShowPreviewEntry :: (MonadIO m, IsFontChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-preview-entry” property. This is rarely needed
--   directly, but it is used by new.
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
--   fontChooserSetFont, 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 fontDescriptionEqual if you want to compare two font
--   descriptions.
--   
--   Since: 3.2
fontChooserGetFontDesc :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe FontDescription)

-- | Gets the FontFace representing the selected font group details
--   (i.e. family, slant, weight, width, etc).
--   
--   If the selected font is not installed, returns Nothing.
--   
--   Since: 3.2
fontChooserGetFontFace :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe FontFace)

-- | Gets the FontFamily representing the selected font family. Font
--   families are a collection of font faces.
--   
--   If the selected font is not installed, returns Nothing.
--   
--   Since: 3.2
fontChooserGetFontFamily :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe FontFamily)

-- | Gets the currently-selected font features.
--   
--   Since: 3.24
fontChooserGetFontFeatures :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Text

-- | Gets the custom font map of this font chooser widget, or
--   Nothing if it does not have one.
--   
--   Since: 3.18
fontChooserGetFontMap :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe FontMap)

-- | The selected font size.
--   
--   Since: 3.2
fontChooserGetFontSize :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Int32

-- | Gets the language that is used for font features.
--   
--   Since: 3.24
fontChooserGetLanguage :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Text

-- | Returns the current level of granularity for selecting fonts.
--   
--   Since: 3.24
fontChooserGetLevel :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m [FontChooserLevel]

-- | Gets the text displayed in the preview area.
--   
--   Since: 3.2
fontChooserGetPreviewText :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Text

-- | Returns whether the preview entry is shown or not.
--   
--   Since: 3.2
fontChooserGetShowPreviewEntry :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Bool

-- | Sets the currently-selected font from fontDesc.
--   
--   Since: 3.2
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.
--   
--   
C code
--   
--   
--   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);
--   
--   
--   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:
--   
--   
--   context = gtk_widget_get_pango_context (label);
--   pango_context_set_font_map (context, fontmap);
--   
--   
--   Since: 3.18
fontChooserSetFontMap :: (HasCallStack, MonadIO m, IsFontChooser a, IsFontMap b) => a -> Maybe b -> m ()

-- | Sets the language to use for font features.
--   
--   Since: 3.24
fontChooserSetLanguage :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Text -> m ()

-- | Sets the desired level of granularity for selecting fonts.
--   
--   Since: 3.24
fontChooserSetLevel :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> [FontChooserLevel] -> m ()

-- | Sets the text displayed in the preview area. The text
--   is used to show how the selected font looks.
--   
--   Since: 3.2
fontChooserSetPreviewText :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Text -> m ()

-- | Shows or hides the editable preview entry.
--   
--   Since: 3.2
fontChooserSetShowPreviewEntry :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Bool -> m ()

-- | Connect a signal handler for the fontActivated signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on fontChooser #fontActivated callback
--   
onFontChooserFontActivated :: (IsFontChooser a, MonadIO m) => a -> ((?self :: a) => FontChooserFontActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the fontActivated signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after fontChooser #fontActivated callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFontChooserFontActivated :: (IsFontChooser a, MonadIO m) => a -> ((?self :: a) => FontChooserFontActivatedCallback) -> m SignalHandlerId

-- | Memory-managed wrapper type.
newtype TableChild
TableChild :: ManagedPtr TableChild -> TableChild

-- | Construct a TableChild struct initialized to zero.
newZeroTableChild :: MonadIO m => m TableChild

-- | Get the value of the “widget” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get tableChild #widget
--   
getTableChildWidget :: MonadIO m => TableChild -> m (Maybe Widget)

-- | Set the value of the “widget” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set tableChild [ #widget := value ]
--   
setTableChildWidget :: MonadIO m => TableChild -> Ptr Widget -> m ()

-- | Set the value of the “widget” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #widget
--   
clearTableChildWidget :: MonadIO m => TableChild -> m ()

-- | Get the value of the “left_attach” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get tableChild #leftAttach
--   
getTableChildLeftAttach :: MonadIO m => TableChild -> m Word16

-- | Set the value of the “left_attach” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set tableChild [ #leftAttach := value ]
--   
setTableChildLeftAttach :: MonadIO m => TableChild -> Word16 -> m ()

-- | Get the value of the “right_attach” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get tableChild #rightAttach
--   
getTableChildRightAttach :: MonadIO m => TableChild -> m Word16

-- | Set the value of the “right_attach” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set tableChild [ #rightAttach := value ]
--   
setTableChildRightAttach :: MonadIO m => TableChild -> Word16 -> m ()

-- | Get the value of the “top_attach” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get tableChild #topAttach
--   
getTableChildTopAttach :: MonadIO m => TableChild -> m Word16

-- | Set the value of the “top_attach” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set tableChild [ #topAttach := value ]
--   
setTableChildTopAttach :: MonadIO m => TableChild -> Word16 -> m ()

-- | Get the value of the “bottom_attach” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get tableChild #bottomAttach
--   
getTableChildBottomAttach :: MonadIO m => TableChild -> m Word16

-- | Set the value of the “bottom_attach” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set tableChild [ #bottomAttach := value ]
--   
setTableChildBottomAttach :: MonadIO m => TableChild -> Word16 -> m ()

-- | Get the value of the “xpadding” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get tableChild #xpadding
--   
getTableChildXpadding :: MonadIO m => TableChild -> m Word16

-- | Set the value of the “xpadding” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set tableChild [ #xpadding := value ]
--   
setTableChildXpadding :: MonadIO m => TableChild -> Word16 -> m ()

-- | Get the value of the “ypadding” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get tableChild #ypadding
--   
getTableChildYpadding :: MonadIO m => TableChild -> m Word16

-- | Set the value of the “ypadding” field. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set tableChild [ #ypadding := value ]
--   
setTableChildYpadding :: MonadIO m => TableChild -> Word16 -> m ()

-- | Get the value of the “xexpand” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get tableChild #xexpand
--   
getTableChildXexpand :: MonadIO m => TableChild -> m Word32

-- | Set the value of the “xexpand” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set tableChild [ #xexpand := value ]
--   
setTableChildXexpand :: MonadIO m => TableChild -> Word32 -> m ()

-- | Get the value of the “yexpand” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get tableChild #yexpand
--   
getTableChildYexpand :: MonadIO m => TableChild -> m Word32

-- | Set the value of the “yexpand” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set tableChild [ #yexpand := value ]
--   
setTableChildYexpand :: MonadIO m => TableChild -> Word32 -> m ()

-- | Get the value of the “xshrink” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get tableChild #xshrink
--   
getTableChildXshrink :: MonadIO m => TableChild -> m Word32

-- | Set the value of the “xshrink” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set tableChild [ #xshrink := value ]
--   
setTableChildXshrink :: MonadIO m => TableChild -> Word32 -> m ()

-- | Get the value of the “yshrink” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get tableChild #yshrink
--   
getTableChildYshrink :: MonadIO m => TableChild -> m Word32

-- | Set the value of the “yshrink” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set tableChild [ #yshrink := value ]
--   
setTableChildYshrink :: MonadIO m => TableChild -> Word32 -> m ()

-- | Get the value of the “xfill” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get tableChild #xfill
--   
getTableChildXfill :: MonadIO m => TableChild -> m Word32

-- | Set the value of the “xfill” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set tableChild [ #xfill := value ]
--   
setTableChildXfill :: MonadIO m => TableChild -> Word32 -> m ()

-- | Get the value of the “yfill” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get tableChild #yfill
--   
getTableChildYfill :: MonadIO m => TableChild -> m Word32

-- | Set the value of the “yfill” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set tableChild [ #yfill := value ]
--   
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 gradientAddColorStop.
--   
--   Since: 3.0
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 gradientAddColorStop.
--   
--   Since: 3.0
gradientNewRadial :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> Double -> Double -> Double -> m Gradient

-- | Increases the reference count of gradient.
--   
--   Since: 3.0
gradientRef :: (HasCallStack, MonadIO m) => Gradient -> m Gradient

-- | If gradient is resolvable,
--   resolvedGradient will be filled in with the resolved
--   gradient as a cairo_pattern_t, and True will be returned.
--   Generally, if gradient can’t be resolved, it is due to
--   it being defined on top of a named color that doesn't exist in
--   props.
--   
--   Since: 3.0
gradientResolve :: (HasCallStack, MonadIO m, IsStyleProperties a) => Gradient -> a -> m (Bool, Pattern)

-- | No description available in the introspection data.
gradientResolveForContext :: (HasCallStack, MonadIO m, IsStyleContext a) => Gradient -> a -> m Pattern

-- | Creates a string representation for gradient that is
--   suitable for using in GTK CSS files.
gradientToString :: (HasCallStack, MonadIO m) => Gradient -> m Text

-- | Decreases the reference count of gradient, freeing its
--   memory if the reference count reaches 0.
--   
--   Since: 3.0
gradientUnref :: (HasCallStack, MonadIO m) => Gradient -> m ()

-- | Memory-managed wrapper type.
newtype FixedChild
FixedChild :: ManagedPtr FixedChild -> FixedChild

-- | Construct a FixedChild struct initialized to zero.
newZeroFixedChild :: MonadIO m => m FixedChild

-- | Get the value of the “widget” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get fixedChild #widget
--   
getFixedChildWidget :: MonadIO m => FixedChild -> m (Maybe Widget)

-- | Set the value of the “widget” field. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set fixedChild [ #widget := value ]
--   
setFixedChildWidget :: MonadIO m => FixedChild -> Ptr Widget -> m ()

-- | Set the value of the “widget” field to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #widget
--   
clearFixedChildWidget :: MonadIO m => FixedChild -> m ()

-- | Get the value of the “x” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get fixedChild #x
--   
getFixedChildX :: MonadIO m => FixedChild -> m Int32

-- | Set the value of the “x” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set fixedChild [ #x := value ]
--   
setFixedChildX :: MonadIO m => FixedChild -> Int32 -> m ()

-- | Get the value of the “y” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   get fixedChild #y
--   
getFixedChildY :: MonadIO m => FixedChild -> m Int32

-- | Set the value of the “y” field. When overloading is
--   enabled, this is equivalent to
--   
--   
--   set fixedChild [ #y := value ]
--   
setFixedChildY :: MonadIO m => FixedChild -> Int32 -> m ()

-- | Type class for types which can be safely cast to Viewport, for
--   instance with toViewport.
class (GObject o, IsDescendantOf Viewport o) => IsViewport o

-- | Cast to Viewport, for types for which this is known to be safe.
--   For general casts, use castTo.
toViewport :: (MonadIO m, IsViewport o) => o -> m Viewport

-- | Get the value of the “shadow-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get viewport #shadowType
--   
getViewportShadowType :: (MonadIO m, IsViewport o) => o -> m ShadowType

-- | Set the value of the “shadow-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set viewport [ #shadowType := value ]
--   
setViewportShadowType :: (MonadIO m, IsViewport o) => o -> ShadowType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “shadow-type” property. This is rarely needed directly, but
--   it is used by new.
constructViewportShadowType :: (IsViewport o, MonadIO m) => ShadowType -> m (GValueConstruct o)

-- | Creates a new Viewport 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 Viewport.
--   
--   Since: 2.20
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 Viewport. See
--   viewportSetShadowType.
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 Viewport.
--   
--   Since: 2.22
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 vertical adjustment of the viewport.
viewportSetVadjustment :: (HasCallStack, MonadIO m, IsViewport a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Type class for types which can be safely cast to
--   ToplevelAccessible, for instance with
--   toToplevelAccessible.
class (GObject o, IsDescendantOf ToplevelAccessible o) => IsToplevelAccessible o

-- | Memory-managed wrapper type.
newtype ToplevelAccessible
ToplevelAccessible :: ManagedPtr ToplevelAccessible -> ToplevelAccessible

-- | Cast to ToplevelAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toToplevelAccessible :: (MonadIO m, IsToplevelAccessible o) => o -> m ToplevelAccessible

-- | No description available in the introspection data.
toplevelAccessibleGetChildren :: (HasCallStack, MonadIO m, IsToplevelAccessible a) => a -> m [Window]

-- | Type class for types which can be safely cast to ThemingEngine,
--   for instance with toThemingEngine.
class (GObject o, IsDescendantOf ThemingEngine o) => IsThemingEngine o

-- | Cast to ThemingEngine, for types for which this is known to be
--   safe. For general casts, use castTo.
toThemingEngine :: (MonadIO m, IsThemingEngine o) => o -> m ThemingEngine

-- | Get the value of the “name” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get themingEngine #name
--   
getThemingEngineName :: (MonadIO m, IsThemingEngine o) => o -> m (Maybe Text)

-- | Construct a GValueConstruct with valid value for the
--   “name” property. This is rarely needed directly, but it is
--   used by new.
constructThemingEngineName :: (IsThemingEngine o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Gets the background color for a given state.
--   
--   Since: 3.0
themingEngineGetBackgroundColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m RGBA

-- | Gets the border for a given state as a Border.
--   
--   Since: 3.0
themingEngineGetBorder :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m Border

-- | Gets the border color for a given state.
--   
--   Since: 3.0
themingEngineGetBorderColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m RGBA

-- | Gets the foreground color for a given state.
--   
--   Since: 3.0
themingEngineGetColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m RGBA

-- | Returns the widget direction used for rendering.
--   
--   Since: 3.0
themingEngineGetDirection :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> m TextDirection

-- | Returns the font description for a given state.
--   
--   Since: 3.0
themingEngineGetFont :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m FontDescription

-- | Returns the widget direction used for rendering.
--   
--   Since: 3.0
themingEngineGetJunctionSides :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> m [JunctionSides]

-- | Gets the margin for a given state as a Border.
--   
--   Since: 3.0
themingEngineGetMargin :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m Border

-- | Gets the padding for a given state as a Border.
--   
--   Since: 3.0
themingEngineGetPadding :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m Border

-- | Returns the widget path used for style matching.
--   
--   Since: 3.0
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.
--   
--   Since: 3.0
themingEngineGetProperty :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> [StateFlags] -> m GValue

-- | Returns the Screen to which engine currently
--   rendering to.
themingEngineGetScreen :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> m (Maybe Screen)

-- | returns the state used when rendering.
--   
--   Since: 3.0
themingEngineGetState :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> m [StateFlags]

-- | Gets the value for a widget style property.
--   
--   Since: 3.0
themingEngineGetStyleProperty :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> m GValue

-- | Returns True if the currently rendered contents have defined
--   the given class name.
--   
--   Since: 3.0
themingEngineHasClass :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> m Bool

-- | Returns True if the currently rendered contents have the region
--   defined. If flagsReturn is not Nothing, it is
--   set to the flags affecting the region.
--   
--   Since: 3.0
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.
--   
--   Since: 3.0
themingEngineLookupColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> m (Bool, RGBA)

-- | Returns True if there is a transition animation running for the
--   current region (see styleContextPushAnimatableRegion).
--   
--   If progress is not Nothing, the animation
--   progress will be returned there, 0.0 means the state is closest to
--   being False, while 1.0 means it’s closest to being True.
--   This means transition animations will run from 0 to 1 when
--   state is being set to True and from 1 to 0 when
--   it’s being set to False.
--   
--   Since: 3.0
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)

-- | Type class for types which can be safely cast to TextView, for
--   instance with toTextView.
class (GObject o, IsDescendantOf TextView o) => IsTextView o

-- | Cast to TextView, for types for which this is known to be safe.
--   For general casts, use castTo.
toTextView :: (MonadIO m, IsTextView o) => o -> m TextView

-- | The toggleOverwrite 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 toggleCursorVisible signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to toggle the
--   TextView:cursorVisible property.
--   
--   The default binding for this signal is F7.
type TextViewToggleCursorVisibleCallback = IO ()

-- | The setAnchor 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 selectAll 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.
--   
--   Since: 2.20
type TextViewPreeditChangedCallback = Text -> IO ()

-- | The populatePopup 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 popup, which will be a
--   Menu in this case.
--   
--   If TextView:populateAll is True, this signal will also
--   be emitted to populate touch popups. In this case,
--   popup will be a different container, e.g. a
--   Toolbar.
--   
--   The signal handler should not make assumptions about the type of
--   widget, but check whether popup is a
--   Menu or Toolbar or another kind of container.
type TextViewPopulatePopupCallback = Widget -> IO ()

-- | The pasteClipboard 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 moveViewport 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 moveCursor signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates a
--   cursor movement. If the cursor is not visible in
--   textView, this signal causes the viewport to be moved
--   instead.
--   
--   Applications should not connect to it, but may emit it with
--   g_signal_emit_by_name() 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. * Arrow keys move by individual characters/lines *
--   Ctrl-arrow key combinations move by words/paragraphs * Home/End keys
--   move to the ends of the buffer * PageUp/PageDown keys move vertically
--   by pages * Ctrl-PageUp/PageDown keys move horizontally by pages
type TextViewMoveCursorCallback = MovementStep -> Int32 -> Bool -> IO ()

-- | The insertEmoji signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to present the Emoji
--   chooser for the textView.
--   
--   The default bindings for this signal are Ctrl-. and Ctrl-;
--   
--   Since: 3.22.27
type TextViewInsertEmojiCallback = IO ()

-- | The insertAtCursor 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 extendSelection signal is emitted when the selection needs
--   to be extended at location.
--   
--   Since: 3.16
type TextViewExtendSelectionCallback = TextExtendSelection -> TextIter -> TextIter -> TextIter -> IO Bool

-- | The deleteFromCursor signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates a
--   text deletion.
--   
--   If the type is DeleteTypeChars, 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 cutClipboard 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 copyClipboard 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 backspace 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 ()

-- | Connect a signal handler for the backspace signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textView #backspace callback
--   
onTextViewBackspace :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewBackspaceCallback) -> m SignalHandlerId

-- | Connect a signal handler for the backspace signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textView #backspace callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewBackspace :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewBackspaceCallback) -> m SignalHandlerId

-- | Connect a signal handler for the copyClipboard signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on textView #copyClipboard callback
--   
onTextViewCopyClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the copyClipboard signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after textView #copyClipboard callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewCopyClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cutClipboard signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textView #cutClipboard callback
--   
onTextViewCutClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewCutClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cutClipboard signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textView #cutClipboard callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewCutClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewCutClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deleteFromCursor signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on textView #deleteFromCursor callback
--   
onTextViewDeleteFromCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewDeleteFromCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the deleteFromCursor signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after textView #deleteFromCursor callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewDeleteFromCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewDeleteFromCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the extendSelection signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on textView #extendSelection callback
--   
onTextViewExtendSelection :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewExtendSelectionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the extendSelection signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after textView #extendSelection callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewExtendSelection :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewExtendSelectionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertAtCursor signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on textView #insertAtCursor callback
--   
onTextViewInsertAtCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewInsertAtCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertAtCursor signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after textView #insertAtCursor callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewInsertAtCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewInsertAtCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertEmoji signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textView #insertEmoji callback
--   
onTextViewInsertEmoji :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewInsertEmojiCallback) -> m SignalHandlerId

-- | Connect a signal handler for the insertEmoji signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textView #insertEmoji callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewInsertEmoji :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewInsertEmojiCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCursor signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textView #moveCursor callback
--   
onTextViewMoveCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCursor signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textView #moveCursor callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewMoveCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveViewport signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textView #moveViewport callback
--   
onTextViewMoveViewport :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewMoveViewportCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveViewport signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textView #moveViewport callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewMoveViewport :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewMoveViewportCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pasteClipboard signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on textView #pasteClipboard callback
--   
onTextViewPasteClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPasteClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pasteClipboard signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after textView #pasteClipboard callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewPasteClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPasteClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the populatePopup signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on textView #populatePopup callback
--   
onTextViewPopulatePopup :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the populatePopup signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after textView #populatePopup callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewPopulatePopup :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preeditChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on textView #preeditChanged callback
--   
onTextViewPreeditChanged :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preeditChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after textView #preeditChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewPreeditChanged :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectAll signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textView #selectAll callback
--   
onTextViewSelectAll :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectAll signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textView #selectAll callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewSelectAll :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the setAnchor signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on textView #setAnchor callback
--   
onTextViewSetAnchor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewSetAnchorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the setAnchor signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after textView #setAnchor callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewSetAnchor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewSetAnchorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleCursorVisible signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on textView #toggleCursorVisible callback
--   
onTextViewToggleCursorVisible :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewToggleCursorVisibleCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleCursorVisible signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after textView #toggleCursorVisible callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewToggleCursorVisible :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewToggleCursorVisibleCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleOverwrite signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on textView #toggleOverwrite callback
--   
onTextViewToggleOverwrite :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewToggleOverwriteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleOverwrite signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after textView #toggleOverwrite callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterTextViewToggleOverwrite :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewToggleOverwriteCallback) -> m SignalHandlerId

-- | Get the value of the “accepts-tab” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #acceptsTab
--   
getTextViewAcceptsTab :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “accepts-tab” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #acceptsTab := value ]
--   
setTextViewAcceptsTab :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accepts-tab” property. This is rarely needed directly, but
--   it is used by new.
constructTextViewAcceptsTab :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “bottom-margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #bottomMargin
--   
getTextViewBottomMargin :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “bottom-margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #bottomMargin := value ]
--   
setTextViewBottomMargin :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “bottom-margin” property. This is rarely needed directly, but
--   it is used by new.
constructTextViewBottomMargin :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “buffer” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #buffer
--   
getTextViewBuffer :: (MonadIO m, IsTextView o) => o -> m TextBuffer

-- | Set the value of the “buffer” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #buffer := value ]
--   
setTextViewBuffer :: (MonadIO m, IsTextView o, IsTextBuffer a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “buffer” property. This is rarely needed directly, but it is
--   used by new.
constructTextViewBuffer :: (IsTextView o, MonadIO m, IsTextBuffer a) => a -> m (GValueConstruct o)

-- | Set the value of the “buffer” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #buffer
--   
clearTextViewBuffer :: (MonadIO m, IsTextView o) => o -> m ()

-- | Get the value of the “cursor-visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #cursorVisible
--   
getTextViewCursorVisible :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “cursor-visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #cursorVisible := value ]
--   
setTextViewCursorVisible :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “cursor-visible” property. This is rarely needed directly,
--   but it is used by new.
constructTextViewCursorVisible :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “editable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #editable
--   
getTextViewEditable :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “editable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #editable := value ]
--   
setTextViewEditable :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “editable” property. This is rarely needed directly, but it
--   is used by new.
constructTextViewEditable :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “im-module” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #imModule
--   
getTextViewImModule :: (MonadIO m, IsTextView o) => o -> m (Maybe Text)

-- | Set the value of the “im-module” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #imModule := value ]
--   
setTextViewImModule :: (MonadIO m, IsTextView o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “im-module” property. This is rarely needed directly, but it
--   is used by new.
constructTextViewImModule :: (IsTextView o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “im-module” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #imModule
--   
clearTextViewImModule :: (MonadIO m, IsTextView o) => o -> m ()

-- | Get the value of the “indent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #indent
--   
getTextViewIndent :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “indent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #indent := value ]
--   
setTextViewIndent :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “indent” property. This is rarely needed directly, but it is
--   used by new.
constructTextViewIndent :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “input-hints” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #inputHints
--   
getTextViewInputHints :: (MonadIO m, IsTextView o) => o -> m [InputHints]

-- | Set the value of the “input-hints” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #inputHints := value ]
--   
setTextViewInputHints :: (MonadIO m, IsTextView o) => o -> [InputHints] -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “input-hints” property. This is rarely needed directly, but
--   it is used by new.
constructTextViewInputHints :: (IsTextView o, MonadIO m) => [InputHints] -> m (GValueConstruct o)

-- | Get the value of the “input-purpose” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #inputPurpose
--   
getTextViewInputPurpose :: (MonadIO m, IsTextView o) => o -> m InputPurpose

-- | Set the value of the “input-purpose” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #inputPurpose := value ]
--   
setTextViewInputPurpose :: (MonadIO m, IsTextView o) => o -> InputPurpose -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “input-purpose” property. This is rarely needed directly, but
--   it is used by new.
constructTextViewInputPurpose :: (IsTextView o, MonadIO m) => InputPurpose -> m (GValueConstruct o)

-- | Get the value of the “justification” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #justification
--   
getTextViewJustification :: (MonadIO m, IsTextView o) => o -> m Justification

-- | Set the value of the “justification” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #justification := value ]
--   
setTextViewJustification :: (MonadIO m, IsTextView o) => o -> Justification -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “justification” property. This is rarely needed directly, but
--   it is used by new.
constructTextViewJustification :: (IsTextView o, MonadIO m) => Justification -> m (GValueConstruct o)

-- | Get the value of the “left-margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #leftMargin
--   
getTextViewLeftMargin :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “left-margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #leftMargin := value ]
--   
setTextViewLeftMargin :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “left-margin” property. This is rarely needed directly, but
--   it is used by new.
constructTextViewLeftMargin :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “monospace” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #monospace
--   
getTextViewMonospace :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “monospace” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #monospace := value ]
--   
setTextViewMonospace :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “monospace” property. This is rarely needed directly, but it
--   is used by new.
constructTextViewMonospace :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “overwrite” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #overwrite
--   
getTextViewOverwrite :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “overwrite” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #overwrite := value ]
--   
setTextViewOverwrite :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “overwrite” property. This is rarely needed directly, but it
--   is used by new.
constructTextViewOverwrite :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “pixels-above-lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #pixelsAboveLines
--   
getTextViewPixelsAboveLines :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “pixels-above-lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #pixelsAboveLines := value ]
--   
setTextViewPixelsAboveLines :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixels-above-lines” property. This is rarely needed
--   directly, but it is used by new.
constructTextViewPixelsAboveLines :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “pixels-below-lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #pixelsBelowLines
--   
getTextViewPixelsBelowLines :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “pixels-below-lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #pixelsBelowLines := value ]
--   
setTextViewPixelsBelowLines :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixels-below-lines” property. This is rarely needed
--   directly, but it is used by new.
constructTextViewPixelsBelowLines :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “pixels-inside-wrap” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #pixelsInsideWrap
--   
getTextViewPixelsInsideWrap :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “pixels-inside-wrap” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #pixelsInsideWrap := value ]
--   
setTextViewPixelsInsideWrap :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixels-inside-wrap” property. This is rarely needed
--   directly, but it is used by new.
constructTextViewPixelsInsideWrap :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “populate-all” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #populateAll
--   
getTextViewPopulateAll :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “populate-all” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #populateAll := value ]
--   
setTextViewPopulateAll :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “populate-all” property. This is rarely needed directly, but
--   it is used by new.
constructTextViewPopulateAll :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “right-margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #rightMargin
--   
getTextViewRightMargin :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “right-margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #rightMargin := value ]
--   
setTextViewRightMargin :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “right-margin” property. This is rarely needed directly, but
--   it is used by new.
constructTextViewRightMargin :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “tabs” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get textView #tabs
--   
getTextViewTabs :: (MonadIO m, IsTextView o) => o -> m (Maybe TabArray)

-- | Set the value of the “tabs” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set textView [ #tabs := value ]
--   
setTextViewTabs :: (MonadIO m, IsTextView o) => o -> TabArray -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tabs” property. This is rarely needed directly, but it is
--   used by new.
constructTextViewTabs :: (IsTextView o, MonadIO m) => TabArray -> m (GValueConstruct o)

-- | Get the value of the “top-margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #topMargin
--   
getTextViewTopMargin :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “top-margin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #topMargin := value ]
--   
setTextViewTopMargin :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “top-margin” property. This is rarely needed directly, but it
--   is used by new.
constructTextViewTopMargin :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “wrap-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get textView #wrapMode
--   
getTextViewWrapMode :: (MonadIO m, IsTextView o) => o -> m WrapMode

-- | Set the value of the “wrap-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set textView [ #wrapMode := value ]
--   
setTextViewWrapMode :: (MonadIO m, IsTextView o) => o -> WrapMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “wrap-mode” property. This is rarely needed directly, but it
--   is used by new.
constructTextViewWrapMode :: (IsTextView o, MonadIO m) => WrapMode -> m (GValueConstruct o)

-- | Adds a child widget in the text buffer, at the given
--   anchor.
textViewAddChildAtAnchor :: (HasCallStack, MonadIO m, IsTextView a, IsWidget b, IsTextChildAnchor c) => a -> b -> c -> m ()

-- | Moves the given iter 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 TextBuffer.
textViewBackwardDisplayLine :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | Moves the given iter 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 TextBuffer.
textViewBackwardDisplayLineStart :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | Moves the given iter 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 TextBuffer.
textViewForwardDisplayLineEnd :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | Returns whether pressing the Tab key inserts a tab characters.
--   textViewSetAcceptsTab.
--   
--   Since: 2.4
textViewGetAcceptsTab :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Gets the width of the specified border window. See
--   textViewSetBorderWindowSize.
textViewGetBorderWindowSize :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> m Int32

-- | Gets the bottom margin for text in the textView.
--   
--   Since: 3.18
textViewGetBottomMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Given an iter 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 iter is Nothing, the actual cursor position
--   is used.
--   
--   Note that if iter 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
--   textViewBufferToWindowCoords to convert these coordinates to
--   coordinates for one of the windows in the text view.
--   
--   Since: 3.0
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 Adjustment.
--   
--   Since: 2.22
textViewGetHadjustment :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Adjustment

-- | Gets the default indentation of paragraphs in
--   textView. 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 TextView:inputHints property.
--   
--   Since: 3.6
textViewGetInputHints :: (HasCallStack, MonadIO m, IsTextView a) => a -> m [InputHints]

-- | Gets the value of the TextView:inputPurpose property.
--   
--   Since: 3.6
textViewGetInputPurpose :: (HasCallStack, MonadIO m, IsTextView a) => a -> m InputPurpose

-- | Retrieves the iterator pointing to the character at buffer coordinates
--   x and y. 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 textViewWindowToBufferCoords.
--   
--   Note that this is different from textViewGetIterAtLocation,
--   which returns cursor locations, i.e. positions between characters.
--   
--   Since: 2.6
textViewGetIterAtPosition :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> Int32 -> m (Bool, TextIter, Int32)

-- | Gets a rectangle which roughly contains the character at
--   iter. The rectangle position is in buffer coordinates;
--   use textViewBufferToWindowCoords 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
--   textView. 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
--   textView. Tags in the buffer may override the default.
textViewGetLeftMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the TextIter at the start of the line containing the
--   coordinate y. y is in buffer
--   coordinates, convert from window coordinates with
--   textViewWindowToBufferCoords. If non-Nothing,
--   lineTop 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
--   iter, and the height of the line. The coordinate is a
--   buffer coordinate; convert to window coordinates with
--   textViewBufferToWindowCoords.
textViewGetLineYrange :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m (Int32, Int32)

-- | Gets the value of the TextView:monospace property.
--   
--   Since: 3.16
textViewGetMonospace :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Returns whether the TextView is in overwrite mode or not.
--   
--   Since: 2.4
textViewGetOverwrite :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Gets the value set by textViewSetPixelsInsideWrap.
textViewGetPixelsInsideWrap :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the default right margin for text in textView.
--   Tags in the buffer may override the default.
textViewGetRightMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the default tabs for textView. Tags in the buffer
--   may override the defaults. The returned array will be Nothing
--   if “standard” (8-space) tabs are used. Free the return value with
--   tabArrayFree.
textViewGetTabs :: (HasCallStack, MonadIO m, IsTextView a) => a -> m (Maybe TabArray)

-- | Gets the top margin for text in the textView.
--   
--   Since: 3.18
textViewGetTopMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the vertical-scrolling Adjustment.
--   
--   Since: 2.22
textViewGetVadjustment :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Adjustment

-- | Fills visibleRect with the currently-visible region of
--   the buffer, in buffer coordinates. Convert to window coordinates with
--   textViewBufferToWindowCoords.
textViewGetVisibleRect :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Rectangle

-- | Retrieves the Window 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 Nothing 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 textView, this
--   function should be called on event->window 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 TextView input method to internally handle key press
--   and release events. If this function returns True, then no
--   further processing should be done for this key event. See
--   iMContextFilterKeypress.
--   
--   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 TextView.
--   
--   
C code
--   
--   
--   static gboolean
--   gtk_foo_bar_key_press_event (GtkWidget   *widget,
--                                GdkEventKey *event)
--   {
--     guint keyval;
--   
--     gdk_event_get_keyval ((GdkEvent*)event, &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)->key_press_event (widget, event);
--   }
--   
--   
--   Since: 2.22
textViewImContextFilterKeypress :: (HasCallStack, MonadIO m, IsTextView a) => a -> EventKey -> m Bool

-- | Updates the position of a child, as for
--   textViewAddChildInWindow.
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 count is positive,
--   then the new strong cursor position will be count
--   positions to the right of the old cursor position. If
--   count is negative then the new strong cursor position
--   will be count 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
--   Widget::keyPressEvent handler).
--   
--   Since: 3.20
textViewResetCursorBlink :: (HasCallStack, MonadIO m, IsTextView a) => a -> m ()

-- | Scrolls textView the minimum distance such that
--   mark is contained within the visible area of the
--   widget.
textViewScrollMarkOnscreen :: (HasCallStack, MonadIO m, IsTextView a, IsTextMark b) => a -> b -> m ()

-- | Scrolls textView so that iter is on
--   the screen in the position indicated by xalign and
--   yalign. An alignment of 0.0 indicates left or top, 1.0
--   indicates right or bottom, 0.5 means center. If
--   useAlign is False, 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 withinMargin.
--   
--   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 textViewScrollToMark 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

-- | Sets the bottom margin for text in textView.
--   
--   Note that this function is confusingly named. In CSS terms, the value
--   set here is padding.
--   
--   Since: 3.18
textViewSetBottomMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> 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
--   Settings:gtk-keynave-use-caret settings.
textViewSetCursorVisible :: (HasCallStack, MonadIO m, IsTextView a) => a -> Bool -> m ()

-- | Sets the default editability of the TextView. 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
--   textView. Tags in the buffer may override the default.
textViewSetIndent :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets the TextView:inputHints property, which allows input
--   methods to fine-tune their behaviour.
--   
--   Since: 3.6
textViewSetInputHints :: (HasCallStack, MonadIO m, IsTextView a) => a -> [InputHints] -> m ()

-- | Sets the TextView:inputPurpose property which can be used by
--   on-screen keyboards and other input methods to adjust their behaviour.
--   
--   Since: 3.6
textViewSetInputPurpose :: (HasCallStack, MonadIO m, IsTextView a) => a -> InputPurpose -> m ()

-- | Sets the default justification of text in textView.
--   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 textView.
--   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 TextView:monospace property, which indicates that the
--   text view should use monospace fonts.
--   
--   Since: 3.16
textViewSetMonospace :: (HasCallStack, MonadIO m, IsTextView a) => a -> Bool -> m ()

-- | Changes the TextView overwrite mode.
--   
--   Since: 2.4
textViewSetOverwrite :: (HasCallStack, MonadIO m, IsTextView a) => a -> Bool -> m ()

-- | Sets the default number of blank pixels above paragraphs in
--   textView. Tags in the buffer for
--   textView may override the defaults.
textViewSetPixelsAboveLines :: (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 textView.
--   Tags in the buffer may override the default.
textViewSetTabs :: (HasCallStack, MonadIO m, IsTextView a) => a -> TabArray -> m ()

-- | Sets the top margin for text in textView.
--   
--   Note that this function is confusingly named. In CSS terms, the value
--   set here is padding.
--   
--   Since: 3.18
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 iter is at the start of a display
--   line. See textViewForwardDisplayLine for an explanation of
--   display lines vs. paragraphs.
textViewStartsDisplayLine :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | Type class for types which can be safely cast to Table, for
--   instance with toTable.
class (GObject o, IsDescendantOf Table o) => IsTable o

-- | Cast to Table, for types for which this is known to be safe.
--   For general casts, use castTo.
toTable :: (MonadIO m, IsTable o) => o -> m Table

-- | Get the value of the “column-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get table #columnSpacing
--   
getTableColumnSpacing :: (MonadIO m, IsTable o) => o -> m Word32

-- | Set the value of the “column-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set table [ #columnSpacing := value ]
--   
setTableColumnSpacing :: (MonadIO m, IsTable o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “column-spacing” property. This is rarely needed directly,
--   but it is used by new.
constructTableColumnSpacing :: (IsTable o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “homogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get table #homogeneous
--   
getTableHomogeneous :: (MonadIO m, IsTable o) => o -> m Bool

-- | Set the value of the “homogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set table [ #homogeneous := value ]
--   
setTableHomogeneous :: (MonadIO m, IsTable o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “homogeneous” property. This is rarely needed directly, but
--   it is used by new.
constructTableHomogeneous :: (IsTable o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “n-columns” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get table #nColumns
--   
getTableNColumns :: (MonadIO m, IsTable o) => o -> m Word32

-- | Set the value of the “n-columns” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set table [ #nColumns := value ]
--   
setTableNColumns :: (MonadIO m, IsTable o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “n-columns” property. This is rarely needed directly, but it
--   is used by new.
constructTableNColumns :: (IsTable o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “n-rows” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get table #nRows
--   
getTableNRows :: (MonadIO m, IsTable o) => o -> m Word32

-- | Set the value of the “n-rows” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set table [ #nRows := value ]
--   
setTableNRows :: (MonadIO m, IsTable o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “n-rows” property. This is rarely needed directly, but it is
--   used by new.
constructTableNRows :: (IsTable o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “row-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get table #rowSpacing
--   
getTableRowSpacing :: (MonadIO m, IsTable o) => o -> m Word32

-- | Set the value of the “row-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set table [ #rowSpacing := value ]
--   
setTableRowSpacing :: (MonadIO m, IsTable o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “row-spacing” property. This is rarely needed directly, but
--   it is used by new.
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 tableResize.
--   rows and columns 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

-- | As there are many options associated with tableAttach, 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 AttachOptions are GTK_EXPAND |
--   GTK_FILL, 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 col, and
--   column col + 1. See tableSetColSpacing.
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
--   tableSetColSpacings)
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 tableSetRowSpacings)
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 row, and row
--   row + 1. See tableSetRowSpacing.
tableGetRowSpacing :: (HasCallStack, MonadIO m, IsTable a) => a -> Word32 -> m Word32

-- | Gets the number of rows and columns in the table.
--   
--   Since: 2.22
tableGetSize :: (HasCallStack, MonadIO m, IsTable a) => a -> m (Word32, Word32)

-- | 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 ()

-- | Type class for types which can be safely cast to Stack, for
--   instance with toStack.
class (GObject o, IsDescendantOf Stack o) => IsStack o

-- | Cast to Stack, for types for which this is known to be safe.
--   For general casts, use castTo.
toStack :: (MonadIO m, IsStack o) => o -> m Stack

-- | Get the value of the “hhomogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stack #hhomogeneous
--   
getStackHhomogeneous :: (MonadIO m, IsStack o) => o -> m Bool

-- | Set the value of the “hhomogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set stack [ #hhomogeneous := value ]
--   
setStackHhomogeneous :: (MonadIO m, IsStack o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “hhomogeneous” property. This is rarely needed directly, but
--   it is used by new.
constructStackHhomogeneous :: (IsStack o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “homogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stack #homogeneous
--   
getStackHomogeneous :: (MonadIO m, IsStack o) => o -> m Bool

-- | Set the value of the “homogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set stack [ #homogeneous := value ]
--   
setStackHomogeneous :: (MonadIO m, IsStack o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “homogeneous” property. This is rarely needed directly, but
--   it is used by new.
constructStackHomogeneous :: (IsStack o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “interpolate-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stack #interpolateSize
--   
getStackInterpolateSize :: (MonadIO m, IsStack o) => o -> m Bool

-- | Set the value of the “interpolate-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set stack [ #interpolateSize := value ]
--   
setStackInterpolateSize :: (MonadIO m, IsStack o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “interpolate-size” property. This is rarely needed directly,
--   but it is used by new.
constructStackInterpolateSize :: (IsStack o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “transition-duration” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stack #transitionDuration
--   
getStackTransitionDuration :: (MonadIO m, IsStack o) => o -> m Word32

-- | Set the value of the “transition-duration” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set stack [ #transitionDuration := value ]
--   
setStackTransitionDuration :: (MonadIO m, IsStack o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “transition-duration” property. This is rarely needed
--   directly, but it is used by new.
constructStackTransitionDuration :: (IsStack o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “transition-running” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stack #transitionRunning
--   
getStackTransitionRunning :: (MonadIO m, IsStack o) => o -> m Bool

-- | Get the value of the “transition-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stack #transitionType
--   
getStackTransitionType :: (MonadIO m, IsStack o) => o -> m StackTransitionType

-- | Set the value of the “transition-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set stack [ #transitionType := value ]
--   
setStackTransitionType :: (MonadIO m, IsStack o) => o -> StackTransitionType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “transition-type” property. This is rarely needed directly,
--   but it is used by new.
constructStackTransitionType :: (IsStack o, MonadIO m) => StackTransitionType -> m (GValueConstruct o)

-- | Get the value of the “vhomogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stack #vhomogeneous
--   
getStackVhomogeneous :: (MonadIO m, IsStack o) => o -> m Bool

-- | Set the value of the “vhomogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set stack [ #vhomogeneous := value ]
--   
setStackVhomogeneous :: (MonadIO m, IsStack o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “vhomogeneous” property. This is rarely needed directly, but
--   it is used by new.
constructStackVhomogeneous :: (IsStack o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “visible-child” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stack #visibleChild
--   
getStackVisibleChild :: (MonadIO m, IsStack o) => o -> m (Maybe Widget)

-- | Set the value of the “visible-child” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set stack [ #visibleChild := value ]
--   
setStackVisibleChild :: (MonadIO m, IsStack o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible-child” property. This is rarely needed directly, but
--   it is used by new.
constructStackVisibleChild :: (IsStack o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “visible-child-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stack #visibleChildName
--   
getStackVisibleChildName :: (MonadIO m, IsStack o) => o -> m (Maybe Text)

-- | Set the value of the “visible-child-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set stack [ #visibleChildName := value ]
--   
setStackVisibleChildName :: (MonadIO m, IsStack o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible-child-name” property. This is rarely needed
--   directly, but it is used by new.
constructStackVisibleChildName :: (IsStack o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Creates a new Stack container.
--   
--   Since: 3.10
stackNew :: (HasCallStack, MonadIO m) => m Stack

-- | Adds a child to stack. The child is identified by the
--   name.
--   
--   Since: 3.10
stackAddNamed :: (HasCallStack, MonadIO m, IsStack a, IsWidget b) => a -> b -> Text -> m ()

-- | Adds a child to stack. The child is identified by the
--   name. The title will be used by
--   StackSwitcher to represent child in a tab bar,
--   so it should be short.
--   
--   Since: 3.10
stackAddTitled :: (HasCallStack, MonadIO m, IsStack a, IsWidget b) => a -> b -> Text -> Text -> m ()

-- | Finds the child of the Stack with the name given as the
--   argument. Returns Nothing if there is no child with this name.
--   
--   Since: 3.12
stackGetChildByName :: (HasCallStack, MonadIO m, IsStack a) => a -> Text -> m (Maybe Widget)

-- | Gets whether stack is horizontally homogeneous. See
--   stackSetHhomogeneous.
--   
--   Since: 3.16
stackGetHhomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> m Bool

-- | Gets whether stack is homogeneous. See
--   stackSetHomogeneous.
--   
--   Since: 3.10
stackGetHomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> m Bool

-- | Returns wether the Stack is set up to interpolate between the
--   sizes of children on page switch.
--   
--   Since: 3.18
stackGetInterpolateSize :: (HasCallStack, MonadIO m, IsStack a) => a -> m Bool

-- | Returns the amount of time (in milliseconds) that transitions between
--   pages in stack will take.
--   
--   Since: 3.10
stackGetTransitionDuration :: (HasCallStack, MonadIO m, IsStack a) => a -> m Word32

-- | Returns whether the stack is currently in a transition
--   from one page to another.
--   
--   Since: 3.12
stackGetTransitionRunning :: (HasCallStack, MonadIO m, IsStack a) => a -> m Bool

-- | Gets the type of animation that will be used for transitions between
--   pages in stack.
--   
--   Since: 3.10
stackGetTransitionType :: (HasCallStack, MonadIO m, IsStack a) => a -> m StackTransitionType

-- | Gets whether stack is vertically homogeneous. See
--   stackSetVhomogeneous.
--   
--   Since: 3.16
stackGetVhomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> m Bool

-- | Gets the currently visible child of stack, or
--   Nothing if there are no visible children.
--   
--   Since: 3.10
stackGetVisibleChild :: (HasCallStack, MonadIO m, IsStack a) => a -> m (Maybe Widget)

-- | Returns the name of the currently visible child of
--   stack, or Nothing if there is no visible child.
--   
--   Since: 3.10
stackGetVisibleChildName :: (HasCallStack, MonadIO m, IsStack a) => a -> m (Maybe Text)

-- | Sets whether or not stack will interpolate its size
--   when changing the visible child. If the Stack:interpolateSize
--   property is set to True, stack 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.
--   
--   Since: 3.18
stackSetInterpolateSize :: (HasCallStack, MonadIO m, IsStack a) => a -> Bool -> m ()

-- | Sets the duration that transitions between pages in
--   stack will take.
--   
--   Since: 3.10
stackSetTransitionDuration :: (HasCallStack, MonadIO m, IsStack a) => a -> Word32 -> m ()

-- | Sets the type of animation that will be used for transitions between
--   pages in stack. 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.
--   
--   Since: 3.10
stackSetTransitionType :: (HasCallStack, MonadIO m, IsStack a) => a -> StackTransitionType -> m ()

-- | Makes child the visible child of
--   stack.
--   
--   If child is different from the currently visible
--   child, the transition between the two will be animated with the
--   current transition type of stack.
--   
--   Note that the child widget has to be visible itself
--   (see widgetShow) in order to become the visible child of
--   stack.
--   
--   Since: 3.10
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
--   widgetShow) in order to become the visible child of
--   stack.
--   
--   Since: 3.10
stackSetVisibleChildFull :: (HasCallStack, MonadIO m, IsStack a) => a -> Text -> StackTransitionType -> m ()

-- | Makes the child with the given name visible.
--   
--   If child is different from the currently visible
--   child, the transition between the two will be animated with the
--   current transition type of stack.
--   
--   Note that the child widget has to be visible itself (see
--   widgetShow) in order to become the visible child of
--   stack.
--   
--   Since: 3.10
stackSetVisibleChildName :: (HasCallStack, MonadIO m, IsStack a) => a -> Text -> m ()

-- | Type class for types which can be safely cast to StackSidebar,
--   for instance with toStackSidebar.
class (GObject o, IsDescendantOf StackSidebar o) => IsStackSidebar o

-- | Cast to StackSidebar, for types for which this is known to be
--   safe. For general casts, use castTo.
toStackSidebar :: (MonadIO m, IsStackSidebar o) => o -> m StackSidebar

-- | Get the value of the “stack” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stackSidebar #stack
--   
getStackSidebarStack :: (MonadIO m, IsStackSidebar o) => o -> m (Maybe Stack)

-- | Set the value of the “stack” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set stackSidebar [ #stack := value ]
--   
setStackSidebarStack :: (MonadIO m, IsStackSidebar o, IsStack a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “stack” property. This is rarely needed directly, but it is
--   used by new.
constructStackSidebarStack :: (IsStackSidebar o, MonadIO m, IsStack a) => a -> m (GValueConstruct o)

-- | Creates a new sidebar.
--   
--   Since: 3.16
stackSidebarNew :: (HasCallStack, MonadIO m) => m StackSidebar

-- | Retrieves the stack. See stackSidebarSetStack.
--   
--   Since: 3.16
stackSidebarGetStack :: (HasCallStack, MonadIO m, IsStackSidebar a) => a -> m (Maybe Stack)

-- | Type class for types which can be safely cast to Spinner, for
--   instance with toSpinner.
class (GObject o, IsDescendantOf Spinner o) => IsSpinner o

-- | Cast to Spinner, for types for which this is known to be safe.
--   For general casts, use castTo.
toSpinner :: (MonadIO m, IsSpinner o) => o -> m Spinner

-- | Get the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get spinner #active
--   
getSpinnerActive :: (MonadIO m, IsSpinner o) => o -> m Bool

-- | Set the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set spinner [ #active := value ]
--   
setSpinnerActive :: (MonadIO m, IsSpinner o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “active” property. This is rarely needed directly, but it is
--   used by new.
constructSpinnerActive :: (IsSpinner o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Returns a new spinner widget. Not yet started.
--   
--   Since: 2.20
spinnerNew :: (HasCallStack, MonadIO m) => m Spinner

-- | Starts the animation of the spinner.
--   
--   Since: 2.20
spinnerStart :: (HasCallStack, MonadIO m, IsSpinner a) => a -> m ()

-- | Stops the animation of the spinner.
--   
--   Since: 2.20
spinnerStop :: (HasCallStack, MonadIO m, IsSpinner a) => a -> m ()

-- | Type class for types which can be safely cast to Socket, for
--   instance with toSocket.
class (GObject o, IsDescendantOf Socket o) => IsSocket o

-- | Cast to Socket, for types for which this is known to be safe.
--   For general casts, use castTo.
toSocket :: (MonadIO m, IsSocket o) => o -> m Socket

-- | This signal is emitted when a client is removed from the socket. The
--   default action is to destroy the Socket widget, so if you want
--   to reuse it you must add a signal handler that returns True.
type SocketPlugRemovedCallback = IO Bool

-- | This signal is emitted when a client is successfully added to the
--   socket.
type SocketPlugAddedCallback = IO ()

-- | Connect a signal handler for the plugAdded signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on socket #plugAdded callback
--   
onSocketPlugAdded :: (IsSocket a, MonadIO m) => a -> ((?self :: a) => SocketPlugAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the plugAdded signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after socket #plugAdded callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterSocketPlugAdded :: (IsSocket a, MonadIO m) => a -> ((?self :: a) => SocketPlugAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the plugRemoved signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on socket #plugRemoved callback
--   
onSocketPlugRemoved :: (IsSocket a, MonadIO m) => a -> ((?self :: a) => SocketPlugRemovedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the plugRemoved signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after socket #plugRemoved callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterSocketPlugRemoved :: (IsSocket a, MonadIO m) => a -> ((?self :: a) => SocketPlugRemovedCallback) -> m SignalHandlerId

-- | Create a new empty Socket.
socketNew :: (HasCallStack, MonadIO m) => m Socket

-- | Retrieves the window of the plug. Use this to check if the plug has
--   been created inside of the socket.
--   
--   Since: 2.14
socketGetPlugWindow :: (HasCallStack, MonadIO m, IsSocket a) => a -> m (Maybe Window)

-- | Type class for types which can be safely cast to SizeGroup, for
--   instance with toSizeGroup.
class (GObject o, IsDescendantOf SizeGroup o) => IsSizeGroup o

-- | Cast to SizeGroup, for types for which this is known to be
--   safe. For general casts, use castTo.
toSizeGroup :: (MonadIO m, IsSizeGroup o) => o -> m SizeGroup

-- | Get the value of the “ignore-hidden” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get sizeGroup #ignoreHidden
--   
getSizeGroupIgnoreHidden :: (MonadIO m, IsSizeGroup o) => o -> m Bool

-- | Set the value of the “ignore-hidden” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set sizeGroup [ #ignoreHidden := value ]
--   
setSizeGroupIgnoreHidden :: (MonadIO m, IsSizeGroup o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “ignore-hidden” property. This is rarely needed directly, but
--   it is used by new.
constructSizeGroupIgnoreHidden :: (IsSizeGroup o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “mode” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get sizeGroup #mode
--   
getSizeGroupMode :: (MonadIO m, IsSizeGroup o) => o -> m SizeGroupMode

-- | Set the value of the “mode” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set sizeGroup [ #mode := value ]
--   
setSizeGroupMode :: (MonadIO m, IsSizeGroup o) => o -> SizeGroupMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “mode” property. This is rarely needed directly, but it is
--   used by new.
constructSizeGroupMode :: (IsSizeGroup o, MonadIO m) => SizeGroupMode -> m (GValueConstruct o)

-- | Create a new SizeGroup.
sizeGroupNew :: (HasCallStack, MonadIO m) => SizeGroupMode -> m SizeGroup

-- | Adds a widget to a SizeGroup. 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 sizeGroupSetMode.
--   
--   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.
--   
--   Since: 2.8
sizeGroupGetIgnoreHidden :: (HasCallStack, MonadIO m, IsSizeGroup a) => a -> m Bool

-- | Gets the current mode of the size group. See sizeGroupSetMode.
sizeGroupGetMode :: (HasCallStack, MonadIO m, IsSizeGroup a) => a -> m SizeGroupMode

-- | Returns the list of widgets associated with sizeGroup.
--   
--   Since: 2.10
sizeGroupGetWidgets :: (HasCallStack, MonadIO m, IsSizeGroup a) => a -> m [Widget]

-- | Removes a widget from a SizeGroup.
sizeGroupRemoveWidget :: (HasCallStack, MonadIO m, IsSizeGroup a, IsWidget b) => a -> b -> m ()

-- | Sets whether unmapped widgets should be ignored when calculating the
--   size.
--   
--   Since: 2.8
sizeGroupSetIgnoreHidden :: (HasCallStack, MonadIO m, IsSizeGroup a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to
--   ShortcutsWindow, for instance with toShortcutsWindow.
class (GObject o, IsDescendantOf ShortcutsWindow o) => IsShortcutsWindow o

-- | Cast to ShortcutsWindow, for types for which this is known to
--   be safe. For general casts, use castTo.
toShortcutsWindow :: (MonadIO m, IsShortcutsWindow o) => o -> m ShortcutsWindow

-- | The search 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 close 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 ()

-- | Connect a signal handler for the close signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on shortcutsWindow #close callback
--   
onShortcutsWindowClose :: (IsShortcutsWindow a, MonadIO m) => a -> ((?self :: a) => ShortcutsWindowCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the close signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after shortcutsWindow #close callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterShortcutsWindowClose :: (IsShortcutsWindow a, MonadIO m) => a -> ((?self :: a) => ShortcutsWindowCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the search signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on shortcutsWindow #search callback
--   
onShortcutsWindowSearch :: (IsShortcutsWindow a, MonadIO m) => a -> ((?self :: a) => ShortcutsWindowSearchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the search signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after shortcutsWindow #search callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterShortcutsWindowSearch :: (IsShortcutsWindow a, MonadIO m) => a -> ((?self :: a) => ShortcutsWindowSearchCallback) -> m SignalHandlerId

-- | Get the value of the “section-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsWindow #sectionName
--   
getShortcutsWindowSectionName :: (MonadIO m, IsShortcutsWindow o) => o -> m (Maybe Text)

-- | Set the value of the “section-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsWindow [ #sectionName := value ]
--   
setShortcutsWindowSectionName :: (MonadIO m, IsShortcutsWindow o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “section-name” property. This is rarely needed directly, but
--   it is used by new.
constructShortcutsWindowSectionName :: (IsShortcutsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “section-name” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #sectionName
--   
clearShortcutsWindowSectionName :: (MonadIO m, IsShortcutsWindow o) => o -> m ()

-- | Get the value of the “view-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsWindow #viewName
--   
getShortcutsWindowViewName :: (MonadIO m, IsShortcutsWindow o) => o -> m (Maybe Text)

-- | Set the value of the “view-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsWindow [ #viewName := value ]
--   
setShortcutsWindowViewName :: (MonadIO m, IsShortcutsWindow o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “view-name” property. This is rarely needed directly, but it
--   is used by new.
constructShortcutsWindowViewName :: (IsShortcutsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “view-name” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #viewName
--   
clearShortcutsWindowViewName :: (MonadIO m, IsShortcutsWindow o) => o -> m ()

-- | Type class for types which can be safely cast to Separator, for
--   instance with toSeparator.
class (GObject o, IsDescendantOf Separator o) => IsSeparator o

-- | Cast to Separator, for types for which this is known to be
--   safe. For general casts, use castTo.
toSeparator :: (MonadIO m, IsSeparator o) => o -> m Separator

-- | Creates a new Separator with the given orientation.
--   
--   Since: 3.0
separatorNew :: (HasCallStack, MonadIO m) => Orientation -> m Separator

-- | Type class for types which can be safely cast to VSeparator,
--   for instance with toVSeparator.
class (GObject o, IsDescendantOf VSeparator o) => IsVSeparator o

-- | Cast to VSeparator, for types for which this is known to be
--   safe. For general casts, use castTo.
toVSeparator :: (MonadIO m, IsVSeparator o) => o -> m VSeparator

-- | Creates a new VSeparator.
vSeparatorNew :: (HasCallStack, MonadIO m) => m VSeparator

-- | Type class for types which can be safely cast to
--   ScrolledWindow, for instance with toScrolledWindow.
class (GObject o, IsDescendantOf ScrolledWindow o) => IsScrolledWindow o

-- | Cast to ScrolledWindow, for types for which this is known to be
--   safe. For general casts, use castTo.
toScrolledWindow :: (MonadIO m, IsScrolledWindow o) => o -> m ScrolledWindow

-- | The scrollChild 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 moveFocusOut signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when focus is moved away
--   from the scrolled window by a keybinding. The Widget::moveFocus
--   signal is emitted with directionType on this scrolled
--   window’s toplevel parent in the container hierarchy. The default
--   bindings for this signal are Ctrl + Tab to move forward and
--   Ctrl + Shift + Tab to move backward.
type ScrolledWindowMoveFocusOutCallback = DirectionType -> IO ()

-- | The edgeReached 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
--   ScrolledWindow::edgeOvershot signal.
--   
--   Note: The pos argument is LTR/RTL aware, so callers
--   should be aware too if intending to provide behavior on horizontal
--   edges.
--   
--   Since: 3.16
type ScrolledWindowEdgeReachedCallback = PositionType -> IO ()

-- | The edgeOvershot 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
--   ScrolledWindow::edgeReached signal.
--   
--   Note: The pos argument is LTR/RTL aware, so callers
--   should be aware too if intending to provide behavior on horizontal
--   edges.
--   
--   Since: 3.16
type ScrolledWindowEdgeOvershotCallback = PositionType -> IO ()

-- | Connect a signal handler for the edgeOvershot signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on scrolledWindow #edgeOvershot callback
--   
onScrolledWindowEdgeOvershot :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowEdgeOvershotCallback) -> m SignalHandlerId

-- | Connect a signal handler for the edgeOvershot signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after scrolledWindow #edgeOvershot callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterScrolledWindowEdgeOvershot :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowEdgeOvershotCallback) -> m SignalHandlerId

-- | Connect a signal handler for the edgeReached signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on scrolledWindow #edgeReached callback
--   
onScrolledWindowEdgeReached :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowEdgeReachedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the edgeReached signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after scrolledWindow #edgeReached callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterScrolledWindowEdgeReached :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowEdgeReachedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveFocusOut signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on scrolledWindow #moveFocusOut callback
--   
onScrolledWindowMoveFocusOut :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowMoveFocusOutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveFocusOut signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after scrolledWindow #moveFocusOut callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterScrolledWindowMoveFocusOut :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowMoveFocusOutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the scrollChild signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on scrolledWindow #scrollChild callback
--   
onScrolledWindowScrollChild :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowScrollChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the scrollChild signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after scrolledWindow #scrollChild callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterScrolledWindowScrollChild :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowScrollChildCallback) -> m SignalHandlerId

-- | Get the value of the “hadjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #hadjustment
--   
getScrolledWindowHadjustment :: (MonadIO m, IsScrolledWindow o) => o -> m Adjustment

-- | Set the value of the “hadjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #hadjustment := value ]
--   
setScrolledWindowHadjustment :: (MonadIO m, IsScrolledWindow o, IsAdjustment a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “hadjustment” property. This is rarely needed directly, but
--   it is used by new.
constructScrolledWindowHadjustment :: (IsScrolledWindow o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Set the value of the “hadjustment” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #hadjustment
--   
clearScrolledWindowHadjustment :: (MonadIO m, IsScrolledWindow o) => o -> m ()

-- | Get the value of the “hscrollbar-policy” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #hscrollbarPolicy
--   
getScrolledWindowHscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> m PolicyType

-- | Set the value of the “hscrollbar-policy” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #hscrollbarPolicy := value ]
--   
setScrolledWindowHscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> PolicyType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “hscrollbar-policy” property. This is rarely needed directly,
--   but it is used by new.
constructScrolledWindowHscrollbarPolicy :: (IsScrolledWindow o, MonadIO m) => PolicyType -> m (GValueConstruct o)

-- | Get the value of the “kinetic-scrolling” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #kineticScrolling
--   
getScrolledWindowKineticScrolling :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “kinetic-scrolling” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #kineticScrolling := value ]
--   
setScrolledWindowKineticScrolling :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “kinetic-scrolling” property. This is rarely needed directly,
--   but it is used by new.
constructScrolledWindowKineticScrolling :: (IsScrolledWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “max-content-height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #maxContentHeight
--   
getScrolledWindowMaxContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> m Int32

-- | Set the value of the “max-content-height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #maxContentHeight := value ]
--   
setScrolledWindowMaxContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “max-content-height” property. This is rarely needed
--   directly, but it is used by new.
constructScrolledWindowMaxContentHeight :: (IsScrolledWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “max-content-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #maxContentWidth
--   
getScrolledWindowMaxContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> m Int32

-- | Set the value of the “max-content-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #maxContentWidth := value ]
--   
setScrolledWindowMaxContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “max-content-width” property. This is rarely needed directly,
--   but it is used by new.
constructScrolledWindowMaxContentWidth :: (IsScrolledWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “min-content-height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #minContentHeight
--   
getScrolledWindowMinContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> m Int32

-- | Set the value of the “min-content-height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #minContentHeight := value ]
--   
setScrolledWindowMinContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “min-content-height” property. This is rarely needed
--   directly, but it is used by new.
constructScrolledWindowMinContentHeight :: (IsScrolledWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “min-content-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #minContentWidth
--   
getScrolledWindowMinContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> m Int32

-- | Set the value of the “min-content-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #minContentWidth := value ]
--   
setScrolledWindowMinContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “min-content-width” property. This is rarely needed directly,
--   but it is used by new.
constructScrolledWindowMinContentWidth :: (IsScrolledWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “overlay-scrolling” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #overlayScrolling
--   
getScrolledWindowOverlayScrolling :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “overlay-scrolling” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #overlayScrolling := value ]
--   
setScrolledWindowOverlayScrolling :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “overlay-scrolling” property. This is rarely needed directly,
--   but it is used by new.
constructScrolledWindowOverlayScrolling :: (IsScrolledWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “propagate-natural-height” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #propagateNaturalHeight
--   
getScrolledWindowPropagateNaturalHeight :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “propagate-natural-height” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #propagateNaturalHeight := value ]
--   
setScrolledWindowPropagateNaturalHeight :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “propagate-natural-height” property. This is rarely needed
--   directly, but it is used by new.
constructScrolledWindowPropagateNaturalHeight :: (IsScrolledWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “propagate-natural-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #propagateNaturalWidth
--   
getScrolledWindowPropagateNaturalWidth :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “propagate-natural-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #propagateNaturalWidth := value ]
--   
setScrolledWindowPropagateNaturalWidth :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “propagate-natural-width” property. This is rarely needed
--   directly, but it is used by new.
constructScrolledWindowPropagateNaturalWidth :: (IsScrolledWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “shadow-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #shadowType
--   
getScrolledWindowShadowType :: (MonadIO m, IsScrolledWindow o) => o -> m ShadowType

-- | Set the value of the “shadow-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #shadowType := value ]
--   
setScrolledWindowShadowType :: (MonadIO m, IsScrolledWindow o) => o -> ShadowType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “shadow-type” property. This is rarely needed directly, but
--   it is used by new.
constructScrolledWindowShadowType :: (IsScrolledWindow o, MonadIO m) => ShadowType -> m (GValueConstruct o)

-- | Get the value of the “vadjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #vadjustment
--   
getScrolledWindowVadjustment :: (MonadIO m, IsScrolledWindow o) => o -> m Adjustment

-- | Set the value of the “vadjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #vadjustment := value ]
--   
setScrolledWindowVadjustment :: (MonadIO m, IsScrolledWindow o, IsAdjustment a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “vadjustment” property. This is rarely needed directly, but
--   it is used by new.
constructScrolledWindowVadjustment :: (IsScrolledWindow o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Set the value of the “vadjustment” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #vadjustment
--   
clearScrolledWindowVadjustment :: (MonadIO m, IsScrolledWindow o) => o -> m ()

-- | Get the value of the “vscrollbar-policy” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #vscrollbarPolicy
--   
getScrolledWindowVscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> m PolicyType

-- | Set the value of the “vscrollbar-policy” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #vscrollbarPolicy := value ]
--   
setScrolledWindowVscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> PolicyType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “vscrollbar-policy” property. This is rarely needed directly,
--   but it is used by new.
constructScrolledWindowVscrollbarPolicy :: (IsScrolledWindow o, MonadIO m) => PolicyType -> m (GValueConstruct o)

-- | Get the value of the “window-placement” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #windowPlacement
--   
getScrolledWindowWindowPlacement :: (MonadIO m, IsScrolledWindow o) => o -> m CornerType

-- | Set the value of the “window-placement” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #windowPlacement := value ]
--   
setScrolledWindowWindowPlacement :: (MonadIO m, IsScrolledWindow o) => o -> CornerType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “window-placement” property. This is rarely needed directly,
--   but it is used by new.
constructScrolledWindowWindowPlacement :: (IsScrolledWindow o, MonadIO m) => CornerType -> m (GValueConstruct o)

-- | Get the value of the “window-placement-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scrolledWindow #windowPlacementSet
--   
getScrolledWindowWindowPlacementSet :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “window-placement-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scrolledWindow [ #windowPlacementSet := value ]
--   
setScrolledWindowWindowPlacementSet :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “window-placement-set” property. This is rarely needed
--   directly, but it is used by new.
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 Nothing 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
--   containerAdd instead of this function.
--   
--   The viewport scrolls the child by moving its Window, and takes
--   the size of the child to be the size of its toplevel Window.
--   This will be very wrong for most widgets that support native
--   scrolling; for example, if you add a widget such as TreeView
--   with a viewport, the whole widget will scroll, including the column
--   headings. Thus, widgets with native scrolling support should not be
--   used with the Viewport proxy.
--   
--   A widget supports scrolling natively if it implements the
--   Scrollable interface.
scrolledWindowAddWithViewport :: (HasCallStack, MonadIO m, IsScrolledWindow a, IsWidget b) => a -> b -> m ()

-- | Return whether button presses are captured during kinetic scrolling.
--   See scrolledWindowSetCaptureButtonPress.
--   
--   Since: 3.4
scrolledWindowGetCaptureButtonPress :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Bool

-- | Returns the horizontal scrollbar of scrolledWindow.
--   
--   Since: 2.8
scrolledWindowGetHscrollbar :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Widget

-- | Returns the specified kinetic scrolling behavior.
--   
--   Since: 3.4
scrolledWindowGetKineticScrolling :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Bool

-- | Returns the maximum content height set.
--   
--   Since: 3.22
scrolledWindowGetMaxContentHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Int32

-- | Returns the maximum content width set.
--   
--   Since: 3.22
scrolledWindowGetMaxContentWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Int32

-- | Gets the minimal content height of scrolledWindow, or
--   -1 if not set.
--   
--   Since: 3.0
scrolledWindowGetMinContentHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Int32

-- | Gets the minimum content width of scrolledWindow, or
--   -1 if not set.
--   
--   Since: 3.0
scrolledWindowGetMinContentWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Int32

-- | Returns whether overlay scrolling is enabled for this scrolled window.
--   
--   Since: 3.16
scrolledWindowGetOverlayScrolling :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Bool

-- | Retrieves the current policy values for the horizontal and vertical
--   scrollbars. See scrolledWindowSetPolicy.
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.
--   
--   Since: 3.22
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.
--   
--   Since: 3.22
scrolledWindowGetPropagateNaturalWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Bool

-- | Gets the shadow type of the scrolled window. See
--   scrolledWindowSetShadowType.
scrolledWindowGetShadowType :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m ShadowType

-- | Returns the vertical scrollbar of scrolledWindow.
--   
--   Since: 2.8
scrolledWindowGetVscrollbar :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Widget

-- | Sets the Adjustment 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 InputSourceTouchscreen.
--   
--   Since: 3.4
scrolledWindowSetKineticScrolling :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Bool -> m ()

-- | Sets the maximum height that scrolledWindow should
--   keep visible. The scrolledWindow 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 ScrolledWindow:minContentHeight.
--   
--   Since: 3.22
scrolledWindowSetMaxContentHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Int32 -> m ()

-- | Sets the maximum width that scrolledWindow should keep
--   visible. The scrolledWindow 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 ScrolledWindow:minContentWidth.
--   
--   Since: 3.22
scrolledWindowSetMaxContentWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Int32 -> m ()

-- | Sets the minimum height that scrolledWindow 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 ScrolledWindow:maxContentHeight.
--   
--   Since: 3.0
scrolledWindowSetMinContentHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Int32 -> m ()

-- | Sets the minimum width that scrolledWindow 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 ScrolledWindow:maxContentWidth.
--   
--   Since: 3.0
scrolledWindowSetMinContentWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Int32 -> m ()

-- | Enables or disables overlay scrolling for this scrolled window.
--   
--   Since: 3.16
scrolledWindowSetOverlayScrolling :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Bool -> m ()

-- | Sets whether the natural height of the child should be calculated and
--   propagated through the scrolled window’s requested natural height.
--   
--   Since: 3.22
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.
--   
--   Since: 3.22
scrolledWindowSetPropagateNaturalWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Bool -> m ()

-- | Sets the Adjustment for the vertical scrollbar.
scrolledWindowSetVadjustment :: (HasCallStack, MonadIO m, IsScrolledWindow a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Type class for types which can be safely cast to Revealer, for
--   instance with toRevealer.
class (GObject o, IsDescendantOf Revealer o) => IsRevealer o

-- | Cast to Revealer, for types for which this is known to be safe.
--   For general casts, use castTo.
toRevealer :: (MonadIO m, IsRevealer o) => o -> m Revealer

-- | Get the value of the “child-revealed” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get revealer #childRevealed
--   
getRevealerChildRevealed :: (MonadIO m, IsRevealer o) => o -> m Bool

-- | Get the value of the “reveal-child” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get revealer #revealChild
--   
getRevealerRevealChild :: (MonadIO m, IsRevealer o) => o -> m Bool

-- | Set the value of the “reveal-child” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set revealer [ #revealChild := value ]
--   
setRevealerRevealChild :: (MonadIO m, IsRevealer o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “reveal-child” property. This is rarely needed directly, but
--   it is used by new.
constructRevealerRevealChild :: (IsRevealer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “transition-duration” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get revealer #transitionDuration
--   
getRevealerTransitionDuration :: (MonadIO m, IsRevealer o) => o -> m Word32

-- | Set the value of the “transition-duration” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set revealer [ #transitionDuration := value ]
--   
setRevealerTransitionDuration :: (MonadIO m, IsRevealer o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “transition-duration” property. This is rarely needed
--   directly, but it is used by new.
constructRevealerTransitionDuration :: (IsRevealer o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “transition-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get revealer #transitionType
--   
getRevealerTransitionType :: (MonadIO m, IsRevealer o) => o -> m RevealerTransitionType

-- | Set the value of the “transition-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set revealer [ #transitionType := value ]
--   
setRevealerTransitionType :: (MonadIO m, IsRevealer o) => o -> RevealerTransitionType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “transition-type” property. This is rarely needed directly,
--   but it is used by new.
constructRevealerTransitionType :: (IsRevealer o, MonadIO m) => RevealerTransitionType -> m (GValueConstruct o)

-- | Creates a new Revealer.
--   
--   Since: 3.10
revealerNew :: (HasCallStack, MonadIO m) => m Revealer

-- | Returns whether the child is currently revealed. See
--   revealerSetRevealChild.
--   
--   This function returns True 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
--   revealerGetChildRevealed.
--   
--   Since: 3.10
revealerGetRevealChild :: (HasCallStack, MonadIO m, IsRevealer a) => a -> m Bool

-- | Returns the amount of time (in milliseconds) that transitions will
--   take.
--   
--   Since: 3.10
revealerGetTransitionDuration :: (HasCallStack, MonadIO m, IsRevealer a) => a -> m Word32

-- | Gets the type of animation that will be used for transitions in
--   revealer.
--   
--   Since: 3.10
revealerGetTransitionType :: (HasCallStack, MonadIO m, IsRevealer a) => a -> m RevealerTransitionType

-- | Sets the duration that transitions will take.
--   
--   Since: 3.10
revealerSetTransitionDuration :: (HasCallStack, MonadIO m, IsRevealer a) => a -> Word32 -> m ()

-- | Sets the type of animation that will be used for transitions in
--   revealer. Available types include various kinds of
--   fades and slides.
--   
--   Since: 3.10
revealerSetTransitionType :: (HasCallStack, MonadIO m, IsRevealer a) => a -> RevealerTransitionType -> m ()

-- | Type class for types which can be safely cast to RecentFilter,
--   for instance with toRecentFilter.
class (GObject o, IsDescendantOf RecentFilter o) => IsRecentFilter o

-- | Cast to RecentFilter, for types for which this is known to be
--   safe. For general casts, use castTo.
toRecentFilter :: (MonadIO m, IsRecentFilter o) => o -> m RecentFilter

-- | Creates a new RecentFilter 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
--   recentFilterAddPattern, recentFilterAddMimeType,
--   recentFilterAddApplication, recentFilterAddAge. To
--   create a filter that accepts any recently used resource, use:
--   
--   
C code
--   
--   
--   GtkRecentFilter *filter = gtk_recent_filter_new ();
--   gtk_recent_filter_add_pattern (filter, "*");
--   
--   
--   Since: 2.10
recentFilterNew :: (HasCallStack, MonadIO m) => m RecentFilter

-- | Adds a rule that allows resources based on the name of the group to
--   which they belong
--   
--   Since: 2.10
recentFilterAddGroup :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> Text -> m ()

-- | Adds a rule allowing image files in the formats supported by
--   GdkPixbuf.
--   
--   Since: 2.10
recentFilterAddPixbufFormats :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> m ()

-- | Gets the human-readable name for the filter. See
--   recentFilterSetName.
--   
--   Since: 2.10
recentFilterGetName :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> m (Maybe Text)

-- | Type class for types which can be safely cast to Range, for
--   instance with toRange.
class (GObject o, IsDescendantOf Range o) => IsRange o

-- | Cast to Range, for types for which this is known to be safe.
--   For general casts, use castTo.
toRange :: (MonadIO m, IsRange o) => o -> m Range

-- | Emitted when the range value changes.
type RangeValueChangedCallback = IO ()

-- | Virtual function that moves the slider. Used for keybindings.
type RangeMoveSliderCallback = ScrollType -> IO ()

-- | The Range::changeValue 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 True to
--   prevent further processing. Or, by returning False, 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
--   GtkRangechangeValue signal is responsible for clamping the
--   value to the desired number of decimal digits; the default GTK+
--   handler clamps the value based on Range:roundDigits.
--   
--   Since: 2.6
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 ()

-- | Connect a signal handler for the adjustBounds signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on range #adjustBounds callback
--   
onRangeAdjustBounds :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeAdjustBoundsCallback) -> m SignalHandlerId

-- | Connect a signal handler for the adjustBounds signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after range #adjustBounds callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterRangeAdjustBounds :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeAdjustBoundsCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changeValue signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on range #changeValue callback
--   
onRangeChangeValue :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeChangeValueCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changeValue signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after range #changeValue callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterRangeChangeValue :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeChangeValueCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveSlider signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on range #moveSlider callback
--   
onRangeMoveSlider :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeMoveSliderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveSlider signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after range #moveSlider callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterRangeMoveSlider :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeMoveSliderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the valueChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on range #valueChanged callback
--   
onRangeValueChanged :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeValueChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the valueChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after range #valueChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterRangeValueChanged :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeValueChangedCallback) -> m SignalHandlerId

-- | Get the value of the “adjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get range #adjustment
--   
getRangeAdjustment :: (MonadIO m, IsRange o) => o -> m Adjustment

-- | Set the value of the “adjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set range [ #adjustment := value ]
--   
setRangeAdjustment :: (MonadIO m, IsRange o, IsAdjustment a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “adjustment” property. This is rarely needed directly, but it
--   is used by new.
constructRangeAdjustment :: (IsRange o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “fill-level” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get range #fillLevel
--   
getRangeFillLevel :: (MonadIO m, IsRange o) => o -> m Double

-- | Set the value of the “fill-level” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set range [ #fillLevel := value ]
--   
setRangeFillLevel :: (MonadIO m, IsRange o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “fill-level” property. This is rarely needed directly, but it
--   is used by new.
constructRangeFillLevel :: (IsRange o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “inverted” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get range #inverted
--   
getRangeInverted :: (MonadIO m, IsRange o) => o -> m Bool

-- | Set the value of the “inverted” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set range [ #inverted := value ]
--   
setRangeInverted :: (MonadIO m, IsRange o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “inverted” property. This is rarely needed directly, but it
--   is used by new.
constructRangeInverted :: (IsRange o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “lower-stepper-sensitivity” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get range #lowerStepperSensitivity
--   
getRangeLowerStepperSensitivity :: (MonadIO m, IsRange o) => o -> m SensitivityType

-- | Set the value of the “lower-stepper-sensitivity” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set range [ #lowerStepperSensitivity := value ]
--   
setRangeLowerStepperSensitivity :: (MonadIO m, IsRange o) => o -> SensitivityType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “lower-stepper-sensitivity” property. This is rarely needed
--   directly, but it is used by new.
constructRangeLowerStepperSensitivity :: (IsRange o, MonadIO m) => SensitivityType -> m (GValueConstruct o)

-- | Get the value of the “restrict-to-fill-level” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get range #restrictToFillLevel
--   
getRangeRestrictToFillLevel :: (MonadIO m, IsRange o) => o -> m Bool

-- | Set the value of the “restrict-to-fill-level” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set range [ #restrictToFillLevel := value ]
--   
setRangeRestrictToFillLevel :: (MonadIO m, IsRange o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “restrict-to-fill-level” property. This is rarely needed
--   directly, but it is used by new.
constructRangeRestrictToFillLevel :: (IsRange o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “round-digits” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get range #roundDigits
--   
getRangeRoundDigits :: (MonadIO m, IsRange o) => o -> m Int32

-- | Set the value of the “round-digits” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set range [ #roundDigits := value ]
--   
setRangeRoundDigits :: (MonadIO m, IsRange o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “round-digits” property. This is rarely needed directly, but
--   it is used by new.
constructRangeRoundDigits :: (IsRange o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “show-fill-level” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get range #showFillLevel
--   
getRangeShowFillLevel :: (MonadIO m, IsRange o) => o -> m Bool

-- | Set the value of the “show-fill-level” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set range [ #showFillLevel := value ]
--   
setRangeShowFillLevel :: (MonadIO m, IsRange o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-fill-level” property. This is rarely needed directly,
--   but it is used by new.
constructRangeShowFillLevel :: (IsRange o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “upper-stepper-sensitivity” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get range #upperStepperSensitivity
--   
getRangeUpperStepperSensitivity :: (MonadIO m, IsRange o) => o -> m SensitivityType

-- | Set the value of the “upper-stepper-sensitivity” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set range [ #upperStepperSensitivity := value ]
--   
setRangeUpperStepperSensitivity :: (MonadIO m, IsRange o) => o -> SensitivityType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “upper-stepper-sensitivity” property. This is rarely needed
--   directly, but it is used by new.
constructRangeUpperStepperSensitivity :: (IsRange o, MonadIO m) => SensitivityType -> m (GValueConstruct o)

-- | Gets the current position of the fill level indicator.
--   
--   Since: 2.12
rangeGetFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> m Double

-- | Gets the value set by rangeSetFlippable.
--   
--   Since: 2.18
rangeGetFlippable :: (HasCallStack, MonadIO m, IsRange a) => a -> m Bool

-- | Gets the value set by rangeSetInverted.
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.
--   
--   Since: 2.10
rangeGetLowerStepperSensitivity :: (HasCallStack, MonadIO m, IsRange a) => a -> m SensitivityType

-- | This function is useful mainly for Range subclasses.
--   
--   See rangeSetMinSliderSize.
--   
--   Since: 2.20
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->window coordinates.
--   
--   This function is useful mainly for Range subclasses.
--   
--   Since: 2.20
rangeGetRangeRect :: (HasCallStack, MonadIO m, IsRange a) => a -> m Rectangle

-- | Gets whether the range is restricted to the fill level.
--   
--   Since: 2.12
rangeGetRestrictToFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> m Bool

-- | Gets the number of digits to round the value to when it changes. See
--   Range::changeValue.
--   
--   Since: 2.24
rangeGetRoundDigits :: (HasCallStack, MonadIO m, IsRange a) => a -> m Int32

-- | Gets whether the range displays the fill level graphically.
--   
--   Since: 2.12
rangeGetShowFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> m Bool

-- | This function returns sliders range along the long dimension, in
--   widget->window coordinates.
--   
--   This function is useful mainly for Range subclasses.
--   
--   Since: 2.20
rangeGetSliderRange :: (HasCallStack, MonadIO m, IsRange a) => a -> m (Int32, Int32)

-- | This function is useful mainly for Range subclasses.
--   
--   See rangeSetSliderSizeFixed.
--   
--   Since: 2.20
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.
--   
--   Since: 2.10
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

-- | Sets the step and page sizes for the range. The step size is used when
--   the user clicks the Scrollbar arrows or moves Scale 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 ()

-- | Sets the sensitivity policy for the stepper that points to the 'lower'
--   end of the GtkRange’s adjustment.
--   
--   Since: 2.10
rangeSetLowerStepperSensitivity :: (HasCallStack, MonadIO m, IsRange a) => a -> SensitivityType -> m ()

-- | Sets the allowable values in the Range, and clamps the range
--   value to be between min and max. (If
--   the range has a non-zero page size, it is clamped between
--   min and max - page-size.)
rangeSetRange :: (HasCallStack, MonadIO m, IsRange a) => a -> Double -> Double -> m ()

-- | Sets the number of digits to round the value to when it changes. See
--   Range::changeValue.
--   
--   Since: 2.24
rangeSetRoundDigits :: (HasCallStack, MonadIO m, IsRange a) => a -> Int32 -> m ()

-- | Sets the sensitivity policy for the stepper that points to the 'upper'
--   end of the GtkRange’s adjustment.
--   
--   Since: 2.10
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 Range::valueChanged signal if the
--   value changes.
rangeSetValue :: (HasCallStack, MonadIO m, IsRange a) => a -> Double -> m ()

-- | Type class for types which can be safely cast to Scrollbar, for
--   instance with toScrollbar.
class (GObject o, IsDescendantOf Scrollbar o) => IsScrollbar o

-- | Cast to Scrollbar, for types for which this is known to be
--   safe. For general casts, use castTo.
toScrollbar :: (MonadIO m, IsScrollbar o) => o -> m Scrollbar

-- | Creates a new scrollbar with the given orientation.
--   
--   Since: 3.0
scrollbarNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Orientation -> Maybe a -> m Scrollbar

-- | Type class for types which can be safely cast to VScrollbar,
--   for instance with toVScrollbar.
class (GObject o, IsDescendantOf VScrollbar o) => IsVScrollbar o

-- | Cast to VScrollbar, for types for which this is known to be
--   safe. For general casts, use castTo.
toVScrollbar :: (MonadIO m, IsVScrollbar o) => o -> m VScrollbar

-- | Creates a new vertical scrollbar.
vScrollbarNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe a -> m VScrollbar

-- | Type class for types which can be safely cast to Scale, for
--   instance with toScale.
class (GObject o, IsDescendantOf Scale o) => IsScale o

-- | Cast to Scale, for types for which this is known to be safe.
--   For general casts, use castTo.
toScale :: (MonadIO m, IsScale o) => o -> m Scale

-- | Signal which allows you to change how the scale value is displayed.
--   Connect a signal handler which returns an allocated string
--   representing value. 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
--   Scale:digits property.
--   
--   Here's an example signal handler which displays a value 1.0 as with
--   "-->1.0<--".
--   
--   
C code
--   
--   
--   static gchar*
--   format_value_callback (GtkScale *scale,
--                          gdouble   value)
--   {
--     return g_strdup_printf ("-->\%0.*g<--",
--                             gtk_scale_get_digits (scale), value);
--    }
--   
type ScaleFormatValueCallback = Double -> IO Text

-- | Connect a signal handler for the formatValue signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on scale #formatValue callback
--   
onScaleFormatValue :: (IsScale a, MonadIO m) => a -> ((?self :: a) => ScaleFormatValueCallback) -> m SignalHandlerId

-- | Connect a signal handler for the formatValue signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after scale #formatValue callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterScaleFormatValue :: (IsScale a, MonadIO m) => a -> ((?self :: a) => ScaleFormatValueCallback) -> m SignalHandlerId

-- | Get the value of the “digits” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scale #digits
--   
getScaleDigits :: (MonadIO m, IsScale o) => o -> m Int32

-- | Set the value of the “digits” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scale [ #digits := value ]
--   
setScaleDigits :: (MonadIO m, IsScale o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “digits” property. This is rarely needed directly, but it is
--   used by new.
constructScaleDigits :: (IsScale o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “draw-value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scale #drawValue
--   
getScaleDrawValue :: (MonadIO m, IsScale o) => o -> m Bool

-- | Set the value of the “draw-value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scale [ #drawValue := value ]
--   
setScaleDrawValue :: (MonadIO m, IsScale o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “draw-value” property. This is rarely needed directly, but it
--   is used by new.
constructScaleDrawValue :: (IsScale o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “has-origin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scale #hasOrigin
--   
getScaleHasOrigin :: (MonadIO m, IsScale o) => o -> m Bool

-- | Set the value of the “has-origin” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scale [ #hasOrigin := value ]
--   
setScaleHasOrigin :: (MonadIO m, IsScale o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-origin” property. This is rarely needed directly, but it
--   is used by new.
constructScaleHasOrigin :: (IsScale o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “value-pos” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scale #valuePos
--   
getScaleValuePos :: (MonadIO m, IsScale o) => o -> m PositionType

-- | Set the value of the “value-pos” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scale [ #valuePos := value ]
--   
setScaleValuePos :: (MonadIO m, IsScale o) => o -> PositionType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “value-pos” property. This is rarely needed directly, but it
--   is used by new.
constructScaleValuePos :: (IsScale o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Creates a new Scale.
--   
--   Since: 3.0
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 min and
--   max (including min and
--   max) with the increment step.
--   step 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
--   step is a power of ten. If the resulting precision is
--   not suitable for your needs, use scaleSetDigits to correct it.
--   
--   Since: 3.0
scaleNewWithRange :: (HasCallStack, MonadIO m) => Orientation -> Double -> Double -> Double -> m Scale

-- | 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.
--   
--   Since: 3.4
scaleGetHasOrigin :: (HasCallStack, MonadIO m, IsScale a) => a -> m Bool

-- | Gets the Layout used to display the scale. The returned object
--   is owned by the scale so does not need to be freed by the caller.
--   
--   Since: 2.4
scaleGetLayout :: (HasCallStack, MonadIO m, IsScale a) => a -> m (Maybe Layout)

-- | Obtains the coordinates where the scale will draw the Layout
--   representing the text in the scale. Remember when using the
--   Layout function you need to convert to and from pixels using
--   PANGO_PIXELS() or SCALE.
--   
--   If the Scale:drawValue property is False, the return
--   values are undefined.
--   
--   Since: 2.4
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 Scale:hasOrigin is set to True (the default), the
--   scale will highlight the part of the trough between the origin (bottom
--   or left side) and the current value.
--   
--   Since: 3.4
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 ()

-- | Type class for types which can be safely cast to VScale, for
--   instance with toVScale.
class (GObject o, IsDescendantOf VScale o) => IsVScale o

-- | Cast to VScale, for types for which this is known to be safe.
--   For general casts, use castTo.
toVScale :: (MonadIO m, IsVScale o) => o -> m VScale

-- | Creates a new VScale.
vScaleNew :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m VScale

-- | Creates a new vertical scale widget that lets the user input a number
--   between min and max (including
--   min and max) with the increment
--   step. step 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
--   step is a power of ten. If the resulting precision is
--   not suitable for your needs, use scaleSetDigits to correct it.
vScaleNewWithRange :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m VScale

-- | Type class for types which can be safely cast to ProgressBar,
--   for instance with toProgressBar.
class (GObject o, IsDescendantOf ProgressBar o) => IsProgressBar o

-- | Cast to ProgressBar, for types for which this is known to be
--   safe. For general casts, use castTo.
toProgressBar :: (MonadIO m, IsProgressBar o) => o -> m ProgressBar

-- | Get the value of the “ellipsize” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get progressBar #ellipsize
--   
getProgressBarEllipsize :: (MonadIO m, IsProgressBar o) => o -> m EllipsizeMode

-- | Set the value of the “ellipsize” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set progressBar [ #ellipsize := value ]
--   
setProgressBarEllipsize :: (MonadIO m, IsProgressBar o) => o -> EllipsizeMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “ellipsize” property. This is rarely needed directly, but it
--   is used by new.
constructProgressBarEllipsize :: (IsProgressBar o, MonadIO m) => EllipsizeMode -> m (GValueConstruct o)

-- | Get the value of the “fraction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get progressBar #fraction
--   
getProgressBarFraction :: (MonadIO m, IsProgressBar o) => o -> m Double

-- | Set the value of the “fraction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set progressBar [ #fraction := value ]
--   
setProgressBarFraction :: (MonadIO m, IsProgressBar o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “fraction” property. This is rarely needed directly, but it
--   is used by new.
constructProgressBarFraction :: (IsProgressBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “inverted” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get progressBar #inverted
--   
getProgressBarInverted :: (MonadIO m, IsProgressBar o) => o -> m Bool

-- | Set the value of the “inverted” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set progressBar [ #inverted := value ]
--   
setProgressBarInverted :: (MonadIO m, IsProgressBar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “inverted” property. This is rarely needed directly, but it
--   is used by new.
constructProgressBarInverted :: (IsProgressBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “pulse-step” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get progressBar #pulseStep
--   
getProgressBarPulseStep :: (MonadIO m, IsProgressBar o) => o -> m Double

-- | Set the value of the “pulse-step” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set progressBar [ #pulseStep := value ]
--   
setProgressBarPulseStep :: (MonadIO m, IsProgressBar o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pulse-step” property. This is rarely needed directly, but it
--   is used by new.
constructProgressBarPulseStep :: (IsProgressBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “show-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get progressBar #showText
--   
getProgressBarShowText :: (MonadIO m, IsProgressBar o) => o -> m Bool

-- | Set the value of the “show-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set progressBar [ #showText := value ]
--   
setProgressBarShowText :: (MonadIO m, IsProgressBar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-text” property. This is rarely needed directly, but it
--   is used by new.
constructProgressBarShowText :: (IsProgressBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get progressBar #text
--   
getProgressBarText :: (MonadIO m, IsProgressBar o) => o -> m (Maybe Text)

-- | Set the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set progressBar [ #text := value ]
--   
setProgressBarText :: (MonadIO m, IsProgressBar o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text” property. This is rarely needed directly, but it is
--   used by new.
constructProgressBarText :: (IsProgressBar o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “text” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #text
--   
clearProgressBarText :: (MonadIO m, IsProgressBar o) => o -> m ()

-- | Creates a new ProgressBar.
progressBarNew :: (HasCallStack, MonadIO m) => m ProgressBar

-- | Returns the ellipsizing position of the progress bar. See
--   progressBarSetEllipsize.
--   
--   Since: 2.6
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 progressBarSetInverted.
progressBarGetInverted :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m Bool

-- | Retrieves the pulse step set with progressBarSetPulseStep.
progressBarGetPulseStep :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m Double

-- | Gets the value of the ProgressBar:showText property. See
--   progressBarSetShowText.
--   
--   Since: 3.0
progressBarGetShowText :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m Bool

-- | Retrieves the text that is displayed with the progress bar, if any,
--   otherwise Nothing. 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)

-- | 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 ()

-- | Causes the given text to appear next to the progress
--   bar.
--   
--   If text is Nothing and
--   ProgressBar:showText is True, the current value of
--   ProgressBar:fraction will be displayed as a percentage.
--   
--   If text is non-Nothing and
--   ProgressBar:showText is True, the text will be
--   displayed. In this case, it will not display the progress percentage.
--   If text is the empty string, the progress bar will
--   still be styled and sized suitably for containing text, as long as
--   ProgressBar:showText is True.
progressBarSetText :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> Maybe Text -> m ()

-- | Type class for types which can be safely cast to
--   PrintOperation, for instance with toPrintOperation.
class (GObject o, IsDescendantOf PrintOperation o) => IsPrintOperation o

-- | Cast to PrintOperation, for types for which this is known to be
--   safe. For general casts, use castTo.
toPrintOperation :: (MonadIO m, IsPrintOperation o) => o -> m 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.
--   
--   Since: 2.18
type PrintOperationUpdateCustomWidgetCallback = Widget -> PageSetup -> PrintSettings -> IO ()

-- | Emitted at between the various phases of the print operation. See
--   PrintStatus for the phases that are being discriminated. Use
--   printOperationGetStatus to find out the current status.
--   
--   Since: 2.10
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
--   setup will be in force only for printing this page.
--   
--   Since: 2.10
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
--   True from its handler for this signal. In order to use the
--   provided context for the preview implementation, it
--   must be given a suitable cairo context with
--   printContextSetCairoContext.
--   
--   The custom preview implementation can use
--   printOperationPreviewIsSelected and
--   printOperationPreviewRenderPage to find pages which are
--   selected for print and render them. The preview must be finished by
--   calling printOperationPreviewEndPreview (typically in response
--   to the user clicking a close button).
--   
--   Since: 2.10
type PrintOperationPreviewCallback = PrintOperationPreview -> PrintContext -> Maybe Window -> IO Bool

-- | Emitted after the PrintOperation::beginPrint signal, but before
--   the actual rendering starts. It keeps getting emitted until a
--   connected signal handler returns True.
--   
--   The paginate 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
--   printOperationSetNPages, and return True 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 beginPrint handler, and set the number of pages from
--   there.
--   
--   Since: 2.10
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
--   PrintOperation::beginPrint handler.
--   
--   Since: 2.10
type PrintOperationEndPrintCallback = PrintContext -> IO ()

-- | Emitted for every page that is printed. The signal handler must render
--   the pageNr's page onto the cairo context obtained from
--   context using printContextGetCairoContext.
--   
--   
C code
--   
--   
--   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, &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);
--   }
--   
--   
--   Use printOperationSetUseFullPage and
--   printOperationSetUnit before starting the print operation to
--   set up the transformation of the cairo context according to your
--   needs.
--   
--   Since: 2.10
type PrintOperationDrawPageCallback = PrintContext -> Int32 -> IO ()

-- | Emitted when the print operation run has finished doing everything
--   required for printing.
--   
--   result gives you information about what happened
--   during the run. If result is
--   PrintOperationResultError then you can call
--   printOperationGetError for more information.
--   
--   If you enabled print status tracking then
--   printOperationIsFinished may still return False after
--   PrintOperation::done was emitted.
--   
--   Since: 2.10
type PrintOperationDoneCallback = PrintOperationResult -> IO ()

-- | Emitted right before PrintOperation::beginPrint if you added a
--   custom widget in the PrintOperation::createCustomWidget
--   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.
--   
--   Since: 2.10
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 PrintOperation::customWidgetApply signal
--   is emitted on the operation. Then you can read out any information you
--   need from the widgets.
--   
--   Since: 2.10
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 beginPrint is to use the parameters from the
--   PrintContext and paginate the document accordingly, and then
--   set the number of pages with printOperationSetNPages.
--   
--   Since: 2.10
type PrintOperationBeginPrintCallback = PrintContext -> IO ()

-- | Connect a signal handler for the beginPrint signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on printOperation #beginPrint callback
--   
onPrintOperationBeginPrint :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationBeginPrintCallback) -> m SignalHandlerId

-- | Connect a signal handler for the beginPrint signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after printOperation #beginPrint callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPrintOperationBeginPrint :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationBeginPrintCallback) -> m SignalHandlerId

-- | Connect a signal handler for the createCustomWidget signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on printOperation #createCustomWidget callback
--   
onPrintOperationCreateCustomWidget :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationCreateCustomWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the createCustomWidget signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after printOperation #createCustomWidget callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPrintOperationCreateCustomWidget :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationCreateCustomWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the customWidgetApply signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on printOperation #customWidgetApply callback
--   
onPrintOperationCustomWidgetApply :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationCustomWidgetApplyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the customWidgetApply signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after printOperation #customWidgetApply callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPrintOperationCustomWidgetApply :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationCustomWidgetApplyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the done signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on printOperation #done callback
--   
onPrintOperationDone :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the done signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after printOperation #done callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPrintOperationDone :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the drawPage signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on printOperation #drawPage callback
--   
onPrintOperationDrawPage :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationDrawPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the drawPage signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after printOperation #drawPage callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPrintOperationDrawPage :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationDrawPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the endPrint signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on printOperation #endPrint callback
--   
onPrintOperationEndPrint :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationEndPrintCallback) -> m SignalHandlerId

-- | Connect a signal handler for the endPrint signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after printOperation #endPrint callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPrintOperationEndPrint :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationEndPrintCallback) -> m SignalHandlerId

-- | Connect a signal handler for the paginate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on printOperation #paginate callback
--   
onPrintOperationPaginate :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationPaginateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the paginate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after printOperation #paginate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPrintOperationPaginate :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationPaginateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preview signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on printOperation #preview callback
--   
onPrintOperationPreview :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preview signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after printOperation #preview callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPrintOperationPreview :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewCallback) -> m SignalHandlerId

-- | Connect a signal handler for the requestPageSetup signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on printOperation #requestPageSetup callback
--   
onPrintOperationRequestPageSetup :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationRequestPageSetupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the requestPageSetup signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after printOperation #requestPageSetup callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPrintOperationRequestPageSetup :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationRequestPageSetupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the statusChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on printOperation #statusChanged callback
--   
onPrintOperationStatusChanged :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationStatusChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the statusChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after printOperation #statusChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPrintOperationStatusChanged :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationStatusChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the updateCustomWidget signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on printOperation #updateCustomWidget callback
--   
onPrintOperationUpdateCustomWidget :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationUpdateCustomWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the updateCustomWidget signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after printOperation #updateCustomWidget callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPrintOperationUpdateCustomWidget :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationUpdateCustomWidgetCallback) -> m SignalHandlerId

-- | Get the value of the “allow-async” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #allowAsync
--   
getPrintOperationAllowAsync :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “allow-async” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set printOperation [ #allowAsync := value ]
--   
setPrintOperationAllowAsync :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “allow-async” property. This is rarely needed directly, but
--   it is used by new.
constructPrintOperationAllowAsync :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “current-page” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #currentPage
--   
getPrintOperationCurrentPage :: (MonadIO m, IsPrintOperation o) => o -> m Int32

-- | Set the value of the “current-page” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set printOperation [ #currentPage := value ]
--   
setPrintOperationCurrentPage :: (MonadIO m, IsPrintOperation o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “current-page” property. This is rarely needed directly, but
--   it is used by new.
constructPrintOperationCurrentPage :: (IsPrintOperation o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “custom-tab-label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #customTabLabel
--   
getPrintOperationCustomTabLabel :: (MonadIO m, IsPrintOperation o) => o -> m (Maybe Text)

-- | Set the value of the “custom-tab-label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set printOperation [ #customTabLabel := value ]
--   
setPrintOperationCustomTabLabel :: (MonadIO m, IsPrintOperation o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “custom-tab-label” property. This is rarely needed directly,
--   but it is used by new.
constructPrintOperationCustomTabLabel :: (IsPrintOperation o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “custom-tab-label” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #customTabLabel
--   
clearPrintOperationCustomTabLabel :: (MonadIO m, IsPrintOperation o) => o -> m ()

-- | Get the value of the “default-page-setup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #defaultPageSetup
--   
getPrintOperationDefaultPageSetup :: (MonadIO m, IsPrintOperation o) => o -> m PageSetup

-- | Set the value of the “default-page-setup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set printOperation [ #defaultPageSetup := value ]
--   
setPrintOperationDefaultPageSetup :: (MonadIO m, IsPrintOperation o, IsPageSetup a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “default-page-setup” property. This is rarely needed
--   directly, but it is used by new.
constructPrintOperationDefaultPageSetup :: (IsPrintOperation o, MonadIO m, IsPageSetup a) => a -> m (GValueConstruct o)

-- | Set the value of the “default-page-setup” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #defaultPageSetup
--   
clearPrintOperationDefaultPageSetup :: (MonadIO m, IsPrintOperation o) => o -> m ()

-- | Get the value of the “embed-page-setup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #embedPageSetup
--   
getPrintOperationEmbedPageSetup :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “embed-page-setup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set printOperation [ #embedPageSetup := value ]
--   
setPrintOperationEmbedPageSetup :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “embed-page-setup” property. This is rarely needed directly,
--   but it is used by new.
constructPrintOperationEmbedPageSetup :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “export-filename” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #exportFilename
--   
getPrintOperationExportFilename :: (MonadIO m, IsPrintOperation o) => o -> m (Maybe Text)

-- | Set the value of the “export-filename” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set printOperation [ #exportFilename := value ]
--   
setPrintOperationExportFilename :: (MonadIO m, IsPrintOperation o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “export-filename” property. This is rarely needed directly,
--   but it is used by new.
constructPrintOperationExportFilename :: (IsPrintOperation o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “export-filename” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #exportFilename
--   
clearPrintOperationExportFilename :: (MonadIO m, IsPrintOperation o) => o -> m ()

-- | Get the value of the “has-selection” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #hasSelection
--   
getPrintOperationHasSelection :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “has-selection” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set printOperation [ #hasSelection := value ]
--   
setPrintOperationHasSelection :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-selection” property. This is rarely needed directly, but
--   it is used by new.
constructPrintOperationHasSelection :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “job-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #jobName
--   
getPrintOperationJobName :: (MonadIO m, IsPrintOperation o) => o -> m (Maybe Text)

-- | Set the value of the “job-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set printOperation [ #jobName := value ]
--   
setPrintOperationJobName :: (MonadIO m, IsPrintOperation o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “job-name” property. This is rarely needed directly, but it
--   is used by new.
constructPrintOperationJobName :: (IsPrintOperation o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “n-pages” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #nPages
--   
getPrintOperationNPages :: (MonadIO m, IsPrintOperation o) => o -> m Int32

-- | Set the value of the “n-pages” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set printOperation [ #nPages := value ]
--   
setPrintOperationNPages :: (MonadIO m, IsPrintOperation o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “n-pages” property. This is rarely needed directly, but it is
--   used by new.
constructPrintOperationNPages :: (IsPrintOperation o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “n-pages-to-print” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #nPagesToPrint
--   
getPrintOperationNPagesToPrint :: (MonadIO m, IsPrintOperation o) => o -> m Int32

-- | Get the value of the “print-settings” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #printSettings
--   
getPrintOperationPrintSettings :: (MonadIO m, IsPrintOperation o) => o -> m PrintSettings

-- | Set the value of the “print-settings” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set printOperation [ #printSettings := value ]
--   
setPrintOperationPrintSettings :: (MonadIO m, IsPrintOperation o, IsPrintSettings a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “print-settings” property. This is rarely needed directly,
--   but it is used by new.
constructPrintOperationPrintSettings :: (IsPrintOperation o, MonadIO m, IsPrintSettings a) => a -> m (GValueConstruct o)

-- | Set the value of the “print-settings” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #printSettings
--   
clearPrintOperationPrintSettings :: (MonadIO m, IsPrintOperation o) => o -> m ()

-- | Get the value of the “show-progress” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #showProgress
--   
getPrintOperationShowProgress :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “show-progress” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set printOperation [ #showProgress := value ]
--   
setPrintOperationShowProgress :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-progress” property. This is rarely needed directly, but
--   it is used by new.
constructPrintOperationShowProgress :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “status” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #status
--   
getPrintOperationStatus :: (MonadIO m, IsPrintOperation o) => o -> m PrintStatus

-- | Get the value of the “status-string” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #statusString
--   
getPrintOperationStatusString :: (MonadIO m, IsPrintOperation o) => o -> m Text

-- | Get the value of the “support-selection” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #supportSelection
--   
getPrintOperationSupportSelection :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “support-selection” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set printOperation [ #supportSelection := value ]
--   
setPrintOperationSupportSelection :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “support-selection” property. This is rarely needed directly,
--   but it is used by new.
constructPrintOperationSupportSelection :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “track-print-status” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #trackPrintStatus
--   
getPrintOperationTrackPrintStatus :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “track-print-status” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set printOperation [ #trackPrintStatus := value ]
--   
setPrintOperationTrackPrintStatus :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “track-print-status” property. This is rarely needed
--   directly, but it is used by new.
constructPrintOperationTrackPrintStatus :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “unit” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get printOperation #unit
--   
getPrintOperationUnit :: (MonadIO m, IsPrintOperation o) => o -> m Unit

-- | Set the value of the “unit” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set printOperation [ #unit := value ]
--   
setPrintOperationUnit :: (MonadIO m, IsPrintOperation o) => o -> Unit -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “unit” property. This is rarely needed directly, but it is
--   used by new.
constructPrintOperationUnit :: (IsPrintOperation o, MonadIO m) => Unit -> m (GValueConstruct o)

-- | Get the value of the “use-full-page” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get printOperation #useFullPage
--   
getPrintOperationUseFullPage :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “use-full-page” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set printOperation [ #useFullPage := value ]
--   
setPrintOperationUseFullPage :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-full-page” property. This is rarely needed directly, but
--   it is used by new.
constructPrintOperationUseFullPage :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new PrintOperation.
--   
--   Since: 2.10
printOperationNew :: (HasCallStack, MonadIO m) => m PrintOperation

-- | Cancels a running print operation. This function may be called from a
--   PrintOperation::beginPrint, PrintOperation::paginate or
--   PrintOperation::drawPage signal handler to stop the currently
--   running print operation.
--   
--   Since: 2.10
printOperationCancel :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m ()

-- | Returns the default page setup, see
--   printOperationSetDefaultPageSetup.
--   
--   Since: 2.10
printOperationGetDefaultPageSetup :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m PageSetup

-- | Gets the value of PrintOperation:embedPageSetup property.
--   
--   Since: 2.18
printOperationGetEmbedPageSetup :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Bool

-- | Gets the value of PrintOperation:hasSelection property.
--   
--   Since: 2.18
printOperationGetHasSelection :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Bool

-- | Gets the value of PrintOperation:supportSelection property.
--   
--   Since: 2.18
printOperationGetSupportSelection :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Bool

-- | Sets the current page.
--   
--   If this is called before printOperationRun, the user will be
--   able to select to print only the current page.
--   
--   Note that this only makes sense for pre-paginated documents.
--   
--   Since: 2.10
printOperationSetCurrentPage :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Int32 -> m ()

-- | Sets the label for the tab holding custom widgets.
--   
--   Since: 2.10
printOperationSetCustomTabLabel :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Maybe Text -> m ()

-- | Embed page size combo box and orientation combo box into page setup
--   page. Selected page setup is stored as default page setup in
--   PrintOperation.
--   
--   Since: 2.18
printOperationSetEmbedPageSetup :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Sets up the PrintOperation 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.
--   
--   Since: 2.10
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 printOperationSetNPages in a callback of
--   PrintOperation::beginPrint.
--   
--   Since: 2.18
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.
--   
--   Since: 2.10
printOperationSetJobName :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Text -> m ()

-- | If showProgress is True, the print operation
--   will show a progress dialog during the print operation.
--   
--   Since: 2.10
printOperationSetShowProgress :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Sets whether selection is supported by PrintOperation.
--   
--   Since: 2.18
printOperationSetSupportSelection :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | If track_status is True, 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.
--   
--   Since: 2.10
printOperationSetTrackPrintStatus :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to Popover, for
--   instance with toPopover.
class (GObject o, IsDescendantOf Popover o) => IsPopover o

-- | Cast to Popover, for types for which this is known to be safe.
--   For general casts, use castTo.
toPopover :: (MonadIO m, IsPopover o) => o -> m Popover

-- | This signal is emitted when the popover is dismissed either through
--   API or user interaction.
--   
--   Since: 3.12
type PopoverClosedCallback = IO ()

-- | Connect a signal handler for the closed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on popover #closed callback
--   
onPopoverClosed :: (IsPopover a, MonadIO m) => a -> ((?self :: a) => PopoverClosedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the closed signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after popover #closed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPopoverClosed :: (IsPopover a, MonadIO m) => a -> ((?self :: a) => PopoverClosedCallback) -> m SignalHandlerId

-- | Get the value of the “constrain-to” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get popover #constrainTo
--   
getPopoverConstrainTo :: (MonadIO m, IsPopover o) => o -> m PopoverConstraint

-- | Set the value of the “constrain-to” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set popover [ #constrainTo := value ]
--   
setPopoverConstrainTo :: (MonadIO m, IsPopover o) => o -> PopoverConstraint -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “constrain-to” property. This is rarely needed directly, but
--   it is used by new.
constructPopoverConstrainTo :: (IsPopover o, MonadIO m) => PopoverConstraint -> m (GValueConstruct o)

-- | Get the value of the “modal” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get popover #modal
--   
getPopoverModal :: (MonadIO m, IsPopover o) => o -> m Bool

-- | Set the value of the “modal” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set popover [ #modal := value ]
--   
setPopoverModal :: (MonadIO m, IsPopover o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “modal” property. This is rarely needed directly, but it is
--   used by new.
constructPopoverModal :: (IsPopover o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “pointing-to” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get popover #pointingTo
--   
getPopoverPointingTo :: (MonadIO m, IsPopover o) => o -> m (Maybe Rectangle)

-- | Set the value of the “pointing-to” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set popover [ #pointingTo := value ]
--   
setPopoverPointingTo :: (MonadIO m, IsPopover o) => o -> Rectangle -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pointing-to” property. This is rarely needed directly, but
--   it is used by new.
constructPopoverPointingTo :: (IsPopover o, MonadIO m) => Rectangle -> m (GValueConstruct o)

-- | Get the value of the “position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get popover #position
--   
getPopoverPosition :: (MonadIO m, IsPopover o) => o -> m PositionType

-- | Set the value of the “position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set popover [ #position := value ]
--   
setPopoverPosition :: (MonadIO m, IsPopover o) => o -> PositionType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “position” property. This is rarely needed directly, but it
--   is used by new.
constructPopoverPosition :: (IsPopover o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Get the value of the “relative-to” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get popover #relativeTo
--   
getPopoverRelativeTo :: (MonadIO m, IsPopover o) => o -> m Widget

-- | Set the value of the “relative-to” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set popover [ #relativeTo := value ]
--   
setPopoverRelativeTo :: (MonadIO m, IsPopover o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “relative-to” property. This is rarely needed directly, but
--   it is used by new.
constructPopoverRelativeTo :: (IsPopover o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “relative-to” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #relativeTo
--   
clearPopoverRelativeTo :: (MonadIO m, IsPopover o) => o -> m ()

-- | Get the value of the “transitions-enabled” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get popover #transitionsEnabled
--   
getPopoverTransitionsEnabled :: (MonadIO m, IsPopover o) => o -> m Bool

-- | Set the value of the “transitions-enabled” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set popover [ #transitionsEnabled := value ]
--   
setPopoverTransitionsEnabled :: (MonadIO m, IsPopover o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “transitions-enabled” property. This is rarely needed
--   directly, but it is used by new.
constructPopoverTransitionsEnabled :: (IsPopover o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new popover to point to relativeTo
--   
--   Since: 3.12
popoverNew :: (HasCallStack, MonadIO m, IsWidget a) => Maybe a -> m Popover

-- | Establishes a binding between a Popover and a MenuModel.
--   
--   The contents of popover are removed and then refilled
--   with menu items according to model. When
--   model changes, popover is updated.
--   Calling this function twice on popover with different
--   model will cause the first binding to be replaced with
--   a binding to the new model. If model is Nothing
--   then any previous binding is undone and all children are removed.
--   
--   If actionNamespace is non-Nothing then the
--   effect is as if all actions mentioned in the model
--   have their names prefixed with the namespace, plus a dot. For example,
--   if the action “quit” is mentioned and actionNamespace
--   is “app” then the effective action name is “app.quit”.
--   
--   This function uses Actionable 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
--   MenuShell outside of a ApplicationWindow, then you will
--   need to attach your own action group to the widget hierarchy using
--   widgetInsertActionGroup. 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 MenuModel.
--   
--   Since: 3.12
popoverBindModel :: (HasCallStack, MonadIO m, IsPopover a, IsMenuModel b) => a -> Maybe b -> Maybe Text -> m ()

-- | Returns the constraint for placing this popover. See
--   popoverSetConstrainTo.
--   
--   Since: 3.20
popoverGetConstrainTo :: (HasCallStack, MonadIO m, IsPopover a) => a -> m PopoverConstraint

-- | Gets the widget that should be set as the default while the popover is
--   shown.
--   
--   Since: 3.18
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.
--   
--   Since: 3.12
popoverGetModal :: (HasCallStack, MonadIO m, IsPopover a) => a -> m Bool

-- | If a rectangle to point to has been set, this function will return
--   True and fill in rect with such rectangle,
--   otherwise it will return False and fill in rect
--   with the attached widget width and height if a widget exists,
--   otherwise it will zero-out rect.
popoverGetPointingTo :: (HasCallStack, MonadIO m, IsPopover a) => a -> m (Bool, Rectangle)

-- | Returns the preferred position of popover.
popoverGetPosition :: (HasCallStack, MonadIO m, IsPopover a) => a -> m PositionType

-- | Returns the widget popover is currently attached to
--   
--   Since: 3.12
popoverGetRelativeTo :: (HasCallStack, MonadIO m, IsPopover a) => a -> m Widget

-- | Returns whether show/hide transitions are enabled on this popover.
--   
--   Since: 3.16
popoverGetTransitionsEnabled :: (HasCallStack, MonadIO m, IsPopover a) => a -> m Bool

-- | Pops popover down.This is different than a
--   widgetHide call in that it shows the popover with a transition.
--   If you want to hide the popover without a transition, use
--   widgetHide.
--   
--   Since: 3.22
popoverPopdown :: (HasCallStack, MonadIO m, IsPopover a) => a -> m ()

-- | Pops popover up. This is different than a
--   widgetShow call in that it shows the popover with a transition.
--   If you want to show the popover without a transition, use
--   widgetShow.
--   
--   Since: 3.22
popoverPopup :: (HasCallStack, MonadIO m, IsPopover a) => a -> m ()

-- | Sets the widget that should be set as default widget while the popover
--   is shown (see windowSetDefault). Popover remembers the
--   previous default widget and reestablishes it when the popover is
--   dismissed.
--   
--   Since: 3.18
popoverSetDefaultWidget :: (HasCallStack, MonadIO m, IsPopover a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether popover 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.
--   
--   Since: 3.12
popoverSetModal :: (HasCallStack, MonadIO m, IsPopover a) => a -> Bool -> m ()

-- | Sets the rectangle that popover will point to, in the
--   coordinate space of the widget popover is attached to,
--   see popoverSetRelativeTo.
--   
--   Since: 3.12
popoverSetPointingTo :: (HasCallStack, MonadIO m, IsPopover a) => a -> Rectangle -> m ()

-- | Sets the preferred position for popover to appear. If
--   the popover 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 Popover may
--   choose to appear on the opposite side
--   
--   Since: 3.12
popoverSetPosition :: (HasCallStack, MonadIO m, IsPopover a) => a -> PositionType -> m ()

-- | Sets whether show/hide transitions are enabled on this popover
--   
--   Since: 3.16
popoverSetTransitionsEnabled :: (HasCallStack, MonadIO m, IsPopover a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to PopoverMenu,
--   for instance with toPopoverMenu.
class (GObject o, IsDescendantOf PopoverMenu o) => IsPopoverMenu o

-- | Cast to PopoverMenu, for types for which this is known to be
--   safe. For general casts, use castTo.
toPopoverMenu :: (MonadIO m, IsPopoverMenu o) => o -> m PopoverMenu

-- | Get the value of the “visible-submenu” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get popoverMenu #visibleSubmenu
--   
getPopoverMenuVisibleSubmenu :: (MonadIO m, IsPopoverMenu o) => o -> m (Maybe Text)

-- | Set the value of the “visible-submenu” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set popoverMenu [ #visibleSubmenu := value ]
--   
setPopoverMenuVisibleSubmenu :: (MonadIO m, IsPopoverMenu o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible-submenu” property. This is rarely needed directly,
--   but it is used by new.
constructPopoverMenuVisibleSubmenu :: (IsPopoverMenu o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “visible-submenu” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #visibleSubmenu
--   
clearPopoverMenuVisibleSubmenu :: (MonadIO m, IsPopoverMenu o) => o -> m ()

-- | Creates a new popover menu.
--   
--   Since: 3.16
popoverMenuNew :: (HasCallStack, MonadIO m) => m PopoverMenu

-- | Opens a submenu of the popover. The
--   name must be one of the names given to the submenus of
--   popover with
--   PopoverMenu:submenu, or "main" to switch back
--   to the main menu.
--   
--   ModelButton will open submenus automatically when the
--   ModelButton:menuName property is set, so this function is only
--   needed when you are using other kinds of widgets to initiate menu
--   changes.
--   
--   Since: 3.16
popoverMenuOpenSubmenu :: (HasCallStack, MonadIO m, IsPopoverMenu a) => a -> Text -> m ()

-- | Type class for types which can be safely cast to Plug, for
--   instance with toPlug.
class (GObject o, IsDescendantOf Plug o) => IsPlug o

-- | Cast to Plug, for types for which this is known to be safe. For
--   general casts, use castTo.
toPlug :: (MonadIO m, IsPlug o) => o -> m Plug

-- | Gets emitted when the plug becomes embedded in a socket.
type PlugEmbeddedCallback = IO ()

-- | Connect a signal handler for the embedded signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on plug #embedded callback
--   
onPlugEmbedded :: (IsPlug a, MonadIO m) => a -> ((?self :: a) => PlugEmbeddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the embedded signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after plug #embedded callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPlugEmbedded :: (IsPlug a, MonadIO m) => a -> ((?self :: a) => PlugEmbeddedCallback) -> m SignalHandlerId

-- | Get the value of the “embedded” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get plug #embedded
--   
getPlugEmbedded :: (MonadIO m, IsPlug o) => o -> m Bool

-- | Get the value of the “socket-window” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get plug #socketWindow
--   
getPlugSocketWindow :: (MonadIO m, IsPlug o) => o -> m (Maybe Window)

-- | Create a new plug widget inside the Socket identified by
--   socket_id.
--   
--   Since: 2.2
plugNewForDisplay :: (HasCallStack, MonadIO m, IsDisplay a) => a -> CULong -> m Plug

-- | Finish the initialization of plug for a given
--   Socket identified by socketId. This function
--   will generally only be used by classes deriving from Plug.
plugConstruct :: (HasCallStack, MonadIO m, IsPlug a) => a -> CULong -> m ()

-- | Finish the initialization of plug for a given
--   Socket identified by socketId which is
--   currently displayed on display. This function will
--   generally only be used by classes deriving from Plug.
--   
--   Since: 2.2
plugConstructForDisplay :: (HasCallStack, MonadIO m, IsPlug a, IsDisplay b) => a -> b -> CULong -> m ()

-- | Determines whether the plug is embedded in a socket.
--   
--   Since: 2.14
plugGetEmbedded :: (HasCallStack, MonadIO m, IsPlug a) => a -> m Bool

-- | Retrieves the socket the plug is embedded in.
--   
--   Since: 2.14
plugGetSocketWindow :: (HasCallStack, MonadIO m, IsPlug a) => a -> m (Maybe Window)

-- | Type class for types which can be safely cast to PlacesSidebar,
--   for instance with toPlacesSidebar.
class (GObject o, IsDescendantOf PlacesSidebar o) => IsPlacesSidebar o

-- | Cast to PlacesSidebar, for types for which this is known to be
--   safe. For general casts, use castTo.
toPlacesSidebar :: (MonadIO m, IsPlacesSidebar o) => o -> m PlacesSidebar

-- | 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 PlacesSidebar can track
--   the progress of the operation and, for example, show a notification.
--   
--   Since: 3.20
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.
--   
--   Since: 3.22.26
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.
--   
--   Since: 3.20
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.
--   
--   Since: 3.18
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.
--   
--   Since: 3.10
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".
--   
--   Since: 3.14
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,
--   fileMountEnclosingVolume.
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 selectedItem for each
--   menu item; during their callbacks, the application can use
--   placesSidebarGetLocation to get the file to which the item
--   refers.
--   
--   The selectedItem argument may be Nothing in
--   case the selection refers to a volume. In this case,
--   selectedVolume will be non-Nothing. In this
--   case, the calling application will have to objectRef the
--   selectedVolume and keep it around to use it in the
--   callback.
--   
--   The container 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 container always was a Menu,
--   and you were expected to add your items as
--   GtkMenuItems. Since 3.18, the popup may be implemented
--   as a Popover, in which case container will be
--   something else, e.g. a Box, to which you may add
--   GtkModelButtons or other widgets, such as
--   GtkEntries, GtkSpinButtons, etc. If
--   your application can deal with this situation, you can set
--   PlacesSidebar::populate-all to True to
--   request that this signal is emitted for populating popovers as well.
--   
--   Since: 3.10
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.
--   
--   Since: 3.10
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 PlacesSidebar can track the
--   progress of the operation and, for example, show a notification.
--   
--   Since: 3.20
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 destFile, and the
--   sourceFileList has the list of files that are dropped
--   into it and which should be copied/moved/etc. based on the specified
--   action.
--   
--   Since: 3.10
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 context for customary
--   actions, or it can check the type of the files indicated by
--   sourceFileList against the possible actions for the
--   destination destFile.
--   
--   The drag action to use must be the return value of the signal handler.
--   
--   Since: 3.10
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.
--   
--   Since: 3.10
type PlacesSidebarDragActionAskCallback = Int32 -> IO Int32

-- | Connect a signal handler for the dragActionAsk signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on placesSidebar #dragActionAsk callback
--   
onPlacesSidebarDragActionAsk :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarDragActionAskCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragActionAsk signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after placesSidebar #dragActionAsk callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPlacesSidebarDragActionAsk :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarDragActionAskCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragActionRequested signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on placesSidebar #dragActionRequested callback
--   
onPlacesSidebarDragActionRequested :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarDragActionRequestedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragActionRequested signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after placesSidebar #dragActionRequested callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPlacesSidebarDragActionRequested :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarDragActionRequestedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragPerformDrop signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on placesSidebar #dragPerformDrop callback
--   
onPlacesSidebarDragPerformDrop :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarDragPerformDropCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragPerformDrop signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after placesSidebar #dragPerformDrop callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPlacesSidebarDragPerformDrop :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarDragPerformDropCallback) -> m SignalHandlerId

-- | Connect a signal handler for the mount signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on placesSidebar #mount callback
--   
onPlacesSidebarMount :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarMountCallback) -> m SignalHandlerId

-- | Connect a signal handler for the mount signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after placesSidebar #mount callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPlacesSidebarMount :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarMountCallback) -> m SignalHandlerId

-- | Connect a signal handler for the openLocation signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on placesSidebar #openLocation callback
--   
onPlacesSidebarOpenLocation :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarOpenLocationCallback) -> m SignalHandlerId

-- | Connect a signal handler for the openLocation signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after placesSidebar #openLocation callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPlacesSidebarOpenLocation :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarOpenLocationCallback) -> m SignalHandlerId

-- | Connect a signal handler for the populatePopup signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on placesSidebar #populatePopup callback
--   
onPlacesSidebarPopulatePopup :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the populatePopup signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after placesSidebar #populatePopup callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPlacesSidebarPopulatePopup :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showConnectToServer signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on placesSidebar #showConnectToServer callback
--   
onPlacesSidebarShowConnectToServer :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowConnectToServerCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showConnectToServer signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after placesSidebar #showConnectToServer callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPlacesSidebarShowConnectToServer :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowConnectToServerCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showEnterLocation signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on placesSidebar #showEnterLocation callback
--   
onPlacesSidebarShowEnterLocation :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowEnterLocationCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showEnterLocation signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after placesSidebar #showEnterLocation callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPlacesSidebarShowEnterLocation :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowEnterLocationCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showErrorMessage signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on placesSidebar #showErrorMessage callback
--   
onPlacesSidebarShowErrorMessage :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowErrorMessageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showErrorMessage signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after placesSidebar #showErrorMessage callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPlacesSidebarShowErrorMessage :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowErrorMessageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showOtherLocations signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on placesSidebar #showOtherLocations callback
--   
onPlacesSidebarShowOtherLocations :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowOtherLocationsCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showOtherLocations signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after placesSidebar #showOtherLocations callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPlacesSidebarShowOtherLocations :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowOtherLocationsCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showOtherLocationsWithFlags
--   signal, to be run before the default handler. When overloading
--   is enabled, this is equivalent to
--   
--   
--   on placesSidebar #showOtherLocationsWithFlags callback
--   
onPlacesSidebarShowOtherLocationsWithFlags :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowOtherLocationsWithFlagsCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showOtherLocationsWithFlags
--   signal, to be run after the default handler. When overloading
--   is enabled, this is equivalent to
--   
--   
--   after placesSidebar #showOtherLocationsWithFlags callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPlacesSidebarShowOtherLocationsWithFlags :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowOtherLocationsWithFlagsCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showStarredLocation signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on placesSidebar #showStarredLocation callback
--   
onPlacesSidebarShowStarredLocation :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowStarredLocationCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showStarredLocation signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after placesSidebar #showStarredLocation callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPlacesSidebarShowStarredLocation :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowStarredLocationCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unmount signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on placesSidebar #unmount callback
--   
onPlacesSidebarUnmount :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarUnmountCallback) -> m SignalHandlerId

-- | Connect a signal handler for the unmount signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after placesSidebar #unmount callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPlacesSidebarUnmount :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarUnmountCallback) -> m SignalHandlerId

-- | Get the value of the “local-only” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get placesSidebar #localOnly
--   
getPlacesSidebarLocalOnly :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “local-only” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set placesSidebar [ #localOnly := value ]
--   
setPlacesSidebarLocalOnly :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “local-only” property. This is rarely needed directly, but it
--   is used by new.
constructPlacesSidebarLocalOnly :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “location” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get placesSidebar #location
--   
getPlacesSidebarLocation :: (MonadIO m, IsPlacesSidebar o) => o -> m (Maybe File)

-- | Set the value of the “location” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set placesSidebar [ #location := value ]
--   
setPlacesSidebarLocation :: (MonadIO m, IsPlacesSidebar o, IsFile a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “location” property. This is rarely needed directly, but it
--   is used by new.
constructPlacesSidebarLocation :: (IsPlacesSidebar o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Set the value of the “location” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #location
--   
clearPlacesSidebarLocation :: (MonadIO m, IsPlacesSidebar o) => o -> m ()

-- | Get the value of the “open-flags” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get placesSidebar #openFlags
--   
getPlacesSidebarOpenFlags :: (MonadIO m, IsPlacesSidebar o) => o -> m [PlacesOpenFlags]

-- | Set the value of the “open-flags” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set placesSidebar [ #openFlags := value ]
--   
setPlacesSidebarOpenFlags :: (MonadIO m, IsPlacesSidebar o) => o -> [PlacesOpenFlags] -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “open-flags” property. This is rarely needed directly, but it
--   is used by new.
constructPlacesSidebarOpenFlags :: (IsPlacesSidebar o, MonadIO m) => [PlacesOpenFlags] -> m (GValueConstruct o)

-- | Get the value of the “populate-all” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get placesSidebar #populateAll
--   
getPlacesSidebarPopulateAll :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “populate-all” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set placesSidebar [ #populateAll := value ]
--   
setPlacesSidebarPopulateAll :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “populate-all” property. This is rarely needed directly, but
--   it is used by new.
constructPlacesSidebarPopulateAll :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-connect-to-server” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get placesSidebar #showConnectToServer
--   
getPlacesSidebarShowConnectToServer :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “show-connect-to-server” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set placesSidebar [ #showConnectToServer := value ]
--   
setPlacesSidebarShowConnectToServer :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-connect-to-server” property. This is rarely needed
--   directly, but it is used by new.
constructPlacesSidebarShowConnectToServer :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-desktop” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get placesSidebar #showDesktop
--   
getPlacesSidebarShowDesktop :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “show-desktop” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set placesSidebar [ #showDesktop := value ]
--   
setPlacesSidebarShowDesktop :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-desktop” property. This is rarely needed directly, but
--   it is used by new.
constructPlacesSidebarShowDesktop :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-enter-location” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get placesSidebar #showEnterLocation
--   
getPlacesSidebarShowEnterLocation :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “show-enter-location” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set placesSidebar [ #showEnterLocation := value ]
--   
setPlacesSidebarShowEnterLocation :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-enter-location” property. This is rarely needed
--   directly, but it is used by new.
constructPlacesSidebarShowEnterLocation :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-other-locations” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get placesSidebar #showOtherLocations
--   
getPlacesSidebarShowOtherLocations :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “show-other-locations” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set placesSidebar [ #showOtherLocations := value ]
--   
setPlacesSidebarShowOtherLocations :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-other-locations” property. This is rarely needed
--   directly, but it is used by new.
constructPlacesSidebarShowOtherLocations :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-recent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get placesSidebar #showRecent
--   
getPlacesSidebarShowRecent :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “show-recent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set placesSidebar [ #showRecent := value ]
--   
setPlacesSidebarShowRecent :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-recent” property. This is rarely needed directly, but
--   it is used by new.
constructPlacesSidebarShowRecent :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-starred-location” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get placesSidebar #showStarredLocation
--   
getPlacesSidebarShowStarredLocation :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “show-starred-location” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set placesSidebar [ #showStarredLocation := value ]
--   
setPlacesSidebarShowStarredLocation :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-starred-location” property. This is rarely needed
--   directly, but it is used by new.
constructPlacesSidebarShowStarredLocation :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-trash” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get placesSidebar #showTrash
--   
getPlacesSidebarShowTrash :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “show-trash” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set placesSidebar [ #showTrash := value ]
--   
setPlacesSidebarShowTrash :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-trash” property. This is rarely needed directly, but it
--   is used by new.
constructPlacesSidebarShowTrash :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new PlacesSidebar widget.
--   
--   The application should connect to at least the
--   PlacesSidebar::openLocation signal to be notified when the user
--   makes a selection in the sidebar.
--   
--   Since: 3.10
placesSidebarNew :: (HasCallStack, MonadIO m) => m PlacesSidebar

-- | Returns the value previously set with
--   placesSidebarSetLocalOnly.
--   
--   Since: 3.12
placesSidebarGetLocalOnly :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | This function queries the bookmarks added by the user to the places
--   sidebar, and returns one of them. This function is used by
--   FileChooser to implement the “Alt-1”, “Alt-2”, etc. shortcuts,
--   which activate the cooresponding bookmark.
--   
--   Since: 3.10
placesSidebarGetNthBookmark :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Int32 -> m (Maybe File)

-- | Gets the open flags.
--   
--   Since: 3.10
placesSidebarGetOpenFlags :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m [PlacesOpenFlags]

-- | Returns the value previously set with
--   placesSidebarSetShowConnectToServer
placesSidebarGetShowConnectToServer :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Returns the value previously set with
--   placesSidebarSetShowDesktop
--   
--   Since: 3.10
placesSidebarGetShowDesktop :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Returns the value previously set with
--   placesSidebarSetShowEnterLocation
--   
--   Since: 3.14
placesSidebarGetShowEnterLocation :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Returns the value previously set with
--   placesSidebarSetShowOtherLocations
--   
--   Since: 3.18
placesSidebarGetShowOtherLocations :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Returns the value previously set with
--   placesSidebarSetShowRecent
--   
--   Since: 3.18
placesSidebarGetShowRecent :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Returns the value previously set with
--   placesSidebarSetShowStarredLocation
--   
--   Since: 3.22.26
placesSidebarGetShowStarredLocation :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Returns the value previously set with placesSidebarSetShowTrash
--   
--   Since: 3.18
placesSidebarGetShowTrash :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Gets the list of shortcuts.
--   
--   Since: 3.10
placesSidebarListShortcuts :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m [File]

-- | Removes an application-specific shortcut that has been previously been
--   inserted with placesSidebarAddShortcut. If the
--   location is not a shortcut in the sidebar, then
--   nothing is done.
--   
--   Since: 3.10
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.
--   
--   Since: 3.18
placesSidebarSetDropTargetsVisible :: (HasCallStack, MonadIO m, IsPlacesSidebar a, IsDragContext b) => a -> Bool -> b -> m ()

-- | Type class for types which can be safely cast to Paned, for
--   instance with toPaned.
class (GObject o, IsDescendantOf Paned o) => IsPaned o

-- | Cast to Paned, for types for which this is known to be safe.
--   For general casts, use castTo.
toPaned :: (MonadIO m, IsPaned o) => o -> m Paned

-- | The toggleHandleFocus 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.
--   
--   Since: 2.0
type PanedToggleHandleFocusCallback = IO Bool

-- | The moveHandle signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to move the handle when
--   the user is using key bindings to move it.
--   
--   Since: 2.0
type PanedMoveHandleCallback = ScrollType -> IO Bool

-- | The cycleHandleFocus 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.
--   
--   Since: 2.0
type PanedCycleHandleFocusCallback = Bool -> IO Bool

-- | The cycleChildFocus signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to cycle the focus
--   between the children of the paned.
--   
--   The default binding is f6.
--   
--   Since: 2.0
type PanedCycleChildFocusCallback = Bool -> IO Bool

-- | The cancelPosition 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.
--   
--   Since: 2.0
type PanedCancelPositionCallback = IO Bool

-- | The acceptPosition 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.
--   
--   Since: 2.0
type PanedAcceptPositionCallback = IO Bool

-- | Connect a signal handler for the acceptPosition signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on paned #acceptPosition callback
--   
onPanedAcceptPosition :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedAcceptPositionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the acceptPosition signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after paned #acceptPosition callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPanedAcceptPosition :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedAcceptPositionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cancelPosition signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on paned #cancelPosition callback
--   
onPanedCancelPosition :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCancelPositionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cancelPosition signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after paned #cancelPosition callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPanedCancelPosition :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCancelPositionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cycleChildFocus signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on paned #cycleChildFocus callback
--   
onPanedCycleChildFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCycleChildFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cycleChildFocus signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after paned #cycleChildFocus callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPanedCycleChildFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCycleChildFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cycleHandleFocus signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on paned #cycleHandleFocus callback
--   
onPanedCycleHandleFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCycleHandleFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cycleHandleFocus signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after paned #cycleHandleFocus callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPanedCycleHandleFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCycleHandleFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveHandle signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on paned #moveHandle callback
--   
onPanedMoveHandle :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedMoveHandleCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveHandle signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after paned #moveHandle callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPanedMoveHandle :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedMoveHandleCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleHandleFocus signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on paned #toggleHandleFocus callback
--   
onPanedToggleHandleFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedToggleHandleFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggleHandleFocus signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after paned #toggleHandleFocus callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterPanedToggleHandleFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedToggleHandleFocusCallback) -> m SignalHandlerId

-- | Get the value of the “max-position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get paned #maxPosition
--   
getPanedMaxPosition :: (MonadIO m, IsPaned o) => o -> m Int32

-- | Get the value of the “min-position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get paned #minPosition
--   
getPanedMinPosition :: (MonadIO m, IsPaned o) => o -> m Int32

-- | Get the value of the “position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get paned #position
--   
getPanedPosition :: (MonadIO m, IsPaned o) => o -> m Int32

-- | Set the value of the “position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set paned [ #position := value ]
--   
setPanedPosition :: (MonadIO m, IsPaned o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “position” property. This is rarely needed directly, but it
--   is used by new.
constructPanedPosition :: (IsPaned o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “position-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get paned #positionSet
--   
getPanedPositionSet :: (MonadIO m, IsPaned o) => o -> m Bool

-- | Set the value of the “position-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set paned [ #positionSet := value ]
--   
setPanedPositionSet :: (MonadIO m, IsPaned o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “position-set” property. This is rarely needed directly, but
--   it is used by new.
constructPanedPositionSet :: (IsPaned o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “wide-handle” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get paned #wideHandle
--   
getPanedWideHandle :: (MonadIO m, IsPaned o) => o -> m Bool

-- | Set the value of the “wide-handle” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set paned [ #wideHandle := value ]
--   
setPanedWideHandle :: (MonadIO m, IsPaned o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “wide-handle” property. This is rarely needed directly, but
--   it is used by new.
constructPanedWideHandle :: (IsPaned o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new Paned widget.
--   
--   Since: 3.0
panedNew :: (HasCallStack, MonadIO m) => Orientation -> m Paned

-- | Adds a child to the top or left pane with default parameters. This is
--   equivalent to gtk_paned_pack1 (paned, child, FALSE, TRUE).
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 gtk_paned_pack2 (paned, child, TRUE, TRUE).
panedAdd2 :: (HasCallStack, MonadIO m, IsPaned a, IsWidget b) => a -> b -> m ()

-- | Obtains the first child of the paned widget.
--   
--   Since: 2.4
panedGetChild1 :: (HasCallStack, MonadIO m, IsPaned a) => a -> m (Maybe Widget)

-- | Obtains the second child of the paned widget.
--   
--   Since: 2.4
panedGetChild2 :: (HasCallStack, MonadIO m, IsPaned a) => a -> m (Maybe Widget)

-- | Returns the Window 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.
--   
--   Since: 2.20
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 Paned:wideHandle property.
--   
--   Since: 3.16
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 Paned:wideHandle property.
--   
--   Since: 3.16
panedSetWideHandle :: (HasCallStack, MonadIO m, IsPaned a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to VPaned, for
--   instance with toVPaned.
class (GObject o, IsDescendantOf VPaned o) => IsVPaned o

-- | Cast to VPaned, for types for which this is known to be safe.
--   For general casts, use castTo.
toVPaned :: (MonadIO m, IsVPaned o) => o -> m VPaned

-- | Create a new VPaned
vPanedNew :: (HasCallStack, MonadIO m) => m VPaned

-- | Type class for types which can be safely cast to Overlay, for
--   instance with toOverlay.
class (GObject o, IsDescendantOf Overlay o) => IsOverlay o

-- | Cast to Overlay, for types for which this is known to be safe.
--   For general casts, use castTo.
toOverlay :: (MonadIO m, IsOverlay o) => o -> m Overlay

-- | The getChildPosition signal is emitted to determine the
--   position and size of any overlay child widgets. A handler for this
--   signal should fill allocation with the desired
--   position and size for widget, relative to the 'main'
--   child of overlay.
--   
--   The default handler for this signal uses the widget's
--   halign and valign properties to determine the position and gives the
--   widget its natural size (except that an alignment of AlignFill
--   will cause the overlay to be full-width/height). If the main child is
--   a ScrolledWindow, the overlays are placed relative to its
--   contents.
type OverlayGetChildPositionCallback = Widget -> Rectangle -> IO Bool

-- | Connect a signal handler for the getChildPosition signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on overlay #getChildPosition callback
--   
onOverlayGetChildPosition :: (IsOverlay a, MonadIO m) => a -> ((?self :: a) => OverlayGetChildPositionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the getChildPosition signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after overlay #getChildPosition callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterOverlayGetChildPosition :: (IsOverlay a, MonadIO m) => a -> ((?self :: a) => OverlayGetChildPositionCallback) -> m SignalHandlerId

-- | Creates a new Overlay.
--   
--   Since: 3.2
overlayNew :: (HasCallStack, MonadIO m) => m Overlay

-- | Adds widget to overlay.
--   
--   The widget will be stacked on top of the main widget added with
--   containerAdd.
--   
--   The position at which widget is placed is determined
--   from its Widget:halign and Widget:valign properties.
--   
--   Since: 3.2
overlayAddOverlay :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> b -> m ()

-- | Convenience function to get the value of the
--   Overlay:pass-through child property for
--   widget.
--   
--   Since: 3.18
overlayGetOverlayPassThrough :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> b -> m Bool

-- | Moves child to a new index in the list
--   of overlay children. The list contains overlays in the
--   order that these were added to overlay by default. See
--   also Overlay:index.
--   
--   A widget’s index in the overlay 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.
--   
--   Since: 3.18
overlayReorderOverlay :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Convenience function to set the value of the
--   Overlay:pass-through child property for
--   widget.
--   
--   Since: 3.18
overlaySetOverlayPassThrough :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> b -> Bool -> m ()

-- | Type class for types which can be safely cast to
--   OffscreenWindow, for instance with toOffscreenWindow.
class (GObject o, IsDescendantOf OffscreenWindow o) => IsOffscreenWindow o

-- | Cast to OffscreenWindow, for types for which this is known to
--   be safe. For general casts, use castTo.
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.
--   
--   Since: 2.20
offscreenWindowNew :: (HasCallStack, MonadIO m) => m OffscreenWindow

-- | Retrieves a snapshot of the contained widget in the form of a
--   Pixbuf. This is a new pixbuf with a reference count of 1, and
--   the application should unreference it once it is no longer needed.
--   
--   Since: 2.20
offscreenWindowGetPixbuf :: (HasCallStack, MonadIO m, IsOffscreenWindow a) => a -> m (Maybe Pixbuf)

-- | Type class for types which can be safely cast to NumerableIcon,
--   for instance with toNumerableIcon.
class (GObject o, IsDescendantOf NumerableIcon o) => IsNumerableIcon o

-- | Cast to NumerableIcon, for types for which this is known to be
--   safe. For general casts, use castTo.
toNumerableIcon :: (MonadIO m, IsNumerableIcon o) => o -> m NumerableIcon

-- | Get the value of the “background-icon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get numerableIcon #backgroundIcon
--   
getNumerableIconBackgroundIcon :: (MonadIO m, IsNumerableIcon o) => o -> m (Maybe Icon)

-- | Set the value of the “background-icon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set numerableIcon [ #backgroundIcon := value ]
--   
setNumerableIconBackgroundIcon :: (MonadIO m, IsNumerableIcon o, IsIcon a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background-icon” property. This is rarely needed directly,
--   but it is used by new.
constructNumerableIconBackgroundIcon :: (IsNumerableIcon o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “background-icon” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #backgroundIcon
--   
clearNumerableIconBackgroundIcon :: (MonadIO m, IsNumerableIcon o) => o -> m ()

-- | Get the value of the “background-icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get numerableIcon #backgroundIconName
--   
getNumerableIconBackgroundIconName :: (MonadIO m, IsNumerableIcon o) => o -> m (Maybe Text)

-- | Set the value of the “background-icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set numerableIcon [ #backgroundIconName := value ]
--   
setNumerableIconBackgroundIconName :: (MonadIO m, IsNumerableIcon o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background-icon-name” property. This is rarely needed
--   directly, but it is used by new.
constructNumerableIconBackgroundIconName :: (IsNumerableIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “background-icon-name” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #backgroundIconName
--   
clearNumerableIconBackgroundIconName :: (MonadIO m, IsNumerableIcon o) => o -> m ()

-- | Get the value of the “count” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get numerableIcon #count
--   
getNumerableIconCount :: (MonadIO m, IsNumerableIcon o) => o -> m Int32

-- | Set the value of the “count” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set numerableIcon [ #count := value ]
--   
setNumerableIconCount :: (MonadIO m, IsNumerableIcon o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “count” property. This is rarely needed directly, but it is
--   used by new.
constructNumerableIconCount :: (IsNumerableIcon o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get numerableIcon #label
--   
getNumerableIconLabel :: (MonadIO m, IsNumerableIcon o) => o -> m (Maybe Text)

-- | Set the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set numerableIcon [ #label := value ]
--   
setNumerableIconLabel :: (MonadIO m, IsNumerableIcon o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label” property. This is rarely needed directly, but it is
--   used by new.
constructNumerableIconLabel :: (IsNumerableIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “label” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #label
--   
clearNumerableIconLabel :: (MonadIO m, IsNumerableIcon o) => o -> m ()

-- | Get the value of the “style-context” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get numerableIcon #styleContext
--   
getNumerableIconStyleContext :: (MonadIO m, IsNumerableIcon o) => o -> m (Maybe StyleContext)

-- | Set the value of the “style-context” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set numerableIcon [ #styleContext := value ]
--   
setNumerableIconStyleContext :: (MonadIO m, IsNumerableIcon o, IsStyleContext a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “style-context” property. This is rarely needed directly, but
--   it is used by new.
constructNumerableIconStyleContext :: (IsNumerableIcon o, MonadIO m, IsStyleContext a) => a -> m (GValueConstruct o)

-- | Returns the Icon that was set as the base background image, or
--   Nothing if there’s none. The caller of this function does not
--   own a reference to the returned Icon.
--   
--   Since: 3.0
numerableIconGetBackgroundGicon :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> m (Maybe Icon)

-- | Returns the icon name used as the base background image, or
--   Nothing if there’s none.
--   
--   Since: 3.0
numerableIconGetBackgroundIconName :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> m (Maybe Text)

-- | Returns the value currently displayed by self.
--   
--   Since: 3.0
numerableIconGetCount :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> m Int32

-- | Returns the currently displayed label of the icon, or Nothing.
--   
--   Since: 3.0
numerableIconGetLabel :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> m (Maybe Text)

-- | Returns the StyleContext used by the icon for theming, or
--   Nothing if there’s none.
--   
--   Since: 3.0
numerableIconGetStyleContext :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> m (Maybe StyleContext)

-- | Creates a new unthemed NumerableIcon.
--   
--   Since: 3.0
numerableIconNew :: (HasCallStack, MonadIO m, IsIcon a) => a -> m Icon

-- | Creates a new NumerableIcon which will themed according to the
--   passed StyleContext. This is a convenience constructor that
--   calls numerableIconSetStyleContext internally.
--   
--   Since: 3.0
numerableIconNewWithStyleContext :: (HasCallStack, MonadIO m, IsIcon a, IsStyleContext b) => a -> b -> m Icon

-- | Type class for types which can be safely cast to Notebook, for
--   instance with toNotebook.
class (GObject o, IsDescendantOf Notebook o) => IsNotebook o

-- | Cast to Notebook, for types for which this is known to be safe.
--   For general casts, use castTo.
toNotebook :: (MonadIO m, IsNotebook o) => o -> m Notebook

-- | Emitted when the user or a function changes the current page.
type NotebookSwitchPageCallback = Widget -> Word32 -> IO ()

-- | No description available in the introspection data.
type NotebookSelectPageCallback = Bool -> IO Bool

-- | No description available in the introspection data.
type NotebookReorderTabCallback = DirectionType -> Bool -> IO Bool

-- | the pageReordered signal is emitted in the notebook right after
--   a page has been reordered.
--   
--   Since: 2.10
type NotebookPageReorderedCallback = Widget -> Word32 -> IO ()

-- | the pageRemoved signal is emitted in the notebook right after a
--   page is removed from the notebook.
--   
--   Since: 2.10
type NotebookPageRemovedCallback = Widget -> Word32 -> IO ()

-- | the pageAdded signal is emitted in the notebook right after a
--   page is added to the notebook.
--   
--   Since: 2.10
type NotebookPageAddedCallback = Widget -> Word32 -> IO ()

-- | No description available in the introspection data.
type NotebookMoveFocusOutCallback = DirectionType -> IO ()

-- | No description available in the introspection data.
type NotebookFocusTabCallback = NotebookTab -> IO Bool

-- | The createWindow 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 Notebook:groupName ).
--   
--   Since: 2.12
type NotebookCreateWindowCallback = Widget -> Int32 -> Int32 -> IO Notebook

-- | No description available in the introspection data.
type NotebookChangeCurrentPageCallback = Int32 -> IO Bool

-- | Connect a signal handler for the changeCurrentPage signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on notebook #changeCurrentPage callback
--   
onNotebookChangeCurrentPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookChangeCurrentPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changeCurrentPage signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after notebook #changeCurrentPage callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterNotebookChangeCurrentPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookChangeCurrentPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the createWindow signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on notebook #createWindow callback
--   
onNotebookCreateWindow :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookCreateWindowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the createWindow signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after notebook #createWindow callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterNotebookCreateWindow :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookCreateWindowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the focusTab signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on notebook #focusTab callback
--   
onNotebookFocusTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookFocusTabCallback) -> m SignalHandlerId

-- | Connect a signal handler for the focusTab signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after notebook #focusTab callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterNotebookFocusTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookFocusTabCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveFocusOut signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on notebook #moveFocusOut callback
--   
onNotebookMoveFocusOut :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookMoveFocusOutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveFocusOut signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after notebook #moveFocusOut callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterNotebookMoveFocusOut :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookMoveFocusOutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pageAdded signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on notebook #pageAdded callback
--   
onNotebookPageAdded :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pageAdded signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after notebook #pageAdded callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterNotebookPageAdded :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pageRemoved signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on notebook #pageRemoved callback
--   
onNotebookPageRemoved :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageRemovedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pageRemoved signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after notebook #pageRemoved callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterNotebookPageRemoved :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageRemovedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pageReordered signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on notebook #pageReordered callback
--   
onNotebookPageReordered :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageReorderedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pageReordered signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after notebook #pageReordered callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterNotebookPageReordered :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageReorderedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the reorderTab signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on notebook #reorderTab callback
--   
onNotebookReorderTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookReorderTabCallback) -> m SignalHandlerId

-- | Connect a signal handler for the reorderTab signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after notebook #reorderTab callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterNotebookReorderTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookReorderTabCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectPage signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on notebook #selectPage callback
--   
onNotebookSelectPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSelectPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectPage signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after notebook #selectPage callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterNotebookSelectPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSelectPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the switchPage signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on notebook #switchPage callback
--   
onNotebookSwitchPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSwitchPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the switchPage signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after notebook #switchPage callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterNotebookSwitchPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSwitchPageCallback) -> m SignalHandlerId

-- | Get the value of the “enable-popup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get notebook #enablePopup
--   
getNotebookEnablePopup :: (MonadIO m, IsNotebook o) => o -> m Bool

-- | Set the value of the “enable-popup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set notebook [ #enablePopup := value ]
--   
setNotebookEnablePopup :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “enable-popup” property. This is rarely needed directly, but
--   it is used by new.
constructNotebookEnablePopup :: (IsNotebook o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “group-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get notebook #groupName
--   
getNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> m (Maybe Text)

-- | Set the value of the “group-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set notebook [ #groupName := value ]
--   
setNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “group-name” property. This is rarely needed directly, but it
--   is used by new.
constructNotebookGroupName :: (IsNotebook o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “group-name” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #groupName
--   
clearNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> m ()

-- | Get the value of the “page” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get notebook #page
--   
getNotebookPage :: (MonadIO m, IsNotebook o) => o -> m Int32

-- | Set the value of the “page” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set notebook [ #page := value ]
--   
setNotebookPage :: (MonadIO m, IsNotebook o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “page” property. This is rarely needed directly, but it is
--   used by new.
constructNotebookPage :: (IsNotebook o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “scrollable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get notebook #scrollable
--   
getNotebookScrollable :: (MonadIO m, IsNotebook o) => o -> m Bool

-- | Set the value of the “scrollable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set notebook [ #scrollable := value ]
--   
setNotebookScrollable :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “scrollable” property. This is rarely needed directly, but it
--   is used by new.
constructNotebookScrollable :: (IsNotebook o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-border” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get notebook #showBorder
--   
getNotebookShowBorder :: (MonadIO m, IsNotebook o) => o -> m Bool

-- | Set the value of the “show-border” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set notebook [ #showBorder := value ]
--   
setNotebookShowBorder :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-border” property. This is rarely needed directly, but
--   it is used by new.
constructNotebookShowBorder :: (IsNotebook o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-tabs” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get notebook #showTabs
--   
getNotebookShowTabs :: (MonadIO m, IsNotebook o) => o -> m Bool

-- | Set the value of the “show-tabs” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set notebook [ #showTabs := value ]
--   
setNotebookShowTabs :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-tabs” property. This is rarely needed directly, but it
--   is used by new.
constructNotebookShowTabs :: (IsNotebook o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “tab-pos” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get notebook #tabPos
--   
getNotebookTabPos :: (MonadIO m, IsNotebook o) => o -> m PositionType

-- | Set the value of the “tab-pos” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set notebook [ #tabPos := value ]
--   
setNotebookTabPos :: (MonadIO m, IsNotebook o) => o -> PositionType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tab-pos” property. This is rarely needed directly, but it is
--   used by new.
constructNotebookTabPos :: (IsNotebook o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Creates a new Notebook widget with no pages.
notebookNew :: (HasCallStack, MonadIO m) => m Notebook

-- | Appends a page to notebook.
notebookAppendPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m Int32

-- | Appends a page to notebook, 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

-- | Gets one of the action widgets. See notebookSetActionWidget.
--   
--   Since: 2.20
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 notebook.
--   
--   Since: 2.24
notebookGetGroupName :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m (Maybe Text)

-- | Retrieves the menu label widget of the page containing
--   child.
notebookGetMenuLabel :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m (Maybe Widget)

-- | Retrieves the text of the menu label for the page containing
--   child.
notebookGetMenuLabelText :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m (Maybe Text)

-- | Gets the number of pages in a notebook.
--   
--   Since: 2.2
notebookGetNPages :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Int32

-- | Returns the child widget contained in page number
--   pageNum.
notebookGetNthPage :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Int32 -> m (Maybe Widget)

-- | Returns whether the tab label area has arrows for scrolling. See
--   notebookSetScrollable.
notebookGetScrollable :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Bool

-- | Returns whether a bevel will be drawn around the notebook pages. See
--   notebookSetShowBorder.
notebookGetShowBorder :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Bool

-- | Returns whether the tabs of the notebook are shown. See
--   notebookSetShowTabs.
notebookGetShowTabs :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Bool

-- | Returns whether the tab contents can be detached from
--   notebook.
--   
--   Since: 2.10
notebookGetTabDetachable :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m Bool

-- | Returns the horizontal width of a tab border.
--   
--   Since: 2.22
notebookGetTabHborder :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Word16

-- | Returns the tab label widget for the page child.
--   Nothing is returned if child is not in
--   notebook or if no tab label has specifically been set
--   for child.
notebookGetTabLabel :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m (Maybe Widget)

-- | Retrieves the text of the tab label for the page containing
--   child.
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.
--   
--   Since: 2.10
notebookGetTabReorderable :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m Bool

-- | Returns the vertical width of a tab border.
--   
--   Since: 2.22
notebookGetTabVborder :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Word16

-- | Insert a page into notebook 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 notebook 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 notebook.
notebookPrependPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m Int32

-- | Prepends a page to notebook, 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 child, so that it appears
--   in position position. If position is
--   greater than or equal to the number of children in the list or
--   negative, child will be moved to the end of the list.
notebookReorderChild :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Switches to the page number pageNum.
--   
--   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 ()

-- | Changes the menu label for the page containing child.
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
--   child.
notebookSetMenuLabelText :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> Text -> m ()

-- | Sets whether the tab can be detached from notebook to
--   another notebook or widget.
--   
--   Note that 2 notebooks must share a common group identificator (see
--   notebookSetGroupName) 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 notebookDetachTab instead of
--   containerRemove 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.
--   
--   
C code
--   
--   
--   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);
--   }
--   
--   
--   If you want a notebook to accept drags from other widgets, you will
--   have to set your own DnD code to do it.
--   
--   Since: 2.10
notebookSetTabDetachable :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> Bool -> m ()

-- | Changes the tab label for child. If Nothing is
--   specified for tabLabel, 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 child.
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.
--   
--   Since: 2.10
notebookSetTabReorderable :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> Bool -> m ()

-- | Type class for types which can be safely cast to NativeDialog,
--   for instance with toNativeDialog.
class (GObject o, IsDescendantOf NativeDialog o) => IsNativeDialog o

-- | Cast to NativeDialog, for types for which this is known to be
--   safe. For general casts, use castTo.
toNativeDialog :: (MonadIO m, IsNativeDialog o) => o -> m NativeDialog

-- | Emitted when the user responds to the dialog.
--   
--   When this is called the dialog has been hidden.
--   
--   If you call nativeDialogHide before the user responds to the
--   dialog this signal will not be emitted.
--   
--   Since: 3.20
type NativeDialogResponseCallback = Int32 -> IO ()

-- | Connect a signal handler for the response signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on nativeDialog #response callback
--   
onNativeDialogResponse :: (IsNativeDialog a, MonadIO m) => a -> ((?self :: a) => NativeDialogResponseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the response signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after nativeDialog #response callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterNativeDialogResponse :: (IsNativeDialog a, MonadIO m) => a -> ((?self :: a) => NativeDialogResponseCallback) -> m SignalHandlerId

-- | Get the value of the “modal” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get nativeDialog #modal
--   
getNativeDialogModal :: (MonadIO m, IsNativeDialog o) => o -> m Bool

-- | Set the value of the “modal” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set nativeDialog [ #modal := value ]
--   
setNativeDialogModal :: (MonadIO m, IsNativeDialog o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “modal” property. This is rarely needed directly, but it is
--   used by new.
constructNativeDialogModal :: (IsNativeDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get nativeDialog #title
--   
getNativeDialogTitle :: (MonadIO m, IsNativeDialog o) => o -> m (Maybe Text)

-- | Set the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set nativeDialog [ #title := value ]
--   
setNativeDialogTitle :: (MonadIO m, IsNativeDialog o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “title” property. This is rarely needed directly, but it is
--   used by new.
constructNativeDialogTitle :: (IsNativeDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “transient-for” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get nativeDialog #transientFor
--   
getNativeDialogTransientFor :: (MonadIO m, IsNativeDialog o) => o -> m (Maybe Window)

-- | Set the value of the “transient-for” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set nativeDialog [ #transientFor := value ]
--   
setNativeDialogTransientFor :: (MonadIO m, IsNativeDialog o, IsWindow a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “transient-for” property. This is rarely needed directly, but
--   it is used by new.
constructNativeDialogTransientFor :: (IsNativeDialog o, MonadIO m, IsWindow a) => a -> m (GValueConstruct o)

-- | Set the value of the “transient-for” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #transientFor
--   
clearNativeDialogTransientFor :: (MonadIO m, IsNativeDialog o) => o -> m ()

-- | Get the value of the “visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get nativeDialog #visible
--   
getNativeDialogVisible :: (MonadIO m, IsNativeDialog o) => o -> m Bool

-- | Set the value of the “visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set nativeDialog [ #visible := value ]
--   
setNativeDialogVisible :: (MonadIO m, IsNativeDialog o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible” property. This is rarely needed directly, but it is
--   used by new.
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 NativeDialog.
--   
--   Since: 3.20
nativeDialogDestroy :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m ()

-- | Returns whether the dialog is modal. See nativeDialogSetModal.
--   
--   Since: 3.20
nativeDialogGetModal :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m Bool

-- | Gets the title of the NativeDialog.
--   
--   Since: 3.20
nativeDialogGetTitle :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m (Maybe Text)

-- | Fetches the transient parent for this window. See
--   nativeDialogSetTransientFor.
--   
--   Since: 3.20
nativeDialogGetTransientFor :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m (Maybe Window)

-- | Determines whether the dialog is visible.
--   
--   Since: 3.20
nativeDialogGetVisible :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m Bool

-- | Sets the title of the NativeDialog.
--   
--   Since: 3.20
nativeDialogSetTitle :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> Text -> m ()

-- | Type class for types which can be safely cast to
--   MountOperation, for instance with toMountOperation.
class (GObject o, IsDescendantOf MountOperation o) => IsMountOperation o

-- | Cast to MountOperation, for types for which this is known to be
--   safe. For general casts, use castTo.
toMountOperation :: (MonadIO m, IsMountOperation o) => o -> m MountOperation

-- | Get the value of the “is-showing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get mountOperation #isShowing
--   
getMountOperationIsShowing :: (MonadIO m, IsMountOperation o) => o -> m Bool

-- | Get the value of the “parent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get mountOperation #parent
--   
getMountOperationParent :: (MonadIO m, IsMountOperation o) => o -> m Window

-- | Set the value of the “parent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set mountOperation [ #parent := value ]
--   
setMountOperationParent :: (MonadIO m, IsMountOperation o, IsWindow a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “parent” property. This is rarely needed directly, but it is
--   used by new.
constructMountOperationParent :: (IsMountOperation o, MonadIO m, IsWindow a) => a -> m (GValueConstruct o)

-- | Set the value of the “parent” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #parent
--   
clearMountOperationParent :: (MonadIO m, IsMountOperation o) => o -> m ()

-- | Get the value of the “screen” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get mountOperation #screen
--   
getMountOperationScreen :: (MonadIO m, IsMountOperation o) => o -> m Screen

-- | Set the value of the “screen” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set mountOperation [ #screen := value ]
--   
setMountOperationScreen :: (MonadIO m, IsMountOperation o, IsScreen a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “screen” property. This is rarely needed directly, but it is
--   used by new.
constructMountOperationScreen :: (IsMountOperation o, MonadIO m, IsScreen a) => a -> m (GValueConstruct o)

-- | Creates a new MountOperation
--   
--   Since: 2.14
mountOperationNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> m MountOperation

-- | Gets the transient parent used by the MountOperation
--   
--   Since: 2.14
mountOperationGetParent :: (HasCallStack, MonadIO m, IsMountOperation a) => a -> m Window

-- | Gets the screen on which windows of the MountOperation will be
--   shown.
--   
--   Since: 2.14
mountOperationGetScreen :: (HasCallStack, MonadIO m, IsMountOperation a) => a -> m Screen

-- | Returns whether the MountOperation is currently displaying a
--   window.
--   
--   Since: 2.14
mountOperationIsShowing :: (HasCallStack, MonadIO m, IsMountOperation a) => a -> m Bool

-- | Sets the transient parent for windows shown by the
--   MountOperation.
--   
--   Since: 2.14
mountOperationSetParent :: (HasCallStack, MonadIO m, IsMountOperation a, IsWindow b) => a -> Maybe b -> m ()

-- | Sets the screen to show windows of the MountOperation on.
--   
--   Since: 2.14
mountOperationSetScreen :: (HasCallStack, MonadIO m, IsMountOperation a, IsScreen b) => a -> b -> m ()

-- | Type class for types which can be safely cast to Misc, for
--   instance with toMisc.
class (GObject o, IsDescendantOf Misc o) => IsMisc o

-- | Cast to Misc, for types for which this is known to be safe. For
--   general casts, use castTo.
toMisc :: (MonadIO m, IsMisc o) => o -> m Misc

-- | Get the value of the “xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get misc #xalign
--   
getMiscXalign :: (MonadIO m, IsMisc o) => o -> m Float

-- | Set the value of the “xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set misc [ #xalign := value ]
--   
setMiscXalign :: (MonadIO m, IsMisc o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “xalign” property. This is rarely needed directly, but it is
--   used by new.
constructMiscXalign :: (IsMisc o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “xpad” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get misc #xpad
--   
getMiscXpad :: (MonadIO m, IsMisc o) => o -> m Int32

-- | Set the value of the “xpad” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set misc [ #xpad := value ]
--   
setMiscXpad :: (MonadIO m, IsMisc o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “xpad” property. This is rarely needed directly, but it is
--   used by new.
constructMiscXpad :: (IsMisc o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get misc #yalign
--   
getMiscYalign :: (MonadIO m, IsMisc o) => o -> m Float

-- | Set the value of the “yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set misc [ #yalign := value ]
--   
setMiscYalign :: (MonadIO m, IsMisc o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “yalign” property. This is rarely needed directly, but it is
--   used by new.
constructMiscYalign :: (IsMisc o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “ypad” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get misc #ypad
--   
getMiscYpad :: (MonadIO m, IsMisc o) => o -> m Int32

-- | Set the value of the “ypad” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set misc [ #ypad := value ]
--   
setMiscYpad :: (MonadIO m, IsMisc o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “ypad” property. This is rarely needed directly, but it is
--   used by new.
constructMiscYpad :: (IsMisc o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Gets the X and Y alignment of the widget within its allocation. See
--   miscSetAlignment.
miscGetAlignment :: (HasCallStack, MonadIO m, IsMisc a) => a -> m (Float, Float)

-- | Gets the padding in the X and Y directions of the widget. See
--   miscSetPadding.
miscGetPadding :: (HasCallStack, MonadIO m, IsMisc a) => a -> m (Int32, Int32)

-- | Type class for types which can be safely cast to LevelBar, for
--   instance with toLevelBar.
class (GObject o, IsDescendantOf LevelBar o) => IsLevelBar o

-- | Cast to LevelBar, for types for which this is known to be safe.
--   For general casts, use castTo.
toLevelBar :: (MonadIO m, IsLevelBar o) => o -> m LevelBar

-- | Emitted when an offset specified on the bar changes value as an effect
--   to levelBarAddOffsetValue being called.
--   
--   The signal supports detailed connections; you can connect to the
--   detailed signal "changedx" in order to only receive callbacks
--   when the value of offset "x" changes.
--   
--   Since: 3.6
type LevelBarOffsetChangedCallback = Text -> IO ()

-- | Connect a signal handler for the offsetChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on levelBar #offsetChanged callback
--   
--   
--   This signal admits a optional parameter detail. If it's not
--   Nothing, we will connect to “offset-changed::detail”
--   instead.
onLevelBarOffsetChanged :: (IsLevelBar a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => LevelBarOffsetChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the offsetChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after levelBar #offsetChanged callback
--   
--   
--   This signal admits a optional parameter detail. If it's not
--   Nothing, we will connect to “offset-changed::detail”
--   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
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterLevelBarOffsetChanged :: (IsLevelBar a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => LevelBarOffsetChangedCallback) -> m SignalHandlerId

-- | Get the value of the “inverted” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get levelBar #inverted
--   
getLevelBarInverted :: (MonadIO m, IsLevelBar o) => o -> m Bool

-- | Set the value of the “inverted” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set levelBar [ #inverted := value ]
--   
setLevelBarInverted :: (MonadIO m, IsLevelBar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “inverted” property. This is rarely needed directly, but it
--   is used by new.
constructLevelBarInverted :: (IsLevelBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “max-value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get levelBar #maxValue
--   
getLevelBarMaxValue :: (MonadIO m, IsLevelBar o) => o -> m Double

-- | Set the value of the “max-value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set levelBar [ #maxValue := value ]
--   
setLevelBarMaxValue :: (MonadIO m, IsLevelBar o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “max-value” property. This is rarely needed directly, but it
--   is used by new.
constructLevelBarMaxValue :: (IsLevelBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “min-value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get levelBar #minValue
--   
getLevelBarMinValue :: (MonadIO m, IsLevelBar o) => o -> m Double

-- | Set the value of the “min-value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set levelBar [ #minValue := value ]
--   
setLevelBarMinValue :: (MonadIO m, IsLevelBar o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “min-value” property. This is rarely needed directly, but it
--   is used by new.
constructLevelBarMinValue :: (IsLevelBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “mode” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get levelBar #mode
--   
getLevelBarMode :: (MonadIO m, IsLevelBar o) => o -> m LevelBarMode

-- | Set the value of the “mode” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set levelBar [ #mode := value ]
--   
setLevelBarMode :: (MonadIO m, IsLevelBar o) => o -> LevelBarMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “mode” property. This is rarely needed directly, but it is
--   used by new.
constructLevelBarMode :: (IsLevelBar o, MonadIO m) => LevelBarMode -> m (GValueConstruct o)

-- | Get the value of the “value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get levelBar #value
--   
getLevelBarValue :: (MonadIO m, IsLevelBar o) => o -> m Double

-- | Set the value of the “value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set levelBar [ #value := value ]
--   
setLevelBarValue :: (MonadIO m, IsLevelBar o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “value” property. This is rarely needed directly, but it is
--   used by new.
constructLevelBarValue :: (IsLevelBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Creates a new LevelBar.
--   
--   Since: 3.6
levelBarNew :: (HasCallStack, MonadIO m) => m LevelBar

-- | Utility constructor that creates a new LevelBar for the
--   specified interval.
--   
--   Since: 3.6
levelBarNewForInterval :: (HasCallStack, MonadIO m) => Double -> Double -> m LevelBar

-- | Return the value of the LevelBar:inverted property.
--   
--   Since: 3.8
levelBarGetInverted :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m Bool

-- | Returns the value of the LevelBar:maxValue property.
--   
--   Since: 3.6
levelBarGetMaxValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m Double

-- | Returns the value of the LevelBar:minValue property.
--   
--   Since: 3.6
levelBarGetMinValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m Double

-- | Returns the value of the LevelBar:mode property.
--   
--   Since: 3.6
levelBarGetMode :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m LevelBarMode

-- | Fetches the value specified for the offset marker name
--   in self, returning True in case an offset named
--   name was found.
--   
--   Since: 3.6
levelBarGetOffsetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Maybe Text -> m (Bool, Double)

-- | Returns the value of the LevelBar:value property.
--   
--   Since: 3.6
levelBarGetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m Double

-- | Removes an offset marker previously added with
--   levelBarAddOffsetValue.
--   
--   Since: 3.6
levelBarRemoveOffsetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Maybe Text -> m ()

-- | Sets the value of the LevelBar:inverted property.
--   
--   Since: 3.8
levelBarSetInverted :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Bool -> m ()

-- | Sets the value of the LevelBar:maxValue property.
--   
--   You probably want to update preexisting level offsets after calling
--   this function.
--   
--   Since: 3.6
levelBarSetMaxValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Double -> m ()

-- | Sets the value of the LevelBar:minValue property.
--   
--   You probably want to update preexisting level offsets after calling
--   this function.
--   
--   Since: 3.6
levelBarSetMinValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Double -> m ()

-- | Sets the value of the LevelBar:mode property.
--   
--   Since: 3.6
levelBarSetMode :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> LevelBarMode -> m ()

-- | Sets the value of the LevelBar:value property.
--   
--   Since: 3.6
levelBarSetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Double -> m ()

-- | Type class for types which can be safely cast to Layout, for
--   instance with toLayout.
class (GObject o, IsDescendantOf Layout o) => IsLayout o

-- | Cast to Layout, for types for which this is known to be safe.
--   For general casts, use castTo.
toLayout :: (MonadIO m, IsLayout o) => o -> m Layout

-- | Get the value of the “height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get layout #height
--   
getLayoutHeight :: (MonadIO m, IsLayout o) => o -> m Word32

-- | Set the value of the “height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set layout [ #height := value ]
--   
setLayoutHeight :: (MonadIO m, IsLayout o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “height” property. This is rarely needed directly, but it is
--   used by new.
constructLayoutHeight :: (IsLayout o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get layout #width
--   
getLayoutWidth :: (MonadIO m, IsLayout o) => o -> m Word32

-- | Set the value of the “width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set layout [ #width := value ]
--   
setLayoutWidth :: (MonadIO m, IsLayout o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “width” property. This is rarely needed directly, but it is
--   used by new.
constructLayoutWidth :: (IsLayout o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Creates a new Layout. Unless you have a specific adjustment
--   you’d like the layout to use for scrolling, pass Nothing for
--   hadjustment and vadjustment.
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.
--   
--   Since: 2.14
layoutGetBinWindow :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Window

-- | This function should only be called after the layout has been placed
--   in a ScrolledWindow or otherwise configured for scrolling. It
--   returns the Adjustment used for communication between the
--   horizontal scrollbar and layout.
--   
--   See ScrolledWindow, Scrollbar, Adjustment 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 ScrolledWindow or otherwise configured for scrolling. It
--   returns the Adjustment used for communication between the
--   vertical scrollbar and layout.
--   
--   See ScrolledWindow, Scrollbar, Adjustment for
--   details.
layoutGetVadjustment :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Adjustment

-- | Moves a current child of layout to a new position.
layoutMove :: (HasCallStack, MonadIO m, IsLayout a, IsWidget b) => a -> b -> Int32 -> Int32 -> m ()

-- | Adds childWidget to layout, at
--   position (x,y). layout
--   becomes the new parent container of childWidget.
layoutPut :: (HasCallStack, MonadIO m, IsLayout a, IsWidget b) => a -> b -> Int32 -> Int32 -> m ()

-- | Sets the horizontal scroll adjustment for the layout.
--   
--   See ScrolledWindow, Scrollbar, Adjustment 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 ScrolledWindow, Scrollbar, Adjustment for
--   details.
layoutSetVadjustment :: (HasCallStack, MonadIO m, IsLayout a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Type class for types which can be safely cast to Invisible, for
--   instance with toInvisible.
class (GObject o, IsDescendantOf Invisible o) => IsInvisible o

-- | Cast to Invisible, for types for which this is known to be
--   safe. For general casts, use castTo.
toInvisible :: (MonadIO m, IsInvisible o) => o -> m Invisible

-- | Get the value of the “screen” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get invisible #screen
--   
getInvisibleScreen :: (MonadIO m, IsInvisible o) => o -> m Screen

-- | Set the value of the “screen” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set invisible [ #screen := value ]
--   
setInvisibleScreen :: (MonadIO m, IsInvisible o, IsScreen a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “screen” property. This is rarely needed directly, but it is
--   used by new.
constructInvisibleScreen :: (IsInvisible o, MonadIO m, IsScreen a) => a -> m (GValueConstruct o)

-- | Creates a new Invisible.
invisibleNew :: (HasCallStack, MonadIO m) => m Invisible

-- | Creates a new Invisible object for a specified screen
--   
--   Since: 2.2
invisibleNewForScreen :: (HasCallStack, MonadIO m, IsScreen a) => a -> m Invisible

-- | Returns the Screen object associated with
--   invisible
--   
--   Since: 2.2
invisibleGetScreen :: (HasCallStack, MonadIO m, IsInvisible a) => a -> m Screen

-- | Sets the Screen where the Invisible object will be
--   displayed.
--   
--   Since: 2.2
invisibleSetScreen :: (HasCallStack, MonadIO m, IsInvisible a, IsScreen b) => a -> b -> m ()

-- | Type class for types which can be safely cast to Image, for
--   instance with toImage.
class (GObject o, IsDescendantOf Image o) => IsImage o

-- | Cast to Image, for types for which this is known to be safe.
--   For general casts, use castTo.
toImage :: (MonadIO m, IsImage o) => o -> m Image

-- | Get the value of the “file” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get image #file
--   
getImageFile :: (MonadIO m, IsImage o) => o -> m (Maybe Text)

-- | Set the value of the “file” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set image [ #file := value ]
--   
setImageFile :: (MonadIO m, IsImage o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “file” property. This is rarely needed directly, but it is
--   used by new.
constructImageFile :: (IsImage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “file” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #file
--   
clearImageFile :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “gicon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get image #gicon
--   
getImageGicon :: (MonadIO m, IsImage o) => o -> m (Maybe Icon)

-- | Set the value of the “gicon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set image [ #gicon := value ]
--   
setImageGicon :: (MonadIO m, IsImage o, IsIcon a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gicon” property. This is rarely needed directly, but it is
--   used by new.
constructImageGicon :: (IsImage o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “gicon” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #gicon
--   
clearImageGicon :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get image #iconName
--   
getImageIconName :: (MonadIO m, IsImage o) => o -> m (Maybe Text)

-- | Set the value of the “icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set image [ #iconName := value ]
--   
setImageIconName :: (MonadIO m, IsImage o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-name” property. This is rarely needed directly, but it
--   is used by new.
constructImageIconName :: (IsImage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “icon-name” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #iconName
--   
clearImageIconName :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “icon-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get image #iconSet
--   
getImageIconSet :: (MonadIO m, IsImage o) => o -> m (Maybe IconSet)

-- | Set the value of the “icon-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set image [ #iconSet := value ]
--   
setImageIconSet :: (MonadIO m, IsImage o) => o -> IconSet -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-set” property. This is rarely needed directly, but it
--   is used by new.
constructImageIconSet :: (IsImage o, MonadIO m) => IconSet -> m (GValueConstruct o)

-- | Set the value of the “icon-set” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #iconSet
--   
clearImageIconSet :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “icon-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get image #iconSize
--   
getImageIconSize :: (MonadIO m, IsImage o) => o -> m Int32

-- | Set the value of the “icon-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set image [ #iconSize := value ]
--   
setImageIconSize :: (MonadIO m, IsImage o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-size” property. This is rarely needed directly, but it
--   is used by new.
constructImageIconSize :: (IsImage o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “pixbuf” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get image #pixbuf
--   
getImagePixbuf :: (MonadIO m, IsImage o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “pixbuf” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set image [ #pixbuf := value ]
--   
setImagePixbuf :: (MonadIO m, IsImage o, IsPixbuf a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixbuf” property. This is rarely needed directly, but it is
--   used by new.
constructImagePixbuf :: (IsImage o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “pixbuf” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #pixbuf
--   
clearImagePixbuf :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “pixbuf-animation” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get image #pixbufAnimation
--   
getImagePixbufAnimation :: (MonadIO m, IsImage o) => o -> m (Maybe PixbufAnimation)

-- | Set the value of the “pixbuf-animation” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set image [ #pixbufAnimation := value ]
--   
setImagePixbufAnimation :: (MonadIO m, IsImage o, IsPixbufAnimation a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixbuf-animation” property. This is rarely needed directly,
--   but it is used by new.
constructImagePixbufAnimation :: (IsImage o, MonadIO m, IsPixbufAnimation a) => a -> m (GValueConstruct o)

-- | Set the value of the “pixbuf-animation” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #pixbufAnimation
--   
clearImagePixbufAnimation :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “pixel-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get image #pixelSize
--   
getImagePixelSize :: (MonadIO m, IsImage o) => o -> m Int32

-- | Set the value of the “pixel-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set image [ #pixelSize := value ]
--   
setImagePixelSize :: (MonadIO m, IsImage o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixel-size” property. This is rarely needed directly, but it
--   is used by new.
constructImagePixelSize :: (IsImage o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “resource” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get image #resource
--   
getImageResource :: (MonadIO m, IsImage o) => o -> m (Maybe Text)

-- | Set the value of the “resource” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set image [ #resource := value ]
--   
setImageResource :: (MonadIO m, IsImage o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “resource” property. This is rarely needed directly, but it
--   is used by new.
constructImageResource :: (IsImage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “resource” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #resource
--   
clearImageResource :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “stock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get image #stock
--   
getImageStock :: (MonadIO m, IsImage o) => o -> m (Maybe Text)

-- | Set the value of the “stock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set image [ #stock := value ]
--   
setImageStock :: (MonadIO m, IsImage o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “stock” property. This is rarely needed directly, but it is
--   used by new.
constructImageStock :: (IsImage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “stock” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #stock
--   
clearImageStock :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “storage-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get image #storageType
--   
getImageStorageType :: (MonadIO m, IsImage o) => o -> m ImageType

-- | Get the value of the “surface” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get image #surface
--   
getImageSurface :: (MonadIO m, IsImage o) => o -> m (Maybe Surface)

-- | Set the value of the “surface” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set image [ #surface := value ]
--   
setImageSurface :: (MonadIO m, IsImage o) => o -> Surface -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “surface” property. This is rarely needed directly, but it is
--   used by new.
constructImageSurface :: (IsImage o, MonadIO m) => Surface -> m (GValueConstruct o)

-- | Set the value of the “surface” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #surface
--   
clearImageSurface :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “use-fallback” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get image #useFallback
--   
getImageUseFallback :: (MonadIO m, IsImage o) => o -> m Bool

-- | Set the value of the “use-fallback” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set image [ #useFallback := value ]
--   
setImageUseFallback :: (MonadIO m, IsImage o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-fallback” property. This is rarely needed directly, but
--   it is used by new.
constructImageUseFallback :: (IsImage o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new empty Image widget.
imageNew :: (HasCallStack, MonadIO m) => m Image

-- | Creates a Image displaying the given animation. The
--   Image does not assume a reference to the animation; you still
--   need to unref it if you own references. Image will add its own
--   reference rather than adopting yours.
--   
--   Note that the animation frames are shown using a timeout with
--   PRIORITY_DEFAULT. 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

-- | Resets the image to be empty.
--   
--   Since: 2.8
imageClear :: (HasCallStack, MonadIO m, IsImage a) => a -> m ()

-- | Gets the PixbufAnimation being displayed by the Image.
--   The storage type of the image must be ImageTypeEmpty or
--   ImageTypeAnimation (see imageGetStorageType). 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 Icon and size being displayed by the Image. The
--   storage type of the image must be ImageTypeEmpty or
--   ImageTypeGicon (see imageGetStorageType). The caller of
--   this function does not own a reference to the returned Icon.
--   
--   Since: 2.14
imageGetGicon :: (HasCallStack, MonadIO m, IsImage a) => a -> m (Icon, Int32)

-- | Gets the icon name and size being displayed by the Image. The
--   storage type of the image must be ImageTypeEmpty or
--   ImageTypeIconName (see imageGetStorageType). The
--   returned string is owned by the Image and should not be freed.
--   
--   Since: 2.6
imageGetIconName :: (HasCallStack, MonadIO m, IsImage a) => a -> m (Text, Int32)

-- | Gets the icon set and size being displayed by the Image. The
--   storage type of the image must be ImageTypeEmpty or
--   ImageTypeIconSet (see imageGetStorageType).
imageGetIconSet :: (HasCallStack, MonadIO m, IsImage a) => a -> m (IconSet, Int32)

-- | Gets the pixel size used for named icons.
--   
--   Since: 2.6
imageGetPixelSize :: (HasCallStack, MonadIO m, IsImage a) => a -> m Int32

-- | Causes the Image to display the given animation (or display
--   nothing, if you set the animation to Nothing).
imageSetFromAnimation :: (HasCallStack, MonadIO m, IsImage a, IsPixbufAnimation b) => a -> b -> m ()

-- | See imageNewFromFile for details.
imageSetFromFile :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe [Char] -> m ()

-- | See imageNewFromGicon for details.
--   
--   Since: 2.14
imageSetFromGicon :: (HasCallStack, MonadIO m, IsImage a, IsIcon b) => a -> b -> Int32 -> m ()

-- | See imageNewFromIconSet for details.
imageSetFromIconSet :: (HasCallStack, MonadIO m, IsImage a) => a -> IconSet -> Int32 -> m ()

-- | See imageNewFromPixbuf for details.
imageSetFromPixbuf :: (HasCallStack, MonadIO m, IsImage a, IsPixbuf b) => a -> Maybe b -> m ()

-- | See imageNewFromResource for details.
imageSetFromResource :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe Text -> m ()

-- | See imageNewFromStock for details.
imageSetFromStock :: (HasCallStack, MonadIO m, IsImage a) => a -> Text -> Int32 -> m ()

-- | See imageNewFromSurface for details.
--   
--   Since: 3.10
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
--   imageSetFromIconName.
--   
--   Since: 2.6
imageSetPixelSize :: (HasCallStack, MonadIO m, IsImage a) => a -> Int32 -> m ()

-- | Type class for types which can be safely cast to IconTheme, for
--   instance with toIconTheme.
class (GObject o, IsDescendantOf IconTheme o) => IsIconTheme o

-- | Cast to IconTheme, for types for which this is known to be
--   safe. For general casts, use castTo.
toIconTheme :: (MonadIO m, IsIconTheme o) => o -> m IconTheme

-- | Type class for types which can be safely cast to IconInfo, for
--   instance with toIconInfo.
class (GObject o, IsDescendantOf IconInfo o) => IsIconInfo o

-- | Cast to IconInfo, for types for which this is known to be safe.
--   For general casts, use castTo.
toIconInfo :: (MonadIO m, IsIconInfo o) => o -> m IconInfo

-- | Creates a IconInfo for a Pixbuf.
--   
--   Since: 2.14
iconInfoNewForPixbuf :: (HasCallStack, MonadIO m, IsIconTheme a, IsPixbuf b) => a -> b -> m IconInfo

-- | 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.
--   
--   Since: 3.10
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.
--   
--   Since: 2.4
iconInfoGetBaseSize :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m Int32

-- | This function is deprecated and always returns Nothing.
--   
--   Since: 2.4
iconInfoGetDisplayName :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m Text

-- | 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.
--   
--   Since: 3.12
iconInfoIsSymbolic :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m Bool

-- | Finishes an async icon load, see iconInfoLoadIconAsync.
--   
--   Since: 3.8
iconInfoLoadIconFinish :: (HasCallStack, MonadIO m, IsIconInfo a, IsAsyncResult b) => a -> b -> m Pixbuf

-- | Finishes an async icon load, see iconInfoLoadSymbolicAsync.
--   
--   Since: 3.8
iconInfoLoadSymbolicFinish :: (HasCallStack, MonadIO m, IsIconInfo a, IsAsyncResult b) => a -> b -> m (Pixbuf, Bool)

-- | Finishes an async icon load, see
--   iconInfoLoadSymbolicForContextAsync.
--   
--   Since: 3.8
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
--   iconInfoLoadIcon.
--   
--   This allows loading symbolic icons that will match the system theme.
--   
--   See iconInfoLoadSymbolic for more details.
--   
--   Since: 3.0
iconInfoLoadSymbolicForStyle :: (HasCallStack, MonadIO m, IsIconInfo a, IsStyle b) => a -> b -> StateType -> m (Pixbuf, Bool)

-- | Sets whether the coordinates returned by
--   iconInfoGetEmbeddedRect and iconInfoGetAttachPoints
--   should be returned in their original form as specified in the icon
--   theme, instead of scaled appropriately for the pixbuf returned by
--   iconInfoLoadIcon.
--   
--   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 iconInfoGetFilename, and seeing if it is
--   non-Nothing 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.
--   
--   Since: 2.4
iconInfoSetRawCoordinates :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> Bool -> m ()

-- | 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 ()

-- | Connect a signal handler for the changed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on iconTheme #changed callback
--   
onIconThemeChanged :: (IsIconTheme a, MonadIO m) => a -> ((?self :: a) => IconThemeChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after iconTheme #changed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterIconThemeChanged :: (IsIconTheme a, MonadIO m) => a -> ((?self :: a) => IconThemeChangedCallback) -> m SignalHandlerId

-- | 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 @path/16x16/actions/run.png. Icons that are
--   directly placed in the resource path instead of a subdirectory are
--   also considered as ultimate fallback.
--   
--   Since: 3.14
iconThemeAddResourcePath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> m ()

-- | Appends a directory to the search path. See
--   iconThemeSetSearchPath.
--   
--   Since: 2.4
iconThemeAppendSearchPath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> [Char] -> m ()

-- | Looks up a named icon for a particular window scale and returns a
--   IconInfo containing information such as the filename of the
--   icon. The icon can then be rendered into a pixbuf using
--   iconInfoLoadIcon. (iconThemeLoadIcon combines these two
--   steps if all you need is the pixbuf.)
--   
--   If iconNames contains more than one name, this
--   function tries them all in the given order before falling back to
--   inherited icon themes.
--   
--   Since: 3.10
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.)
--   
--   Since: 2.4
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.
--   
--   Since: 2.6
iconThemeGetIconSizes :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> m [Int32]

-- | Gets the current search path. See iconThemeSetSearchPath.
--   
--   Since: 2.4
iconThemeGetSearchPath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> m [[Char]]

-- | Checks whether an icon theme includes an icon for a particular name.
--   
--   Since: 2.4
iconThemeHasIcon :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> m Bool

-- | 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
--   iconThemeLookupIcon followed by iconInfoLoadIcon.
--   
--   Note that you probably want to listen for icon theme changes and
--   update the icon. This is usually done by connecting to the
--   GtkWidgetstyleSet signal. If for some reason you do not want to
--   update the icon when the icon theme changes, you should consider using
--   pixbufCopy 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.
--   
--   Since: 3.10
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 iconThemeLookupIcon followed by iconInfoLoadSurface.
--   
--   Note that you probably want to listen for icon theme changes and
--   update the icon. This is usually done by connecting to the
--   GtkWidgetstyleSet signal.
--   
--   Since: 3.10
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 IconInfo containing information
--   such as the filename of the icon. The icon can then be rendered into a
--   pixbuf using iconInfoLoadIcon.
--   
--   When rendering on displays with high pixel densities you should not
--   use a size multiplied by the scaling factor returned
--   by functions like windowGetScaleFactor. Instead, you should use
--   iconThemeLookupByGiconForScale, as the assets loaded for a
--   given scaling factor may be different.
--   
--   Since: 2.14
iconThemeLookupByGicon :: (HasCallStack, MonadIO m, IsIconTheme a, IsIcon b) => a -> b -> Int32 -> [IconLookupFlags] -> m (Maybe IconInfo)

-- | Prepends a directory to the search path. See
--   iconThemeSetSearchPath.
--   
--   Since: 2.4
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
--   iconTheme is accessed.
--   
--   Since: 2.4
iconThemeRescanIfNeeded :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> m Bool

-- | Sets the name of the icon theme that the IconTheme object uses
--   overriding system configuration. This function cannot be called on the
--   icon theme objects returned from iconThemeGetDefault and
--   iconThemeGetForScreen.
--   
--   Since: 2.4
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.
--   
--   Since: 2.4
iconThemeSetScreen :: (HasCallStack, MonadIO m, IsIconTheme a, IsScreen b) => a -> b -> m ()

-- | Type class for types which can be safely cast to HeaderBar, for
--   instance with toHeaderBar.
class (GObject o, IsDescendantOf HeaderBar o) => IsHeaderBar o

-- | Cast to HeaderBar, for types for which this is known to be
--   safe. For general casts, use castTo.
toHeaderBar :: (MonadIO m, IsHeaderBar o) => o -> m HeaderBar

-- | Get the value of the “custom-title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get headerBar #customTitle
--   
getHeaderBarCustomTitle :: (MonadIO m, IsHeaderBar o) => o -> m (Maybe Widget)

-- | Set the value of the “custom-title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set headerBar [ #customTitle := value ]
--   
setHeaderBarCustomTitle :: (MonadIO m, IsHeaderBar o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “custom-title” property. This is rarely needed directly, but
--   it is used by new.
constructHeaderBarCustomTitle :: (IsHeaderBar o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “custom-title” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #customTitle
--   
clearHeaderBarCustomTitle :: (MonadIO m, IsHeaderBar o) => o -> m ()

-- | Get the value of the “decoration-layout” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get headerBar #decorationLayout
--   
getHeaderBarDecorationLayout :: (MonadIO m, IsHeaderBar o) => o -> m Text

-- | Set the value of the “decoration-layout” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set headerBar [ #decorationLayout := value ]
--   
setHeaderBarDecorationLayout :: (MonadIO m, IsHeaderBar o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “decoration-layout” property. This is rarely needed directly,
--   but it is used by new.
constructHeaderBarDecorationLayout :: (IsHeaderBar o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “decoration-layout” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #decorationLayout
--   
clearHeaderBarDecorationLayout :: (MonadIO m, IsHeaderBar o) => o -> m ()

-- | Get the value of the “decoration-layout-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get headerBar #decorationLayoutSet
--   
getHeaderBarDecorationLayoutSet :: (MonadIO m, IsHeaderBar o) => o -> m Bool

-- | Set the value of the “decoration-layout-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set headerBar [ #decorationLayoutSet := value ]
--   
setHeaderBarDecorationLayoutSet :: (MonadIO m, IsHeaderBar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “decoration-layout-set” property. This is rarely needed
--   directly, but it is used by new.
constructHeaderBarDecorationLayoutSet :: (IsHeaderBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “has-subtitle” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get headerBar #hasSubtitle
--   
getHeaderBarHasSubtitle :: (MonadIO m, IsHeaderBar o) => o -> m Bool

-- | Set the value of the “has-subtitle” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set headerBar [ #hasSubtitle := value ]
--   
setHeaderBarHasSubtitle :: (MonadIO m, IsHeaderBar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-subtitle” property. This is rarely needed directly, but
--   it is used by new.
constructHeaderBarHasSubtitle :: (IsHeaderBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-close-button” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get headerBar #showCloseButton
--   
getHeaderBarShowCloseButton :: (MonadIO m, IsHeaderBar o) => o -> m Bool

-- | Set the value of the “show-close-button” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set headerBar [ #showCloseButton := value ]
--   
setHeaderBarShowCloseButton :: (MonadIO m, IsHeaderBar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-close-button” property. This is rarely needed directly,
--   but it is used by new.
constructHeaderBarShowCloseButton :: (IsHeaderBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get headerBar #spacing
--   
getHeaderBarSpacing :: (MonadIO m, IsHeaderBar o) => o -> m Int32

-- | Set the value of the “spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set headerBar [ #spacing := value ]
--   
setHeaderBarSpacing :: (MonadIO m, IsHeaderBar o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “spacing” property. This is rarely needed directly, but it is
--   used by new.
constructHeaderBarSpacing :: (IsHeaderBar o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “subtitle” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get headerBar #subtitle
--   
getHeaderBarSubtitle :: (MonadIO m, IsHeaderBar o) => o -> m (Maybe Text)

-- | Set the value of the “subtitle” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set headerBar [ #subtitle := value ]
--   
setHeaderBarSubtitle :: (MonadIO m, IsHeaderBar o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “subtitle” property. This is rarely needed directly, but it
--   is used by new.
constructHeaderBarSubtitle :: (IsHeaderBar o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “subtitle” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #subtitle
--   
clearHeaderBarSubtitle :: (MonadIO m, IsHeaderBar o) => o -> m ()

-- | Get the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get headerBar #title
--   
getHeaderBarTitle :: (MonadIO m, IsHeaderBar o) => o -> m (Maybe Text)

-- | Set the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set headerBar [ #title := value ]
--   
setHeaderBarTitle :: (MonadIO m, IsHeaderBar o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “title” property. This is rarely needed directly, but it is
--   used by new.
constructHeaderBarTitle :: (IsHeaderBar o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “title” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #title
--   
clearHeaderBarTitle :: (MonadIO m, IsHeaderBar o) => o -> m ()

-- | Creates a new HeaderBar widget.
--   
--   Since: 3.10
headerBarNew :: (HasCallStack, MonadIO m) => m HeaderBar

-- | Retrieves the custom title widget of the header. See
--   headerBarSetCustomTitle.
--   
--   Since: 3.10
headerBarGetCustomTitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m (Maybe Widget)

-- | Gets the decoration layout set with
--   headerBarSetDecorationLayout.
--   
--   Since: 3.12
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.
--   
--   Since: 3.12
headerBarGetHasSubtitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m Bool

-- | Returns whether this header bar shows the standard window decorations.
--   
--   Since: 3.10
headerBarGetShowCloseButton :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m Bool

-- | Retrieves the subtitle of the header. See headerBarSetSubtitle.
--   
--   Since: 3.10
headerBarGetSubtitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m (Maybe Text)

-- | Retrieves the title of the header. See headerBarSetTitle.
--   
--   Since: 3.10
headerBarGetTitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m (Maybe Text)

-- | Adds child to bar, packed with
--   reference to the end of the bar.
--   
--   Since: 3.10
headerBarPackEnd :: (HasCallStack, MonadIO m, IsHeaderBar a, IsWidget b) => a -> b -> m ()

-- | Adds child to bar, packed with
--   reference to the start of the bar.
--   
--   Since: 3.10
headerBarPackStart :: (HasCallStack, MonadIO m, IsHeaderBar a, IsWidget b) => a -> b -> m ()

-- | Sets whether the header bar should reserve space for a subtitle, even
--   if none is currently set.
--   
--   Since: 3.12
headerBarSetHasSubtitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Bool -> m ()

-- | Sets whether this header bar shows the standard window decorations,
--   including close, maximize, and minimize.
--   
--   Since: 3.10
headerBarSetShowCloseButton :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to HandleBox, for
--   instance with toHandleBox.
class (GObject o, IsDescendantOf HandleBox o) => IsHandleBox o

-- | Cast to HandleBox, for types for which this is known to be
--   safe. For general casts, use castTo.
toHandleBox :: (MonadIO m, IsHandleBox o) => o -> m HandleBox

-- | 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 ()

-- | Connect a signal handler for the childAttached signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on handleBox #childAttached callback
--   
onHandleBoxChildAttached :: (IsHandleBox a, MonadIO m) => a -> ((?self :: a) => HandleBoxChildAttachedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the childAttached signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after handleBox #childAttached callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterHandleBoxChildAttached :: (IsHandleBox a, MonadIO m) => a -> ((?self :: a) => HandleBoxChildAttachedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the childDetached signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on handleBox #childDetached callback
--   
onHandleBoxChildDetached :: (IsHandleBox a, MonadIO m) => a -> ((?self :: a) => HandleBoxChildDetachedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the childDetached signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after handleBox #childDetached callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterHandleBoxChildDetached :: (IsHandleBox a, MonadIO m) => a -> ((?self :: a) => HandleBoxChildDetachedCallback) -> m SignalHandlerId

-- | Get the value of the “child-detached” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get handleBox #childDetached
--   
getHandleBoxChildDetached :: (MonadIO m, IsHandleBox o) => o -> m Bool

-- | Get the value of the “handle-position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get handleBox #handlePosition
--   
getHandleBoxHandlePosition :: (MonadIO m, IsHandleBox o) => o -> m PositionType

-- | Set the value of the “handle-position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set handleBox [ #handlePosition := value ]
--   
setHandleBoxHandlePosition :: (MonadIO m, IsHandleBox o) => o -> PositionType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “handle-position” property. This is rarely needed directly,
--   but it is used by new.
constructHandleBoxHandlePosition :: (IsHandleBox o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Get the value of the “shadow-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get handleBox #shadowType
--   
getHandleBoxShadowType :: (MonadIO m, IsHandleBox o) => o -> m ShadowType

-- | Set the value of the “shadow-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set handleBox [ #shadowType := value ]
--   
setHandleBoxShadowType :: (MonadIO m, IsHandleBox o) => o -> ShadowType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “shadow-type” property. This is rarely needed directly, but
--   it is used by new.
constructHandleBoxShadowType :: (IsHandleBox o, MonadIO m) => ShadowType -> m (GValueConstruct o)

-- | Get the value of the “snap-edge” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get handleBox #snapEdge
--   
getHandleBoxSnapEdge :: (MonadIO m, IsHandleBox o) => o -> m PositionType

-- | Set the value of the “snap-edge” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set handleBox [ #snapEdge := value ]
--   
setHandleBoxSnapEdge :: (MonadIO m, IsHandleBox o) => o -> PositionType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “snap-edge” property. This is rarely needed directly, but it
--   is used by new.
constructHandleBoxSnapEdge :: (IsHandleBox o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Get the value of the “snap-edge-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get handleBox #snapEdgeSet
--   
getHandleBoxSnapEdgeSet :: (MonadIO m, IsHandleBox o) => o -> m Bool

-- | Set the value of the “snap-edge-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set handleBox [ #snapEdgeSet := value ]
--   
setHandleBoxSnapEdgeSet :: (MonadIO m, IsHandleBox o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “snap-edge-set” property. This is rarely needed directly, but
--   it is used by new.
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.
--   
--   Since: 2.14
handleBoxGetChildDetached :: (HasCallStack, MonadIO m, IsHandleBox a) => a -> m Bool

-- | Gets the handle position of the handle box. See
--   handleBoxSetHandlePosition.
handleBoxGetHandlePosition :: (HasCallStack, MonadIO m, IsHandleBox a) => a -> m PositionType

-- | Gets the type of shadow drawn around the handle box. See
--   handleBoxSetShadowType.
handleBoxGetShadowType :: (HasCallStack, MonadIO m, IsHandleBox a) => a -> m ShadowType

-- | Gets the edge used for determining reattachment of the handle box. See
--   handleBoxSetSnapEdge.
handleBoxGetSnapEdge :: (HasCallStack, MonadIO m, IsHandleBox a) => a -> m PositionType

-- | Type class for types which can be safely cast to HSeparator,
--   for instance with toHSeparator.
class (GObject o, IsDescendantOf HSeparator o) => IsHSeparator o

-- | Cast to HSeparator, for types for which this is known to be
--   safe. For general casts, use castTo.
toHSeparator :: (MonadIO m, IsHSeparator o) => o -> m HSeparator

-- | Creates a new HSeparator.
hSeparatorNew :: (HasCallStack, MonadIO m) => m HSeparator

-- | Type class for types which can be safely cast to HScrollbar,
--   for instance with toHScrollbar.
class (GObject o, IsDescendantOf HScrollbar o) => IsHScrollbar o

-- | Cast to HScrollbar, for types for which this is known to be
--   safe. For general casts, use castTo.
toHScrollbar :: (MonadIO m, IsHScrollbar o) => o -> m HScrollbar

-- | Creates a new horizontal scrollbar.
hScrollbarNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe a -> m HScrollbar

-- | Type class for types which can be safely cast to HScale, for
--   instance with toHScale.
class (GObject o, IsDescendantOf HScale o) => IsHScale o

-- | Cast to HScale, for types for which this is known to be safe.
--   For general casts, use castTo.
toHScale :: (MonadIO m, IsHScale o) => o -> m HScale

-- | Creates a new HScale.
hScaleNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe a -> m HScale

-- | Creates a new horizontal scale widget that lets the user input a
--   number between min and max (including
--   min and max) with the increment
--   step. step 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
--   step is a power of ten. If the resulting precision is
--   not suitable for your needs, use scaleSetDigits to correct it.
hScaleNewWithRange :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m HScale

-- | Type class for types which can be safely cast to HSV, for
--   instance with toHSV.
class (GObject o, IsDescendantOf HSV o) => IsHSV o

-- | Cast to HSV, for types for which this is known to be safe. For
--   general casts, use castTo.
toHSV :: (MonadIO m, IsHSV o) => o -> m HSV

-- | No description available in the introspection data.
type HSVMoveCallback = DirectionType -> IO ()

-- | No description available in the introspection data.
type HSVChangedCallback = IO ()

-- | Connect a signal handler for the changed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on hSV #changed callback
--   
onHSVChanged :: (IsHSV a, MonadIO m) => a -> ((?self :: a) => HSVChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after hSV #changed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterHSVChanged :: (IsHSV a, MonadIO m) => a -> ((?self :: a) => HSVChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the move signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on hSV #move callback
--   
onHSVMove :: (IsHSV a, MonadIO m) => a -> ((?self :: a) => HSVMoveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the move signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after hSV #move callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterHSVMove :: (IsHSV a, MonadIO m) => a -> ((?self :: a) => HSVMoveCallback) -> m SignalHandlerId

-- | Creates a new HSV color selector.
--   
--   Since: 2.14
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.
--   
--   Since: 2.14
hSVGetColor :: (HasCallStack, MonadIO m, IsHSV a) => a -> m (Double, Double, Double)

-- | Queries the size and ring width of an HSV color selector.
--   
--   Since: 2.14
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.
--   
--   Since: 2.14
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.
--   
--   Since: 2.14
hSVSetColor :: (HasCallStack, MonadIO m, IsHSV a) => a -> Double -> Double -> Double -> m ()

-- | Sets the size and ring width of an HSV color selector.
--   
--   Since: 2.14
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.
--   
--   Since: 2.14
hSVToRgb :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m (Double, Double, Double)

-- | Type class for types which can be safely cast to HPaned, for
--   instance with toHPaned.
class (GObject o, IsDescendantOf HPaned o) => IsHPaned o

-- | Cast to HPaned, for types for which this is known to be safe.
--   For general casts, use castTo.
toHPaned :: (MonadIO m, IsHPaned o) => o -> m HPaned

-- | Create a new HPaned
hPanedNew :: (HasCallStack, MonadIO m) => m HPaned

-- | Type class for types which can be safely cast to Grid, for
--   instance with toGrid.
class (GObject o, IsDescendantOf Grid o) => IsGrid o

-- | Cast to Grid, for types for which this is known to be safe. For
--   general casts, use castTo.
toGrid :: (MonadIO m, IsGrid o) => o -> m Grid

-- | Get the value of the “baseline-row” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get grid #baselineRow
--   
getGridBaselineRow :: (MonadIO m, IsGrid o) => o -> m Int32

-- | Set the value of the “baseline-row” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set grid [ #baselineRow := value ]
--   
setGridBaselineRow :: (MonadIO m, IsGrid o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “baseline-row” property. This is rarely needed directly, but
--   it is used by new.
constructGridBaselineRow :: (IsGrid o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “column-homogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get grid #columnHomogeneous
--   
getGridColumnHomogeneous :: (MonadIO m, IsGrid o) => o -> m Bool

-- | Set the value of the “column-homogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set grid [ #columnHomogeneous := value ]
--   
setGridColumnHomogeneous :: (MonadIO m, IsGrid o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “column-homogeneous” property. This is rarely needed
--   directly, but it is used by new.
constructGridColumnHomogeneous :: (IsGrid o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “column-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get grid #columnSpacing
--   
getGridColumnSpacing :: (MonadIO m, IsGrid o) => o -> m Int32

-- | Set the value of the “column-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set grid [ #columnSpacing := value ]
--   
setGridColumnSpacing :: (MonadIO m, IsGrid o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “column-spacing” property. This is rarely needed directly,
--   but it is used by new.
constructGridColumnSpacing :: (IsGrid o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “row-homogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get grid #rowHomogeneous
--   
getGridRowHomogeneous :: (MonadIO m, IsGrid o) => o -> m Bool

-- | Set the value of the “row-homogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set grid [ #rowHomogeneous := value ]
--   
setGridRowHomogeneous :: (MonadIO m, IsGrid o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “row-homogeneous” property. This is rarely needed directly,
--   but it is used by new.
constructGridRowHomogeneous :: (IsGrid o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “row-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get grid #rowSpacing
--   
getGridRowSpacing :: (MonadIO m, IsGrid o) => o -> m Int32

-- | Set the value of the “row-spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set grid [ #rowSpacing := value ]
--   
setGridRowSpacing :: (MonadIO m, IsGrid o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “row-spacing” property. This is rarely needed directly, but
--   it is used by new.
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 sibling, on the side
--   determined by side. When sibling is
--   Nothing, the widget is placed in row (for left or right
--   placement) or column 0 (for top or bottom placement), at the end
--   indicated by side.
--   
--   Attaching widgets labeled [1], [2], [3] with sibling
--   == Nothing and side == PositionTypeLeft
--   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 grid.
--   
--   Since: 3.10
gridGetBaselineRow :: (HasCallStack, MonadIO m, IsGrid a) => a -> m Int32

-- | Gets the child of grid whose area covers the grid cell
--   whose upper left corner is at left,
--   top.
--   
--   Since: 3.2
gridGetChildAt :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> Int32 -> m (Maybe Widget)

-- | Returns whether all columns of grid have the same
--   width.
gridGetColumnHomogeneous :: (HasCallStack, MonadIO m, IsGrid a) => a -> m Bool

-- | Returns the amount of space between the columns of
--   grid.
gridGetColumnSpacing :: (HasCallStack, MonadIO m, IsGrid a) => a -> m Word32

-- | Returns the baseline position of row as set by
--   gridSetRowBaselinePosition or the default value
--   BaselinePositionCenter.
--   
--   Since: 3.10
gridGetRowBaselinePosition :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> m BaselinePosition

-- | Returns whether all rows of grid have the same height.
gridGetRowHomogeneous :: (HasCallStack, MonadIO m, IsGrid a) => a -> m Bool

-- | Returns the amount of space between the rows of grid.
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.
--   
--   Since: 3.2
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 sibling, on
--   the side determined by side. If side
--   is PositionTypeTop or PositionTypeBottom, a row is
--   inserted. If side is PositionTypeLeft of
--   PositionTypeRight, a column is inserted.
--   
--   Since: 3.2
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.
--   
--   Since: 3.2
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.
--   
--   Since: 3.10
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.
--   
--   Since: 3.10
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
--   grid.
--   
--   Since: 3.10
gridSetBaselineRow :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> m ()

-- | Sets whether all columns of grid will have the same
--   width.
gridSetColumnHomogeneous :: (HasCallStack, MonadIO m, IsGrid a) => a -> Bool -> m ()

-- | Sets the amount of space between columns of grid.
gridSetColumnSpacing :: (HasCallStack, MonadIO m, IsGrid a) => a -> Word32 -> m ()

-- | Sets whether all rows of grid will have the same
--   height.
gridSetRowHomogeneous :: (HasCallStack, MonadIO m, IsGrid a) => a -> Bool -> m ()

-- | Sets the amount of space between rows of grid.
gridSetRowSpacing :: (HasCallStack, MonadIO m, IsGrid a) => a -> Word32 -> m ()

-- | Type class for types which can be safely cast to GLArea, for
--   instance with toGLArea.
class (GObject o, IsDescendantOf GLArea o) => IsGLArea o

-- | Cast to GLArea, for types for which this is known to be safe.
--   For general casts, use castTo.
toGLArea :: (MonadIO m, IsGLArea o) => o -> m GLArea

-- | The resize 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.
--   
--   Since: 3.16
type GLAreaResizeCallback = Int32 -> Int32 -> IO ()

-- | The render signal is emitted every time the contents of the
--   GLArea should be redrawn.
--   
--   The context is bound to the area prior
--   to emitting this function, and the buffers are painted to the window
--   once the emission terminates.
--   
--   Since: 3.16
type GLAreaRenderCallback = GLContext -> IO Bool

-- | The createContext 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
--   gLAreaSetError to register a more detailed error of how the
--   construction failed.
--   
--   Since: 3.16
type GLAreaCreateContextCallback = IO GLContext

-- | Connect a signal handler for the createContext signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on gLArea #createContext callback
--   
onGLAreaCreateContext :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaCreateContextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the createContext signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after gLArea #createContext callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGLAreaCreateContext :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaCreateContextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the render signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gLArea #render callback
--   
onGLAreaRender :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaRenderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the render signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gLArea #render callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGLAreaRender :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaRenderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the resize signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gLArea #resize callback
--   
onGLAreaResize :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaResizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the resize signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gLArea #resize callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGLAreaResize :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaResizeCallback) -> m SignalHandlerId

-- | Get the value of the “auto-render” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get gLArea #autoRender
--   
getGLAreaAutoRender :: (MonadIO m, IsGLArea o) => o -> m Bool

-- | Set the value of the “auto-render” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set gLArea [ #autoRender := value ]
--   
setGLAreaAutoRender :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “auto-render” property. This is rarely needed directly, but
--   it is used by new.
constructGLAreaAutoRender :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “context” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get gLArea #context
--   
getGLAreaContext :: (MonadIO m, IsGLArea o) => o -> m GLContext

-- | Get the value of the “has-alpha” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get gLArea #hasAlpha
--   
getGLAreaHasAlpha :: (MonadIO m, IsGLArea o) => o -> m Bool

-- | Set the value of the “has-alpha” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set gLArea [ #hasAlpha := value ]
--   
setGLAreaHasAlpha :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-alpha” property. This is rarely needed directly, but it
--   is used by new.
constructGLAreaHasAlpha :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “has-depth-buffer” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get gLArea #hasDepthBuffer
--   
getGLAreaHasDepthBuffer :: (MonadIO m, IsGLArea o) => o -> m Bool

-- | Set the value of the “has-depth-buffer” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set gLArea [ #hasDepthBuffer := value ]
--   
setGLAreaHasDepthBuffer :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-depth-buffer” property. This is rarely needed directly,
--   but it is used by new.
constructGLAreaHasDepthBuffer :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “has-stencil-buffer” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get gLArea #hasStencilBuffer
--   
getGLAreaHasStencilBuffer :: (MonadIO m, IsGLArea o) => o -> m Bool

-- | Set the value of the “has-stencil-buffer” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set gLArea [ #hasStencilBuffer := value ]
--   
setGLAreaHasStencilBuffer :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-stencil-buffer” property. This is rarely needed
--   directly, but it is used by new.
constructGLAreaHasStencilBuffer :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “use-es” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get gLArea #useEs
--   
getGLAreaUseEs :: (MonadIO m, IsGLArea o) => o -> m Bool

-- | Set the value of the “use-es” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set gLArea [ #useEs := value ]
--   
setGLAreaUseEs :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-es” property. This is rarely needed directly, but it is
--   used by new.
constructGLAreaUseEs :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new GLArea widget.
--   
--   Since: 3.16
gLAreaNew :: (HasCallStack, MonadIO m) => m GLArea

-- | Ensures that the area framebuffer object is made the
--   current draw and read target, and that all the required buffers for
--   the area are created and bound to the frambuffer.
--   
--   This function is automatically called before emitting the
--   GLArea::render signal, and doesn't normally need to be called
--   by application code.
--   
--   Since: 3.16
gLAreaAttachBuffers :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m ()

-- | Returns whether the area is in auto render mode or not.
--   
--   Since: 3.16
gLAreaGetAutoRender :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool

-- | Retrieves the GLContext used by area.
--   
--   Since: 3.16
gLAreaGetContext :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m GLContext

-- | Gets the current error set on the area.
--   
--   Since: 3.16
gLAreaGetError :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m (Maybe GError)

-- | Returns whether the area has an alpha component.
--   
--   Since: 3.16
gLAreaGetHasAlpha :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool

-- | Returns whether the area has a depth buffer.
--   
--   Since: 3.16
gLAreaGetHasDepthBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool

-- | Returns whether the area has a stencil buffer.
--   
--   Since: 3.16
gLAreaGetHasStencilBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool

-- | Retrieves the required version of OpenGL set using
--   gLAreaSetRequiredVersion.
--   
--   Since: 3.16
gLAreaGetRequiredVersion :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m (Int32, Int32)

-- | Retrieves the value set by gLAreaSetUseEs.
--   
--   Since: 3.22
gLAreaGetUseEs :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool

-- | Ensures that the GLContext used by area is
--   associated with the GLArea.
--   
--   This function is automatically called before emitting the
--   GLArea::render signal, and doesn't normally need to be called
--   by application code.
--   
--   Since: 3.16
gLAreaMakeCurrent :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m ()

-- | If hasAlpha is True 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 hasAlpha is False there will be no alpha
--   channel, and the buffer will fully replace anything below the widget.
--   
--   Since: 3.16
gLAreaSetHasAlpha :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()

-- | If hasDepthBuffer is True the widget will
--   allocate and enable a depth buffer for the target framebuffer.
--   Otherwise there will be none.
--   
--   Since: 3.16
gLAreaSetHasDepthBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()

-- | If hasStencilBuffer is True the widget will
--   allocate and enable a stencil buffer for the target framebuffer.
--   Otherwise there will be none.
--   
--   Since: 3.16
gLAreaSetHasStencilBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to Frame, for
--   instance with toFrame.
class (GObject o, IsDescendantOf Frame o) => IsFrame o

-- | Cast to Frame, for types for which this is known to be safe.
--   For general casts, use castTo.
toFrame :: (MonadIO m, IsFrame o) => o -> m Frame

-- | Get the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get frame #label
--   
getFrameLabel :: (MonadIO m, IsFrame o) => o -> m (Maybe Text)

-- | Set the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set frame [ #label := value ]
--   
setFrameLabel :: (MonadIO m, IsFrame o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label” property. This is rarely needed directly, but it is
--   used by new.
constructFrameLabel :: (IsFrame o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “label” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #label
--   
clearFrameLabel :: (MonadIO m, IsFrame o) => o -> m ()

-- | Get the value of the “label-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get frame #labelWidget
--   
getFrameLabelWidget :: (MonadIO m, IsFrame o) => o -> m (Maybe Widget)

-- | Set the value of the “label-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set frame [ #labelWidget := value ]
--   
setFrameLabelWidget :: (MonadIO m, IsFrame o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label-widget” property. This is rarely needed directly, but
--   it is used by new.
constructFrameLabelWidget :: (IsFrame o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “label-widget” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #labelWidget
--   
clearFrameLabelWidget :: (MonadIO m, IsFrame o) => o -> m ()

-- | Get the value of the “label-xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get frame #labelXalign
--   
getFrameLabelXalign :: (MonadIO m, IsFrame o) => o -> m Float

-- | Set the value of the “label-xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set frame [ #labelXalign := value ]
--   
setFrameLabelXalign :: (MonadIO m, IsFrame o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label-xalign” property. This is rarely needed directly, but
--   it is used by new.
constructFrameLabelXalign :: (IsFrame o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “label-yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get frame #labelYalign
--   
getFrameLabelYalign :: (MonadIO m, IsFrame o) => o -> m Float

-- | Set the value of the “label-yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set frame [ #labelYalign := value ]
--   
setFrameLabelYalign :: (MonadIO m, IsFrame o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label-yalign” property. This is rarely needed directly, but
--   it is used by new.
constructFrameLabelYalign :: (IsFrame o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “shadow-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get frame #shadowType
--   
getFrameShadowType :: (MonadIO m, IsFrame o) => o -> m ShadowType

-- | Set the value of the “shadow-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set frame [ #shadowType := value ]
--   
setFrameShadowType :: (MonadIO m, IsFrame o) => o -> ShadowType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “shadow-type” property. This is rarely needed directly, but
--   it is used by new.
constructFrameShadowType :: (IsFrame o, MonadIO m) => ShadowType -> m (GValueConstruct o)

-- | If the frame’s label widget is a Label, returns the text in the
--   label widget. (The frame will have a Label for the label widget
--   if a non-Nothing argument was passed to frameNew.)
frameGetLabel :: (HasCallStack, MonadIO m, IsFrame a) => a -> m (Maybe Text)

-- | Retrieves the X and Y alignment of the frame’s label. See
--   frameSetLabelAlign.
frameGetLabelAlign :: (HasCallStack, MonadIO m, IsFrame a) => a -> m (Float, Float)

-- | Retrieves the label widget for the frame. See
--   frameSetLabelWidget.
frameGetLabelWidget :: (HasCallStack, MonadIO m, IsFrame a) => a -> m (Maybe Widget)

-- | Retrieves the shadow type of the frame. See frameSetShadowType.
frameGetShadowType :: (HasCallStack, MonadIO m, IsFrame a) => a -> m ShadowType

-- | Removes the current Frame:labelWidget. If label
--   is not Nothing, creates a new Label with that text and
--   adds it as the Frame:labelWidget.
frameSetLabel :: (HasCallStack, MonadIO m, IsFrame a) => a -> Maybe Text -> m ()

-- | Type class for types which can be safely cast to Fixed, for
--   instance with toFixed.
class (GObject o, IsDescendantOf Fixed o) => IsFixed o

-- | Cast to Fixed, for types for which this is known to be safe.
--   For general casts, use castTo.
toFixed :: (MonadIO m, IsFixed o) => o -> m Fixed

-- | Creates a new Fixed.
fixedNew :: (HasCallStack, MonadIO m) => m Fixed

-- | Moves a child of a Fixed container to the given position.
fixedMove :: (HasCallStack, MonadIO m, IsFixed a, IsWidget b) => a -> b -> Int32 -> Int32 -> m ()

-- | Adds a widget to a Fixed container at the given position.
fixedPut :: (HasCallStack, MonadIO m, IsFixed a, IsWidget b) => a -> b -> Int32 -> Int32 -> m ()

-- | Type class for types which can be safely cast to FileFilter,
--   for instance with toFileFilter.
class (GObject o, IsDescendantOf FileFilter o) => IsFileFilter o

-- | Cast to FileFilter, for types for which this is known to be
--   safe. For general casts, use castTo.
toFileFilter :: (MonadIO m, IsFileFilter o) => o -> m FileFilter

-- | Creates a new FileFilter with no rules added to it. Such a
--   filter doesn’t accept any files, so is not particularly useful until
--   you add rules with fileFilterAddMimeType,
--   fileFilterAddPattern, or fileFilterAddCustom. To create
--   a filter that accepts any file, use:
--   
--   
C code
--   
--   
--   GtkFileFilter *filter = gtk_file_filter_new ();
--   gtk_file_filter_add_pattern (filter, "*");
--   
--   
--   Since: 2.4
fileFilterNew :: (HasCallStack, MonadIO m) => m FileFilter

-- | Deserialize a file filter from an a{sv} variant in the format produced
--   by fileFilterToGvariant.
--   
--   Since: 3.22
fileFilterNewFromGvariant :: (HasCallStack, MonadIO m) => GVariant -> m FileFilter

-- | Adds a rule allowing image files in the formats supported by
--   GdkPixbuf.
--   
--   Since: 2.6
fileFilterAddPixbufFormats :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> m ()

-- | Gets the human-readable name for the filter. See
--   fileFilterSetName.
--   
--   Since: 2.4
fileFilterGetName :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> m (Maybe Text)

-- | Type class for types which can be safely cast to Expander, for
--   instance with toExpander.
class (GObject o, IsDescendantOf Expander o) => IsExpander o

-- | Cast to Expander, for types for which this is known to be safe.
--   For general casts, use castTo.
toExpander :: (MonadIO m, IsExpander o) => o -> m Expander

-- | No description available in the introspection data.
type ExpanderActivateCallback = IO ()

-- | Connect a signal handler for the activate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on expander #activate callback
--   
onExpanderActivate :: (IsExpander a, MonadIO m) => a -> ((?self :: a) => ExpanderActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after expander #activate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterExpanderActivate :: (IsExpander a, MonadIO m) => a -> ((?self :: a) => ExpanderActivateCallback) -> m SignalHandlerId

-- | Get the value of the “expanded” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get expander #expanded
--   
getExpanderExpanded :: (MonadIO m, IsExpander o) => o -> m Bool

-- | Set the value of the “expanded” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set expander [ #expanded := value ]
--   
setExpanderExpanded :: (MonadIO m, IsExpander o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “expanded” property. This is rarely needed directly, but it
--   is used by new.
constructExpanderExpanded :: (IsExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get expander #label
--   
getExpanderLabel :: (MonadIO m, IsExpander o) => o -> m (Maybe Text)

-- | Set the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set expander [ #label := value ]
--   
setExpanderLabel :: (MonadIO m, IsExpander o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label” property. This is rarely needed directly, but it is
--   used by new.
constructExpanderLabel :: (IsExpander o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “label” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #label
--   
clearExpanderLabel :: (MonadIO m, IsExpander o) => o -> m ()

-- | Get the value of the “label-fill” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get expander #labelFill
--   
getExpanderLabelFill :: (MonadIO m, IsExpander o) => o -> m Bool

-- | Set the value of the “label-fill” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set expander [ #labelFill := value ]
--   
setExpanderLabelFill :: (MonadIO m, IsExpander o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label-fill” property. This is rarely needed directly, but it
--   is used by new.
constructExpanderLabelFill :: (IsExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “label-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get expander #labelWidget
--   
getExpanderLabelWidget :: (MonadIO m, IsExpander o) => o -> m (Maybe Widget)

-- | Set the value of the “label-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set expander [ #labelWidget := value ]
--   
setExpanderLabelWidget :: (MonadIO m, IsExpander o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label-widget” property. This is rarely needed directly, but
--   it is used by new.
constructExpanderLabelWidget :: (IsExpander o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “label-widget” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #labelWidget
--   
clearExpanderLabelWidget :: (MonadIO m, IsExpander o) => o -> m ()

-- | Get the value of the “resize-toplevel” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get expander #resizeToplevel
--   
getExpanderResizeToplevel :: (MonadIO m, IsExpander o) => o -> m Bool

-- | Set the value of the “resize-toplevel” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set expander [ #resizeToplevel := value ]
--   
setExpanderResizeToplevel :: (MonadIO m, IsExpander o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “resize-toplevel” property. This is rarely needed directly,
--   but it is used by new.
constructExpanderResizeToplevel :: (IsExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get expander #spacing
--   
getExpanderSpacing :: (MonadIO m, IsExpander o) => o -> m Int32

-- | Set the value of the “spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set expander [ #spacing := value ]
--   
setExpanderSpacing :: (MonadIO m, IsExpander o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “spacing” property. This is rarely needed directly, but it is
--   used by new.
constructExpanderSpacing :: (IsExpander o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “use-markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get expander #useMarkup
--   
getExpanderUseMarkup :: (MonadIO m, IsExpander o) => o -> m Bool

-- | Set the value of the “use-markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set expander [ #useMarkup := value ]
--   
setExpanderUseMarkup :: (MonadIO m, IsExpander o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-markup” property. This is rarely needed directly, but it
--   is used by new.
constructExpanderUseMarkup :: (IsExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “use-underline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get expander #useUnderline
--   
getExpanderUseUnderline :: (MonadIO m, IsExpander o) => o -> m Bool

-- | Set the value of the “use-underline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set expander [ #useUnderline := value ]
--   
setExpanderUseUnderline :: (MonadIO m, IsExpander o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-underline” property. This is rarely needed directly, but
--   it is used by new.
constructExpanderUseUnderline :: (IsExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new expander using label as the text of the
--   label.
--   
--   Since: 2.4
expanderNew :: (HasCallStack, MonadIO m) => Maybe Text -> m Expander

-- | Creates a new expander using label as the text of the
--   label. If characters in label 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.
--   
--   Since: 2.4
expanderNewWithMnemonic :: (HasCallStack, MonadIO m) => Maybe Text -> m Expander

-- | Queries a Expander and returns its current state. Returns
--   True if the child widget is revealed.
--   
--   See expanderSetExpanded.
--   
--   Since: 2.4
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
--   expanderSetLabel. If the label text has not been set the return
--   value will be Nothing. This will be the case if you create an
--   empty button with buttonNew 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.
--   
--   Since: 2.4
expanderGetLabel :: (HasCallStack, MonadIO m, IsExpander a) => a -> m (Maybe Text)

-- | Returns whether the label widget will fill all available horizontal
--   space allocated to expander.
--   
--   Since: 2.22
expanderGetLabelFill :: (HasCallStack, MonadIO m, IsExpander a) => a -> m Bool

-- | Retrieves the label widget for the frame. See
--   expanderSetLabelWidget.
--   
--   Since: 2.4
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.
--   
--   Since: 3.2
expanderGetResizeToplevel :: (HasCallStack, MonadIO m, IsExpander a) => a -> m Bool

-- | Gets the value set by expanderSetSpacing.
--   
--   Since: 2.4
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
--   expanderSetUseMarkup.
--   
--   Since: 2.4
expanderGetUseMarkup :: (HasCallStack, MonadIO m, IsExpander a) => a -> m Bool

-- | Returns whether an embedded underline in the expander label indicates
--   a mnemonic. See expanderSetUseUnderline.
--   
--   Since: 2.4
expanderGetUseUnderline :: (HasCallStack, MonadIO m, IsExpander a) => a -> m Bool

-- | Sets whether the label widget should fill all available horizontal
--   space allocated to expander.
--   
--   Note that this function has no effect since 3.20.
--   
--   Since: 2.22
expanderSetLabelFill :: (HasCallStack, MonadIO m, IsExpander a) => a -> Bool -> m ()

-- | Sets whether the expander will resize the toplevel widget containing
--   the expander upon resizing and collpasing.
--   
--   Since: 3.2
expanderSetResizeToplevel :: (HasCallStack, MonadIO m, IsExpander a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to
--   EventController, for instance with toEventController.
class (GObject o, IsDescendantOf EventController o) => IsEventController o

-- | Cast to EventController, for types for which this is known to
--   be safe. For general casts, use castTo.
toEventController :: (MonadIO m, IsEventController o) => o -> m EventController

-- | Get the value of the “propagation-phase” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get eventController #propagationPhase
--   
getEventControllerPropagationPhase :: (MonadIO m, IsEventController o) => o -> m PropagationPhase

-- | Set the value of the “propagation-phase” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set eventController [ #propagationPhase := value ]
--   
setEventControllerPropagationPhase :: (MonadIO m, IsEventController o) => o -> PropagationPhase -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “propagation-phase” property. This is rarely needed directly,
--   but it is used by new.
constructEventControllerPropagationPhase :: (IsEventController o, MonadIO m) => PropagationPhase -> m (GValueConstruct o)

-- | Get the value of the “widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get eventController #widget
--   
getEventControllerWidget :: (MonadIO m, IsEventController o) => o -> m Widget

-- | Construct a GValueConstruct with valid value for the
--   “widget” property. This is rarely needed directly, but it is
--   used by new.
constructEventControllerWidget :: (IsEventController o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Gets the propagation phase at which controller handles
--   events.
--   
--   Since: 3.14
eventControllerGetPropagationPhase :: (HasCallStack, MonadIO m, IsEventController a) => a -> m PropagationPhase

-- | Sets the propagation phase at which a controller handles events.
--   
--   If phase is PropagationPhaseNone, no automatic
--   event handling will be performed, but other additional gesture
--   maintenance will. In that phase, the events can be managed by calling
--   eventControllerHandleEvent.
--   
--   Since: 3.14
eventControllerSetPropagationPhase :: (HasCallStack, MonadIO m, IsEventController a) => a -> PropagationPhase -> m ()

-- | Type class for types which can be safely cast to PadController,
--   for instance with toPadController.
class (GObject o, IsDescendantOf PadController o) => IsPadController o

-- | Cast to PadController, for types for which this is known to be
--   safe. For general casts, use castTo.
toPadController :: (MonadIO m, IsPadController o) => o -> m PadController

-- | Get the value of the “action-group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get padController #actionGroup
--   
getPadControllerActionGroup :: (MonadIO m, IsPadController o) => o -> m (Maybe ActionGroup)

-- | Construct a GValueConstruct with valid value for the
--   “action-group” property. This is rarely needed directly, but
--   it is used by new.
constructPadControllerActionGroup :: (IsPadController o, MonadIO m, IsActionGroup a) => a -> m (GValueConstruct o)

-- | Get the value of the “pad” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get padController #pad
--   
getPadControllerPad :: (MonadIO m, IsPadController o) => o -> m (Maybe Device)

-- | Construct a GValueConstruct with valid value for the
--   “pad” property. This is rarely needed directly, but it is
--   used by new.
constructPadControllerPad :: (IsPadController o, MonadIO m, IsDevice a) => a -> m (GValueConstruct o)

-- | Creates a new PadController that will associate events from
--   pad to actions. A Nothing pad may be provided
--   so the controller manages all pad devices generically, it is
--   discouraged to mix PadController objects with Nothing
--   and non-Nothing pad argument on the same
--   window, as execution order is not guaranteed.
--   
--   The PadController is created with no mapped actions. In order
--   to map pad events to actions, use padControllerSetActionEntries
--   or padControllerSetAction.
--   
--   Since: 3.22
padControllerNew :: (HasCallStack, MonadIO m, IsWindow a, IsActionGroup b, IsDevice c) => a -> b -> Maybe c -> m PadController

-- | Type class for types which can be safely cast to Gesture, for
--   instance with toGesture.
class (GObject o, IsDescendantOf Gesture o) => IsGesture o

-- | Cast to Gesture, for types for which this is known to be safe.
--   For general casts, use castTo.
toGesture :: (MonadIO m, IsGesture o) => o -> m Gesture

-- | This signal is emitted whenever an event is handled while the gesture
--   is recognized. sequence is guaranteed to pertain to
--   the set of active touches.
--   
--   Since: 3.14
type GestureUpdateCallback = Maybe EventSequence -> IO ()

-- | This signal is emitted whenever a sequence state changes. See
--   gestureSetSequenceState to know more about the expectable
--   sequence lifetimes.
--   
--   Since: 3.14
type GestureSequenceStateChangedCallback = Maybe EventSequence -> EventSequenceState -> IO ()

-- | This signal is emitted when gesture either stopped
--   recognizing the event sequences as something to be handled (the
--   Gesture::check handler returned False),
--   or the number of touch sequences became higher or lower than
--   Gesture:nPoints.
--   
--   Note: sequence might not pertain to the group of
--   sequences that were previously triggering recognition on
--   gesture (ie. a just pressed touch sequence that
--   exceeds Gesture:nPoints). This situation may be detected by
--   checking through gestureHandlesSequence.
--   
--   Since: 3.14
type GestureEndCallback = Maybe EventSequence -> IO ()

-- | This signal is emitted whenever a sequence is cancelled. This usually
--   happens on active touches when eventControllerReset is called
--   on gesture (manually, due to grabs...), or the
--   individual sequence was claimed by parent widgets'
--   controllers (see gestureSetSequenceState).
--   
--   gesture must forget everything about
--   sequence as a reaction to this signal.
--   
--   Since: 3.14
type GestureCancelCallback = Maybe EventSequence -> IO ()

-- | This signal is emitted when the gesture is recognized. This means the
--   number of touch sequences matches Gesture:nPoints, and the
--   Gesture::check handler(s) returned
--   TRUE.
--   
--   Note: These conditions may also happen when an extra touch (eg. a
--   third touch on a 2-touches gesture) is lifted, in that situation
--   sequence won't pertain to the current set of active
--   touches, so don't rely on this being true.
--   
--   Since: 3.14
type GestureBeginCallback = Maybe EventSequence -> IO ()

-- | Connect a signal handler for the begin signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on gesture #begin callback
--   
onGestureBegin :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the begin signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gesture #begin callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureBegin :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cancel signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gesture #cancel callback
--   
onGestureCancel :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cancel signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gesture #cancel callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureCancel :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the end signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on gesture #end callback
--   
onGestureEnd :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the end signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gesture #end callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureEnd :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the sequenceStateChanged signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on gesture #sequenceStateChanged callback
--   
onGestureSequenceStateChanged :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureSequenceStateChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the sequenceStateChanged signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after gesture #sequenceStateChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureSequenceStateChanged :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureSequenceStateChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the update signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gesture #update callback
--   
onGestureUpdate :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureUpdateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the update signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gesture #update callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureUpdate :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureUpdateCallback) -> m SignalHandlerId

-- | Get the value of the “n-points” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get gesture #nPoints
--   
getGestureNPoints :: (MonadIO m, IsGesture o) => o -> m Word32

-- | Construct a GValueConstruct with valid value for the
--   “n-points” property. This is rarely needed directly, but it
--   is used by new.
constructGestureNPoints :: (IsGesture o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “window” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get gesture #window
--   
getGestureWindow :: (MonadIO m, IsGesture o) => o -> m (Maybe Window)

-- | Set the value of the “window” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set gesture [ #window := value ]
--   
setGestureWindow :: (MonadIO m, IsGesture o, IsWindow a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “window” property. This is rarely needed directly, but it is
--   used by new.
constructGestureWindow :: (IsGesture o, MonadIO m, IsWindow a) => a -> m (GValueConstruct o)

-- | Set the value of the “window” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #window
--   
clearGestureWindow :: (MonadIO m, IsGesture o) => o -> m ()

-- | If there are touch sequences being currently handled by
--   gesture, this function returns True and fills
--   in rect with the bounding box containing all active
--   touches. Otherwise, False 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, rect width and height will thus be 0 regardless
--   of the number of touchpoints.
--   
--   Since: 3.14
gestureGetBoundingBox :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Bool, Rectangle)

-- | If there are touch sequences being currently handled by
--   gesture, this function returns True and fills
--   in x and y with the center of the
--   bounding box containing all active touches. Otherwise, False
--   will be returned.
--   
--   Since: 3.14
gestureGetBoundingBoxCenter :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Bool, Double, Double)

-- | Returns the master Device that is currently operating on
--   gesture, or Nothing if the gesture is not being
--   interacted.
--   
--   Since: 3.14
gestureGetDevice :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Maybe Device)

-- | Returns all gestures in the group of gesture
--   
--   Since: 3.14
gestureGetGroup :: (HasCallStack, MonadIO m, IsGesture a) => a -> m [Gesture]

-- | Returns the last event that was processed for
--   sequence.
--   
--   Note that the returned pointer is only valid as long as the
--   sequence is still interpreted by the
--   gesture. 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 EventSequence that was last updated on
--   gesture.
--   
--   Since: 3.14
gestureGetLastUpdatedSequence :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Maybe EventSequence)

-- | If sequence is currently being interpreted by
--   gesture, this function returns True and fills
--   in x and y with the last coordinates
--   stored for that event sequence. The coordinates are always relative to
--   the widget allocation.
--   
--   Since: 3.14
gestureGetPoint :: (HasCallStack, MonadIO m, IsGesture a) => a -> Maybe EventSequence -> m (Bool, Double, Double)

-- | Returns the sequence state, as seen by
--   gesture.
--   
--   Since: 3.14
gestureGetSequenceState :: (HasCallStack, MonadIO m, IsGesture a) => a -> EventSequence -> m EventSequenceState

-- | Returns the list of GdkEventSequences currently being
--   interpreted by gesture.
--   
--   Since: 3.14
gestureGetSequences :: (HasCallStack, MonadIO m, IsGesture a) => a -> m [EventSequence]

-- | Returns the user-defined window that receives the events handled by
--   gesture. See gestureSetWindow for more
--   information.
--   
--   Since: 3.14
gestureGetWindow :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Maybe Window)

-- | Adds gesture to the same group than
--   groupGesture. Gestures are by default isolated in
--   their own groups.
--   
--   When gestures are grouped, the state of
--   GdkEventSequences is kept in sync for all of those, so
--   calling gestureSetSequenceState, on one will transfer the same
--   value to the others.
--   
--   Groups also perform an "implicit grabbing" of sequences, if a
--   EventSequence state is set to
--   GTK_EVENT_SEQUENCE_CLAIMED on one group, every other
--   gesture group attached to the same Widget will switch the state
--   for that sequence to GTK_EVENT_SEQUENCE_DENIED.
--   
--   Since: 3.14
gestureGroup :: (HasCallStack, MonadIO m, IsGesture a, IsGesture b) => a -> b -> m ()

-- | Returns True if both gestures pertain to the same group.
--   
--   Since: 3.14
gestureIsGroupedWith :: (HasCallStack, MonadIO m, IsGesture a, IsGesture b) => a -> b -> m Bool

-- | Returns True if the gesture is currently recognized. A gesture
--   is recognized if there are as many interacting touch sequences as
--   required by gesture, and
--   Gesture::check returned True for the
--   sequences being currently interpreted.
--   
--   Since: 3.14
gestureIsRecognized :: (HasCallStack, MonadIO m, IsGesture a) => a -> m Bool

-- | Sets the state of all sequences that gesture is
--   currently interacting with. See gestureSetSequenceState for
--   more details on sequence states.
--   
--   Since: 3.14
gestureSetState :: (HasCallStack, MonadIO m, IsGesture a) => a -> EventSequenceState -> m Bool

-- | Separates gesture into an isolated group.
--   
--   Since: 3.14
gestureUngroup :: (HasCallStack, MonadIO m, IsGesture a) => a -> m ()

-- | Type class for types which can be safely cast to GestureZoom,
--   for instance with toGestureZoom.
class (GObject o, IsDescendantOf GestureZoom o) => IsGestureZoom o

-- | Cast to GestureZoom, for types for which this is known to be
--   safe. For general casts, use castTo.
toGestureZoom :: (MonadIO m, IsGestureZoom o) => o -> m GestureZoom

-- | This signal is emitted whenever the distance between both tracked
--   sequences changes.
--   
--   Since: 3.14
type GestureZoomScaleChangedCallback = Double -> IO ()

-- | Connect a signal handler for the scaleChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gestureZoom #scaleChanged callback
--   
onGestureZoomScaleChanged :: (IsGestureZoom a, MonadIO m) => a -> ((?self :: a) => GestureZoomScaleChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the scaleChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureZoom #scaleChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureZoomScaleChanged :: (IsGestureZoom a, MonadIO m) => a -> ((?self :: a) => GestureZoomScaleChangedCallback) -> m SignalHandlerId

-- | Returns a newly created Gesture that recognizes zoom in/out
--   gestures (usually known as pinch/zoom).
--   
--   Since: 3.14
gestureZoomNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureZoom

-- | If gesture is active, this function returns the
--   zooming difference since the gesture was recognized (hence the
--   starting point is considered 1:1). If gesture is not
--   active, 1 is returned.
--   
--   Since: 3.14
gestureZoomGetScaleDelta :: (HasCallStack, MonadIO m, IsGestureZoom a) => a -> m Double

-- | Type class for types which can be safely cast to GestureSingle,
--   for instance with toGestureSingle.
class (GObject o, IsDescendantOf GestureSingle o) => IsGestureSingle o

-- | Cast to GestureSingle, for types for which this is known to be
--   safe. For general casts, use castTo.
toGestureSingle :: (MonadIO m, IsGestureSingle o) => o -> m GestureSingle

-- | Get the value of the “button” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get gestureSingle #button
--   
getGestureSingleButton :: (MonadIO m, IsGestureSingle o) => o -> m Word32

-- | Set the value of the “button” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set gestureSingle [ #button := value ]
--   
setGestureSingleButton :: (MonadIO m, IsGestureSingle o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “button” property. This is rarely needed directly, but it is
--   used by new.
constructGestureSingleButton :: (IsGestureSingle o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “exclusive” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get gestureSingle #exclusive
--   
getGestureSingleExclusive :: (MonadIO m, IsGestureSingle o) => o -> m Bool

-- | Set the value of the “exclusive” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set gestureSingle [ #exclusive := value ]
--   
setGestureSingleExclusive :: (MonadIO m, IsGestureSingle o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “exclusive” property. This is rarely needed directly, but it
--   is used by new.
constructGestureSingleExclusive :: (IsGestureSingle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “touch-only” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get gestureSingle #touchOnly
--   
getGestureSingleTouchOnly :: (MonadIO m, IsGestureSingle o) => o -> m Bool

-- | Set the value of the “touch-only” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set gestureSingle [ #touchOnly := value ]
--   
setGestureSingleTouchOnly :: (MonadIO m, IsGestureSingle o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “touch-only” property. This is rarely needed directly, but it
--   is used by new.
constructGestureSingleTouchOnly :: (IsGestureSingle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Returns the button number gesture listens for, or 0 if
--   gesture reacts to any button press.
--   
--   Since: 3.14
gestureSingleGetButton :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m Word32

-- | Returns the button number currently interacting with
--   gesture, or 0 if there is none.
--   
--   Since: 3.14
gestureSingleGetCurrentButton :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m Word32

-- | Returns the event sequence currently interacting with
--   gesture. This is only meaningful if
--   gestureIsActive returns True.
--   
--   Since: 3.14
gestureSingleGetCurrentSequence :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m (Maybe EventSequence)

-- | Gets whether a gesture is exclusive. For more information, see
--   gestureSingleSetExclusive.
--   
--   Since: 3.14
gestureSingleGetExclusive :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m Bool

-- | Returns True if the gesture is only triggered by touch events.
--   
--   Since: 3.14
gestureSingleGetTouchOnly :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m Bool

-- | Sets the button number gesture listens to. If non-0,
--   every button press from a different button number will be ignored.
--   Touch events implicitly match with button 1.
--   
--   Since: 3.14
gestureSingleSetButton :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> Word32 -> m ()

-- | If touchOnly is True, gesture
--   will only handle events of type GDK_TOUCH_BEGIN,
--   GDK_TOUCH_UPDATE or GDK_TOUCH_END. If
--   False, mouse events will be handled too.
--   
--   Since: 3.14
gestureSingleSetTouchOnly :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to GestureSwipe,
--   for instance with toGestureSwipe.
class (GObject o, IsDescendantOf GestureSwipe o) => IsGestureSwipe o

-- | Cast to GestureSwipe, for types for which this is known to be
--   safe. For general casts, use castTo.
toGestureSwipe :: (MonadIO m, IsGestureSwipe o) => o -> m GestureSwipe

-- | This signal is emitted when the recognized gesture is finished,
--   velocity and direction are a product of previously recorded events.
--   
--   Since: 3.14
type GestureSwipeSwipeCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the swipe signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on gestureSwipe #swipe callback
--   
onGestureSwipeSwipe :: (IsGestureSwipe a, MonadIO m) => a -> ((?self :: a) => GestureSwipeSwipeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the swipe signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureSwipe #swipe callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureSwipeSwipe :: (IsGestureSwipe a, MonadIO m) => a -> ((?self :: a) => GestureSwipeSwipeCallback) -> m SignalHandlerId

-- | Returns a newly created Gesture that recognizes swipes.
--   
--   Since: 3.14
gestureSwipeNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureSwipe

-- | If the gesture is recognized, this function returns True and
--   fill in velocityX and velocityY with
--   the recorded velocity, as per the last event(s) processed.
--   
--   Since: 3.14
gestureSwipeGetVelocity :: (HasCallStack, MonadIO m, IsGestureSwipe a) => a -> m (Bool, Double, Double)

-- | Type class for types which can be safely cast to GestureStylus,
--   for instance with toGestureStylus.
class (GObject o, IsDescendantOf GestureStylus o) => IsGestureStylus o

-- | Cast to GestureStylus, for types for which this is known to be
--   safe. For general casts, use castTo.
toGestureStylus :: (MonadIO m, IsGestureStylus o) => o -> m GestureStylus

-- | No description available in the introspection data.
type GestureStylusUpCallback = Double -> Double -> IO ()

-- | No description available in the introspection data.
type GestureStylusProximityCallback = Double -> Double -> IO ()

-- | No description available in the introspection data.
type GestureStylusMotionCallback = Double -> Double -> IO ()

-- | No description available in the introspection data.
type GestureStylusDownCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the down signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on gestureStylus #down callback
--   
onGestureStylusDown :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusDownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the down signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureStylus #down callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureStylusDown :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusDownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the motion signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gestureStylus #motion callback
--   
onGestureStylusMotion :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the motion signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureStylus #motion callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureStylusMotion :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the proximity signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gestureStylus #proximity callback
--   
onGestureStylusProximity :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusProximityCallback) -> m SignalHandlerId

-- | Connect a signal handler for the proximity signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureStylus #proximity callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureStylusProximity :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusProximityCallback) -> m SignalHandlerId

-- | Connect a signal handler for the up signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on gestureStylus #up callback
--   
onGestureStylusUp :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusUpCallback) -> m SignalHandlerId

-- | Connect a signal handler for the up signal, to be run after the
--   default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureStylus #up callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureStylusUp :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusUpCallback) -> m SignalHandlerId

-- | Creates a new GestureStylus.
--   
--   Since: 3.24
gestureStylusNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureStylus

-- | Returns the current value for the requested axis. This
--   function must be called from either the
--   GestureStylus:down,
--   GestureStylus:motion,
--   GestureStylus:up or
--   GestureStylus:proximity signals.
--   
--   Since: 3.24
gestureStylusGetAxis :: (HasCallStack, MonadIO m, IsGestureStylus a) => a -> AxisUse -> m (Bool, Double)

-- | Returns the DeviceTool currently driving input through this
--   gesture. This function must be called from either the
--   GestureStylus::down, GestureStylus::motion,
--   GestureStylus::up or GestureStylus::proximity signal
--   handlers.
--   
--   Since: 3.24
gestureStylusGetDeviceTool :: (HasCallStack, MonadIO m, IsGestureStylus a) => a -> m (Maybe DeviceTool)

-- | Type class for types which can be safely cast to GestureRotate,
--   for instance with toGestureRotate.
class (GObject o, IsDescendantOf GestureRotate o) => IsGestureRotate o

-- | Cast to GestureRotate, for types for which this is known to be
--   safe. For general casts, use castTo.
toGestureRotate :: (MonadIO m, IsGestureRotate o) => o -> m GestureRotate

-- | This signal is emitted when the angle between both tracked points
--   changes.
--   
--   Since: 3.14
type GestureRotateAngleChangedCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the angleChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gestureRotate #angleChanged callback
--   
onGestureRotateAngleChanged :: (IsGestureRotate a, MonadIO m) => a -> ((?self :: a) => GestureRotateAngleChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the angleChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureRotate #angleChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureRotateAngleChanged :: (IsGestureRotate a, MonadIO m) => a -> ((?self :: a) => GestureRotateAngleChangedCallback) -> m SignalHandlerId

-- | Returns a newly created Gesture that recognizes 2-touch
--   rotation gestures.
--   
--   Since: 3.14
gestureRotateNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureRotate

-- | If gesture is active, this function returns the angle
--   difference in radians since the gesture was first recognized. If
--   gesture is not active, 0 is returned.
--   
--   Since: 3.14
gestureRotateGetAngleDelta :: (HasCallStack, MonadIO m, IsGestureRotate a) => a -> m Double

-- | Type class for types which can be safely cast to
--   GestureMultiPress, for instance with
--   toGestureMultiPress.
class (GObject o, IsDescendantOf GestureMultiPress o) => IsGestureMultiPress o

-- | Cast to GestureMultiPress, for types for which this is known to
--   be safe. For general casts, use castTo.
toGestureMultiPress :: (MonadIO m, IsGestureMultiPress o) => o -> m GestureMultiPress

-- | This signal is emitted whenever any time/distance threshold has been
--   exceeded.
--   
--   Since: 3.14
type GestureMultiPressStoppedCallback = IO ()

-- | This signal is emitted when a button or touch is released.
--   nPress will report the number of press that is paired
--   to this event, note that GestureMultiPress::stopped may have
--   been emitted between the press and its release, nPress
--   will only start over at the next press.
--   
--   Since: 3.14
type GestureMultiPressReleasedCallback = Int32 -> Double -> Double -> IO ()

-- | This signal is emitted whenever a button or touch press happens.
--   
--   Since: 3.14
type GestureMultiPressPressedCallback = Int32 -> Double -> Double -> IO ()

-- | Connect a signal handler for the pressed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gestureMultiPress #pressed callback
--   
onGestureMultiPressPressed :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pressed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureMultiPress #pressed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureMultiPressPressed :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the released signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gestureMultiPress #released callback
--   
onGestureMultiPressReleased :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressReleasedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the released signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureMultiPress #released callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureMultiPressReleased :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressReleasedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the stopped signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gestureMultiPress #stopped callback
--   
onGestureMultiPressStopped :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressStoppedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the stopped signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureMultiPress #stopped callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureMultiPressStopped :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressStoppedCallback) -> m SignalHandlerId

-- | Returns a newly created Gesture that recognizes single and
--   multiple presses.
--   
--   Since: 3.14
gestureMultiPressNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureMultiPress

-- | If an area was set through gestureMultiPressSetArea, this
--   function will return True and fill in rect with
--   the press area. See gestureMultiPressSetArea for more details
--   on what the press area represents.
--   
--   Since: 3.14
gestureMultiPressGetArea :: (HasCallStack, MonadIO m, IsGestureMultiPress a) => a -> m (Bool, Rectangle)

-- | Type class for types which can be safely cast to
--   GestureLongPress, for instance with toGestureLongPress.
class (GObject o, IsDescendantOf GestureLongPress o) => IsGestureLongPress o

-- | Cast to GestureLongPress, for types for which this is known to
--   be safe. For general casts, use castTo.
toGestureLongPress :: (MonadIO m, IsGestureLongPress o) => o -> m GestureLongPress

-- | This signal is emitted whenever a press goes unmoved/unreleased longer
--   than what the GTK+ defaults tell.
--   
--   Since: 3.14
type GestureLongPressPressedCallback = Double -> Double -> IO ()

-- | This signal is emitted whenever a press moved too far, or was released
--   before GestureLongPress::pressed happened.
--   
--   Since: 3.14
type GestureLongPressCancelledCallback = IO ()

-- | Connect a signal handler for the cancelled signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gestureLongPress #cancelled callback
--   
onGestureLongPressCancelled :: (IsGestureLongPress a, MonadIO m) => a -> ((?self :: a) => GestureLongPressCancelledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cancelled signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureLongPress #cancelled callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureLongPressCancelled :: (IsGestureLongPress a, MonadIO m) => a -> ((?self :: a) => GestureLongPressCancelledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pressed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gestureLongPress #pressed callback
--   
onGestureLongPressPressed :: (IsGestureLongPress a, MonadIO m) => a -> ((?self :: a) => GestureLongPressPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pressed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureLongPress #pressed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureLongPressPressed :: (IsGestureLongPress a, MonadIO m) => a -> ((?self :: a) => GestureLongPressPressedCallback) -> m SignalHandlerId

-- | Get the value of the “delay-factor” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get gestureLongPress #delayFactor
--   
getGestureLongPressDelayFactor :: (MonadIO m, IsGestureLongPress o) => o -> m Double

-- | Set the value of the “delay-factor” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set gestureLongPress [ #delayFactor := value ]
--   
setGestureLongPressDelayFactor :: (MonadIO m, IsGestureLongPress o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “delay-factor” property. This is rarely needed directly, but
--   it is used by new.
constructGestureLongPressDelayFactor :: (IsGestureLongPress o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Returns a newly created Gesture that recognizes long presses.
--   
--   Since: 3.14
gestureLongPressNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureLongPress

-- | Type class for types which can be safely cast to GestureDrag,
--   for instance with toGestureDrag.
class (GObject o, IsDescendantOf GestureDrag o) => IsGestureDrag o

-- | Cast to GestureDrag, for types for which this is known to be
--   safe. For general casts, use castTo.
toGestureDrag :: (MonadIO m, IsGestureDrag o) => o -> m GestureDrag

-- | This signal is emitted whenever the dragging point moves.
--   
--   Since: 3.14
type GestureDragDragUpdateCallback = Double -> Double -> IO ()

-- | This signal is emitted whenever the dragging is finished.
--   
--   Since: 3.14
type GestureDragDragEndCallback = Double -> Double -> IO ()

-- | This signal is emitted whenever dragging starts.
--   
--   Since: 3.14
type GestureDragDragBeginCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the dragBegin signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gestureDrag #dragBegin callback
--   
onGestureDragDragBegin :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragBegin signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureDrag #dragBegin callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureDragDragBegin :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragEnd signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gestureDrag #dragEnd callback
--   
onGestureDragDragEnd :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragEnd signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureDrag #dragEnd callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureDragDragEnd :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragUpdate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on gestureDrag #dragUpdate callback
--   
onGestureDragDragUpdate :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragUpdateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the dragUpdate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gestureDrag #dragUpdate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGestureDragDragUpdate :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragUpdateCallback) -> m SignalHandlerId

-- | Returns a newly created Gesture that recognizes drags.
--   
--   Since: 3.14
gestureDragNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureDrag

-- | If the gesture is active, this function returns
--   True and fills in x and y with
--   the coordinates of the current point, as an offset to the starting
--   drag point.
--   
--   Since: 3.14
gestureDragGetOffset :: (HasCallStack, MonadIO m, IsGestureDrag a) => a -> m (Bool, Double, Double)

-- | If the gesture is active, this function returns
--   True and fills in x and y with
--   the drag start coordinates, in window-relative coordinates.
--   
--   Since: 3.14
gestureDragGetStartPoint :: (HasCallStack, MonadIO m, IsGestureDrag a) => a -> m (Bool, Double, Double)

-- | Type class for types which can be safely cast to GesturePan,
--   for instance with toGesturePan.
class (GObject o, IsDescendantOf GesturePan o) => IsGesturePan o

-- | Cast to GesturePan, for types for which this is known to be
--   safe. For general casts, use castTo.
toGesturePan :: (MonadIO m, IsGesturePan o) => o -> m GesturePan

-- | This signal is emitted once a panning gesture along the expected axis
--   is detected.
--   
--   Since: 3.14
type GesturePanPanCallback = PanDirection -> Double -> IO ()

-- | Connect a signal handler for the pan signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on gesturePan #pan callback
--   
onGesturePanPan :: (IsGesturePan a, MonadIO m) => a -> ((?self :: a) => GesturePanPanCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pan signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after gesturePan #pan callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterGesturePanPan :: (IsGesturePan a, MonadIO m) => a -> ((?self :: a) => GesturePanPanCallback) -> m SignalHandlerId

-- | Get the value of the “orientation” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get gesturePan #orientation
--   
getGesturePanOrientation :: (MonadIO m, IsGesturePan o) => o -> m Orientation

-- | Set the value of the “orientation” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set gesturePan [ #orientation := value ]
--   
setGesturePanOrientation :: (MonadIO m, IsGesturePan o) => o -> Orientation -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “orientation” property. This is rarely needed directly, but
--   it is used by new.
constructGesturePanOrientation :: (IsGesturePan o, MonadIO m) => Orientation -> m (GValueConstruct o)

-- | Returns a newly created Gesture that recognizes pan gestures.
--   
--   Since: 3.14
gesturePanNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> Orientation -> m GesturePan

-- | Returns the orientation of the pan gestures that this
--   gesture expects.
--   
--   Since: 3.14
gesturePanGetOrientation :: (HasCallStack, MonadIO m, IsGesturePan a) => a -> m Orientation

-- | Sets the orientation to be expected on pan gestures.
--   
--   Since: 3.14
gesturePanSetOrientation :: (HasCallStack, MonadIO m, IsGesturePan a) => a -> Orientation -> m ()

-- | Type class for types which can be safely cast to
--   EventControllerScroll, for instance with
--   toEventControllerScroll.
class (GObject o, IsDescendantOf EventControllerScroll o) => IsEventControllerScroll o

-- | Cast to EventControllerScroll, for types for which this is
--   known to be safe. For general casts, use castTo.
toEventControllerScroll :: (MonadIO m, IsEventControllerScroll o) => o -> m EventControllerScroll

-- | 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
--   dx and dy.
type EventControllerScrollScrollCallback = Double -> Double -> IO ()

-- | Emitted after scroll is finished if the
--   GTK_EVENT_CONTROLLER_SCROLL_KINETIC flag is set.
--   velX and velY express the initial
--   velocity that was imprinted by the scroll events. velX
--   and velY are expressed in pixels/ms.
type EventControllerScrollDecelerateCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the decelerate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on eventControllerScroll #decelerate callback
--   
onEventControllerScrollDecelerate :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollDecelerateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the decelerate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after eventControllerScroll #decelerate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEventControllerScrollDecelerate :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollDecelerateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the scroll signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on eventControllerScroll #scroll callback
--   
onEventControllerScrollScroll :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollCallback) -> m SignalHandlerId

-- | Connect a signal handler for the scroll signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after eventControllerScroll #scroll callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEventControllerScrollScroll :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollCallback) -> m SignalHandlerId

-- | Connect a signal handler for the scrollBegin signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on eventControllerScroll #scrollBegin callback
--   
onEventControllerScrollScrollBegin :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the scrollBegin signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after eventControllerScroll #scrollBegin callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEventControllerScrollScrollBegin :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the scrollEnd signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on eventControllerScroll #scrollEnd callback
--   
onEventControllerScrollScrollEnd :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the scrollEnd signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after eventControllerScroll #scrollEnd callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEventControllerScrollScrollEnd :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollEndCallback) -> m SignalHandlerId

-- | Get the value of the “flags” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get eventControllerScroll #flags
--   
getEventControllerScrollFlags :: (MonadIO m, IsEventControllerScroll o) => o -> m [EventControllerScrollFlags]

-- | Set the value of the “flags” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set eventControllerScroll [ #flags := value ]
--   
setEventControllerScrollFlags :: (MonadIO m, IsEventControllerScroll o) => o -> [EventControllerScrollFlags] -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “flags” property. This is rarely needed directly, but it is
--   used by new.
constructEventControllerScrollFlags :: (IsEventControllerScroll o, MonadIO m) => [EventControllerScrollFlags] -> m (GValueConstruct o)

-- | Creates a new event controller that will handle scroll events for the
--   given widget.
--   
--   Since: 3.24
eventControllerScrollNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> [EventControllerScrollFlags] -> m EventControllerScroll

-- | Gets the flags conditioning the scroll controller behavior.
--   
--   Since: 3.24
eventControllerScrollGetFlags :: (HasCallStack, MonadIO m, IsEventControllerScroll a) => a -> m [EventControllerScrollFlags]

-- | Sets the flags conditioning scroll controller behavior.
--   
--   Since: 3.24
eventControllerScrollSetFlags :: (HasCallStack, MonadIO m, IsEventControllerScroll a) => a -> [EventControllerScrollFlags] -> m ()

-- | Type class for types which can be safely cast to
--   EventControllerMotion, for instance with
--   toEventControllerMotion.
class (GObject o, IsDescendantOf EventControllerMotion o) => IsEventControllerMotion o

-- | Cast to EventControllerMotion, for types for which this is
--   known to be safe. For general casts, use castTo.
toEventControllerMotion :: (MonadIO m, IsEventControllerMotion o) => o -> m 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 ()

-- | Connect a signal handler for the enter signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on eventControllerMotion #enter callback
--   
onEventControllerMotionEnter :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionEnterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the enter signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after eventControllerMotion #enter callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEventControllerMotionEnter :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionEnterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the leave signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on eventControllerMotion #leave callback
--   
onEventControllerMotionLeave :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the leave signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after eventControllerMotion #leave callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEventControllerMotionLeave :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the motion signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on eventControllerMotion #motion callback
--   
onEventControllerMotionMotion :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the motion signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after eventControllerMotion #motion callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams 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 widget.
--   
--   Since: 3.24
eventControllerMotionNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m EventControllerMotion

-- | Type class for types which can be safely cast to
--   EventControllerKey, for instance with
--   toEventControllerKey.
class (GObject o, IsDescendantOf EventControllerKey o) => IsEventControllerKey o

-- | Cast to EventControllerKey, for types for which this is known
--   to be safe. For general casts, use castTo.
toEventControllerKey :: (MonadIO m, IsEventControllerKey o) => o -> m EventControllerKey

-- | No description available in the introspection data.
type EventControllerKeyModifiersCallback = [ModifierType] -> IO Bool

-- | This signal is emitted whenever a key is released.
--   
--   Since: 3.24
type EventControllerKeyKeyReleasedCallback = Word32 -> Word32 -> [ModifierType] -> IO ()

-- | This signal is emitted whenever a key is pressed.
--   
--   Since: 3.24
type EventControllerKeyKeyPressedCallback = Word32 -> Word32 -> [ModifierType] -> IO Bool

-- | No description available in the introspection data.
type EventControllerKeyImUpdateCallback = IO ()

-- | No description available in the introspection data.
type EventControllerKeyFocusOutCallback = IO ()

-- | No description available in the introspection data.
type EventControllerKeyFocusInCallback = IO ()

-- | Connect a signal handler for the focusIn signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on eventControllerKey #focusIn callback
--   
onEventControllerKeyFocusIn :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyFocusInCallback) -> m SignalHandlerId

-- | Connect a signal handler for the focusIn signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after eventControllerKey #focusIn callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEventControllerKeyFocusIn :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyFocusInCallback) -> m SignalHandlerId

-- | Connect a signal handler for the focusOut signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on eventControllerKey #focusOut callback
--   
onEventControllerKeyFocusOut :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyFocusOutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the focusOut signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after eventControllerKey #focusOut callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEventControllerKeyFocusOut :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyFocusOutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the imUpdate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on eventControllerKey #imUpdate callback
--   
onEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyImUpdateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the imUpdate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after eventControllerKey #imUpdate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyImUpdateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the keyPressed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on eventControllerKey #keyPressed callback
--   
onEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyKeyPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the keyPressed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after eventControllerKey #keyPressed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyKeyPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the keyReleased signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on eventControllerKey #keyReleased callback
--   
onEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyKeyReleasedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the keyReleased signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after eventControllerKey #keyReleased callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyKeyReleasedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the modifiers signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on eventControllerKey #modifiers callback
--   
onEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyModifiersCallback) -> m SignalHandlerId

-- | Connect a signal handler for the modifiers signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after eventControllerKey #modifiers callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyModifiersCallback) -> m SignalHandlerId

-- | No description available in the introspection data.
eventControllerKeyNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m EventControllerKey

-- | No description available in the introspection data.
eventControllerKeyForward :: (HasCallStack, MonadIO m, IsEventControllerKey a, IsWidget b) => a -> b -> m Bool

-- | No description available in the introspection data.
eventControllerKeyGetGroup :: (HasCallStack, MonadIO m, IsEventControllerKey a) => a -> m Word32

-- | Gets the IM context of a key controller.
--   
--   Since: 3.24
eventControllerKeyGetImContext :: (HasCallStack, MonadIO m, IsEventControllerKey a) => a -> m IMContext

-- | No description available in the introspection data.
eventControllerKeySetImContext :: (HasCallStack, MonadIO m, IsEventControllerKey a, IsIMContext b) => a -> b -> m ()

-- | Type class for types which can be safely cast to EventBox, for
--   instance with toEventBox.
class (GObject o, IsDescendantOf EventBox o) => IsEventBox o

-- | Cast to EventBox, for types for which this is known to be safe.
--   For general casts, use castTo.
toEventBox :: (MonadIO m, IsEventBox o) => o -> m EventBox

-- | Get the value of the “above-child” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get eventBox #aboveChild
--   
getEventBoxAboveChild :: (MonadIO m, IsEventBox o) => o -> m Bool

-- | Set the value of the “above-child” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set eventBox [ #aboveChild := value ]
--   
setEventBoxAboveChild :: (MonadIO m, IsEventBox o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “above-child” property. This is rarely needed directly, but
--   it is used by new.
constructEventBoxAboveChild :: (IsEventBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “visible-window” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get eventBox #visibleWindow
--   
getEventBoxVisibleWindow :: (MonadIO m, IsEventBox o) => o -> m Bool

-- | Set the value of the “visible-window” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set eventBox [ #visibleWindow := value ]
--   
setEventBoxVisibleWindow :: (MonadIO m, IsEventBox o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible-window” property. This is rarely needed directly,
--   but it is used by new.
constructEventBoxVisibleWindow :: (IsEventBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new EventBox.
eventBoxNew :: (HasCallStack, MonadIO m) => m EventBox

-- | Returns whether the event box window is above or below the windows of
--   its child. See eventBoxSetAboveChild for details.
--   
--   Since: 2.4
eventBoxGetAboveChild :: (HasCallStack, MonadIO m, IsEventBox a) => a -> m Bool

-- | Returns whether the event box has a visible window. See
--   eventBoxSetVisibleWindow for details.
--   
--   Since: 2.4
eventBoxGetVisibleWindow :: (HasCallStack, MonadIO m, IsEventBox a) => a -> m Bool

-- | Type class for types which can be safely cast to DrawingArea,
--   for instance with toDrawingArea.
class (GObject o, IsDescendantOf DrawingArea o) => IsDrawingArea o

-- | Cast to DrawingArea, for types for which this is known to be
--   safe. For general casts, use castTo.
toDrawingArea :: (MonadIO m, IsDrawingArea o) => o -> m DrawingArea

-- | Creates a new drawing area.
drawingAreaNew :: (HasCallStack, MonadIO m) => m DrawingArea

-- | Type class for types which can be safely cast to CssProvider,
--   for instance with toCssProvider.
class (GObject o, IsDescendantOf CssProvider o) => IsCssProvider o

-- | Cast to CssProvider, for types for which this is known to be
--   safe. For general casts, use castTo.
toCssProvider :: (MonadIO m, IsCssProvider o) => o -> m CssProvider

-- | Signals that a parsing error occurred. the path,
--   line and position 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 ()

-- | Connect a signal handler for the parsingError signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on cssProvider #parsingError callback
--   
onCssProviderParsingError :: (IsCssProvider a, MonadIO m) => a -> ((?self :: a) => CssProviderParsingErrorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the parsingError signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after cssProvider #parsingError callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCssProviderParsingError :: (IsCssProvider a, MonadIO m) => a -> ((?self :: a) => CssProviderParsingErrorCallback) -> m SignalHandlerId

-- | Loads the data contained in path into
--   cssProvider, making it clear any previously loaded
--   information.
cssProviderLoadFromPath :: (HasCallStack, MonadIO m, IsCssProvider a) => a -> Text -> m ()

-- | Loads the data contained in the resource at
--   resourcePath into the CssProvider, clearing any
--   previously loaded information.
--   
--   To track errors while loading CSS, connect to the
--   CssProvider::parsingError signal.
--   
--   Since: 3.16
cssProviderLoadFromResource :: (HasCallStack, MonadIO m, IsCssProvider a) => a -> Text -> m ()

-- | Converts the provider into a string representation in
--   CSS format.
--   
--   Using cssProviderLoadFromData with the return value from this
--   function on a new provider created with cssProviderNew will
--   basically create a duplicate of this provider.
--   
--   Since: 3.2
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

-- | Type class for types which can be safely cast to Box, for
--   instance with toBox.
class (GObject o, IsDescendantOf Box o) => IsBox o

-- | Cast to Box, for types for which this is known to be safe. For
--   general casts, use castTo.
toBox :: (MonadIO m, IsBox o) => o -> m Box

-- | Get the value of the “baseline-position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get box #baselinePosition
--   
getBoxBaselinePosition :: (MonadIO m, IsBox o) => o -> m BaselinePosition

-- | Set the value of the “baseline-position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set box [ #baselinePosition := value ]
--   
setBoxBaselinePosition :: (MonadIO m, IsBox o) => o -> BaselinePosition -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “baseline-position” property. This is rarely needed directly,
--   but it is used by new.
constructBoxBaselinePosition :: (IsBox o, MonadIO m) => BaselinePosition -> m (GValueConstruct o)

-- | Get the value of the “homogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get box #homogeneous
--   
getBoxHomogeneous :: (MonadIO m, IsBox o) => o -> m Bool

-- | Set the value of the “homogeneous” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set box [ #homogeneous := value ]
--   
setBoxHomogeneous :: (MonadIO m, IsBox o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “homogeneous” property. This is rarely needed directly, but
--   it is used by new.
constructBoxHomogeneous :: (IsBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get box #spacing
--   
getBoxSpacing :: (MonadIO m, IsBox o) => o -> m Int32

-- | Set the value of the “spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set box [ #spacing := value ]
--   
setBoxSpacing :: (MonadIO m, IsBox o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “spacing” property. This is rarely needed directly, but it is
--   used by new.
constructBoxSpacing :: (IsBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new Box.
--   
--   Since: 3.0
boxNew :: (HasCallStack, MonadIO m) => Orientation -> Int32 -> m Box

-- | Gets the value set by boxSetBaselinePosition.
--   
--   Since: 3.10
boxGetBaselinePosition :: (HasCallStack, MonadIO m, IsBox a) => a -> m BaselinePosition

-- | Retrieves the center widget of the box.
--   
--   Since: 3.12
boxGetCenterWidget :: (HasCallStack, MonadIO m, IsBox a) => a -> m (Maybe Widget)

-- | Returns whether the box is homogeneous (all children are the same
--   size). See boxSetHomogeneous.
boxGetHomogeneous :: (HasCallStack, MonadIO m, IsBox a) => a -> m Bool

-- | Gets the value set by boxSetSpacing.
boxGetSpacing :: (HasCallStack, MonadIO m, IsBox a) => a -> m Int32

-- | Adds child to box, packed with
--   reference to the end of box. The child
--   is packed after (away from end of) any other child packed with
--   reference to the end of box.
boxPackEnd :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> b -> Bool -> Bool -> Word32 -> m ()

-- | Obtains information about how child is packed into
--   box.
boxQueryChildPacking :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> b -> m (Bool, Bool, Word32, PackType)

-- | Moves child to a new position in the
--   list of box children. The list contains widgets packed
--   GTK_PACK_START as well as widgets packed
--   GTK_PACK_END, in the order that these widgets were
--   added to box.
--   
--   A widget’s position in the box children list
--   determines where the widget is packed into box. 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 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.
--   
--   Since: 3.12
boxSetCenterWidget :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the way child is packed into box.
boxSetChildPacking :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> b -> Bool -> Bool -> Word32 -> PackType -> m ()

-- | Type class for types which can be safely cast to VBox, for
--   instance with toVBox.
class (GObject o, IsDescendantOf VBox o) => IsVBox o

-- | Cast to VBox, for types for which this is known to be safe. For
--   general casts, use castTo.
toVBox :: (MonadIO m, IsVBox o) => o -> m VBox

-- | Creates a new VBox.
vBoxNew :: (HasCallStack, MonadIO m) => Bool -> Int32 -> m VBox

-- | Type class for types which can be safely cast to Statusbar, for
--   instance with toStatusbar.
class (GObject o, IsDescendantOf Statusbar o) => IsStatusbar o

-- | Cast to Statusbar, for types for which this is known to be
--   safe. For general casts, use castTo.
toStatusbar :: (MonadIO m, IsStatusbar o) => o -> m Statusbar

-- | 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 ()

-- | Connect a signal handler for the textPopped signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on statusbar #textPopped callback
--   
onStatusbarTextPopped :: (IsStatusbar a, MonadIO m) => a -> ((?self :: a) => StatusbarTextPoppedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the textPopped signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after statusbar #textPopped callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterStatusbarTextPopped :: (IsStatusbar a, MonadIO m) => a -> ((?self :: a) => StatusbarTextPoppedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the textPushed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on statusbar #textPushed callback
--   
onStatusbarTextPushed :: (IsStatusbar a, MonadIO m) => a -> ((?self :: a) => StatusbarTextPushedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the textPushed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after statusbar #textPushed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterStatusbarTextPushed :: (IsStatusbar a, MonadIO m) => a -> ((?self :: a) => StatusbarTextPushedCallback) -> m SignalHandlerId

-- | Creates a new Statusbar ready for messages.
statusbarNew :: (HasCallStack, MonadIO m) => m Statusbar

-- | Retrieves the box containing the label widget.
--   
--   Since: 2.20
statusbarGetMessageArea :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> m Box

-- | Removes the first message in the Statusbar’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 ()

-- | Forces the removal of all messages from a statusbar's stack with the
--   exact contextId.
--   
--   Since: 2.22
statusbarRemoveAll :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> Word32 -> m ()

-- | Type class for types which can be safely cast to StackSwitcher,
--   for instance with toStackSwitcher.
class (GObject o, IsDescendantOf StackSwitcher o) => IsStackSwitcher o

-- | Cast to StackSwitcher, for types for which this is known to be
--   safe. For general casts, use castTo.
toStackSwitcher :: (MonadIO m, IsStackSwitcher o) => o -> m StackSwitcher

-- | Get the value of the “icon-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stackSwitcher #iconSize
--   
getStackSwitcherIconSize :: (MonadIO m, IsStackSwitcher o) => o -> m Int32

-- | Set the value of the “icon-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set stackSwitcher [ #iconSize := value ]
--   
setStackSwitcherIconSize :: (MonadIO m, IsStackSwitcher o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-size” property. This is rarely needed directly, but it
--   is used by new.
constructStackSwitcherIconSize :: (IsStackSwitcher o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “stack” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get stackSwitcher #stack
--   
getStackSwitcherStack :: (MonadIO m, IsStackSwitcher o) => o -> m (Maybe Stack)

-- | Set the value of the “stack” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set stackSwitcher [ #stack := value ]
--   
setStackSwitcherStack :: (MonadIO m, IsStackSwitcher o, IsStack a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “stack” property. This is rarely needed directly, but it is
--   used by new.
constructStackSwitcherStack :: (IsStackSwitcher o, MonadIO m, IsStack a) => a -> m (GValueConstruct o)

-- | Set the value of the “stack” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #stack
--   
clearStackSwitcherStack :: (MonadIO m, IsStackSwitcher o) => o -> m ()

-- | Create a new StackSwitcher.
--   
--   Since: 3.10
stackSwitcherNew :: (HasCallStack, MonadIO m) => m StackSwitcher

-- | Retrieves the stack. See stackSwitcherSetStack.
--   
--   Since: 3.10
stackSwitcherGetStack :: (HasCallStack, MonadIO m, IsStackSwitcher a) => a -> m (Maybe Stack)

-- | Type class for types which can be safely cast to
--   ShortcutsShortcut, for instance with
--   toShortcutsShortcut.
class (GObject o, IsDescendantOf ShortcutsShortcut o) => IsShortcutsShortcut o

-- | Memory-managed wrapper type.
newtype ShortcutsShortcut
ShortcutsShortcut :: ManagedPtr ShortcutsShortcut -> ShortcutsShortcut

-- | Cast to ShortcutsShortcut, for types for which this is known to
--   be safe. For general casts, use castTo.
toShortcutsShortcut :: (MonadIO m, IsShortcutsShortcut o) => o -> m ShortcutsShortcut

-- | Set the value of the “accel-size-group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsShortcut [ #accelSizeGroup := value ]
--   
setShortcutsShortcutAccelSizeGroup :: (MonadIO m, IsShortcutsShortcut o, IsSizeGroup a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accel-size-group” property. This is rarely needed directly,
--   but it is used by new.
constructShortcutsShortcutAccelSizeGroup :: (IsShortcutsShortcut o, MonadIO m, IsSizeGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “accel-size-group” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #accelSizeGroup
--   
clearShortcutsShortcutAccelSizeGroup :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Get the value of the “accelerator” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsShortcut #accelerator
--   
getShortcutsShortcutAccelerator :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Text)

-- | Set the value of the “accelerator” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsShortcut [ #accelerator := value ]
--   
setShortcutsShortcutAccelerator :: (MonadIO m, IsShortcutsShortcut o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accelerator” property. This is rarely needed directly, but
--   it is used by new.
constructShortcutsShortcutAccelerator :: (IsShortcutsShortcut o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “accelerator” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #accelerator
--   
clearShortcutsShortcutAccelerator :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Get the value of the “action-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsShortcut #actionName
--   
getShortcutsShortcutActionName :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Text)

-- | Set the value of the “action-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsShortcut [ #actionName := value ]
--   
setShortcutsShortcutActionName :: (MonadIO m, IsShortcutsShortcut o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “action-name” property. This is rarely needed directly, but
--   it is used by new.
constructShortcutsShortcutActionName :: (IsShortcutsShortcut o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “action-name” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #actionName
--   
clearShortcutsShortcutActionName :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Get the value of the “direction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsShortcut #direction
--   
getShortcutsShortcutDirection :: (MonadIO m, IsShortcutsShortcut o) => o -> m TextDirection

-- | Set the value of the “direction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsShortcut [ #direction := value ]
--   
setShortcutsShortcutDirection :: (MonadIO m, IsShortcutsShortcut o) => o -> TextDirection -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “direction” property. This is rarely needed directly, but it
--   is used by new.
constructShortcutsShortcutDirection :: (IsShortcutsShortcut o, MonadIO m) => TextDirection -> m (GValueConstruct o)

-- | Get the value of the “icon” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get shortcutsShortcut #icon
--   
getShortcutsShortcutIcon :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Icon)

-- | Set the value of the “icon” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set shortcutsShortcut [ #icon := value ]
--   
setShortcutsShortcutIcon :: (MonadIO m, IsShortcutsShortcut o, IsIcon a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon” property. This is rarely needed directly, but it is
--   used by new.
constructShortcutsShortcutIcon :: (IsShortcutsShortcut o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “icon” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #icon
--   
clearShortcutsShortcutIcon :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Get the value of the “icon-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsShortcut #iconSet
--   
getShortcutsShortcutIconSet :: (MonadIO m, IsShortcutsShortcut o) => o -> m Bool

-- | Set the value of the “icon-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsShortcut [ #iconSet := value ]
--   
setShortcutsShortcutIconSet :: (MonadIO m, IsShortcutsShortcut o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-set” property. This is rarely needed directly, but it
--   is used by new.
constructShortcutsShortcutIconSet :: (IsShortcutsShortcut o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “shortcut-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsShortcut #shortcutType
--   
getShortcutsShortcutShortcutType :: (MonadIO m, IsShortcutsShortcut o) => o -> m ShortcutType

-- | Set the value of the “shortcut-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsShortcut [ #shortcutType := value ]
--   
setShortcutsShortcutShortcutType :: (MonadIO m, IsShortcutsShortcut o) => o -> ShortcutType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “shortcut-type” property. This is rarely needed directly, but
--   it is used by new.
constructShortcutsShortcutShortcutType :: (IsShortcutsShortcut o, MonadIO m) => ShortcutType -> m (GValueConstruct o)

-- | Get the value of the “subtitle” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsShortcut #subtitle
--   
getShortcutsShortcutSubtitle :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Text)

-- | Set the value of the “subtitle” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsShortcut [ #subtitle := value ]
--   
setShortcutsShortcutSubtitle :: (MonadIO m, IsShortcutsShortcut o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “subtitle” property. This is rarely needed directly, but it
--   is used by new.
constructShortcutsShortcutSubtitle :: (IsShortcutsShortcut o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “subtitle” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #subtitle
--   
clearShortcutsShortcutSubtitle :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Get the value of the “subtitle-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsShortcut #subtitleSet
--   
getShortcutsShortcutSubtitleSet :: (MonadIO m, IsShortcutsShortcut o) => o -> m Bool

-- | Set the value of the “subtitle-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsShortcut [ #subtitleSet := value ]
--   
setShortcutsShortcutSubtitleSet :: (MonadIO m, IsShortcutsShortcut o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “subtitle-set” property. This is rarely needed directly, but
--   it is used by new.
constructShortcutsShortcutSubtitleSet :: (IsShortcutsShortcut o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsShortcut #title
--   
getShortcutsShortcutTitle :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Text)

-- | Set the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsShortcut [ #title := value ]
--   
setShortcutsShortcutTitle :: (MonadIO m, IsShortcutsShortcut o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “title” property. This is rarely needed directly, but it is
--   used by new.
constructShortcutsShortcutTitle :: (IsShortcutsShortcut o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “title” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #title
--   
clearShortcutsShortcutTitle :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Set the value of the “title-size-group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsShortcut [ #titleSizeGroup := value ]
--   
setShortcutsShortcutTitleSizeGroup :: (MonadIO m, IsShortcutsShortcut o, IsSizeGroup a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “title-size-group” property. This is rarely needed directly,
--   but it is used by new.
constructShortcutsShortcutTitleSizeGroup :: (IsShortcutsShortcut o, MonadIO m, IsSizeGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “title-size-group” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #titleSizeGroup
--   
clearShortcutsShortcutTitleSizeGroup :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Type class for types which can be safely cast to
--   ShortcutsSection, for instance with toShortcutsSection.
class (GObject o, IsDescendantOf ShortcutsSection o) => IsShortcutsSection o

-- | Memory-managed wrapper type.
newtype ShortcutsSection
ShortcutsSection :: ManagedPtr ShortcutsSection -> ShortcutsSection

-- | Cast to ShortcutsSection, for types for which this is known to
--   be safe. For general casts, use castTo.
toShortcutsSection :: (MonadIO m, IsShortcutsSection o) => o -> m ShortcutsSection

-- | No description available in the introspection data.
type ShortcutsSectionChangeCurrentPageCallback = Int32 -> IO Bool

-- | Connect a signal handler for the changeCurrentPage signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on shortcutsSection #changeCurrentPage callback
--   
onShortcutsSectionChangeCurrentPage :: (IsShortcutsSection a, MonadIO m) => a -> ((?self :: a) => ShortcutsSectionChangeCurrentPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changeCurrentPage signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after shortcutsSection #changeCurrentPage callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterShortcutsSectionChangeCurrentPage :: (IsShortcutsSection a, MonadIO m) => a -> ((?self :: a) => ShortcutsSectionChangeCurrentPageCallback) -> m SignalHandlerId

-- | Get the value of the “max-height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsSection #maxHeight
--   
getShortcutsSectionMaxHeight :: (MonadIO m, IsShortcutsSection o) => o -> m Word32

-- | Set the value of the “max-height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsSection [ #maxHeight := value ]
--   
setShortcutsSectionMaxHeight :: (MonadIO m, IsShortcutsSection o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “max-height” property. This is rarely needed directly, but it
--   is used by new.
constructShortcutsSectionMaxHeight :: (IsShortcutsSection o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “section-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsSection #sectionName
--   
getShortcutsSectionSectionName :: (MonadIO m, IsShortcutsSection o) => o -> m (Maybe Text)

-- | Set the value of the “section-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsSection [ #sectionName := value ]
--   
setShortcutsSectionSectionName :: (MonadIO m, IsShortcutsSection o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “section-name” property. This is rarely needed directly, but
--   it is used by new.
constructShortcutsSectionSectionName :: (IsShortcutsSection o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “section-name” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #sectionName
--   
clearShortcutsSectionSectionName :: (MonadIO m, IsShortcutsSection o) => o -> m ()

-- | Get the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsSection #title
--   
getShortcutsSectionTitle :: (MonadIO m, IsShortcutsSection o) => o -> m (Maybe Text)

-- | Set the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsSection [ #title := value ]
--   
setShortcutsSectionTitle :: (MonadIO m, IsShortcutsSection o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “title” property. This is rarely needed directly, but it is
--   used by new.
constructShortcutsSectionTitle :: (IsShortcutsSection o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “title” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #title
--   
clearShortcutsSectionTitle :: (MonadIO m, IsShortcutsSection o) => o -> m ()

-- | Get the value of the “view-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsSection #viewName
--   
getShortcutsSectionViewName :: (MonadIO m, IsShortcutsSection o) => o -> m (Maybe Text)

-- | Set the value of the “view-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsSection [ #viewName := value ]
--   
setShortcutsSectionViewName :: (MonadIO m, IsShortcutsSection o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “view-name” property. This is rarely needed directly, but it
--   is used by new.
constructShortcutsSectionViewName :: (IsShortcutsSection o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “view-name” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #viewName
--   
clearShortcutsSectionViewName :: (MonadIO m, IsShortcutsSection o) => o -> m ()

-- | Type class for types which can be safely cast to
--   ShortcutsGroup, for instance with toShortcutsGroup.
class (GObject o, IsDescendantOf ShortcutsGroup o) => IsShortcutsGroup o

-- | Memory-managed wrapper type.
newtype ShortcutsGroup
ShortcutsGroup :: ManagedPtr ShortcutsGroup -> ShortcutsGroup

-- | Cast to ShortcutsGroup, for types for which this is known to be
--   safe. For general casts, use castTo.
toShortcutsGroup :: (MonadIO m, IsShortcutsGroup o) => o -> m ShortcutsGroup

-- | Set the value of the “accel-size-group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsGroup [ #accelSizeGroup := value ]
--   
setShortcutsGroupAccelSizeGroup :: (MonadIO m, IsShortcutsGroup o, IsSizeGroup a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accel-size-group” property. This is rarely needed directly,
--   but it is used by new.
constructShortcutsGroupAccelSizeGroup :: (IsShortcutsGroup o, MonadIO m, IsSizeGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “accel-size-group” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #accelSizeGroup
--   
clearShortcutsGroupAccelSizeGroup :: (MonadIO m, IsShortcutsGroup o) => o -> m ()

-- | Get the value of the “height” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsGroup #height
--   
getShortcutsGroupHeight :: (MonadIO m, IsShortcutsGroup o) => o -> m Word32

-- | Get the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutsGroup #title
--   
getShortcutsGroupTitle :: (MonadIO m, IsShortcutsGroup o) => o -> m (Maybe Text)

-- | Set the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsGroup [ #title := value ]
--   
setShortcutsGroupTitle :: (MonadIO m, IsShortcutsGroup o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “title” property. This is rarely needed directly, but it is
--   used by new.
constructShortcutsGroupTitle :: (IsShortcutsGroup o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “title” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #title
--   
clearShortcutsGroupTitle :: (MonadIO m, IsShortcutsGroup o) => o -> m ()

-- | Set the value of the “title-size-group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutsGroup [ #titleSizeGroup := value ]
--   
setShortcutsGroupTitleSizeGroup :: (MonadIO m, IsShortcutsGroup o, IsSizeGroup a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “title-size-group” property. This is rarely needed directly,
--   but it is used by new.
constructShortcutsGroupTitleSizeGroup :: (IsShortcutsGroup o, MonadIO m, IsSizeGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “title-size-group” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #titleSizeGroup
--   
clearShortcutsGroupTitleSizeGroup :: (MonadIO m, IsShortcutsGroup o) => o -> m ()

-- | Get the value of the “view” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get shortcutsGroup #view
--   
getShortcutsGroupView :: (MonadIO m, IsShortcutsGroup o) => o -> m (Maybe Text)

-- | Set the value of the “view” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set shortcutsGroup [ #view := value ]
--   
setShortcutsGroupView :: (MonadIO m, IsShortcutsGroup o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “view” property. This is rarely needed directly, but it is
--   used by new.
constructShortcutsGroupView :: (IsShortcutsGroup o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “view” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #view
--   
clearShortcutsGroupView :: (MonadIO m, IsShortcutsGroup o) => o -> m ()

-- | Type class for types which can be safely cast to ShortcutLabel,
--   for instance with toShortcutLabel.
class (GObject o, IsDescendantOf ShortcutLabel o) => IsShortcutLabel o

-- | Cast to ShortcutLabel, for types for which this is known to be
--   safe. For general casts, use castTo.
toShortcutLabel :: (MonadIO m, IsShortcutLabel o) => o -> m ShortcutLabel

-- | Get the value of the “accelerator” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutLabel #accelerator
--   
getShortcutLabelAccelerator :: (MonadIO m, IsShortcutLabel o) => o -> m (Maybe Text)

-- | Set the value of the “accelerator” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutLabel [ #accelerator := value ]
--   
setShortcutLabelAccelerator :: (MonadIO m, IsShortcutLabel o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accelerator” property. This is rarely needed directly, but
--   it is used by new.
constructShortcutLabelAccelerator :: (IsShortcutLabel o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “disabled-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get shortcutLabel #disabledText
--   
getShortcutLabelDisabledText :: (MonadIO m, IsShortcutLabel o) => o -> m (Maybe Text)

-- | Set the value of the “disabled-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set shortcutLabel [ #disabledText := value ]
--   
setShortcutLabelDisabledText :: (MonadIO m, IsShortcutLabel o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “disabled-text” property. This is rarely needed directly, but
--   it is used by new.
constructShortcutLabelDisabledText :: (IsShortcutLabel o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Creates a new ShortcutLabel with accelerator
--   set.
--   
--   Since: 3.22
shortcutLabelNew :: (HasCallStack, MonadIO m) => Text -> m ShortcutLabel

-- | Retrieves the current accelerator of self.
--   
--   Since: 3.22
shortcutLabelGetAccelerator :: (HasCallStack, MonadIO m, IsShortcutLabel a) => a -> m (Maybe Text)

-- | Retrieves the text that is displayed when no accelerator is set.
--   
--   Since: 3.22
shortcutLabelGetDisabledText :: (HasCallStack, MonadIO m, IsShortcutLabel a) => a -> m (Maybe Text)

-- | Sets the accelerator to be displayed by self.
--   
--   Since: 3.22
shortcutLabelSetAccelerator :: (HasCallStack, MonadIO m, IsShortcutLabel a) => a -> Text -> m ()

-- | Sets the text to be displayed by self when no
--   accelerator is set.
--   
--   Since: 3.22
shortcutLabelSetDisabledText :: (HasCallStack, MonadIO m, IsShortcutLabel a) => a -> Text -> m ()

-- | Type class for types which can be safely cast to HBox, for
--   instance with toHBox.
class (GObject o, IsDescendantOf HBox o) => IsHBox o

-- | Cast to HBox, for types for which this is known to be safe. For
--   general casts, use castTo.
toHBox :: (MonadIO m, IsHBox o) => o -> m HBox

-- | Creates a new HBox.
hBoxNew :: (HasCallStack, MonadIO m) => Bool -> Int32 -> m HBox

-- | Type class for types which can be safely cast to FontSelection,
--   for instance with toFontSelection.
class (GObject o, IsDescendantOf FontSelection o) => IsFontSelection o

-- | Cast to FontSelection, for types for which this is known to be
--   safe. For general casts, use castTo.
toFontSelection :: (MonadIO m, IsFontSelection o) => o -> m FontSelection

-- | Get the value of the “font-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontSelection #fontName
--   
getFontSelectionFontName :: (MonadIO m, IsFontSelection o) => o -> m (Maybe Text)

-- | Set the value of the “font-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fontSelection [ #fontName := value ]
--   
setFontSelectionFontName :: (MonadIO m, IsFontSelection o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “font-name” property. This is rarely needed directly, but it
--   is used by new.
constructFontSelectionFontName :: (IsFontSelection o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “font-name” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #fontName
--   
clearFontSelectionFontName :: (MonadIO m, IsFontSelection o) => o -> m ()

-- | Get the value of the “preview-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontSelection #previewText
--   
getFontSelectionPreviewText :: (MonadIO m, IsFontSelection o) => o -> m Text

-- | Set the value of the “preview-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fontSelection [ #previewText := value ]
--   
setFontSelectionPreviewText :: (MonadIO m, IsFontSelection o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “preview-text” property. This is rarely needed directly, but
--   it is used by new.
constructFontSelectionPreviewText :: (IsFontSelection o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Creates a new FontSelection.
fontSelectionNew :: (HasCallStack, MonadIO m) => m FontSelection

-- | Gets the FontFace representing the selected font group details
--   (i.e. family, slant, weight, width, etc).
--   
--   Since: 2.14
fontSelectionGetFace :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m FontFace

-- | This returns the TreeView which lists all styles available for
--   the selected font. For example, “Regular”, “Bold”, etc.
--   
--   Since: 2.14
fontSelectionGetFaceList :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m Widget

-- | Gets the FontFamily representing the selected font family.
--   
--   Since: 2.14
fontSelectionGetFamily :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m FontFamily

-- | This returns the TreeView that lists font families, for
--   example, “Sans”, “Serif”, etc.
--   
--   Since: 2.14
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
--   fontSelectionSetFontName, 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 fontDescriptionEqual if you
--   want to compare two font descriptions.
fontSelectionGetFontName :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m Text

-- | This returns the Entry used to display the font as a preview.
--   
--   Since: 2.14
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.
--   
--   Since: 2.14
fontSelectionGetSize :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m Int32

-- | This returns the Entry used to allow the user to edit the font
--   number manually instead of selecting it from the list of font sizes.
--   
--   Since: 2.14
fontSelectionGetSizeEntry :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m Widget

-- | This returns the TreeView used to list font sizes.
--   
--   Since: 2.14
fontSelectionGetSizeList :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m Widget

-- | Sets the text displayed in the preview area. The text
--   is used to show how the selected font looks.
fontSelectionSetPreviewText :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> Text -> m ()

-- | Type class for types which can be safely cast to
--   FontChooserWidget, for instance with
--   toFontChooserWidget.
class (GObject o, IsDescendantOf FontChooserWidget o) => IsFontChooserWidget o

-- | Cast to FontChooserWidget, for types for which this is known to
--   be safe. For general casts, use castTo.
toFontChooserWidget :: (MonadIO m, IsFontChooserWidget o) => o -> m FontChooserWidget

-- | Get the value of the “tweak-action” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontChooserWidget #tweakAction
--   
getFontChooserWidgetTweakAction :: (MonadIO m, IsFontChooserWidget o) => o -> m (Maybe Action)

-- | Creates a new FontChooserWidget.
--   
--   Since: 3.2
fontChooserWidgetNew :: (HasCallStack, MonadIO m) => m FontChooserWidget

-- | Type class for types which can be safely cast to Dialog, for
--   instance with toDialog.
class (GObject o, IsDescendantOf Dialog o) => IsDialog o

-- | Cast to Dialog, for types for which this is known to be safe.
--   For general casts, use castTo.
toDialog :: (MonadIO m, IsDialog o) => o -> m Dialog

-- | Emitted when an action widget is clicked, the dialog receives a delete
--   event, or the application programmer calls dialogResponse. On a
--   delete event, the response ID is
--   GTK_RESPONSE_DELETE_EVENT. Otherwise, it depends on
--   which action widget was clicked.
type DialogResponseCallback = Int32 -> IO ()

-- | The close 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 ()

-- | Connect a signal handler for the close signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on dialog #close callback
--   
onDialogClose :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the close signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after dialog #close callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterDialogClose :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the response signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on dialog #response callback
--   
onDialogResponse :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogResponseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the response signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after dialog #response callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterDialogResponse :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogResponseCallback) -> m SignalHandlerId

-- | Get the value of the “use-header-bar” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get dialog #useHeaderBar
--   
getDialogUseHeaderBar :: (MonadIO m, IsDialog o) => o -> m Int32

-- | Construct a GValueConstruct with valid value for the
--   “use-header-bar” property. This is rarely needed directly,
--   but it is used by new.
constructDialogUseHeaderBar :: (IsDialog o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new dialog box.
--   
--   Widgets should not be packed into this Window directly, but
--   into the vbox and actionArea, as
--   described above.
dialogNew :: (HasCallStack, MonadIO m) => m Dialog

-- | Adds an activatable widget to the action area of a Dialog,
--   connecting a signal handler that will emit the Dialog::response
--   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
--   actionArea field of the Dialog struct.
dialogAddActionWidget :: (HasCallStack, MonadIO m, IsDialog a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Returns the action area of dialog.
--   
--   Since: 2.14
dialogGetActionArea :: (HasCallStack, MonadIO m, IsDialog a) => a -> m Box

-- | Returns the header bar of dialog. Note that the
--   headerbar is only used by the dialog if the Dialog:useHeaderBar
--   property is True.
--   
--   Since: 3.12
dialogGetHeaderBar :: (HasCallStack, MonadIO m, IsDialog a) => a -> m HeaderBar

-- | Gets the response id of a widget in the action area of a dialog.
--   
--   Since: 2.8
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.
--   
--   Since: 2.20
dialogGetWidgetForResponse :: (HasCallStack, MonadIO m, IsDialog a) => a -> Int32 -> m (Maybe Widget)

-- | Sets an alternative button order. If the
--   Settings:gtkAlternativeButtonOrder setting is set to
--   True, the dialog buttons are reordered according to the order
--   of the response ids in newOrder.
--   
--   See gtk_dialog_set_alternative_button_order() for more
--   information.
--   
--   This function is for use by language bindings.
--   
--   Since: 2.6
dialogSetAlternativeButtonOrderFromArray :: (HasCallStack, MonadIO m, IsDialog a) => a -> [Int32] -> m ()

-- | Sets the last widget in the dialog’s action area with the given
--   responseId as the default widget for the dialog.
--   Pressing “Enter” normally activates the default widget.
dialogSetDefaultResponse :: (HasCallStack, MonadIO m, IsDialog a) => a -> Int32 -> m ()

-- | Calls gtk_widget_set_sensitive (widget, @setting) for each
--   widget in the dialog’s action area with the given
--   responseId. A convenient way to sensitize/desensitize
--   dialog buttons.
dialogSetResponseSensitive :: (HasCallStack, MonadIO m, IsDialog a) => a -> Int32 -> Bool -> m ()

-- | Type class for types which can be safely cast to MessageDialog,
--   for instance with toMessageDialog.
class (GObject o, IsDescendantOf MessageDialog o) => IsMessageDialog o

-- | Cast to MessageDialog, for types for which this is known to be
--   safe. For general casts, use castTo.
toMessageDialog :: (MonadIO m, IsMessageDialog o) => o -> m MessageDialog

-- | Construct a GValueConstruct with valid value for the
--   “buttons” property. This is rarely needed directly, but it is
--   used by new.
constructMessageDialogButtons :: (IsMessageDialog o, MonadIO m) => ButtonsType -> m (GValueConstruct o)

-- | Get the value of the “image” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get messageDialog #image
--   
getMessageDialogImage :: (MonadIO m, IsMessageDialog o) => o -> m Widget

-- | Set the value of the “image” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set messageDialog [ #image := value ]
--   
setMessageDialogImage :: (MonadIO m, IsMessageDialog o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “image” property. This is rarely needed directly, but it is
--   used by new.
constructMessageDialogImage :: (IsMessageDialog o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “message-area” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get messageDialog #messageArea
--   
getMessageDialogMessageArea :: (MonadIO m, IsMessageDialog o) => o -> m Widget

-- | Get the value of the “message-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get messageDialog #messageType
--   
getMessageDialogMessageType :: (MonadIO m, IsMessageDialog o) => o -> m MessageType

-- | Set the value of the “message-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set messageDialog [ #messageType := value ]
--   
setMessageDialogMessageType :: (MonadIO m, IsMessageDialog o) => o -> MessageType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “message-type” property. This is rarely needed directly, but
--   it is used by new.
constructMessageDialogMessageType :: (IsMessageDialog o, MonadIO m) => MessageType -> m (GValueConstruct o)

-- | Get the value of the “secondary-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get messageDialog #secondaryText
--   
getMessageDialogSecondaryText :: (MonadIO m, IsMessageDialog o) => o -> m (Maybe Text)

-- | Set the value of the “secondary-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set messageDialog [ #secondaryText := value ]
--   
setMessageDialogSecondaryText :: (MonadIO m, IsMessageDialog o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “secondary-text” property. This is rarely needed directly,
--   but it is used by new.
constructMessageDialogSecondaryText :: (IsMessageDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “secondary-text” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #secondaryText
--   
clearMessageDialogSecondaryText :: (MonadIO m, IsMessageDialog o) => o -> m ()

-- | Get the value of the “secondary-use-markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get messageDialog #secondaryUseMarkup
--   
getMessageDialogSecondaryUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> m Bool

-- | Set the value of the “secondary-use-markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set messageDialog [ #secondaryUseMarkup := value ]
--   
setMessageDialogSecondaryUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “secondary-use-markup” property. This is rarely needed
--   directly, but it is used by new.
constructMessageDialogSecondaryUseMarkup :: (IsMessageDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get messageDialog #text
--   
getMessageDialogText :: (MonadIO m, IsMessageDialog o) => o -> m (Maybe Text)

-- | Set the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set messageDialog [ #text := value ]
--   
setMessageDialogText :: (MonadIO m, IsMessageDialog o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text” property. This is rarely needed directly, but it is
--   used by new.
constructMessageDialogText :: (IsMessageDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “text” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #text
--   
clearMessageDialogText :: (MonadIO m, IsMessageDialog o) => o -> m ()

-- | Get the value of the “use-markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get messageDialog #useMarkup
--   
getMessageDialogUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> m Bool

-- | Set the value of the “use-markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set messageDialog [ #useMarkup := value ]
--   
setMessageDialogUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-markup” property. This is rarely needed directly, but it
--   is used by new.
constructMessageDialogUseMarkup :: (IsMessageDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Gets the dialog’s image.
--   
--   Since: 2.14
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
--   dialogGetContentArea for the corresponding function in the
--   parent Dialog.
--   
--   Since: 2.22
messageDialogGetMessageArea :: (HasCallStack, MonadIO m, IsMessageDialog a) => a -> m Widget

-- | Sets the dialog’s image to image.
--   
--   Since: 2.10
messageDialogSetImage :: (HasCallStack, MonadIO m, IsMessageDialog a, IsWidget b) => a -> b -> m ()

-- | Sets the text of the message dialog to be str, which
--   is marked up with the [Pango text markup language][PangoMarkupFormat].
--   
--   Since: 2.4
messageDialogSetMarkup :: (HasCallStack, MonadIO m, IsMessageDialog a) => a -> Text -> m ()

-- | Type class for types which can be safely cast to
--   FontSelectionDialog, for instance with
--   toFontSelectionDialog.
class (GObject o, IsDescendantOf FontSelectionDialog o) => IsFontSelectionDialog o

-- | Cast to FontSelectionDialog, for types for which this is known
--   to be safe. For general casts, use castTo.
toFontSelectionDialog :: (MonadIO m, IsFontSelectionDialog o) => o -> m FontSelectionDialog

-- | Creates a new FontSelectionDialog.
fontSelectionDialogNew :: (HasCallStack, MonadIO m) => Text -> m FontSelectionDialog

-- | Gets the “Cancel” button.
--   
--   Since: 2.14
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
--   fontSelectionDialogSetFontName, 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 fontDescriptionEqual if you
--   want to compare two font descriptions.
fontSelectionDialogGetFontName :: (HasCallStack, MonadIO m, IsFontSelectionDialog a) => a -> m Text

-- | Retrieves the FontSelection widget embedded in the dialog.
--   
--   Since: 2.22
fontSelectionDialogGetFontSelection :: (HasCallStack, MonadIO m, IsFontSelectionDialog a) => a -> m Widget

-- | Gets the “OK” button.
--   
--   Since: 2.14
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 text displayed in the preview area.
fontSelectionDialogSetPreviewText :: (HasCallStack, MonadIO m, IsFontSelectionDialog a) => a -> Text -> m ()

-- | Type class for types which can be safely cast to
--   FontChooserDialog, for instance with
--   toFontChooserDialog.
class (GObject o, IsDescendantOf FontChooserDialog o) => IsFontChooserDialog o

-- | Cast to FontChooserDialog, for types for which this is known to
--   be safe. For general casts, use castTo.
toFontChooserDialog :: (MonadIO m, IsFontChooserDialog o) => o -> m FontChooserDialog

-- | Creates a new FontChooserDialog.
--   
--   Since: 3.2
fontChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe Text -> Maybe a -> m FontChooserDialog

-- | Type class for types which can be safely cast to
--   ColorSelectionDialog, for instance with
--   toColorSelectionDialog.
class (GObject o, IsDescendantOf ColorSelectionDialog o) => IsColorSelectionDialog o

-- | Cast to ColorSelectionDialog, for types for which this is known
--   to be safe. For general casts, use castTo.
toColorSelectionDialog :: (MonadIO m, IsColorSelectionDialog o) => o -> m ColorSelectionDialog

-- | Get the value of the “cancel-button” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorSelectionDialog #cancelButton
--   
getColorSelectionDialogCancelButton :: (MonadIO m, IsColorSelectionDialog o) => o -> m (Maybe Widget)

-- | Get the value of the “color-selection” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorSelectionDialog #colorSelection
--   
getColorSelectionDialogColorSelection :: (MonadIO m, IsColorSelectionDialog o) => o -> m Widget

-- | Get the value of the “help-button” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorSelectionDialog #helpButton
--   
getColorSelectionDialogHelpButton :: (MonadIO m, IsColorSelectionDialog o) => o -> m (Maybe Widget)

-- | Get the value of the “ok-button” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorSelectionDialog #okButton
--   
getColorSelectionDialogOkButton :: (MonadIO m, IsColorSelectionDialog o) => o -> m (Maybe Widget)

-- | Creates a new ColorSelectionDialog.
colorSelectionDialogNew :: (HasCallStack, MonadIO m) => Text -> m ColorSelectionDialog

-- | Retrieves the ColorSelection widget embedded in the dialog.
--   
--   Since: 2.14
colorSelectionDialogGetColorSelection :: (HasCallStack, MonadIO m, IsColorSelectionDialog a) => a -> m Widget

-- | Type class for types which can be safely cast to
--   ColorSelection, for instance with toColorSelection.
class (GObject o, IsDescendantOf ColorSelection o) => IsColorSelection o

-- | Cast to ColorSelection, for types for which this is known to be
--   safe. For general casts, use castTo.
toColorSelection :: (MonadIO m, IsColorSelection o) => o -> m ColorSelection

-- | This signal is emitted when the color changes in the
--   ColorSelection according to its update policy.
type ColorSelectionColorChangedCallback = IO ()

-- | Connect a signal handler for the colorChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on colorSelection #colorChanged callback
--   
onColorSelectionColorChanged :: (IsColorSelection a, MonadIO m) => a -> ((?self :: a) => ColorSelectionColorChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the colorChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after colorSelection #colorChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterColorSelectionColorChanged :: (IsColorSelection a, MonadIO m) => a -> ((?self :: a) => ColorSelectionColorChangedCallback) -> m SignalHandlerId

-- | Get the value of the “current-alpha” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorSelection #currentAlpha
--   
getColorSelectionCurrentAlpha :: (MonadIO m, IsColorSelection o) => o -> m Word32

-- | Set the value of the “current-alpha” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set colorSelection [ #currentAlpha := value ]
--   
setColorSelectionCurrentAlpha :: (MonadIO m, IsColorSelection o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “current-alpha” property. This is rarely needed directly, but
--   it is used by new.
constructColorSelectionCurrentAlpha :: (IsColorSelection o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “current-color” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorSelection #currentColor
--   
getColorSelectionCurrentColor :: (MonadIO m, IsColorSelection o) => o -> m (Maybe Color)

-- | Set the value of the “current-color” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set colorSelection [ #currentColor := value ]
--   
setColorSelectionCurrentColor :: (MonadIO m, IsColorSelection o) => o -> Color -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “current-color” property. This is rarely needed directly, but
--   it is used by new.
constructColorSelectionCurrentColor :: (IsColorSelection o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Get the value of the “current-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorSelection #currentRgba
--   
getColorSelectionCurrentRgba :: (MonadIO m, IsColorSelection o) => o -> m (Maybe RGBA)

-- | Set the value of the “current-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set colorSelection [ #currentRgba := value ]
--   
setColorSelectionCurrentRgba :: (MonadIO m, IsColorSelection o) => o -> RGBA -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “current-rgba” property. This is rarely needed directly, but
--   it is used by new.
constructColorSelectionCurrentRgba :: (IsColorSelection o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “has-opacity-control” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorSelection #hasOpacityControl
--   
getColorSelectionHasOpacityControl :: (MonadIO m, IsColorSelection o) => o -> m Bool

-- | Set the value of the “has-opacity-control” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set colorSelection [ #hasOpacityControl := value ]
--   
setColorSelectionHasOpacityControl :: (MonadIO m, IsColorSelection o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-opacity-control” property. This is rarely needed
--   directly, but it is used by new.
constructColorSelectionHasOpacityControl :: (IsColorSelection o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “has-palette” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorSelection #hasPalette
--   
getColorSelectionHasPalette :: (MonadIO m, IsColorSelection o) => o -> m Bool

-- | Set the value of the “has-palette” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set colorSelection [ #hasPalette := value ]
--   
setColorSelectionHasPalette :: (MonadIO m, IsColorSelection o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-palette” property. This is rarely needed directly, but
--   it is used by new.
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 color to be the current color in the
--   GtkColorSelection widget.
colorSelectionGetCurrentColor :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m Color

-- | Sets rgba to be the current color in the
--   GtkColorSelection widget.
--   
--   Since: 3.0
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 color in with the original color value.
colorSelectionGetPreviousColor :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m Color

-- | Fills rgba in with the original color value.
--   
--   Since: 3.0
colorSelectionGetPreviousRgba :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m RGBA

-- | Gets the current state of the colorsel.
colorSelectionIsAdjusting :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m Bool

-- | Sets the current opacity to be alpha.
--   
--   The first time this is called, it will also set the original opacity
--   to be alpha too.
colorSelectionSetCurrentAlpha :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> Word16 -> m ()

-- | Sets the colorsel 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
--   hasPalette.
colorSelectionSetHasPalette :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> Bool -> m ()

-- | Sets the “previous” alpha to be alpha.
--   
--   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 color.
--   
--   This function should be called with some hesitations, as it might seem
--   confusing to have that color change. Calling
--   colorSelectionSetCurrentColor 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 rgba.
--   
--   This function should be called with some hesitations, as it might seem
--   confusing to have that color change. Calling
--   colorSelectionSetCurrentRgba will also set this color the first
--   time it is called.
--   
--   Since: 3.0
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 colorParse.
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

-- | Type class for types which can be safely cast to
--   ColorChooserWidget, for instance with
--   toColorChooserWidget.
class (GObject o, IsDescendantOf ColorChooserWidget o) => IsColorChooserWidget o

-- | Cast to ColorChooserWidget, for types for which this is known
--   to be safe. For general casts, use castTo.
toColorChooserWidget :: (MonadIO m, IsColorChooserWidget o) => o -> m ColorChooserWidget

-- | Get the value of the “show-editor” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorChooserWidget #showEditor
--   
getColorChooserWidgetShowEditor :: (MonadIO m, IsColorChooserWidget o) => o -> m Bool

-- | Set the value of the “show-editor” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set colorChooserWidget [ #showEditor := value ]
--   
setColorChooserWidgetShowEditor :: (MonadIO m, IsColorChooserWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-editor” property. This is rarely needed directly, but
--   it is used by new.
constructColorChooserWidgetShowEditor :: (IsColorChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new ColorChooserWidget.
--   
--   Since: 3.4
colorChooserWidgetNew :: (HasCallStack, MonadIO m) => m ColorChooserWidget

-- | Type class for types which can be safely cast to
--   ColorChooserDialog, for instance with
--   toColorChooserDialog.
class (GObject o, IsDescendantOf ColorChooserDialog o) => IsColorChooserDialog o

-- | Cast to ColorChooserDialog, for types for which this is known
--   to be safe. For general casts, use castTo.
toColorChooserDialog :: (MonadIO m, IsColorChooserDialog o) => o -> m ColorChooserDialog

-- | Get the value of the “show-editor” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorChooserDialog #showEditor
--   
getColorChooserDialogShowEditor :: (MonadIO m, IsColorChooserDialog o) => o -> m Bool

-- | Set the value of the “show-editor” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set colorChooserDialog [ #showEditor := value ]
--   
setColorChooserDialogShowEditor :: (MonadIO m, IsColorChooserDialog o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-editor” property. This is rarely needed directly, but
--   it is used by new.
constructColorChooserDialogShowEditor :: (IsColorChooserDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new ColorChooserDialog.
--   
--   Since: 3.4
colorChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe Text -> Maybe a -> m ColorChooserDialog

-- | Type class for types which can be safely cast to ButtonBox, for
--   instance with toButtonBox.
class (GObject o, IsDescendantOf ButtonBox o) => IsButtonBox o

-- | Cast to ButtonBox, for types for which this is known to be
--   safe. For general casts, use castTo.
toButtonBox :: (MonadIO m, IsButtonBox o) => o -> m ButtonBox

-- | Get the value of the “layout-style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get buttonBox #layoutStyle
--   
getButtonBoxLayoutStyle :: (MonadIO m, IsButtonBox o) => o -> m ButtonBoxStyle

-- | Set the value of the “layout-style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set buttonBox [ #layoutStyle := value ]
--   
setButtonBoxLayoutStyle :: (MonadIO m, IsButtonBox o) => o -> ButtonBoxStyle -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “layout-style” property. This is rarely needed directly, but
--   it is used by new.
constructButtonBoxLayoutStyle :: (IsButtonBox o, MonadIO m) => ButtonBoxStyle -> m (GValueConstruct o)

-- | Creates a new ButtonBox.
--   
--   Since: 3.0
buttonBoxNew :: (HasCallStack, MonadIO m) => Orientation -> m ButtonBox

-- | Returns whether the child is exempted from homogenous sizing.
--   
--   Since: 3.2
buttonBoxGetChildNonHomogeneous :: (HasCallStack, MonadIO m, IsButtonBox a, IsWidget b) => a -> b -> m Bool

-- | Returns whether child should appear in a secondary
--   group of children.
--   
--   Since: 2.4
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.
--   
--   Since: 3.2
buttonBoxSetChildNonHomogeneous :: (HasCallStack, MonadIO m, IsButtonBox a, IsWidget b) => a -> b -> Bool -> m ()

-- | Sets whether child 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
--   ButtonBoxStyleStart, ButtonBoxStyleSpread or
--   ButtonBoxStyleEdge, and before the other children if the style
--   is ButtonBoxStyleEnd. For horizontal button boxes, the
--   definition of before/after depends on direction of the widget (see
--   widgetSetDirection). If the style is ButtonBoxStyleStart
--   or ButtonBoxStyleEnd, 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 ()

-- | Type class for types which can be safely cast to VButtonBox,
--   for instance with toVButtonBox.
class (GObject o, IsDescendantOf VButtonBox o) => IsVButtonBox o

-- | Memory-managed wrapper type.
newtype VButtonBox
VButtonBox :: ManagedPtr VButtonBox -> VButtonBox

-- | Cast to VButtonBox, for types for which this is known to be
--   safe. For general casts, use castTo.
toVButtonBox :: (MonadIO m, IsVButtonBox o) => o -> m VButtonBox

-- | Creates a new vertical button box.
vButtonBoxNew :: (HasCallStack, MonadIO m) => m VButtonBox

-- | Type class for types which can be safely cast to HButtonBox,
--   for instance with toHButtonBox.
class (GObject o, IsDescendantOf HButtonBox o) => IsHButtonBox o

-- | Memory-managed wrapper type.
newtype HButtonBox
HButtonBox :: ManagedPtr HButtonBox -> HButtonBox

-- | Cast to HButtonBox, for types for which this is known to be
--   safe. For general casts, use castTo.
toHButtonBox :: (MonadIO m, IsHButtonBox o) => o -> m HButtonBox

-- | Creates a new horizontal button box.
hButtonBoxNew :: (HasCallStack, MonadIO m) => m HButtonBox

-- | Type class for types which can be safely cast to Assistant, for
--   instance with toAssistant.
class (GObject o, IsDescendantOf Assistant o) => IsAssistant o

-- | Cast to Assistant, for types for which this is known to be
--   safe. For general casts, use castTo.
toAssistant :: (MonadIO m, IsAssistant o) => o -> m Assistant

-- | The prepare 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 page.
--   
--   Since: 2.10
type AssistantPrepareCallback = Widget -> IO ()

-- | No description available in the introspection data.
type AssistantEscapeCallback = IO ()

-- | The close 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 AssistantPageTypeConfirm) is clicked.
--   
--   Since: 2.10
type AssistantCloseCallback = IO ()

-- | The cancel signal is emitted when then the cancel button is
--   clicked.
--   
--   Since: 2.10
type AssistantCancelCallback = IO ()

-- | The apply signal is emitted when the apply button is clicked.
--   
--   The default behavior of the Assistant is to switch to the page
--   after the current page, unless the current page is the last one.
--   
--   A handler for the apply 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
--   AssistantPageTypeProgress after the confirmation page and
--   handle this operation within the Assistant::prepare signal of
--   the progress page.
--   
--   Since: 2.10
type AssistantApplyCallback = IO ()

-- | Connect a signal handler for the apply signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on assistant #apply callback
--   
onAssistantApply :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantApplyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the apply signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after assistant #apply callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAssistantApply :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantApplyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cancel signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on assistant #cancel callback
--   
onAssistantCancel :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the cancel signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after assistant #cancel callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAssistantCancel :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the close signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on assistant #close callback
--   
onAssistantClose :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the close signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after assistant #close callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAssistantClose :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the escape signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on assistant #escape callback
--   
onAssistantEscape :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantEscapeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the escape signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after assistant #escape callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAssistantEscape :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantEscapeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the prepare signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on assistant #prepare callback
--   
onAssistantPrepare :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantPrepareCallback) -> m SignalHandlerId

-- | Connect a signal handler for the prepare signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after assistant #prepare callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAssistantPrepare :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantPrepareCallback) -> m SignalHandlerId

-- | Get the value of the “use-header-bar” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get assistant #useHeaderBar
--   
getAssistantUseHeaderBar :: (MonadIO m, IsAssistant o) => o -> m Int32

-- | Construct a GValueConstruct with valid value for the
--   “use-header-bar” property. This is rarely needed directly,
--   but it is used by new.
constructAssistantUseHeaderBar :: (IsAssistant o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new Assistant.
--   
--   Since: 2.10
assistantNew :: (HasCallStack, MonadIO m) => m Assistant

-- | Appends a page to the assistant.
--   
--   Since: 2.10
assistantAppendPage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Int32

-- | Returns the page number of the current page.
--   
--   Since: 2.10
assistantGetCurrentPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m Int32

-- | Returns the number of pages in the assistant
--   
--   Since: 2.10
assistantGetNPages :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m Int32

-- | Returns the child widget contained in page number
--   pageNum.
--   
--   Since: 2.10
assistantGetNthPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> Int32 -> m (Maybe Widget)

-- | Gets whether page is complete.
--   
--   Since: 2.10
assistantGetPageComplete :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Bool

-- | Gets whether page has padding.
--   
--   Since: 3.18
assistantGetPageHasPadding :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Bool

-- | Gets the header image for page.
--   
--   Since: 2.10
assistantGetPageHeaderImage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Pixbuf

-- | Gets the side image for page.
--   
--   Since: 2.10
assistantGetPageSideImage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Pixbuf

-- | Gets the title for page.
--   
--   Since: 2.10
assistantGetPageTitle :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Text

-- | Gets the page type of page.
--   
--   Since: 2.10
assistantGetPageType :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m AssistantPageType

-- | Inserts a page in the assistant at a given position.
--   
--   Since: 2.10
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
--   GTK_ASSISTANT_PAGE_CUSTOM type.
--   
--   Since: 3.0
assistantNextPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m ()

-- | Prepends a page to the assistant.
--   
--   Since: 2.10
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
--   GTK_ASSISTANT_PAGE_CUSTOM type.
--   
--   Since: 3.0
assistantPreviousPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m ()

-- | Removes a widget from the action area of a Assistant.
--   
--   Since: 2.10
assistantRemoveActionWidget :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m ()

-- | Removes the pageNum’s page from
--   assistant.
--   
--   Since: 3.2
assistantRemovePage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> Int32 -> m ()

-- | Switches the page to pageNum.
--   
--   Note that this will only be necessary in custom buttons, as the
--   assistant flow can be set with
--   assistantSetForwardPageFunc.
--   
--   Since: 2.10
assistantSetCurrentPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> Int32 -> m ()

-- | Sets whether page contents are complete.
--   
--   This will make assistant update the buttons state to
--   be able to continue the task.
--   
--   Since: 2.10
assistantSetPageComplete :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> Bool -> m ()

-- | Sets whether the assistant is adding padding around the page.
--   
--   Since: 3.18
assistantSetPageHasPadding :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> Bool -> m ()

-- | Sets a header image for page.
--   
--   Since: 2.10
assistantSetPageHeaderImage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b, IsPixbuf c) => a -> b -> Maybe c -> m ()

-- | Sets a side image for page.
--   
--   This image used to be displayed in the side area of the assistant when
--   page is the current page.
--   
--   Since: 2.10
assistantSetPageSideImage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b, IsPixbuf c) => a -> b -> Maybe c -> m ()

-- | Sets a title for page.
--   
--   The title is displayed in the header area of the assistant when
--   page is the current page.
--   
--   Since: 2.10
assistantSetPageTitle :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> Text -> m ()

-- | Sets the page type for page.
--   
--   The page type determines the page behavior in the
--   assistant.
--   
--   Since: 2.10
assistantSetPageType :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> AssistantPageType -> m ()

-- | Forces assistant 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.
--   
--   Since: 2.10
assistantUpdateButtonsState :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m ()

-- | Type class for types which can be safely cast to AspectFrame,
--   for instance with toAspectFrame.
class (GObject o, IsDescendantOf AspectFrame o) => IsAspectFrame o

-- | Cast to AspectFrame, for types for which this is known to be
--   safe. For general casts, use castTo.
toAspectFrame :: (MonadIO m, IsAspectFrame o) => o -> m AspectFrame

-- | Get the value of the “obey-child” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aspectFrame #obeyChild
--   
getAspectFrameObeyChild :: (MonadIO m, IsAspectFrame o) => o -> m Bool

-- | Set the value of the “obey-child” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aspectFrame [ #obeyChild := value ]
--   
setAspectFrameObeyChild :: (MonadIO m, IsAspectFrame o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “obey-child” property. This is rarely needed directly, but it
--   is used by new.
constructAspectFrameObeyChild :: (IsAspectFrame o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “ratio” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aspectFrame #ratio
--   
getAspectFrameRatio :: (MonadIO m, IsAspectFrame o) => o -> m Float

-- | Set the value of the “ratio” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aspectFrame [ #ratio := value ]
--   
setAspectFrameRatio :: (MonadIO m, IsAspectFrame o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “ratio” property. This is rarely needed directly, but it is
--   used by new.
constructAspectFrameRatio :: (IsAspectFrame o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aspectFrame #xalign
--   
getAspectFrameXalign :: (MonadIO m, IsAspectFrame o) => o -> m Float

-- | Set the value of the “xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aspectFrame [ #xalign := value ]
--   
setAspectFrameXalign :: (MonadIO m, IsAspectFrame o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “xalign” property. This is rarely needed directly, but it is
--   used by new.
constructAspectFrameXalign :: (IsAspectFrame o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aspectFrame #yalign
--   
getAspectFrameYalign :: (MonadIO m, IsAspectFrame o) => o -> m Float

-- | Set the value of the “yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aspectFrame [ #yalign := value ]
--   
setAspectFrameYalign :: (MonadIO m, IsAspectFrame o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “yalign” property. This is rarely needed directly, but it is
--   used by new.
constructAspectFrameYalign :: (IsAspectFrame o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Create a new AspectFrame.
aspectFrameNew :: (HasCallStack, MonadIO m) => Maybe Text -> Float -> Float -> Float -> Bool -> m AspectFrame

-- | Set parameters for an existing AspectFrame.
aspectFrameSet :: (HasCallStack, MonadIO m, IsAspectFrame a) => a -> Float -> Float -> Float -> Bool -> m ()

-- | Type class for types which can be safely cast to Arrow, for
--   instance with toArrow.
class (GObject o, IsDescendantOf Arrow o) => IsArrow o

-- | Cast to Arrow, for types for which this is known to be safe.
--   For general casts, use castTo.
toArrow :: (MonadIO m, IsArrow o) => o -> m Arrow

-- | Get the value of the “arrow-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get arrow #arrowType
--   
getArrowArrowType :: (MonadIO m, IsArrow o) => o -> m ArrowType

-- | Set the value of the “arrow-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set arrow [ #arrowType := value ]
--   
setArrowArrowType :: (MonadIO m, IsArrow o) => o -> ArrowType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “arrow-type” property. This is rarely needed directly, but it
--   is used by new.
constructArrowArrowType :: (IsArrow o, MonadIO m) => ArrowType -> m (GValueConstruct o)

-- | Get the value of the “shadow-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get arrow #shadowType
--   
getArrowShadowType :: (MonadIO m, IsArrow o) => o -> m ShadowType

-- | Set the value of the “shadow-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set arrow [ #shadowType := value ]
--   
setArrowShadowType :: (MonadIO m, IsArrow o) => o -> ShadowType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “shadow-type” property. This is rarely needed directly, but
--   it is used by new.
constructArrowShadowType :: (IsArrow o, MonadIO m) => ShadowType -> m (GValueConstruct o)

-- | Creates a new Arrow widget.
arrowNew :: (HasCallStack, MonadIO m) => ArrowType -> ShadowType -> m Arrow

-- | Sets the direction and style of the Arrow,
--   arrow.
arrowSet :: (HasCallStack, MonadIO m, IsArrow a) => a -> ArrowType -> ShadowType -> m ()

-- | Type class for types which can be safely cast to
--   ApplicationWindow, for instance with
--   toApplicationWindow.
class (GObject o, IsDescendantOf ApplicationWindow o) => IsApplicationWindow o

-- | Cast to ApplicationWindow, for types for which this is known to
--   be safe. For general casts, use castTo.
toApplicationWindow :: (MonadIO m, IsApplicationWindow o) => o -> m ApplicationWindow

-- | Get the value of the “show-menubar” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get applicationWindow #showMenubar
--   
getApplicationWindowShowMenubar :: (MonadIO m, IsApplicationWindow o) => o -> m Bool

-- | Set the value of the “show-menubar” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set applicationWindow [ #showMenubar := value ]
--   
setApplicationWindowShowMenubar :: (MonadIO m, IsApplicationWindow o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-menubar” property. This is rarely needed directly, but
--   it is used by new.
constructApplicationWindowShowMenubar :: (IsApplicationWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new ApplicationWindow.
--   
--   Since: 3.4
applicationWindowNew :: (HasCallStack, MonadIO m, IsApplication a) => a -> m ApplicationWindow

-- | Gets the ShortcutsWindow that has been set up with a prior call
--   to applicationWindowSetHelpOverlay.
--   
--   Since: 3.20
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.
--   
--   Since: 3.4
applicationWindowGetShowMenubar :: (HasCallStack, MonadIO m, IsApplicationWindow a) => a -> m Bool

-- | Sets whether the window will display a menubar for the app menu and
--   menubar as needed.
--   
--   Since: 3.4
applicationWindowSetShowMenubar :: (HasCallStack, MonadIO m, IsApplicationWindow a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to Alignment, for
--   instance with toAlignment.
class (GObject o, IsDescendantOf Alignment o) => IsAlignment o

-- | Cast to Alignment, for types for which this is known to be
--   safe. For general casts, use castTo.
toAlignment :: (MonadIO m, IsAlignment o) => o -> m Alignment

-- | Get the value of the “bottom-padding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get alignment #bottomPadding
--   
getAlignmentBottomPadding :: (MonadIO m, IsAlignment o) => o -> m Word32

-- | Set the value of the “bottom-padding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set alignment [ #bottomPadding := value ]
--   
setAlignmentBottomPadding :: (MonadIO m, IsAlignment o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “bottom-padding” property. This is rarely needed directly,
--   but it is used by new.
constructAlignmentBottomPadding :: (IsAlignment o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “left-padding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get alignment #leftPadding
--   
getAlignmentLeftPadding :: (MonadIO m, IsAlignment o) => o -> m Word32

-- | Set the value of the “left-padding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set alignment [ #leftPadding := value ]
--   
setAlignmentLeftPadding :: (MonadIO m, IsAlignment o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “left-padding” property. This is rarely needed directly, but
--   it is used by new.
constructAlignmentLeftPadding :: (IsAlignment o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “right-padding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get alignment #rightPadding
--   
getAlignmentRightPadding :: (MonadIO m, IsAlignment o) => o -> m Word32

-- | Set the value of the “right-padding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set alignment [ #rightPadding := value ]
--   
setAlignmentRightPadding :: (MonadIO m, IsAlignment o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “right-padding” property. This is rarely needed directly, but
--   it is used by new.
constructAlignmentRightPadding :: (IsAlignment o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “top-padding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get alignment #topPadding
--   
getAlignmentTopPadding :: (MonadIO m, IsAlignment o) => o -> m Word32

-- | Set the value of the “top-padding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set alignment [ #topPadding := value ]
--   
setAlignmentTopPadding :: (MonadIO m, IsAlignment o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “top-padding” property. This is rarely needed directly, but
--   it is used by new.
constructAlignmentTopPadding :: (IsAlignment o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get alignment #xalign
--   
getAlignmentXalign :: (MonadIO m, IsAlignment o) => o -> m Float

-- | Set the value of the “xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set alignment [ #xalign := value ]
--   
setAlignmentXalign :: (MonadIO m, IsAlignment o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “xalign” property. This is rarely needed directly, but it is
--   used by new.
constructAlignmentXalign :: (IsAlignment o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “xscale” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get alignment #xscale
--   
getAlignmentXscale :: (MonadIO m, IsAlignment o) => o -> m Float

-- | Set the value of the “xscale” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set alignment [ #xscale := value ]
--   
setAlignmentXscale :: (MonadIO m, IsAlignment o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “xscale” property. This is rarely needed directly, but it is
--   used by new.
constructAlignmentXscale :: (IsAlignment o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get alignment #yalign
--   
getAlignmentYalign :: (MonadIO m, IsAlignment o) => o -> m Float

-- | Set the value of the “yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set alignment [ #yalign := value ]
--   
setAlignmentYalign :: (MonadIO m, IsAlignment o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “yalign” property. This is rarely needed directly, but it is
--   used by new.
constructAlignmentYalign :: (IsAlignment o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “yscale” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get alignment #yscale
--   
getAlignmentYscale :: (MonadIO m, IsAlignment o) => o -> m Float

-- | Set the value of the “yscale” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set alignment [ #yscale := value ]
--   
setAlignmentYscale :: (MonadIO m, IsAlignment o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “yscale” property. This is rarely needed directly, but it is
--   used by new.
constructAlignmentYscale :: (IsAlignment o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Creates a new Alignment.
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 ().
--   
--   Since: 2.4
alignmentGetPadding :: (HasCallStack, MonadIO m, IsAlignment a) => a -> m (Word32, Word32, Word32, Word32)

-- | Sets the Alignment 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.
--   
--   Since: 2.4
alignmentSetPadding :: (HasCallStack, MonadIO m, IsAlignment a) => a -> Word32 -> Word32 -> Word32 -> Word32 -> m ()

-- | Type class for types which can be safely cast to ActionBar, for
--   instance with toActionBar.
class (GObject o, IsDescendantOf ActionBar o) => IsActionBar o

-- | Cast to ActionBar, for types for which this is known to be
--   safe. For general casts, use castTo.
toActionBar :: (MonadIO m, IsActionBar o) => o -> m ActionBar

-- | Creates a new ActionBar widget.
--   
--   Since: 3.12
actionBarNew :: (HasCallStack, MonadIO m) => m ActionBar

-- | Retrieves the center bar widget of the bar.
--   
--   Since: 3.12
actionBarGetCenterWidget :: (HasCallStack, MonadIO m, IsActionBar a) => a -> m (Maybe Widget)

-- | Adds child to actionBar, packed with
--   reference to the end of the actionBar.
--   
--   Since: 3.12
actionBarPackEnd :: (HasCallStack, MonadIO m, IsActionBar a, IsWidget b) => a -> b -> m ()

-- | Adds child to actionBar, packed with
--   reference to the start of the actionBar.
--   
--   Since: 3.12
actionBarPackStart :: (HasCallStack, MonadIO m, IsActionBar a, IsWidget b) => a -> b -> m ()

-- | Sets the center widget for the ActionBar.
--   
--   Since: 3.12
actionBarSetCenterWidget :: (HasCallStack, MonadIO m, IsActionBar a, IsWidget b) => a -> Maybe b -> m ()

-- | Type class for types which can be safely cast to UIManager, for
--   instance with toUIManager.
class (GObject o, IsDescendantOf UIManager o) => IsUIManager o

-- | Cast to UIManager, for types for which this is known to be
--   safe. For general casts, use castTo.
toUIManager :: (MonadIO m, IsUIManager o) => o -> m UIManager

-- | The preActivate signal is emitted just before the
--   action is activated.
--   
--   This is intended for applications to get notification just before any
--   action is activated.
--   
--   Since: 2.4
type UIManagerPreActivateCallback = Action -> IO ()

-- | The postActivate signal is emitted just after the
--   action is activated.
--   
--   This is intended for applications to get notification just after any
--   action is activated.
--   
--   Since: 2.4
type UIManagerPostActivateCallback = Action -> IO ()

-- | The disconnectProxy signal is emitted after disconnecting a
--   proxy from an action in the group.
--   
--   Since: 2.4
type UIManagerDisconnectProxyCallback = Action -> Widget -> IO ()

-- | The connectProxy 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.
--   
--   Since: 2.4
type UIManagerConnectProxyCallback = Action -> Widget -> IO ()

-- | The addWidget signal is emitted for each generated menubar and
--   toolbar. It is not emitted for generated popup menus, which can be
--   obtained by uIManagerGetWidget.
--   
--   Since: 2.4
type UIManagerAddWidgetCallback = Widget -> IO ()

-- | The actionsChanged signal is emitted whenever the set of
--   actions changes.
--   
--   Since: 2.4
type UIManagerActionsChangedCallback = IO ()

-- | Connect a signal handler for the actionsChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on uIManager #actionsChanged callback
--   
onUIManagerActionsChanged :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerActionsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the actionsChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after uIManager #actionsChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterUIManagerActionsChanged :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerActionsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the addWidget signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on uIManager #addWidget callback
--   
onUIManagerAddWidget :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerAddWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the addWidget signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after uIManager #addWidget callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterUIManagerAddWidget :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerAddWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the connectProxy signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on uIManager #connectProxy callback
--   
onUIManagerConnectProxy :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerConnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the connectProxy signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after uIManager #connectProxy callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterUIManagerConnectProxy :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerConnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the disconnectProxy signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on uIManager #disconnectProxy callback
--   
onUIManagerDisconnectProxy :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerDisconnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the disconnectProxy signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after uIManager #disconnectProxy callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterUIManagerDisconnectProxy :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerDisconnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the postActivate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on uIManager #postActivate callback
--   
onUIManagerPostActivate :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerPostActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the postActivate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after uIManager #postActivate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterUIManagerPostActivate :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerPostActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preActivate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on uIManager #preActivate callback
--   
onUIManagerPreActivate :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerPreActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the preActivate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after uIManager #preActivate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterUIManagerPreActivate :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerPreActivateCallback) -> m SignalHandlerId

-- | Get the value of the “add-tearoffs” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get uIManager #addTearoffs
--   
getUIManagerAddTearoffs :: (MonadIO m, IsUIManager o) => o -> m Bool

-- | Set the value of the “add-tearoffs” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set uIManager [ #addTearoffs := value ]
--   
setUIManagerAddTearoffs :: (MonadIO m, IsUIManager o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “add-tearoffs” property. This is rarely needed directly, but
--   it is used by new.
constructUIManagerAddTearoffs :: (IsUIManager o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “ui” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get uIManager #ui
--   
getUIManagerUi :: (MonadIO m, IsUIManager o) => o -> m (Maybe Text)

-- | Creates a new ui manager object.
--   
--   Since: 2.4
uIManagerNew :: (HasCallStack, MonadIO m) => m UIManager

-- | Parses a file containing a [UI definition][XML-UI] and merges it with
--   the current contents of manager.
--   
--   Since: 2.4
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 manager.
--   
--   Since: 3.4
uIManagerAddUiFromResource :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Text -> m Word32

-- | Makes sure that all pending updates to the UI have been completed.
--   
--   This may occasionally be necessary, since UIManager 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:
--   
--   
C code
--   
--   
--   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);
--   
--   
--   Since: 2.4
uIManagerEnsureUpdate :: (HasCallStack, MonadIO m, IsUIManager a) => a -> m ()

-- | Returns the AccelGroup associated with manager.
--   
--   Since: 2.4
uIManagerGetAccelGroup :: (HasCallStack, MonadIO m, IsUIManager a) => a -> m AccelGroup

-- | Looks up an action by following a path. See uIManagerGetWidget
--   for more information about paths.
--   
--   Since: 2.4
uIManagerGetAction :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Text -> m (Maybe Action)

-- | Returns the list of action groups associated with
--   manager.
--   
--   Since: 2.4
uIManagerGetActionGroups :: (HasCallStack, MonadIO m, IsUIManager a) => a -> m [ActionGroup]

-- | Returns whether menus generated by this UIManager will have
--   tearoff menu items.
--   
--   Since: 2.4
uIManagerGetAddTearoffs :: (HasCallStack, MonadIO m, IsUIManager a) => a -> m Bool

-- | Obtains a list of all toplevel widgets of the requested types.
--   
--   Since: 2.4
uIManagerGetToplevels :: (HasCallStack, MonadIO m, IsUIManager a) => a -> [UIManagerItemType] -> m [Widget]

-- | Creates a [UI definition][XML-UI] of the merged UI.
--   
--   Since: 2.4
uIManagerGetUi :: (HasCallStack, MonadIO m, IsUIManager a) => a -> m Text

-- | Inserts an action group into the list of action groups associated with
--   manager. Actions in earlier groups hide actions with
--   the same name in later groups.
--   
--   If pos is larger than the number of action groups in
--   manager, or negative, actionGroup will
--   be inserted at the end of the internal list.
--   
--   Since: 2.4
uIManagerInsertActionGroup :: (HasCallStack, MonadIO m, IsUIManager a, IsActionGroup b) => a -> b -> Int32 -> m ()

-- | Removes an action group from the list of action groups associated with
--   manager.
--   
--   Since: 2.4
uIManagerRemoveActionGroup :: (HasCallStack, MonadIO m, IsUIManager a, IsActionGroup b) => a -> b -> m ()

-- | Sets the “add_tearoffs” property, which controls whether menus
--   generated by this UIManager will have tearoff menu items.
--   
--   Note that this only affects regular menus. Generated popup menus never
--   have tearoff menu items.
--   
--   Since: 2.4
uIManagerSetAddTearoffs :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to ToggleAction,
--   for instance with toToggleAction.
class (GObject o, IsDescendantOf ToggleAction o) => IsToggleAction o

-- | Cast to ToggleAction, for types for which this is known to be
--   safe. For general casts, use castTo.
toToggleAction :: (MonadIO m, IsToggleAction o) => o -> m ToggleAction

-- | Should be connected if you wish to perform an action whenever the
--   ToggleAction state is changed.
type ToggleActionToggledCallback = IO ()

-- | Connect a signal handler for the toggled signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on toggleAction #toggled callback
--   
onToggleActionToggled :: (IsToggleAction a, MonadIO m) => a -> ((?self :: a) => ToggleActionToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggled signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after toggleAction #toggled callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterToggleActionToggled :: (IsToggleAction a, MonadIO m) => a -> ((?self :: a) => ToggleActionToggledCallback) -> m SignalHandlerId

-- | Get the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toggleAction #active
--   
getToggleActionActive :: (MonadIO m, IsToggleAction o) => o -> m Bool

-- | Set the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toggleAction [ #active := value ]
--   
setToggleActionActive :: (MonadIO m, IsToggleAction o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “active” property. This is rarely needed directly, but it is
--   used by new.
constructToggleActionActive :: (IsToggleAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “draw-as-radio” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toggleAction #drawAsRadio
--   
getToggleActionDrawAsRadio :: (MonadIO m, IsToggleAction o) => o -> m Bool

-- | Set the value of the “draw-as-radio” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toggleAction [ #drawAsRadio := value ]
--   
setToggleActionDrawAsRadio :: (MonadIO m, IsToggleAction o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “draw-as-radio” property. This is rarely needed directly, but
--   it is used by new.
constructToggleActionDrawAsRadio :: (IsToggleAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new ToggleAction object. To add the action to a
--   ActionGroup and set the accelerator for the action, call
--   actionGroupAddActionWithAccel.
--   
--   Since: 2.4
toggleActionNew :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> m ToggleAction

-- | Returns the checked state of the toggle action.
--   
--   Since: 2.4
toggleActionGetActive :: (HasCallStack, MonadIO m, IsToggleAction a) => a -> m Bool

-- | Returns whether the action should have proxies like a radio action.
--   
--   Since: 2.4
toggleActionGetDrawAsRadio :: (HasCallStack, MonadIO m, IsToggleAction a) => a -> m Bool

-- | Sets the checked state on the toggle action.
--   
--   Since: 2.4
toggleActionSetActive :: (HasCallStack, MonadIO m, IsToggleAction a) => a -> Bool -> m ()

-- | Sets whether the action should have proxies like a radio action.
--   
--   Since: 2.4
toggleActionSetDrawAsRadio :: (HasCallStack, MonadIO m, IsToggleAction a) => a -> Bool -> m ()

-- | Emits the “toggled” signal on the toggle action.
--   
--   Since: 2.4
toggleActionToggled :: (HasCallStack, MonadIO m, IsToggleAction a) => a -> m ()

-- | Type class for types which can be safely cast to RadioAction,
--   for instance with toRadioAction.
class (GObject o, IsDescendantOf RadioAction o) => IsRadioAction o

-- | Cast to RadioAction, for types for which this is known to be
--   safe. For general casts, use castTo.
toRadioAction :: (MonadIO m, IsRadioAction o) => o -> m RadioAction

-- | The changed signal is emitted on every member of a radio group
--   when the active member is changed. The signal gets emitted after the
--   activate signals for the previous and current active members.
--   
--   Since: 2.4
type RadioActionChangedCallback = RadioAction -> IO ()

-- | Connect a signal handler for the changed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on radioAction #changed callback
--   
onRadioActionChanged :: (IsRadioAction a, MonadIO m) => a -> ((?self :: a) => RadioActionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after radioAction #changed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterRadioActionChanged :: (IsRadioAction a, MonadIO m) => a -> ((?self :: a) => RadioActionChangedCallback) -> m SignalHandlerId

-- | Get the value of the “current-value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get radioAction #currentValue
--   
getRadioActionCurrentValue :: (MonadIO m, IsRadioAction o) => o -> m Int32

-- | Set the value of the “current-value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set radioAction [ #currentValue := value ]
--   
setRadioActionCurrentValue :: (MonadIO m, IsRadioAction o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “current-value” property. This is rarely needed directly, but
--   it is used by new.
constructRadioActionCurrentValue :: (IsRadioAction o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Set the value of the “group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set radioAction [ #group := value ]
--   
setRadioActionGroup :: (MonadIO m, IsRadioAction o, IsRadioAction a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “group” property. This is rarely needed directly, but it is
--   used by new.
constructRadioActionGroup :: (IsRadioAction o, MonadIO m, IsRadioAction a) => a -> m (GValueConstruct o)

-- | Set the value of the “group” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #group
--   
clearRadioActionGroup :: (MonadIO m, IsRadioAction o) => o -> m ()

-- | Get the value of the “value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get radioAction #value
--   
getRadioActionValue :: (MonadIO m, IsRadioAction o) => o -> m Int32

-- | Set the value of the “value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set radioAction [ #value := value ]
--   
setRadioActionValue :: (MonadIO m, IsRadioAction o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “value” property. This is rarely needed directly, but it is
--   used by new.
constructRadioActionValue :: (IsRadioAction o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new RadioAction object. To add the action to a
--   ActionGroup and set the accelerator for the action, call
--   actionGroupAddActionWithAccel.
--   
--   Since: 2.4
radioActionNew :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> Int32 -> m RadioAction

-- | Joins a radio action object to the group of another radio action
--   object.
--   
--   Use this in language bindings instead of the
--   radioActionGetGroup and radioActionSetGroup methods
--   
--   A common way to set up a group of radio actions is the following:
--   
--   
C code
--   
--   
--   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;
--     }
--   
--   
--   Since: 3.0
radioActionJoinGroup :: (HasCallStack, MonadIO m, IsRadioAction a, IsRadioAction b) => a -> Maybe b -> m ()

-- | Sets the currently active group member to the member with value
--   property currentValue.
--   
--   Since: 2.10
radioActionSetCurrentValue :: (HasCallStack, MonadIO m, IsRadioAction a) => a -> Int32 -> m ()

-- | Type class for types which can be safely cast to Accessible,
--   for instance with toAccessible.
class (GObject o, IsDescendantOf Accessible o) => IsAccessible o

-- | Cast to Accessible, for types for which this is known to be
--   safe. For general casts, use castTo.
toAccessible :: (MonadIO m, IsAccessible o) => o -> m Accessible

-- | Get the value of the “widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get accessible #widget
--   
getAccessibleWidget :: (MonadIO m, IsAccessible o) => o -> m (Maybe Widget)

-- | Set the value of the “widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set accessible [ #widget := value ]
--   
setAccessibleWidget :: (MonadIO m, IsAccessible o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “widget” property. This is rarely needed directly, but it is
--   used by new.
constructAccessibleWidget :: (IsAccessible o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “widget” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #widget
--   
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 Widget corresponding to the Accessible. The
--   returned widget does not have a reference added, so you do not need to
--   unref it.
--   
--   Since: 2.22
accessibleGetWidget :: (HasCallStack, MonadIO m, IsAccessible a) => a -> m (Maybe Widget)

-- | Sets the Widget corresponding to the Accessible.
--   
--   accessible will not hold a reference to
--   widget. It is the caller’s responsibility to ensure
--   that when widget is destroyed, the widget is unset by
--   calling this function again with widget set to
--   Nothing.
--   
--   Since: 2.22
accessibleSetWidget :: (HasCallStack, MonadIO m, IsAccessible a, IsWidget b) => a -> Maybe b -> m ()

-- | Type class for types which can be safely cast to
--   WidgetAccessible, for instance with toWidgetAccessible.
class (GObject o, IsDescendantOf WidgetAccessible o) => IsWidgetAccessible o

-- | Memory-managed wrapper type.
newtype WidgetAccessible
WidgetAccessible :: ManagedPtr WidgetAccessible -> WidgetAccessible

-- | Cast to WidgetAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toWidgetAccessible :: (MonadIO m, IsWidgetAccessible o) => o -> m WidgetAccessible

-- | Type class for types which can be safely cast to
--   SwitchAccessible, for instance with toSwitchAccessible.
class (GObject o, IsDescendantOf SwitchAccessible o) => IsSwitchAccessible o

-- | Memory-managed wrapper type.
newtype SwitchAccessible
SwitchAccessible :: ManagedPtr SwitchAccessible -> SwitchAccessible

-- | Cast to SwitchAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toSwitchAccessible :: (MonadIO m, IsSwitchAccessible o) => o -> m SwitchAccessible

-- | Type class for types which can be safely cast to
--   SpinnerAccessible, for instance with
--   toSpinnerAccessible.
class (GObject o, IsDescendantOf SpinnerAccessible o) => IsSpinnerAccessible o

-- | Memory-managed wrapper type.
newtype SpinnerAccessible
SpinnerAccessible :: ManagedPtr SpinnerAccessible -> SpinnerAccessible

-- | Cast to SpinnerAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toSpinnerAccessible :: (MonadIO m, IsSpinnerAccessible o) => o -> m SpinnerAccessible

-- | Type class for types which can be safely cast to
--   RangeAccessible, for instance with toRangeAccessible.
class (GObject o, IsDescendantOf RangeAccessible o) => IsRangeAccessible o

-- | Memory-managed wrapper type.
newtype RangeAccessible
RangeAccessible :: ManagedPtr RangeAccessible -> RangeAccessible

-- | Cast to RangeAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toRangeAccessible :: (MonadIO m, IsRangeAccessible o) => o -> m RangeAccessible

-- | Type class for types which can be safely cast to
--   ScaleAccessible, for instance with toScaleAccessible.
class (GObject o, IsDescendantOf ScaleAccessible o) => IsScaleAccessible o

-- | Memory-managed wrapper type.
newtype ScaleAccessible
ScaleAccessible :: ManagedPtr ScaleAccessible -> ScaleAccessible

-- | Cast to ScaleAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toScaleAccessible :: (MonadIO m, IsScaleAccessible o) => o -> m ScaleAccessible

-- | Type class for types which can be safely cast to
--   ProgressBarAccessible, for instance with
--   toProgressBarAccessible.
class (GObject o, IsDescendantOf ProgressBarAccessible o) => IsProgressBarAccessible o

-- | Memory-managed wrapper type.
newtype ProgressBarAccessible
ProgressBarAccessible :: ManagedPtr ProgressBarAccessible -> ProgressBarAccessible

-- | Cast to ProgressBarAccessible, for types for which this is
--   known to be safe. For general casts, use castTo.
toProgressBarAccessible :: (MonadIO m, IsProgressBarAccessible o) => o -> m ProgressBarAccessible

-- | Type class for types which can be safely cast to
--   LevelBarAccessible, for instance with
--   toLevelBarAccessible.
class (GObject o, IsDescendantOf LevelBarAccessible o) => IsLevelBarAccessible o

-- | Memory-managed wrapper type.
newtype LevelBarAccessible
LevelBarAccessible :: ManagedPtr LevelBarAccessible -> LevelBarAccessible

-- | Cast to LevelBarAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toLevelBarAccessible :: (MonadIO m, IsLevelBarAccessible o) => o -> m LevelBarAccessible

-- | Type class for types which can be safely cast to
--   LabelAccessible, for instance with toLabelAccessible.
class (GObject o, IsDescendantOf LabelAccessible o) => IsLabelAccessible o

-- | Memory-managed wrapper type.
newtype LabelAccessible
LabelAccessible :: ManagedPtr LabelAccessible -> LabelAccessible

-- | Cast to LabelAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toLabelAccessible :: (MonadIO m, IsLabelAccessible o) => o -> m LabelAccessible

-- | Type class for types which can be safely cast to
--   ImageAccessible, for instance with toImageAccessible.
class (GObject o, IsDescendantOf ImageAccessible o) => IsImageAccessible o

-- | Memory-managed wrapper type.
newtype ImageAccessible
ImageAccessible :: ManagedPtr ImageAccessible -> ImageAccessible

-- | Cast to ImageAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toImageAccessible :: (MonadIO m, IsImageAccessible o) => o -> m ImageAccessible

-- | Type class for types which can be safely cast to
--   EntryAccessible, for instance with toEntryAccessible.
class (GObject o, IsDescendantOf EntryAccessible o) => IsEntryAccessible o

-- | Memory-managed wrapper type.
newtype EntryAccessible
EntryAccessible :: ManagedPtr EntryAccessible -> EntryAccessible

-- | Cast to EntryAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toEntryAccessible :: (MonadIO m, IsEntryAccessible o) => o -> m EntryAccessible

-- | Type class for types which can be safely cast to
--   SpinButtonAccessible, for instance with
--   toSpinButtonAccessible.
class (GObject o, IsDescendantOf SpinButtonAccessible o) => IsSpinButtonAccessible o

-- | Memory-managed wrapper type.
newtype SpinButtonAccessible
SpinButtonAccessible :: ManagedPtr SpinButtonAccessible -> SpinButtonAccessible

-- | Cast to SpinButtonAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toSpinButtonAccessible :: (MonadIO m, IsSpinButtonAccessible o) => o -> m SpinButtonAccessible

-- | Type class for types which can be safely cast to
--   ContainerAccessible, for instance with
--   toContainerAccessible.
class (GObject o, IsDescendantOf ContainerAccessible o) => IsContainerAccessible o

-- | Memory-managed wrapper type.
newtype ContainerAccessible
ContainerAccessible :: ManagedPtr ContainerAccessible -> ContainerAccessible

-- | Cast to ContainerAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toContainerAccessible :: (MonadIO m, IsContainerAccessible o) => o -> m ContainerAccessible

-- | Type class for types which can be safely cast to
--   WindowAccessible, for instance with toWindowAccessible.
class (GObject o, IsDescendantOf WindowAccessible o) => IsWindowAccessible o

-- | Memory-managed wrapper type.
newtype WindowAccessible
WindowAccessible :: ManagedPtr WindowAccessible -> WindowAccessible

-- | Cast to WindowAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toWindowAccessible :: (MonadIO m, IsWindowAccessible o) => o -> m WindowAccessible

-- | Type class for types which can be safely cast to
--   TextViewAccessible, for instance with
--   toTextViewAccessible.
class (GObject o, IsDescendantOf TextViewAccessible o) => IsTextViewAccessible o

-- | Memory-managed wrapper type.
newtype TextViewAccessible
TextViewAccessible :: ManagedPtr TextViewAccessible -> TextViewAccessible

-- | Cast to TextViewAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toTextViewAccessible :: (MonadIO m, IsTextViewAccessible o) => o -> m TextViewAccessible

-- | Type class for types which can be safely cast to
--   StatusbarAccessible, for instance with
--   toStatusbarAccessible.
class (GObject o, IsDescendantOf StatusbarAccessible o) => IsStatusbarAccessible o

-- | Memory-managed wrapper type.
newtype StatusbarAccessible
StatusbarAccessible :: ManagedPtr StatusbarAccessible -> StatusbarAccessible

-- | Cast to StatusbarAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toStatusbarAccessible :: (MonadIO m, IsStatusbarAccessible o) => o -> m StatusbarAccessible

-- | Type class for types which can be safely cast to
--   StackAccessible, for instance with toStackAccessible.
class (GObject o, IsDescendantOf StackAccessible o) => IsStackAccessible o

-- | Memory-managed wrapper type.
newtype StackAccessible
StackAccessible :: ManagedPtr StackAccessible -> StackAccessible

-- | Cast to StackAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toStackAccessible :: (MonadIO m, IsStackAccessible o) => o -> m StackAccessible

-- | Type class for types which can be safely cast to
--   SocketAccessible, for instance with toSocketAccessible.
class (GObject o, IsDescendantOf SocketAccessible o) => IsSocketAccessible o

-- | Memory-managed wrapper type.
newtype SocketAccessible
SocketAccessible :: ManagedPtr SocketAccessible -> SocketAccessible

-- | Cast to SocketAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toSocketAccessible :: (MonadIO m, IsSocketAccessible o) => o -> m SocketAccessible

-- | No description available in the introspection data.
socketAccessibleEmbed :: (HasCallStack, MonadIO m, IsSocketAccessible a) => a -> Text -> m ()

-- | Type class for types which can be safely cast to
--   ScrolledWindowAccessible, for instance with
--   toScrolledWindowAccessible.
class (GObject o, IsDescendantOf ScrolledWindowAccessible o) => IsScrolledWindowAccessible o

-- | Memory-managed wrapper type.
newtype ScrolledWindowAccessible
ScrolledWindowAccessible :: ManagedPtr ScrolledWindowAccessible -> ScrolledWindowAccessible

-- | Cast to ScrolledWindowAccessible, for types for which this is
--   known to be safe. For general casts, use castTo.
toScrolledWindowAccessible :: (MonadIO m, IsScrolledWindowAccessible o) => o -> m ScrolledWindowAccessible

-- | Type class for types which can be safely cast to
--   PopoverAccessible, for instance with
--   toPopoverAccessible.
class (GObject o, IsDescendantOf PopoverAccessible o) => IsPopoverAccessible o

-- | Memory-managed wrapper type.
newtype PopoverAccessible
PopoverAccessible :: ManagedPtr PopoverAccessible -> PopoverAccessible

-- | Cast to PopoverAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toPopoverAccessible :: (MonadIO m, IsPopoverAccessible o) => o -> m PopoverAccessible

-- | Type class for types which can be safely cast to
--   PlugAccessible, for instance with toPlugAccessible.
class (GObject o, IsDescendantOf PlugAccessible o) => IsPlugAccessible o

-- | Memory-managed wrapper type.
newtype PlugAccessible
PlugAccessible :: ManagedPtr PlugAccessible -> PlugAccessible

-- | Cast to PlugAccessible, for types for which this is known to be
--   safe. For general casts, use castTo.
toPlugAccessible :: (MonadIO m, IsPlugAccessible o) => o -> m PlugAccessible

-- | No description available in the introspection data.
plugAccessibleGetId :: (HasCallStack, MonadIO m, IsPlugAccessible a) => a -> m Text

-- | Type class for types which can be safely cast to
--   PanedAccessible, for instance with toPanedAccessible.
class (GObject o, IsDescendantOf PanedAccessible o) => IsPanedAccessible o

-- | Memory-managed wrapper type.
newtype PanedAccessible
PanedAccessible :: ManagedPtr PanedAccessible -> PanedAccessible

-- | Cast to PanedAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toPanedAccessible :: (MonadIO m, IsPanedAccessible o) => o -> m PanedAccessible

-- | Type class for types which can be safely cast to
--   NotebookAccessible, for instance with
--   toNotebookAccessible.
class (GObject o, IsDescendantOf NotebookAccessible o) => IsNotebookAccessible o

-- | Memory-managed wrapper type.
newtype NotebookAccessible
NotebookAccessible :: ManagedPtr NotebookAccessible -> NotebookAccessible

-- | Cast to NotebookAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toNotebookAccessible :: (MonadIO m, IsNotebookAccessible o) => o -> m NotebookAccessible

-- | Type class for types which can be safely cast to
--   NotebookPageAccessible, for instance with
--   toNotebookPageAccessible.
class (GObject o, IsDescendantOf NotebookPageAccessible o) => IsNotebookPageAccessible o

-- | Memory-managed wrapper type.
newtype NotebookPageAccessible
NotebookPageAccessible :: ManagedPtr NotebookPageAccessible -> NotebookPageAccessible

-- | Cast to NotebookPageAccessible, for types for which this is
--   known to be safe. For general casts, use castTo.
toNotebookPageAccessible :: (MonadIO m, IsNotebookPageAccessible o) => o -> m NotebookPageAccessible

-- | No description available in the introspection data.
notebookPageAccessibleNew :: (HasCallStack, MonadIO m, IsNotebookAccessible a, IsWidget b) => a -> b -> m NotebookPageAccessible

-- | No description available in the introspection data.
notebookPageAccessibleInvalidate :: (HasCallStack, MonadIO m, IsNotebookPageAccessible a) => a -> m ()

-- | Type class for types which can be safely cast to
--   MenuShellAccessible, for instance with
--   toMenuShellAccessible.
class (GObject o, IsDescendantOf MenuShellAccessible o) => IsMenuShellAccessible o

-- | Memory-managed wrapper type.
newtype MenuShellAccessible
MenuShellAccessible :: ManagedPtr MenuShellAccessible -> MenuShellAccessible

-- | Cast to MenuShellAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toMenuShellAccessible :: (MonadIO m, IsMenuShellAccessible o) => o -> m MenuShellAccessible

-- | Type class for types which can be safely cast to
--   MenuItemAccessible, for instance with
--   toMenuItemAccessible.
class (GObject o, IsDescendantOf MenuItemAccessible o) => IsMenuItemAccessible o

-- | Memory-managed wrapper type.
newtype MenuItemAccessible
MenuItemAccessible :: ManagedPtr MenuItemAccessible -> MenuItemAccessible

-- | Cast to MenuItemAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toMenuItemAccessible :: (MonadIO m, IsMenuItemAccessible o) => o -> m MenuItemAccessible

-- | Type class for types which can be safely cast to
--   MenuAccessible, for instance with toMenuAccessible.
class (GObject o, IsDescendantOf MenuAccessible o) => IsMenuAccessible o

-- | Memory-managed wrapper type.
newtype MenuAccessible
MenuAccessible :: ManagedPtr MenuAccessible -> MenuAccessible

-- | Cast to MenuAccessible, for types for which this is known to be
--   safe. For general casts, use castTo.
toMenuAccessible :: (MonadIO m, IsMenuAccessible o) => o -> m MenuAccessible

-- | Type class for types which can be safely cast to
--   ListBoxRowAccessible, for instance with
--   toListBoxRowAccessible.
class (GObject o, IsDescendantOf ListBoxRowAccessible o) => IsListBoxRowAccessible o

-- | Memory-managed wrapper type.
newtype ListBoxRowAccessible
ListBoxRowAccessible :: ManagedPtr ListBoxRowAccessible -> ListBoxRowAccessible

-- | Cast to ListBoxRowAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toListBoxRowAccessible :: (MonadIO m, IsListBoxRowAccessible o) => o -> m ListBoxRowAccessible

-- | Type class for types which can be safely cast to
--   ListBoxAccessible, for instance with
--   toListBoxAccessible.
class (GObject o, IsDescendantOf ListBoxAccessible o) => IsListBoxAccessible o

-- | Memory-managed wrapper type.
newtype ListBoxAccessible
ListBoxAccessible :: ManagedPtr ListBoxAccessible -> ListBoxAccessible

-- | Cast to ListBoxAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toListBoxAccessible :: (MonadIO m, IsListBoxAccessible o) => o -> m ListBoxAccessible

-- | Type class for types which can be safely cast to
--   IconViewAccessible, for instance with
--   toIconViewAccessible.
class (GObject o, IsDescendantOf IconViewAccessible o) => IsIconViewAccessible o

-- | Memory-managed wrapper type.
newtype IconViewAccessible
IconViewAccessible :: ManagedPtr IconViewAccessible -> IconViewAccessible

-- | Cast to IconViewAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toIconViewAccessible :: (MonadIO m, IsIconViewAccessible o) => o -> m IconViewAccessible

-- | Type class for types which can be safely cast to
--   HeaderBarAccessible, for instance with
--   toHeaderBarAccessible.
class (GObject o, IsDescendantOf HeaderBarAccessible o) => IsHeaderBarAccessible o

-- | Memory-managed wrapper type.
newtype HeaderBarAccessible
HeaderBarAccessible :: ManagedPtr HeaderBarAccessible -> HeaderBarAccessible

-- | Cast to HeaderBarAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toHeaderBarAccessible :: (MonadIO m, IsHeaderBarAccessible o) => o -> m HeaderBarAccessible

-- | Type class for types which can be safely cast to
--   FrameAccessible, for instance with toFrameAccessible.
class (GObject o, IsDescendantOf FrameAccessible o) => IsFrameAccessible o

-- | Memory-managed wrapper type.
newtype FrameAccessible
FrameAccessible :: ManagedPtr FrameAccessible -> FrameAccessible

-- | Cast to FrameAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toFrameAccessible :: (MonadIO m, IsFrameAccessible o) => o -> m FrameAccessible

-- | Type class for types which can be safely cast to
--   FlowBoxChildAccessible, for instance with
--   toFlowBoxChildAccessible.
class (GObject o, IsDescendantOf FlowBoxChildAccessible o) => IsFlowBoxChildAccessible o

-- | Memory-managed wrapper type.
newtype FlowBoxChildAccessible
FlowBoxChildAccessible :: ManagedPtr FlowBoxChildAccessible -> FlowBoxChildAccessible

-- | Cast to FlowBoxChildAccessible, for types for which this is
--   known to be safe. For general casts, use castTo.
toFlowBoxChildAccessible :: (MonadIO m, IsFlowBoxChildAccessible o) => o -> m FlowBoxChildAccessible

-- | Type class for types which can be safely cast to
--   FlowBoxAccessible, for instance with
--   toFlowBoxAccessible.
class (GObject o, IsDescendantOf FlowBoxAccessible o) => IsFlowBoxAccessible o

-- | Memory-managed wrapper type.
newtype FlowBoxAccessible
FlowBoxAccessible :: ManagedPtr FlowBoxAccessible -> FlowBoxAccessible

-- | Cast to FlowBoxAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toFlowBoxAccessible :: (MonadIO m, IsFlowBoxAccessible o) => o -> m FlowBoxAccessible

-- | Type class for types which can be safely cast to
--   FileChooserWidgetAccessible, for instance with
--   toFileChooserWidgetAccessible.
class (GObject o, IsDescendantOf FileChooserWidgetAccessible o) => IsFileChooserWidgetAccessible o

-- | Memory-managed wrapper type.
newtype FileChooserWidgetAccessible
FileChooserWidgetAccessible :: ManagedPtr FileChooserWidgetAccessible -> FileChooserWidgetAccessible

-- | Cast to FileChooserWidgetAccessible, for types for which this
--   is known to be safe. For general casts, use castTo.
toFileChooserWidgetAccessible :: (MonadIO m, IsFileChooserWidgetAccessible o) => o -> m FileChooserWidgetAccessible

-- | Type class for types which can be safely cast to
--   ExpanderAccessible, for instance with
--   toExpanderAccessible.
class (GObject o, IsDescendantOf ExpanderAccessible o) => IsExpanderAccessible o

-- | Memory-managed wrapper type.
newtype ExpanderAccessible
ExpanderAccessible :: ManagedPtr ExpanderAccessible -> ExpanderAccessible

-- | Cast to ExpanderAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toExpanderAccessible :: (MonadIO m, IsExpanderAccessible o) => o -> m ExpanderAccessible

-- | Type class for types which can be safely cast to
--   ComboBoxAccessible, for instance with
--   toComboBoxAccessible.
class (GObject o, IsDescendantOf ComboBoxAccessible o) => IsComboBoxAccessible o

-- | Memory-managed wrapper type.
newtype ComboBoxAccessible
ComboBoxAccessible :: ManagedPtr ComboBoxAccessible -> ComboBoxAccessible

-- | Cast to ComboBoxAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toComboBoxAccessible :: (MonadIO m, IsComboBoxAccessible o) => o -> m ComboBoxAccessible

-- | Type class for types which can be safely cast to
--   CheckMenuItemAccessible, for instance with
--   toCheckMenuItemAccessible.
class (GObject o, IsDescendantOf CheckMenuItemAccessible o) => IsCheckMenuItemAccessible o

-- | Memory-managed wrapper type.
newtype CheckMenuItemAccessible
CheckMenuItemAccessible :: ManagedPtr CheckMenuItemAccessible -> CheckMenuItemAccessible

-- | Cast to CheckMenuItemAccessible, for types for which this is
--   known to be safe. For general casts, use castTo.
toCheckMenuItemAccessible :: (MonadIO m, IsCheckMenuItemAccessible o) => o -> m CheckMenuItemAccessible

-- | Type class for types which can be safely cast to
--   RadioMenuItemAccessible, for instance with
--   toRadioMenuItemAccessible.
class (GObject o, IsDescendantOf RadioMenuItemAccessible o) => IsRadioMenuItemAccessible o

-- | Memory-managed wrapper type.
newtype RadioMenuItemAccessible
RadioMenuItemAccessible :: ManagedPtr RadioMenuItemAccessible -> RadioMenuItemAccessible

-- | Cast to RadioMenuItemAccessible, for types for which this is
--   known to be safe. For general casts, use castTo.
toRadioMenuItemAccessible :: (MonadIO m, IsRadioMenuItemAccessible o) => o -> m RadioMenuItemAccessible

-- | Type class for types which can be safely cast to
--   CellAccessible, for instance with toCellAccessible.
class (GObject o, IsDescendantOf CellAccessible o) => IsCellAccessible o

-- | Memory-managed wrapper type.
newtype CellAccessible
CellAccessible :: ManagedPtr CellAccessible -> CellAccessible

-- | Cast to CellAccessible, for types for which this is known to be
--   safe. For general casts, use castTo.
toCellAccessible :: (MonadIO m, IsCellAccessible o) => o -> m CellAccessible

-- | Type class for types which can be safely cast to
--   ContainerCellAccessible, for instance with
--   toContainerCellAccessible.
class (GObject o, IsDescendantOf ContainerCellAccessible o) => IsContainerCellAccessible o

-- | Memory-managed wrapper type.
newtype ContainerCellAccessible
ContainerCellAccessible :: ManagedPtr ContainerCellAccessible -> ContainerCellAccessible

-- | Cast to ContainerCellAccessible, for types for which this is
--   known to be safe. For general casts, use castTo.
toContainerCellAccessible :: (MonadIO m, IsContainerCellAccessible o) => o -> m ContainerCellAccessible

-- | No description available in the introspection data.
containerCellAccessibleNew :: (HasCallStack, MonadIO m) => m ContainerCellAccessible

-- | No description available in the introspection data.
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]

-- | No description available in the introspection data.
containerCellAccessibleRemoveChild :: (HasCallStack, MonadIO m, IsContainerCellAccessible a, IsCellAccessible b) => a -> b -> m ()

-- | Type class for types which can be safely cast to
--   ButtonAccessible, for instance with toButtonAccessible.
class (GObject o, IsDescendantOf ButtonAccessible o) => IsButtonAccessible o

-- | Memory-managed wrapper type.
newtype ButtonAccessible
ButtonAccessible :: ManagedPtr ButtonAccessible -> ButtonAccessible

-- | Cast to ButtonAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toButtonAccessible :: (MonadIO m, IsButtonAccessible o) => o -> m ButtonAccessible

-- | Type class for types which can be safely cast to
--   ToggleButtonAccessible, for instance with
--   toToggleButtonAccessible.
class (GObject o, IsDescendantOf ToggleButtonAccessible o) => IsToggleButtonAccessible o

-- | Memory-managed wrapper type.
newtype ToggleButtonAccessible
ToggleButtonAccessible :: ManagedPtr ToggleButtonAccessible -> ToggleButtonAccessible

-- | Cast to ToggleButtonAccessible, for types for which this is
--   known to be safe. For general casts, use castTo.
toToggleButtonAccessible :: (MonadIO m, IsToggleButtonAccessible o) => o -> m ToggleButtonAccessible

-- | Type class for types which can be safely cast to
--   ScaleButtonAccessible, for instance with
--   toScaleButtonAccessible.
class (GObject o, IsDescendantOf ScaleButtonAccessible o) => IsScaleButtonAccessible o

-- | Memory-managed wrapper type.
newtype ScaleButtonAccessible
ScaleButtonAccessible :: ManagedPtr ScaleButtonAccessible -> ScaleButtonAccessible

-- | Cast to ScaleButtonAccessible, for types for which this is
--   known to be safe. For general casts, use castTo.
toScaleButtonAccessible :: (MonadIO m, IsScaleButtonAccessible o) => o -> m ScaleButtonAccessible

-- | Type class for types which can be safely cast to
--   RadioButtonAccessible, for instance with
--   toRadioButtonAccessible.
class (GObject o, IsDescendantOf RadioButtonAccessible o) => IsRadioButtonAccessible o

-- | Memory-managed wrapper type.
newtype RadioButtonAccessible
RadioButtonAccessible :: ManagedPtr RadioButtonAccessible -> RadioButtonAccessible

-- | Cast to RadioButtonAccessible, for types for which this is
--   known to be safe. For general casts, use castTo.
toRadioButtonAccessible :: (MonadIO m, IsRadioButtonAccessible o) => o -> m RadioButtonAccessible

-- | Type class for types which can be safely cast to
--   MenuButtonAccessible, for instance with
--   toMenuButtonAccessible.
class (GObject o, IsDescendantOf MenuButtonAccessible o) => IsMenuButtonAccessible o

-- | Memory-managed wrapper type.
newtype MenuButtonAccessible
MenuButtonAccessible :: ManagedPtr MenuButtonAccessible -> MenuButtonAccessible

-- | Cast to MenuButtonAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toMenuButtonAccessible :: (MonadIO m, IsMenuButtonAccessible o) => o -> m MenuButtonAccessible

-- | Type class for types which can be safely cast to
--   LockButtonAccessible, for instance with
--   toLockButtonAccessible.
class (GObject o, IsDescendantOf LockButtonAccessible o) => IsLockButtonAccessible o

-- | Memory-managed wrapper type.
newtype LockButtonAccessible
LockButtonAccessible :: ManagedPtr LockButtonAccessible -> LockButtonAccessible

-- | Cast to LockButtonAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toLockButtonAccessible :: (MonadIO m, IsLockButtonAccessible o) => o -> m LockButtonAccessible

-- | Type class for types which can be safely cast to
--   LinkButtonAccessible, for instance with
--   toLinkButtonAccessible.
class (GObject o, IsDescendantOf LinkButtonAccessible o) => IsLinkButtonAccessible o

-- | Memory-managed wrapper type.
newtype LinkButtonAccessible
LinkButtonAccessible :: ManagedPtr LinkButtonAccessible -> LinkButtonAccessible

-- | Cast to LinkButtonAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toLinkButtonAccessible :: (MonadIO m, IsLinkButtonAccessible o) => o -> m LinkButtonAccessible

-- | Type class for types which can be safely cast to
--   ArrowAccessible, for instance with toArrowAccessible.
class (GObject o, IsDescendantOf ArrowAccessible o) => IsArrowAccessible o

-- | Memory-managed wrapper type.
newtype ArrowAccessible
ArrowAccessible :: ManagedPtr ArrowAccessible -> ArrowAccessible

-- | Cast to ArrowAccessible, for types for which this is known to
--   be safe. For general casts, use castTo.
toArrowAccessible :: (MonadIO m, IsArrowAccessible o) => o -> m ArrowAccessible

-- | Type class for types which can be safely cast to AboutDialog,
--   for instance with toAboutDialog.
class (GObject o, IsDescendantOf AboutDialog o) => IsAboutDialog o

-- | Cast to AboutDialog, for types for which this is known to be
--   safe. For general casts, use castTo.
toAboutDialog :: (MonadIO m, IsAboutDialog o) => o -> m AboutDialog

-- | The signal which gets emitted to activate a URI. Applications may
--   connect to it to override the default behaviour, which is to call
--   showUriOnWindow.
--   
--   Since: 2.24
type AboutDialogActivateLinkCallback = Text -> IO Bool

-- | Connect a signal handler for the activateLink signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on aboutDialog #activateLink callback
--   
onAboutDialogActivateLink :: (IsAboutDialog a, MonadIO m) => a -> ((?self :: a) => AboutDialogActivateLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activateLink signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after aboutDialog #activateLink callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAboutDialogActivateLink :: (IsAboutDialog a, MonadIO m) => a -> ((?self :: a) => AboutDialogActivateLinkCallback) -> m SignalHandlerId

-- | Get the value of the “artists” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aboutDialog #artists
--   
getAboutDialogArtists :: (MonadIO m, IsAboutDialog o) => o -> m [Text]

-- | Set the value of the “artists” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #artists := value ]
--   
setAboutDialogArtists :: (MonadIO m, IsAboutDialog o) => o -> [Text] -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “artists” property. This is rarely needed directly, but it is
--   used by new.
constructAboutDialogArtists :: (IsAboutDialog o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “authors” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aboutDialog #authors
--   
getAboutDialogAuthors :: (MonadIO m, IsAboutDialog o) => o -> m [Text]

-- | Set the value of the “authors” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #authors := value ]
--   
setAboutDialogAuthors :: (MonadIO m, IsAboutDialog o) => o -> [Text] -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “authors” property. This is rarely needed directly, but it is
--   used by new.
constructAboutDialogAuthors :: (IsAboutDialog o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “comments” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aboutDialog #comments
--   
getAboutDialogComments :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “comments” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #comments := value ]
--   
setAboutDialogComments :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “comments” property. This is rarely needed directly, but it
--   is used by new.
constructAboutDialogComments :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “comments” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #comments
--   
clearAboutDialogComments :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “copyright” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aboutDialog #copyright
--   
getAboutDialogCopyright :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “copyright” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #copyright := value ]
--   
setAboutDialogCopyright :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “copyright” property. This is rarely needed directly, but it
--   is used by new.
constructAboutDialogCopyright :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “copyright” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #copyright
--   
clearAboutDialogCopyright :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “documenters” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aboutDialog #documenters
--   
getAboutDialogDocumenters :: (MonadIO m, IsAboutDialog o) => o -> m [Text]

-- | Set the value of the “documenters” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #documenters := value ]
--   
setAboutDialogDocumenters :: (MonadIO m, IsAboutDialog o) => o -> [Text] -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “documenters” property. This is rarely needed directly, but
--   it is used by new.
constructAboutDialogDocumenters :: (IsAboutDialog o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “license” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aboutDialog #license
--   
getAboutDialogLicense :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “license” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #license := value ]
--   
setAboutDialogLicense :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “license” property. This is rarely needed directly, but it is
--   used by new.
constructAboutDialogLicense :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “license” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #license
--   
clearAboutDialogLicense :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “license-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aboutDialog #licenseType
--   
getAboutDialogLicenseType :: (MonadIO m, IsAboutDialog o) => o -> m License

-- | Set the value of the “license-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #licenseType := value ]
--   
setAboutDialogLicenseType :: (MonadIO m, IsAboutDialog o) => o -> License -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “license-type” property. This is rarely needed directly, but
--   it is used by new.
constructAboutDialogLicenseType :: (IsAboutDialog o, MonadIO m) => License -> m (GValueConstruct o)

-- | Get the value of the “logo” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get aboutDialog #logo
--   
getAboutDialogLogo :: (MonadIO m, IsAboutDialog o) => o -> m Pixbuf

-- | Set the value of the “logo” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #logo := value ]
--   
setAboutDialogLogo :: (MonadIO m, IsAboutDialog o, IsPixbuf a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “logo” property. This is rarely needed directly, but it is
--   used by new.
constructAboutDialogLogo :: (IsAboutDialog o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “logo” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #logo
--   
clearAboutDialogLogo :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “logo-icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aboutDialog #logoIconName
--   
getAboutDialogLogoIconName :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “logo-icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #logoIconName := value ]
--   
setAboutDialogLogoIconName :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “logo-icon-name” property. This is rarely needed directly,
--   but it is used by new.
constructAboutDialogLogoIconName :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “logo-icon-name” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #logoIconName
--   
clearAboutDialogLogoIconName :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “program-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aboutDialog #programName
--   
getAboutDialogProgramName :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “program-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #programName := value ]
--   
setAboutDialogProgramName :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “program-name” property. This is rarely needed directly, but
--   it is used by new.
constructAboutDialogProgramName :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “translator-credits” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aboutDialog #translatorCredits
--   
getAboutDialogTranslatorCredits :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “translator-credits” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #translatorCredits := value ]
--   
setAboutDialogTranslatorCredits :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “translator-credits” property. This is rarely needed
--   directly, but it is used by new.
constructAboutDialogTranslatorCredits :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “translator-credits” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #translatorCredits
--   
clearAboutDialogTranslatorCredits :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “version” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aboutDialog #version
--   
getAboutDialogVersion :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “version” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #version := value ]
--   
setAboutDialogVersion :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “version” property. This is rarely needed directly, but it is
--   used by new.
constructAboutDialogVersion :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “version” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #version
--   
clearAboutDialogVersion :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “website” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aboutDialog #website
--   
getAboutDialogWebsite :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “website” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #website := value ]
--   
setAboutDialogWebsite :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “website” property. This is rarely needed directly, but it is
--   used by new.
constructAboutDialogWebsite :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “website” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #website
--   
clearAboutDialogWebsite :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “website-label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aboutDialog #websiteLabel
--   
getAboutDialogWebsiteLabel :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “website-label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #websiteLabel := value ]
--   
setAboutDialogWebsiteLabel :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “website-label” property. This is rarely needed directly, but
--   it is used by new.
constructAboutDialogWebsiteLabel :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “wrap-license” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get aboutDialog #wrapLicense
--   
getAboutDialogWrapLicense :: (MonadIO m, IsAboutDialog o) => o -> m Bool

-- | Set the value of the “wrap-license” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set aboutDialog [ #wrapLicense := value ]
--   
setAboutDialogWrapLicense :: (MonadIO m, IsAboutDialog o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “wrap-license” property. This is rarely needed directly, but
--   it is used by new.
constructAboutDialogWrapLicense :: (IsAboutDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new AboutDialog.
--   
--   Since: 2.6
aboutDialogNew :: (HasCallStack, MonadIO m) => m AboutDialog

-- | Creates a new section in the Credits page.
--   
--   Since: 3.4
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.
--   
--   Since: 2.6
aboutDialogGetArtists :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m [Text]

-- | Returns the string which are displayed in the authors tab of the
--   secondary credits dialog.
--   
--   Since: 2.6
aboutDialogGetAuthors :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m [Text]

-- | Returns the comments string.
--   
--   Since: 2.6
aboutDialogGetComments :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns the copyright string.
--   
--   Since: 2.6
aboutDialogGetCopyright :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns the string which are displayed in the documenters tab of the
--   secondary credits dialog.
--   
--   Since: 2.6
aboutDialogGetDocumenters :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m [Text]

-- | Returns the license information.
--   
--   Since: 2.6
aboutDialogGetLicense :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Retrieves the license set using aboutDialogSetLicenseType
--   
--   Since: 3.0
aboutDialogGetLicenseType :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m License

-- | Returns the pixbuf displayed as logo in the about dialog.
--   
--   Since: 2.6
aboutDialogGetLogo :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Pixbuf

-- | Returns the icon name displayed as logo in the about dialog.
--   
--   Since: 2.6
aboutDialogGetLogoIconName :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns the program name displayed in the about dialog.
--   
--   Since: 2.12
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.
--   
--   Since: 2.6
aboutDialogGetTranslatorCredits :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns the version string.
--   
--   Since: 2.6
aboutDialogGetVersion :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns the website URL.
--   
--   Since: 2.6
aboutDialogGetWebsite :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns the label used for the website link.
--   
--   Since: 2.6
aboutDialogGetWebsiteLabel :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns whether the license text in about is
--   automatically wrapped.
--   
--   Since: 2.8
aboutDialogGetWrapLicense :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Bool

-- | Sets the strings which are displayed in the artists tab of the
--   secondary credits dialog.
--   
--   Since: 2.6
aboutDialogSetArtists :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> [Text] -> m ()

-- | Sets the strings which are displayed in the authors tab of the
--   secondary credits dialog.
--   
--   Since: 2.6
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.
--   
--   Since: 2.6
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.
--   
--   Since: 2.6
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.
--   
--   Since: 2.6
aboutDialogSetDocumenters :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> [Text] -> m ()

-- | Sets the pixbuf to be displayed as logo in the about dialog. If it is
--   Nothing, the default window icon set with
--   windowSetDefaultIcon will be used.
--   
--   Since: 2.6
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
--   Nothing, the default window icon set with
--   windowSetDefaultIcon will be used.
--   
--   Since: 2.6
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 getApplicationName.
--   
--   Since: 2.12
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
--   gettext(), a simple way to achieve that is to mark the
--   string for translation:
--   
--   
C code
--   
--   
--   GtkWidget *about = gtk_about_dialog_new ();
--   gtk_about_dialog_set_translator_credits (GTK_ABOUT_DIALOG (about),
--                                            _("translator-credits"));
--   
--   
--   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 AboutDialog will detect if
--   “translator-credits” is untranslated and hide the tab.
--   
--   Since: 2.6
aboutDialogSetTranslatorCredits :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the version string to display in the about dialog.
--   
--   Since: 2.6
aboutDialogSetVersion :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the URL to use for the website link.
--   
--   Since: 2.6
aboutDialogSetWebsite :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the label to be used for the website link.
--   
--   Since: 2.6
aboutDialogSetWebsiteLabel :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Text -> m ()

-- | Sets whether the license text in about is
--   automatically wrapped.
--   
--   Since: 2.8
aboutDialogSetWrapLicense :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Bool -> m ()

-- | Type class for types which implement TreeDragSource.
class (ManagedPtrNewtype o, IsDescendantOf TreeDragSource o) => IsTreeDragSource o

-- | Asks the TreeDragSource to delete the row at
--   path, because it was moved somewhere else via
--   drag-and-drop. Returns False if the deletion fails because
--   path no longer exists, or for some model-specific
--   reason. Should robustly handle a path no longer found
--   in the model!
treeDragSourceDragDataDelete :: (HasCallStack, MonadIO m, IsTreeDragSource a) => a -> TreePath -> m Bool

-- | Asks the TreeDragSource to fill in
--   selectionData with a representation of the row at
--   path. selectionData->target gives
--   the required type of the data. Should robustly handle a
--   path no longer found in the model!
treeDragSourceDragDataGet :: (HasCallStack, MonadIO m, IsTreeDragSource a) => a -> TreePath -> SelectionData -> m Bool

-- | Asks the TreeDragSource 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

-- | Type class for types which can be safely cast to TreeModelSort,
--   for instance with toTreeModelSort.
class (GObject o, IsDescendantOf TreeModelSort o) => IsTreeModelSort o

-- | Cast to TreeModelSort, for types for which this is known to be
--   safe. For general casts, use castTo.
toTreeModelSort :: (MonadIO m, IsTreeModelSort o) => o -> m TreeModelSort

-- | Get the value of the “model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeModelSort #model
--   
getTreeModelSortModel :: (MonadIO m, IsTreeModelSort o) => o -> m TreeModel

-- | Construct a GValueConstruct with valid value for the
--   “model” property. This is rarely needed directly, but it is
--   used by new.
constructTreeModelSortModel :: (IsTreeModelSort o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Creates a new TreeModelSort, with childModel as
--   the child model.
treeModelSortNewWithModel :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m TreeModelSort

-- | This function should almost never be called. It clears the
--   treeModelSort of any cached iterators that haven’t
--   been reffed with treeModelRefNode. 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 sortIter to point to the row in
--   treeModelSort that corresponds to the row pointed at
--   by childIter. If sortIter was not set,
--   False is returned. Note: a boolean is only returned since 2.14.
treeModelSortConvertChildIterToIter :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreeIter -> m (Bool, TreeIter)

-- | Converts childPath to a path relative to
--   treeModelSort. That is, childPath
--   points to a path in the child model. The returned path will point to
--   the same row in the sorted model. If childPath isn’t a
--   valid path on the child model, then Nothing is returned.
treeModelSortConvertChildPathToPath :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreePath -> m (Maybe TreePath)

-- | Sets childIter to point to the row pointed to by
--   sortedIter.
treeModelSortConvertIterToChildIter :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreeIter -> m TreeIter

-- | Converts sortedPath to a path on the child model of
--   treeModelSort. That is, sortedPath
--   points to a location in treeModelSort. The returned
--   path will point to the same location in the model not being sorted. If
--   sortedPath does not point to a location in the child
--   model, Nothing is returned.
treeModelSortConvertPathToChildPath :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreePath -> m (Maybe TreePath)

-- | Returns the model the TreeModelSort is sorting.
treeModelSortGetModel :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> m TreeModel

-- | 
--   This function is slow. Only use it for debugging and\/or testing
--   purposes.
--   
--   
--   Checks if the given iter is a valid iter for this
--   TreeModelSort.
--   
--   Since: 2.2
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
--   TreeModelSort is in “unsorted” state.
treeModelSortResetDefaultSortFunc :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> m ()

-- | Type class for types which can be safely cast to
--   TreeModelFilter, for instance with toTreeModelFilter.
class (GObject o, IsDescendantOf TreeModelFilter o) => IsTreeModelFilter o

-- | Cast to TreeModelFilter, for types for which this is known to
--   be safe. For general casts, use castTo.
toTreeModelFilter :: (MonadIO m, IsTreeModelFilter o) => o -> m TreeModelFilter

-- | Get the value of the “child-model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeModelFilter #childModel
--   
getTreeModelFilterChildModel :: (MonadIO m, IsTreeModelFilter o) => o -> m (Maybe TreeModel)

-- | Construct a GValueConstruct with valid value for the
--   “child-model” property. This is rarely needed directly, but
--   it is used by new.
constructTreeModelFilterChildModel :: (IsTreeModelFilter o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “virtual-root” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get treeModelFilter #virtualRoot
--   
getTreeModelFilterVirtualRoot :: (MonadIO m, IsTreeModelFilter o) => o -> m (Maybe TreePath)

-- | Construct a GValueConstruct with valid value for the
--   “virtual-root” property. This is rarely needed directly, but
--   it is used by new.
constructTreeModelFilterVirtualRoot :: (IsTreeModelFilter o, MonadIO m) => TreePath -> m (GValueConstruct o)

-- | This function should almost never be called. It clears the
--   filter of any cached iterators that haven’t been
--   reffed with treeModelRefNode. 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.
--   
--   Since: 2.4
treeModelFilterClearCache :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> m ()

-- | Sets filterIter to point to the row in
--   filter that corresponds to the row pointed at by
--   childIter. If filterIter was not set,
--   False is returned.
--   
--   Since: 2.4
treeModelFilterConvertChildIterToIter :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreeIter -> m (Bool, TreeIter)

-- | Converts childPath to a path relative to
--   filter. That is, childPath points to a
--   path in the child model. The rerturned path will point to the same row
--   in the filtered model. If childPath isn’t a valid path
--   on the child model or points to a row which is not visible in
--   filter, then Nothing is returned.
--   
--   Since: 2.4
treeModelFilterConvertChildPathToPath :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreePath -> m (Maybe TreePath)

-- | Sets childIter to point to the row pointed to by
--   filterIter.
--   
--   Since: 2.4
treeModelFilterConvertIterToChildIter :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreeIter -> m TreeIter

-- | Converts filterPath to a path on the child model of
--   filter. That is, filterPath points to
--   a location in filter. The returned path will point to
--   the same location in the model not being filtered. If
--   filterPath does not point to a location in the child
--   model, Nothing is returned.
--   
--   Since: 2.4
treeModelFilterConvertPathToChildPath :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreePath -> m (Maybe TreePath)

-- | Returns a pointer to the child model of filter.
--   
--   Since: 2.4
treeModelFilterGetModel :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> m TreeModel

-- | Type class for types which implement TreeDragDest.
class (ManagedPtrNewtype o, IsDescendantOf TreeDragDest o) => IsTreeDragDest o

-- | Asks the TreeDragDest to insert a row before the path
--   dest, deriving the contents of the row from
--   selectionData. If dest is outside the
--   tree so that inserting before it is impossible, False will be
--   returned. Also, False may be returned if the new row is not
--   created for some model-specific reason. Should robustly handle a
--   dest 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
--   destPath, at the same depth as
--   destPath. i.e., can we drop the data in
--   selectionData at that location.
--   destPath does not have to exist; the return value will
--   almost certainly be False if the parent of
--   destPath doesn’t exist, though.
treeDragDestRowDropPossible :: (HasCallStack, MonadIO m, IsTreeDragDest a) => a -> TreePath -> SelectionData -> m Bool

-- | Type class for types which can be safely cast to TreeStore, for
--   instance with toTreeStore.
class (GObject o, IsDescendantOf TreeStore o) => IsTreeStore o

-- | Cast to TreeStore, for types for which this is known to be
--   safe. For general casts, use castTo.
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 treeStore. If
--   parent is non-Nothing, then it will append the
--   new row after the last child of parent, otherwise it
--   will append a row to the top level. iter 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
--   gtk_tree_store_set() or treeStoreSetValue.
treeStoreAppend :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> m TreeIter

-- | Removes all rows from treeStore
treeStoreClear :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> m ()

-- | Creates a new row at position. If parent is
--   non-Nothing, then the row will be made a child of
--   parent. Otherwise, the row will be created at the
--   toplevel. If position 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. iter 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 gtk_tree_store_set() or
--   treeStoreSetValue.
treeStoreInsert :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Int32 -> m TreeIter

-- | Inserts a new row after sibling. If
--   sibling is Nothing, then the row will be
--   prepended to parent ’s children. If
--   parent and sibling are Nothing,
--   then the row will be prepended to the toplevel. If both
--   sibling and parent are set, then
--   parent must be the parent of sibling.
--   When sibling is set, parent is
--   optional.
--   
--   iter 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 gtk_tree_store_set() or
--   treeStoreSetValue.
treeStoreInsertAfter :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Maybe TreeIter -> m TreeIter

-- | Inserts a new row before sibling. If
--   sibling is Nothing, then the row will be
--   appended to parent ’s children. If
--   parent and sibling are Nothing,
--   then the row will be appended to the toplevel. If both
--   sibling and parent are set, then
--   parent must be the parent of sibling.
--   When sibling is set, parent is
--   optional.
--   
--   iter 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 gtk_tree_store_set() or
--   treeStoreSetValue.
treeStoreInsertBefore :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Maybe TreeIter -> m TreeIter

-- | A variant of gtk_tree_store_insert_with_values() which
--   takes the columns and values as two arrays, instead of varargs. This
--   function is mainly intended for language bindings.
--   
--   Since: 2.10
treeStoreInsertWithValues :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Int32 -> [Int32] -> [GValue] -> m TreeIter

-- | Returns True if iter is an ancestor of
--   descendant. That is, iter is the
--   parent (or grandparent or great-grandparent) of
--   descendant.
treeStoreIsAncestor :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> TreeIter -> m Bool

-- | Returns the depth of iter. 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 TreeStore.
--   
--   Since: 2.2
treeStoreIterIsValid :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> m Bool

-- | Moves iter in treeStore to the
--   position after position. iter and
--   position should be in the same level. Note that this
--   function only works with unsorted stores. If position
--   is Nothing, iter will be moved to the start of
--   the level.
--   
--   Since: 2.2
treeStoreMoveAfter :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

-- | Moves iter in treeStore to the
--   position before position. iter and
--   position should be in the same level. Note that this
--   function only works with unsorted stores. If position
--   is Nothing, iter will be moved to the end of
--   the level.
--   
--   Since: 2.2
treeStoreMoveBefore :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

-- | Prepends a new row to treeStore. If
--   parent is non-Nothing, then it will prepend the
--   new row before the first child of parent, otherwise it
--   will prepend a row to the top level. iter 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
--   gtk_tree_store_set() or treeStoreSetValue.
treeStorePrepend :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> m TreeIter

-- | Removes iter from treeStore. After
--   being removed, iter 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 GObjects that
--   inherit from TreeStore, and should only be used when
--   constructing a new TreeStore. It will not function after a row
--   has been added, or a method on the TreeModel interface is
--   called.
treeStoreSetColumnTypes :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> [GType] -> m ()

-- | A variant of gtk_tree_store_set_valist() 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.
--   
--   Since: 2.12
treeStoreSet :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> [Int32] -> [GValue] -> m ()

-- | Swaps a and b in the same level of
--   treeStore. Note that this function only works with
--   unsorted stores.
--   
--   Since: 2.2
treeStoreSwap :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> TreeIter -> m ()

-- | Type class for types which can be safely cast to ListStore, for
--   instance with toListStore.
class (GObject o, IsDescendantOf ListStore o) => IsListStore o

-- | Cast to ListStore, for types for which this is known to be
--   safe. For general casts, use castTo.
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 listStore. iter
--   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
--   gtk_list_store_set() or listStoreSetValue.
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 position. iter
--   will be changed to point to this new row. If position
--   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
--   gtk_list_store_set() or listStoreSetValue.
listStoreInsert :: (HasCallStack, MonadIO m, IsListStore a) => a -> Int32 -> m TreeIter

-- | Inserts a new row after sibling. If
--   sibling is Nothing, then the row will be
--   prepended to the beginning of the list. iter 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
--   gtk_list_store_set() or listStoreSetValue.
listStoreInsertAfter :: (HasCallStack, MonadIO m, IsListStore a) => a -> Maybe TreeIter -> m TreeIter

-- | Inserts a new row before sibling. If
--   sibling is Nothing, then the row will be
--   appended to the end of the list. iter 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
--   gtk_list_store_set() or listStoreSetValue.
listStoreInsertBefore :: (HasCallStack, MonadIO m, IsListStore a) => a -> Maybe TreeIter -> m TreeIter

-- | A variant of gtk_list_store_insert_with_values() which
--   takes the columns and values as two arrays, instead of varargs. This
--   function is mainly intended for language-bindings.
--   
--   Since: 2.6
listStoreInsertWithValuesv :: (HasCallStack, MonadIO m, IsListStore a) => a -> Int32 -> [Int32] -> [GValue] -> m TreeIter

-- | 
--   This function is slow. Only use it for debugging and\/or testing
--   purposes.
--   
--   
--   Checks if the given iter is a valid iter for this ListStore.
--   
--   Since: 2.2
listStoreIterIsValid :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> m Bool

-- | Moves iter in store to the position
--   after position. Note that this function only works
--   with unsorted stores. If position is Nothing,
--   iter will be moved to the start of the list.
--   
--   Since: 2.2
listStoreMoveAfter :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

-- | Moves iter in store to the position
--   before position. Note that this function only works
--   with unsorted stores. If position is Nothing,
--   iter will be moved to the end of the list.
--   
--   Since: 2.2
listStoreMoveBefore :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

-- | Prepends a new row to listStore. iter
--   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
--   gtk_list_store_set() or listStoreSetValue.
listStorePrepend :: (HasCallStack, MonadIO m, IsListStore a) => a -> m TreeIter

-- | Removes the given row from the list store. After being removed,
--   iter is set to be the next valid row, or invalidated
--   if it pointed to the last row in listStore.
listStoreRemove :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> m Bool

-- | Reorders store to follow the order indicated by
--   newOrder. Note that this function only works with
--   unsorted stores.
--   
--   Since: 2.2
listStoreReorder :: (HasCallStack, MonadIO m, IsListStore a) => a -> [Int32] -> m ()

-- | This function is meant primarily for GObjects that
--   inherit from ListStore, and should only be used when
--   constructing a new ListStore. It will not function after a row
--   has been added, or a method on the TreeModel interface is
--   called.
listStoreSetColumnTypes :: (HasCallStack, MonadIO m, IsListStore a) => a -> [GType] -> m ()

-- | A variant of gtk_list_store_set_valist() 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.
--   
--   Since: 2.12
listStoreSet :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> [Int32] -> [GValue] -> m ()

-- | Swaps a and b in
--   store. Note that this function only works with
--   unsorted stores.
--   
--   Since: 2.2
listStoreSwap :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> TreeIter -> m ()

-- | Type class for types which can be safely cast to ToolShell, for
--   instance with toToolShell.
class (GObject o, IsDescendantOf ToolShell o) => IsToolShell o

-- | Cast to ToolShell, for types for which this is known to be
--   safe. For general casts, use castTo.
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
--   toolItemGetEllipsizeMode instead.
--   
--   Since: 2.20
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
--   toolItemGetTextAlignment instead.
--   
--   Since: 2.20
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
--   toolItemGetTextOrientation instead.
--   
--   Since: 2.20
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
--   toolItemGetTextSizeGroup instead.
--   
--   Since: 2.20
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
--   toolItemRebuildMenu instead.
--   
--   Since: 2.14
toolShellRebuildMenu :: (HasCallStack, MonadIO m, IsToolShell a) => a -> m ()

-- | Type class for types which can be safely cast to RecentChooser,
--   for instance with toRecentChooser.
class (GObject o, IsDescendantOf RecentChooser o) => IsRecentChooser o

-- | Cast to RecentChooser, for types for which this is known to be
--   safe. For general casts, use castTo.
toRecentChooser :: (MonadIO m, IsRecentChooser o) => o -> m RecentChooser

-- | 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.
--   
--   Since: 2.10
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 Enter.
--   
--   Since: 2.10
type RecentChooserItemActivatedCallback = IO ()

-- | Get the value of the “filter” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentChooser #filter
--   
getRecentChooserFilter :: (MonadIO m, IsRecentChooser o) => o -> m RecentFilter

-- | Set the value of the “filter” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentChooser [ #filter := value ]
--   
setRecentChooserFilter :: (MonadIO m, IsRecentChooser o, IsRecentFilter a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “filter” property. This is rarely needed directly, but it is
--   used by new.
constructRecentChooserFilter :: (IsRecentChooser o, MonadIO m, IsRecentFilter a) => a -> m (GValueConstruct o)

-- | Set the value of the “filter” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #filter
--   
clearRecentChooserFilter :: (MonadIO m, IsRecentChooser o) => o -> m ()

-- | Get the value of the “limit” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentChooser #limit
--   
getRecentChooserLimit :: (MonadIO m, IsRecentChooser o) => o -> m Int32

-- | Set the value of the “limit” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentChooser [ #limit := value ]
--   
setRecentChooserLimit :: (MonadIO m, IsRecentChooser o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “limit” property. This is rarely needed directly, but it is
--   used by new.
constructRecentChooserLimit :: (IsRecentChooser o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “local-only” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentChooser #localOnly
--   
getRecentChooserLocalOnly :: (MonadIO m, IsRecentChooser o) => o -> m Bool

-- | Set the value of the “local-only” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentChooser [ #localOnly := value ]
--   
setRecentChooserLocalOnly :: (MonadIO m, IsRecentChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “local-only” property. This is rarely needed directly, but it
--   is used by new.
constructRecentChooserLocalOnly :: (IsRecentChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Construct a GValueConstruct with valid value for the
--   “recent-manager” property. This is rarely needed directly,
--   but it is used by new.
constructRecentChooserRecentManager :: (IsRecentChooser o, MonadIO m, IsRecentManager a) => a -> m (GValueConstruct o)

-- | Get the value of the “select-multiple” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentChooser #selectMultiple
--   
getRecentChooserSelectMultiple :: (MonadIO m, IsRecentChooser o) => o -> m Bool

-- | Set the value of the “select-multiple” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentChooser [ #selectMultiple := value ]
--   
setRecentChooserSelectMultiple :: (MonadIO m, IsRecentChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “select-multiple” property. This is rarely needed directly,
--   but it is used by new.
constructRecentChooserSelectMultiple :: (IsRecentChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-icons” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentChooser #showIcons
--   
getRecentChooserShowIcons :: (MonadIO m, IsRecentChooser o) => o -> m Bool

-- | Set the value of the “show-icons” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentChooser [ #showIcons := value ]
--   
setRecentChooserShowIcons :: (MonadIO m, IsRecentChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-icons” property. This is rarely needed directly, but it
--   is used by new.
constructRecentChooserShowIcons :: (IsRecentChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-not-found” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentChooser #showNotFound
--   
getRecentChooserShowNotFound :: (MonadIO m, IsRecentChooser o) => o -> m Bool

-- | Set the value of the “show-not-found” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentChooser [ #showNotFound := value ]
--   
setRecentChooserShowNotFound :: (MonadIO m, IsRecentChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-not-found” property. This is rarely needed directly,
--   but it is used by new.
constructRecentChooserShowNotFound :: (IsRecentChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-private” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentChooser #showPrivate
--   
getRecentChooserShowPrivate :: (MonadIO m, IsRecentChooser o) => o -> m Bool

-- | Set the value of the “show-private” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentChooser [ #showPrivate := value ]
--   
setRecentChooserShowPrivate :: (MonadIO m, IsRecentChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-private” property. This is rarely needed directly, but
--   it is used by new.
constructRecentChooserShowPrivate :: (IsRecentChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-tips” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentChooser #showTips
--   
getRecentChooserShowTips :: (MonadIO m, IsRecentChooser o) => o -> m Bool

-- | Set the value of the “show-tips” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentChooser [ #showTips := value ]
--   
setRecentChooserShowTips :: (MonadIO m, IsRecentChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-tips” property. This is rarely needed directly, but it
--   is used by new.
constructRecentChooserShowTips :: (IsRecentChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “sort-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentChooser #sortType
--   
getRecentChooserSortType :: (MonadIO m, IsRecentChooser o) => o -> m RecentSortType

-- | Set the value of the “sort-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentChooser [ #sortType := value ]
--   
setRecentChooserSortType :: (MonadIO m, IsRecentChooser o) => o -> RecentSortType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “sort-type” property. This is rarely needed directly, but it
--   is used by new.
constructRecentChooserSortType :: (IsRecentChooser o, MonadIO m) => RecentSortType -> m (GValueConstruct o)

-- | Adds filter to the list of RecentFilter objects
--   held by chooser.
--   
--   If no previous filter objects were defined, this function will call
--   recentChooserSetFilter.
--   
--   Since: 2.10
recentChooserAddFilter :: (HasCallStack, MonadIO m, IsRecentChooser a, IsRecentFilter b) => a -> b -> m ()

-- | Gets the RecentInfo currently selected by
--   chooser.
--   
--   Since: 2.10
recentChooserGetCurrentItem :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m RecentInfo

-- | Gets the URI currently selected by chooser.
--   
--   Since: 2.10
recentChooserGetCurrentUri :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Text

-- | Gets the RecentFilter object currently used by
--   chooser to affect the display of the recently used
--   resources.
--   
--   Since: 2.10
recentChooserGetFilter :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m RecentFilter

-- | Gets the number of items returned by recentChooserGetItems and
--   recentChooserGetUris.
--   
--   Since: 2.10
recentChooserGetLimit :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Int32

-- | Gets whether only local resources should be shown in the recently used
--   resources selector. See recentChooserSetLocalOnly
--   
--   Since: 2.10
recentChooserGetLocalOnly :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Bool

-- | Gets whether chooser can select multiple items.
--   
--   Since: 2.10
recentChooserGetSelectMultiple :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Bool

-- | Retrieves whether chooser should show an icon near the
--   resource.
--   
--   Since: 2.10
recentChooserGetShowIcons :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Bool

-- | Retrieves whether chooser should show the recently
--   used resources that were not found.
--   
--   Since: 2.10
recentChooserGetShowNotFound :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Bool

-- | Returns whether chooser should display recently used
--   resources registered as private.
--   
--   Since: 2.10
recentChooserGetShowPrivate :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Bool

-- | Gets whether chooser should display tooltips
--   containing the full path of a recently user resource.
--   
--   Since: 2.10
recentChooserGetShowTips :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Bool

-- | Gets the value set by recentChooserSetSortType.
--   
--   Since: 2.10
recentChooserGetSortType :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m RecentSortType

-- | Gets the RecentFilter objects held by chooser.
--   
--   Since: 2.10
recentChooserListFilters :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m [RecentFilter]

-- | Removes filter from the list of RecentFilter
--   objects held by chooser.
--   
--   Since: 2.10
recentChooserRemoveFilter :: (HasCallStack, MonadIO m, IsRecentChooser a, IsRecentFilter b) => a -> b -> m ()

-- | Selects all the items inside chooser, if the
--   chooser supports multiple selection.
--   
--   Since: 2.10
recentChooserSelectAll :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m ()

-- | Selects uri inside chooser.
--   
--   Since: 2.10
recentChooserSelectUri :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Text -> m ()

-- | Sets uri as the current URI for
--   chooser.
--   
--   Since: 2.10
recentChooserSetCurrentUri :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Text -> m ()

-- | Sets the number of items that should be returned by
--   recentChooserGetItems and recentChooserGetUris.
--   
--   Since: 2.10
recentChooserSetLimit :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Int32 -> m ()

-- | Sets whether chooser can select multiple items.
--   
--   Since: 2.10
recentChooserSetSelectMultiple :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Bool -> m ()

-- | Sets whether chooser should show an icon near the
--   resource when displaying it.
--   
--   Since: 2.10
recentChooserSetShowIcons :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Bool -> m ()

-- | Sets whether chooser should display the recently used
--   resources that it didn’t find. This only applies to local resources.
--   
--   Since: 2.10
recentChooserSetShowNotFound :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Bool -> m ()

-- | Whether to show recently used resources marked registered as private.
--   
--   Since: 2.10
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 RecentChooser widget.
--   
--   Since: 2.10
recentChooserSetShowTips :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Bool -> m ()

-- | Unselects all the items inside chooser.
--   
--   Since: 2.10
recentChooserUnselectAll :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m ()

-- | Unselects uri inside chooser.
--   
--   Since: 2.10
recentChooserUnselectUri :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Text -> m ()

-- | Connect a signal handler for the itemActivated signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on recentChooser #itemActivated callback
--   
onRecentChooserItemActivated :: (IsRecentChooser a, MonadIO m) => a -> ((?self :: a) => RecentChooserItemActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the itemActivated signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after recentChooser #itemActivated callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterRecentChooserItemActivated :: (IsRecentChooser a, MonadIO m) => a -> ((?self :: a) => RecentChooserItemActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on recentChooser #selectionChanged callback
--   
onRecentChooserSelectionChanged :: (IsRecentChooser a, MonadIO m) => a -> ((?self :: a) => RecentChooserSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after recentChooser #selectionChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterRecentChooserSelectionChanged :: (IsRecentChooser a, MonadIO m) => a -> ((?self :: a) => RecentChooserSelectionChangedCallback) -> m SignalHandlerId

-- | Type class for types which can be safely cast to
--   RecentChooserWidget, for instance with
--   toRecentChooserWidget.
class (GObject o, IsDescendantOf RecentChooserWidget o) => IsRecentChooserWidget o

-- | Cast to RecentChooserWidget, for types for which this is known
--   to be safe. For general casts, use castTo.
toRecentChooserWidget :: (MonadIO m, IsRecentChooserWidget o) => o -> m RecentChooserWidget

-- | Creates a new RecentChooserWidget object. This is an embeddable
--   widget used to access the recently used resources list.
--   
--   Since: 2.10
recentChooserWidgetNew :: (HasCallStack, MonadIO m) => m RecentChooserWidget

-- | Creates a new RecentChooserWidget 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 RecentManager object.
--   
--   Since: 2.10
recentChooserWidgetNewForManager :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> m RecentChooserWidget

-- | Type class for types which can be safely cast to
--   RecentChooserDialog, for instance with
--   toRecentChooserDialog.
class (GObject o, IsDescendantOf RecentChooserDialog o) => IsRecentChooserDialog o

-- | Memory-managed wrapper type.
newtype RecentChooserDialog
RecentChooserDialog :: ManagedPtr RecentChooserDialog -> RecentChooserDialog

-- | Cast to RecentChooserDialog, for types for which this is known
--   to be safe. For general casts, use castTo.
toRecentChooserDialog :: (MonadIO m, IsRecentChooserDialog o) => o -> m RecentChooserDialog

-- | Type class for types which can be safely cast to RecentAction,
--   for instance with toRecentAction.
class (GObject o, IsDescendantOf RecentAction o) => IsRecentAction o

-- | Cast to RecentAction, for types for which this is known to be
--   safe. For general casts, use castTo.
toRecentAction :: (MonadIO m, IsRecentAction o) => o -> m RecentAction

-- | Get the value of the “show-numbers” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentAction #showNumbers
--   
getRecentActionShowNumbers :: (MonadIO m, IsRecentAction o) => o -> m Bool

-- | Set the value of the “show-numbers” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentAction [ #showNumbers := value ]
--   
setRecentActionShowNumbers :: (MonadIO m, IsRecentAction o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-numbers” property. This is rarely needed directly, but
--   it is used by new.
constructRecentActionShowNumbers :: (IsRecentAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new RecentAction object. To add the action to a
--   ActionGroup and set the accelerator for the action, call
--   actionGroupAddActionWithAccel.
--   
--   Since: 2.12
recentActionNew :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> m RecentAction

-- | Creates a new RecentAction object. To add the action to a
--   ActionGroup and set the accelerator for the action, call
--   actionGroupAddActionWithAccel.
--   
--   Since: 2.12
recentActionNewForManager :: (HasCallStack, MonadIO m, IsRecentManager a) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> Maybe a -> m RecentAction

-- | Returns the value set by recentChooserMenuSetShowNumbers.
--   
--   Since: 2.12
recentActionGetShowNumbers :: (HasCallStack, MonadIO m, IsRecentAction a) => a -> m Bool

-- | Sets whether a number should be added to the items shown by the
--   widgets representing action. 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.
--   
--   Since: 2.12
recentActionSetShowNumbers :: (HasCallStack, MonadIO m, IsRecentAction a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to FileChooser,
--   for instance with toFileChooser.
class (GObject o, IsDescendantOf FileChooser o) => IsFileChooser o

-- | Cast to FileChooser, for types for which this is known to be
--   safe. For general casts, use castTo.
toFileChooser :: (MonadIO m, IsFileChooser o) => o -> m FileChooser

-- | 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
--   fileChooserSetPreviewWidget, you should update it when this
--   signal is emitted. You can use the functions
--   fileChooserGetPreviewFilename or
--   fileChooserGetPreviewUri 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 fileChooserSetPreviewWidgetActive 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: fileChooserSetPreviewWidget,
--   fileChooserSetPreviewWidgetActive,
--   fileChooserSetUsePreviewLabel,
--   fileChooserGetPreviewFilename, fileChooserGetPreviewUri.
type FileChooserUpdatePreviewCallback = IO ()

-- | This signal is emitted when there is a change in the set of selected
--   files in a FileChooser. 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: fileChooserSelectFilename,
--   fileChooserUnselectFilename, fileChooserGetFilename,
--   fileChooserGetFilenames, fileChooserSelectUri,
--   fileChooserUnselectUri, fileChooserGetUri,
--   fileChooserGetUris.
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 Enter.
--   
--   Normally you do not need to connect to this signal. It is used
--   internally by FileChooserDialog to know when to activate the
--   default button in the dialog.
--   
--   See also: fileChooserGetFilename,
--   fileChooserGetFilenames, fileChooserGetUri,
--   fileChooserGetUris.
type FileChooserFileActivatedCallback = IO ()

-- | This signal is emitted when the current folder in a FileChooser
--   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: fileChooserSetCurrentFolder,
--   fileChooserGetCurrentFolder,
--   fileChooserSetCurrentFolderUri,
--   fileChooserGetCurrentFolderUri.
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 FileChooserActionSave mode.
--   
--   Most applications just need to turn on the
--   FileChooser:doOverwriteConfirmation property (or call the
--   fileChooserSetDoOverwriteConfirmation 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
--   FileChooser::confirmOverwrite signal.
--   
--   A signal handler for this signal must return a
--   FileChooserConfirmation value, which indicates the action to
--   take. If the handler determines that the user wants to select a
--   different filename, it should return
--   FileChooserConfirmationSelectAgain. If it determines that the
--   user is satisfied with his choice of file name, it should return
--   FileChooserConfirmationAcceptFilename. On the other hand, if it
--   determines that the stock confirmation dialog should be used, it
--   should return FileChooserConfirmationConfirm. The following
--   example illustrates this.
--   
--   ## Custom confirmation ##
--   {gtkfilechooser-confirmation}
--   
--   
C code
--   
--   
--   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);
--   
--   
--   Since: 2.8
type FileChooserConfirmOverwriteCallback = IO FileChooserConfirmation

-- | Get the value of the “action” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooser #action
--   
getFileChooserAction :: (MonadIO m, IsFileChooser o) => o -> m FileChooserAction

-- | Set the value of the “action” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooser [ #action := value ]
--   
setFileChooserAction :: (MonadIO m, IsFileChooser o) => o -> FileChooserAction -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “action” property. This is rarely needed directly, but it is
--   used by new.
constructFileChooserAction :: (IsFileChooser o, MonadIO m) => FileChooserAction -> m (GValueConstruct o)

-- | Get the value of the “create-folders” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooser #createFolders
--   
getFileChooserCreateFolders :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “create-folders” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooser [ #createFolders := value ]
--   
setFileChooserCreateFolders :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “create-folders” property. This is rarely needed directly,
--   but it is used by new.
constructFileChooserCreateFolders :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “do-overwrite-confirmation” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   get fileChooser #doOverwriteConfirmation
--   
getFileChooserDoOverwriteConfirmation :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “do-overwrite-confirmation” property.
--   When overloading is enabled, this is equivalent to
--   
--   
--   set fileChooser [ #doOverwriteConfirmation := value ]
--   
setFileChooserDoOverwriteConfirmation :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “do-overwrite-confirmation” property. This is rarely needed
--   directly, but it is used by new.
constructFileChooserDoOverwriteConfirmation :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “extra-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooser #extraWidget
--   
getFileChooserExtraWidget :: (MonadIO m, IsFileChooser o) => o -> m (Maybe Widget)

-- | Set the value of the “extra-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooser [ #extraWidget := value ]
--   
setFileChooserExtraWidget :: (MonadIO m, IsFileChooser o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “extra-widget” property. This is rarely needed directly, but
--   it is used by new.
constructFileChooserExtraWidget :: (IsFileChooser o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “filter” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooser #filter
--   
getFileChooserFilter :: (MonadIO m, IsFileChooser o) => o -> m (Maybe FileFilter)

-- | Set the value of the “filter” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooser [ #filter := value ]
--   
setFileChooserFilter :: (MonadIO m, IsFileChooser o, IsFileFilter a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “filter” property. This is rarely needed directly, but it is
--   used by new.
constructFileChooserFilter :: (IsFileChooser o, MonadIO m, IsFileFilter a) => a -> m (GValueConstruct o)

-- | Get the value of the “local-only” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooser #localOnly
--   
getFileChooserLocalOnly :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “local-only” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooser [ #localOnly := value ]
--   
setFileChooserLocalOnly :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “local-only” property. This is rarely needed directly, but it
--   is used by new.
constructFileChooserLocalOnly :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “preview-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooser #previewWidget
--   
getFileChooserPreviewWidget :: (MonadIO m, IsFileChooser o) => o -> m (Maybe Widget)

-- | Set the value of the “preview-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooser [ #previewWidget := value ]
--   
setFileChooserPreviewWidget :: (MonadIO m, IsFileChooser o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “preview-widget” property. This is rarely needed directly,
--   but it is used by new.
constructFileChooserPreviewWidget :: (IsFileChooser o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “preview-widget-active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooser #previewWidgetActive
--   
getFileChooserPreviewWidgetActive :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “preview-widget-active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooser [ #previewWidgetActive := value ]
--   
setFileChooserPreviewWidgetActive :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “preview-widget-active” property. This is rarely needed
--   directly, but it is used by new.
constructFileChooserPreviewWidgetActive :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “select-multiple” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooser #selectMultiple
--   
getFileChooserSelectMultiple :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “select-multiple” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooser [ #selectMultiple := value ]
--   
setFileChooserSelectMultiple :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “select-multiple” property. This is rarely needed directly,
--   but it is used by new.
constructFileChooserSelectMultiple :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-hidden” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooser #showHidden
--   
getFileChooserShowHidden :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “show-hidden” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooser [ #showHidden := value ]
--   
setFileChooserShowHidden :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-hidden” property. This is rarely needed directly, but
--   it is used by new.
constructFileChooserShowHidden :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “use-preview-label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooser #usePreviewLabel
--   
getFileChooserUsePreviewLabel :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “use-preview-label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooser [ #usePreviewLabel := value ]
--   
setFileChooserUsePreviewLabel :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-preview-label” property. This is rarely needed directly,
--   but it is used by new.
constructFileChooserUsePreviewLabel :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Gets the type of operation that the file chooser is performing; see
--   fileChooserSetAction.
--   
--   Since: 2.4
fileChooserGetAction :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m FileChooserAction

-- | Gets whether file choser will offer to create new folders. See
--   fileChooserSetCreateFolders.
--   
--   Since: 2.18
fileChooserGetCreateFolders :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Gets the current folder of chooser as File. See
--   fileChooserGetCurrentFolderUri.
--   
--   Since: 2.14
fileChooserGetCurrentFolderFile :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe File)

-- | 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”.
--   
--   Since: 3.10
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.
--   
--   Since: 2.8
fileChooserGetDoOverwriteConfirmation :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Gets the current extra widget; see fileChooserSetExtraWidget.
--   
--   Since: 2.4
fileChooserGetExtraWidget :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe Widget)

-- | Gets the File 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.
--   
--   Since: 2.14
fileChooserGetFile :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m File

-- | Lists all the selected files and subfolders in the current folder of
--   chooser as File. An internal function, see
--   fileChooserGetUris.
--   
--   Since: 2.14
fileChooserGetFiles :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m [File]

-- | Gets the current filter; see fileChooserSetFilter.
--   
--   Since: 2.4
fileChooserGetFilter :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe FileFilter)

-- | Gets whether only local files can be selected in the file selector.
--   See fileChooserSetLocalOnly
--   
--   Since: 2.4
fileChooserGetLocalOnly :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Gets the File that should be previewed in a custom preview
--   Internal function, see fileChooserGetPreviewUri.
--   
--   Since: 2.14
fileChooserGetPreviewFile :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe File)

-- | Gets the current preview widget; see
--   fileChooserSetPreviewWidget.
--   
--   Since: 2.4
fileChooserGetPreviewWidget :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe Widget)

-- | Gets whether the preview widget set by
--   fileChooserSetPreviewWidget should be shown for the current
--   filename. See fileChooserSetPreviewWidgetActive.
--   
--   Since: 2.4
fileChooserGetPreviewWidgetActive :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Gets whether multiple files can be selected in the file selector. See
--   fileChooserSetSelectMultiple.
--   
--   Since: 2.4
fileChooserGetSelectMultiple :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Gets whether hidden files and folders are displayed in the file
--   selector. See fileChooserSetShowHidden.
--   
--   Since: 2.6
fileChooserGetShowHidden :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Gets whether a stock label should be drawn with the name of the
--   previewed file. See fileChooserSetUsePreviewLabel.
fileChooserGetUsePreviewLabel :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Lists the current set of user-selectable filters; see
--   fileChooserAddFilter, fileChooserRemoveFilter.
--   
--   Since: 2.4
fileChooserListFilters :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m [FileFilter]

-- | Queries the list of shortcut folders in the file chooser, as set by
--   fileChooserAddShortcutFolderUri.
--   
--   Since: 2.4
fileChooserListShortcutFolderUris :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m [Text]

-- | Queries the list of shortcut folders in the file chooser, as set by
--   fileChooserAddShortcutFolder.
--   
--   Since: 2.4
fileChooserListShortcutFolders :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m [[Char]]

-- | Removes a 'choice' that has been added with
--   fileChooserAddChoice.
--   
--   Since: 3.22
fileChooserRemoveChoice :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m ()

-- | Removes a folder from a file chooser’s list of shortcut folders.
--   
--   Since: 2.4
fileChooserRemoveShortcutFolder :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> [Char] -> m ()

-- | Removes a folder URI from a file chooser’s list of shortcut folders.
--   
--   Since: 2.4
fileChooserRemoveShortcutFolderUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m ()

-- | Selects all the files in the current folder of a file chooser.
--   
--   Since: 2.4
fileChooserSelectAll :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m ()

-- | Selects the file referred to by file. An internal
--   function. See _gtk_file_chooser_select_uri().
--   
--   Since: 2.14
fileChooserSelectFile :: (HasCallStack, MonadIO m, IsFileChooser a, IsFile b) => a -> b -> m ()

-- | Sets the current folder for chooser from a
--   File. Internal function, see
--   fileChooserSetCurrentFolderUri.
--   
--   Since: 2.14
fileChooserSetCurrentFolderFile :: (HasCallStack, MonadIO m, IsFileChooser a, IsFile b) => a -> b -> m ()

-- | Sets file 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 chooser is in
--   FileChooserActionSave 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
--   chooser, then the current folder of
--   chooser will be changed to the folder containing
--   filename. This is equivalent to a sequence of
--   fileChooserUnselectAll followed by
--   fileChooserSelectFilename.
--   
--   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:
--   
--   
C code
--   
--   
--   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);
--     }
--   
--   
--   Since: 2.14
fileChooserSetFile :: (HasCallStack, MonadIO m, IsFileChooser a, IsFile b) => a -> b -> m ()

-- | Unselects the file referred to by file. If the file is
--   not in the current directory, does not exist, or is otherwise not
--   currently selected, does nothing.
--   
--   Since: 2.14
fileChooserUnselectFile :: (HasCallStack, MonadIO m, IsFileChooser a, IsFile b) => a -> b -> m ()

-- | Connect a signal handler for the confirmOverwrite signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on fileChooser #confirmOverwrite callback
--   
onFileChooserConfirmOverwrite :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserConfirmOverwriteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the confirmOverwrite signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after fileChooser #confirmOverwrite callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserConfirmOverwrite :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserConfirmOverwriteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the currentFolderChanged signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on fileChooser #currentFolderChanged callback
--   
onFileChooserCurrentFolderChanged :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserCurrentFolderChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the currentFolderChanged signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after fileChooser #currentFolderChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserCurrentFolderChanged :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserCurrentFolderChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the fileActivated signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on fileChooser #fileActivated callback
--   
onFileChooserFileActivated :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserFileActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the fileActivated signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after fileChooser #fileActivated callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserFileActivated :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserFileActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on fileChooser #selectionChanged callback
--   
onFileChooserSelectionChanged :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the selectionChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after fileChooser #selectionChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserSelectionChanged :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the updatePreview signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on fileChooser #updatePreview callback
--   
onFileChooserUpdatePreview :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserUpdatePreviewCallback) -> m SignalHandlerId

-- | Connect a signal handler for the updatePreview signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after fileChooser #updatePreview callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserUpdatePreview :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserUpdatePreviewCallback) -> m SignalHandlerId

-- | Type class for types which can be safely cast to
--   FileChooserWidget, for instance with
--   toFileChooserWidget.
class (GObject o, IsDescendantOf FileChooserWidget o) => IsFileChooserWidget o

-- | Cast to FileChooserWidget, for types for which this is known to
--   be safe. For general casts, use castTo.
toFileChooserWidget :: (MonadIO m, IsFileChooserWidget o) => o -> m FileChooserWidget

-- | The upFolder 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 Alt + Up.
type FileChooserWidgetUpFolderCallback = IO ()

-- | The showHidden 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 Control + H.
type FileChooserWidgetShowHiddenCallback = IO ()

-- | The searchShortcut 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 Alt + S.
type FileChooserWidgetSearchShortcutCallback = IO ()

-- | The recentShortcut 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 Alt + R.
type FileChooserWidgetRecentShortcutCallback = IO ()

-- | The quickBookmark 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 bookmarkIndex 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 Alt + 1, Alt +
--   2, etc. until Alt + 0. Note that in the default binding,
--   that Alt + 1 is actually defined to switch to the bookmark at
--   index 0, and so on successively; Alt + 0 is defined to switch
--   to the bookmark at index 10.
type FileChooserWidgetQuickBookmarkCallback = Int32 -> IO ()

-- | The placesShortcut 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 Alt + P.
type FileChooserWidgetPlacesShortcutCallback = IO ()

-- | The locationTogglePopup 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 Control + L.
type FileChooserWidgetLocationTogglePopupCallback = IO ()

-- | The locationPopupOnPaste 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 FileChooserWidget.
--   
--   The default binding for this signal is Control + V.
type FileChooserWidgetLocationPopupOnPasteCallback = IO ()

-- | The locationPopup 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 Control + L with a
--   path string of "" (the empty string). It is also bound
--   to / with a path string of "/" (a
--   slash): this lets you type / and immediately type a path
--   name. On Unix systems, this is bound to ~ (tilde) with a
--   path string of "~" itself for access to home
--   directories.
type FileChooserWidgetLocationPopupCallback = Text -> IO ()

-- | The homeFolder 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 Alt + Home.
type FileChooserWidgetHomeFolderCallback = IO ()

-- | The downFolder 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 Alt + Down.
type FileChooserWidgetDownFolderCallback = IO ()

-- | The desktopFolder 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 Alt + D.
type FileChooserWidgetDesktopFolderCallback = IO ()

-- | Connect a signal handler for the desktopFolder signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on fileChooserWidget #desktopFolder callback
--   
onFileChooserWidgetDesktopFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetDesktopFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the desktopFolder signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after fileChooserWidget #desktopFolder callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserWidgetDesktopFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetDesktopFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the downFolder signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on fileChooserWidget #downFolder callback
--   
onFileChooserWidgetDownFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetDownFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the downFolder signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after fileChooserWidget #downFolder callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserWidgetDownFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetDownFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the homeFolder signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on fileChooserWidget #homeFolder callback
--   
onFileChooserWidgetHomeFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetHomeFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the homeFolder signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after fileChooserWidget #homeFolder callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserWidgetHomeFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetHomeFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the locationPopup signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on fileChooserWidget #locationPopup callback
--   
onFileChooserWidgetLocationPopup :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationPopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the locationPopup signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after fileChooserWidget #locationPopup callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserWidgetLocationPopup :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationPopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the locationPopupOnPaste signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on fileChooserWidget #locationPopupOnPaste callback
--   
onFileChooserWidgetLocationPopupOnPaste :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationPopupOnPasteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the locationPopupOnPaste signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after fileChooserWidget #locationPopupOnPaste callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserWidgetLocationPopupOnPaste :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationPopupOnPasteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the locationTogglePopup signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on fileChooserWidget #locationTogglePopup callback
--   
onFileChooserWidgetLocationTogglePopup :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationTogglePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the locationTogglePopup signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after fileChooserWidget #locationTogglePopup callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserWidgetLocationTogglePopup :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationTogglePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the placesShortcut signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on fileChooserWidget #placesShortcut callback
--   
onFileChooserWidgetPlacesShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetPlacesShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the placesShortcut signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after fileChooserWidget #placesShortcut callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserWidgetPlacesShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetPlacesShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the quickBookmark signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on fileChooserWidget #quickBookmark callback
--   
onFileChooserWidgetQuickBookmark :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetQuickBookmarkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the quickBookmark signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after fileChooserWidget #quickBookmark callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserWidgetQuickBookmark :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetQuickBookmarkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the recentShortcut signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on fileChooserWidget #recentShortcut callback
--   
onFileChooserWidgetRecentShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetRecentShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the recentShortcut signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after fileChooserWidget #recentShortcut callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserWidgetRecentShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetRecentShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the searchShortcut signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on fileChooserWidget #searchShortcut callback
--   
onFileChooserWidgetSearchShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetSearchShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the searchShortcut signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after fileChooserWidget #searchShortcut callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserWidgetSearchShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetSearchShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showHidden signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on fileChooserWidget #showHidden callback
--   
onFileChooserWidgetShowHidden :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetShowHiddenCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showHidden signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after fileChooserWidget #showHidden callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserWidgetShowHidden :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetShowHiddenCallback) -> m SignalHandlerId

-- | Connect a signal handler for the upFolder signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on fileChooserWidget #upFolder callback
--   
onFileChooserWidgetUpFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetUpFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the upFolder signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after fileChooserWidget #upFolder callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserWidgetUpFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetUpFolderCallback) -> m SignalHandlerId

-- | Get the value of the “search-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooserWidget #searchMode
--   
getFileChooserWidgetSearchMode :: (MonadIO m, IsFileChooserWidget o) => o -> m Bool

-- | Set the value of the “search-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooserWidget [ #searchMode := value ]
--   
setFileChooserWidgetSearchMode :: (MonadIO m, IsFileChooserWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “search-mode” property. This is rarely needed directly, but
--   it is used by new.
constructFileChooserWidgetSearchMode :: (IsFileChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “subtitle” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooserWidget #subtitle
--   
getFileChooserWidgetSubtitle :: (MonadIO m, IsFileChooserWidget o) => o -> m (Maybe Text)

-- | Creates a new FileChooserWidget. This is a file chooser widget
--   that can be embedded in custom windows, and it is the same widget that
--   is used by FileChooserDialog.
--   
--   Since: 2.4
fileChooserWidgetNew :: (HasCallStack, MonadIO m) => FileChooserAction -> m FileChooserWidget

-- | Type class for types which can be safely cast to
--   FileChooserNative, for instance with
--   toFileChooserNative.
class (GObject o, IsDescendantOf FileChooserNative o) => IsFileChooserNative o

-- | Cast to FileChooserNative, for types for which this is known to
--   be safe. For general casts, use castTo.
toFileChooserNative :: (MonadIO m, IsFileChooserNative o) => o -> m FileChooserNative

-- | Get the value of the “accept-label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooserNative #acceptLabel
--   
getFileChooserNativeAcceptLabel :: (MonadIO m, IsFileChooserNative o) => o -> m (Maybe Text)

-- | Set the value of the “accept-label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooserNative [ #acceptLabel := value ]
--   
setFileChooserNativeAcceptLabel :: (MonadIO m, IsFileChooserNative o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accept-label” property. This is rarely needed directly, but
--   it is used by new.
constructFileChooserNativeAcceptLabel :: (IsFileChooserNative o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “accept-label” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #acceptLabel
--   
clearFileChooserNativeAcceptLabel :: (MonadIO m, IsFileChooserNative o) => o -> m ()

-- | Get the value of the “cancel-label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooserNative #cancelLabel
--   
getFileChooserNativeCancelLabel :: (MonadIO m, IsFileChooserNative o) => o -> m (Maybe Text)

-- | Set the value of the “cancel-label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooserNative [ #cancelLabel := value ]
--   
setFileChooserNativeCancelLabel :: (MonadIO m, IsFileChooserNative o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “cancel-label” property. This is rarely needed directly, but
--   it is used by new.
constructFileChooserNativeCancelLabel :: (IsFileChooserNative o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “cancel-label” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #cancelLabel
--   
clearFileChooserNativeCancelLabel :: (MonadIO m, IsFileChooserNative o) => o -> m ()

-- | Creates a new FileChooserNative.
--   
--   Since: 3.20
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.
--   
--   Since: 3.20
fileChooserNativeGetAcceptLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> m (Maybe Text)

-- | Retrieves the custom label text for the cancel button.
--   
--   Since: 3.20
fileChooserNativeGetCancelLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> m (Maybe Text)

-- | Sets the custom label text for the accept button.
--   
--   If characters in label 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.
--   
--   Since: 3.20
fileChooserNativeSetAcceptLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> Maybe Text -> m ()

-- | Sets the custom label text for the cancel button.
--   
--   If characters in label 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.
--   
--   Since: 3.20
fileChooserNativeSetCancelLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> Maybe Text -> m ()

-- | Type class for types which can be safely cast to
--   FileChooserDialog, for instance with
--   toFileChooserDialog.
class (GObject o, IsDescendantOf FileChooserDialog o) => IsFileChooserDialog o

-- | Cast to FileChooserDialog, for types for which this is known to
--   be safe. For general casts, use castTo.
toFileChooserDialog :: (MonadIO m, IsFileChooserDialog o) => o -> m FileChooserDialog

-- | Type class for types which can be safely cast to
--   FileChooserButton, for instance with
--   toFileChooserButton.
class (GObject o, IsDescendantOf FileChooserButton o) => IsFileChooserButton o

-- | Cast to FileChooserButton, for types for which this is known to
--   be safe. For general casts, use castTo.
toFileChooserButton :: (MonadIO m, IsFileChooserButton o) => o -> m FileChooserButton

-- | The fileSet signal is emitted when the user selects a file.
--   
--   Note that this signal is only emitted when the user changes the file.
--   
--   Since: 2.12
type FileChooserButtonFileSetCallback = IO ()

-- | Connect a signal handler for the fileSet signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on fileChooserButton #fileSet callback
--   
onFileChooserButtonFileSet :: (IsFileChooserButton a, MonadIO m) => a -> ((?self :: a) => FileChooserButtonFileSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the fileSet signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after fileChooserButton #fileSet callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFileChooserButtonFileSet :: (IsFileChooserButton a, MonadIO m) => a -> ((?self :: a) => FileChooserButtonFileSetCallback) -> m SignalHandlerId

-- | Construct a GValueConstruct with valid value for the
--   “dialog” property. This is rarely needed directly, but it is
--   used by new.
constructFileChooserButtonDialog :: (IsFileChooserButton o, MonadIO m, IsFileChooser a) => a -> m (GValueConstruct o)

-- | Get the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooserButton #title
--   
getFileChooserButtonTitle :: (MonadIO m, IsFileChooserButton o) => o -> m Text

-- | Set the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooserButton [ #title := value ]
--   
setFileChooserButtonTitle :: (MonadIO m, IsFileChooserButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “title” property. This is rarely needed directly, but it is
--   used by new.
constructFileChooserButtonTitle :: (IsFileChooserButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fileChooserButton #widthChars
--   
getFileChooserButtonWidthChars :: (MonadIO m, IsFileChooserButton o) => o -> m Int32

-- | Set the value of the “width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fileChooserButton [ #widthChars := value ]
--   
setFileChooserButtonWidthChars :: (MonadIO m, IsFileChooserButton o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “width-chars” property. This is rarely needed directly, but
--   it is used by new.
constructFileChooserButtonWidthChars :: (IsFileChooserButton o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new file-selecting button widget.
--   
--   Since: 2.6
fileChooserButtonNew :: (HasCallStack, MonadIO m) => Text -> FileChooserAction -> m FileChooserButton

-- | Creates a FileChooserButton widget which uses
--   dialog as its file-picking window.
--   
--   Note that dialog must be a Dialog (or subclass)
--   which implements the FileChooser interface and must not have
--   DialogFlagsDestroyWithParent set.
--   
--   Also note that the dialog needs to have its confirmative button added
--   with response ResponseTypeAccept or ResponseTypeOk in
--   order for the button to take over the file selected in the dialog.
--   
--   Since: 2.6
fileChooserButtonNewWithDialog :: (HasCallStack, MonadIO m, IsDialog a) => a -> m FileChooserButton

-- | Returns whether the button grabs focus when it is clicked with the
--   mouse. See fileChooserButtonSetFocusOnClick.
--   
--   Since: 2.10
fileChooserButtonGetFocusOnClick :: (HasCallStack, MonadIO m, IsFileChooserButton a) => a -> m Bool

-- | Retrieves the title of the browse dialog used by
--   button. The returned value should not be modified or
--   freed.
--   
--   Since: 2.6
fileChooserButtonGetTitle :: (HasCallStack, MonadIO m, IsFileChooserButton a) => a -> m Text

-- | Retrieves the width in characters of the button
--   widget’s entry and/or label.
--   
--   Since: 2.6
fileChooserButtonGetWidthChars :: (HasCallStack, MonadIO m, IsFileChooserButton a) => a -> m Int32

-- | Modifies the title of the browse dialog used by
--   button.
--   
--   Since: 2.6
fileChooserButtonSetTitle :: (HasCallStack, MonadIO m, IsFileChooserButton a) => a -> Text -> m ()

-- | Sets the width (in characters) that button will use to
--   nChars.
--   
--   Since: 2.6
fileChooserButtonSetWidthChars :: (HasCallStack, MonadIO m, IsFileChooserButton a) => a -> Int32 -> m ()

-- | Type class for types which can be safely cast to
--   RendererCellAccessible, for instance with
--   toRendererCellAccessible.
class (GObject o, IsDescendantOf RendererCellAccessible o) => IsRendererCellAccessible o

-- | Memory-managed wrapper type.
newtype RendererCellAccessible
RendererCellAccessible :: ManagedPtr RendererCellAccessible -> RendererCellAccessible

-- | Cast to RendererCellAccessible, for types for which this is
--   known to be safe. For general casts, use castTo.
toRendererCellAccessible :: (MonadIO m, IsRendererCellAccessible o) => o -> m RendererCellAccessible

-- | Get the value of the “renderer” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get rendererCellAccessible #renderer
--   
getRendererCellAccessibleRenderer :: (MonadIO m, IsRendererCellAccessible o) => o -> m (Maybe CellRenderer)

-- | Construct a GValueConstruct with valid value for the
--   “renderer” property. This is rarely needed directly, but it
--   is used by new.
constructRendererCellAccessibleRenderer :: (IsRendererCellAccessible o, MonadIO m, IsCellRenderer a) => a -> m (GValueConstruct o)

-- | No description available in the introspection data.
rendererCellAccessibleNew :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m RendererCellAccessible

-- | Type class for types which can be safely cast to
--   TextCellAccessible, for instance with
--   toTextCellAccessible.
class (GObject o, IsDescendantOf TextCellAccessible o) => IsTextCellAccessible o

-- | Memory-managed wrapper type.
newtype TextCellAccessible
TextCellAccessible :: ManagedPtr TextCellAccessible -> TextCellAccessible

-- | Cast to TextCellAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toTextCellAccessible :: (MonadIO m, IsTextCellAccessible o) => o -> m TextCellAccessible

-- | Type class for types which can be safely cast to
--   ImageCellAccessible, for instance with
--   toImageCellAccessible.
class (GObject o, IsDescendantOf ImageCellAccessible o) => IsImageCellAccessible o

-- | Memory-managed wrapper type.
newtype ImageCellAccessible
ImageCellAccessible :: ManagedPtr ImageCellAccessible -> ImageCellAccessible

-- | Cast to ImageCellAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toImageCellAccessible :: (MonadIO m, IsImageCellAccessible o) => o -> m ImageCellAccessible

-- | Type class for types which can be safely cast to
--   CellRendererToggle, for instance with
--   toCellRendererToggle.
class (GObject o, IsDescendantOf CellRendererToggle o) => IsCellRendererToggle o

-- | Cast to CellRendererToggle, for types for which this is known
--   to be safe. For general casts, use castTo.
toCellRendererToggle :: (MonadIO m, IsCellRendererToggle o) => o -> m CellRendererToggle

-- | The toggled 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 path. Often this is
--   simply the opposite of the value currently stored at
--   path.
type CellRendererToggleToggledCallback = Text -> IO ()

-- | Connect a signal handler for the toggled signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on cellRendererToggle #toggled callback
--   
onCellRendererToggleToggled :: (IsCellRendererToggle a, MonadIO m) => a -> ((?self :: a) => CellRendererToggleToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggled signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after cellRendererToggle #toggled callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCellRendererToggleToggled :: (IsCellRendererToggle a, MonadIO m) => a -> ((?self :: a) => CellRendererToggleToggledCallback) -> m SignalHandlerId

-- | Get the value of the “activatable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererToggle #activatable
--   
getCellRendererToggleActivatable :: (MonadIO m, IsCellRendererToggle o) => o -> m Bool

-- | Set the value of the “activatable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererToggle [ #activatable := value ]
--   
setCellRendererToggleActivatable :: (MonadIO m, IsCellRendererToggle o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “activatable” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererToggleActivatable :: (IsCellRendererToggle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererToggle #active
--   
getCellRendererToggleActive :: (MonadIO m, IsCellRendererToggle o) => o -> m Bool

-- | Set the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererToggle [ #active := value ]
--   
setCellRendererToggleActive :: (MonadIO m, IsCellRendererToggle o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “active” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererToggleActive :: (IsCellRendererToggle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “inconsistent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererToggle #inconsistent
--   
getCellRendererToggleInconsistent :: (MonadIO m, IsCellRendererToggle o) => o -> m Bool

-- | Set the value of the “inconsistent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererToggle [ #inconsistent := value ]
--   
setCellRendererToggleInconsistent :: (MonadIO m, IsCellRendererToggle o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “inconsistent” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererToggleInconsistent :: (IsCellRendererToggle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “indicator-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererToggle #indicatorSize
--   
getCellRendererToggleIndicatorSize :: (MonadIO m, IsCellRendererToggle o) => o -> m Int32

-- | Set the value of the “indicator-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererToggle [ #indicatorSize := value ]
--   
setCellRendererToggleIndicatorSize :: (MonadIO m, IsCellRendererToggle o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “indicator-size” property. This is rarely needed directly,
--   but it is used by new.
constructCellRendererToggleIndicatorSize :: (IsCellRendererToggle o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “radio” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererToggle #radio
--   
getCellRendererToggleRadio :: (MonadIO m, IsCellRendererToggle o) => o -> m Bool

-- | Set the value of the “radio” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererToggle [ #radio := value ]
--   
setCellRendererToggleRadio :: (MonadIO m, IsCellRendererToggle o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “radio” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererToggleRadio :: (IsCellRendererToggle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new CellRendererToggle. Adjust rendering parameters
--   using object properties. Object properties can be set globally (with
--   g_object_set()). Also, with TreeViewColumn, you
--   can bind a property to a value in a TreeModel. 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
--   cellRendererToggleSetActivatable.
--   
--   Since: 2.18
cellRendererToggleGetActivatable :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> m Bool

-- | Returns whether the cell renderer is active. See
--   cellRendererToggleSetActive.
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

-- | If radio is True, the cell renderer renders a
--   radio toggle (i.e. a toggle in a group of mutually-exclusive toggles).
--   If False, 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 TreeView, you
--   set up a per-row setting using TreeViewColumn to associate
--   model columns with cell renderer properties).
cellRendererToggleSetRadio :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to
--   CellRendererText, for instance with toCellRendererText.
class (GObject o, IsDescendantOf CellRendererText o) => IsCellRendererText o

-- | Cast to CellRendererText, for types for which this is known to
--   be safe. For general casts, use castTo.
toCellRendererText :: (MonadIO m, IsCellRendererText o) => o -> m CellRendererText

-- | This signal is emitted after renderer has been edited.
--   
--   It is the responsibility of the application to update the model and
--   store newText at the position indicated by
--   path.
type CellRendererTextEditedCallback = Text -> Text -> IO ()

-- | Connect a signal handler for the edited signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on cellRendererText #edited callback
--   
onCellRendererTextEdited :: (IsCellRendererText a, MonadIO m) => a -> ((?self :: a) => CellRendererTextEditedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the edited signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after cellRendererText #edited callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCellRendererTextEdited :: (IsCellRendererText a, MonadIO m) => a -> ((?self :: a) => CellRendererTextEditedCallback) -> m SignalHandlerId

-- | Get the value of the “align-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #alignSet
--   
getCellRendererTextAlignSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “align-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #alignSet := value ]
--   
setCellRendererTextAlignSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “align-set” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextAlignSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “alignment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #alignment
--   
getCellRendererTextAlignment :: (MonadIO m, IsCellRendererText o) => o -> m Alignment

-- | Set the value of the “alignment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #alignment := value ]
--   
setCellRendererTextAlignment :: (MonadIO m, IsCellRendererText o) => o -> Alignment -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “alignment” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextAlignment :: (IsCellRendererText o, MonadIO m) => Alignment -> m (GValueConstruct o)

-- | Get the value of the “attributes” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #attributes
--   
getCellRendererTextAttributes :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe AttrList)

-- | Set the value of the “attributes” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #attributes := value ]
--   
setCellRendererTextAttributes :: (MonadIO m, IsCellRendererText o) => o -> AttrList -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “attributes” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextAttributes :: (IsCellRendererText o, MonadIO m) => AttrList -> m (GValueConstruct o)

-- | Set the value of the “attributes” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #attributes
--   
clearCellRendererTextAttributes :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Set the value of the “background” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #background := value ]
--   
setCellRendererTextBackground :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextBackground :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “background” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #background
--   
clearCellRendererTextBackground :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “background-gdk” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #backgroundGdk
--   
getCellRendererTextBackgroundGdk :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Color)

-- | Set the value of the “background-gdk” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #backgroundGdk := value ]
--   
setCellRendererTextBackgroundGdk :: (MonadIO m, IsCellRendererText o) => o -> Color -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background-gdk” property. This is rarely needed directly,
--   but it is used by new.
constructCellRendererTextBackgroundGdk :: (IsCellRendererText o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Set the value of the “background-gdk” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #backgroundGdk
--   
clearCellRendererTextBackgroundGdk :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “background-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #backgroundRgba
--   
getCellRendererTextBackgroundRgba :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe RGBA)

-- | Set the value of the “background-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #backgroundRgba := value ]
--   
setCellRendererTextBackgroundRgba :: (MonadIO m, IsCellRendererText o) => o -> RGBA -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background-rgba” property. This is rarely needed directly,
--   but it is used by new.
constructCellRendererTextBackgroundRgba :: (IsCellRendererText o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “background-rgba” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #backgroundRgba
--   
clearCellRendererTextBackgroundRgba :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “background-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #backgroundSet
--   
getCellRendererTextBackgroundSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “background-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #backgroundSet := value ]
--   
setCellRendererTextBackgroundSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background-set” property. This is rarely needed directly,
--   but it is used by new.
constructCellRendererTextBackgroundSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “editable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #editable
--   
getCellRendererTextEditable :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “editable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #editable := value ]
--   
setCellRendererTextEditable :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “editable” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextEditable :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “editable-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #editableSet
--   
getCellRendererTextEditableSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “editable-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #editableSet := value ]
--   
setCellRendererTextEditableSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “editable-set” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererTextEditableSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “ellipsize” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #ellipsize
--   
getCellRendererTextEllipsize :: (MonadIO m, IsCellRendererText o) => o -> m EllipsizeMode

-- | Set the value of the “ellipsize” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #ellipsize := value ]
--   
setCellRendererTextEllipsize :: (MonadIO m, IsCellRendererText o) => o -> EllipsizeMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “ellipsize” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextEllipsize :: (IsCellRendererText o, MonadIO m) => EllipsizeMode -> m (GValueConstruct o)

-- | Get the value of the “ellipsize-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #ellipsizeSet
--   
getCellRendererTextEllipsizeSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “ellipsize-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #ellipsizeSet := value ]
--   
setCellRendererTextEllipsizeSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “ellipsize-set” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererTextEllipsizeSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “family” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #family
--   
getCellRendererTextFamily :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “family” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #family := value ]
--   
setCellRendererTextFamily :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “family” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererTextFamily :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “family” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #family
--   
clearCellRendererTextFamily :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “family-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #familySet
--   
getCellRendererTextFamilySet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “family-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #familySet := value ]
--   
setCellRendererTextFamilySet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “family-set” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextFamilySet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “font” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get cellRendererText #font
--   
getCellRendererTextFont :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “font” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #font := value ]
--   
setCellRendererTextFont :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “font” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererTextFont :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “font” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #font
--   
clearCellRendererTextFont :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “font-desc” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #fontDesc
--   
getCellRendererTextFontDesc :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe FontDescription)

-- | Set the value of the “font-desc” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #fontDesc := value ]
--   
setCellRendererTextFontDesc :: (MonadIO m, IsCellRendererText o) => o -> FontDescription -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “font-desc” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextFontDesc :: (IsCellRendererText o, MonadIO m) => FontDescription -> m (GValueConstruct o)

-- | Set the value of the “font-desc” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #fontDesc
--   
clearCellRendererTextFontDesc :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Set the value of the “foreground” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #foreground := value ]
--   
setCellRendererTextForeground :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “foreground” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextForeground :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “foreground” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #foreground
--   
clearCellRendererTextForeground :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “foreground-gdk” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #foregroundGdk
--   
getCellRendererTextForegroundGdk :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Color)

-- | Set the value of the “foreground-gdk” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #foregroundGdk := value ]
--   
setCellRendererTextForegroundGdk :: (MonadIO m, IsCellRendererText o) => o -> Color -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “foreground-gdk” property. This is rarely needed directly,
--   but it is used by new.
constructCellRendererTextForegroundGdk :: (IsCellRendererText o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Set the value of the “foreground-gdk” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #foregroundGdk
--   
clearCellRendererTextForegroundGdk :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “foreground-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #foregroundRgba
--   
getCellRendererTextForegroundRgba :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe RGBA)

-- | Set the value of the “foreground-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #foregroundRgba := value ]
--   
setCellRendererTextForegroundRgba :: (MonadIO m, IsCellRendererText o) => o -> RGBA -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “foreground-rgba” property. This is rarely needed directly,
--   but it is used by new.
constructCellRendererTextForegroundRgba :: (IsCellRendererText o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “foreground-rgba” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #foregroundRgba
--   
clearCellRendererTextForegroundRgba :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “foreground-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #foregroundSet
--   
getCellRendererTextForegroundSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “foreground-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #foregroundSet := value ]
--   
setCellRendererTextForegroundSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “foreground-set” property. This is rarely needed directly,
--   but it is used by new.
constructCellRendererTextForegroundSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “language” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #language
--   
getCellRendererTextLanguage :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “language” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #language := value ]
--   
setCellRendererTextLanguage :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “language” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextLanguage :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “language” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #language
--   
clearCellRendererTextLanguage :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “language-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #languageSet
--   
getCellRendererTextLanguageSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “language-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #languageSet := value ]
--   
setCellRendererTextLanguageSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “language-set” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererTextLanguageSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Set the value of the “markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #markup := value ]
--   
setCellRendererTextMarkup :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “markup” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererTextMarkup :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “markup” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #markup
--   
clearCellRendererTextMarkup :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “max-width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #maxWidthChars
--   
getCellRendererTextMaxWidthChars :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “max-width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #maxWidthChars := value ]
--   
setCellRendererTextMaxWidthChars :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “max-width-chars” property. This is rarely needed directly,
--   but it is used by new.
constructCellRendererTextMaxWidthChars :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “placeholder-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #placeholderText
--   
getCellRendererTextPlaceholderText :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “placeholder-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #placeholderText := value ]
--   
setCellRendererTextPlaceholderText :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “placeholder-text” property. This is rarely needed directly,
--   but it is used by new.
constructCellRendererTextPlaceholderText :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “placeholder-text” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #placeholderText
--   
clearCellRendererTextPlaceholderText :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “rise” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get cellRendererText #rise
--   
getCellRendererTextRise :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “rise” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #rise := value ]
--   
setCellRendererTextRise :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “rise” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererTextRise :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “rise-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #riseSet
--   
getCellRendererTextRiseSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “rise-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #riseSet := value ]
--   
setCellRendererTextRiseSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “rise-set” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextRiseSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “scale” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #scale
--   
getCellRendererTextScale :: (MonadIO m, IsCellRendererText o) => o -> m Double

-- | Set the value of the “scale” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #scale := value ]
--   
setCellRendererTextScale :: (MonadIO m, IsCellRendererText o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “scale” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererTextScale :: (IsCellRendererText o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “scale-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #scaleSet
--   
getCellRendererTextScaleSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “scale-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #scaleSet := value ]
--   
setCellRendererTextScaleSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “scale-set” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextScaleSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “single-paragraph-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #singleParagraphMode
--   
getCellRendererTextSingleParagraphMode :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “single-paragraph-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #singleParagraphMode := value ]
--   
setCellRendererTextSingleParagraphMode :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “single-paragraph-mode” property. This is rarely needed
--   directly, but it is used by new.
constructCellRendererTextSingleParagraphMode :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “size” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get cellRendererText #size
--   
getCellRendererTextSize :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “size” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #size := value ]
--   
setCellRendererTextSize :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “size” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererTextSize :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “size-points” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #sizePoints
--   
getCellRendererTextSizePoints :: (MonadIO m, IsCellRendererText o) => o -> m Double

-- | Set the value of the “size-points” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #sizePoints := value ]
--   
setCellRendererTextSizePoints :: (MonadIO m, IsCellRendererText o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “size-points” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererTextSizePoints :: (IsCellRendererText o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “size-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #sizeSet
--   
getCellRendererTextSizeSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “size-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #sizeSet := value ]
--   
setCellRendererTextSizeSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “size-set” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextSizeSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “stretch” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #stretch
--   
getCellRendererTextStretch :: (MonadIO m, IsCellRendererText o) => o -> m Stretch

-- | Set the value of the “stretch” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #stretch := value ]
--   
setCellRendererTextStretch :: (MonadIO m, IsCellRendererText o) => o -> Stretch -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “stretch” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererTextStretch :: (IsCellRendererText o, MonadIO m) => Stretch -> m (GValueConstruct o)

-- | Get the value of the “stretch-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #stretchSet
--   
getCellRendererTextStretchSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “stretch-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #stretchSet := value ]
--   
setCellRendererTextStretchSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “stretch-set” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererTextStretchSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “strikethrough” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #strikethrough
--   
getCellRendererTextStrikethrough :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “strikethrough” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #strikethrough := value ]
--   
setCellRendererTextStrikethrough :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “strikethrough” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererTextStrikethrough :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “strikethrough-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #strikethroughSet
--   
getCellRendererTextStrikethroughSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “strikethrough-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #strikethroughSet := value ]
--   
setCellRendererTextStrikethroughSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “strikethrough-set” property. This is rarely needed directly,
--   but it is used by new.
constructCellRendererTextStrikethroughSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #style
--   
getCellRendererTextStyle :: (MonadIO m, IsCellRendererText o) => o -> m Style

-- | Set the value of the “style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #style := value ]
--   
setCellRendererTextStyle :: (MonadIO m, IsCellRendererText o) => o -> Style -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “style” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererTextStyle :: (IsCellRendererText o, MonadIO m) => Style -> m (GValueConstruct o)

-- | Get the value of the “style-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #styleSet
--   
getCellRendererTextStyleSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “style-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #styleSet := value ]
--   
setCellRendererTextStyleSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “style-set” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextStyleSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get cellRendererText #text
--   
getCellRendererTextText :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #text := value ]
--   
setCellRendererTextText :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererTextText :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “text” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #text
--   
clearCellRendererTextText :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “underline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #underline
--   
getCellRendererTextUnderline :: (MonadIO m, IsCellRendererText o) => o -> m Underline

-- | Set the value of the “underline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #underline := value ]
--   
setCellRendererTextUnderline :: (MonadIO m, IsCellRendererText o) => o -> Underline -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “underline” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextUnderline :: (IsCellRendererText o, MonadIO m) => Underline -> m (GValueConstruct o)

-- | Get the value of the “underline-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #underlineSet
--   
getCellRendererTextUnderlineSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “underline-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #underlineSet := value ]
--   
setCellRendererTextUnderlineSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “underline-set” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererTextUnderlineSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “variant” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #variant
--   
getCellRendererTextVariant :: (MonadIO m, IsCellRendererText o) => o -> m Variant

-- | Set the value of the “variant” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #variant := value ]
--   
setCellRendererTextVariant :: (MonadIO m, IsCellRendererText o) => o -> Variant -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “variant” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererTextVariant :: (IsCellRendererText o, MonadIO m) => Variant -> m (GValueConstruct o)

-- | Get the value of the “variant-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #variantSet
--   
getCellRendererTextVariantSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “variant-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #variantSet := value ]
--   
setCellRendererTextVariantSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “variant-set” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererTextVariantSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “weight” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #weight
--   
getCellRendererTextWeight :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “weight” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #weight := value ]
--   
setCellRendererTextWeight :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “weight” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererTextWeight :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “weight-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #weightSet
--   
getCellRendererTextWeightSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “weight-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #weightSet := value ]
--   
setCellRendererTextWeightSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “weight-set” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextWeightSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #widthChars
--   
getCellRendererTextWidthChars :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #widthChars := value ]
--   
setCellRendererTextWidthChars :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “width-chars” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererTextWidthChars :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “wrap-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #wrapMode
--   
getCellRendererTextWrapMode :: (MonadIO m, IsCellRendererText o) => o -> m WrapMode

-- | Set the value of the “wrap-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #wrapMode := value ]
--   
setCellRendererTextWrapMode :: (MonadIO m, IsCellRendererText o) => o -> WrapMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “wrap-mode” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextWrapMode :: (IsCellRendererText o, MonadIO m) => WrapMode -> m (GValueConstruct o)

-- | Get the value of the “wrap-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererText #wrapWidth
--   
getCellRendererTextWrapWidth :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “wrap-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererText [ #wrapWidth := value ]
--   
setCellRendererTextWrapWidth :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “wrap-width” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererTextWrapWidth :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new CellRendererText. Adjust how text is drawn using
--   object properties. Object properties can be set globally (with
--   g_object_set()). Also, with TreeViewColumn, you
--   can bind a property to a value in a TreeModel. 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
--   TreeView
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
--   numberOfRows 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 ()

-- | Type class for types which can be safely cast to
--   CellRendererSpinner, for instance with
--   toCellRendererSpinner.
class (GObject o, IsDescendantOf CellRendererSpinner o) => IsCellRendererSpinner o

-- | Memory-managed wrapper type.
newtype CellRendererSpinner
CellRendererSpinner :: ManagedPtr CellRendererSpinner -> CellRendererSpinner

-- | Cast to CellRendererSpinner, for types for which this is known
--   to be safe. For general casts, use castTo.
toCellRendererSpinner :: (MonadIO m, IsCellRendererSpinner o) => o -> m CellRendererSpinner

-- | Get the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererSpinner #active
--   
getCellRendererSpinnerActive :: (MonadIO m, IsCellRendererSpinner o) => o -> m Bool

-- | Set the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererSpinner [ #active := value ]
--   
setCellRendererSpinnerActive :: (MonadIO m, IsCellRendererSpinner o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “active” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererSpinnerActive :: (IsCellRendererSpinner o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “pulse” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererSpinner #pulse
--   
getCellRendererSpinnerPulse :: (MonadIO m, IsCellRendererSpinner o) => o -> m Word32

-- | Set the value of the “pulse” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererSpinner [ #pulse := value ]
--   
setCellRendererSpinnerPulse :: (MonadIO m, IsCellRendererSpinner o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pulse” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererSpinnerPulse :: (IsCellRendererSpinner o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “size” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get cellRendererSpinner #size
--   
getCellRendererSpinnerSize :: (MonadIO m, IsCellRendererSpinner o) => o -> m IconSize

-- | Set the value of the “size” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set cellRendererSpinner [ #size := value ]
--   
setCellRendererSpinnerSize :: (MonadIO m, IsCellRendererSpinner o) => o -> IconSize -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “size” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererSpinnerSize :: (IsCellRendererSpinner o, MonadIO m) => IconSize -> m (GValueConstruct o)

-- | Returns a new cell renderer which will show a spinner to indicate
--   activity.
--   
--   Since: 2.20
cellRendererSpinnerNew :: (HasCallStack, MonadIO m) => m CellRendererSpinner

-- | Type class for types which can be safely cast to
--   CellRendererSpin, for instance with toCellRendererSpin.
class (GObject o, IsDescendantOf CellRendererSpin o) => IsCellRendererSpin o

-- | Cast to CellRendererSpin, for types for which this is known to
--   be safe. For general casts, use castTo.
toCellRendererSpin :: (MonadIO m, IsCellRendererSpin o) => o -> m CellRendererSpin

-- | Get the value of the “adjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererSpin #adjustment
--   
getCellRendererSpinAdjustment :: (MonadIO m, IsCellRendererSpin o) => o -> m (Maybe Adjustment)

-- | Set the value of the “adjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererSpin [ #adjustment := value ]
--   
setCellRendererSpinAdjustment :: (MonadIO m, IsCellRendererSpin o, IsAdjustment a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “adjustment” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererSpinAdjustment :: (IsCellRendererSpin o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Set the value of the “adjustment” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #adjustment
--   
clearCellRendererSpinAdjustment :: (MonadIO m, IsCellRendererSpin o) => o -> m ()

-- | Get the value of the “climb-rate” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererSpin #climbRate
--   
getCellRendererSpinClimbRate :: (MonadIO m, IsCellRendererSpin o) => o -> m Double

-- | Set the value of the “climb-rate” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererSpin [ #climbRate := value ]
--   
setCellRendererSpinClimbRate :: (MonadIO m, IsCellRendererSpin o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “climb-rate” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererSpinClimbRate :: (IsCellRendererSpin o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “digits” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererSpin #digits
--   
getCellRendererSpinDigits :: (MonadIO m, IsCellRendererSpin o) => o -> m Word32

-- | Set the value of the “digits” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererSpin [ #digits := value ]
--   
setCellRendererSpinDigits :: (MonadIO m, IsCellRendererSpin o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “digits” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererSpinDigits :: (IsCellRendererSpin o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Creates a new CellRendererSpin.
--   
--   Since: 2.10
cellRendererSpinNew :: (HasCallStack, MonadIO m) => m CellRendererSpin

-- | Type class for types which can be safely cast to
--   CellRendererProgress, for instance with
--   toCellRendererProgress.
class (GObject o, IsDescendantOf CellRendererProgress o) => IsCellRendererProgress o

-- | Cast to CellRendererProgress, for types for which this is known
--   to be safe. For general casts, use castTo.
toCellRendererProgress :: (MonadIO m, IsCellRendererProgress o) => o -> m CellRendererProgress

-- | Get the value of the “inverted” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererProgress #inverted
--   
getCellRendererProgressInverted :: (MonadIO m, IsCellRendererProgress o) => o -> m Bool

-- | Set the value of the “inverted” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererProgress [ #inverted := value ]
--   
setCellRendererProgressInverted :: (MonadIO m, IsCellRendererProgress o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “inverted” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererProgressInverted :: (IsCellRendererProgress o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “pulse” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererProgress #pulse
--   
getCellRendererProgressPulse :: (MonadIO m, IsCellRendererProgress o) => o -> m Int32

-- | Set the value of the “pulse” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererProgress [ #pulse := value ]
--   
setCellRendererProgressPulse :: (MonadIO m, IsCellRendererProgress o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pulse” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererProgressPulse :: (IsCellRendererProgress o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get cellRendererProgress #text
--   
getCellRendererProgressText :: (MonadIO m, IsCellRendererProgress o) => o -> m (Maybe Text)

-- | Set the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set cellRendererProgress [ #text := value ]
--   
setCellRendererProgressText :: (MonadIO m, IsCellRendererProgress o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererProgressText :: (IsCellRendererProgress o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “text” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #text
--   
clearCellRendererProgressText :: (MonadIO m, IsCellRendererProgress o) => o -> m ()

-- | Get the value of the “text-xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererProgress #textXalign
--   
getCellRendererProgressTextXalign :: (MonadIO m, IsCellRendererProgress o) => o -> m Float

-- | Set the value of the “text-xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererProgress [ #textXalign := value ]
--   
setCellRendererProgressTextXalign :: (MonadIO m, IsCellRendererProgress o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text-xalign” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererProgressTextXalign :: (IsCellRendererProgress o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “text-yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererProgress #textYalign
--   
getCellRendererProgressTextYalign :: (MonadIO m, IsCellRendererProgress o) => o -> m Float

-- | Set the value of the “text-yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererProgress [ #textYalign := value ]
--   
setCellRendererProgressTextYalign :: (MonadIO m, IsCellRendererProgress o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text-yalign” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererProgressTextYalign :: (IsCellRendererProgress o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererProgress #value
--   
getCellRendererProgressValue :: (MonadIO m, IsCellRendererProgress o) => o -> m Int32

-- | Set the value of the “value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererProgress [ #value := value ]
--   
setCellRendererProgressValue :: (MonadIO m, IsCellRendererProgress o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “value” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererProgressValue :: (IsCellRendererProgress o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new CellRendererProgress.
--   
--   Since: 2.6
cellRendererProgressNew :: (HasCallStack, MonadIO m) => m CellRendererProgress

-- | Type class for types which can be safely cast to
--   CellRendererPixbuf, for instance with
--   toCellRendererPixbuf.
class (GObject o, IsDescendantOf CellRendererPixbuf o) => IsCellRendererPixbuf o

-- | Cast to CellRendererPixbuf, for types for which this is known
--   to be safe. For general casts, use castTo.
toCellRendererPixbuf :: (MonadIO m, IsCellRendererPixbuf o) => o -> m CellRendererPixbuf

-- | Get the value of the “follow-state” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererPixbuf #followState
--   
getCellRendererPixbufFollowState :: (MonadIO m, IsCellRendererPixbuf o) => o -> m Bool

-- | Set the value of the “follow-state” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererPixbuf [ #followState := value ]
--   
setCellRendererPixbufFollowState :: (MonadIO m, IsCellRendererPixbuf o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “follow-state” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererPixbufFollowState :: (IsCellRendererPixbuf o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “gicon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererPixbuf #gicon
--   
getCellRendererPixbufGicon :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Icon)

-- | Set the value of the “gicon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererPixbuf [ #gicon := value ]
--   
setCellRendererPixbufGicon :: (MonadIO m, IsCellRendererPixbuf o, IsIcon a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gicon” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererPixbufGicon :: (IsCellRendererPixbuf o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “gicon” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #gicon
--   
clearCellRendererPixbufGicon :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Get the value of the “icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererPixbuf #iconName
--   
getCellRendererPixbufIconName :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Text)

-- | Set the value of the “icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererPixbuf [ #iconName := value ]
--   
setCellRendererPixbufIconName :: (MonadIO m, IsCellRendererPixbuf o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-name” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererPixbufIconName :: (IsCellRendererPixbuf o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “icon-name” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #iconName
--   
clearCellRendererPixbufIconName :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Get the value of the “pixbuf” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererPixbuf #pixbuf
--   
getCellRendererPixbufPixbuf :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “pixbuf” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererPixbuf [ #pixbuf := value ]
--   
setCellRendererPixbufPixbuf :: (MonadIO m, IsCellRendererPixbuf o, IsPixbuf a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixbuf” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererPixbufPixbuf :: (IsCellRendererPixbuf o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “pixbuf” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #pixbuf
--   
clearCellRendererPixbufPixbuf :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Get the value of the “pixbuf-expander-closed” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererPixbuf #pixbufExpanderClosed
--   
getCellRendererPixbufPixbufExpanderClosed :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “pixbuf-expander-closed” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererPixbuf [ #pixbufExpanderClosed := value ]
--   
setCellRendererPixbufPixbufExpanderClosed :: (MonadIO m, IsCellRendererPixbuf o, IsPixbuf a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixbuf-expander-closed” property. This is rarely needed
--   directly, but it is used by new.
constructCellRendererPixbufPixbufExpanderClosed :: (IsCellRendererPixbuf o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “pixbuf-expander-closed” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #pixbufExpanderClosed
--   
clearCellRendererPixbufPixbufExpanderClosed :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Get the value of the “pixbuf-expander-open” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererPixbuf #pixbufExpanderOpen
--   
getCellRendererPixbufPixbufExpanderOpen :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “pixbuf-expander-open” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererPixbuf [ #pixbufExpanderOpen := value ]
--   
setCellRendererPixbufPixbufExpanderOpen :: (MonadIO m, IsCellRendererPixbuf o, IsPixbuf a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixbuf-expander-open” property. This is rarely needed
--   directly, but it is used by new.
constructCellRendererPixbufPixbufExpanderOpen :: (IsCellRendererPixbuf o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “pixbuf-expander-open” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #pixbufExpanderOpen
--   
clearCellRendererPixbufPixbufExpanderOpen :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Get the value of the “stock-detail” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererPixbuf #stockDetail
--   
getCellRendererPixbufStockDetail :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Text)

-- | Set the value of the “stock-detail” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererPixbuf [ #stockDetail := value ]
--   
setCellRendererPixbufStockDetail :: (MonadIO m, IsCellRendererPixbuf o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “stock-detail” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererPixbufStockDetail :: (IsCellRendererPixbuf o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “stock-detail” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #stockDetail
--   
clearCellRendererPixbufStockDetail :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Get the value of the “stock-id” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererPixbuf #stockId
--   
getCellRendererPixbufStockId :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Text)

-- | Set the value of the “stock-id” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererPixbuf [ #stockId := value ]
--   
setCellRendererPixbufStockId :: (MonadIO m, IsCellRendererPixbuf o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “stock-id” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererPixbufStockId :: (IsCellRendererPixbuf o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “stock-id” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #stockId
--   
clearCellRendererPixbufStockId :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Get the value of the “stock-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererPixbuf #stockSize
--   
getCellRendererPixbufStockSize :: (MonadIO m, IsCellRendererPixbuf o) => o -> m Word32

-- | Set the value of the “stock-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererPixbuf [ #stockSize := value ]
--   
setCellRendererPixbufStockSize :: (MonadIO m, IsCellRendererPixbuf o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “stock-size” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererPixbufStockSize :: (IsCellRendererPixbuf o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “surface” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererPixbuf #surface
--   
getCellRendererPixbufSurface :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Surface)

-- | Set the value of the “surface” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererPixbuf [ #surface := value ]
--   
setCellRendererPixbufSurface :: (MonadIO m, IsCellRendererPixbuf o) => o -> Surface -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “surface” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererPixbufSurface :: (IsCellRendererPixbuf o, MonadIO m) => Surface -> m (GValueConstruct o)

-- | Set the value of the “surface” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #surface
--   
clearCellRendererPixbufSurface :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Creates a new CellRendererPixbuf. Adjust rendering parameters
--   using object properties. Object properties can be set globally (with
--   g_object_set()). Also, with TreeViewColumn, you
--   can bind a property to a value in a TreeModel. 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
--   TreeView.
cellRendererPixbufNew :: (HasCallStack, MonadIO m) => m CellRendererPixbuf

-- | Type class for types which can be safely cast to
--   CellRendererCombo, for instance with
--   toCellRendererCombo.
class (GObject o, IsDescendantOf CellRendererCombo o) => IsCellRendererCombo o

-- | Cast to CellRendererCombo, for types for which this is known to
--   be safe. For general casts, use castTo.
toCellRendererCombo :: (MonadIO m, IsCellRendererCombo o) => o -> m 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, GtkCellRendererCombochanged is not emitted for
--   changes made to a selected item in the entry. The argument
--   newIter 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.
--   
--   Since: 2.14
type CellRendererComboChangedCallback = Text -> TreeIter -> IO ()

-- | Connect a signal handler for the changed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on cellRendererCombo #changed callback
--   
onCellRendererComboChanged :: (IsCellRendererCombo a, MonadIO m) => a -> ((?self :: a) => CellRendererComboChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after cellRendererCombo #changed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCellRendererComboChanged :: (IsCellRendererCombo a, MonadIO m) => a -> ((?self :: a) => CellRendererComboChangedCallback) -> m SignalHandlerId

-- | Get the value of the “has-entry” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererCombo #hasEntry
--   
getCellRendererComboHasEntry :: (MonadIO m, IsCellRendererCombo o) => o -> m Bool

-- | Set the value of the “has-entry” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererCombo [ #hasEntry := value ]
--   
setCellRendererComboHasEntry :: (MonadIO m, IsCellRendererCombo o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-entry” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererComboHasEntry :: (IsCellRendererCombo o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererCombo #model
--   
getCellRendererComboModel :: (MonadIO m, IsCellRendererCombo o) => o -> m (Maybe TreeModel)

-- | Set the value of the “model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererCombo [ #model := value ]
--   
setCellRendererComboModel :: (MonadIO m, IsCellRendererCombo o, IsTreeModel a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “model” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererComboModel :: (IsCellRendererCombo o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “model” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #model
--   
clearCellRendererComboModel :: (MonadIO m, IsCellRendererCombo o) => o -> m ()

-- | Get the value of the “text-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererCombo #textColumn
--   
getCellRendererComboTextColumn :: (MonadIO m, IsCellRendererCombo o) => o -> m Int32

-- | Set the value of the “text-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererCombo [ #textColumn := value ]
--   
setCellRendererComboTextColumn :: (MonadIO m, IsCellRendererCombo o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text-column” property. This is rarely needed directly, but
--   it is used by new.
constructCellRendererComboTextColumn :: (IsCellRendererCombo o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new CellRendererCombo. Adjust how text is drawn using
--   object properties. Object properties can be set globally (with
--   g_object_set()). Also, with TreeViewColumn, you
--   can bind a property to a value in a TreeModel. 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
--   TreeView.
--   
--   Since: 2.6
cellRendererComboNew :: (HasCallStack, MonadIO m) => m CellRendererCombo

-- | Type class for types which can be safely cast to
--   CellRendererAccel, for instance with
--   toCellRendererAccel.
class (GObject o, IsDescendantOf CellRendererAccel o) => IsCellRendererAccel o

-- | Cast to CellRendererAccel, for types for which this is known to
--   be safe. For general casts, use castTo.
toCellRendererAccel :: (MonadIO m, IsCellRendererAccel o) => o -> m CellRendererAccel

-- | Gets emitted when the user has selected a new accelerator.
--   
--   Since: 2.10
type CellRendererAccelAccelEditedCallback = Text -> Word32 -> [ModifierType] -> Word32 -> IO ()

-- | Gets emitted when the user has removed the accelerator.
--   
--   Since: 2.10
type CellRendererAccelAccelClearedCallback = Text -> IO ()

-- | Connect a signal handler for the accelCleared signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on cellRendererAccel #accelCleared callback
--   
onCellRendererAccelAccelCleared :: (IsCellRendererAccel a, MonadIO m) => a -> ((?self :: a) => CellRendererAccelAccelClearedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the accelCleared signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after cellRendererAccel #accelCleared callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCellRendererAccelAccelCleared :: (IsCellRendererAccel a, MonadIO m) => a -> ((?self :: a) => CellRendererAccelAccelClearedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the accelEdited signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on cellRendererAccel #accelEdited callback
--   
onCellRendererAccelAccelEdited :: (IsCellRendererAccel a, MonadIO m) => a -> ((?self :: a) => CellRendererAccelAccelEditedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the accelEdited signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after cellRendererAccel #accelEdited callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCellRendererAccelAccelEdited :: (IsCellRendererAccel a, MonadIO m) => a -> ((?self :: a) => CellRendererAccelAccelEditedCallback) -> m SignalHandlerId

-- | Get the value of the “accel-key” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererAccel #accelKey
--   
getCellRendererAccelAccelKey :: (MonadIO m, IsCellRendererAccel o) => o -> m Word32

-- | Set the value of the “accel-key” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererAccel [ #accelKey := value ]
--   
setCellRendererAccelAccelKey :: (MonadIO m, IsCellRendererAccel o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accel-key” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererAccelAccelKey :: (IsCellRendererAccel o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “accel-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererAccel #accelMode
--   
getCellRendererAccelAccelMode :: (MonadIO m, IsCellRendererAccel o) => o -> m CellRendererAccelMode

-- | Set the value of the “accel-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererAccel [ #accelMode := value ]
--   
setCellRendererAccelAccelMode :: (MonadIO m, IsCellRendererAccel o) => o -> CellRendererAccelMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accel-mode” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererAccelAccelMode :: (IsCellRendererAccel o, MonadIO m) => CellRendererAccelMode -> m (GValueConstruct o)

-- | Get the value of the “accel-mods” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererAccel #accelMods
--   
getCellRendererAccelAccelMods :: (MonadIO m, IsCellRendererAccel o) => o -> m [ModifierType]

-- | Set the value of the “accel-mods” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererAccel [ #accelMods := value ]
--   
setCellRendererAccelAccelMods :: (MonadIO m, IsCellRendererAccel o) => o -> [ModifierType] -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accel-mods” property. This is rarely needed directly, but it
--   is used by new.
constructCellRendererAccelAccelMods :: (IsCellRendererAccel o, MonadIO m) => [ModifierType] -> m (GValueConstruct o)

-- | Get the value of the “keycode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellRendererAccel #keycode
--   
getCellRendererAccelKeycode :: (MonadIO m, IsCellRendererAccel o) => o -> m Word32

-- | Set the value of the “keycode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellRendererAccel [ #keycode := value ]
--   
setCellRendererAccelKeycode :: (MonadIO m, IsCellRendererAccel o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “keycode” property. This is rarely needed directly, but it is
--   used by new.
constructCellRendererAccelKeycode :: (IsCellRendererAccel o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Creates a new CellRendererAccel.
--   
--   Since: 2.10
cellRendererAccelNew :: (HasCallStack, MonadIO m) => m CellRendererAccel

-- | Type class for types which can be safely cast to
--   BooleanCellAccessible, for instance with
--   toBooleanCellAccessible.
class (GObject o, IsDescendantOf BooleanCellAccessible o) => IsBooleanCellAccessible o

-- | Memory-managed wrapper type.
newtype BooleanCellAccessible
BooleanCellAccessible :: ManagedPtr BooleanCellAccessible -> BooleanCellAccessible

-- | Cast to BooleanCellAccessible, for types for which this is
--   known to be safe. For general casts, use castTo.
toBooleanCellAccessible :: (MonadIO m, IsBooleanCellAccessible o) => o -> m BooleanCellAccessible

-- | Type class for types which can be safely cast to SpinButton,
--   for instance with toSpinButton.
class (GObject o, IsDescendantOf SpinButton o) => IsSpinButton o

-- | Cast to SpinButton, for types for which this is known to be
--   safe. For general casts, use castTo.
toSpinButton :: (MonadIO m, IsSpinButton o) => o -> m SpinButton

-- | The wrapped signal is emitted right after the spinbutton wraps
--   from its maximum to minimum value or vice-versa.
--   
--   Since: 2.10
type SpinButtonWrappedCallback = IO ()

-- | The valueChanged signal is emitted when the value represented
--   by spinbutton changes. Also see the
--   SpinButton::output signal.
type SpinButtonValueChangedCallback = IO ()

-- | The output signal can be used to change to formatting of the
--   value that is displayed in the spin buttons entry.
--   
--   
C code
--   
--   
--   // 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;
--   }
--   
type SpinButtonOutputCallback = IO Bool

-- | The input signal can be used to influence the conversion of the
--   users input into a double value. The signal handler is expected to use
--   entryGetText to retrieve the text of the entry and set
--   newValue to the new value.
--   
--   The default conversion uses strtod.
type SpinButtonInputCallback = IO (Int32, Double)

-- | The changeValue 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
--   g_signal_emit_by_name() 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 ()

-- | Connect a signal handler for the changeValue signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on spinButton #changeValue callback
--   
onSpinButtonChangeValue :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonChangeValueCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changeValue signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after spinButton #changeValue callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterSpinButtonChangeValue :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonChangeValueCallback) -> m SignalHandlerId

-- | Connect a signal handler for the input signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on spinButton #input callback
--   
onSpinButtonInput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonInputCallback) -> m SignalHandlerId

-- | Connect a signal handler for the input signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after spinButton #input callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterSpinButtonInput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonInputCallback) -> m SignalHandlerId

-- | Connect a signal handler for the output signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on spinButton #output callback
--   
onSpinButtonOutput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonOutputCallback) -> m SignalHandlerId

-- | Connect a signal handler for the output signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after spinButton #output callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterSpinButtonOutput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonOutputCallback) -> m SignalHandlerId

-- | Connect a signal handler for the valueChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on spinButton #valueChanged callback
--   
onSpinButtonValueChanged :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonValueChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the valueChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after spinButton #valueChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterSpinButtonValueChanged :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonValueChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the wrapped signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on spinButton #wrapped callback
--   
onSpinButtonWrapped :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonWrappedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the wrapped signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after spinButton #wrapped callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterSpinButtonWrapped :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonWrappedCallback) -> m SignalHandlerId

-- | Get the value of the “adjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get spinButton #adjustment
--   
getSpinButtonAdjustment :: (MonadIO m, IsSpinButton o) => o -> m Adjustment

-- | Set the value of the “adjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set spinButton [ #adjustment := value ]
--   
setSpinButtonAdjustment :: (MonadIO m, IsSpinButton o, IsAdjustment a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “adjustment” property. This is rarely needed directly, but it
--   is used by new.
constructSpinButtonAdjustment :: (IsSpinButton o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “climb-rate” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get spinButton #climbRate
--   
getSpinButtonClimbRate :: (MonadIO m, IsSpinButton o) => o -> m Double

-- | Set the value of the “climb-rate” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set spinButton [ #climbRate := value ]
--   
setSpinButtonClimbRate :: (MonadIO m, IsSpinButton o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “climb-rate” property. This is rarely needed directly, but it
--   is used by new.
constructSpinButtonClimbRate :: (IsSpinButton o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “digits” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get spinButton #digits
--   
getSpinButtonDigits :: (MonadIO m, IsSpinButton o) => o -> m Word32

-- | Set the value of the “digits” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set spinButton [ #digits := value ]
--   
setSpinButtonDigits :: (MonadIO m, IsSpinButton o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “digits” property. This is rarely needed directly, but it is
--   used by new.
constructSpinButtonDigits :: (IsSpinButton o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “numeric” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get spinButton #numeric
--   
getSpinButtonNumeric :: (MonadIO m, IsSpinButton o) => o -> m Bool

-- | Set the value of the “numeric” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set spinButton [ #numeric := value ]
--   
setSpinButtonNumeric :: (MonadIO m, IsSpinButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “numeric” property. This is rarely needed directly, but it is
--   used by new.
constructSpinButtonNumeric :: (IsSpinButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “snap-to-ticks” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get spinButton #snapToTicks
--   
getSpinButtonSnapToTicks :: (MonadIO m, IsSpinButton o) => o -> m Bool

-- | Set the value of the “snap-to-ticks” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set spinButton [ #snapToTicks := value ]
--   
setSpinButtonSnapToTicks :: (MonadIO m, IsSpinButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “snap-to-ticks” property. This is rarely needed directly, but
--   it is used by new.
constructSpinButtonSnapToTicks :: (IsSpinButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “update-policy” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get spinButton #updatePolicy
--   
getSpinButtonUpdatePolicy :: (MonadIO m, IsSpinButton o) => o -> m SpinButtonUpdatePolicy

-- | Set the value of the “update-policy” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set spinButton [ #updatePolicy := value ]
--   
setSpinButtonUpdatePolicy :: (MonadIO m, IsSpinButton o) => o -> SpinButtonUpdatePolicy -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “update-policy” property. This is rarely needed directly, but
--   it is used by new.
constructSpinButtonUpdatePolicy :: (IsSpinButton o, MonadIO m) => SpinButtonUpdatePolicy -> m (GValueConstruct o)

-- | Get the value of the “value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get spinButton #value
--   
getSpinButtonValue :: (MonadIO m, IsSpinButton o) => o -> m Double

-- | Set the value of the “value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set spinButton [ #value := value ]
--   
setSpinButtonValue :: (MonadIO m, IsSpinButton o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “value” property. This is rarely needed directly, but it is
--   used by new.
constructSpinButtonValue :: (IsSpinButton o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “wrap” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get spinButton #wrap
--   
getSpinButtonWrap :: (MonadIO m, IsSpinButton o) => o -> m Bool

-- | Set the value of the “wrap” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set spinButton [ #wrap := value ]
--   
setSpinButtonWrap :: (MonadIO m, IsSpinButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “wrap” property. This is rarely needed directly, but it is
--   used by new.
constructSpinButtonWrap :: (IsSpinButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new SpinButton.
spinButtonNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe a -> Double -> Word32 -> m SpinButton

-- | This is a convenience constructor that allows creation of a numeric
--   SpinButton without manually creating an adjustment. The value
--   is initially set to the minimum value and a page increment of 10 *
--   step is the default. The precision of the spin button
--   is equivalent to the precision of step.
--   
--   Note that the way in which the precision is derived works best if
--   step is a power of ten. If the resulting precision is
--   not suitable for your needs, use spinButtonSetDigits 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 SpinButton
spinButtonGetAdjustment :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Adjustment

-- | Fetches the precision of spinButton. See
--   spinButtonSetDigits.
spinButtonGetDigits :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Word32

-- | Gets the current step and page the increments used by
--   spinButton. See spinButtonSetIncrements.
spinButtonGetIncrements :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m (Double, Double)

-- | Returns whether non-numeric text can be typed into the spin button.
--   See spinButtonSetNumeric.
spinButtonGetNumeric :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Bool

-- | Gets the range allowed for spinButton. See
--   spinButtonSetRange.
spinButtonGetRange :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m (Double, Double)

-- | Returns whether the values are corrected to the nearest step. See
--   spinButtonSetSnapToTicks.
spinButtonGetSnapToTicks :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Bool

-- | Gets the update behavior of a spin button. See
--   spinButtonSetUpdatePolicy.
spinButtonGetUpdatePolicy :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m SpinButtonUpdatePolicy

-- | Get the value in the spinButton.
spinButtonGetValue :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Double

-- | Get the value spinButton 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
--   spinButtonSetWrap.
spinButtonGetWrap :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Bool

-- | Replaces the Adjustment associated with
--   spinButton.
spinButtonSetAdjustment :: (HasCallStack, MonadIO m, IsSpinButton a, IsAdjustment b) => a -> b -> m ()

-- | Sets the value of spinButton.
spinButtonSetValue :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Double -> m ()

-- | Manually force an update of the spin button.
spinButtonUpdate :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m ()

-- | Type class for types which can be safely cast to SearchEntry,
--   for instance with toSearchEntry.
class (GObject o, IsDescendantOf SearchEntry o) => IsSearchEntry o

-- | Cast to SearchEntry, for types for which this is known to be
--   safe. For general casts, use castTo.
toSearchEntry :: (MonadIO m, IsSearchEntry o) => o -> m SearchEntry

-- | The stopSearch 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.
--   
--   Since: 3.16
type SearchEntryStopSearchCallback = IO ()

-- | The SearchEntry::searchChanged signal is emitted with a short
--   delay of 150 milliseconds after the last change to the entry text.
--   
--   Since: 3.10
type SearchEntrySearchChangedCallback = IO ()

-- | The previousMatch 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.
--   
--   Since: 3.16
type SearchEntryPreviousMatchCallback = IO ()

-- | The nextMatch 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.
--   
--   Since: 3.16
type SearchEntryNextMatchCallback = IO ()

-- | Connect a signal handler for the nextMatch signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on searchEntry #nextMatch callback
--   
onSearchEntryNextMatch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryNextMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the nextMatch signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after searchEntry #nextMatch callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterSearchEntryNextMatch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryNextMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the previousMatch signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on searchEntry #previousMatch callback
--   
onSearchEntryPreviousMatch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryPreviousMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the previousMatch signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after searchEntry #previousMatch callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterSearchEntryPreviousMatch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryPreviousMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the searchChanged signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on searchEntry #searchChanged callback
--   
onSearchEntrySearchChanged :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntrySearchChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the searchChanged signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after searchEntry #searchChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterSearchEntrySearchChanged :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntrySearchChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the stopSearch signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on searchEntry #stopSearch callback
--   
onSearchEntryStopSearch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryStopSearchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the stopSearch signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after searchEntry #stopSearch callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterSearchEntryStopSearch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryStopSearchCallback) -> m SignalHandlerId

-- | Creates a SearchEntry, with a find icon when the search field
--   is empty, and a clear icon when it isn't.
--   
--   Since: 3.6
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 SearchBar, it is preferable to call
--   searchBarHandleEvent 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, EVENT_STOP will be returned. The caller
--   should ensure that the entry is shown in this case, and not propagate
--   the event further.
--   
--   Since: 3.16
searchEntryHandleEvent :: (HasCallStack, MonadIO m, IsSearchEntry a) => a -> Event -> m Bool

-- | Type class for types which can be safely cast to SearchBar, for
--   instance with toSearchBar.
class (GObject o, IsDescendantOf SearchBar o) => IsSearchBar o

-- | Cast to SearchBar, for types for which this is known to be
--   safe. For general casts, use castTo.
toSearchBar :: (MonadIO m, IsSearchBar o) => o -> m SearchBar

-- | Get the value of the “search-mode-enabled” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get searchBar #searchModeEnabled
--   
getSearchBarSearchModeEnabled :: (MonadIO m, IsSearchBar o) => o -> m Bool

-- | Set the value of the “search-mode-enabled” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set searchBar [ #searchModeEnabled := value ]
--   
setSearchBarSearchModeEnabled :: (MonadIO m, IsSearchBar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “search-mode-enabled” property. This is rarely needed
--   directly, but it is used by new.
constructSearchBarSearchModeEnabled :: (IsSearchBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-close-button” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get searchBar #showCloseButton
--   
getSearchBarShowCloseButton :: (MonadIO m, IsSearchBar o) => o -> m Bool

-- | Set the value of the “show-close-button” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set searchBar [ #showCloseButton := value ]
--   
setSearchBarShowCloseButton :: (MonadIO m, IsSearchBar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-close-button” property. This is rarely needed directly,
--   but it is used by new.
constructSearchBarShowCloseButton :: (IsSearchBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a SearchBar. You will need to tell it about which
--   widget is going to be your text entry using
--   searchBarConnectEntry.
--   
--   Since: 3.10
searchBarNew :: (HasCallStack, MonadIO m) => m SearchBar

-- | Returns whether the search mode is on or off.
--   
--   Since: 3.10
searchBarGetSearchMode :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> m Bool

-- | Returns whether the close button is shown.
--   
--   Since: 3.10
searchBarGetShowCloseButton :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> m Bool

-- | Switches the search mode on or off.
--   
--   Since: 3.10
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.
--   
--   Since: 3.10
searchBarSetShowCloseButton :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to ComboBox, for
--   instance with toComboBox.
class (GObject o, IsDescendantOf ComboBox o) => IsComboBox o

-- | Cast to ComboBox, for types for which this is known to be safe.
--   For general casts, use castTo.
toComboBox :: (MonadIO m, IsComboBox o) => o -> m ComboBox

-- | The popup signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted to popup the combo box list.
--   
--   The default binding for this signal is Alt+Down.
--   
--   Since: 2.12
type ComboBoxPopupCallback = IO ()

-- | The popdown 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.
--   
--   Since: 2.12
type ComboBoxPopdownCallback = IO Bool

-- | The moveActive signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to move the active
--   selection.
--   
--   Since: 2.12
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 path. 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 GtkComboBoxentryTextColumn model column.
--   
--   Here's an example signal handler which fetches data from the model and
--   displays it in the entry.
--   
--   
C code
--   
--   
--   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, &iter, path);
--     gtk_tree_model_get (model, &iter,
--                         THE_DOUBLE_VALUE_COLUMN, &value,
--                         -1);
--   
--     return g_strdup_printf ("%g", value);
--   }
--   
--   
--   Since: 3.4
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 comboBoxSetActiveIter. It will also be emitted while
--   typing into the entry of a combo box with an entry.
--   
--   Since: 2.4
type ComboBoxChangedCallback = IO ()

-- | Connect a signal handler for the changed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on comboBox #changed callback
--   
onComboBoxChanged :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the changed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after comboBox #changed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterComboBoxChanged :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the formatEntryText signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on comboBox #formatEntryText callback
--   
onComboBoxFormatEntryText :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxFormatEntryTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the formatEntryText signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after comboBox #formatEntryText callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterComboBoxFormatEntryText :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxFormatEntryTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveActive signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on comboBox #moveActive callback
--   
onComboBoxMoveActive :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxMoveActiveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveActive signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after comboBox #moveActive callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterComboBoxMoveActive :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxMoveActiveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the popdown signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on comboBox #popdown callback
--   
onComboBoxPopdown :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxPopdownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the popdown signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after comboBox #popdown callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterComboBoxPopdown :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxPopdownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the popup signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on comboBox #popup callback
--   
onComboBoxPopup :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxPopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the popup signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after comboBox #popup callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterComboBoxPopup :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxPopupCallback) -> m SignalHandlerId

-- | Get the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #active
--   
getComboBoxActive :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set comboBox [ #active := value ]
--   
setComboBoxActive :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “active” property. This is rarely needed directly, but it is
--   used by new.
constructComboBoxActive :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “active-id” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #activeId
--   
getComboBoxActiveId :: (MonadIO m, IsComboBox o) => o -> m (Maybe Text)

-- | Set the value of the “active-id” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set comboBox [ #activeId := value ]
--   
setComboBoxActiveId :: (MonadIO m, IsComboBox o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “active-id” property. This is rarely needed directly, but it
--   is used by new.
constructComboBoxActiveId :: (IsComboBox o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “active-id” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #activeId
--   
clearComboBoxActiveId :: (MonadIO m, IsComboBox o) => o -> m ()

-- | Get the value of the “add-tearoffs” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #addTearoffs
--   
getComboBoxAddTearoffs :: (MonadIO m, IsComboBox o) => o -> m Bool

-- | Set the value of the “add-tearoffs” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set comboBox [ #addTearoffs := value ]
--   
setComboBoxAddTearoffs :: (MonadIO m, IsComboBox o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “add-tearoffs” property. This is rarely needed directly, but
--   it is used by new.
constructComboBoxAddTearoffs :: (IsComboBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “button-sensitivity” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #buttonSensitivity
--   
getComboBoxButtonSensitivity :: (MonadIO m, IsComboBox o) => o -> m SensitivityType

-- | Set the value of the “button-sensitivity” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set comboBox [ #buttonSensitivity := value ]
--   
setComboBoxButtonSensitivity :: (MonadIO m, IsComboBox o) => o -> SensitivityType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “button-sensitivity” property. This is rarely needed
--   directly, but it is used by new.
constructComboBoxButtonSensitivity :: (IsComboBox o, MonadIO m) => SensitivityType -> m (GValueConstruct o)

-- | Get the value of the “cell-area” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #cellArea
--   
getComboBoxCellArea :: (MonadIO m, IsComboBox o) => o -> m (Maybe CellArea)

-- | Construct a GValueConstruct with valid value for the
--   “cell-area” property. This is rarely needed directly, but it
--   is used by new.
constructComboBoxCellArea :: (IsComboBox o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “column-span-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #columnSpanColumn
--   
getComboBoxColumnSpanColumn :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “column-span-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set comboBox [ #columnSpanColumn := value ]
--   
setComboBoxColumnSpanColumn :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “column-span-column” property. This is rarely needed
--   directly, but it is used by new.
constructComboBoxColumnSpanColumn :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “entry-text-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #entryTextColumn
--   
getComboBoxEntryTextColumn :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “entry-text-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set comboBox [ #entryTextColumn := value ]
--   
setComboBoxEntryTextColumn :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “entry-text-column” property. This is rarely needed directly,
--   but it is used by new.
constructComboBoxEntryTextColumn :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “has-entry” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #hasEntry
--   
getComboBoxHasEntry :: (MonadIO m, IsComboBox o) => o -> m Bool

-- | Construct a GValueConstruct with valid value for the
--   “has-entry” property. This is rarely needed directly, but it
--   is used by new.
constructComboBoxHasEntry :: (IsComboBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “has-frame” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #hasFrame
--   
getComboBoxHasFrame :: (MonadIO m, IsComboBox o) => o -> m Bool

-- | Set the value of the “has-frame” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set comboBox [ #hasFrame := value ]
--   
setComboBoxHasFrame :: (MonadIO m, IsComboBox o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-frame” property. This is rarely needed directly, but it
--   is used by new.
constructComboBoxHasFrame :: (IsComboBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “id-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #idColumn
--   
getComboBoxIdColumn :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “id-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set comboBox [ #idColumn := value ]
--   
setComboBoxIdColumn :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “id-column” property. This is rarely needed directly, but it
--   is used by new.
constructComboBoxIdColumn :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #model
--   
getComboBoxModel :: (MonadIO m, IsComboBox o) => o -> m TreeModel

-- | Set the value of the “model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set comboBox [ #model := value ]
--   
setComboBoxModel :: (MonadIO m, IsComboBox o, IsTreeModel a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “model” property. This is rarely needed directly, but it is
--   used by new.
constructComboBoxModel :: (IsComboBox o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “model” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #model
--   
clearComboBoxModel :: (MonadIO m, IsComboBox o) => o -> m ()

-- | Get the value of the “popup-fixed-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #popupFixedWidth
--   
getComboBoxPopupFixedWidth :: (MonadIO m, IsComboBox o) => o -> m Bool

-- | Set the value of the “popup-fixed-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set comboBox [ #popupFixedWidth := value ]
--   
setComboBoxPopupFixedWidth :: (MonadIO m, IsComboBox o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “popup-fixed-width” property. This is rarely needed directly,
--   but it is used by new.
constructComboBoxPopupFixedWidth :: (IsComboBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “popup-shown” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #popupShown
--   
getComboBoxPopupShown :: (MonadIO m, IsComboBox o) => o -> m Bool

-- | Get the value of the “row-span-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #rowSpanColumn
--   
getComboBoxRowSpanColumn :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “row-span-column” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set comboBox [ #rowSpanColumn := value ]
--   
setComboBoxRowSpanColumn :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “row-span-column” property. This is rarely needed directly,
--   but it is used by new.
constructComboBoxRowSpanColumn :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “tearoff-title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #tearoffTitle
--   
getComboBoxTearoffTitle :: (MonadIO m, IsComboBox o) => o -> m (Maybe Text)

-- | Set the value of the “tearoff-title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set comboBox [ #tearoffTitle := value ]
--   
setComboBoxTearoffTitle :: (MonadIO m, IsComboBox o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tearoff-title” property. This is rarely needed directly, but
--   it is used by new.
constructComboBoxTearoffTitle :: (IsComboBox o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “tearoff-title” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #tearoffTitle
--   
clearComboBoxTearoffTitle :: (MonadIO m, IsComboBox o) => o -> m ()

-- | Get the value of the “wrap-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get comboBox #wrapWidth
--   
getComboBoxWrapWidth :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “wrap-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set comboBox [ #wrapWidth := value ]
--   
setComboBoxWrapWidth :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “wrap-width” property. This is rarely needed directly, but it
--   is used by new.
constructComboBoxWrapWidth :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new empty ComboBox.
--   
--   Since: 2.4
comboBoxNew :: (HasCallStack, MonadIO m) => m ComboBox

-- | Creates a new empty ComboBox using area to
--   layout cells.
comboBoxNewWithArea :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m ComboBox

-- | Creates a new empty ComboBox with an entry.
--   
--   The new combo box will use area to layout cells.
comboBoxNewWithAreaAndEntry :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m ComboBox

-- | Creates a new empty ComboBox with an entry.
--   
--   Since: 2.24
comboBoxNewWithEntry :: (HasCallStack, MonadIO m) => m ComboBox

-- | Creates a new ComboBox with the model initialized to
--   model.
--   
--   Since: 2.4
comboBoxNewWithModel :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m ComboBox

-- | Creates a new empty ComboBox with an entry and with the model
--   initialized to model.
--   
--   Since: 2.24
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 gtk_tree_path_get_indices (path)[0], where
--   path is the TreePath of the active item.
--   
--   Since: 2.4
comboBoxGetActive :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Returns the ID of the active row of comboBox. This
--   value is taken from the active row and the column specified by the
--   ComboBox:idColumn property of comboBox (see
--   comboBoxSetIdColumn).
--   
--   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 ComboBox:idColumn property of comboBox
--   is not set, or if no row is active, or if the active row has a
--   Nothing ID value, then Nothing is returned.
--   
--   Since: 3.0
comboBoxGetActiveId :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m (Maybe Text)

-- | Sets iter to point to the currently active item, if
--   any item is active. Otherwise, iter is left unchanged.
--   
--   Since: 2.4
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.
--   
--   Since: 2.14
comboBoxGetButtonSensitivity :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m SensitivityType

-- | Returns the column with column span information for
--   comboBox.
--   
--   Since: 2.6
comboBoxGetColumnSpanColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Returns the column which comboBox is using to get the
--   strings from to display in the internal entry.
--   
--   Since: 2.24
comboBoxGetEntryTextColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Returns whether the combo box grabs focus when it is clicked with the
--   mouse. See comboBoxSetFocusOnClick.
--   
--   Since: 2.6
comboBoxGetFocusOnClick :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Bool

-- | Returns whether the combo box has an entry.
--   
--   Since: 2.24
comboBoxGetHasEntry :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Bool

-- | Returns the column which comboBox is using to get
--   string IDs for values from.
--   
--   Since: 3.0
comboBoxGetIdColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Returns the TreeModel which is acting as data source for
--   comboBox.
--   
--   Since: 2.4
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.
--   
--   Since: 2.6
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.
--   
--   Since: 3.0
comboBoxGetPopupFixedWidth :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Bool

-- | Returns the column with row span information for
--   comboBox.
--   
--   Since: 2.6
comboBoxGetRowSpanColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Gets the current title of the menu in tearoff mode. See
--   comboBoxSetAddTearoffs.
--   
--   Since: 2.10
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.
--   
--   Since: 2.6
comboBoxGetWrapWidth :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Hides the menu or dropdown list of comboBox.
--   
--   This function is mostly intended for use by accessibility
--   technologies; applications should have little use for it.
--   
--   Since: 2.4
comboBoxPopdown :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m ()

-- | Pops up the menu or dropdown list of comboBox.
--   
--   This function is mostly intended for use by accessibility
--   technologies; applications should have little use for it.
--   
--   Before calling this, comboBox must be mapped, or
--   nothing will happen.
--   
--   Since: 2.4
comboBoxPopup :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m ()

-- | Pops up the menu or dropdown list of comboBox, the
--   popup window will be grabbed so only device and its
--   associated pointer/keyboard are the only GdkDevices
--   able to send events to it.
--   
--   Since: 3.0
comboBoxPopupForDevice :: (HasCallStack, MonadIO m, IsComboBox a, IsDevice b) => a -> b -> m ()

-- | Sets the active item of comboBox to be the item at
--   index.
--   
--   Since: 2.4
comboBoxSetActive :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Int32 -> m ()

-- | Changes the active row of comboBox to the one that has
--   an ID equal to activeId, or unsets the active row if
--   activeId is Nothing. Rows having a
--   Nothing ID string cannot be made active by this function.
--   
--   If the ComboBox:idColumn property of comboBox
--   is unset or if no row has the given ID then the function does nothing
--   and returns False.
--   
--   Since: 3.0
comboBoxSetActiveId :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Maybe Text -> m Bool

-- | Sets whether the dropdown button of the combo box should be always
--   sensitive (SensitivityTypeOn), never sensitive
--   (SensitivityTypeOff) or only if there is at least one item to
--   display (SensitivityTypeAuto).
--   
--   Since: 2.14
comboBoxSetButtonSensitivity :: (HasCallStack, MonadIO m, IsComboBox a) => a -> SensitivityType -> m ()

-- | Sets the column with column span information for
--   comboBox to be columnSpan. The column
--   span column contains integers which indicate how many columns an item
--   should span.
--   
--   Since: 2.4
comboBoxSetColumnSpanColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Int32 -> m ()

-- | Sets the model column which comboBox should use to get
--   strings from to be textColumn. The column
--   textColumn in the model of comboBox
--   must be of type G_TYPE_STRING.
--   
--   This is only relevant if comboBox has been created
--   with ComboBox:hasEntry as True.
--   
--   Since: 2.24
comboBoxSetEntryTextColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Int32 -> m ()

-- | Sets the model used by comboBox to be
--   model. Will unset a previously set model (if
--   applicable). If model is Nothing, then it will unset the model.
--   
--   Note that this function does not clear the cell renderers, you have to
--   call cellLayoutClear yourself if you need to set up different
--   cell renderers for the new model.
--   
--   Since: 2.4
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.
--   
--   Since: 3.0
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
--   Nothing, no separators are drawn. This is the default value.
--   
--   Since: 2.6
comboBoxSetRowSeparatorFunc :: (HasCallStack, MonadIO m, IsComboBox a) => a -> TreeViewRowSeparatorFunc -> m ()

-- | Sets the column with row span information for comboBox
--   to be rowSpan. The row span column contains integers
--   which indicate how many rows an item should span.
--   
--   Since: 2.4
comboBoxSetRowSpanColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Int32 -> m ()

-- | Sets the menu’s title in tearoff mode.
--   
--   Since: 2.10
comboBoxSetTitle :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Text -> m ()

-- | Sets the wrap width of comboBox to be
--   width. The wrap width is basically the preferred
--   number of columns when you want the popup to be layed out in a table.
--   
--   Since: 2.4
comboBoxSetWrapWidth :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Int32 -> m ()

-- | Type class for types which can be safely cast to ComboBoxText,
--   for instance with toComboBoxText.
class (GObject o, IsDescendantOf ComboBoxText o) => IsComboBoxText o

-- | Cast to ComboBoxText, for types for which this is known to be
--   safe. For general casts, use castTo.
toComboBoxText :: (MonadIO m, IsComboBoxText o) => o -> m ComboBoxText

-- | Creates a new ComboBoxText, which is a ComboBox just
--   displaying strings.
--   
--   Since: 2.24
comboBoxTextNew :: (HasCallStack, MonadIO m) => m ComboBoxText

-- | Creates a new ComboBoxText, which is a ComboBox just
--   displaying strings. The combo box created by this function has an
--   entry.
--   
--   Since: 2.24
comboBoxTextNewWithEntry :: (HasCallStack, MonadIO m) => m ComboBoxText

-- | Appends text to the list of strings stored in
--   comboBox. If id is non-Nothing
--   then it is used as the ID of the row.
--   
--   This is the same as calling comboBoxTextInsert with a position
--   of -1.
--   
--   Since: 2.24
comboBoxTextAppend :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Maybe Text -> Text -> m ()

-- | Appends text to the list of strings stored in
--   comboBox.
--   
--   This is the same as calling comboBoxTextInsertText with a
--   position of -1.
--   
--   Since: 2.24
comboBoxTextAppendText :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Text -> m ()

-- | Returns the currently active string in comboBox, or
--   Nothing if none is selected. If comboBox
--   contains an entry, this function will return its contents (which will
--   not necessarily be an item from the list).
--   
--   Since: 2.24
comboBoxTextGetActiveText :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> m (Maybe Text)

-- | Prepends text to the list of strings stored in
--   comboBox. If id is non-Nothing
--   then it is used as the ID of the row.
--   
--   This is the same as calling comboBoxTextInsert with a position
--   of 0.
--   
--   Since: 2.24
comboBoxTextPrepend :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Maybe Text -> Text -> m ()

-- | Prepends text to the list of strings stored in
--   comboBox.
--   
--   This is the same as calling comboBoxTextInsertText with a
--   position of 0.
--   
--   Since: 2.24
comboBoxTextPrependText :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Text -> m ()

-- | Removes the string at position from
--   comboBox.
--   
--   Since: 2.24
comboBoxTextRemove :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Int32 -> m ()

-- | Removes all the text entries from the combo box.
--   
--   Since: 3.0
comboBoxTextRemoveAll :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> m ()

-- | Type class for types which can be safely cast to CellView, for
--   instance with toCellView.
class (GObject o, IsDescendantOf CellView o) => IsCellView o

-- | Cast to CellView, for types for which this is known to be safe.
--   For general casts, use castTo.
toCellView :: (MonadIO m, IsCellView o) => o -> m CellView

-- | Set the value of the “background” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellView [ #background := value ]
--   
setCellViewBackground :: (MonadIO m, IsCellView o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background” property. This is rarely needed directly, but it
--   is used by new.
constructCellViewBackground :: (IsCellView o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “background” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #background
--   
clearCellViewBackground :: (MonadIO m, IsCellView o) => o -> m ()

-- | Get the value of the “background-gdk” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellView #backgroundGdk
--   
getCellViewBackgroundGdk :: (MonadIO m, IsCellView o) => o -> m (Maybe Color)

-- | Set the value of the “background-gdk” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellView [ #backgroundGdk := value ]
--   
setCellViewBackgroundGdk :: (MonadIO m, IsCellView o) => o -> Color -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background-gdk” property. This is rarely needed directly,
--   but it is used by new.
constructCellViewBackgroundGdk :: (IsCellView o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Set the value of the “background-gdk” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #backgroundGdk
--   
clearCellViewBackgroundGdk :: (MonadIO m, IsCellView o) => o -> m ()

-- | Get the value of the “background-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellView #backgroundRgba
--   
getCellViewBackgroundRgba :: (MonadIO m, IsCellView o) => o -> m (Maybe RGBA)

-- | Set the value of the “background-rgba” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellView [ #backgroundRgba := value ]
--   
setCellViewBackgroundRgba :: (MonadIO m, IsCellView o) => o -> RGBA -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background-rgba” property. This is rarely needed directly,
--   but it is used by new.
constructCellViewBackgroundRgba :: (IsCellView o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “background-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellView #backgroundSet
--   
getCellViewBackgroundSet :: (MonadIO m, IsCellView o) => o -> m Bool

-- | Set the value of the “background-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellView [ #backgroundSet := value ]
--   
setCellViewBackgroundSet :: (MonadIO m, IsCellView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “background-set” property. This is rarely needed directly,
--   but it is used by new.
constructCellViewBackgroundSet :: (IsCellView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “cell-area” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellView #cellArea
--   
getCellViewCellArea :: (MonadIO m, IsCellView o) => o -> m (Maybe CellArea)

-- | Construct a GValueConstruct with valid value for the
--   “cell-area” property. This is rarely needed directly, but it
--   is used by new.
constructCellViewCellArea :: (IsCellView o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “cell-area-context” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellView #cellAreaContext
--   
getCellViewCellAreaContext :: (MonadIO m, IsCellView o) => o -> m (Maybe CellAreaContext)

-- | Construct a GValueConstruct with valid value for the
--   “cell-area-context” property. This is rarely needed directly,
--   but it is used by new.
constructCellViewCellAreaContext :: (IsCellView o, MonadIO m, IsCellAreaContext a) => a -> m (GValueConstruct o)

-- | Get the value of the “draw-sensitive” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellView #drawSensitive
--   
getCellViewDrawSensitive :: (MonadIO m, IsCellView o) => o -> m Bool

-- | Set the value of the “draw-sensitive” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellView [ #drawSensitive := value ]
--   
setCellViewDrawSensitive :: (MonadIO m, IsCellView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “draw-sensitive” property. This is rarely needed directly,
--   but it is used by new.
constructCellViewDrawSensitive :: (IsCellView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “fit-model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellView #fitModel
--   
getCellViewFitModel :: (MonadIO m, IsCellView o) => o -> m Bool

-- | Set the value of the “fit-model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellView [ #fitModel := value ]
--   
setCellViewFitModel :: (MonadIO m, IsCellView o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “fit-model” property. This is rarely needed directly, but it
--   is used by new.
constructCellViewFitModel :: (IsCellView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellView #model
--   
getCellViewModel :: (MonadIO m, IsCellView o) => o -> m (Maybe TreeModel)

-- | Set the value of the “model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellView [ #model := value ]
--   
setCellViewModel :: (MonadIO m, IsCellView o, IsTreeModel a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “model” property. This is rarely needed directly, but it is
--   used by new.
constructCellViewModel :: (IsCellView o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “model” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #model
--   
clearCellViewModel :: (MonadIO m, IsCellView o) => o -> m ()

-- | Creates a new CellView widget.
--   
--   Since: 2.6
cellViewNew :: (HasCallStack, MonadIO m) => m CellView

-- | Creates a new CellView widget with a specific CellArea
--   to layout cells and a specific CellAreaContext.
--   
--   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.
--   
--   Since: 2.6
cellViewNewWithContext :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b) => a -> b -> m CellView

-- | Creates a new CellView widget, adds a CellRendererText
--   to it, and makes it show markup. The text can be
--   marked up with the [Pango text markup language][PangoMarkupFormat].
--   
--   Since: 2.6
cellViewNewWithMarkup :: (HasCallStack, MonadIO m) => Text -> m CellView

-- | Creates a new CellView widget, adds a CellRendererPixbuf
--   to it, and makes it show pixbuf.
--   
--   Since: 2.6
cellViewNewWithPixbuf :: (HasCallStack, MonadIO m, IsPixbuf a) => a -> m CellView

-- | Creates a new CellView widget, adds a CellRendererText
--   to it, and makes it show text.
--   
--   Since: 2.6
cellViewNewWithText :: (HasCallStack, MonadIO m) => Text -> m CellView

-- | Returns a TreePath referring to the currently displayed row. If
--   no row is currently displayed, Nothing is returned.
--   
--   Since: 2.6
cellViewGetDisplayedRow :: (HasCallStack, MonadIO m, IsCellView a) => a -> m (Maybe TreePath)

-- | Gets whether cellView is configured to draw all of its
--   cells in a sensitive state.
--   
--   Since: 3.0
cellViewGetDrawSensitive :: (HasCallStack, MonadIO m, IsCellView a) => a -> m Bool

-- | Gets whether cellView is configured to request space
--   to fit the entire TreeModel.
--   
--   Since: 3.0
cellViewGetFitModel :: (HasCallStack, MonadIO m, IsCellView a) => a -> m Bool

-- | Returns the model for cellView. If no model is used
--   Nothing is returned.
--   
--   Since: 2.16
cellViewGetModel :: (HasCallStack, MonadIO m, IsCellView a) => a -> m (Maybe TreeModel)

-- | Sets requisition to the size needed by
--   cellView to display the model row pointed to by
--   path.
--   
--   Since: 2.6
cellViewGetSizeOfRow :: (HasCallStack, MonadIO m, IsCellView a) => a -> TreePath -> m (Bool, Requisition)

-- | Sets the background color of view.
--   
--   Since: 2.6
cellViewSetBackgroundColor :: (HasCallStack, MonadIO m, IsCellView a) => a -> Color -> m ()

-- | Sets the background color of cellView.
--   
--   Since: 3.0
cellViewSetBackgroundRgba :: (HasCallStack, MonadIO m, IsCellView a) => a -> RGBA -> m ()

-- | Sets the row of the model that is currently displayed by the
--   CellView. 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 CellView becomes temporarily empty.
--   
--   Since: 2.6
cellViewSetDisplayedRow :: (HasCallStack, MonadIO m, IsCellView a) => a -> Maybe TreePath -> m ()

-- | Sets whether cellView should draw all of its cells in
--   a sensitive state, this is used by ComboBox menus to ensure
--   that rows with insensitive cells that contain children appear
--   sensitive in the parent menu item.
--   
--   Since: 3.0
cellViewSetDrawSensitive :: (HasCallStack, MonadIO m, IsCellView a) => a -> Bool -> m ()

-- | Sets whether cellView should request space to fit the
--   entire TreeModel.
--   
--   This is used by ComboBox to ensure that the cell view displayed
--   on the combo box’s button always gets enough space and does not resize
--   when selection changes.
--   
--   Since: 3.0
cellViewSetFitModel :: (HasCallStack, MonadIO m, IsCellView a) => a -> Bool -> m ()

-- | Sets the model for cellView. If
--   cellView already has a model set, it will remove it
--   before setting the new model. If model is
--   Nothing, then it will unset the old model.
--   
--   Since: 2.6
cellViewSetModel :: (HasCallStack, MonadIO m, IsCellView a, IsTreeModel b) => a -> Maybe b -> m ()

-- | Type class for types which can be safely cast to CellAreaBox,
--   for instance with toCellAreaBox.
class (GObject o, IsDescendantOf CellAreaBox o) => IsCellAreaBox o

-- | Cast to CellAreaBox, for types for which this is known to be
--   safe. For general casts, use castTo.
toCellAreaBox :: (MonadIO m, IsCellAreaBox o) => o -> m CellAreaBox

-- | Get the value of the “spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get cellAreaBox #spacing
--   
getCellAreaBoxSpacing :: (MonadIO m, IsCellAreaBox o) => o -> m Int32

-- | Set the value of the “spacing” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set cellAreaBox [ #spacing := value ]
--   
setCellAreaBoxSpacing :: (MonadIO m, IsCellAreaBox o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “spacing” property. This is rarely needed directly, but it is
--   used by new.
constructCellAreaBoxSpacing :: (IsCellAreaBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new CellAreaBox.
--   
--   Since: 3.0
cellAreaBoxNew :: (HasCallStack, MonadIO m) => m CellAreaBox

-- | Gets the spacing added between cell renderers.
--   
--   Since: 3.0
cellAreaBoxGetSpacing :: (HasCallStack, MonadIO m, IsCellAreaBox a) => a -> m Int32

-- | Adds renderer to box, packed with
--   reference to the end of box.
--   
--   The renderer is packed after (away from end of) any
--   other CellRenderer packed with reference to the end of
--   box.
--   
--   Since: 3.0
cellAreaBoxPackEnd :: (HasCallStack, MonadIO m, IsCellAreaBox a, IsCellRenderer b) => a -> b -> Bool -> Bool -> Bool -> m ()

-- | Adds renderer to box, packed with
--   reference to the start of box.
--   
--   The renderer is packed after any other
--   CellRenderer packed with reference to the start of
--   box.
--   
--   Since: 3.0
cellAreaBoxPackStart :: (HasCallStack, MonadIO m, IsCellAreaBox a, IsCellRenderer b) => a -> b -> Bool -> Bool -> Bool -> m ()

-- | Sets the spacing to add between cell renderers in box.
--   
--   Since: 3.0
cellAreaBoxSetSpacing :: (HasCallStack, MonadIO m, IsCellAreaBox a) => a -> Int32 -> m ()

-- | Type class for types which implement CellAccessibleParent.
class (ManagedPtrNewtype o, IsDescendantOf CellAccessibleParent o) => IsCellAccessibleParent o

-- | Memory-managed wrapper type.
newtype CellAccessibleParent
CellAccessibleParent :: ManagedPtr CellAccessibleParent -> CellAccessibleParent

-- | No description available in the introspection data.
cellAccessibleParentActivate :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m ()

-- | No description available in the introspection data.
cellAccessibleParentEdit :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m ()

-- | No description available in the introspection data.
cellAccessibleParentExpandCollapse :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m ()

-- | No description available in the introspection data.
cellAccessibleParentGetCellArea :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m Rectangle

-- | No description available in the introspection data.
cellAccessibleParentGetCellExtents :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> CoordType -> m (Int32, Int32, Int32, Int32)

-- | No description available in the introspection data.
cellAccessibleParentGetCellPosition :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m (Int32, Int32)

-- | No description available in the introspection data.
cellAccessibleParentGetChildIndex :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m Int32

-- | No description available in the introspection data.
cellAccessibleParentGetColumnHeaderCells :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m [Object]

-- | No description available in the introspection data.
cellAccessibleParentGetRendererState :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m [CellRendererState]

-- | No description available in the introspection data.
cellAccessibleParentGetRowHeaderCells :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m [Object]

-- | No description available in the introspection data.
cellAccessibleParentGrabFocus :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m Bool

-- | No description available in the introspection data.
cellAccessibleParentUpdateRelationset :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b, IsRelationSet c) => a -> b -> c -> m ()

-- | Type class for types which can be safely cast to
--   TreeViewAccessible, for instance with
--   toTreeViewAccessible.
class (GObject o, IsDescendantOf TreeViewAccessible o) => IsTreeViewAccessible o

-- | Memory-managed wrapper type.
newtype TreeViewAccessible
TreeViewAccessible :: ManagedPtr TreeViewAccessible -> TreeViewAccessible

-- | Cast to TreeViewAccessible, for types for which this is known
--   to be safe. For general casts, use castTo.
toTreeViewAccessible :: (MonadIO m, IsTreeViewAccessible o) => o -> m TreeViewAccessible

-- | Type class for types which can be safely cast to AppChooser,
--   for instance with toAppChooser.
class (GObject o, IsDescendantOf AppChooser o) => IsAppChooser o

-- | Cast to AppChooser, for types for which this is known to be
--   safe. For general casts, use castTo.
toAppChooser :: (MonadIO m, IsAppChooser o) => o -> m AppChooser

-- | Get the value of the “content-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get appChooser #contentType
--   
getAppChooserContentType :: (MonadIO m, IsAppChooser o) => o -> m (Maybe Text)

-- | Construct a GValueConstruct with valid value for the
--   “content-type” property. This is rarely needed directly, but
--   it is used by new.
constructAppChooserContentType :: (IsAppChooser o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Returns the currently selected application.
--   
--   Since: 3.0
appChooserGetAppInfo :: (HasCallStack, MonadIO m, IsAppChooser a) => a -> m (Maybe AppInfo)

-- | Returns the current value of the AppChooser:contentType
--   property.
--   
--   Since: 3.0
appChooserGetContentType :: (HasCallStack, MonadIO m, IsAppChooser a) => a -> m Text

-- | Type class for types which can be safely cast to
--   AppChooserDialog, for instance with toAppChooserDialog.
class (GObject o, IsDescendantOf AppChooserDialog o) => IsAppChooserDialog o

-- | Cast to AppChooserDialog, for types for which this is known to
--   be safe. For general casts, use castTo.
toAppChooserDialog :: (MonadIO m, IsAppChooserDialog o) => o -> m AppChooserDialog

-- | Get the value of the “gfile” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get appChooserDialog #gfile
--   
getAppChooserDialogGfile :: (MonadIO m, IsAppChooserDialog o) => o -> m (Maybe File)

-- | Construct a GValueConstruct with valid value for the
--   “gfile” property. This is rarely needed directly, but it is
--   used by new.
constructAppChooserDialogGfile :: (IsAppChooserDialog o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “heading” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get appChooserDialog #heading
--   
getAppChooserDialogHeading :: (MonadIO m, IsAppChooserDialog o) => o -> m (Maybe Text)

-- | Set the value of the “heading” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set appChooserDialog [ #heading := value ]
--   
setAppChooserDialogHeading :: (MonadIO m, IsAppChooserDialog o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “heading” property. This is rarely needed directly, but it is
--   used by new.
constructAppChooserDialogHeading :: (IsAppChooserDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Creates a new AppChooserDialog for the provided File, to
--   allow the user to select an application for it.
--   
--   Since: 3.0
appChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a, IsFile b) => Maybe a -> [DialogFlags] -> b -> m AppChooserDialog

-- | Creates a new AppChooserDialog for the provided content type,
--   to allow the user to select an application for it.
--   
--   Since: 3.0
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 AppChooserWidget of this dialog.
--   
--   Since: 3.0
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 ()

-- | Type class for types which can be safely cast to
--   AppChooserButton, for instance with toAppChooserButton.
class (GObject o, IsDescendantOf AppChooserButton o) => IsAppChooserButton o

-- | Cast to AppChooserButton, for types for which this is known to
--   be safe. For general casts, use castTo.
toAppChooserButton :: (MonadIO m, IsAppChooserButton o) => o -> m AppChooserButton

-- | Emitted when a custom item, previously added with
--   appChooserButtonAppendCustomItem, is activated from the
--   dropdown menu.
type AppChooserButtonCustomItemActivatedCallback = Text -> IO ()

-- | Connect a signal handler for the customItemActivated signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on appChooserButton #customItemActivated callback
--   
--   
--   This signal admits a optional parameter detail. If it's not
--   Nothing, we will connect to
--   “custom-item-activated::detail” instead.
onAppChooserButtonCustomItemActivated :: (IsAppChooserButton a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AppChooserButtonCustomItemActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the customItemActivated signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after appChooserButton #customItemActivated callback
--   
--   
--   This signal admits a optional parameter detail. If it's not
--   Nothing, we will connect to
--   “custom-item-activated::detail” 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
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAppChooserButtonCustomItemActivated :: (IsAppChooserButton a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AppChooserButtonCustomItemActivatedCallback) -> m SignalHandlerId

-- | Get the value of the “heading” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get appChooserButton #heading
--   
getAppChooserButtonHeading :: (MonadIO m, IsAppChooserButton o) => o -> m (Maybe Text)

-- | Set the value of the “heading” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set appChooserButton [ #heading := value ]
--   
setAppChooserButtonHeading :: (MonadIO m, IsAppChooserButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “heading” property. This is rarely needed directly, but it is
--   used by new.
constructAppChooserButtonHeading :: (IsAppChooserButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “show-default-item” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get appChooserButton #showDefaultItem
--   
getAppChooserButtonShowDefaultItem :: (MonadIO m, IsAppChooserButton o) => o -> m Bool

-- | Set the value of the “show-default-item” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set appChooserButton [ #showDefaultItem := value ]
--   
setAppChooserButtonShowDefaultItem :: (MonadIO m, IsAppChooserButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-default-item” property. This is rarely needed directly,
--   but it is used by new.
constructAppChooserButtonShowDefaultItem :: (IsAppChooserButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-dialog-item” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get appChooserButton #showDialogItem
--   
getAppChooserButtonShowDialogItem :: (MonadIO m, IsAppChooserButton o) => o -> m Bool

-- | Set the value of the “show-dialog-item” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set appChooserButton [ #showDialogItem := value ]
--   
setAppChooserButtonShowDialogItem :: (MonadIO m, IsAppChooserButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-dialog-item” property. This is rarely needed directly,
--   but it is used by new.
constructAppChooserButtonShowDialogItem :: (IsAppChooserButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new AppChooserButton for applications that can handle
--   content of the given type.
--   
--   Since: 3.0
appChooserButtonNew :: (HasCallStack, MonadIO m) => Text -> m AppChooserButton

-- | 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
--   AppChooserButton:showDefaultItem property.
--   
--   Since: 3.2
appChooserButtonGetShowDefaultItem :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> m Bool

-- | Returns the current value of the
--   AppChooserButton:showDialogItem property.
--   
--   Since: 3.0
appChooserButtonGetShowDialogItem :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> m Bool

-- | Selects a custom item previously added with
--   appChooserButtonAppendCustomItem.
--   
--   Use appChooserRefresh to bring the selection to its initial
--   state.
--   
--   Since: 3.0
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.
--   
--   Since: 3.2
appChooserButtonSetShowDefaultItem :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> Bool -> m ()

-- | Sets whether the dropdown menu of this button should show an entry to
--   trigger a AppChooserDialog.
--   
--   Since: 3.0
appChooserButtonSetShowDialogItem :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to ToolItem, for
--   instance with toToolItem.
class (GObject o, IsDescendantOf ToolItem o) => IsToolItem o

-- | Cast to ToolItem, for types for which this is known to be safe.
--   For general casts, use castTo.
toToolItem :: (MonadIO m, IsToolItem o) => o -> m ToolItem

-- | This signal is emitted when some property of the toolbar that the item
--   is a child of changes. For custom subclasses of ToolItem, the
--   default handler of this signal use the functions *
--   toolShellGetOrientation * toolShellGetStyle *
--   toolShellGetIconSize * toolShellGetReliefStyle 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
--   toolItem about whether the item should appear in the
--   toolbar overflow menu. In response the tool item should either
--   
--   
--   
- call toolItemSetProxyMenuItem with a Nothing pointer
--   and return True to indicate that the item should not appear in
--   the overflow menu
--   
- call toolItemSetProxyMenuItem with a new menu item and
--   return True, or
--   
- return False 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.
--   
--   
--   The toolbar may cache the result of this signal. When the tool item
--   changes how it will respond to this signal it must call
--   toolItemRebuildMenu to invalidate the cache and ensure that the
--   toolbar rebuilds its overflow menu.
type ToolItemCreateMenuProxyCallback = IO Bool

-- | Connect a signal handler for the createMenuProxy signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on toolItem #createMenuProxy callback
--   
onToolItemCreateMenuProxy :: (IsToolItem a, MonadIO m) => a -> ((?self :: a) => ToolItemCreateMenuProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the createMenuProxy signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after toolItem #createMenuProxy callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterToolItemCreateMenuProxy :: (IsToolItem a, MonadIO m) => a -> ((?self :: a) => ToolItemCreateMenuProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toolbarReconfigured signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on toolItem #toolbarReconfigured callback
--   
onToolItemToolbarReconfigured :: (IsToolItem a, MonadIO m) => a -> ((?self :: a) => ToolItemToolbarReconfiguredCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toolbarReconfigured signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after toolItem #toolbarReconfigured callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterToolItemToolbarReconfigured :: (IsToolItem a, MonadIO m) => a -> ((?self :: a) => ToolItemToolbarReconfiguredCallback) -> m SignalHandlerId

-- | Get the value of the “is-important” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolItem #isImportant
--   
getToolItemIsImportant :: (MonadIO m, IsToolItem o) => o -> m Bool

-- | Set the value of the “is-important” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolItem [ #isImportant := value ]
--   
setToolItemIsImportant :: (MonadIO m, IsToolItem o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “is-important” property. This is rarely needed directly, but
--   it is used by new.
constructToolItemIsImportant :: (IsToolItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “visible-horizontal” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolItem #visibleHorizontal
--   
getToolItemVisibleHorizontal :: (MonadIO m, IsToolItem o) => o -> m Bool

-- | Set the value of the “visible-horizontal” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolItem [ #visibleHorizontal := value ]
--   
setToolItemVisibleHorizontal :: (MonadIO m, IsToolItem o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible-horizontal” property. This is rarely needed
--   directly, but it is used by new.
constructToolItemVisibleHorizontal :: (IsToolItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “visible-vertical” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolItem #visibleVertical
--   
getToolItemVisibleVertical :: (MonadIO m, IsToolItem o) => o -> m Bool

-- | Set the value of the “visible-vertical” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolItem [ #visibleVertical := value ]
--   
setToolItemVisibleVertical :: (MonadIO m, IsToolItem o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible-vertical” property. This is rarely needed directly,
--   but it is used by new.
constructToolItemVisibleVertical :: (IsToolItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new ToolItem
--   
--   Since: 2.4
toolItemNew :: (HasCallStack, MonadIO m) => m ToolItem

-- | Returns whether toolItem is allocated extra space. See
--   toolItemSetExpand.
--   
--   Since: 2.4
toolItemGetExpand :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Bool

-- | Returns whether toolItem is the same size as other
--   homogeneous items. See toolItemSetHomogeneous.
--   
--   Since: 2.4
toolItemGetHomogeneous :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Bool

-- | Returns whether toolItem is considered important. See
--   toolItemSetIsImportant
--   
--   Since: 2.4
toolItemGetIsImportant :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Bool

-- | Returns whether toolItem has a drag window. See
--   toolItemSetUseDragWindow.
--   
--   Since: 2.4
toolItemGetUseDragWindow :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Bool

-- | Returns whether the toolItem is visible on toolbars
--   that are docked horizontally.
--   
--   Since: 2.4
toolItemGetVisibleHorizontal :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Bool

-- | Returns whether toolItem is visible when the toolbar
--   is docked vertically. See toolItemSetVisibleVertical.
--   
--   Since: 2.4
toolItemGetVisibleVertical :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Bool

-- | Returns the MenuItem that was last set by
--   toolItemSetProxyMenuItem, ie. the MenuItem that is going
--   to appear in the overflow menu.
--   
--   Since: 2.4
toolItemRetrieveProxyMenuItem :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Widget

-- | Sets the markup text to be displayed as tooltip on the item. See
--   widgetSetTooltipMarkup.
--   
--   Since: 2.12
toolItemSetTooltipMarkup :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Text -> m ()

-- | Sets whether toolItem is visible when the toolbar is
--   docked horizontally.
--   
--   Since: 2.4
toolItemSetVisibleHorizontal :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Bool -> m ()

-- | Emits the signal ToolItem::toolbar_reconfigured
--   on toolItem. Toolbar and other ToolShell
--   implementations use this function to notify children, when some aspect
--   of their configuration changes.
--   
--   Since: 2.14
toolItemToolbarReconfigured :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m ()

-- | Type class for types which can be safely cast to Toolbar, for
--   instance with toToolbar.
class (GObject o, IsDescendantOf Toolbar o) => IsToolbar o

-- | Cast to Toolbar, for types for which this is known to be safe.
--   For general casts, use castTo.
toToolbar :: (MonadIO m, IsToolbar o) => o -> m Toolbar

-- | 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 x and y.
--   The mouse button number is given by the button
--   parameter. If the menu was popped up using the keybaord,
--   button 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

-- | Connect a signal handler for the focusHomeOrEnd signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on toolbar #focusHomeOrEnd callback
--   
onToolbarFocusHomeOrEnd :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarFocusHomeOrEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the focusHomeOrEnd signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after toolbar #focusHomeOrEnd callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterToolbarFocusHomeOrEnd :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarFocusHomeOrEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the orientationChanged signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on toolbar #orientationChanged callback
--   
onToolbarOrientationChanged :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarOrientationChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the orientationChanged signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after toolbar #orientationChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterToolbarOrientationChanged :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarOrientationChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the popupContextMenu signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on toolbar #popupContextMenu callback
--   
onToolbarPopupContextMenu :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarPopupContextMenuCallback) -> m SignalHandlerId

-- | Connect a signal handler for the popupContextMenu signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after toolbar #popupContextMenu callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterToolbarPopupContextMenu :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarPopupContextMenuCallback) -> m SignalHandlerId

-- | Connect a signal handler for the styleChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on toolbar #styleChanged callback
--   
onToolbarStyleChanged :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarStyleChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the styleChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after toolbar #styleChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterToolbarStyleChanged :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarStyleChangedCallback) -> m SignalHandlerId

-- | Get the value of the “icon-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolbar #iconSize
--   
getToolbarIconSize :: (MonadIO m, IsToolbar o) => o -> m IconSize

-- | Set the value of the “icon-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolbar [ #iconSize := value ]
--   
setToolbarIconSize :: (MonadIO m, IsToolbar o) => o -> IconSize -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-size” property. This is rarely needed directly, but it
--   is used by new.
constructToolbarIconSize :: (IsToolbar o, MonadIO m) => IconSize -> m (GValueConstruct o)

-- | Get the value of the “icon-size-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolbar #iconSizeSet
--   
getToolbarIconSizeSet :: (MonadIO m, IsToolbar o) => o -> m Bool

-- | Set the value of the “icon-size-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolbar [ #iconSizeSet := value ]
--   
setToolbarIconSizeSet :: (MonadIO m, IsToolbar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-size-set” property. This is rarely needed directly, but
--   it is used by new.
constructToolbarIconSizeSet :: (IsToolbar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-arrow” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolbar #showArrow
--   
getToolbarShowArrow :: (MonadIO m, IsToolbar o) => o -> m Bool

-- | Set the value of the “show-arrow” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolbar [ #showArrow := value ]
--   
setToolbarShowArrow :: (MonadIO m, IsToolbar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-arrow” property. This is rarely needed directly, but it
--   is used by new.
constructToolbarShowArrow :: (IsToolbar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “toolbar-style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolbar #toolbarStyle
--   
getToolbarToolbarStyle :: (MonadIO m, IsToolbar o) => o -> m ToolbarStyle

-- | Set the value of the “toolbar-style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolbar [ #toolbarStyle := value ]
--   
setToolbarToolbarStyle :: (MonadIO m, IsToolbar o) => o -> ToolbarStyle -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “toolbar-style” property. This is rarely needed directly, but
--   it is used by new.
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
--   toolbar. This is useful when dragging items to the
--   toolbar: this function returns the position a new item should be
--   inserted.
--   
--   x and y are in toolbar
--   coordinates.
--   
--   Since: 2.4
toolbarGetDropIndex :: (HasCallStack, MonadIO m, IsToolbar a) => a -> Int32 -> Int32 -> m Int32

-- | Retrieves the icon size for the toolbar. See
--   toolbarSetIconSize.
toolbarGetIconSize :: (HasCallStack, MonadIO m, IsToolbar a) => a -> m IconSize

-- | Returns the position of item on the toolbar, starting
--   from 0. It is an error if item is not a child of the
--   toolbar.
--   
--   Since: 2.4
toolbarGetItemIndex :: (HasCallStack, MonadIO m, IsToolbar a, IsToolItem b) => a -> b -> m Int32

-- | Returns the number of items on the toolbar.
--   
--   Since: 2.4
toolbarGetNItems :: (HasCallStack, MonadIO m, IsToolbar a) => a -> m Int32

-- | Returns the n'th item on toolbar, or
--   Nothing if the toolbar does not contain an n'th
--   item.
--   
--   Since: 2.4
toolbarGetNthItem :: (HasCallStack, MonadIO m, IsToolbar a) => a -> Int32 -> m (Maybe ToolItem)

-- | Returns the relief style of buttons on toolbar. See
--   buttonSetRelief.
--   
--   Since: 2.4
toolbarGetReliefStyle :: (HasCallStack, MonadIO m, IsToolbar a) => a -> m ReliefStyle

-- | Returns whether the toolbar has an overflow menu. See
--   toolbarSetShowArrow.
--   
--   Since: 2.4
toolbarGetShowArrow :: (HasCallStack, MonadIO m, IsToolbar a) => a -> m Bool

-- | Retrieves whether the toolbar has text, icons, or both . See
--   toolbarSetStyle.
toolbarGetStyle :: (HasCallStack, MonadIO m, IsToolbar a) => a -> m ToolbarStyle

-- | Insert a ToolItem into the toolbar at position
--   pos. If pos is 0 the item is prepended
--   to the start of the toolbar. If pos is negative, the
--   item is appended to the end of the toolbar.
--   
--   Since: 2.4
toolbarInsert :: (HasCallStack, MonadIO m, IsToolbar a, IsToolItem b) => a -> b -> Int32 -> m ()

-- | Highlights toolbar to give an idea of what it would
--   look like if item was added to toolbar
--   at the position indicated by index_. If
--   item is Nothing, highlighting is turned off. In
--   that case index_ is ignored.
--   
--   The toolItem 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.
--   
--   Since: 2.4
toolbarSetDropHighlightItem :: (HasCallStack, MonadIO m, IsToolbar a, IsToolItem b) => a -> Maybe b -> Int32 -> m ()

-- | Unsets toolbar icon size set with toolbarSetIconSize, 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 toolbarSetStyle, so that user
--   preferences will be used to determine the toolbar style.
toolbarUnsetStyle :: (HasCallStack, MonadIO m, IsToolbar a) => a -> m ()

-- | Type class for types which can be safely cast to ToolItemGroup,
--   for instance with toToolItemGroup.
class (GObject o, IsDescendantOf ToolItemGroup o) => IsToolItemGroup o

-- | Cast to ToolItemGroup, for types for which this is known to be
--   safe. For general casts, use castTo.
toToolItemGroup :: (MonadIO m, IsToolItemGroup o) => o -> m ToolItemGroup

-- | Get the value of the “collapsed” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolItemGroup #collapsed
--   
getToolItemGroupCollapsed :: (MonadIO m, IsToolItemGroup o) => o -> m Bool

-- | Set the value of the “collapsed” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolItemGroup [ #collapsed := value ]
--   
setToolItemGroupCollapsed :: (MonadIO m, IsToolItemGroup o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “collapsed” property. This is rarely needed directly, but it
--   is used by new.
constructToolItemGroupCollapsed :: (IsToolItemGroup o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “ellipsize” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolItemGroup #ellipsize
--   
getToolItemGroupEllipsize :: (MonadIO m, IsToolItemGroup o) => o -> m EllipsizeMode

-- | Set the value of the “ellipsize” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolItemGroup [ #ellipsize := value ]
--   
setToolItemGroupEllipsize :: (MonadIO m, IsToolItemGroup o) => o -> EllipsizeMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “ellipsize” property. This is rarely needed directly, but it
--   is used by new.
constructToolItemGroupEllipsize :: (IsToolItemGroup o, MonadIO m) => EllipsizeMode -> m (GValueConstruct o)

-- | Get the value of the “header-relief” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolItemGroup #headerRelief
--   
getToolItemGroupHeaderRelief :: (MonadIO m, IsToolItemGroup o) => o -> m ReliefStyle

-- | Set the value of the “header-relief” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolItemGroup [ #headerRelief := value ]
--   
setToolItemGroupHeaderRelief :: (MonadIO m, IsToolItemGroup o) => o -> ReliefStyle -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “header-relief” property. This is rarely needed directly, but
--   it is used by new.
constructToolItemGroupHeaderRelief :: (IsToolItemGroup o, MonadIO m) => ReliefStyle -> m (GValueConstruct o)

-- | Get the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolItemGroup #label
--   
getToolItemGroupLabel :: (MonadIO m, IsToolItemGroup o) => o -> m Text

-- | Set the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolItemGroup [ #label := value ]
--   
setToolItemGroupLabel :: (MonadIO m, IsToolItemGroup o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label” property. This is rarely needed directly, but it is
--   used by new.
constructToolItemGroupLabel :: (IsToolItemGroup o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “label-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolItemGroup #labelWidget
--   
getToolItemGroupLabelWidget :: (MonadIO m, IsToolItemGroup o) => o -> m Widget

-- | Set the value of the “label-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolItemGroup [ #labelWidget := value ]
--   
setToolItemGroupLabelWidget :: (MonadIO m, IsToolItemGroup o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label-widget” property. This is rarely needed directly, but
--   it is used by new.
constructToolItemGroupLabelWidget :: (IsToolItemGroup o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Creates a new tool item group with label label.
--   
--   Since: 2.20
toolItemGroupNew :: (HasCallStack, MonadIO m) => Text -> m ToolItemGroup

-- | Gets whether group is collapsed or expanded.
--   
--   Since: 2.20
toolItemGroupGetCollapsed :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> m Bool

-- | Gets the tool item at position (x, y).
--   
--   Since: 2.20
toolItemGroupGetDropItem :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> Int32 -> Int32 -> m ToolItem

-- | Gets the ellipsization mode of group.
--   
--   Since: 2.20
toolItemGroupGetEllipsize :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> m EllipsizeMode

-- | Gets the relief mode of the header button of group.
--   
--   Since: 2.20
toolItemGroupGetHeaderRelief :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> m ReliefStyle

-- | Gets the position of item in group as
--   index.
--   
--   Since: 2.20
toolItemGroupGetItemPosition :: (HasCallStack, MonadIO m, IsToolItemGroup a, IsToolItem b) => a -> b -> m Int32

-- | Gets the label of group.
--   
--   Since: 2.20
toolItemGroupGetLabel :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> m Text

-- | Gets the label widget of group. See
--   toolItemGroupSetLabelWidget.
--   
--   Since: 2.20
toolItemGroupGetLabelWidget :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> m Widget

-- | Gets the number of tool items in group.
--   
--   Since: 2.20
toolItemGroupGetNItems :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> m Word32

-- | Gets the tool item at index in group.
--   
--   Since: 2.20
toolItemGroupGetNthItem :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> Word32 -> m ToolItem

-- | Inserts item at position in the list
--   of children of group.
--   
--   Since: 2.20
toolItemGroupInsert :: (HasCallStack, MonadIO m, IsToolItemGroup a, IsToolItem b) => a -> b -> Int32 -> m ()

-- | Sets whether the group should be collapsed or
--   expanded.
--   
--   Since: 2.20
toolItemGroupSetCollapsed :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> Bool -> m ()

-- | Sets the ellipsization mode which should be used by labels in
--   group.
--   
--   Since: 2.20
toolItemGroupSetEllipsize :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> EllipsizeMode -> m ()

-- | Set the button relief of the group header. See buttonSetRelief
--   for details.
--   
--   Since: 2.20
toolItemGroupSetHeaderRelief :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> ReliefStyle -> m ()

-- | Sets the position of item in the list of children of
--   group.
--   
--   Since: 2.20
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.
--   
--   Since: 2.20
toolItemGroupSetLabel :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> Text -> m ()

-- | Type class for types which can be safely cast to ToolPalette,
--   for instance with toToolPalette.
class (GObject o, IsDescendantOf ToolPalette o) => IsToolPalette o

-- | Cast to ToolPalette, for types for which this is known to be
--   safe. For general casts, use castTo.
toToolPalette :: (MonadIO m, IsToolPalette o) => o -> m ToolPalette

-- | Get the value of the “icon-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolPalette #iconSize
--   
getToolPaletteIconSize :: (MonadIO m, IsToolPalette o) => o -> m IconSize

-- | Set the value of the “icon-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolPalette [ #iconSize := value ]
--   
setToolPaletteIconSize :: (MonadIO m, IsToolPalette o) => o -> IconSize -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-size” property. This is rarely needed directly, but it
--   is used by new.
constructToolPaletteIconSize :: (IsToolPalette o, MonadIO m) => IconSize -> m (GValueConstruct o)

-- | Get the value of the “icon-size-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolPalette #iconSizeSet
--   
getToolPaletteIconSizeSet :: (MonadIO m, IsToolPalette o) => o -> m Bool

-- | Set the value of the “icon-size-set” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolPalette [ #iconSizeSet := value ]
--   
setToolPaletteIconSizeSet :: (MonadIO m, IsToolPalette o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-size-set” property. This is rarely needed directly, but
--   it is used by new.
constructToolPaletteIconSizeSet :: (IsToolPalette o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “toolbar-style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolPalette #toolbarStyle
--   
getToolPaletteToolbarStyle :: (MonadIO m, IsToolPalette o) => o -> m ToolbarStyle

-- | Set the value of the “toolbar-style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolPalette [ #toolbarStyle := value ]
--   
setToolPaletteToolbarStyle :: (MonadIO m, IsToolPalette o) => o -> ToolbarStyle -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “toolbar-style” property. This is rarely needed directly, but
--   it is used by new.
constructToolPaletteToolbarStyle :: (IsToolPalette o, MonadIO m) => ToolbarStyle -> m (GValueConstruct o)

-- | Creates a new tool palette.
--   
--   Since: 2.20
toolPaletteNew :: (HasCallStack, MonadIO m) => m ToolPalette

-- | Sets palette as drag source (see
--   toolPaletteSetDragSource) and sets widget as a
--   drag destination for drags from palette. See
--   widgetDragDestSet.
--   
--   Since: 2.20
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
--   ToolItem or a ToolItemGroup.
--   
--   Since: 2.20
toolPaletteGetDragItem :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> SelectionData -> m Widget

-- | Gets the item at position (x, y). See toolPaletteGetDropGroup.
--   
--   Since: 2.20
toolPaletteGetDropItem :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> Int32 -> Int32 -> m (Maybe ToolItem)

-- | Gets whether group is exclusive or not. See
--   toolPaletteSetExclusive.
--   
--   Since: 2.20
toolPaletteGetExclusive :: (HasCallStack, MonadIO m, IsToolPalette a, IsToolItemGroup b) => a -> b -> m Bool

-- | Gets whether group should be given extra space. See
--   toolPaletteSetExpand.
--   
--   Since: 2.20
toolPaletteGetExpand :: (HasCallStack, MonadIO m, IsToolPalette a, IsToolItemGroup b) => a -> b -> m Bool

-- | Gets the position of group in palette
--   as index. See toolPaletteSetGroupPosition.
--   
--   Since: 2.20
toolPaletteGetGroupPosition :: (HasCallStack, MonadIO m, IsToolPalette a, IsToolItemGroup b) => a -> b -> m Int32

-- | Gets the horizontal adjustment of the tool palette.
--   
--   Since: 2.20
toolPaletteGetHadjustment :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> m Adjustment

-- | Gets the size of icons in the tool palette. See
--   toolPaletteSetIconSize.
--   
--   Since: 2.20
toolPaletteGetIconSize :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> m Int32

-- | Gets the style (icons, text or both) of items in the tool palette.
--   
--   Since: 2.20
toolPaletteGetStyle :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> m ToolbarStyle

-- | Gets the vertical adjustment of the tool palette.
--   
--   Since: 2.20
toolPaletteGetVadjustment :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> m Adjustment

-- | Unsets the tool palette icon size set with
--   toolPaletteSetIconSize, so that user preferences will be used
--   to determine the icon size.
--   
--   Since: 2.20
toolPaletteUnsetIconSize :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> m ()

-- | Unsets a toolbar style set with toolPaletteSetStyle, so that
--   user preferences will be used to determine the toolbar style.
--   
--   Since: 2.20
toolPaletteUnsetStyle :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> m ()

-- | Get the target entry for a dragged ToolItemGroup.
--   
--   Since: 2.20
toolPaletteGetDragTargetGroup :: (HasCallStack, MonadIO m) => m TargetEntry

-- | Gets the target entry for a dragged ToolItem.
--   
--   Since: 2.20
toolPaletteGetDragTargetItem :: (HasCallStack, MonadIO m) => m TargetEntry

-- | Type class for types which can be safely cast to
--   SeparatorToolItem, for instance with
--   toSeparatorToolItem.
class (GObject o, IsDescendantOf SeparatorToolItem o) => IsSeparatorToolItem o

-- | Cast to SeparatorToolItem, for types for which this is known to
--   be safe. For general casts, use castTo.
toSeparatorToolItem :: (MonadIO m, IsSeparatorToolItem o) => o -> m SeparatorToolItem

-- | Get the value of the “draw” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get separatorToolItem #draw
--   
getSeparatorToolItemDraw :: (MonadIO m, IsSeparatorToolItem o) => o -> m Bool

-- | Set the value of the “draw” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set separatorToolItem [ #draw := value ]
--   
setSeparatorToolItemDraw :: (MonadIO m, IsSeparatorToolItem o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “draw” property. This is rarely needed directly, but it is
--   used by new.
constructSeparatorToolItemDraw :: (IsSeparatorToolItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Create a new SeparatorToolItem
--   
--   Since: 2.4
separatorToolItemNew :: (HasCallStack, MonadIO m) => m SeparatorToolItem

-- | Returns whether item is drawn as a line, or just
--   blank. See separatorToolItemSetDraw.
--   
--   Since: 2.4
separatorToolItemGetDraw :: (HasCallStack, MonadIO m, IsSeparatorToolItem a) => a -> m Bool

-- | Type class for types which can be safely cast to ToolButton,
--   for instance with toToolButton.
class (GObject o, IsDescendantOf ToolButton o) => IsToolButton o

-- | Cast to ToolButton, for types for which this is known to be
--   safe. For general casts, use castTo.
toToolButton :: (MonadIO m, IsToolButton o) => o -> m ToolButton

-- | This signal is emitted when the tool button is clicked with the mouse
--   or activated with the keyboard.
type ToolButtonClickedCallback = IO ()

-- | Connect a signal handler for the clicked signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on toolButton #clicked callback
--   
onToolButtonClicked :: (IsToolButton a, MonadIO m) => a -> ((?self :: a) => ToolButtonClickedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the clicked signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after toolButton #clicked callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterToolButtonClicked :: (IsToolButton a, MonadIO m) => a -> ((?self :: a) => ToolButtonClickedCallback) -> m SignalHandlerId

-- | Get the value of the “icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolButton #iconName
--   
getToolButtonIconName :: (MonadIO m, IsToolButton o) => o -> m (Maybe Text)

-- | Set the value of the “icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolButton [ #iconName := value ]
--   
setToolButtonIconName :: (MonadIO m, IsToolButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-name” property. This is rarely needed directly, but it
--   is used by new.
constructToolButtonIconName :: (IsToolButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “icon-name” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #iconName
--   
clearToolButtonIconName :: (MonadIO m, IsToolButton o) => o -> m ()

-- | Get the value of the “icon-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolButton #iconWidget
--   
getToolButtonIconWidget :: (MonadIO m, IsToolButton o) => o -> m (Maybe Widget)

-- | Set the value of the “icon-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolButton [ #iconWidget := value ]
--   
setToolButtonIconWidget :: (MonadIO m, IsToolButton o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-widget” property. This is rarely needed directly, but
--   it is used by new.
constructToolButtonIconWidget :: (IsToolButton o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “icon-widget” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #iconWidget
--   
clearToolButtonIconWidget :: (MonadIO m, IsToolButton o) => o -> m ()

-- | Get the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolButton #label
--   
getToolButtonLabel :: (MonadIO m, IsToolButton o) => o -> m (Maybe Text)

-- | Set the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolButton [ #label := value ]
--   
setToolButtonLabel :: (MonadIO m, IsToolButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label” property. This is rarely needed directly, but it is
--   used by new.
constructToolButtonLabel :: (IsToolButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “label” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #label
--   
clearToolButtonLabel :: (MonadIO m, IsToolButton o) => o -> m ()

-- | Get the value of the “label-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolButton #labelWidget
--   
getToolButtonLabelWidget :: (MonadIO m, IsToolButton o) => o -> m (Maybe Widget)

-- | Set the value of the “label-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolButton [ #labelWidget := value ]
--   
setToolButtonLabelWidget :: (MonadIO m, IsToolButton o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label-widget” property. This is rarely needed directly, but
--   it is used by new.
constructToolButtonLabelWidget :: (IsToolButton o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “label-widget” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #labelWidget
--   
clearToolButtonLabelWidget :: (MonadIO m, IsToolButton o) => o -> m ()

-- | Get the value of the “stock-id” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolButton #stockId
--   
getToolButtonStockId :: (MonadIO m, IsToolButton o) => o -> m Text

-- | Set the value of the “stock-id” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolButton [ #stockId := value ]
--   
setToolButtonStockId :: (MonadIO m, IsToolButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “stock-id” property. This is rarely needed directly, but it
--   is used by new.
constructToolButtonStockId :: (IsToolButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “stock-id” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #stockId
--   
clearToolButtonStockId :: (MonadIO m, IsToolButton o) => o -> m ()

-- | Get the value of the “use-underline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toolButton #useUnderline
--   
getToolButtonUseUnderline :: (MonadIO m, IsToolButton o) => o -> m Bool

-- | Set the value of the “use-underline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toolButton [ #useUnderline := value ]
--   
setToolButtonUseUnderline :: (MonadIO m, IsToolButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-underline” property. This is rarely needed directly, but
--   it is used by new.
constructToolButtonUseUnderline :: (IsToolButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new ToolButton using iconWidget as
--   contents and label as label.
--   
--   Since: 2.4
toolButtonNew :: (HasCallStack, MonadIO m, IsWidget a) => Maybe a -> Maybe Text -> m ToolButton

-- | Returns the name of the themed icon for the tool button, see
--   toolButtonSetIconName.
--   
--   Since: 2.8
toolButtonGetIconName :: (HasCallStack, MonadIO m, IsToolButton a) => a -> m (Maybe Text)

-- | Return the widget used as icon widget on button. See
--   toolButtonSetIconWidget.
--   
--   Since: 2.4
toolButtonGetIconWidget :: (HasCallStack, MonadIO m, IsToolButton a) => a -> m (Maybe Widget)

-- | Returns the label used by the tool button, or Nothing 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.
--   
--   Since: 2.4
toolButtonGetLabel :: (HasCallStack, MonadIO m, IsToolButton a) => a -> m (Maybe Text)

-- | Returns the widget used as label on button. See
--   toolButtonSetLabelWidget.
--   
--   Since: 2.4
toolButtonGetLabelWidget :: (HasCallStack, MonadIO m, IsToolButton a) => a -> m (Maybe Widget)

-- | Returns the name of the stock item. See toolButtonSetStockId.
--   The returned string is owned by GTK+ and must not be freed or modifed.
--   
--   Since: 2.4
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
--   toolButtonSetUseUnderline.
--   
--   Since: 2.4
toolButtonGetUseUnderline :: (HasCallStack, MonadIO m, IsToolButton a) => a -> m Bool

-- | Sets label as the label used for the tool button. The
--   ToolButton:label property only has an effect if not overridden
--   by a non-Nothing ToolButton:labelWidget property. If
--   both the ToolButton:labelWidget and ToolButton:label
--   properties are Nothing, the label is determined by the
--   ToolButton:stockId property. If the ToolButton:stockId
--   property is also Nothing, button will not have
--   a label.
--   
--   Since: 2.4
toolButtonSetLabel :: (HasCallStack, MonadIO m, IsToolButton a) => a -> Maybe Text -> m ()

-- | Type class for types which can be safely cast to
--   ToggleToolButton, for instance with toToggleToolButton.
class (GObject o, IsDescendantOf ToggleToolButton o) => IsToggleToolButton o

-- | Cast to ToggleToolButton, for types for which this is known to
--   be safe. For general casts, use castTo.
toToggleToolButton :: (MonadIO m, IsToggleToolButton o) => o -> m ToggleToolButton

-- | Emitted whenever the toggle tool button changes state.
type ToggleToolButtonToggledCallback = IO ()

-- | Connect a signal handler for the toggled signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on toggleToolButton #toggled callback
--   
onToggleToolButtonToggled :: (IsToggleToolButton a, MonadIO m) => a -> ((?self :: a) => ToggleToolButtonToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggled signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after toggleToolButton #toggled callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterToggleToolButtonToggled :: (IsToggleToolButton a, MonadIO m) => a -> ((?self :: a) => ToggleToolButtonToggledCallback) -> m SignalHandlerId

-- | Get the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toggleToolButton #active
--   
getToggleToolButtonActive :: (MonadIO m, IsToggleToolButton o) => o -> m Bool

-- | Set the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toggleToolButton [ #active := value ]
--   
setToggleToolButtonActive :: (MonadIO m, IsToggleToolButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “active” property. This is rarely needed directly, but it is
--   used by new.
constructToggleToolButtonActive :: (IsToggleToolButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Returns a new ToggleToolButton
--   
--   Since: 2.4
toggleToolButtonNew :: (HasCallStack, MonadIO m) => m ToggleToolButton

-- | Creates a new ToggleToolButton containing the image and text
--   from a stock item. Some stock ids have preprocessor macros like
--   STOCK_OK and STOCK_APPLY.
--   
--   It is an error if stockId is not a name of a stock
--   item.
--   
--   Since: 2.4
toggleToolButtonNewFromStock :: (HasCallStack, MonadIO m) => Text -> m ToggleToolButton

-- | Queries a ToggleToolButton and returns its current state.
--   Returns True if the toggle button is pressed in and
--   False if it is raised.
--   
--   Since: 2.4
toggleToolButtonGetActive :: (HasCallStack, MonadIO m, IsToggleToolButton a) => a -> m Bool

-- | Sets the status of the toggle tool button. Set to True if you
--   want the GtkToggleButton to be “pressed in”, and False to raise
--   it. This action causes the toggled signal to be emitted.
--   
--   Since: 2.4
toggleToolButtonSetActive :: (HasCallStack, MonadIO m, IsToggleToolButton a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to Switch, for
--   instance with toSwitch.
class (GObject o, IsDescendantOf Switch o) => IsSwitch o

-- | Cast to Switch, for types for which this is known to be safe.
--   For general casts, use castTo.
toSwitch :: (MonadIO m, IsSwitch o) => o -> m Switch

-- | The stateSet 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
--   Switch:active property.
--   
--   To implement delayed state change, applications can connect to this
--   signal, initiate the change of the underlying state, and call
--   switchSetState when the underlying state change is complete.
--   The signal handler should return True to prevent the default
--   handler from running.
--   
--   Visually, the underlying state is represented by the trough color of
--   the switch, while the Switch:active property is represented by
--   the position of the switch.
--   
--   Since: 3.14
type SwitchStateSetCallback = Bool -> IO Bool

-- | The activate 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 notifyactive signal.
type SwitchActivateCallback = IO ()

-- | Connect a signal handler for the activate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on switch #activate callback
--   
onSwitchActivate :: (IsSwitch a, MonadIO m) => a -> ((?self :: a) => SwitchActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after switch #activate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterSwitchActivate :: (IsSwitch a, MonadIO m) => a -> ((?self :: a) => SwitchActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the stateSet signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on switch #stateSet callback
--   
onSwitchStateSet :: (IsSwitch a, MonadIO m) => a -> ((?self :: a) => SwitchStateSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the stateSet signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after switch #stateSet callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterSwitchStateSet :: (IsSwitch a, MonadIO m) => a -> ((?self :: a) => SwitchStateSetCallback) -> m SignalHandlerId

-- | Get the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get switch #active
--   
getSwitchActive :: (MonadIO m, IsSwitch o) => o -> m Bool

-- | Set the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set switch [ #active := value ]
--   
setSwitchActive :: (MonadIO m, IsSwitch o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “active” property. This is rarely needed directly, but it is
--   used by new.
constructSwitchActive :: (IsSwitch o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “state” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get switch #state
--   
getSwitchState :: (MonadIO m, IsSwitch o) => o -> m Bool

-- | Set the value of the “state” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set switch [ #state := value ]
--   
setSwitchState :: (MonadIO m, IsSwitch o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “state” property. This is rarely needed directly, but it is
--   used by new.
constructSwitchState :: (IsSwitch o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new Switch widget.
--   
--   Since: 3.0
switchNew :: (HasCallStack, MonadIO m) => m Switch

-- | Gets whether the Switch is in its “on” or “off” state.
--   
--   Since: 3.0
switchGetActive :: (HasCallStack, MonadIO m, IsSwitch a) => a -> m Bool

-- | Gets the underlying state of the Switch.
--   
--   Since: 3.14
switchGetState :: (HasCallStack, MonadIO m, IsSwitch a) => a -> m Bool

-- | Changes the state of sw to the desired one.
--   
--   Since: 3.0
switchSetActive :: (HasCallStack, MonadIO m, IsSwitch a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to
--   TearoffMenuItem, for instance with toTearoffMenuItem.
class (GObject o, IsDescendantOf TearoffMenuItem o) => IsTearoffMenuItem o

-- | Cast to TearoffMenuItem, for types for which this is known to
--   be safe. For general casts, use castTo.
toTearoffMenuItem :: (MonadIO m, IsTearoffMenuItem o) => o -> m TearoffMenuItem

-- | Creates a new TearoffMenuItem.
tearoffMenuItemNew :: (HasCallStack, MonadIO m) => m TearoffMenuItem

-- | Type class for types which can be safely cast to StatusIcon,
--   for instance with toStatusIcon.
class (GObject o, IsDescendantOf StatusIcon o) => IsStatusIcon o

-- | Cast to StatusIcon, for types for which this is known to be
--   safe. For general casts, use castTo.
toStatusIcon :: (MonadIO m, IsStatusIcon o) => o -> m StatusIcon

-- | Gets emitted when the size available for the image changes, e.g.
--   because the notification area got resized.
--   
--   Since: 2.10
type StatusIconSizeChangedCallback = Int32 -> IO Bool

-- | The scrollEvent 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.
--   
--   Since: 2.16
type StatusIconScrollEventCallback = EventScroll -> IO Bool

-- | Emitted when the hover timeout has expired with the cursor hovering
--   above statusIcon; or emitted when
--   statusIcon got focus in keyboard mode.
--   
--   Using the given coordinates, the signal handler should determine
--   whether a tooltip should be shown for statusIcon. If
--   this is the case True should be returned, False
--   otherwise. Note that if keyboardMode is True,
--   the values of x and y are undefined
--   and should not be used.
--   
--   The signal handler is free to manipulate tooltip with
--   the therefore destined function calls.
--   
--   Whether this signal is emitted is platform-dependent. For plain text
--   tooltips, use StatusIcon:tooltipText in preference.
--   
--   Since: 2.16
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 button and activateTime parameters
--   should be passed as the last to arguments to menuPopup.
--   
--   Unlike most G_SIGNAL_ACTION signals, this signal is meant to be used
--   by applications and should be wrapped by language bindings.
--   
--   Since: 2.10
type StatusIconPopupMenuCallback = Word32 -> Word32 -> IO ()

-- | The buttonReleaseEvent signal will be emitted when a button
--   (typically from a mouse) is released.
--   
--   Whether this event is emitted is platform-dependent. Use the
--   activate and popupMenu signals in preference.
--   
--   Since: 2.14
type StatusIconButtonReleaseEventCallback = EventButton -> IO Bool

-- | The buttonPressEvent signal will be emitted when a button
--   (typically from a mouse) is pressed.
--   
--   Whether this event is emitted is platform-dependent. Use the
--   activate and popupMenu signals in preference.
--   
--   Since: 2.14
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.
--   
--   Since: 2.10
type StatusIconActivateCallback = IO ()

-- | Connect a signal handler for the activate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on statusIcon #activate callback
--   
onStatusIconActivate :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after statusIcon #activate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterStatusIconActivate :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the buttonPressEvent signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on statusIcon #buttonPressEvent callback
--   
onStatusIconButtonPressEvent :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconButtonPressEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the buttonPressEvent signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after statusIcon #buttonPressEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterStatusIconButtonPressEvent :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconButtonPressEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the buttonReleaseEvent signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on statusIcon #buttonReleaseEvent callback
--   
onStatusIconButtonReleaseEvent :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconButtonReleaseEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the buttonReleaseEvent signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after statusIcon #buttonReleaseEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterStatusIconButtonReleaseEvent :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconButtonReleaseEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the popupMenu signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on statusIcon #popupMenu callback
--   
onStatusIconPopupMenu :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconPopupMenuCallback) -> m SignalHandlerId

-- | Connect a signal handler for the popupMenu signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after statusIcon #popupMenu callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterStatusIconPopupMenu :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconPopupMenuCallback) -> m SignalHandlerId

-- | Connect a signal handler for the queryTooltip signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on statusIcon #queryTooltip callback
--   
onStatusIconQueryTooltip :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconQueryTooltipCallback) -> m SignalHandlerId

-- | Connect a signal handler for the queryTooltip signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after statusIcon #queryTooltip callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterStatusIconQueryTooltip :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconQueryTooltipCallback) -> m SignalHandlerId

-- | Connect a signal handler for the scrollEvent signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on statusIcon #scrollEvent callback
--   
onStatusIconScrollEvent :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconScrollEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the scrollEvent signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after statusIcon #scrollEvent callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterStatusIconScrollEvent :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconScrollEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the sizeChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on statusIcon #sizeChanged callback
--   
onStatusIconSizeChanged :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconSizeChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the sizeChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after statusIcon #sizeChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterStatusIconSizeChanged :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconSizeChangedCallback) -> m SignalHandlerId

-- | Get the value of the “embedded” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get statusIcon #embedded
--   
getStatusIconEmbedded :: (MonadIO m, IsStatusIcon o) => o -> m Bool

-- | Set the value of the “file” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set statusIcon [ #file := value ]
--   
setStatusIconFile :: (MonadIO m, IsStatusIcon o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “file” property. This is rarely needed directly, but it is
--   used by new.
constructStatusIconFile :: (IsStatusIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “file” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #file
--   
clearStatusIconFile :: (MonadIO m, IsStatusIcon o) => o -> m ()

-- | Get the value of the “gicon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get statusIcon #gicon
--   
getStatusIconGicon :: (MonadIO m, IsStatusIcon o) => o -> m (Maybe Icon)

-- | Set the value of the “gicon” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set statusIcon [ #gicon := value ]
--   
setStatusIconGicon :: (MonadIO m, IsStatusIcon o, IsIcon a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “gicon” property. This is rarely needed directly, but it is
--   used by new.
constructStatusIconGicon :: (IsStatusIcon o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “gicon” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #gicon
--   
clearStatusIconGicon :: (MonadIO m, IsStatusIcon o) => o -> m ()

-- | Get the value of the “has-tooltip” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get statusIcon #hasTooltip
--   
getStatusIconHasTooltip :: (MonadIO m, IsStatusIcon o) => o -> m Bool

-- | Set the value of the “has-tooltip” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set statusIcon [ #hasTooltip := value ]
--   
setStatusIconHasTooltip :: (MonadIO m, IsStatusIcon o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “has-tooltip” property. This is rarely needed directly, but
--   it is used by new.
constructStatusIconHasTooltip :: (IsStatusIcon o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get statusIcon #iconName
--   
getStatusIconIconName :: (MonadIO m, IsStatusIcon o) => o -> m (Maybe Text)

-- | Set the value of the “icon-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set statusIcon [ #iconName := value ]
--   
setStatusIconIconName :: (MonadIO m, IsStatusIcon o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon-name” property. This is rarely needed directly, but it
--   is used by new.
constructStatusIconIconName :: (IsStatusIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “icon-name” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #iconName
--   
clearStatusIconIconName :: (MonadIO m, IsStatusIcon o) => o -> m ()

-- | Get the value of the “orientation” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get statusIcon #orientation
--   
getStatusIconOrientation :: (MonadIO m, IsStatusIcon o) => o -> m Orientation

-- | Get the value of the “pixbuf” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get statusIcon #pixbuf
--   
getStatusIconPixbuf :: (MonadIO m, IsStatusIcon o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “pixbuf” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set statusIcon [ #pixbuf := value ]
--   
setStatusIconPixbuf :: (MonadIO m, IsStatusIcon o, IsPixbuf a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pixbuf” property. This is rarely needed directly, but it is
--   used by new.
constructStatusIconPixbuf :: (IsStatusIcon o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “pixbuf” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #pixbuf
--   
clearStatusIconPixbuf :: (MonadIO m, IsStatusIcon o) => o -> m ()

-- | Get the value of the “screen” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get statusIcon #screen
--   
getStatusIconScreen :: (MonadIO m, IsStatusIcon o) => o -> m Screen

-- | Set the value of the “screen” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set statusIcon [ #screen := value ]
--   
setStatusIconScreen :: (MonadIO m, IsStatusIcon o, IsScreen a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “screen” property. This is rarely needed directly, but it is
--   used by new.
constructStatusIconScreen :: (IsStatusIcon o, MonadIO m, IsScreen a) => a -> m (GValueConstruct o)

-- | Get the value of the “size” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get statusIcon #size
--   
getStatusIconSize :: (MonadIO m, IsStatusIcon o) => o -> m Int32

-- | Get the value of the “stock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get statusIcon #stock
--   
getStatusIconStock :: (MonadIO m, IsStatusIcon o) => o -> m (Maybe Text)

-- | Set the value of the “stock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set statusIcon [ #stock := value ]
--   
setStatusIconStock :: (MonadIO m, IsStatusIcon o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “stock” property. This is rarely needed directly, but it is
--   used by new.
constructStatusIconStock :: (IsStatusIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “stock” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #stock
--   
clearStatusIconStock :: (MonadIO m, IsStatusIcon o) => o -> m ()

-- | Get the value of the “storage-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get statusIcon #storageType
--   
getStatusIconStorageType :: (MonadIO m, IsStatusIcon o) => o -> m ImageType

-- | Get the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get statusIcon #title
--   
getStatusIconTitle :: (MonadIO m, IsStatusIcon o) => o -> m Text

-- | Set the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set statusIcon [ #title := value ]
--   
setStatusIconTitle :: (MonadIO m, IsStatusIcon o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “title” property. This is rarely needed directly, but it is
--   used by new.
constructStatusIconTitle :: (IsStatusIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “tooltip-markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get statusIcon #tooltipMarkup
--   
getStatusIconTooltipMarkup :: (MonadIO m, IsStatusIcon o) => o -> m (Maybe Text)

-- | Set the value of the “tooltip-markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set statusIcon [ #tooltipMarkup := value ]
--   
setStatusIconTooltipMarkup :: (MonadIO m, IsStatusIcon o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tooltip-markup” property. This is rarely needed directly,
--   but it is used by new.
constructStatusIconTooltipMarkup :: (IsStatusIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “tooltip-markup” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #tooltipMarkup
--   
clearStatusIconTooltipMarkup :: (MonadIO m, IsStatusIcon o) => o -> m ()

-- | Get the value of the “tooltip-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get statusIcon #tooltipText
--   
getStatusIconTooltipText :: (MonadIO m, IsStatusIcon o) => o -> m (Maybe Text)

-- | Set the value of the “tooltip-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set statusIcon [ #tooltipText := value ]
--   
setStatusIconTooltipText :: (MonadIO m, IsStatusIcon o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tooltip-text” property. This is rarely needed directly, but
--   it is used by new.
constructStatusIconTooltipText :: (IsStatusIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get statusIcon #visible
--   
getStatusIconVisible :: (MonadIO m, IsStatusIcon o) => o -> m Bool

-- | Set the value of the “visible” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set statusIcon [ #visible := value ]
--   
setStatusIconVisible :: (MonadIO m, IsStatusIcon o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visible” property. This is rarely needed directly, but it is
--   used by new.
constructStatusIconVisible :: (IsStatusIcon o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates an empty status icon object.
--   
--   Since: 2.10
statusIconNew :: (HasCallStack, MonadIO m) => 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 statusIconPositionMenu 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 statusIconIsEmbedded.
--   
--   Since: 2.10
statusIconGetGeometry :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m (Bool, Screen, Rectangle, Orientation)

-- | Retrieves the Icon being displayed by the StatusIcon.
--   The storage type of the status icon must be ImageTypeEmpty or
--   ImageTypeGicon (see statusIconGetStorageType). The
--   caller of this function does not own a reference to the returned
--   Icon.
--   
--   If this function fails, icon is left unchanged;
--   
--   Since: 2.14
statusIconGetGicon :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m (Maybe Icon)

-- | Returns the current value of the has-tooltip property. See
--   StatusIcon:hasTooltip for more information.
--   
--   Since: 2.16
statusIconGetHasTooltip :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m Bool

-- | Gets the name of the icon being displayed by the StatusIcon.
--   The storage type of the status icon must be ImageTypeEmpty or
--   ImageTypeIconName (see statusIconGetStorageType). The
--   returned string is owned by the StatusIcon and should not be
--   freed or modified.
--   
--   Since: 2.10
statusIconGetIconName :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m (Maybe Text)

-- | Gets the Pixbuf being displayed by the StatusIcon. The
--   storage type of the status icon must be ImageTypeEmpty or
--   ImageTypePixbuf (see statusIconGetStorageType). The
--   caller of this function does not own a reference to the returned
--   pixbuf.
--   
--   Since: 2.10
statusIconGetPixbuf :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m (Maybe Pixbuf)

-- | Returns the Screen associated with statusIcon.
--   
--   Since: 2.12
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 statusIconIsEmbedded).
--   
--   Since: 2.10
statusIconGetSize :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m Int32

-- | Gets the id of the stock icon being displayed by the
--   StatusIcon. The storage type of the status icon must be
--   ImageTypeEmpty or ImageTypeStock (see
--   statusIconGetStorageType). The returned string is owned by the
--   StatusIcon and should not be freed or modified.
--   
--   Since: 2.10
statusIconGetStock :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m (Maybe Text)

-- | Gets the title of this tray icon. See statusIconSetTitle.
--   
--   Since: 2.18
statusIconGetTitle :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m Text

-- | Gets the contents of the tooltip for statusIcon.
--   
--   Since: 2.16
statusIconGetTooltipMarkup :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m (Maybe Text)

-- | Gets the contents of the tooltip for statusIcon.
--   
--   Since: 2.16
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 statusIconIsEmbedded.
--   
--   Since: 2.10
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
--   statusIconPositionMenu.
--   
--   Since: 2.14
statusIconGetX11WindowId :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m Word32

-- | Makes statusIcon display the file
--   filename. See statusIconNewFromFile for
--   details.
--   
--   Since: 2.10
statusIconSetFromFile :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> [Char] -> m ()

-- | Makes statusIcon display the Icon. See
--   statusIconNewFromGicon for details.
--   
--   Since: 2.14
statusIconSetFromGicon :: (HasCallStack, MonadIO m, IsStatusIcon a, IsIcon b) => a -> b -> m ()

-- | Makes statusIcon display the icon named
--   iconName from the current icon theme. See
--   statusIconNewFromIconName for details.
--   
--   Since: 2.10
statusIconSetFromIconName :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Text -> m ()

-- | Makes statusIcon display pixbuf. See
--   statusIconNewFromPixbuf for details.
--   
--   Since: 2.10
statusIconSetFromPixbuf :: (HasCallStack, MonadIO m, IsStatusIcon a, IsPixbuf b) => a -> Maybe b -> m ()

-- | Makes statusIcon display the stock icon with the id
--   stockId. See statusIconNewFromStock for
--   details.
--   
--   Since: 2.10
statusIconSetFromStock :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Text -> m ()

-- | Sets the has-tooltip property on statusIcon to
--   hasTooltip. See StatusIcon:hasTooltip for more
--   information.
--   
--   Since: 2.16
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.
--   
--   Since: 2.20
statusIconSetName :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Text -> m ()

-- | Sets the Screen where statusIcon is displayed;
--   if the icon is already mapped, it will be unmapped, and then remapped
--   on the new screen.
--   
--   Since: 2.12
statusIconSetScreen :: (HasCallStack, MonadIO m, IsStatusIcon a, IsScreen b) => a -> b -> m ()

-- | Sets markup as the contents of the tooltip, which is
--   marked up with the [Pango text markup language][PangoMarkupFormat].
--   
--   This function will take care of setting StatusIcon:hasTooltip
--   to True and of the default handler for the
--   StatusIcon::queryTooltip signal.
--   
--   See also the StatusIcon:tooltipMarkup property and
--   tooltipSetMarkup.
--   
--   Since: 2.16
statusIconSetTooltipMarkup :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Maybe Text -> m ()

-- | Sets text as the contents of the tooltip.
--   
--   This function will take care of setting StatusIcon:hasTooltip
--   to True and of the default handler for the
--   StatusIcon::queryTooltip signal.
--   
--   See also the StatusIcon:tooltipText property and
--   tooltipSetText.
--   
--   Since: 2.16
statusIconSetTooltipText :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Text -> m ()

-- | Shows or hides a status icon.
--   
--   Since: 2.10
statusIconSetVisible :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to
--   SeparatorMenuItem, for instance with
--   toSeparatorMenuItem.
class (GObject o, IsDescendantOf SeparatorMenuItem o) => IsSeparatorMenuItem o

-- | Cast to SeparatorMenuItem, for types for which this is known to
--   be safe. For general casts, use castTo.
toSeparatorMenuItem :: (MonadIO m, IsSeparatorMenuItem o) => o -> m SeparatorMenuItem

-- | Creates a new SeparatorMenuItem.
separatorMenuItemNew :: (HasCallStack, MonadIO m) => m SeparatorMenuItem

-- | Type class for types which can be safely cast to
--   RecentChooserMenu, for instance with
--   toRecentChooserMenu.
class (GObject o, IsDescendantOf RecentChooserMenu o) => IsRecentChooserMenu o

-- | Cast to RecentChooserMenu, for types for which this is known to
--   be safe. For general casts, use castTo.
toRecentChooserMenu :: (MonadIO m, IsRecentChooserMenu o) => o -> m RecentChooserMenu

-- | Get the value of the “show-numbers” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get recentChooserMenu #showNumbers
--   
getRecentChooserMenuShowNumbers :: (MonadIO m, IsRecentChooserMenu o) => o -> m Bool

-- | Set the value of the “show-numbers” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set recentChooserMenu [ #showNumbers := value ]
--   
setRecentChooserMenuShowNumbers :: (MonadIO m, IsRecentChooserMenu o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-numbers” property. This is rarely needed directly, but
--   it is used by new.
constructRecentChooserMenuShowNumbers :: (IsRecentChooserMenu o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new RecentChooserMenu 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 RecentChooser interface.
--   
--   This widget creates its own RecentManager object. See the
--   recentChooserMenuNewForManager function to know how to create a
--   RecentChooserMenu widget bound to another RecentManager
--   object.
--   
--   Since: 2.10
recentChooserMenuNew :: (HasCallStack, MonadIO m) => m RecentChooserMenu

-- | Returns the value set by recentChooserMenuSetShowNumbers.
--   
--   Since: 2.10
recentChooserMenuGetShowNumbers :: (HasCallStack, MonadIO m, IsRecentChooserMenu a) => a -> m Bool

-- | Type class for types which can be safely cast to
--   MenuToolButton, for instance with toMenuToolButton.
class (GObject o, IsDescendantOf MenuToolButton o) => IsMenuToolButton o

-- | Cast to MenuToolButton, for types for which this is known to be
--   safe. For general casts, use castTo.
toMenuToolButton :: (MonadIO m, IsMenuToolButton o) => o -> m MenuToolButton

-- | The showMenu signal is emitted before the menu is shown.
--   
--   It can be used to populate the menu on demand, using
--   menuToolButtonSetMenu.
--   
--   Note that even if you populate the menu dynamically in this way, you
--   must set an empty menu on the MenuToolButton beforehand, since
--   the arrow is made insensitive if the menu is not set.
type MenuToolButtonShowMenuCallback = IO ()

-- | Connect a signal handler for the showMenu signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on menuToolButton #showMenu callback
--   
onMenuToolButtonShowMenu :: (IsMenuToolButton a, MonadIO m) => a -> ((?self :: a) => MenuToolButtonShowMenuCallback) -> m SignalHandlerId

-- | Connect a signal handler for the showMenu signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after menuToolButton #showMenu callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterMenuToolButtonShowMenu :: (IsMenuToolButton a, MonadIO m) => a -> ((?self :: a) => MenuToolButtonShowMenuCallback) -> m SignalHandlerId

-- | Get the value of the “menu” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get menuToolButton #menu
--   
getMenuToolButtonMenu :: (MonadIO m, IsMenuToolButton o) => o -> m (Maybe Menu)

-- | Set the value of the “menu” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set menuToolButton [ #menu := value ]
--   
setMenuToolButtonMenu :: (MonadIO m, IsMenuToolButton o, IsMenu a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “menu” property. This is rarely needed directly, but it is
--   used by new.
constructMenuToolButtonMenu :: (IsMenuToolButton o, MonadIO m, IsMenu a) => a -> m (GValueConstruct o)

-- | Set the value of the “menu” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #menu
--   
clearMenuToolButtonMenu :: (MonadIO m, IsMenuToolButton o) => o -> m ()

-- | Creates a new MenuToolButton using iconWidget
--   as icon and label as label.
--   
--   Since: 2.6
menuToolButtonNew :: (HasCallStack, MonadIO m, IsWidget a) => Maybe a -> Maybe Text -> m MenuToolButton

-- | Creates a new MenuToolButton. The new MenuToolButton
--   will contain an icon and label from the stock item indicated by
--   stockId.
--   
--   Since: 2.6
menuToolButtonNewFromStock :: (HasCallStack, MonadIO m) => Text -> m MenuToolButton

-- | Gets the Menu associated with MenuToolButton.
--   
--   Since: 2.6
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 toolItemSetTooltipText for
--   setting a tooltip on the whole MenuToolButton.
--   
--   Since: 2.12
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 toolItemSetTooltipText for setting a
--   tooltip on the whole MenuToolButton.
--   
--   Since: 2.12
menuToolButtonSetArrowTooltipText :: (HasCallStack, MonadIO m, IsMenuToolButton a) => a -> Text -> m ()

-- | Type class for types which can be safely cast to MenuBar, for
--   instance with toMenuBar.
class (GObject o, IsDescendantOf MenuBar o) => IsMenuBar o

-- | Cast to MenuBar, for types for which this is known to be safe.
--   For general casts, use castTo.
toMenuBar :: (MonadIO m, IsMenuBar o) => o -> m MenuBar

-- | Get the value of the “child-pack-direction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menuBar #childPackDirection
--   
getMenuBarChildPackDirection :: (MonadIO m, IsMenuBar o) => o -> m PackDirection

-- | Set the value of the “child-pack-direction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menuBar [ #childPackDirection := value ]
--   
setMenuBarChildPackDirection :: (MonadIO m, IsMenuBar o) => o -> PackDirection -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “child-pack-direction” property. This is rarely needed
--   directly, but it is used by new.
constructMenuBarChildPackDirection :: (IsMenuBar o, MonadIO m) => PackDirection -> m (GValueConstruct o)

-- | Get the value of the “pack-direction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menuBar #packDirection
--   
getMenuBarPackDirection :: (MonadIO m, IsMenuBar o) => o -> m PackDirection

-- | Set the value of the “pack-direction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menuBar [ #packDirection := value ]
--   
setMenuBarPackDirection :: (MonadIO m, IsMenuBar o) => o -> PackDirection -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pack-direction” property. This is rarely needed directly,
--   but it is used by new.
constructMenuBarPackDirection :: (IsMenuBar o, MonadIO m) => PackDirection -> m (GValueConstruct o)

-- | Creates a new MenuBar
menuBarNew :: (HasCallStack, MonadIO m) => m MenuBar

-- | Retrieves the current child pack direction of the menubar. See
--   menuBarSetChildPackDirection.
--   
--   Since: 2.8
menuBarGetChildPackDirection :: (HasCallStack, MonadIO m, IsMenuBar a) => a -> m PackDirection

-- | Retrieves the current pack direction of the menubar. See
--   menuBarSetPackDirection.
--   
--   Since: 2.8
menuBarGetPackDirection :: (HasCallStack, MonadIO m, IsMenuBar a) => a -> m PackDirection

-- | Cast to Label, for types for which this is known to be safe.
--   For general casts, use castTo.
toLabel :: (MonadIO m, IsLabel o) => o -> m Label

-- | The populatePopup 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 menu.
type LabelPopulatePopupCallback = Menu -> IO ()

-- | The moveCursor signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates a
--   cursor movement. If the cursor is not visible in
--   entry, this signal causes the viewport to be moved
--   instead.
--   
--   Applications should not connect to it, but may emit it with
--   g_signal_emit_by_name() 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. * Arrow keys move by individual characters/lines *
--   Ctrl-arrow key combinations move by words/paragraphs * Home/End keys
--   move to the ends of the buffer
type LabelMoveCursorCallback = MovementStep -> Int32 -> Bool -> IO ()

-- | The copyClipboard 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
--   showUriOnWindow.
--   
--   Since: 2.18
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
--   g_signal_emit_by_name() if they need to control
--   activation of URIs programmatically.
--   
--   The default bindings for this signal are all forms of the Enter key.
--   
--   Since: 2.18
type LabelActivateCurrentLinkCallback = IO ()

-- | Connect a signal handler for the activateCurrentLink signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on label #activateCurrentLink callback
--   
onLabelActivateCurrentLink :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelActivateCurrentLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activateCurrentLink signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after label #activateCurrentLink callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterLabelActivateCurrentLink :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelActivateCurrentLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activateLink signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on label #activateLink callback
--   
onLabelActivateLink :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelActivateLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activateLink signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after label #activateLink callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterLabelActivateLink :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelActivateLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the copyClipboard signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on label #copyClipboard callback
--   
onLabelCopyClipboard :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the copyClipboard signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after label #copyClipboard callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterLabelCopyClipboard :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCursor signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on label #moveCursor callback
--   
onLabelMoveCursor :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the moveCursor signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after label #moveCursor callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterLabelMoveCursor :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the populatePopup signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on label #populatePopup callback
--   
onLabelPopulatePopup :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the populatePopup signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after label #populatePopup callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterLabelPopulatePopup :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelPopulatePopupCallback) -> m SignalHandlerId

-- | Get the value of the “angle” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #angle
--   
getLabelAngle :: (MonadIO m, IsLabel o) => o -> m Double

-- | Set the value of the “angle” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #angle := value ]
--   
setLabelAngle :: (MonadIO m, IsLabel o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “angle” property. This is rarely needed directly, but it is
--   used by new.
constructLabelAngle :: (IsLabel o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “attributes” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #attributes
--   
getLabelAttributes :: (MonadIO m, IsLabel o) => o -> m (Maybe AttrList)

-- | Set the value of the “attributes” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #attributes := value ]
--   
setLabelAttributes :: (MonadIO m, IsLabel o) => o -> AttrList -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “attributes” property. This is rarely needed directly, but it
--   is used by new.
constructLabelAttributes :: (IsLabel o, MonadIO m) => AttrList -> m (GValueConstruct o)

-- | Set the value of the “attributes” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #attributes
--   
clearLabelAttributes :: (MonadIO m, IsLabel o) => o -> m ()

-- | Get the value of the “cursor-position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #cursorPosition
--   
getLabelCursorPosition :: (MonadIO m, IsLabel o) => o -> m Int32

-- | Get the value of the “ellipsize” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #ellipsize
--   
getLabelEllipsize :: (MonadIO m, IsLabel o) => o -> m EllipsizeMode

-- | Set the value of the “ellipsize” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #ellipsize := value ]
--   
setLabelEllipsize :: (MonadIO m, IsLabel o) => o -> EllipsizeMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “ellipsize” property. This is rarely needed directly, but it
--   is used by new.
constructLabelEllipsize :: (IsLabel o, MonadIO m) => EllipsizeMode -> m (GValueConstruct o)

-- | Get the value of the “justify” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #justify
--   
getLabelJustify :: (MonadIO m, IsLabel o) => o -> m Justification

-- | Set the value of the “justify” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #justify := value ]
--   
setLabelJustify :: (MonadIO m, IsLabel o) => o -> Justification -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “justify” property. This is rarely needed directly, but it is
--   used by new.
constructLabelJustify :: (IsLabel o, MonadIO m) => Justification -> m (GValueConstruct o)

-- | Get the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #label
--   
getLabelLabel :: (MonadIO m, IsLabel o) => o -> m Text

-- | Set the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #label := value ]
--   
setLabelLabel :: (MonadIO m, IsLabel o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label” property. This is rarely needed directly, but it is
--   used by new.
constructLabelLabel :: (IsLabel o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #lines
--   
getLabelLines :: (MonadIO m, IsLabel o) => o -> m Int32

-- | Set the value of the “lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #lines := value ]
--   
setLabelLines :: (MonadIO m, IsLabel o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “lines” property. This is rarely needed directly, but it is
--   used by new.
constructLabelLines :: (IsLabel o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “max-width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #maxWidthChars
--   
getLabelMaxWidthChars :: (MonadIO m, IsLabel o) => o -> m Int32

-- | Set the value of the “max-width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #maxWidthChars := value ]
--   
setLabelMaxWidthChars :: (MonadIO m, IsLabel o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “max-width-chars” property. This is rarely needed directly,
--   but it is used by new.
constructLabelMaxWidthChars :: (IsLabel o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “mnemonic-keyval” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #mnemonicKeyval
--   
getLabelMnemonicKeyval :: (MonadIO m, IsLabel o) => o -> m Word32

-- | Get the value of the “mnemonic-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #mnemonicWidget
--   
getLabelMnemonicWidget :: (MonadIO m, IsLabel o) => o -> m (Maybe Widget)

-- | Set the value of the “mnemonic-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #mnemonicWidget := value ]
--   
setLabelMnemonicWidget :: (MonadIO m, IsLabel o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “mnemonic-widget” property. This is rarely needed directly,
--   but it is used by new.
constructLabelMnemonicWidget :: (IsLabel o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “mnemonic-widget” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #mnemonicWidget
--   
clearLabelMnemonicWidget :: (MonadIO m, IsLabel o) => o -> m ()

-- | Set the value of the “pattern” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #pattern := value ]
--   
setLabelPattern :: (MonadIO m, IsLabel o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pattern” property. This is rarely needed directly, but it is
--   used by new.
constructLabelPattern :: (IsLabel o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “selectable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #selectable
--   
getLabelSelectable :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “selectable” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #selectable := value ]
--   
setLabelSelectable :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “selectable” property. This is rarely needed directly, but it
--   is used by new.
constructLabelSelectable :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “selection-bound” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #selectionBound
--   
getLabelSelectionBound :: (MonadIO m, IsLabel o) => o -> m Int32

-- | Get the value of the “single-line-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #singleLineMode
--   
getLabelSingleLineMode :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “single-line-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #singleLineMode := value ]
--   
setLabelSingleLineMode :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “single-line-mode” property. This is rarely needed directly,
--   but it is used by new.
constructLabelSingleLineMode :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “track-visited-links” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #trackVisitedLinks
--   
getLabelTrackVisitedLinks :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “track-visited-links” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #trackVisitedLinks := value ]
--   
setLabelTrackVisitedLinks :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “track-visited-links” property. This is rarely needed
--   directly, but it is used by new.
constructLabelTrackVisitedLinks :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “use-markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #useMarkup
--   
getLabelUseMarkup :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “use-markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #useMarkup := value ]
--   
setLabelUseMarkup :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-markup” property. This is rarely needed directly, but it
--   is used by new.
constructLabelUseMarkup :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “use-underline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #useUnderline
--   
getLabelUseUnderline :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “use-underline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #useUnderline := value ]
--   
setLabelUseUnderline :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-underline” property. This is rarely needed directly, but
--   it is used by new.
constructLabelUseUnderline :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #widthChars
--   
getLabelWidthChars :: (MonadIO m, IsLabel o) => o -> m Int32

-- | Set the value of the “width-chars” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #widthChars := value ]
--   
setLabelWidthChars :: (MonadIO m, IsLabel o) => o -> Int32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “width-chars” property. This is rarely needed directly, but
--   it is used by new.
constructLabelWidthChars :: (IsLabel o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “wrap” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get label #wrap
--   
getLabelWrap :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “wrap” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set label [ #wrap := value ]
--   
setLabelWrap :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “wrap” property. This is rarely needed directly, but it is
--   used by new.
constructLabelWrap :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “wrap-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #wrapMode
--   
getLabelWrapMode :: (MonadIO m, IsLabel o) => o -> m WrapMode

-- | Set the value of the “wrap-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #wrapMode := value ]
--   
setLabelWrapMode :: (MonadIO m, IsLabel o) => o -> WrapMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “wrap-mode” property. This is rarely needed directly, but it
--   is used by new.
constructLabelWrapMode :: (IsLabel o, MonadIO m) => WrapMode -> m (GValueConstruct o)

-- | Get the value of the “xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #xalign
--   
getLabelXalign :: (MonadIO m, IsLabel o) => o -> m Float

-- | Set the value of the “xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #xalign := value ]
--   
setLabelXalign :: (MonadIO m, IsLabel o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “xalign” property. This is rarely needed directly, but it is
--   used by new.
constructLabelXalign :: (IsLabel o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get label #yalign
--   
getLabelYalign :: (MonadIO m, IsLabel o) => o -> m Float

-- | Set the value of the “yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set label [ #yalign := value ]
--   
setLabelYalign :: (MonadIO m, IsLabel o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “yalign” property. This is rarely needed directly, but it is
--   used by new.
constructLabelYalign :: (IsLabel o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Gets the angle of rotation for the label. See labelSetAngle.
--   
--   Since: 2.6
labelGetAngle :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Double

-- | Gets the attribute list that was set on the label using
--   labelSetAttributes, if any. This function does not reflect
--   attributes that come from the labels markup (see
--   labelSetMarkup). 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 Label::activateLink
--   handler or for use in a Widget::queryTooltip handler.
--   
--   Since: 2.18
labelGetCurrentUri :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Text

-- | Returns the ellipsizing position of the label. See
--   labelSetEllipsize.
--   
--   Since: 2.6
labelGetEllipsize :: (HasCallStack, MonadIO m, IsLabel a) => a -> m EllipsizeMode

-- | Returns the justification of the label. See labelSetJustify.
labelGetJustify :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Justification

-- | Gets the Layout used to display the label. The layout is useful
--   to e.g. convert text positions to pixel positions, in combination with
--   labelGetLayoutOffsets. The returned layout is owned by the
--   label so need not be freed by the caller. The
--   label 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

-- | Returns whether lines in the label are automatically wrapped. See
--   labelSetLineWrap.
labelGetLineWrap :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Returns line wrap mode used by the label. See
--   labelSetLineWrapMode.
--   
--   Since: 2.10
labelGetLineWrapMode :: (HasCallStack, MonadIO m, IsLabel a) => a -> m WrapMode

-- | Gets the number of lines to which an ellipsized, wrapping label should
--   be limited. See labelSetLines.
--   
--   Since: 3.10
labelGetLines :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Int32

-- | Retrieves the desired maximum width of label, in
--   characters. See labelSetWidthChars.
--   
--   Since: 2.6
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 KEY_VoidSymbol.
labelGetMnemonicKeyval :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Word32

-- | Retrieves the target of the mnemonic (keyboard shortcut) of this
--   label. See labelSetMnemonicWidget.
labelGetMnemonicWidget :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Maybe Widget)

-- | Gets the value set by labelSetSelectable.
labelGetSelectable :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Gets the selected range of characters in the label, returning
--   True 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.
--   
--   Since: 2.6
labelGetSingleLineMode :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Returns whether the label is currently keeping track of clicked links.
--   
--   Since: 2.18
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 labelSetUseUnderline.
labelGetUseUnderline :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Retrieves the desired width of label, in characters.
--   See labelSetWidthChars.
--   
--   Since: 2.6
labelGetWidthChars :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Int32

-- | Gets the Label:xalign property for label.
--   
--   Since: 3.16
labelGetXalign :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Float

-- | Gets the Label:yalign property for label.
--   
--   Since: 3.16
labelGetYalign :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Float

-- | Selects a range of characters in the label, if the label is
--   selectable. See labelSetSelectable. If the label is not
--   selectable, this function has no effect. If
--   startOffset or endOffset are -1, then
--   the end of the label will be substituted.
labelSelectRegion :: (HasCallStack, MonadIO m, IsLabel a) => a -> Int32 -> Int32 -> 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
--   Label:useUnderline and Label:useMarkup properties.
labelSetLabel :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Sets the desired maximum width in characters of label
--   to nChars.
--   
--   Since: 2.6
labelSetMaxWidthChars :: (HasCallStack, MonadIO m, IsLabel a) => a -> Int32 -> m ()

-- | The pattern of underlines you want under the existing text within the
--   Label widget. For example if the current text of the label says
--   “FooBarBaz” passing a pattern of “_ _” will underline “Foo” and
--   “Baz” but not “Bar”.
labelSetPattern :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Sets whether the label is in single line mode.
--   
--   Since: 2.6
labelSetSingleLineMode :: (HasCallStack, MonadIO m, IsLabel a) => a -> Bool -> m ()

-- | Sets whether the label should keep track of clicked links (and use a
--   different color for them).
--   
--   Since: 2.18
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 labelSetMarkup.
labelSetUseMarkup :: (HasCallStack, MonadIO m, IsLabel a) => a -> Bool -> m ()

-- | Sets the Label:xalign property for label.
--   
--   Since: 3.16
labelSetXalign :: (HasCallStack, MonadIO m, IsLabel a) => a -> Float -> m ()

-- | Sets the Label:yalign property for label.
--   
--   Since: 3.16
labelSetYalign :: (HasCallStack, MonadIO m, IsLabel a) => a -> Float -> m ()

-- | Type class for types which can be safely cast to ImageMenuItem,
--   for instance with toImageMenuItem.
class (GObject o, IsDescendantOf ImageMenuItem o) => IsImageMenuItem o

-- | Cast to ImageMenuItem, for types for which this is known to be
--   safe. For general casts, use castTo.
toImageMenuItem :: (MonadIO m, IsImageMenuItem o) => o -> m ImageMenuItem

-- | Set the value of the “accel-group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set imageMenuItem [ #accelGroup := value ]
--   
setImageMenuItemAccelGroup :: (MonadIO m, IsImageMenuItem o, IsAccelGroup a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accel-group” property. This is rarely needed directly, but
--   it is used by new.
constructImageMenuItemAccelGroup :: (IsImageMenuItem o, MonadIO m, IsAccelGroup a) => a -> m (GValueConstruct o)

-- | Get the value of the “always-show-image” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get imageMenuItem #alwaysShowImage
--   
getImageMenuItemAlwaysShowImage :: (MonadIO m, IsImageMenuItem o) => o -> m Bool

-- | Set the value of the “always-show-image” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set imageMenuItem [ #alwaysShowImage := value ]
--   
setImageMenuItemAlwaysShowImage :: (MonadIO m, IsImageMenuItem o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “always-show-image” property. This is rarely needed directly,
--   but it is used by new.
constructImageMenuItemAlwaysShowImage :: (IsImageMenuItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “image” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get imageMenuItem #image
--   
getImageMenuItemImage :: (MonadIO m, IsImageMenuItem o) => o -> m Widget

-- | Set the value of the “image” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set imageMenuItem [ #image := value ]
--   
setImageMenuItemImage :: (MonadIO m, IsImageMenuItem o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “image” property. This is rarely needed directly, but it is
--   used by new.
constructImageMenuItemImage :: (IsImageMenuItem o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “image” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #image
--   
clearImageMenuItemImage :: (MonadIO m, IsImageMenuItem o) => o -> m ()

-- | Get the value of the “use-stock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get imageMenuItem #useStock
--   
getImageMenuItemUseStock :: (MonadIO m, IsImageMenuItem o) => o -> m Bool

-- | Set the value of the “use-stock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set imageMenuItem [ #useStock := value ]
--   
setImageMenuItemUseStock :: (MonadIO m, IsImageMenuItem o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-stock” property. This is rarely needed directly, but it
--   is used by new.
constructImageMenuItemUseStock :: (IsImageMenuItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new ImageMenuItem with an empty label.
imageMenuItemNew :: (HasCallStack, MonadIO m) => m ImageMenuItem

-- | Creates a new ImageMenuItem containing a label.
imageMenuItemNewWithLabel :: (HasCallStack, MonadIO m) => Text -> m ImageMenuItem

-- | Creates a new ImageMenuItem containing a label. The label will
--   be created using labelNewWithMnemonic, so underscores in
--   label indicate the mnemonic for the menu item.
imageMenuItemNewWithMnemonic :: (HasCallStack, MonadIO m) => Text -> m ImageMenuItem

-- | Returns whether the menu item will ignore the
--   Settings:gtkMenuImages setting and always show the image, if
--   available.
--   
--   Since: 2.16
imageMenuItemGetAlwaysShowImage :: (HasCallStack, MonadIO m, IsImageMenuItem a) => a -> m Bool

-- | Gets the widget that is currently set as the image of
--   imageMenuItem. See imageMenuItemSetImage.
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.
--   
--   Since: 2.16
imageMenuItemGetUseStock :: (HasCallStack, MonadIO m, IsImageMenuItem a) => a -> m Bool

-- | Specifies an accelGroup 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 imageMenuItemSetUseStock and
--   menuItemSetLabel with a valid stock item first).
--   
--   If you want this menu item to have changeable accelerators then you
--   shouldnt need this (see imageMenuItemNewFromStock).
--   
--   Since: 2.16
imageMenuItemSetAccelGroup :: (HasCallStack, MonadIO m, IsImageMenuItem a, IsAccelGroup b) => a -> b -> m ()

-- | If True, the menu item will ignore the
--   Settings:gtkMenuImages setting and always show the image, if
--   available.
--   
--   Use this property if the menuitem would be useless or hard to use
--   without the image.
--   
--   Since: 2.16
imageMenuItemSetAlwaysShowImage :: (HasCallStack, MonadIO m, IsImageMenuItem a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to
--   IMMulticontext, for instance with toIMMulticontext.
class (GObject o, IsDescendantOf IMMulticontext o) => IsIMMulticontext o

-- | Cast to IMMulticontext, for types for which this is known to be
--   safe. For general casts, use castTo.
toIMMulticontext :: (MonadIO m, IsIMMulticontext o) => o -> m IMMulticontext

-- | Creates a new IMMulticontext.
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
--   context.
--   
--   Since: 2.16
iMMulticontextGetContextId :: (HasCallStack, MonadIO m, IsIMMulticontext a) => a -> m Text

-- | Sets the context id for context.
--   
--   This causes the currently active slave of context to
--   be replaced by the slave corresponding to the new context id.
--   
--   Since: 2.16
iMMulticontextSetContextId :: (HasCallStack, MonadIO m, IsIMMulticontext a) => a -> Text -> m ()

-- | Type class for types which can be safely cast to CheckMenuItem,
--   for instance with toCheckMenuItem.
class (GObject o, IsDescendantOf CheckMenuItem o) => IsCheckMenuItem o

-- | Cast to CheckMenuItem, for types for which this is known to be
--   safe. For general casts, use castTo.
toCheckMenuItem :: (MonadIO m, IsCheckMenuItem o) => o -> m CheckMenuItem

-- | This signal is emitted when the state of the check box is changed.
--   
--   A signal handler can use checkMenuItemGetActive to discover the
--   new state.
type CheckMenuItemToggledCallback = IO ()

-- | Connect a signal handler for the toggled signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on checkMenuItem #toggled callback
--   
onCheckMenuItemToggled :: (IsCheckMenuItem a, MonadIO m) => a -> ((?self :: a) => CheckMenuItemToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggled signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after checkMenuItem #toggled callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterCheckMenuItemToggled :: (IsCheckMenuItem a, MonadIO m) => a -> ((?self :: a) => CheckMenuItemToggledCallback) -> m SignalHandlerId

-- | Get the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get checkMenuItem #active
--   
getCheckMenuItemActive :: (MonadIO m, IsCheckMenuItem o) => o -> m Bool

-- | Set the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set checkMenuItem [ #active := value ]
--   
setCheckMenuItemActive :: (MonadIO m, IsCheckMenuItem o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “active” property. This is rarely needed directly, but it is
--   used by new.
constructCheckMenuItemActive :: (IsCheckMenuItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “draw-as-radio” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get checkMenuItem #drawAsRadio
--   
getCheckMenuItemDrawAsRadio :: (MonadIO m, IsCheckMenuItem o) => o -> m Bool

-- | Set the value of the “draw-as-radio” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set checkMenuItem [ #drawAsRadio := value ]
--   
setCheckMenuItemDrawAsRadio :: (MonadIO m, IsCheckMenuItem o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “draw-as-radio” property. This is rarely needed directly, but
--   it is used by new.
constructCheckMenuItemDrawAsRadio :: (IsCheckMenuItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “inconsistent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get checkMenuItem #inconsistent
--   
getCheckMenuItemInconsistent :: (MonadIO m, IsCheckMenuItem o) => o -> m Bool

-- | Set the value of the “inconsistent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set checkMenuItem [ #inconsistent := value ]
--   
setCheckMenuItemInconsistent :: (MonadIO m, IsCheckMenuItem o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “inconsistent” property. This is rarely needed directly, but
--   it is used by new.
constructCheckMenuItemInconsistent :: (IsCheckMenuItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new CheckMenuItem.
checkMenuItemNew :: (HasCallStack, MonadIO m) => m CheckMenuItem

-- | Creates a new CheckMenuItem with a label.
checkMenuItemNewWithLabel :: (HasCallStack, MonadIO m) => Text -> m CheckMenuItem

-- | Creates a new CheckMenuItem containing a label. The label will
--   be created using labelNewWithMnemonic, so underscores in
--   label indicate the mnemonic for the menu item.
checkMenuItemNewWithMnemonic :: (HasCallStack, MonadIO m) => Text -> m CheckMenuItem

-- | Returns whether checkMenuItem looks like a
--   RadioMenuItem
--   
--   Since: 2.4
checkMenuItemGetDrawAsRadio :: (HasCallStack, MonadIO m, IsCheckMenuItem a) => a -> m Bool

-- | Retrieves the value set by checkMenuItemSetInconsistent.
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 checkMenuItem is drawn like a
--   RadioMenuItem
--   
--   Since: 2.4
checkMenuItemSetDrawAsRadio :: (HasCallStack, MonadIO m, IsCheckMenuItem a) => a -> Bool -> m ()

-- | Emits the CheckMenuItem::toggled signal.
checkMenuItemToggled :: (HasCallStack, MonadIO m, IsCheckMenuItem a) => a -> m ()

-- | Type class for types which can be safely cast to RadioMenuItem,
--   for instance with toRadioMenuItem.
class (GObject o, IsDescendantOf RadioMenuItem o) => IsRadioMenuItem o

-- | Cast to RadioMenuItem, for types for which this is known to be
--   safe. For general casts, use castTo.
toRadioMenuItem :: (MonadIO m, IsRadioMenuItem o) => o -> m RadioMenuItem

-- | No description available in the introspection data.
type RadioMenuItemGroupChangedCallback = IO ()

-- | Connect a signal handler for the groupChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on radioMenuItem #groupChanged callback
--   
onRadioMenuItemGroupChanged :: (IsRadioMenuItem a, MonadIO m) => a -> ((?self :: a) => RadioMenuItemGroupChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the groupChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after radioMenuItem #groupChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterRadioMenuItemGroupChanged :: (IsRadioMenuItem a, MonadIO m) => a -> ((?self :: a) => RadioMenuItemGroupChangedCallback) -> m SignalHandlerId

-- | Set the value of the “group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set radioMenuItem [ #group := value ]
--   
setRadioMenuItemGroup :: (MonadIO m, IsRadioMenuItem o, IsRadioMenuItem a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “group” property. This is rarely needed directly, but it is
--   used by new.
constructRadioMenuItemGroup :: (IsRadioMenuItem o, MonadIO m, IsRadioMenuItem a) => a -> m (GValueConstruct o)

-- | Set the value of the “group” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #group
--   
clearRadioMenuItemGroup :: (MonadIO m, IsRadioMenuItem o) => o -> m ()

-- | Creates a new RadioMenuItem.
radioMenuItemNew :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => [a] -> m RadioMenuItem

-- | Creates a new RadioMenuItem adding it to the same group as
--   group.
--   
--   Since: 2.4
radioMenuItemNewFromWidget :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => Maybe a -> m RadioMenuItem

-- | Creates a new RadioMenuItem whose child is a simple
--   Label.
radioMenuItemNewWithLabel :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => [a] -> Text -> m RadioMenuItem

-- | Creates a new GtkRadioMenuItem whose child is a simple GtkLabel. The
--   new RadioMenuItem is added to the same group as
--   group.
--   
--   Since: 2.4
radioMenuItemNewWithLabelFromWidget :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => Maybe a -> Maybe Text -> m RadioMenuItem

-- | Creates a new RadioMenuItem containing a label. The label will
--   be created using labelNewWithMnemonic, so underscores in
--   label 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 labelNewWithMnemonic, so underscores in label
--   indicate the mnemonic for the menu item.
--   
--   The new RadioMenuItem is added to the same group as
--   group.
--   
--   Since: 2.4
radioMenuItemNewWithMnemonicFromWidget :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => Maybe a -> Maybe Text -> m RadioMenuItem

-- | Joins a RadioMenuItem object to the group of another
--   RadioMenuItem object.
--   
--   This function should be used by language bindings to avoid the memory
--   manangement of the opaque SList of radioMenuItemGetGroup
--   and radioMenuItemSetGroup.
--   
--   A common way to set up a group of RadioMenuItem instances is:
--   
--   
--   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;
--     }
--   
--   
--   Since: 3.18
radioMenuItemJoinGroup :: (HasCallStack, MonadIO m, IsRadioMenuItem a, IsRadioMenuItem b) => a -> Maybe b -> m ()

-- | Type class for types which can be safely cast to Button, for
--   instance with toButton.
class (GObject o, IsDescendantOf Button o) => IsButton o

-- | Cast to Button, for types for which this is known to be safe.
--   For general casts, use castTo.
toButton :: (MonadIO m, IsButton o) => o -> m Button

-- | 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 activate 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
--   Button::clicked signal.
type ButtonActivateCallback = IO ()

-- | Connect a signal handler for the activate signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on button #activate callback
--   
onButtonActivate :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activate signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after button #activate callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterButtonActivate :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the clicked signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on button #clicked callback
--   
onButtonClicked :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonClickedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the clicked signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after button #clicked callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterButtonClicked :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonClickedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the enter signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on button #enter callback
--   
onButtonEnter :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonEnterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the enter signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after button #enter callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterButtonEnter :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonEnterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the leave signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on button #leave callback
--   
onButtonLeave :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the leave signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after button #leave callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterButtonLeave :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pressed signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on button #pressed callback
--   
onButtonPressed :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the pressed signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after button #pressed callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterButtonPressed :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the released signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on button #released callback
--   
onButtonReleased :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonReleasedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the released signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after button #released callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterButtonReleased :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonReleasedCallback) -> m SignalHandlerId

-- | Get the value of the “always-show-image” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get button #alwaysShowImage
--   
getButtonAlwaysShowImage :: (MonadIO m, IsButton o) => o -> m Bool

-- | Set the value of the “always-show-image” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set button [ #alwaysShowImage := value ]
--   
setButtonAlwaysShowImage :: (MonadIO m, IsButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “always-show-image” property. This is rarely needed directly,
--   but it is used by new.
constructButtonAlwaysShowImage :: (IsButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “image” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get button #image
--   
getButtonImage :: (MonadIO m, IsButton o) => o -> m (Maybe Widget)

-- | Set the value of the “image” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set button [ #image := value ]
--   
setButtonImage :: (MonadIO m, IsButton o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “image” property. This is rarely needed directly, but it is
--   used by new.
constructButtonImage :: (IsButton o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “image” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #image
--   
clearButtonImage :: (MonadIO m, IsButton o) => o -> m ()

-- | Get the value of the “image-position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get button #imagePosition
--   
getButtonImagePosition :: (MonadIO m, IsButton o) => o -> m PositionType

-- | Set the value of the “image-position” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set button [ #imagePosition := value ]
--   
setButtonImagePosition :: (MonadIO m, IsButton o) => o -> PositionType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “image-position” property. This is rarely needed directly,
--   but it is used by new.
constructButtonImagePosition :: (IsButton o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Get the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get button #label
--   
getButtonLabel :: (MonadIO m, IsButton o) => o -> m Text

-- | Set the value of the “label” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set button [ #label := value ]
--   
setButtonLabel :: (MonadIO m, IsButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “label” property. This is rarely needed directly, but it is
--   used by new.
constructButtonLabel :: (IsButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “relief” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get button #relief
--   
getButtonRelief :: (MonadIO m, IsButton o) => o -> m ReliefStyle

-- | Set the value of the “relief” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set button [ #relief := value ]
--   
setButtonRelief :: (MonadIO m, IsButton o) => o -> ReliefStyle -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “relief” property. This is rarely needed directly, but it is
--   used by new.
constructButtonRelief :: (IsButton o, MonadIO m) => ReliefStyle -> m (GValueConstruct o)

-- | Get the value of the “use-stock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get button #useStock
--   
getButtonUseStock :: (MonadIO m, IsButton o) => o -> m Bool

-- | Set the value of the “use-stock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set button [ #useStock := value ]
--   
setButtonUseStock :: (MonadIO m, IsButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-stock” property. This is rarely needed directly, but it
--   is used by new.
constructButtonUseStock :: (IsButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “use-underline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get button #useUnderline
--   
getButtonUseUnderline :: (MonadIO m, IsButton o) => o -> m Bool

-- | Set the value of the “use-underline” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set button [ #useUnderline := value ]
--   
setButtonUseUnderline :: (MonadIO m, IsButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-underline” property. This is rarely needed directly, but
--   it is used by new.
constructButtonUseUnderline :: (IsButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get button #xalign
--   
getButtonXalign :: (MonadIO m, IsButton o) => o -> m Float

-- | Set the value of the “xalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set button [ #xalign := value ]
--   
setButtonXalign :: (MonadIO m, IsButton o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “xalign” property. This is rarely needed directly, but it is
--   used by new.
constructButtonXalign :: (IsButton o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get button #yalign
--   
getButtonYalign :: (MonadIO m, IsButton o) => o -> m Float

-- | Set the value of the “yalign” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set button [ #yalign := value ]
--   
setButtonYalign :: (MonadIO m, IsButton o) => o -> Float -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “yalign” property. This is rarely needed directly, but it is
--   used by new.
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 buttonNew and
--   buttonSetImage.
--   
--   Since: 3.10
buttonNewFromIconName :: (HasCallStack, MonadIO m) => Maybe Text -> Int32 -> m Button

-- | Creates a Button widget with a Label child containing
--   the given text.
buttonNewWithLabel :: (HasCallStack, MonadIO m) => Text -> m Button

-- | Emits a Button::clicked signal to the given Button.
buttonClicked :: (HasCallStack, MonadIO m, IsButton a) => a -> m ()

-- | Emits a Button::enter signal to the given Button.
buttonEnter :: (HasCallStack, MonadIO m, IsButton a) => a -> m ()

-- | Gets the alignment of the child in the button.
--   
--   Since: 2.4
buttonGetAlignment :: (HasCallStack, MonadIO m, IsButton a) => a -> m (Float, Float)

-- | Returns whether the button will ignore the
--   Settings:gtkButtonImages setting and always show the image, if
--   available.
--   
--   Since: 3.6
buttonGetAlwaysShowImage :: (HasCallStack, MonadIO m, IsButton a) => a -> m Bool

-- | Returns the button’s event window if it is realized, Nothing
--   otherwise. This function should be rarely needed.
--   
--   Since: 2.22
buttonGetEventWindow :: (HasCallStack, MonadIO m, IsButton a) => a -> m Window

-- | Returns whether the button grabs focus when it is clicked with the
--   mouse. See buttonSetFocusOnClick.
--   
--   Since: 2.4
buttonGetFocusOnClick :: (HasCallStack, MonadIO m, IsButton a) => a -> m Bool

-- | Gets the widget that is currenty set as the image of
--   button. This may have been explicitly set by
--   buttonSetImage or constructed by buttonNewFromStock.
--   
--   Since: 2.6
buttonGetImage :: (HasCallStack, MonadIO m, IsButton a) => a -> m (Maybe Widget)

-- | Gets the position of the image relative to the text inside the button.
--   
--   Since: 2.10
buttonGetImagePosition :: (HasCallStack, MonadIO m, IsButton a) => a -> m PositionType

-- | Fetches the text from the label of the button, as set by
--   buttonSetLabel. If the label text has not been set the return
--   value will be Nothing. This will be the case if you create an
--   empty button with buttonNew to use as a container.
buttonGetLabel :: (HasCallStack, MonadIO m, IsButton a) => a -> m Text

-- | Returns the current relief style of the given Button.
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 Button::leave signal to the given Button.
buttonLeave :: (HasCallStack, MonadIO m, IsButton a) => a -> m ()

-- | Emits a Button::pressed signal to the given Button.
buttonPressed :: (HasCallStack, MonadIO m, IsButton a) => a -> m ()

-- | Emits a Button::released signal to the given Button.
buttonReleased :: (HasCallStack, MonadIO m, IsButton a) => a -> m ()

-- | Sets the alignment of the child. This property has no effect unless
--   the child is a Misc or a Alignment.
--   
--   Since: 2.4
buttonSetAlignment :: (HasCallStack, MonadIO m, IsButton a) => a -> Float -> Float -> m ()

-- | If True, the button will ignore the
--   Settings:gtkButtonImages setting and always show the image, if
--   available.
--   
--   Use this property if the button would be useless or hard to use
--   without the image.
--   
--   Since: 3.6
buttonSetAlwaysShowImage :: (HasCallStack, MonadIO m, IsButton a) => a -> Bool -> m ()

-- | Sets the position of the image relative to the text inside the button.
--   
--   Since: 2.10
buttonSetImagePosition :: (HasCallStack, MonadIO m, IsButton a) => a -> PositionType -> 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 ()

-- | Type class for types which can be safely cast to ToggleButton,
--   for instance with toToggleButton.
class (GObject o, IsDescendantOf ToggleButton o) => IsToggleButton o

-- | Cast to ToggleButton, for types for which this is known to be
--   safe. For general casts, use castTo.
toToggleButton :: (MonadIO m, IsToggleButton o) => o -> m ToggleButton

-- | Should be connected if you wish to perform an action whenever the
--   ToggleButton's state is changed.
type ToggleButtonToggledCallback = IO ()

-- | Connect a signal handler for the toggled signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on toggleButton #toggled callback
--   
onToggleButtonToggled :: (IsToggleButton a, MonadIO m) => a -> ((?self :: a) => ToggleButtonToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the toggled signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after toggleButton #toggled callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterToggleButtonToggled :: (IsToggleButton a, MonadIO m) => a -> ((?self :: a) => ToggleButtonToggledCallback) -> m SignalHandlerId

-- | Get the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toggleButton #active
--   
getToggleButtonActive :: (MonadIO m, IsToggleButton o) => o -> m Bool

-- | Set the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toggleButton [ #active := value ]
--   
setToggleButtonActive :: (MonadIO m, IsToggleButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “active” property. This is rarely needed directly, but it is
--   used by new.
constructToggleButtonActive :: (IsToggleButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “draw-indicator” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toggleButton #drawIndicator
--   
getToggleButtonDrawIndicator :: (MonadIO m, IsToggleButton o) => o -> m Bool

-- | Set the value of the “draw-indicator” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toggleButton [ #drawIndicator := value ]
--   
setToggleButtonDrawIndicator :: (MonadIO m, IsToggleButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “draw-indicator” property. This is rarely needed directly,
--   but it is used by new.
constructToggleButtonDrawIndicator :: (IsToggleButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “inconsistent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get toggleButton #inconsistent
--   
getToggleButtonInconsistent :: (MonadIO m, IsToggleButton o) => o -> m Bool

-- | Set the value of the “inconsistent” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set toggleButton [ #inconsistent := value ]
--   
setToggleButtonInconsistent :: (MonadIO m, IsToggleButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “inconsistent” property. This is rarely needed directly, but
--   it is used by new.
constructToggleButtonInconsistent :: (IsToggleButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new toggle button. A widget should be packed into the
--   button, as in buttonNew.
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 ToggleButton containing a label. The label will
--   be created using labelNewWithMnemonic, so underscores in
--   label indicate the mnemonic for the button.
toggleButtonNewWithMnemonic :: (HasCallStack, MonadIO m) => Text -> m ToggleButton

-- | Queries a ToggleButton and returns its current state. Returns
--   True if the toggle button is pressed in and False if it
--   is raised.
toggleButtonGetActive :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> m Bool

-- | Gets the value set by toggleButtonSetInconsistent.
toggleButtonGetInconsistent :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> m Bool

-- | Retrieves whether the button is displayed as a separate indicator and
--   label. See toggleButtonSetMode.
toggleButtonGetMode :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> m Bool

-- | Sets the status of the toggle button. Set to True if you want
--   the GtkToggleButton to be “pressed in”, and False to raise it.
--   This action causes the ToggleButton::toggled signal and the
--   Button::clicked signal to be emitted.
toggleButtonSetActive :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> Bool -> m ()

-- | Emits the ToggleButton::toggled signal on the
--   ToggleButton. There is no good reason for an application ever
--   to call this function.
toggleButtonToggled :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> m ()

-- | Type class for types which can be safely cast to ScaleButton,
--   for instance with toScaleButton.
class (GObject o, IsDescendantOf ScaleButton o) => IsScaleButton o

-- | Cast to ScaleButton, for types for which this is known to be
--   safe. For general casts, use castTo.
toScaleButton :: (MonadIO m, IsScaleButton o) => o -> m ScaleButton

-- | The valueChanged signal is emitted when the value field has
--   changed.
--   
--   Since: 2.12
type ScaleButtonValueChangedCallback = Double -> IO ()

-- | The popup 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.
--   
--   Since: 2.12
type ScaleButtonPopupCallback = IO ()

-- | The popdown signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted to popdown the scale widget.
--   
--   The default binding for this signal is Escape.
--   
--   Since: 2.12
type ScaleButtonPopdownCallback = IO ()

-- | Connect a signal handler for the popdown signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on scaleButton #popdown callback
--   
onScaleButtonPopdown :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonPopdownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the popdown signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after scaleButton #popdown callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterScaleButtonPopdown :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonPopdownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the popup signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on scaleButton #popup callback
--   
onScaleButtonPopup :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonPopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the popup signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after scaleButton #popup callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterScaleButtonPopup :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonPopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the valueChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on scaleButton #valueChanged callback
--   
onScaleButtonValueChanged :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonValueChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the valueChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after scaleButton #valueChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterScaleButtonValueChanged :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonValueChangedCallback) -> m SignalHandlerId

-- | Get the value of the “adjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scaleButton #adjustment
--   
getScaleButtonAdjustment :: (MonadIO m, IsScaleButton o) => o -> m Adjustment

-- | Set the value of the “adjustment” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scaleButton [ #adjustment := value ]
--   
setScaleButtonAdjustment :: (MonadIO m, IsScaleButton o, IsAdjustment a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “adjustment” property. This is rarely needed directly, but it
--   is used by new.
constructScaleButtonAdjustment :: (IsScaleButton o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “icons” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scaleButton #icons
--   
getScaleButtonIcons :: (MonadIO m, IsScaleButton o) => o -> m (Maybe [Text])

-- | Set the value of the “icons” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scaleButton [ #icons := value ]
--   
setScaleButtonIcons :: (MonadIO m, IsScaleButton o) => o -> [Text] -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icons” property. This is rarely needed directly, but it is
--   used by new.
constructScaleButtonIcons :: (IsScaleButton o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “size” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get scaleButton #size
--   
getScaleButtonSize :: (MonadIO m, IsScaleButton o) => o -> m IconSize

-- | Set the value of the “size” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set scaleButton [ #size := value ]
--   
setScaleButtonSize :: (MonadIO m, IsScaleButton o) => o -> IconSize -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “size” property. This is rarely needed directly, but it is
--   used by new.
constructScaleButtonSize :: (IsScaleButton o, MonadIO m) => IconSize -> m (GValueConstruct o)

-- | Get the value of the “value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get scaleButton #value
--   
getScaleButtonValue :: (MonadIO m, IsScaleButton o) => o -> m Double

-- | Set the value of the “value” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set scaleButton [ #value := value ]
--   
setScaleButtonValue :: (MonadIO m, IsScaleButton o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “value” property. This is rarely needed directly, but it is
--   used by new.
constructScaleButtonValue :: (IsScaleButton o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Creates a ScaleButton, with a range between min
--   and max, with a stepping of step.
--   
--   Since: 2.12
scaleButtonNew :: (HasCallStack, MonadIO m) => Int32 -> Double -> Double -> Double -> Maybe [Text] -> m ScaleButton

-- | Gets the Adjustment associated with the ScaleButton’s
--   scale. See rangeGetAdjustment for details.
--   
--   Since: 2.12
scaleButtonGetAdjustment :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Adjustment

-- | Retrieves the minus button of the ScaleButton.
--   
--   Since: 2.14
scaleButtonGetMinusButton :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Button

-- | Retrieves the plus button of the ScaleButton.
--   
--   Since: 2.14
scaleButtonGetPlusButton :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Button

-- | Retrieves the popup of the ScaleButton.
--   
--   Since: 2.14
scaleButtonGetPopup :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Widget

-- | Gets the current value of the scale button.
--   
--   Since: 2.12
scaleButtonGetValue :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Double

-- | Sets the Adjustment to be used as a model for the
--   ScaleButton’s scale. See rangeSetAdjustment for details.
--   
--   Since: 2.12
scaleButtonSetAdjustment :: (HasCallStack, MonadIO m, IsScaleButton a, IsAdjustment b) => a -> b -> 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 ScaleButton::valueChanged
--   signal if the value changes.
--   
--   Since: 2.12
scaleButtonSetValue :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> Double -> m ()

-- | Type class for types which can be safely cast to VolumeButton,
--   for instance with toVolumeButton.
class (GObject o, IsDescendantOf VolumeButton o) => IsVolumeButton o

-- | Cast to VolumeButton, for types for which this is known to be
--   safe. For general casts, use castTo.
toVolumeButton :: (MonadIO m, IsVolumeButton o) => o -> m VolumeButton

-- | Get the value of the “use-symbolic” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get volumeButton #useSymbolic
--   
getVolumeButtonUseSymbolic :: (MonadIO m, IsVolumeButton o) => o -> m Bool

-- | Set the value of the “use-symbolic” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set volumeButton [ #useSymbolic := value ]
--   
setVolumeButtonUseSymbolic :: (MonadIO m, IsVolumeButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-symbolic” property. This is rarely needed directly, but
--   it is used by new.
constructVolumeButtonUseSymbolic :: (IsVolumeButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a VolumeButton, 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 ScaleButton.
--   
--   Since: 2.12
volumeButtonNew :: (HasCallStack, MonadIO m) => m VolumeButton

-- | Type class for types which can be safely cast to ModelButton,
--   for instance with toModelButton.
class (GObject o, IsDescendantOf ModelButton o) => IsModelButton o

-- | Cast to ModelButton, for types for which this is known to be
--   safe. For general casts, use castTo.
toModelButton :: (MonadIO m, IsModelButton o) => o -> m ModelButton

-- | Get the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get modelButton #active
--   
getModelButtonActive :: (MonadIO m, IsModelButton o) => o -> m Bool

-- | Set the value of the “active” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set modelButton [ #active := value ]
--   
setModelButtonActive :: (MonadIO m, IsModelButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “active” property. This is rarely needed directly, but it is
--   used by new.
constructModelButtonActive :: (IsModelButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “centered” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get modelButton #centered
--   
getModelButtonCentered :: (MonadIO m, IsModelButton o) => o -> m Bool

-- | Set the value of the “centered” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set modelButton [ #centered := value ]
--   
setModelButtonCentered :: (MonadIO m, IsModelButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “centered” property. This is rarely needed directly, but it
--   is used by new.
constructModelButtonCentered :: (IsModelButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “icon” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get modelButton #icon
--   
getModelButtonIcon :: (MonadIO m, IsModelButton o) => o -> m (Maybe Icon)

-- | Set the value of the “icon” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set modelButton [ #icon := value ]
--   
setModelButtonIcon :: (MonadIO m, IsModelButton o, IsIcon a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “icon” property. This is rarely needed directly, but it is
--   used by new.
constructModelButtonIcon :: (IsModelButton o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “icon” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #icon
--   
clearModelButtonIcon :: (MonadIO m, IsModelButton o) => o -> m ()

-- | Get the value of the “iconic” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get modelButton #iconic
--   
getModelButtonIconic :: (MonadIO m, IsModelButton o) => o -> m Bool

-- | Set the value of the “iconic” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set modelButton [ #iconic := value ]
--   
setModelButtonIconic :: (MonadIO m, IsModelButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “iconic” property. This is rarely needed directly, but it is
--   used by new.
constructModelButtonIconic :: (IsModelButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “inverted” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get modelButton #inverted
--   
getModelButtonInverted :: (MonadIO m, IsModelButton o) => o -> m Bool

-- | Set the value of the “inverted” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set modelButton [ #inverted := value ]
--   
setModelButtonInverted :: (MonadIO m, IsModelButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “inverted” property. This is rarely needed directly, but it
--   is used by new.
constructModelButtonInverted :: (IsModelButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “menu-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get modelButton #menuName
--   
getModelButtonMenuName :: (MonadIO m, IsModelButton o) => o -> m (Maybe Text)

-- | Set the value of the “menu-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set modelButton [ #menuName := value ]
--   
setModelButtonMenuName :: (MonadIO m, IsModelButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “menu-name” property. This is rarely needed directly, but it
--   is used by new.
constructModelButtonMenuName :: (IsModelButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “menu-name” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #menuName
--   
clearModelButtonMenuName :: (MonadIO m, IsModelButton o) => o -> m ()

-- | Get the value of the “role” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get modelButton #role
--   
getModelButtonRole :: (MonadIO m, IsModelButton o) => o -> m ButtonRole

-- | Set the value of the “role” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set modelButton [ #role := value ]
--   
setModelButtonRole :: (MonadIO m, IsModelButton o) => o -> ButtonRole -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “role” property. This is rarely needed directly, but it is
--   used by new.
constructModelButtonRole :: (IsModelButton o, MonadIO m) => ButtonRole -> m (GValueConstruct o)

-- | Get the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get modelButton #text
--   
getModelButtonText :: (MonadIO m, IsModelButton o) => o -> m (Maybe Text)

-- | Set the value of the “text” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set modelButton [ #text := value ]
--   
setModelButtonText :: (MonadIO m, IsModelButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text” property. This is rarely needed directly, but it is
--   used by new.
constructModelButtonText :: (IsModelButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “text” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #text
--   
clearModelButtonText :: (MonadIO m, IsModelButton o) => o -> m ()

-- | Get the value of the “use-markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get modelButton #useMarkup
--   
getModelButtonUseMarkup :: (MonadIO m, IsModelButton o) => o -> m Bool

-- | Set the value of the “use-markup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set modelButton [ #useMarkup := value ]
--   
setModelButtonUseMarkup :: (MonadIO m, IsModelButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-markup” property. This is rarely needed directly, but it
--   is used by new.
constructModelButtonUseMarkup :: (IsModelButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new GtkModelButton.
--   
--   Since: 3.16
modelButtonNew :: (HasCallStack, MonadIO m) => m ModelButton

-- | Type class for types which can be safely cast to MenuButton,
--   for instance with toMenuButton.
class (GObject o, IsDescendantOf MenuButton o) => IsMenuButton o

-- | Cast to MenuButton, for types for which this is known to be
--   safe. For general casts, use castTo.
toMenuButton :: (MonadIO m, IsMenuButton o) => o -> m MenuButton

-- | Get the value of the “align-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menuButton #alignWidget
--   
getMenuButtonAlignWidget :: (MonadIO m, IsMenuButton o) => o -> m (Maybe Container)

-- | Set the value of the “align-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menuButton [ #alignWidget := value ]
--   
setMenuButtonAlignWidget :: (MonadIO m, IsMenuButton o, IsContainer a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “align-widget” property. This is rarely needed directly, but
--   it is used by new.
constructMenuButtonAlignWidget :: (IsMenuButton o, MonadIO m, IsContainer a) => a -> m (GValueConstruct o)

-- | Set the value of the “align-widget” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #alignWidget
--   
clearMenuButtonAlignWidget :: (MonadIO m, IsMenuButton o) => o -> m ()

-- | Get the value of the “direction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menuButton #direction
--   
getMenuButtonDirection :: (MonadIO m, IsMenuButton o) => o -> m ArrowType

-- | Set the value of the “direction” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menuButton [ #direction := value ]
--   
setMenuButtonDirection :: (MonadIO m, IsMenuButton o) => o -> ArrowType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “direction” property. This is rarely needed directly, but it
--   is used by new.
constructMenuButtonDirection :: (IsMenuButton o, MonadIO m) => ArrowType -> m (GValueConstruct o)

-- | Get the value of the “menu-model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menuButton #menuModel
--   
getMenuButtonMenuModel :: (MonadIO m, IsMenuButton o) => o -> m (Maybe MenuModel)

-- | Set the value of the “menu-model” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menuButton [ #menuModel := value ]
--   
setMenuButtonMenuModel :: (MonadIO m, IsMenuButton o, IsMenuModel a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “menu-model” property. This is rarely needed directly, but it
--   is used by new.
constructMenuButtonMenuModel :: (IsMenuButton o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “menu-model” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #menuModel
--   
clearMenuButtonMenuModel :: (MonadIO m, IsMenuButton o) => o -> m ()

-- | Get the value of the “popover” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menuButton #popover
--   
getMenuButtonPopover :: (MonadIO m, IsMenuButton o) => o -> m (Maybe Popover)

-- | Set the value of the “popover” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menuButton [ #popover := value ]
--   
setMenuButtonPopover :: (MonadIO m, IsMenuButton o, IsPopover a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “popover” property. This is rarely needed directly, but it is
--   used by new.
constructMenuButtonPopover :: (IsMenuButton o, MonadIO m, IsPopover a) => a -> m (GValueConstruct o)

-- | Set the value of the “popover” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #popover
--   
clearMenuButtonPopover :: (MonadIO m, IsMenuButton o) => o -> m ()

-- | Get the value of the “popup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menuButton #popup
--   
getMenuButtonPopup :: (MonadIO m, IsMenuButton o) => o -> m (Maybe Menu)

-- | Set the value of the “popup” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menuButton [ #popup := value ]
--   
setMenuButtonPopup :: (MonadIO m, IsMenuButton o, IsMenu a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “popup” property. This is rarely needed directly, but it is
--   used by new.
constructMenuButtonPopup :: (IsMenuButton o, MonadIO m, IsMenu a) => a -> m (GValueConstruct o)

-- | Set the value of the “popup” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #popup
--   
clearMenuButtonPopup :: (MonadIO m, IsMenuButton o) => o -> m ()

-- | Get the value of the “use-popover” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get menuButton #usePopover
--   
getMenuButtonUsePopover :: (MonadIO m, IsMenuButton o) => o -> m Bool

-- | Set the value of the “use-popover” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set menuButton [ #usePopover := value ]
--   
setMenuButtonUsePopover :: (MonadIO m, IsMenuButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-popover” property. This is rarely needed directly, but
--   it is used by new.
constructMenuButtonUsePopover :: (IsMenuButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new MenuButton widget with downwards-pointing arrow
--   as the only child. You can replace the child widget with another
--   Widget should you wish to.
--   
--   Since: 3.6
menuButtonNew :: (HasCallStack, MonadIO m) => m MenuButton

-- | Returns the parent Widget to use to line up with menu.
--   
--   Since: 3.6
menuButtonGetAlignWidget :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m (Maybe Widget)

-- | Returns the direction the popup will be pointing at when popped up.
--   
--   Since: 3.6
menuButtonGetDirection :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m ArrowType

-- | Returns the MenuModel used to generate the popup.
--   
--   Since: 3.6
menuButtonGetMenuModel :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m (Maybe MenuModel)

-- | Returns the Popover that pops out of the button. If the button
--   is not using a Popover, this function returns Nothing.
--   
--   Since: 3.12
menuButtonGetPopover :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m (Maybe Popover)

-- | Returns the Menu that pops out of the button. If the button
--   does not use a Menu, this function returns Nothing.
--   
--   Since: 3.6
menuButtonGetPopup :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m (Maybe Menu)

-- | Returns whether a Popover or a Menu will be constructed
--   from the menu model.
--   
--   Since: 3.12
menuButtonGetUsePopover :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m Bool

-- | Sets the Widget to use to line the menu with when popped up.
--   Note that the alignWidget must contain the
--   MenuButton itself.
--   
--   Setting it to Nothing 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.
--   
--   Since: 3.6
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 ArrowTypeNone for a direction, the
--   popup will behave as if you passed ArrowTypeDown (although you
--   won’t see any arrows).
--   
--   Since: 3.6
menuButtonSetDirection :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> ArrowType -> m ()

-- | Sets the Popover that will be popped up when the
--   menuButton is clicked, or Nothing to dissociate
--   any existing popover and disable the button.
--   
--   If MenuButton:menuModel or MenuButton:popup are set,
--   those objects are dissociated from the menuButton, and
--   those properties are set to Nothing.
--   
--   Since: 3.12
menuButtonSetPopover :: (HasCallStack, MonadIO m, IsMenuButton a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the Menu that will be popped up when the
--   menuButton is clicked, or Nothing to dissociate
--   any existing menu and disable the button.
--   
--   If MenuButton:menuModel or MenuButton:popover are set,
--   those objects are dissociated from the menuButton, and
--   those properties are set to Nothing.
--   
--   Since: 3.6
menuButtonSetPopup :: (HasCallStack, MonadIO m, IsMenuButton a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether to construct a Popover instead of Menu when
--   menuButtonSetMenuModel is called. Note that this property is
--   only consulted when a new menu model is set.
--   
--   Since: 3.12
menuButtonSetUsePopover :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to LockButton,
--   for instance with toLockButton.
class (GObject o, IsDescendantOf LockButton o) => IsLockButton o

-- | Cast to LockButton, for types for which this is known to be
--   safe. For general casts, use castTo.
toLockButton :: (MonadIO m, IsLockButton o) => o -> m LockButton

-- | Get the value of the “permission” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get lockButton #permission
--   
getLockButtonPermission :: (MonadIO m, IsLockButton o) => o -> m Permission

-- | Set the value of the “permission” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set lockButton [ #permission := value ]
--   
setLockButtonPermission :: (MonadIO m, IsLockButton o, IsPermission a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “permission” property. This is rarely needed directly, but it
--   is used by new.
constructLockButtonPermission :: (IsLockButton o, MonadIO m, IsPermission a) => a -> m (GValueConstruct o)

-- | Set the value of the “permission” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #permission
--   
clearLockButtonPermission :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Get the value of the “text-lock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get lockButton #textLock
--   
getLockButtonTextLock :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “text-lock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set lockButton [ #textLock := value ]
--   
setLockButtonTextLock :: (MonadIO m, IsLockButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text-lock” property. This is rarely needed directly, but it
--   is used by new.
constructLockButtonTextLock :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “text-lock” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #textLock
--   
clearLockButtonTextLock :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Get the value of the “text-unlock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get lockButton #textUnlock
--   
getLockButtonTextUnlock :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “text-unlock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set lockButton [ #textUnlock := value ]
--   
setLockButtonTextUnlock :: (MonadIO m, IsLockButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text-unlock” property. This is rarely needed directly, but
--   it is used by new.
constructLockButtonTextUnlock :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “text-unlock” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #textUnlock
--   
clearLockButtonTextUnlock :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Get the value of the “tooltip-lock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get lockButton #tooltipLock
--   
getLockButtonTooltipLock :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “tooltip-lock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set lockButton [ #tooltipLock := value ]
--   
setLockButtonTooltipLock :: (MonadIO m, IsLockButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tooltip-lock” property. This is rarely needed directly, but
--   it is used by new.
constructLockButtonTooltipLock :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “tooltip-lock” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #tooltipLock
--   
clearLockButtonTooltipLock :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Get the value of the “tooltip-not-authorized” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get lockButton #tooltipNotAuthorized
--   
getLockButtonTooltipNotAuthorized :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “tooltip-not-authorized” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set lockButton [ #tooltipNotAuthorized := value ]
--   
setLockButtonTooltipNotAuthorized :: (MonadIO m, IsLockButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tooltip-not-authorized” property. This is rarely needed
--   directly, but it is used by new.
constructLockButtonTooltipNotAuthorized :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “tooltip-not-authorized” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #tooltipNotAuthorized
--   
clearLockButtonTooltipNotAuthorized :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Get the value of the “tooltip-unlock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get lockButton #tooltipUnlock
--   
getLockButtonTooltipUnlock :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “tooltip-unlock” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set lockButton [ #tooltipUnlock := value ]
--   
setLockButtonTooltipUnlock :: (MonadIO m, IsLockButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “tooltip-unlock” property. This is rarely needed directly,
--   but it is used by new.
constructLockButtonTooltipUnlock :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “tooltip-unlock” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #tooltipUnlock
--   
clearLockButtonTooltipUnlock :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Creates a new lock button which reflects the
--   permission.
--   
--   Since: 3.2
lockButtonNew :: (HasCallStack, MonadIO m, IsPermission a) => Maybe a -> m LockButton

-- | Obtains the Permission object that controls
--   button.
--   
--   Since: 3.2
lockButtonGetPermission :: (HasCallStack, MonadIO m, IsLockButton a) => a -> m Permission

-- | Sets the Permission object that controls
--   button.
--   
--   Since: 3.2
lockButtonSetPermission :: (HasCallStack, MonadIO m, IsLockButton a, IsPermission b) => a -> Maybe b -> m ()

-- | Type class for types which can be safely cast to LinkButton,
--   for instance with toLinkButton.
class (GObject o, IsDescendantOf LinkButton o) => IsLinkButton o

-- | Cast to LinkButton, for types for which this is known to be
--   safe. For general casts, use castTo.
toLinkButton :: (MonadIO m, IsLinkButton o) => o -> m LinkButton

-- | The activateLink signal is emitted each time the
--   LinkButton has been clicked.
--   
--   The default handler will call showUriOnWindow with the URI
--   stored inside the LinkButton:uri property.
--   
--   To override the default behavior, you can connect to the
--   activateLink signal and stop the propagation of the signal by
--   returning True from your handler.
type LinkButtonActivateLinkCallback = IO Bool

-- | Connect a signal handler for the activateLink signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on linkButton #activateLink callback
--   
onLinkButtonActivateLink :: (IsLinkButton a, MonadIO m) => a -> ((?self :: a) => LinkButtonActivateLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the activateLink signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after linkButton #activateLink callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterLinkButtonActivateLink :: (IsLinkButton a, MonadIO m) => a -> ((?self :: a) => LinkButtonActivateLinkCallback) -> m SignalHandlerId

-- | Get the value of the “uri” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get linkButton #uri
--   
getLinkButtonUri :: (MonadIO m, IsLinkButton o) => o -> m Text

-- | Set the value of the “uri” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set linkButton [ #uri := value ]
--   
setLinkButtonUri :: (MonadIO m, IsLinkButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “uri” property. This is rarely needed directly, but it is
--   used by new.
constructLinkButtonUri :: (IsLinkButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “visited” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get linkButton #visited
--   
getLinkButtonVisited :: (MonadIO m, IsLinkButton o) => o -> m Bool

-- | Set the value of the “visited” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set linkButton [ #visited := value ]
--   
setLinkButtonVisited :: (MonadIO m, IsLinkButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “visited” property. This is rarely needed directly, but it is
--   used by new.
constructLinkButtonVisited :: (IsLinkButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new LinkButton with the URI as its text.
--   
--   Since: 2.10
linkButtonNew :: (HasCallStack, MonadIO m) => Text -> m LinkButton

-- | Creates a new LinkButton containing a label.
--   
--   Since: 2.10
linkButtonNewWithLabel :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> m LinkButton

-- | Retrieves the URI set using linkButtonSetUri.
--   
--   Since: 2.10
linkButtonGetUri :: (HasCallStack, MonadIO m, IsLinkButton a) => a -> m Text

-- | Type class for types which can be safely cast to InfoBar, for
--   instance with toInfoBar.
class (GObject o, IsDescendantOf InfoBar o) => IsInfoBar o

-- | Cast to InfoBar, for types for which this is known to be safe.
--   For general casts, use castTo.
toInfoBar :: (MonadIO m, IsInfoBar o) => o -> m InfoBar

-- | Emitted when an action widget is clicked or the application programmer
--   calls dialogResponse. The responseId depends on
--   which action widget was clicked.
--   
--   Since: 2.18
type InfoBarResponseCallback = Int32 -> IO ()

-- | The close 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.
--   
--   Since: 2.18
type InfoBarCloseCallback = IO ()

-- | Connect a signal handler for the close signal, to be run before
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on infoBar #close callback
--   
onInfoBarClose :: (IsInfoBar a, MonadIO m) => a -> ((?self :: a) => InfoBarCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the close signal, to be run after
--   the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after infoBar #close callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterInfoBarClose :: (IsInfoBar a, MonadIO m) => a -> ((?self :: a) => InfoBarCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the response signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on infoBar #response callback
--   
onInfoBarResponse :: (IsInfoBar a, MonadIO m) => a -> ((?self :: a) => InfoBarResponseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the response signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after infoBar #response callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterInfoBarResponse :: (IsInfoBar a, MonadIO m) => a -> ((?self :: a) => InfoBarResponseCallback) -> m SignalHandlerId

-- | Get the value of the “message-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get infoBar #messageType
--   
getInfoBarMessageType :: (MonadIO m, IsInfoBar o) => o -> m MessageType

-- | Set the value of the “message-type” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set infoBar [ #messageType := value ]
--   
setInfoBarMessageType :: (MonadIO m, IsInfoBar o) => o -> MessageType -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “message-type” property. This is rarely needed directly, but
--   it is used by new.
constructInfoBarMessageType :: (IsInfoBar o, MonadIO m) => MessageType -> m (GValueConstruct o)

-- | Get the value of the “revealed” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get infoBar #revealed
--   
getInfoBarRevealed :: (MonadIO m, IsInfoBar o) => o -> m Bool

-- | Set the value of the “revealed” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set infoBar [ #revealed := value ]
--   
setInfoBarRevealed :: (MonadIO m, IsInfoBar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “revealed” property. This is rarely needed directly, but it
--   is used by new.
constructInfoBarRevealed :: (IsInfoBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-close-button” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get infoBar #showCloseButton
--   
getInfoBarShowCloseButton :: (MonadIO m, IsInfoBar o) => o -> m Bool

-- | Set the value of the “show-close-button” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set infoBar [ #showCloseButton := value ]
--   
setInfoBarShowCloseButton :: (MonadIO m, IsInfoBar o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-close-button” property. This is rarely needed directly,
--   but it is used by new.
constructInfoBarShowCloseButton :: (IsInfoBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new InfoBar object.
--   
--   Since: 2.18
infoBarNew :: (HasCallStack, MonadIO m) => m InfoBar

-- | Add an activatable widget to the action area of a InfoBar,
--   connecting a signal handler that will emit the
--   InfoBar::response signal on the message area when the widget is
--   activated. The widget is appended to the end of the message areas
--   action area.
--   
--   Since: 2.18
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.
--   
--   Since: 2.18
infoBarAddButton :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Text -> Int32 -> m Button

-- | Returns the action area of infoBar.
--   
--   Since: 2.18
infoBarGetActionArea :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> m Box

-- | Returns the content area of infoBar.
--   
--   Since: 2.18
infoBarGetContentArea :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> m Box

-- | Returns the message type of the message area.
--   
--   Since: 2.18
infoBarGetMessageType :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> m MessageType

-- | No description available in the introspection data.
--   
--   Since: 3.22.29
infoBarGetRevealed :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> m Bool

-- | Returns whether the widget will display a standard close button.
--   
--   Since: 3.10
infoBarGetShowCloseButton :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> m Bool

-- | Emits the “response” signal with the given responseId.
--   
--   Since: 2.18
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 infoBar to
--   be added to a widget hierarchy.
--   
--   Since: 2.18
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.
--   
--   Since: 2.18
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.
--   
--   Since: 2.18
infoBarSetResponseSensitive :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Int32 -> Bool -> m ()

-- | Sets the GtkInfoBar:revealed property to revealed.
--   This will cause infoBar to show up with a slide-in
--   transition.
--   
--   Note that this property does not automatically show
--   infoBar and thus won’t have any effect if it is
--   invisible.
--   
--   Since: 3.22.29
infoBarSetRevealed :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Bool -> m ()

-- | If true, a standard close button is shown. When clicked it emits the
--   response ResponseTypeClose.
--   
--   Since: 3.10
infoBarSetShowCloseButton :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to FontButton,
--   for instance with toFontButton.
class (GObject o, IsDescendantOf FontButton o) => IsFontButton o

-- | Cast to FontButton, for types for which this is known to be
--   safe. For general casts, use castTo.
toFontButton :: (MonadIO m, IsFontButton o) => o -> m FontButton

-- | The fontSet signal is emitted when the user selects a font.
--   When handling this signal, use fontChooserGetFont 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
--   notifyfont signal.
--   
--   Since: 2.4
type FontButtonFontSetCallback = IO ()

-- | Connect a signal handler for the fontSet signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on fontButton #fontSet callback
--   
onFontButtonFontSet :: (IsFontButton a, MonadIO m) => a -> ((?self :: a) => FontButtonFontSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the fontSet signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after fontButton #fontSet callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterFontButtonFontSet :: (IsFontButton a, MonadIO m) => a -> ((?self :: a) => FontButtonFontSetCallback) -> m SignalHandlerId

-- | Get the value of the “font-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontButton #fontName
--   
getFontButtonFontName :: (MonadIO m, IsFontButton o) => o -> m Text

-- | Set the value of the “font-name” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fontButton [ #fontName := value ]
--   
setFontButtonFontName :: (MonadIO m, IsFontButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “font-name” property. This is rarely needed directly, but it
--   is used by new.
constructFontButtonFontName :: (IsFontButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “font-name” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #fontName
--   
clearFontButtonFontName :: (MonadIO m, IsFontButton o) => o -> m ()

-- | Get the value of the “show-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontButton #showSize
--   
getFontButtonShowSize :: (MonadIO m, IsFontButton o) => o -> m Bool

-- | Set the value of the “show-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fontButton [ #showSize := value ]
--   
setFontButtonShowSize :: (MonadIO m, IsFontButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-size” property. This is rarely needed directly, but it
--   is used by new.
constructFontButtonShowSize :: (IsFontButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontButton #showStyle
--   
getFontButtonShowStyle :: (MonadIO m, IsFontButton o) => o -> m Bool

-- | Set the value of the “show-style” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fontButton [ #showStyle := value ]
--   
setFontButtonShowStyle :: (MonadIO m, IsFontButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-style” property. This is rarely needed directly, but it
--   is used by new.
constructFontButtonShowStyle :: (IsFontButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontButton #title
--   
getFontButtonTitle :: (MonadIO m, IsFontButton o) => o -> m Text

-- | Set the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fontButton [ #title := value ]
--   
setFontButtonTitle :: (MonadIO m, IsFontButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “title” property. This is rarely needed directly, but it is
--   used by new.
constructFontButtonTitle :: (IsFontButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “use-font” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontButton #useFont
--   
getFontButtonUseFont :: (MonadIO m, IsFontButton o) => o -> m Bool

-- | Set the value of the “use-font” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fontButton [ #useFont := value ]
--   
setFontButtonUseFont :: (MonadIO m, IsFontButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-font” property. This is rarely needed directly, but it
--   is used by new.
constructFontButtonUseFont :: (IsFontButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “use-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get fontButton #useSize
--   
getFontButtonUseSize :: (MonadIO m, IsFontButton o) => o -> m Bool

-- | Set the value of the “use-size” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set fontButton [ #useSize := value ]
--   
setFontButtonUseSize :: (MonadIO m, IsFontButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-size” property. This is rarely needed directly, but it
--   is used by new.
constructFontButtonUseSize :: (IsFontButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new font picker widget.
--   
--   Since: 2.4
fontButtonNew :: (HasCallStack, MonadIO m) => m FontButton

-- | Creates a new font picker widget.
--   
--   Since: 2.4
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 fontDescriptionFromString .
--   If you’re interested in peeking certain values (family name, style,
--   size, weight) just query these properties from the
--   FontDescription object.
--   
--   Since: 2.4
fontButtonGetFontName :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Text

-- | Returns whether the font size will be shown in the label.
--   
--   Since: 2.4
fontButtonGetShowSize :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Bool

-- | Returns whether the name of the font style will be shown in the label.
--   
--   Since: 2.4
fontButtonGetShowStyle :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Bool

-- | Retrieves the title of the font chooser dialog.
--   
--   Since: 2.4
fontButtonGetTitle :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Text

-- | Returns whether the selected font is used in the label.
--   
--   Since: 2.4
fontButtonGetUseFont :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Bool

-- | Returns whether the selected size is used in the label.
--   
--   Since: 2.4
fontButtonGetUseSize :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Bool

-- | Sets or updates the currently-displayed font in font picker dialog.
--   
--   Since: 2.4
fontButtonSetFontName :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Text -> m Bool

-- | If showSize is True, the font size will be
--   displayed along with the name of the selected font.
--   
--   Since: 2.4
fontButtonSetShowSize :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Bool -> m ()

-- | If showStyle is True, the font style will be
--   displayed along with name of the selected font.
--   
--   Since: 2.4
fontButtonSetShowStyle :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Bool -> m ()

-- | Sets the title for the font chooser dialog.
--   
--   Since: 2.4
fontButtonSetTitle :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Text -> m ()

-- | If useFont is True, the font name will be
--   written using the selected font.
--   
--   Since: 2.4
fontButtonSetUseFont :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Bool -> m ()

-- | If useSize is True, the font name will be
--   written using the selected size.
--   
--   Since: 2.4
fontButtonSetUseSize :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to ColorButton,
--   for instance with toColorButton.
class (GObject o, IsDescendantOf ColorButton o) => IsColorButton o

-- | Cast to ColorButton, for types for which this is known to be
--   safe. For general casts, use castTo.
toColorButton :: (MonadIO m, IsColorButton o) => o -> m ColorButton

-- | The colorSet signal is emitted when the user selects a color.
--   When handling this signal, use
--   gtk_color_button_get_rgba() 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
--   notifycolor signal.
--   
--   Since: 2.4
type ColorButtonColorSetCallback = IO ()

-- | Connect a signal handler for the colorSet signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on colorButton #colorSet callback
--   
onColorButtonColorSet :: (IsColorButton a, MonadIO m) => a -> ((?self :: a) => ColorButtonColorSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the colorSet signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after colorButton #colorSet callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterColorButtonColorSet :: (IsColorButton a, MonadIO m) => a -> ((?self :: a) => ColorButtonColorSetCallback) -> m SignalHandlerId

-- | Get the value of the “alpha” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorButton #alpha
--   
getColorButtonAlpha :: (MonadIO m, IsColorButton o) => o -> m Word32

-- | Set the value of the “alpha” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set colorButton [ #alpha := value ]
--   
setColorButtonAlpha :: (MonadIO m, IsColorButton o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “alpha” property. This is rarely needed directly, but it is
--   used by new.
constructColorButtonAlpha :: (IsColorButton o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “color” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorButton #color
--   
getColorButtonColor :: (MonadIO m, IsColorButton o) => o -> m (Maybe Color)

-- | Set the value of the “color” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set colorButton [ #color := value ]
--   
setColorButtonColor :: (MonadIO m, IsColorButton o) => o -> Color -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “color” property. This is rarely needed directly, but it is
--   used by new.
constructColorButtonColor :: (IsColorButton o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Get the value of the “rgba” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get colorButton #rgba
--   
getColorButtonRgba :: (MonadIO m, IsColorButton o) => o -> m (Maybe RGBA)

-- | Set the value of the “rgba” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set colorButton [ #rgba := value ]
--   
setColorButtonRgba :: (MonadIO m, IsColorButton o) => o -> RGBA -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “rgba” property. This is rarely needed directly, but it is
--   used by new.
constructColorButtonRgba :: (IsColorButton o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “rgba” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #rgba
--   
clearColorButtonRgba :: (MonadIO m, IsColorButton o) => o -> m ()

-- | Get the value of the “show-editor” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorButton #showEditor
--   
getColorButtonShowEditor :: (MonadIO m, IsColorButton o) => o -> m Bool

-- | Set the value of the “show-editor” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set colorButton [ #showEditor := value ]
--   
setColorButtonShowEditor :: (MonadIO m, IsColorButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-editor” property. This is rarely needed directly, but
--   it is used by new.
constructColorButtonShowEditor :: (IsColorButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorButton #title
--   
getColorButtonTitle :: (MonadIO m, IsColorButton o) => o -> m Text

-- | Set the value of the “title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set colorButton [ #title := value ]
--   
setColorButtonTitle :: (MonadIO m, IsColorButton o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “title” property. This is rarely needed directly, but it is
--   used by new.
constructColorButtonTitle :: (IsColorButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “use-alpha” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get colorButton #useAlpha
--   
getColorButtonUseAlpha :: (MonadIO m, IsColorButton o) => o -> m Bool

-- | Set the value of the “use-alpha” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set colorButton [ #useAlpha := value ]
--   
setColorButtonUseAlpha :: (MonadIO m, IsColorButton o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “use-alpha” property. This is rarely needed directly, but it
--   is used by new.
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.
--   
--   Since: 2.4
colorButtonNew :: (HasCallStack, MonadIO m) => m ColorButton

-- | Creates a new color button.
--   
--   Since: 2.4
colorButtonNewWithColor :: (HasCallStack, MonadIO m) => Color -> m ColorButton

-- | Creates a new color button.
--   
--   Since: 3.0
colorButtonNewWithRgba :: (HasCallStack, MonadIO m) => RGBA -> m ColorButton

-- | Returns the current alpha value.
--   
--   Since: 2.4
colorButtonGetAlpha :: (HasCallStack, MonadIO m, IsColorButton a) => a -> m Word16

-- | Sets color to be the current color in the
--   ColorButton widget.
--   
--   Since: 2.4
colorButtonGetColor :: (HasCallStack, MonadIO m, IsColorButton a) => a -> m Color

-- | Gets the title of the color selection dialog.
--   
--   Since: 2.4
colorButtonGetTitle :: (HasCallStack, MonadIO m, IsColorButton a) => a -> m Text

-- | Does the color selection dialog use the alpha channel ?
--   
--   Since: 2.4
colorButtonGetUseAlpha :: (HasCallStack, MonadIO m, IsColorButton a) => a -> m Bool

-- | Sets the current opacity to be alpha.
--   
--   Since: 2.4
colorButtonSetAlpha :: (HasCallStack, MonadIO m, IsColorButton a) => a -> Word16 -> m ()

-- | Sets the current color to be color.
--   
--   Since: 2.4
colorButtonSetColor :: (HasCallStack, MonadIO m, IsColorButton a) => a -> Color -> m ()

-- | Sets the title for the color selection dialog.
--   
--   Since: 2.4
colorButtonSetTitle :: (HasCallStack, MonadIO m, IsColorButton a) => a -> Text -> m ()

-- | Sets whether or not the color button should use the alpha channel.
--   
--   Since: 2.4
colorButtonSetUseAlpha :: (HasCallStack, MonadIO m, IsColorButton a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to CheckButton,
--   for instance with toCheckButton.
class (GObject o, IsDescendantOf CheckButton o) => IsCheckButton o

-- | Cast to CheckButton, for types for which this is known to be
--   safe. For general casts, use castTo.
toCheckButton :: (MonadIO m, IsCheckButton o) => o -> m CheckButton

-- | Creates a new CheckButton.
checkButtonNew :: (HasCallStack, MonadIO m) => m CheckButton

-- | Creates a new CheckButton with a Label to the right of
--   it.
checkButtonNewWithLabel :: (HasCallStack, MonadIO m) => Text -> m CheckButton

-- | Creates a new CheckButton containing a label. The label will be
--   created using labelNewWithMnemonic, so underscores in
--   label indicate the mnemonic for the check button.
checkButtonNewWithMnemonic :: (HasCallStack, MonadIO m) => Text -> m CheckButton

-- | Type class for types which can be safely cast to RadioButton,
--   for instance with toRadioButton.
class (GObject o, IsDescendantOf RadioButton o) => IsRadioButton o

-- | Cast to RadioButton, for types for which this is known to be
--   safe. For general casts, use castTo.
toRadioButton :: (MonadIO m, IsRadioButton o) => o -> m RadioButton

-- | 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.
--   
--   Since: 2.4
type RadioButtonGroupChangedCallback = IO ()

-- | Connect a signal handler for the groupChanged signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on radioButton #groupChanged callback
--   
onRadioButtonGroupChanged :: (IsRadioButton a, MonadIO m) => a -> ((?self :: a) => RadioButtonGroupChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the groupChanged signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after radioButton #groupChanged callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterRadioButtonGroupChanged :: (IsRadioButton a, MonadIO m) => a -> ((?self :: a) => RadioButtonGroupChangedCallback) -> m SignalHandlerId

-- | Set the value of the “group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set radioButton [ #group := value ]
--   
setRadioButtonGroup :: (MonadIO m, IsRadioButton o, IsRadioButton a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “group” property. This is rarely needed directly, but it is
--   used by new.
constructRadioButtonGroup :: (IsRadioButton o, MonadIO m, IsRadioButton a) => a -> m (GValueConstruct o)

-- | Set the value of the “group” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #group
--   
clearRadioButtonGroup :: (MonadIO m, IsRadioButton o) => o -> m ()

-- | Creates a new RadioButton, adding it to the same group as
--   radioGroupMember. As with radioButtonNew, a
--   widget should be packed into the radio button.
radioButtonNewFromWidget :: (HasCallStack, MonadIO m, IsRadioButton a) => Maybe a -> m RadioButton

-- | Creates a new RadioButton with a text label.
radioButtonNewWithLabel :: (HasCallStack, MonadIO m, IsRadioButton a) => [a] -> Text -> m RadioButton

-- | Creates a new RadioButton with a text label, adding it to the
--   same group as radioGroupMember.
radioButtonNewWithLabelFromWidget :: (HasCallStack, MonadIO m, IsRadioButton a) => Maybe a -> Text -> m RadioButton

-- | Creates a new RadioButton containing a label, adding it to the
--   same group as group. The label will be created using
--   labelNewWithMnemonic, so underscores in label
--   indicate the mnemonic for the button.
radioButtonNewWithMnemonic :: (HasCallStack, MonadIO m, IsRadioButton a) => [a] -> Text -> m RadioButton

-- | Creates a new RadioButton containing a label. The label will be
--   created using labelNewWithMnemonic, so underscores in
--   label indicate the mnemonic for the button.
radioButtonNewWithMnemonicFromWidget :: (HasCallStack, MonadIO m, IsRadioButton a) => Maybe a -> Text -> m RadioButton

-- | Joins a RadioButton object to the group of another
--   RadioButton object
--   
--   Use this in language bindings instead of the
--   radioButtonGetGroup and radioButtonSetGroup methods
--   
--   A common way to set up a group of radio buttons is the following:
--   
--   
C code
--   
--   
--   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;
--     }
--   
--   
--   Since: 3.0
radioButtonJoinGroup :: (HasCallStack, MonadIO m, IsRadioButton a, IsRadioButton b) => a -> Maybe b -> m ()

-- | Type class for types which can be safely cast to
--   RadioToolButton, for instance with toRadioToolButton.
class (GObject o, IsDescendantOf RadioToolButton o) => IsRadioToolButton o

-- | Cast to RadioToolButton, for types for which this is known to
--   be safe. For general casts, use castTo.
toRadioToolButton :: (MonadIO m, IsRadioToolButton o) => o -> m RadioToolButton

-- | Set the value of the “group” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set radioToolButton [ #group := value ]
--   
setRadioToolButtonGroup :: (MonadIO m, IsRadioToolButton o, IsRadioToolButton a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “group” property. This is rarely needed directly, but it is
--   used by new.
constructRadioToolButtonGroup :: (IsRadioToolButton o, MonadIO m, IsRadioToolButton a) => a -> m (GValueConstruct o)

-- | Set the value of the “group” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #group
--   
clearRadioToolButtonGroup :: (MonadIO m, IsRadioToolButton o) => o -> m ()

-- | Creates a new RadioToolButton, adding it to
--   group.
--   
--   Since: 2.4
radioToolButtonNew :: (HasCallStack, MonadIO m, IsRadioButton a) => [a] -> m RadioToolButton

-- | Creates a new RadioToolButton, adding it to
--   group. The new RadioToolButton will contain an
--   icon and label from the stock item indicated by
--   stockId.
--   
--   Since: 2.4
radioToolButtonNewFromStock :: (HasCallStack, MonadIO m, IsRadioButton a) => [a] -> Text -> m RadioToolButton

-- | Creates a new RadioToolButton adding it to the same group as
--   gruup
--   
--   Since: 2.4
radioToolButtonNewFromWidget :: (HasCallStack, MonadIO m, IsRadioToolButton a) => Maybe a -> m RadioToolButton

-- | Creates a new RadioToolButton adding it to the same group as
--   group. The new RadioToolButton will contain an
--   icon and label from the stock item indicated by
--   stockId.
--   
--   Since: 2.4
radioToolButtonNewWithStockFromWidget :: (HasCallStack, MonadIO m, IsRadioToolButton a) => Maybe a -> Text -> m RadioToolButton

-- | Returns the radio button group button belongs to.
--   
--   Since: 2.4
radioToolButtonGetGroup :: (HasCallStack, MonadIO m, IsRadioToolButton a) => a -> m [RadioButton]

-- | Adds button to group, removing it from
--   the group it belonged to before.
--   
--   Since: 2.4
radioToolButtonSetGroup :: (HasCallStack, MonadIO m, IsRadioToolButton a, IsRadioButton b) => a -> [b] -> m ()

-- | Type class for types which can be safely cast to
--   AppChooserWidget, for instance with toAppChooserWidget.
class (GObject o, IsDescendantOf AppChooserWidget o) => IsAppChooserWidget o

-- | Cast to AppChooserWidget, for types for which this is known to
--   be safe. For general casts, use castTo.
toAppChooserWidget :: (MonadIO m, IsAppChooserWidget o) => o -> m AppChooserWidget

-- | Emitted when a context menu is about to popup over an application
--   item. Clients can insert menu items into the provided Menu
--   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 ()

-- | Connect a signal handler for the applicationActivated signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on appChooserWidget #applicationActivated callback
--   
onAppChooserWidgetApplicationActivated :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetApplicationActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the applicationActivated signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after appChooserWidget #applicationActivated callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAppChooserWidgetApplicationActivated :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetApplicationActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the applicationSelected signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on appChooserWidget #applicationSelected callback
--   
onAppChooserWidgetApplicationSelected :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetApplicationSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the applicationSelected signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after appChooserWidget #applicationSelected callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAppChooserWidgetApplicationSelected :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetApplicationSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the populatePopup signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on appChooserWidget #populatePopup callback
--   
onAppChooserWidgetPopulatePopup :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the populatePopup signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after appChooserWidget #populatePopup callback
--   
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   ?self parameter. Note that this requires activating the
--   ImplicitParams GHC extension.
afterAppChooserWidgetPopulatePopup :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetPopulatePopupCallback) -> m SignalHandlerId

-- | Get the value of the “default-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get appChooserWidget #defaultText
--   
getAppChooserWidgetDefaultText :: (MonadIO m, IsAppChooserWidget o) => o -> m Text

-- | Set the value of the “default-text” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set appChooserWidget [ #defaultText := value ]
--   
setAppChooserWidgetDefaultText :: (MonadIO m, IsAppChooserWidget o) => o -> Text -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “default-text” property. This is rarely needed directly, but
--   it is used by new.
constructAppChooserWidgetDefaultText :: (IsAppChooserWidget o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “show-all” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get appChooserWidget #showAll
--   
getAppChooserWidgetShowAll :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “show-all” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set appChooserWidget [ #showAll := value ]
--   
setAppChooserWidgetShowAll :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-all” property. This is rarely needed directly, but it
--   is used by new.
constructAppChooserWidgetShowAll :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-default” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get appChooserWidget #showDefault
--   
getAppChooserWidgetShowDefault :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “show-default” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set appChooserWidget [ #showDefault := value ]
--   
setAppChooserWidgetShowDefault :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-default” property. This is rarely needed directly, but
--   it is used by new.
constructAppChooserWidgetShowDefault :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-fallback” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get appChooserWidget #showFallback
--   
getAppChooserWidgetShowFallback :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “show-fallback” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set appChooserWidget [ #showFallback := value ]
--   
setAppChooserWidgetShowFallback :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-fallback” property. This is rarely needed directly, but
--   it is used by new.
constructAppChooserWidgetShowFallback :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-other” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get appChooserWidget #showOther
--   
getAppChooserWidgetShowOther :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “show-other” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set appChooserWidget [ #showOther := value ]
--   
setAppChooserWidgetShowOther :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-other” property. This is rarely needed directly, but it
--   is used by new.
constructAppChooserWidgetShowOther :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “show-recommended” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get appChooserWidget #showRecommended
--   
getAppChooserWidgetShowRecommended :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “show-recommended” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set appChooserWidget [ #showRecommended := value ]
--   
setAppChooserWidgetShowRecommended :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “show-recommended” property. This is rarely needed directly,
--   but it is used by new.
constructAppChooserWidgetShowRecommended :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new AppChooserWidget for applications that can handle
--   content of the given type.
--   
--   Since: 3.0
appChooserWidgetNew :: (HasCallStack, MonadIO m) => Text -> m AppChooserWidget

-- | Returns the text that is shown if there are not applications that can
--   handle the content type.
--   
--   Since: 3.0
appChooserWidgetGetDefaultText :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Text

-- | Returns the current value of the AppChooserWidget:showAll
--   property.
--   
--   Since: 3.0
appChooserWidgetGetShowAll :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Bool

-- | Returns the current value of the AppChooserWidget:showDefault
--   property.
--   
--   Since: 3.0
appChooserWidgetGetShowDefault :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Bool

-- | Returns the current value of the AppChooserWidget:showFallback
--   property.
--   
--   Since: 3.0
appChooserWidgetGetShowFallback :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Bool

-- | Returns the current value of the AppChooserWidget:showOther
--   property.
--   
--   Since: 3.0
appChooserWidgetGetShowOther :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Bool

-- | Returns the current value of the
--   AppChooserWidget:showRecommended property.
--   
--   Since: 3.0
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.
--   
--   Since: 3.0
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.
--   
--   Since: 3.0
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.
--   
--   Since: 3.0
appChooserWidgetSetShowFallback :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> Bool -> m ()

-- | Sets whether the app chooser should show applications which are
--   unrelated to the content type.
--   
--   Since: 3.0
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.
--   
--   Since: 3.0
appChooserWidgetSetShowRecommended :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> Bool -> m ()

-- | Type class for types which can be safely cast to AccelLabel,
--   for instance with toAccelLabel.
class (GObject o, IsDescendantOf AccelLabel o) => IsAccelLabel o

-- | Cast to AccelLabel, for types for which this is known to be
--   safe. For general casts, use castTo.
toAccelLabel :: (MonadIO m, IsAccelLabel o) => o -> m AccelLabel

-- | Get the value of the “accel-closure” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get accelLabel #accelClosure
--   
getAccelLabelAccelClosure :: (MonadIO m, IsAccelLabel o) => o -> m (Maybe (GClosure ()))

-- | Set the value of the “accel-closure” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set accelLabel [ #accelClosure := value ]
--   
setAccelLabelAccelClosure :: (MonadIO m, IsAccelLabel o) => o -> GClosure a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accel-closure” property. This is rarely needed directly, but
--   it is used by new.
constructAccelLabelAccelClosure :: (IsAccelLabel o, MonadIO m) => GClosure a -> m (GValueConstruct o)

-- | Set the value of the “accel-closure” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #accelClosure
--   
clearAccelLabelAccelClosure :: (MonadIO m, IsAccelLabel o) => o -> m ()

-- | Get the value of the “accel-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get accelLabel #accelWidget
--   
getAccelLabelAccelWidget :: (MonadIO m, IsAccelLabel o) => o -> m (Maybe Widget)

-- | Set the value of the “accel-widget” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set accelLabel [ #accelWidget := value ]
--   
setAccelLabelAccelWidget :: (MonadIO m, IsAccelLabel o, IsWidget a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “accel-widget” property. This is rarely needed directly, but
--   it is used by new.
constructAccelLabelAccelWidget :: (IsAccelLabel o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “accel-widget” property to
--   Nothing. When overloading is enabled, this is equivalent
--   to
--   
--   
--   clear #accelWidget
--   
clearAccelLabelAccelWidget :: (MonadIO m, IsAccelLabel o) => o -> m ()

-- | Creates a new AccelLabel.
accelLabelNew :: (HasCallStack, MonadIO m) => Text -> m AccelLabel

-- | Gets the keyval and modifier mask set with accelLabelSetAccel.
--   
--   Since: 3.12
accelLabelGetAccel :: (HasCallStack, MonadIO m, IsAccelLabel a) => a -> m (Word32, [ModifierType])

-- | Fetches the widget monitored by this accelerator label. See
--   accelLabelSetAccelWidget.
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 MenuItem 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

-- | Sets the closure to be monitored by this accelerator label. The
--   closure must be connected to an accelerator group; see
--   accelGroupConnect. Passing Nothing for
--   accelClosure will dissociate
--   accelLabel from its current closure, if any.
accelLabelSetAccelClosure :: (HasCallStack, MonadIO m, IsAccelLabel a) => a -> Maybe (GClosure b) -> m ()

-- | Sets selection data of target type GTK_TREE_MODEL_ROW.
--   Normally used in a drag_data_get handler.
treeSetRowDragData :: (HasCallStack, MonadIO m, IsTreeModel a) => SelectionData -> a -> TreePath -> m Bool

-- | Obtains a treeModel and path from
--   selection data of target type GTK_TREE_MODEL_ROW.
--   Normally called from a drag_data_received handler. This function can
--   only be used if selectionData 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 TreeDragDest
--   drag_data_received handler, you can assume that selection data of type
--   GTK_TREE_MODEL_ROW is in from the current process. The
--   returned path must be freed with treePathFree.
treeGetRowDragData :: (HasCallStack, MonadIO m) => SelectionData -> m (Bool, Maybe TreeModel, Maybe TreePath)

-- | Enters the main loop and waits for widget to be
--   “drawn”. In this context that means it waits for the frame clock of
--   widget to have run a full styling, layout and drawing
--   cycle.
--   
--   This function is intended to be used for syncing with actions that
--   depend on widget relayouting or on interaction with
--   the display server.
--   
--   Since: 3.10
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
--   widget. For windowless widgets like Button
--   (which returns False from widgetGetHasWindow), this will
--   often be an input-only event window. For other widgets, this is
--   usually widget->window. Certain caveats should be considered when
--   using this function, in particular because the mouse pointer is warped
--   to the key press location, see testSimulateKey for details.
--   
--   Since: 2.14
testWidgetSendKey :: (HasCallStack, MonadIO m, IsWidget a) => a -> Word32 -> [ModifierType] -> m Bool

-- | Set the text string of widget to
--   string if it is a GtkLabel, GtkEditable (entry and
--   text widgets) or GtkTextView.
--   
--   Since: 2.14
testTextSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m ()

-- | Retrive the text string of widget if it is a GtkLabel,
--   GtkEditable (entry and text widgets) or GtkTextView.
--   
--   Since: 2.14
testTextGet :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Text

-- | This function will generate a button click in the
--   upwards or downwards spin button arrow areas, usually leading to an
--   increase or decrease of spin button’s value.
--   
--   Since: 2.14
testSpinButtonClick :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Word32 -> Bool -> m Bool

-- | 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 widget, and is not a percentage as passed
--   in to testSliderSetPerc.
--   
--   Since: 2.14
testSliderGetValue :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Double

-- | Return the type ids that have been registered after calling
--   testRegisterAllTypes.
--   
--   Since: 2.14
testListAllTypes :: (HasCallStack, MonadIO m) => m ([GType], Word32)

-- | This function will search the descendants of widget
--   for a widget of type widgetType that has a label
--   matching labelPattern 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 testFindLabel,
--   testFindSibling and testWidgetClick for possible caveats
--   involving the search of such widgets and synthesizing widget events.
--   
--   Since: 2.14
testFindWidget :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> GType -> m (Maybe Widget)

-- | Create a simple window with window title windowTitle
--   and text contents dialogText. The window will quit any
--   running main-loop when destroyed, and it will automatically be
--   destroyed upon test function teardown.
--   
--   Since: 2.14
testCreateSimpleWindow :: (HasCallStack, MonadIO m) => Text -> Text -> m Widget

-- | Determines if any of the targets in targets can be
--   used to provide an uri list.
--   
--   Since: 2.10
targetsIncludeUri :: (HasCallStack, MonadIO m) => [Atom] -> m Bool

-- | Determines if any of the targets in targets can be
--   used to provide text.
--   
--   Since: 2.10
targetsIncludeText :: (HasCallStack, MonadIO m) => [Atom] -> m Bool

-- | Determines if any of the targets in targets can be
--   used to provide rich text.
--   
--   Since: 2.10
targetsIncludeRichText :: (HasCallStack, MonadIO m, IsTextBuffer a) => [Atom] -> a -> m Bool

-- | Determines if any of the targets in targets can be
--   used to provide a Pixbuf.
--   
--   Since: 2.10
targetsIncludeImage :: (HasCallStack, MonadIO m) => [Atom] -> Bool -> m Bool

-- | Sets a function to be used for translating the label
--   of a stock item.
--   
--   If no function is registered for a translation domain, dgettext
--   is used.
--   
--   The function is used for all stock items whose
--   translationDomain matches domain. Note
--   that it is possible to use strings different from the actual gettext
--   translation domain of your application for this, as long as your
--   TranslateFunc uses the correct domain when calling
--   dgettext(). This can be useful, e.g. when dealing with
--   message contexts:
--   
--   
C code
--   
--   
--   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");
--   
--   
--   Since: 2.8
stockSetTranslateFunc :: (HasCallStack, MonadIO m) => Text -> TranslateFunc -> m ()

-- | Retrieves a list of all known stock IDs added to a IconFactory
--   or registered with stockAdd. The list must be freed with
--   g_slist_free(), and each string in the list must be
--   freed with free.
stockListIds :: (HasCallStack, MonadIO m) => m [Text]

-- | 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.
--   
--   Since: 2.14
rgbToHsv :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m (Double, Double, Double)

-- | Renders a slider (as in Scale) in the rectangle defined by
--   x, y, width,
--   height. orientation defines whether
--   the slider is vertical or horizontal.
--   
--   Typical slider rendering:
--   
--   
--   Since: 3.0
renderSlider :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> Orientation -> m ()

-- | Renders an option mark (as in a RadioButton), the
--   StateFlagsChecked state will determine whether the option is on
--   or off, and StateFlagsInconsistent whether it should be marked
--   as undefined.
--   
--   Typical option mark rendering:
--   
--   
--   Since: 3.0
renderOption :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders a line from (x0, y0) to (x1, y1).
--   
--   Since: 3.0
renderLine :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders layout on the coordinates x,
--   y
--   
--   Since: 3.0
renderLayout :: (HasCallStack, MonadIO m, IsStyleContext a, IsLayout b) => a -> Context -> Double -> Double -> b -> m ()

-- | Draws a text caret on cr at the specified index of
--   layout.
--   
--   Since: 3.4
renderInsertionCursor :: (HasCallStack, MonadIO m, IsStyleContext a, IsLayout b) => a -> Context -> Double -> Double -> b -> Int32 -> Direction -> m ()

-- | Renders the icon in pixbuf at the specified
--   x and y coordinates.
--   
--   This function will render the icon in pixbuf 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 renderIconSurface instead, if you
--   already have a Cairo surface.
--   
--   Since: 3.2
renderIcon :: (HasCallStack, MonadIO m, IsStyleContext a, IsPixbuf b) => a -> Context -> b -> Double -> Double -> m ()

-- | Renders a handle (as in HandleBox, Paned and
--   Window’s resize grip), in the rectangle determined by
--   x, y, width,
--   height.
--   
--   Handles rendered for the paned and grip classes:
--   
--   
--   Since: 3.0
renderHandle :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders a frame around the rectangle defined by (x,
--   y, width, height),
--   leaving a gap on one side. xy0Gap and
--   xy1Gap will mean X coordinates for
--   PositionTypeTop and PositionTypeBottom gap sides, and Y
--   coordinates for PositionTypeLeft and PositionTypeRight.
--   
--   Typical rendering of a frame with a gap:
--   
--   
--   Since: 3.0
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
--   x, y, width,
--   height.
--   
--   Typical focus rendering:
--   
--   
--   Since: 3.0
renderFocus :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders a extension (as in a Notebook tab) in the rectangle
--   defined by x, y,
--   width, height. The side where the
--   extension connects to is defined by gapSide.
--   
--   Typical extension rendering:
--   
--   
--   Since: 3.0
renderExtension :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> PositionType -> m ()

-- | Renders an expander (as used in TreeView and Expander)
--   in the area defined by x, y,
--   width, height. The state
--   StateFlagsChecked determines whether the expander is collapsed
--   or expanded.
--   
--   Typical expander rendering:
--   
--   
--   Since: 3.0
renderExpander :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders a checkmark (as in a CheckButton).
--   
--   The StateFlagsChecked state determines whether the check is on
--   or off, and StateFlagsInconsistent determines whether it should
--   be marked as undefined.
--   
--   Typical checkmark rendering:
--   
--   
--   Since: 3.0
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
--   renderBackground for the given context and
--   rectangle.
--   
--   Since: 3.20
renderBackgroundGetClip :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Double -> Double -> Double -> Double -> m Rectangle

-- | Renders an arrow pointing to angle.
--   
--   Typical arrow rendering at 0, 1⁄2 π;, π; and 3⁄2 π:
--   
--   
--   Since: 3.0
renderArrow :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders an activity indicator (such as in Spinner). The state
--   StateFlagsChecked determines whether there is activity going
--   on.
--   
--   Since: 3.0
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 init.
rcSetDefaultFiles :: (HasCallStack, MonadIO m) => [[Char]] -> m ()

-- | This function recomputes the styles for all widgets that use a
--   particular Settings object. (There is one Settings
--   object per Screen, see settingsGetForScreen); 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
--   widgetSetStyle.
--   
--   Since: 2.4
rcResetStyles :: (HasCallStack, MonadIO m, IsSettings a) => a -> m ()

-- | If the modification time on any previously read file for the given
--   Settings 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
--   Settings 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 StateType variable from the format expected in a RC
--   file.
rcParseState :: (HasCallStack, MonadIO m) => Scanner -> m (Word32, StateType)

-- | Parses a PathPriorityType 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.
--   
--   Note that theme engines should use rcParseColorFull 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 Style 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 rcGetStyle is similar to:
--   
--   
C code
--   
--   
--   gtk_widget_path (widget, NULL, &path, NULL);
--   gtk_widget_class_path (widget, NULL, &class_path, NULL);
--   gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget),
--                              path, class_path,
--                              G_OBJECT_TYPE (widget));
--   
rcGetStyleByPaths :: (HasCallStack, MonadIO m, IsSettings a) => a -> Maybe Text -> Maybe Text -> GType -> m (Maybe Style)

-- | Returns a directory in which GTK+ looks for theme engines. For full
--   information about the search for theme engines, see the docs for
--   GTK_PATH 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 GTK_PATH 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
--   GTK_IM_MODULE_FILE 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 init.
rcGetDefaultFiles :: (HasCallStack, MonadIO m) => m [[Char]]

-- | Looks up a file in pixmap path for the specified Settings. If
--   the file is not found, it outputs a warning message using
--   g_warning() and returns Nothing.
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
--   init.
rcAddDefaultFile :: (HasCallStack, MonadIO m) => [Char] -> m ()

-- | Draws a vertical line from (x, y1_) to
--   (x, y2_) in cr 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 cr 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 window 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 cr 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 cr 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 cr 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 cr 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
--   cr 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 cr 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 (x1, y)
--   to (x2, y) in cr 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 HandleBox and Paned.
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
--   cr 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 cr 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 TreeView. x and
--   y specify the center the expander. The size of the
--   expander is determined by the “expander-size” style property of
--   widget. (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 window 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
--   cr 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 cr 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 cr 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 cr using the
--   given parameters. arrowType 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 ()

-- | 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 waiting to be processed GTK+ will block until the
--   next event is noticed. If you don’t want to block look at
--   mainIterationDo or check if any events are pending with
--   eventsPending first.
mainIteration :: (HasCallStack, MonadIO m) => m Bool

-- | Removes the key snooper function with the given id.
keySnooperRemove :: (HasCallStack, MonadIO m) => Word32 -> m ()

-- | Queries the current grab of the default window group.
grabGetCurrent :: (HasCallStack, MonadIO m) => m (Maybe Widget)

-- | 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
--   setlocale() and will default to setting the
--   TextDirectionLtr direction otherwise. TextDirectionNone
--   will never be returned.
--   
--   GTK+ sets the default text direction according to the locale during
--   init, and you should normally use widgetGetDirection or
--   widgetGetDefaultDirection 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:
--   
--   
C code
--   
--   
--   setlocale (LC_ALL, new_locale);
--   direction = gtk_get_locale_direction ();
--   gtk_widget_set_default_direction (direction);
--   
--   
--   Since: 3.12
getLocaleDirection :: (HasCallStack, MonadIO m) => m TextDirection

-- | If event is Nothing or the event was not
--   associated with any widget, returns Nothing, 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 state and return True, otherwise
--   return False.
getCurrentEventState :: (HasCallStack, MonadIO m) => m (Bool, [ModifierType])

-- | If there is a current event and it has a device, return that device,
--   otherwise return Nothing.
getCurrentEventDevice :: (HasCallStack, MonadIO m) => m (Maybe Device)

-- | Analogical to true, this function does nothing but always
--   returns False.
false :: (HasCallStack, MonadIO m) => m Bool

-- | Draws a text caret on cr at location.
--   This is not a style function but merely a convenience function for
--   drawing the standard cursor shape.
--   
--   Since: 3.0
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 surface 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
--   cairo_surface_set_device_offset() on
--   surface. 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 pixbuf 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 the given icon.
--   See the documentation for dragSetIconName for more details
--   about using icons in drag and drop.
--   
--   Since: 3.2
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 widgetDragBeginWithCoordinates, or by connecting to
--   Widget::dragBegin.
--   
--   If context does not refer to an ongoing drag
--   operation, this function does nothing.
--   
--   If a drag is cancelled in this way, the result
--   argument of Widget::dragFailed is set to
--   gTKDRAGRESULTERROR.
--   
--   Since: 3.16
dragCancel :: (HasCallStack, MonadIO m, IsDragContext a) => a -> m ()

-- | Distributes extraSpace to child sizes
--   by bringing smaller children up to natural size first.
--   
--   The remaining space will be added to the minimumSize
--   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 init, initCheck, initWithArgs and
--   parseArgs from automatically calling setlocale (LC_ALL,
--   ""). 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 ()

-- | Transforms the given cairo context cr that from
--   widget-relative coordinates to
--   window-relative coordinates. If the
--   widget’s window is not an ancestor of
--   window, no modification will be applied.
--   
--   This is the inverse to the transformation GTK applies when preparing
--   an expose event to be emitted with the Widget::draw signal. It
--   is intended to help porting multiwindow widgets from GTK+ 2 to the
--   rendering architecture of GTK+ 3.
--   
--   Since: 3.0
cairoTransformToWindow :: (HasCallStack, MonadIO m, IsWidget a, IsWindow b) => Context -> a -> b -> m ()

-- | This function is supposed to be called in Widget::draw
--   implementations for widgets that support multiple windows.
--   cr must be untransformed from invoking of the draw
--   function. This function will return True if the contents of the
--   given window are supposed to be drawn and False
--   otherwise. Note that when the drawing was not initiated by the
--   windowing system this function will return True 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.
--   
--   Since: 3.0
cairoShouldDrawWindow :: (HasCallStack, MonadIO m, IsWindow a) => Context -> a -> m Bool

-- | Looks up key bindings for object to find one matching
--   event, and if one was found, activate it.
--   
--   Since: 2.4
bindingsActivateEvent :: (HasCallStack, MonadIO m, IsObject a) => a -> EventKey -> m Bool

-- | Find a key binding matching keyval and
--   modifiers and activate the binding on
--   object.
bindingsActivate :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> [ModifierType] -> m Bool

-- | Returns True if dialogs are expected to use an alternative
--   button order on the screen screen. See
--   gtk_dialog_set_alternative_button_order() for more
--   details about alternative button order.
--   
--   If you need to use this function, you should probably connect to the
--   notify:gtk-alternative-button-order signal on the
--   Settings object associated to screen, in order
--   to be notified if the button order setting changes.
--   
--   Since: 2.6
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 KEY_a keyval plus
--   GDK_CONTROL_MASK is valid - this is a “Ctrl+a”
--   accelerator. But, you can't, for instance, use the
--   KEY_Control_L keyval as an accelerator.
acceleratorValid :: (HasCallStack, MonadIO m) => Word32 -> [ModifierType] -> m Bool

-- | Converts an accelerator keyval and modifier mask into a string
--   parseable by acceleratorParseWithKeycode, similarly to
--   acceleratorName but handling keycodes. This is only useful for
--   system-level components, applications should use
--   acceleratorParse instead.
--   
--   Since: 3.4
acceleratorNameWithKeycode :: (HasCallStack, MonadIO m, IsDisplay a) => Maybe a -> Word32 -> 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
--   acceleratorGetLabel, but handling keycodes.
--   
--   This is only useful for system-level components, applications should
--   use acceleratorParse instead.
--   
--   Since: 3.4
acceleratorGetLabelWithKeycode :: (HasCallStack, MonadIO m, IsDisplay a) => Maybe a -> Word32 -> Word32 -> [ModifierType] -> m Text

-- | Gets the modifier mask.
--   
--   The modifier mask determines which modifiers are considered
--   significant for keyboard accelerators. See
--   acceleratorSetDefaultModMask.
acceleratorGetDefaultModMask :: (HasCallStack, MonadIO m) => m [ModifierType]

-- | Gets a list of all accel groups which are attached to
--   object.
accelGroupsFromObject :: (HasCallStack, MonadIO m, IsObject a) => a -> m [AccelGroup]

-- | Memory-managed wrapper type.
newtype WindowGeometryInfo
WindowGeometryInfo :: ManagedPtr WindowGeometryInfo -> WindowGeometryInfo
calendarDay :: AttrLabelProxy "day"
calendarMonth :: AttrLabelProxy "month"
calendarYear :: AttrLabelProxy "year"
data ActionableActionNamePropertyInfo
data ActionableActionTargetPropertyInfo
data ActionableGetActionNameMethodInfo
data ActionableGetActionTargetValueMethodInfo
data ActionableSetActionNameMethodInfo
data ActionableSetActionTargetValueMethodInfo
data ActionableSetDetailedActionNameMethodInfo
type family ResolveActionableMethod (t :: Symbol) o
actionableActionName :: AttrLabelProxy "actionName"
actionableActionTarget :: AttrLabelProxy "actionTarget"
data ActivatableDoSetRelatedActionMethodInfo
data ActivatableGetRelatedActionMethodInfo
data ActivatableGetUseActionAppearanceMethodInfo
data ActivatableRelatedActionPropertyInfo
data ActivatableSetRelatedActionMethodInfo
data ActivatableSetUseActionAppearanceMethodInfo
data ActivatableSyncActionPropertiesMethodInfo
data ActivatableUseActionAppearancePropertyInfo
type family ResolveActivatableMethod (t :: Symbol) o
activatableRelatedAction :: AttrLabelProxy "relatedAction"
activatableUseActionAppearance :: AttrLabelProxy "useActionAppearance"
data AppChooserContentTypePropertyInfo
data AppChooserGetAppInfoMethodInfo
data AppChooserGetContentTypeMethodInfo
data AppChooserRefreshMethodInfo
type family ResolveAppChooserMethod (t :: Symbol) o
appChooserContentType :: AttrLabelProxy "contentType"
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
cellEditableEditingCanceled :: AttrLabelProxy "editingCanceled"
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
colorChooserRgba :: AttrLabelProxy "rgba"
colorChooserUseAlpha :: AttrLabelProxy "useAlpha"
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
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"
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
fontChooserFont :: AttrLabelProxy "font"
fontChooserFontDesc :: AttrLabelProxy "fontDesc"
fontChooserFontFeatures :: AttrLabelProxy "fontFeatures"
fontChooserLanguage :: AttrLabelProxy "language"
fontChooserLevel :: AttrLabelProxy "level"
fontChooserPreviewText :: AttrLabelProxy "previewText"
fontChooserShowPreviewEntry :: AttrLabelProxy "showPreviewEntry"
data OrientableGetOrientationMethodInfo
data OrientableOrientationPropertyInfo
data OrientableSetOrientationMethodInfo
type family ResolveOrientableMethod (t :: Symbol) o
orientableOrientation :: AttrLabelProxy "orientation"
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
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"
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
scrollableHadjustment :: AttrLabelProxy "hadjustment"
scrollableHscrollPolicy :: AttrLabelProxy "hscrollPolicy"
scrollableVadjustment :: AttrLabelProxy "vadjustment"
scrollableVscrollPolicy :: AttrLabelProxy "vscrollPolicy"
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
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"
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
accelGroupIsLocked :: AttrLabelProxy "isLocked"
accelGroupModifierMask :: AttrLabelProxy "modifierMask"
data AccelLabelAccelClosurePropertyInfo
data AccelLabelAccelWidgetPropertyInfo
data AccelLabelGetAccelMethodInfo
data AccelLabelGetAccelWidgetMethodInfo
data AccelLabelGetAccelWidthMethodInfo
data AccelLabelRefetchMethodInfo
data AccelLabelSetAccelClosureMethodInfo
data AccelLabelSetAccelMethodInfo
data AccelLabelSetAccelWidgetMethodInfo
type family ResolveAccelLabelMethod (t :: Symbol) o
accelLabelAccelClosure :: AttrLabelProxy "accelClosure"
accelLabelAccelWidget :: AttrLabelProxy "accelWidget"
data AccelMapChangedSignalInfo
type family ResolveAccelMapMethod (t :: Symbol) o
data AccessibleConnectWidgetDestroyedMethodInfo
data AccessibleGetWidgetMethodInfo
data AccessibleSetWidgetMethodInfo
data AccessibleWidgetPropertyInfo
type family ResolveAccessibleMethod (t :: Symbol) o
accessibleWidget :: AttrLabelProxy "widget"
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
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"
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
actionGroupAccelGroup :: AttrLabelProxy "accelGroup"
actionGroupName :: AttrLabelProxy "name"
actionGroupSensitive :: AttrLabelProxy "sensitive"
actionGroupVisible :: AttrLabelProxy "visible"
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
adjustmentLower :: AttrLabelProxy "lower"
adjustmentPageIncrement :: AttrLabelProxy "pageIncrement"
adjustmentPageSize :: AttrLabelProxy "pageSize"
adjustmentStepIncrement :: AttrLabelProxy "stepIncrement"
adjustmentUpper :: AttrLabelProxy "upper"
adjustmentValue :: AttrLabelProxy "value"
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
alignmentBottomPadding :: AttrLabelProxy "bottomPadding"
alignmentLeftPadding :: AttrLabelProxy "leftPadding"
alignmentRightPadding :: AttrLabelProxy "rightPadding"
alignmentTopPadding :: AttrLabelProxy "topPadding"
alignmentXalign :: AttrLabelProxy "xalign"
alignmentXscale :: AttrLabelProxy "xscale"
alignmentYalign :: AttrLabelProxy "yalign"
alignmentYscale :: AttrLabelProxy "yscale"
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
appChooserButtonHeading :: AttrLabelProxy "heading"
appChooserButtonShowDefaultItem :: AttrLabelProxy "showDefaultItem"
appChooserButtonShowDialogItem :: AttrLabelProxy "showDialogItem"
data AppChooserDialogGetHeadingMethodInfo
data AppChooserDialogGetWidgetMethodInfo
data AppChooserDialogGfilePropertyInfo
data AppChooserDialogHeadingPropertyInfo
data AppChooserDialogSetHeadingMethodInfo
type family ResolveAppChooserDialogMethod (t :: Symbol) o
appChooserDialogGfile :: AttrLabelProxy "gfile"
appChooserDialogHeading :: AttrLabelProxy "heading"
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
appChooserWidgetDefaultText :: AttrLabelProxy "defaultText"
appChooserWidgetShowAll :: AttrLabelProxy "showAll"
appChooserWidgetShowDefault :: AttrLabelProxy "showDefault"
appChooserWidgetShowFallback :: AttrLabelProxy "showFallback"
appChooserWidgetShowOther :: AttrLabelProxy "showOther"
appChooserWidgetShowRecommended :: AttrLabelProxy "showRecommended"
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
applicationActiveWindow :: AttrLabelProxy "activeWindow"
applicationAppMenu :: AttrLabelProxy "appMenu"
applicationMenubar :: AttrLabelProxy "menubar"
applicationRegisterSession :: AttrLabelProxy "registerSession"
applicationScreensaverActive :: AttrLabelProxy "screensaverActive"
data ApplicationWindowGetHelpOverlayMethodInfo
data ApplicationWindowGetIdMethodInfo
data ApplicationWindowGetShowMenubarMethodInfo
data ApplicationWindowSetHelpOverlayMethodInfo
data ApplicationWindowSetShowMenubarMethodInfo
data ApplicationWindowShowMenubarPropertyInfo
type family ResolveApplicationWindowMethod (t :: Symbol) o
applicationWindowShowMenubar :: AttrLabelProxy "showMenubar"
data ArrowArrowTypePropertyInfo
data ArrowSetMethodInfo
data ArrowShadowTypePropertyInfo
type family ResolveArrowMethod (t :: Symbol) o
arrowArrowType :: AttrLabelProxy "arrowType"
arrowShadowType :: AttrLabelProxy "shadowType"
type family ResolveArrowAccessibleMethod (t :: Symbol) o
data AspectFrameObeyChildPropertyInfo
data AspectFrameRatioPropertyInfo
data AspectFrameSetMethodInfo
data AspectFrameXalignPropertyInfo
data AspectFrameYalignPropertyInfo
type family ResolveAspectFrameMethod (t :: Symbol) o
aspectFrameObeyChild :: AttrLabelProxy "obeyChild"
aspectFrameRatio :: AttrLabelProxy "ratio"
aspectFrameXalign :: AttrLabelProxy "xalign"
aspectFrameYalign :: AttrLabelProxy "yalign"
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
assistantUseHeaderBar :: AttrLabelProxy "useHeaderBar"
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
boxBaselinePosition :: AttrLabelProxy "baselinePosition"
boxHomogeneous :: AttrLabelProxy "homogeneous"
boxSpacing :: AttrLabelProxy "spacing"
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
builderTranslationDomain :: AttrLabelProxy "translationDomain"
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
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"
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
buttonBoxLayoutStyle :: AttrLabelProxy "layoutStyle"
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
calendarDetailHeightRows :: AttrLabelProxy "detailHeightRows"
calendarDetailWidthChars :: AttrLabelProxy "detailWidthChars"
calendarNoMonthChange :: AttrLabelProxy "noMonthChange"
calendarShowDayNames :: AttrLabelProxy "showDayNames"
calendarShowDetails :: AttrLabelProxy "showDetails"
calendarShowHeading :: AttrLabelProxy "showHeading"
calendarShowWeekNumbers :: AttrLabelProxy "showWeekNumbers"
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
cellAreaEditWidget :: AttrLabelProxy "editWidget"
cellAreaEditedCell :: AttrLabelProxy "editedCell"
cellAreaFocusCell :: AttrLabelProxy "focusCell"
data CellAreaBoxGetSpacingMethodInfo
data CellAreaBoxPackEndMethodInfo
data CellAreaBoxPackStartMethodInfo
data CellAreaBoxSetSpacingMethodInfo
data CellAreaBoxSpacingPropertyInfo
type family ResolveCellAreaBoxMethod (t :: Symbol) o
cellAreaBoxSpacing :: AttrLabelProxy "spacing"
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
cellAreaContextArea :: AttrLabelProxy "area"
cellAreaContextMinimumHeight :: AttrLabelProxy "minimumHeight"
cellAreaContextMinimumWidth :: AttrLabelProxy "minimumWidth"
cellAreaContextNaturalHeight :: AttrLabelProxy "naturalHeight"
cellAreaContextNaturalWidth :: AttrLabelProxy "naturalWidth"
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
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"
data CellRendererAccelAccelClearedSignalInfo
data CellRendererAccelAccelEditedSignalInfo
data CellRendererAccelAccelKeyPropertyInfo
data CellRendererAccelAccelModePropertyInfo
data CellRendererAccelAccelModsPropertyInfo
data CellRendererAccelKeycodePropertyInfo
type family ResolveCellRendererAccelMethod (t :: Symbol) o
cellRendererAccelAccelKey :: AttrLabelProxy "accelKey"
cellRendererAccelAccelMode :: AttrLabelProxy "accelMode"
cellRendererAccelAccelMods :: AttrLabelProxy "accelMods"
cellRendererAccelKeycode :: AttrLabelProxy "keycode"
data CellRendererComboChangedSignalInfo
data CellRendererComboHasEntryPropertyInfo
data CellRendererComboModelPropertyInfo
data CellRendererComboTextColumnPropertyInfo
type family ResolveCellRendererComboMethod (t :: Symbol) o
cellRendererComboHasEntry :: AttrLabelProxy "hasEntry"
cellRendererComboModel :: AttrLabelProxy "model"
cellRendererComboTextColumn :: AttrLabelProxy "textColumn"
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
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"
data CellRendererProgressInvertedPropertyInfo
data CellRendererProgressPulsePropertyInfo
data CellRendererProgressTextPropertyInfo
data CellRendererProgressTextXalignPropertyInfo
data CellRendererProgressTextYalignPropertyInfo
data CellRendererProgressValuePropertyInfo
type family ResolveCellRendererProgressMethod (t :: Symbol) o
cellRendererProgressInverted :: AttrLabelProxy "inverted"
cellRendererProgressPulse :: AttrLabelProxy "pulse"
cellRendererProgressText :: AttrLabelProxy "text"
cellRendererProgressTextXalign :: AttrLabelProxy "textXalign"
cellRendererProgressTextYalign :: AttrLabelProxy "textYalign"
cellRendererProgressValue :: AttrLabelProxy "value"
data CellRendererSpinAdjustmentPropertyInfo
data CellRendererSpinClimbRatePropertyInfo
data CellRendererSpinDigitsPropertyInfo
type family ResolveCellRendererSpinMethod (t :: Symbol) o
cellRendererSpinAdjustment :: AttrLabelProxy "adjustment"
cellRendererSpinClimbRate :: AttrLabelProxy "climbRate"
cellRendererSpinDigits :: AttrLabelProxy "digits"
data CellRendererSpinnerActivePropertyInfo
data CellRendererSpinnerPulsePropertyInfo
data CellRendererSpinnerSizePropertyInfo
type family ResolveCellRendererSpinnerMethod (t :: Symbol) o
cellRendererSpinnerActive :: AttrLabelProxy "active"
cellRendererSpinnerPulse :: AttrLabelProxy "pulse"
cellRendererSpinnerSize :: AttrLabelProxy "size"
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
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"
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
cellRendererToggleActivatable :: AttrLabelProxy "activatable"
cellRendererToggleActive :: AttrLabelProxy "active"
cellRendererToggleInconsistent :: AttrLabelProxy "inconsistent"
cellRendererToggleIndicatorSize :: AttrLabelProxy "indicatorSize"
cellRendererToggleRadio :: AttrLabelProxy "radio"
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
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"
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
checkMenuItemActive :: AttrLabelProxy "active"
checkMenuItemDrawAsRadio :: AttrLabelProxy "drawAsRadio"
checkMenuItemInconsistent :: AttrLabelProxy "inconsistent"
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
colorButtonAlpha :: AttrLabelProxy "alpha"
colorButtonColor :: AttrLabelProxy "color"
colorButtonRgba :: AttrLabelProxy "rgba"
colorButtonShowEditor :: AttrLabelProxy "showEditor"
colorButtonTitle :: AttrLabelProxy "title"
colorButtonUseAlpha :: AttrLabelProxy "useAlpha"
data ColorChooserDialogShowEditorPropertyInfo
type family ResolveColorChooserDialogMethod (t :: Symbol) o
colorChooserDialogShowEditor :: AttrLabelProxy "showEditor"
data ColorChooserWidgetShowEditorPropertyInfo
type family ResolveColorChooserWidgetMethod (t :: Symbol) o
colorChooserWidgetShowEditor :: AttrLabelProxy "showEditor"
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
colorSelectionCurrentAlpha :: AttrLabelProxy "currentAlpha"
colorSelectionCurrentColor :: AttrLabelProxy "currentColor"
colorSelectionCurrentRgba :: AttrLabelProxy "currentRgba"
colorSelectionHasOpacityControl :: AttrLabelProxy "hasOpacityControl"
colorSelectionHasPalette :: AttrLabelProxy "hasPalette"
data ColorSelectionDialogCancelButtonPropertyInfo
data ColorSelectionDialogColorSelectionPropertyInfo
data ColorSelectionDialogGetColorSelectionMethodInfo
data ColorSelectionDialogHelpButtonPropertyInfo
data ColorSelectionDialogOkButtonPropertyInfo
type family ResolveColorSelectionDialogMethod (t :: Symbol) o
colorSelectionDialogCancelButton :: AttrLabelProxy "cancelButton"
colorSelectionDialogColorSelection :: AttrLabelProxy "colorSelection"
colorSelectionDialogHelpButton :: AttrLabelProxy "helpButton"
colorSelectionDialogOkButton :: AttrLabelProxy "okButton"
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
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"
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
containerBorderWidth :: AttrLabelProxy "borderWidth"
containerChild :: AttrLabelProxy "child"
containerResizeMode :: AttrLabelProxy "resizeMode"
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
dialogUseHeaderBar :: AttrLabelProxy "useHeaderBar"
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 EntryToggleDirectionSignalInfo
data EntryToggleOverwriteSignalInfo
data EntryTruncateMultilinePropertyInfo
data EntryUnsetInvisibleCharMethodInfo
data EntryVisibilityPropertyInfo
data EntryWidthCharsPropertyInfo
data EntryXalignPropertyInfo
type family ResolveEntryMethod (t :: Symbol) o
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"
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
entryBufferLength :: AttrLabelProxy "length"
entryBufferMaxLength :: AttrLabelProxy "maxLength"
entryBufferText :: AttrLabelProxy "text"
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
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"
type family ResolveEntryIconAccessibleMethod (t :: Symbol) o
data EventBoxAboveChildPropertyInfo
data EventBoxGetAboveChildMethodInfo
data EventBoxGetVisibleWindowMethodInfo
data EventBoxSetAboveChildMethodInfo
data EventBoxSetVisibleWindowMethodInfo
data EventBoxVisibleWindowPropertyInfo
type family ResolveEventBoxMethod (t :: Symbol) o
eventBoxAboveChild :: AttrLabelProxy "aboveChild"
eventBoxVisibleWindow :: AttrLabelProxy "visibleWindow"
data EventControllerGetPropagationPhaseMethodInfo
data EventControllerGetWidgetMethodInfo
data EventControllerHandleEventMethodInfo
data EventControllerPropagationPhasePropertyInfo
data EventControllerResetMethodInfo
data EventControllerSetPropagationPhaseMethodInfo
data EventControllerWidgetPropertyInfo
type family ResolveEventControllerMethod (t :: Symbol) o
eventControllerPropagationPhase :: AttrLabelProxy "propagationPhase"
eventControllerWidget :: AttrLabelProxy "widget"
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
eventControllerScrollFlags :: AttrLabelProxy "flags"
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
expanderExpanded :: AttrLabelProxy "expanded"
expanderLabel :: AttrLabelProxy "label"
expanderLabelFill :: AttrLabelProxy "labelFill"
expanderLabelWidget :: AttrLabelProxy "labelWidget"
expanderResizeToplevel :: AttrLabelProxy "resizeToplevel"
expanderSpacing :: AttrLabelProxy "spacing"
expanderUseMarkup :: AttrLabelProxy "useMarkup"
expanderUseUnderline :: AttrLabelProxy "useUnderline"
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
fileChooserButtonDialog :: AttrLabelProxy "dialog"
fileChooserButtonTitle :: AttrLabelProxy "title"
fileChooserButtonWidthChars :: AttrLabelProxy "widthChars"
type family ResolveFileChooserDialogMethod (t :: Symbol) o
data FileChooserNativeAcceptLabelPropertyInfo
data FileChooserNativeCancelLabelPropertyInfo
data FileChooserNativeGetAcceptLabelMethodInfo
data FileChooserNativeGetCancelLabelMethodInfo
data FileChooserNativeSetAcceptLabelMethodInfo
data FileChooserNativeSetCancelLabelMethodInfo
type family ResolveFileChooserNativeMethod (t :: Symbol) o
fileChooserNativeAcceptLabel :: AttrLabelProxy "acceptLabel"
fileChooserNativeCancelLabel :: AttrLabelProxy "cancelLabel"
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
fileChooserWidgetSearchMode :: AttrLabelProxy "searchMode"
fileChooserWidgetSubtitle :: AttrLabelProxy "subtitle"
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
flowBoxActivateOnSingleClick :: AttrLabelProxy "activateOnSingleClick"
flowBoxColumnSpacing :: AttrLabelProxy "columnSpacing"
flowBoxHomogeneous :: AttrLabelProxy "homogeneous"
flowBoxMaxChildrenPerLine :: AttrLabelProxy "maxChildrenPerLine"
flowBoxMinChildrenPerLine :: AttrLabelProxy "minChildrenPerLine"
flowBoxRowSpacing :: AttrLabelProxy "rowSpacing"
flowBoxSelectionMode :: AttrLabelProxy "selectionMode"
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
fontButtonFontName :: AttrLabelProxy "fontName"
fontButtonShowSize :: AttrLabelProxy "showSize"
fontButtonShowStyle :: AttrLabelProxy "showStyle"
fontButtonTitle :: AttrLabelProxy "title"
fontButtonUseFont :: AttrLabelProxy "useFont"
fontButtonUseSize :: AttrLabelProxy "useSize"
type family ResolveFontChooserDialogMethod (t :: Symbol) o
data FontChooserWidgetTweakActionPropertyInfo
type family ResolveFontChooserWidgetMethod (t :: Symbol) o
fontChooserWidgetTweakAction :: AttrLabelProxy "tweakAction"
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
fontSelectionFontName :: AttrLabelProxy "fontName"
fontSelectionPreviewText :: AttrLabelProxy "previewText"
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
frameLabel :: AttrLabelProxy "label"
frameLabelWidget :: AttrLabelProxy "labelWidget"
frameLabelXalign :: AttrLabelProxy "labelXalign"
frameLabelYalign :: AttrLabelProxy "labelYalign"
frameShadowType :: AttrLabelProxy "shadowType"
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
gLAreaAutoRender :: AttrLabelProxy "autoRender"
gLAreaContext :: AttrLabelProxy "context"
gLAreaHasAlpha :: AttrLabelProxy "hasAlpha"
gLAreaHasDepthBuffer :: AttrLabelProxy "hasDepthBuffer"
gLAreaHasStencilBuffer :: AttrLabelProxy "hasStencilBuffer"
gLAreaUseEs :: AttrLabelProxy "useEs"
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
gestureNPoints :: AttrLabelProxy "nPoints"
gestureWindow :: AttrLabelProxy "window"
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
gestureLongPressDelayFactor :: AttrLabelProxy "delayFactor"
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
gesturePanOrientation :: AttrLabelProxy "orientation"
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
gestureSingleButton :: AttrLabelProxy "button"
gestureSingleExclusive :: AttrLabelProxy "exclusive"
gestureSingleTouchOnly :: AttrLabelProxy "touchOnly"
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
gridBaselineRow :: AttrLabelProxy "baselineRow"
gridColumnHomogeneous :: AttrLabelProxy "columnHomogeneous"
gridColumnSpacing :: AttrLabelProxy "columnSpacing"
gridRowHomogeneous :: AttrLabelProxy "rowHomogeneous"
gridRowSpacing :: AttrLabelProxy "rowSpacing"
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
handleBoxChildDetached :: AttrLabelProxy "childDetached"
handleBoxHandlePosition :: AttrLabelProxy "handlePosition"
handleBoxShadowType :: AttrLabelProxy "shadowType"
handleBoxSnapEdge :: AttrLabelProxy "snapEdge"
handleBoxSnapEdgeSet :: AttrLabelProxy "snapEdgeSet"
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
headerBarCustomTitle :: AttrLabelProxy "customTitle"
headerBarDecorationLayout :: AttrLabelProxy "decorationLayout"
headerBarDecorationLayoutSet :: AttrLabelProxy "decorationLayoutSet"
headerBarHasSubtitle :: AttrLabelProxy "hasSubtitle"
headerBarShowCloseButton :: AttrLabelProxy "showCloseButton"
headerBarSpacing :: AttrLabelProxy "spacing"
headerBarSubtitle :: AttrLabelProxy "subtitle"
headerBarTitle :: AttrLabelProxy "title"
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
iMContextInputHints :: AttrLabelProxy "inputHints"
iMContextInputPurpose :: AttrLabelProxy "inputPurpose"
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
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"
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
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"
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
imageMenuItemAccelGroup :: AttrLabelProxy "accelGroup"
imageMenuItemAlwaysShowImage :: AttrLabelProxy "alwaysShowImage"
imageMenuItemImage :: AttrLabelProxy "image"
imageMenuItemUseStock :: AttrLabelProxy "useStock"
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
infoBarMessageType :: AttrLabelProxy "messageType"
infoBarRevealed :: AttrLabelProxy "revealed"
infoBarShowCloseButton :: AttrLabelProxy "showCloseButton"
data InvisibleGetScreenMethodInfo
data InvisibleScreenPropertyInfo
data InvisibleSetScreenMethodInfo
type family ResolveInvisibleMethod (t :: Symbol) o
invisibleScreen :: AttrLabelProxy "screen"
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
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"
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
layoutHeight :: AttrLabelProxy "height"
layoutWidth :: AttrLabelProxy "width"
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
levelBarInverted :: AttrLabelProxy "inverted"
levelBarMaxValue :: AttrLabelProxy "maxValue"
levelBarMinValue :: AttrLabelProxy "minValue"
levelBarMode :: AttrLabelProxy "mode"
levelBarValue :: AttrLabelProxy "value"
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
linkButtonUri :: AttrLabelProxy "uri"
linkButtonVisited :: AttrLabelProxy "visited"
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
listBoxActivateOnSingleClick :: AttrLabelProxy "activateOnSingleClick"
listBoxSelectionMode :: AttrLabelProxy "selectionMode"
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
listBoxRowActivatable :: AttrLabelProxy "activatable"
listBoxRowSelectable :: AttrLabelProxy "selectable"
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
lockButtonPermission :: AttrLabelProxy "permission"
lockButtonTextLock :: AttrLabelProxy "textLock"
lockButtonTextUnlock :: AttrLabelProxy "textUnlock"
lockButtonTooltipLock :: AttrLabelProxy "tooltipLock"
lockButtonTooltipNotAuthorized :: AttrLabelProxy "tooltipNotAuthorized"
lockButtonTooltipUnlock :: AttrLabelProxy "tooltipUnlock"
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
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"
type family ResolveMenuAccessibleMethod (t :: Symbol) o
data MenuBarChildPackDirectionPropertyInfo
data MenuBarGetChildPackDirectionMethodInfo
data MenuBarGetPackDirectionMethodInfo
data MenuBarPackDirectionPropertyInfo
data MenuBarSetChildPackDirectionMethodInfo
data MenuBarSetPackDirectionMethodInfo
type family ResolveMenuBarMethod (t :: Symbol) o
menuBarChildPackDirection :: AttrLabelProxy "childPackDirection"
menuBarPackDirection :: AttrLabelProxy "packDirection"
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
menuButtonAlignWidget :: AttrLabelProxy "alignWidget"
menuButtonDirection :: AttrLabelProxy "direction"
menuButtonMenuModel :: AttrLabelProxy "menuModel"
menuButtonPopover :: AttrLabelProxy "popover"
menuButtonPopup :: AttrLabelProxy "popup"
menuButtonUsePopover :: AttrLabelProxy "usePopover"
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
menuItemAccelPath :: AttrLabelProxy "accelPath"
menuItemLabel :: AttrLabelProxy "label"
menuItemRightJustified :: AttrLabelProxy "rightJustified"
menuItemSubmenu :: AttrLabelProxy "submenu"
menuItemUseUnderline :: AttrLabelProxy "useUnderline"
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
menuShellTakeFocus :: AttrLabelProxy "takeFocus"
type family ResolveMenuShellAccessibleMethod (t :: Symbol) o
data MenuToolButtonGetMenuMethodInfo
data MenuToolButtonMenuPropertyInfo
data MenuToolButtonSetArrowTooltipMarkupMethodInfo
data MenuToolButtonSetArrowTooltipTextMethodInfo
data MenuToolButtonSetMenuMethodInfo
data MenuToolButtonShowMenuSignalInfo
type family ResolveMenuToolButtonMethod (t :: Symbol) o
menuToolButtonMenu :: AttrLabelProxy "menu"
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
messageDialogButtons :: AttrLabelProxy "buttons"
messageDialogImage :: AttrLabelProxy "image"
messageDialogMessageArea :: AttrLabelProxy "messageArea"
messageDialogMessageType :: AttrLabelProxy "messageType"
messageDialogSecondaryText :: AttrLabelProxy "secondaryText"
messageDialogSecondaryUseMarkup :: AttrLabelProxy "secondaryUseMarkup"
messageDialogText :: AttrLabelProxy "text"
messageDialogUseMarkup :: AttrLabelProxy "useMarkup"
data MiscGetAlignmentMethodInfo
data MiscGetPaddingMethodInfo
data MiscSetAlignmentMethodInfo
data MiscSetPaddingMethodInfo
data MiscXalignPropertyInfo
data MiscXpadPropertyInfo
data MiscYalignPropertyInfo
data MiscYpadPropertyInfo
type family ResolveMiscMethod (t :: Symbol) o
miscXalign :: AttrLabelProxy "xalign"
miscXpad :: AttrLabelProxy "xpad"
miscYalign :: AttrLabelProxy "yalign"
miscYpad :: AttrLabelProxy "ypad"
data ModelButtonActivePropertyInfo
data ModelButtonCenteredPropertyInfo
data ModelButtonIconPropertyInfo
data ModelButtonIconicPropertyInfo
data ModelButtonInvertedPropertyInfo
data ModelButtonMenuNamePropertyInfo
data ModelButtonRolePropertyInfo
data ModelButtonTextPropertyInfo
data ModelButtonUseMarkupPropertyInfo
type family ResolveModelButtonMethod (t :: Symbol) o
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"
data MountOperationGetParentMethodInfo
data MountOperationGetScreenMethodInfo
data MountOperationIsShowingMethodInfo
data MountOperationIsShowingPropertyInfo
data MountOperationParentPropertyInfo
data MountOperationScreenPropertyInfo
data MountOperationSetParentMethodInfo
data MountOperationSetScreenMethodInfo
type family ResolveMountOperationMethod (t :: Symbol) o
mountOperationParent :: AttrLabelProxy "parent"
mountOperationScreen :: AttrLabelProxy "screen"
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
nativeDialogModal :: AttrLabelProxy "modal"
nativeDialogTitle :: AttrLabelProxy "title"
nativeDialogTransientFor :: AttrLabelProxy "transientFor"
nativeDialogVisible :: AttrLabelProxy "visible"
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
notebookEnablePopup :: AttrLabelProxy "enablePopup"
notebookGroupName :: AttrLabelProxy "groupName"
notebookPage :: AttrLabelProxy "page"
notebookScrollable :: AttrLabelProxy "scrollable"
notebookShowBorder :: AttrLabelProxy "showBorder"
notebookShowTabs :: AttrLabelProxy "showTabs"
notebookTabPos :: AttrLabelProxy "tabPos"
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
numerableIconBackgroundIcon :: AttrLabelProxy "backgroundIcon"
numerableIconBackgroundIconName :: AttrLabelProxy "backgroundIconName"
numerableIconCount :: AttrLabelProxy "count"
numerableIconLabel :: AttrLabelProxy "label"
numerableIconStyleContext :: AttrLabelProxy "styleContext"
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
padControllerActionGroup :: AttrLabelProxy "actionGroup"
padControllerPad :: AttrLabelProxy "pad"
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
panedMaxPosition :: AttrLabelProxy "maxPosition"
panedMinPosition :: AttrLabelProxy "minPosition"
panedPosition :: AttrLabelProxy "position"
panedPositionSet :: AttrLabelProxy "positionSet"
panedWideHandle :: AttrLabelProxy "wideHandle"
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
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"
data PlugConstructForDisplayMethodInfo
data PlugConstructMethodInfo
data PlugEmbeddedPropertyInfo
data PlugEmbeddedSignalInfo
data PlugGetEmbeddedMethodInfo
data PlugGetIdMethodInfo
data PlugGetSocketWindowMethodInfo
data PlugSocketWindowPropertyInfo
type family ResolvePlugMethod (t :: Symbol) o
plugEmbedded :: AttrLabelProxy "embedded"
plugSocketWindow :: AttrLabelProxy "socketWindow"
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
popoverConstrainTo :: AttrLabelProxy "constrainTo"
popoverModal :: AttrLabelProxy "modal"
popoverPointingTo :: AttrLabelProxy "pointingTo"
popoverPosition :: AttrLabelProxy "position"
popoverRelativeTo :: AttrLabelProxy "relativeTo"
popoverTransitionsEnabled :: AttrLabelProxy "transitionsEnabled"
type family ResolvePopoverAccessibleMethod (t :: Symbol) o
data PopoverMenuOpenSubmenuMethodInfo
data PopoverMenuVisibleSubmenuPropertyInfo
type family ResolvePopoverMenuMethod (t :: Symbol) o
popoverMenuVisibleSubmenu :: AttrLabelProxy "visibleSubmenu"
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
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"
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
progressBarEllipsize :: AttrLabelProxy "ellipsize"
progressBarFraction :: AttrLabelProxy "fraction"
progressBarInverted :: AttrLabelProxy "inverted"
progressBarPulseStep :: AttrLabelProxy "pulseStep"
progressBarShowText :: AttrLabelProxy "showText"
progressBarText :: AttrLabelProxy "text"
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
radioActionCurrentValue :: AttrLabelProxy "currentValue"
radioActionGroup :: AttrLabelProxy "group"
radioActionValue :: AttrLabelProxy "value"
data RadioButtonGetGroupMethodInfo
data RadioButtonGroupChangedSignalInfo
data RadioButtonGroupPropertyInfo
data RadioButtonJoinGroupMethodInfo
data RadioButtonSetGroupMethodInfo
type family ResolveRadioButtonMethod (t :: Symbol) o
radioButtonGroup :: AttrLabelProxy "group"
type family ResolveRadioButtonAccessibleMethod (t :: Symbol) o
data RadioMenuItemGetGroupMethodInfo
data RadioMenuItemGroupChangedSignalInfo
data RadioMenuItemGroupPropertyInfo
data RadioMenuItemJoinGroupMethodInfo
data RadioMenuItemSetGroupMethodInfo
type family ResolveRadioMenuItemMethod (t :: Symbol) o
radioMenuItemGroup :: AttrLabelProxy "group"
type family ResolveRadioMenuItemAccessibleMethod (t :: Symbol) o
data RadioToolButtonGetGroupMethodInfo
data RadioToolButtonGroupPropertyInfo
data RadioToolButtonSetGroupMethodInfo
type family ResolveRadioToolButtonMethod (t :: Symbol) o
radioToolButtonGroup :: AttrLabelProxy "group"
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
rangeAdjustment :: AttrLabelProxy "adjustment"
rangeFillLevel :: AttrLabelProxy "fillLevel"
rangeInverted :: AttrLabelProxy "inverted"
rangeLowerStepperSensitivity :: AttrLabelProxy "lowerStepperSensitivity"
rangeRestrictToFillLevel :: AttrLabelProxy "restrictToFillLevel"
rangeRoundDigits :: AttrLabelProxy "roundDigits"
rangeShowFillLevel :: AttrLabelProxy "showFillLevel"
rangeUpperStepperSensitivity :: AttrLabelProxy "upperStepperSensitivity"
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
recentActionShowNumbers :: AttrLabelProxy "showNumbers"
type family ResolveRecentChooserDialogMethod (t :: Symbol) o
data RecentChooserMenuGetShowNumbersMethodInfo
data RecentChooserMenuSetShowNumbersMethodInfo
data RecentChooserMenuShowNumbersPropertyInfo
type family ResolveRecentChooserMenuMethod (t :: Symbol) o
recentChooserMenuShowNumbers :: AttrLabelProxy "showNumbers"
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
recentManagerFilename :: AttrLabelProxy "filename"
recentManagerSize :: AttrLabelProxy "size"
data RendererCellAccessibleRendererPropertyInfo
type family ResolveRendererCellAccessibleMethod (t :: Symbol) o
rendererCellAccessibleRenderer :: AttrLabelProxy "renderer"
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
revealerChildRevealed :: AttrLabelProxy "childRevealed"
revealerRevealChild :: AttrLabelProxy "revealChild"
revealerTransitionDuration :: AttrLabelProxy "transitionDuration"
revealerTransitionType :: AttrLabelProxy "transitionType"
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
scaleDigits :: AttrLabelProxy "digits"
scaleDrawValue :: AttrLabelProxy "drawValue"
scaleHasOrigin :: AttrLabelProxy "hasOrigin"
scaleValuePos :: AttrLabelProxy "valuePos"
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
scaleButtonAdjustment :: AttrLabelProxy "adjustment"
scaleButtonIcons :: AttrLabelProxy "icons"
scaleButtonSize :: AttrLabelProxy "size"
scaleButtonValue :: AttrLabelProxy "value"
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
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"
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
searchBarSearchModeEnabled :: AttrLabelProxy "searchModeEnabled"
searchBarShowCloseButton :: AttrLabelProxy "showCloseButton"
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
separatorToolItemDraw :: AttrLabelProxy "draw"
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
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"
type family ResolveShortcutLabelMethod (t :: Symbol) o
data ShortcutLabelAcceleratorPropertyInfo
data ShortcutLabelDisabledTextPropertyInfo
data ShortcutLabelGetAcceleratorMethodInfo
data ShortcutLabelGetDisabledTextMethodInfo
data ShortcutLabelSetAcceleratorMethodInfo
data ShortcutLabelSetDisabledTextMethodInfo
shortcutLabelAccelerator :: AttrLabelProxy "accelerator"
shortcutLabelDisabledText :: AttrLabelProxy "disabledText"
type family ResolveShortcutsGroupMethod (t :: Symbol) o
data ShortcutsGroupAccelSizeGroupPropertyInfo
data ShortcutsGroupHeightPropertyInfo
data ShortcutsGroupTitlePropertyInfo
data ShortcutsGroupTitleSizeGroupPropertyInfo
data ShortcutsGroupViewPropertyInfo
shortcutsGroupAccelSizeGroup :: AttrLabelProxy "accelSizeGroup"
shortcutsGroupHeight :: AttrLabelProxy "height"
shortcutsGroupTitle :: AttrLabelProxy "title"
shortcutsGroupTitleSizeGroup :: AttrLabelProxy "titleSizeGroup"
shortcutsGroupView :: AttrLabelProxy "view"
type family ResolveShortcutsSectionMethod (t :: Symbol) o
data ShortcutsSectionChangeCurrentPageSignalInfo
data ShortcutsSectionMaxHeightPropertyInfo
data ShortcutsSectionSectionNamePropertyInfo
data ShortcutsSectionTitlePropertyInfo
data ShortcutsSectionViewNamePropertyInfo
shortcutsSectionMaxHeight :: AttrLabelProxy "maxHeight"
shortcutsSectionSectionName :: AttrLabelProxy "sectionName"
shortcutsSectionTitle :: AttrLabelProxy "title"
shortcutsSectionViewName :: AttrLabelProxy "viewName"
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
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"
type family ResolveShortcutsWindowMethod (t :: Symbol) o
data ShortcutsWindowCloseSignalInfo
data ShortcutsWindowSearchSignalInfo
data ShortcutsWindowSectionNamePropertyInfo
data ShortcutsWindowViewNamePropertyInfo
shortcutsWindowSectionName :: AttrLabelProxy "sectionName"
shortcutsWindowViewName :: AttrLabelProxy "viewName"
type family ResolveSizeGroupMethod (t :: Symbol) o
data SizeGroupAddWidgetMethodInfo
data SizeGroupGetIgnoreHiddenMethodInfo
data SizeGroupGetModeMethodInfo
data SizeGroupGetWidgetsMethodInfo
data SizeGroupIgnoreHiddenPropertyInfo
data SizeGroupModePropertyInfo
data SizeGroupRemoveWidgetMethodInfo
data SizeGroupSetIgnoreHiddenMethodInfo
data SizeGroupSetModeMethodInfo
sizeGroupIgnoreHidden :: AttrLabelProxy "ignoreHidden"
sizeGroupMode :: AttrLabelProxy "mode"
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
spinButtonAdjustment :: AttrLabelProxy "adjustment"
spinButtonClimbRate :: AttrLabelProxy "climbRate"
spinButtonDigits :: AttrLabelProxy "digits"
spinButtonNumeric :: AttrLabelProxy "numeric"
spinButtonSnapToTicks :: AttrLabelProxy "snapToTicks"
spinButtonUpdatePolicy :: AttrLabelProxy "updatePolicy"
spinButtonValue :: AttrLabelProxy "value"
spinButtonWrap :: AttrLabelProxy "wrap"
type family ResolveSpinButtonAccessibleMethod (t :: Symbol) o
type family ResolveSpinnerMethod (t :: Symbol) o
data SpinnerActivePropertyInfo
data SpinnerStartMethodInfo
data SpinnerStopMethodInfo
spinnerActive :: AttrLabelProxy "active"
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
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"
type family ResolveStackAccessibleMethod (t :: Symbol) o
type family ResolveStackSidebarMethod (t :: Symbol) o
data StackSidebarGetStackMethodInfo
data StackSidebarSetStackMethodInfo
data StackSidebarStackPropertyInfo
stackSidebarStack :: AttrLabelProxy "stack"
type family ResolveStackSwitcherMethod (t :: Symbol) o
data StackSwitcherGetStackMethodInfo
data StackSwitcherIconSizePropertyInfo
data StackSwitcherSetStackMethodInfo
data StackSwitcherStackPropertyInfo
stackSwitcherIconSize :: AttrLabelProxy "iconSize"
stackSwitcherStack :: AttrLabelProxy "stack"
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
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"
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
styleContext :: AttrLabelProxy "context"
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
styleContextDirection :: AttrLabelProxy "direction"
styleContextPaintClock :: AttrLabelProxy "paintClock"
styleContextParent :: AttrLabelProxy "parent"
styleContextScreen :: AttrLabelProxy "screen"
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
switchActive :: AttrLabelProxy "active"
switchState :: AttrLabelProxy "state"
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
tableColumnSpacing :: AttrLabelProxy "columnSpacing"
tableHomogeneous :: AttrLabelProxy "homogeneous"
tableNColumns :: AttrLabelProxy "nColumns"
tableNRows :: AttrLabelProxy "nRows"
tableRowSpacing :: AttrLabelProxy "rowSpacing"
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
textBufferCopyTargetList :: AttrLabelProxy "copyTargetList"
textBufferCursorPosition :: AttrLabelProxy "cursorPosition"
textBufferHasSelection :: AttrLabelProxy "hasSelection"
textBufferPasteTargetList :: AttrLabelProxy "pasteTargetList"
textBufferTagTable :: AttrLabelProxy "tagTable"
textBufferText :: AttrLabelProxy "text"
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
textMarkLeftGravity :: AttrLabelProxy "leftGravity"
textMarkName :: AttrLabelProxy "name"
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
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"
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
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"
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
themingEngineName :: AttrLabelProxy "name"
type family ResolveToggleActionMethod (t :: Symbol) o
data ToggleActionActivePropertyInfo
data ToggleActionDrawAsRadioPropertyInfo
data ToggleActionGetActiveMethodInfo
data ToggleActionGetDrawAsRadioMethodInfo
data ToggleActionSetActiveMethodInfo
data ToggleActionSetDrawAsRadioMethodInfo
data ToggleActionToggledMethodInfo
data ToggleActionToggledSignalInfo
toggleActionActive :: AttrLabelProxy "active"
toggleActionDrawAsRadio :: AttrLabelProxy "drawAsRadio"
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
toggleButtonActive :: AttrLabelProxy "active"
toggleButtonDrawIndicator :: AttrLabelProxy "drawIndicator"
toggleButtonInconsistent :: AttrLabelProxy "inconsistent"
type family ResolveToggleButtonAccessibleMethod (t :: Symbol) o
type family ResolveToggleToolButtonMethod (t :: Symbol) o
data ToggleToolButtonActivePropertyInfo
data ToggleToolButtonGetActiveMethodInfo
data ToggleToolButtonSetActiveMethodInfo
data ToggleToolButtonToggledSignalInfo
toggleToolButtonActive :: AttrLabelProxy "active"
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
toolButtonIconName :: AttrLabelProxy "iconName"
toolButtonIconWidget :: AttrLabelProxy "iconWidget"
toolButtonLabel :: AttrLabelProxy "label"
toolButtonLabelWidget :: AttrLabelProxy "labelWidget"
toolButtonStockId :: AttrLabelProxy "stockId"
toolButtonUseUnderline :: AttrLabelProxy "useUnderline"
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
toolItemIsImportant :: AttrLabelProxy "isImportant"
toolItemVisibleHorizontal :: AttrLabelProxy "visibleHorizontal"
toolItemVisibleVertical :: AttrLabelProxy "visibleVertical"
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
toolItemGroupCollapsed :: AttrLabelProxy "collapsed"
toolItemGroupEllipsize :: AttrLabelProxy "ellipsize"
toolItemGroupHeaderRelief :: AttrLabelProxy "headerRelief"
toolItemGroupLabel :: AttrLabelProxy "label"
toolItemGroupLabelWidget :: AttrLabelProxy "labelWidget"
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
toolPaletteIconSize :: AttrLabelProxy "iconSize"
toolPaletteIconSizeSet :: AttrLabelProxy "iconSizeSet"
toolPaletteToolbarStyle :: AttrLabelProxy "toolbarStyle"
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
toolbarIconSize :: AttrLabelProxy "iconSize"
toolbarIconSizeSet :: AttrLabelProxy "iconSizeSet"
toolbarShowArrow :: AttrLabelProxy "showArrow"
toolbarToolbarStyle :: AttrLabelProxy "toolbarStyle"
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
treeModelFilterChildModel :: AttrLabelProxy "childModel"
treeModelFilterVirtualRoot :: AttrLabelProxy "virtualRoot"
type family ResolveTreeModelSortMethod (t :: Symbol) o
data TreeModelSortClearCacheMethodInfo
data TreeModelSortConvertChildIterToIterMethodInfo
data TreeModelSortConvertChildPathToPathMethodInfo
data TreeModelSortConvertIterToChildIterMethodInfo
data TreeModelSortConvertPathToChildPathMethodInfo
data TreeModelSortGetModelMethodInfo
data TreeModelSortIterIsValidMethodInfo
data TreeModelSortModelPropertyInfo
data TreeModelSortResetDefaultSortFuncMethodInfo
treeModelSortModel :: AttrLabelProxy "model"
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
treeSelectionMode :: AttrLabelProxy "mode"
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 TreeViewUbuntuAlmostFixedHeightModePropertyInfo
data TreeViewUnselectAllSignalInfo
data TreeViewUnsetRowsDragDestMethodInfo
data TreeViewUnsetRowsDragSourceMethodInfo
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"
treeViewUbuntuAlmostFixedHeightMode :: AttrLabelProxy "ubuntuAlmostFixedHeightMode"
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
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"
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
uIManagerAddTearoffs :: AttrLabelProxy "addTearoffs"
uIManagerUi :: AttrLabelProxy "ui"
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
viewportShadowType :: AttrLabelProxy "shadowType"
type family ResolveVolumeButtonMethod (t :: Symbol) o
data VolumeButtonUseSymbolicPropertyInfo
volumeButtonUseSymbolic :: AttrLabelProxy "useSymbolic"
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
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"
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
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"
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
accelGroupEntry_accelPathQuark :: AttrLabelProxy "accelPathQuark"
accelGroupEntry_closure :: AttrLabelProxy "closure"
accelGroupEntry_key :: AttrLabelProxy "key"
type family ResolveAccelKeyMethod (t :: Symbol) o
accelKey_accelFlags :: AttrLabelProxy "accelFlags"
accelKey_accelKey :: AttrLabelProxy "accelKey"
accelKey_accelMods :: AttrLabelProxy "accelMods"
type family ResolveActionEntryMethod (t :: Symbol) o
actionEntry_accelerator :: AttrLabelProxy "accelerator"
actionEntry_callback :: AttrLabelProxy "callback"
actionEntry_label :: AttrLabelProxy "label"
actionEntry_name :: AttrLabelProxy "name"
actionEntry_stockId :: AttrLabelProxy "stockId"
actionEntry_tooltip :: AttrLabelProxy "tooltip"
type family ResolveActionableInterfaceMethod (t :: Symbol) o
actionableInterface_getActionName :: AttrLabelProxy "getActionName"
actionableInterface_getActionTargetValue :: AttrLabelProxy "getActionTargetValue"
actionableInterface_setActionName :: AttrLabelProxy "setActionName"
actionableInterface_setActionTargetValue :: AttrLabelProxy "setActionTargetValue"
type family ResolveBindingArgMethod (t :: Symbol) o
bindingArg_argType :: AttrLabelProxy "argType"
type family ResolveBindingEntryMethod (t :: Symbol) o
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"
data BindingSetActivateMethodInfo
data BindingSetAddPathMethodInfo
type family ResolveBindingSetMethod (t :: Symbol) o
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"
type family ResolveBindingSignalMethod (t :: Symbol) o
bindingSignal_nArgs :: AttrLabelProxy "nArgs"
bindingSignal_next :: AttrLabelProxy "next"
bindingSignal_signalName :: AttrLabelProxy "signalName"
data BorderCopyMethodInfo
data BorderFreeMethodInfo
type family ResolveBorderMethod (t :: Symbol) o
border_bottom :: AttrLabelProxy "bottom"
border_left :: AttrLabelProxy "left"
border_right :: AttrLabelProxy "right"
border_top :: AttrLabelProxy "top"
data ContainerClassFindChildPropertyMethodInfo
data ContainerClassHandleBorderWidthMethodInfo
data ContainerClassInstallChildPropertyMethodInfo
type family ResolveContainerClassMethod (t :: Symbol) o
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"
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
fileFilterInfo_contains :: AttrLabelProxy "contains"
fileFilterInfo_displayName :: AttrLabelProxy "displayName"
fileFilterInfo_filename :: AttrLabelProxy "filename"
fileFilterInfo_mimeType :: AttrLabelProxy "mimeType"
fileFilterInfo_uri :: AttrLabelProxy "uri"
type family ResolveFixedChildMethod (t :: Symbol) o
fixedChild_widget :: AttrLabelProxy "widget"
fixedChild_x :: AttrLabelProxy "x"
fixedChild_y :: AttrLabelProxy "y"
data GradientAddColorStopMethodInfo
data GradientRefMethodInfo
data GradientResolveForContextMethodInfo
data GradientResolveMethodInfo
data GradientToStringMethodInfo
data GradientUnrefMethodInfo
type family ResolveGradientMethod (t :: Symbol) o
type family ResolveIMContextInfoMethod (t :: Symbol) o
iMContextInfo_contextId :: AttrLabelProxy "contextId"
iMContextInfo_contextName :: AttrLabelProxy "contextName"
iMContextInfo_defaultLocales :: AttrLabelProxy "defaultLocales"
iMContextInfo_domain :: AttrLabelProxy "domain"
iMContextInfo_domainDirname :: AttrLabelProxy "domainDirname"
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
mountOperationHandlerIface__parentIface :: AttrLabelProxy "parentIface"
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
padActionEntry_actionName :: AttrLabelProxy "actionName"
padActionEntry_index :: AttrLabelProxy "index"
padActionEntry_label :: AttrLabelProxy "label"
padActionEntry_mode :: AttrLabelProxy "mode"
padActionEntry_type :: AttrLabelProxy "type"
type family ResolvePageRangeMethod (t :: Symbol) o
pageRange_end :: AttrLabelProxy "end"
pageRange_start :: AttrLabelProxy "start"
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
radioActionEntry_accelerator :: AttrLabelProxy "accelerator"
radioActionEntry_label :: AttrLabelProxy "label"
radioActionEntry_name :: AttrLabelProxy "name"
radioActionEntry_stockId :: AttrLabelProxy "stockId"
radioActionEntry_tooltip :: AttrLabelProxy "tooltip"
radioActionEntry_value :: AttrLabelProxy "value"
type family ResolveRcContextMethod (t :: Symbol) o
type family ResolveRcPropertyMethod (t :: Symbol) o
rcProperty_origin :: AttrLabelProxy "origin"
rcProperty_propertyName :: AttrLabelProxy "propertyName"
rcProperty_typeName :: AttrLabelProxy "typeName"
rcProperty_value :: AttrLabelProxy "value"
type family ResolveRecentDataMethod (t :: Symbol) o
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"
type family ResolveRecentFilterInfoMethod (t :: Symbol) o
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"
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
requestedSize_data :: AttrLabelProxy "data"
requestedSize_minimumSize :: AttrLabelProxy "minimumSize"
requestedSize_naturalSize :: AttrLabelProxy "naturalSize"
data RequisitionCopyMethodInfo
data RequisitionFreeMethodInfo
type family ResolveRequisitionMethod (t :: Symbol) o
requisition_height :: AttrLabelProxy "height"
requisition_width :: AttrLabelProxy "width"
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
settingsValue_origin :: AttrLabelProxy "origin"
settingsValue_value :: AttrLabelProxy "value"
type family ResolveStockItemMethod (t :: Symbol) o
data StockItemFreeMethodInfo
stockItem_keyval :: AttrLabelProxy "keyval"
stockItem_label :: AttrLabelProxy "label"
stockItem_modifier :: AttrLabelProxy "modifier"
stockItem_stockId :: AttrLabelProxy "stockId"
stockItem_translationDomain :: AttrLabelProxy "translationDomain"
type family ResolveSymbolicColorMethod (t :: Symbol) o
data SymbolicColorRefMethodInfo
data SymbolicColorResolveMethodInfo
data SymbolicColorToStringMethodInfo
data SymbolicColorUnrefMethodInfo
type family ResolveTableChildMethod (t :: Symbol) o
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"
type family ResolveTableRowColMethod (t :: Symbol) o
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"
type family ResolveTargetEntryMethod (t :: Symbol) o
data TargetEntryCopyMethodInfo
data TargetEntryFreeMethodInfo
targetEntry_flags :: AttrLabelProxy "flags"
targetEntry_info :: AttrLabelProxy "info"
targetEntry_target :: AttrLabelProxy "target"
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
targetPair_flags :: AttrLabelProxy "flags"
targetPair_info :: AttrLabelProxy "info"
targetPair_target :: AttrLabelProxy "target"
type family ResolveTextAppearanceMethod (t :: Symbol) o
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"
type family ResolveTextAttributesMethod (t :: Symbol) o
data TextAttributesCopyMethodInfo
data TextAttributesCopyValuesMethodInfo
data TextAttributesRefMethodInfo
data TextAttributesUnrefMethodInfo
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"
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
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"
type family ResolveTreeIterMethod (t :: Symbol) o
data TreeIterCopyMethodInfo
data TreeIterFreeMethodInfo
treeIter_stamp :: AttrLabelProxy "stamp"
treeIter_userData :: AttrLabelProxy "userData"
treeIter_userData2 :: AttrLabelProxy "userData2"
treeIter_userData3 :: AttrLabelProxy "userData3"
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
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"
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
