gi-gtk 3.0.25 → 3.0.26

raw patch · 5 files changed

+23/−2 lines, 5 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- GI.Gtk.Structs.AccelGroupEntry: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.AccelGroupEntry.AccelGroupEntry tag

- GI.Gtk.Structs.AccelKey: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.AccelKey.AccelKey tag

- GI.Gtk.Structs.ActionEntry: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.ActionEntry.ActionEntry tag

- GI.Gtk.Structs.BindingArg: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.BindingArg.BindingArg tag

- GI.Gtk.Structs.BindingEntry: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.BindingEntry.BindingEntry tag

- GI.Gtk.Structs.BindingSet: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.BindingSet.BindingSet tag

- GI.Gtk.Structs.BindingSignal: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.BindingSignal.BindingSignal tag

- GI.Gtk.Structs.Border: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.Border.Border tag

- GI.Gtk.Structs.FileFilterInfo: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.FileFilterInfo.FileFilterInfo tag

- GI.Gtk.Structs.FixedChild: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.FixedChild.FixedChild tag

- GI.Gtk.Structs.IMContextInfo: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.IMContextInfo.IMContextInfo tag

- GI.Gtk.Structs.PadActionEntry: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.PadActionEntry.PadActionEntry tag

- GI.Gtk.Structs.PageRange: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.PageRange.PageRange tag

- GI.Gtk.Structs.RadioActionEntry: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.RadioActionEntry.RadioActionEntry tag

- GI.Gtk.Structs.RcProperty: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.RcProperty.RcProperty tag

- GI.Gtk.Structs.RecentData: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.RecentData.RecentData tag

- GI.Gtk.Structs.RecentFilterInfo: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.RecentFilterInfo.RecentFilterInfo tag

- GI.Gtk.Structs.RequestedSize: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.RequestedSize.RequestedSize tag

- GI.Gtk.Structs.Requisition: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.Requisition.Requisition tag

- GI.Gtk.Structs.SettingsValue: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.SettingsValue.SettingsValue tag

- GI.Gtk.Structs.StockItem: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.StockItem.StockItem tag

- GI.Gtk.Structs.TableChild: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TableChild.TableChild tag

- GI.Gtk.Structs.TableRowCol: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TableRowCol.TableRowCol tag

- GI.Gtk.Structs.TargetEntry: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TargetEntry.TargetEntry tag

- GI.Gtk.Structs.TargetPair: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TargetPair.TargetPair tag

- GI.Gtk.Structs.TextAppearance: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TextAppearance.TextAppearance tag

- GI.Gtk.Structs.TextAttributes: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TextAttributes.TextAttributes tag

- GI.Gtk.Structs.TextIter: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TextIter.TextIter tag

- GI.Gtk.Structs.ToggleActionEntry: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.ToggleActionEntry.ToggleActionEntry tag

- GI.Gtk.Structs.TreeIter: instance (tag ~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TreeIter.TreeIter tag

+ GI.Gtk.Flags: AnotherEventControllerScrollFlags :: Int -> EventControllerScrollFlags

+ GI.Gtk.Flags: AnotherFontChooserLevel :: Int -> FontChooserLevel

+ GI.Gtk.Flags: EventControllerScrollFlagsBothAxes :: EventControllerScrollFlags

+ GI.Gtk.Flags: EventControllerScrollFlagsDiscrete :: EventControllerScrollFlags

+ GI.Gtk.Flags: EventControllerScrollFlagsHorizontal :: EventControllerScrollFlags

+ GI.Gtk.Flags: EventControllerScrollFlagsKinetic :: EventControllerScrollFlags

+ GI.Gtk.Flags: EventControllerScrollFlagsNone :: EventControllerScrollFlags

+ GI.Gtk.Flags: EventControllerScrollFlagsVertical :: EventControllerScrollFlags

+ GI.Gtk.Flags: FontChooserLevelFamily :: FontChooserLevel

+ GI.Gtk.Flags: FontChooserLevelFeatures :: FontChooserLevel

+ GI.Gtk.Flags: FontChooserLevelSize :: FontChooserLevel

+ GI.Gtk.Flags: FontChooserLevelStyle :: FontChooserLevel

+ GI.Gtk.Flags: FontChooserLevelVariations :: FontChooserLevel

+ GI.Gtk.Flags: data EventControllerScrollFlags

+ GI.Gtk.Flags: data FontChooserLevel

+ GI.Gtk.Flags: instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.EventControllerScrollFlags

+ GI.Gtk.Flags: instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.FontChooserLevel

+ GI.Gtk.Flags: instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.EventControllerScrollFlags

+ GI.Gtk.Flags: instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.FontChooserLevel

+ GI.Gtk.Flags: instance GHC.Classes.Eq GI.Gtk.Flags.EventControllerScrollFlags

+ GI.Gtk.Flags: instance GHC.Classes.Eq GI.Gtk.Flags.FontChooserLevel

+ GI.Gtk.Flags: instance GHC.Classes.Ord GI.Gtk.Flags.EventControllerScrollFlags

+ GI.Gtk.Flags: instance GHC.Classes.Ord GI.Gtk.Flags.FontChooserLevel

+ GI.Gtk.Flags: instance GHC.Enum.Enum GI.Gtk.Flags.EventControllerScrollFlags

+ GI.Gtk.Flags: instance GHC.Enum.Enum GI.Gtk.Flags.FontChooserLevel

+ GI.Gtk.Flags: instance GHC.Show.Show GI.Gtk.Flags.EventControllerScrollFlags

+ GI.Gtk.Flags: instance GHC.Show.Show GI.Gtk.Flags.FontChooserLevel

+ GI.Gtk.Interfaces.FontChooser: constructFontChooserLanguage :: IsFontChooser o => Text -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.FontChooser: constructFontChooserLevel :: IsFontChooser o => [FontChooserLevel] -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.FontChooser: fontChooserGetFontFeatures :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Text

+ GI.Gtk.Interfaces.FontChooser: fontChooserGetLanguage :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Text

+ GI.Gtk.Interfaces.FontChooser: fontChooserGetLevel :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m [FontChooserLevel]

+ GI.Gtk.Interfaces.FontChooser: fontChooserSetLanguage :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Text -> m ()

+ GI.Gtk.Interfaces.FontChooser: fontChooserSetLevel :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> [FontChooserLevel] -> m ()

+ GI.Gtk.Interfaces.FontChooser: getFontChooserFontFeatures :: (MonadIO m, IsFontChooser o) => o -> m (Maybe Text)

+ GI.Gtk.Interfaces.FontChooser: getFontChooserLanguage :: (MonadIO m, IsFontChooser o) => o -> m (Maybe Text)

+ GI.Gtk.Interfaces.FontChooser: getFontChooserLevel :: (MonadIO m, IsFontChooser o) => o -> m [FontChooserLevel]

+ GI.Gtk.Interfaces.FontChooser: setFontChooserLanguage :: (MonadIO m, IsFontChooser o) => o -> Text -> m ()

+ GI.Gtk.Interfaces.FontChooser: setFontChooserLevel :: (MonadIO m, IsFontChooser o) => o -> [FontChooserLevel] -> m ()

+ GI.Gtk.Objects.Application: getApplicationScreensaverActive :: (MonadIO m, IsApplication o) => o -> m Bool

+ GI.Gtk.Objects.Entry: constructEntryEnableEmojiCompletion :: IsEntry o => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: getEntryEnableEmojiCompletion :: (MonadIO m, IsEntry o) => o -> m Bool

+ GI.Gtk.Objects.Entry: setEntryEnableEmojiCompletion :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

+ GI.Gtk.Objects.EventControllerKey: EventControllerKey :: ManagedPtr EventControllerKey -> EventControllerKey

+ GI.Gtk.Objects.EventControllerKey: afterEventControllerKeyFocusIn :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusInCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerKey: afterEventControllerKeyFocusOut :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusOutCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerKey: afterEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyImUpdateCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerKey: afterEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyPressedCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerKey: afterEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyReleasedCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerKey: afterEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyModifiersCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerKey: class GObject o => IsEventControllerKey o

+ GI.Gtk.Objects.EventControllerKey: eventControllerKeyForward :: (HasCallStack, MonadIO m, IsEventControllerKey a, IsWidget b) => a -> b -> m Bool

+ GI.Gtk.Objects.EventControllerKey: eventControllerKeyGetGroup :: (HasCallStack, MonadIO m, IsEventControllerKey a) => a -> m Word32

+ GI.Gtk.Objects.EventControllerKey: eventControllerKeyGetImContext :: (HasCallStack, MonadIO m, IsEventControllerKey a) => a -> m IMContext

+ GI.Gtk.Objects.EventControllerKey: eventControllerKeyNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m EventControllerKey

+ GI.Gtk.Objects.EventControllerKey: eventControllerKeySetImContext :: (HasCallStack, MonadIO m, IsEventControllerKey a, IsIMContext b) => a -> b -> m ()

+ GI.Gtk.Objects.EventControllerKey: genClosure_EventControllerKeyFocusIn :: EventControllerKeyFocusInCallback -> IO Closure

+ GI.Gtk.Objects.EventControllerKey: genClosure_EventControllerKeyFocusOut :: EventControllerKeyFocusOutCallback -> IO Closure

+ GI.Gtk.Objects.EventControllerKey: genClosure_EventControllerKeyImUpdate :: EventControllerKeyImUpdateCallback -> IO Closure

+ GI.Gtk.Objects.EventControllerKey: genClosure_EventControllerKeyKeyPressed :: EventControllerKeyKeyPressedCallback -> IO Closure

+ GI.Gtk.Objects.EventControllerKey: genClosure_EventControllerKeyKeyReleased :: EventControllerKeyKeyReleasedCallback -> IO Closure

+ GI.Gtk.Objects.EventControllerKey: genClosure_EventControllerKeyModifiers :: EventControllerKeyModifiersCallback -> IO Closure

+ GI.Gtk.Objects.EventControllerKey: instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Gtk.Objects.EventControllerKey.EventControllerKey a) => GI.Gtk.Objects.EventControllerKey.IsEventControllerKey a

+ GI.Gtk.Objects.EventControllerKey: instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.EventControllerKey.EventControllerKey

+ GI.Gtk.Objects.EventControllerKey: instance GI.GObject.Objects.Object.IsObject GI.Gtk.Objects.EventControllerKey.EventControllerKey

+ GI.Gtk.Objects.EventControllerKey: instance GI.Gtk.Objects.EventController.IsEventController GI.Gtk.Objects.EventControllerKey.EventControllerKey

+ GI.Gtk.Objects.EventControllerKey: instance GI.Gtk.Objects.EventControllerKey.IsEventControllerKey GI.Gtk.Objects.EventControllerKey.EventControllerKey

+ GI.Gtk.Objects.EventControllerKey: mk_EventControllerKeyFocusInCallback :: C_EventControllerKeyFocusInCallback -> IO (FunPtr C_EventControllerKeyFocusInCallback)

+ GI.Gtk.Objects.EventControllerKey: mk_EventControllerKeyFocusOutCallback :: C_EventControllerKeyFocusOutCallback -> IO (FunPtr C_EventControllerKeyFocusOutCallback)

+ GI.Gtk.Objects.EventControllerKey: mk_EventControllerKeyImUpdateCallback :: C_EventControllerKeyImUpdateCallback -> IO (FunPtr C_EventControllerKeyImUpdateCallback)

+ GI.Gtk.Objects.EventControllerKey: mk_EventControllerKeyKeyPressedCallback :: C_EventControllerKeyKeyPressedCallback -> IO (FunPtr C_EventControllerKeyKeyPressedCallback)

+ GI.Gtk.Objects.EventControllerKey: mk_EventControllerKeyKeyReleasedCallback :: C_EventControllerKeyKeyReleasedCallback -> IO (FunPtr C_EventControllerKeyKeyReleasedCallback)

+ GI.Gtk.Objects.EventControllerKey: mk_EventControllerKeyModifiersCallback :: C_EventControllerKeyModifiersCallback -> IO (FunPtr C_EventControllerKeyModifiersCallback)

+ GI.Gtk.Objects.EventControllerKey: newtype EventControllerKey

+ GI.Gtk.Objects.EventControllerKey: noEventControllerKey :: Maybe EventControllerKey

+ GI.Gtk.Objects.EventControllerKey: noEventControllerKeyFocusInCallback :: Maybe EventControllerKeyFocusInCallback

+ GI.Gtk.Objects.EventControllerKey: noEventControllerKeyFocusOutCallback :: Maybe EventControllerKeyFocusOutCallback

+ GI.Gtk.Objects.EventControllerKey: noEventControllerKeyImUpdateCallback :: Maybe EventControllerKeyImUpdateCallback

+ GI.Gtk.Objects.EventControllerKey: noEventControllerKeyKeyPressedCallback :: Maybe EventControllerKeyKeyPressedCallback

+ GI.Gtk.Objects.EventControllerKey: noEventControllerKeyKeyReleasedCallback :: Maybe EventControllerKeyKeyReleasedCallback

+ GI.Gtk.Objects.EventControllerKey: noEventControllerKeyModifiersCallback :: Maybe EventControllerKeyModifiersCallback

+ GI.Gtk.Objects.EventControllerKey: onEventControllerKeyFocusIn :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusInCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerKey: onEventControllerKeyFocusOut :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyFocusOutCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerKey: onEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyImUpdateCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerKey: onEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyPressedCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerKey: onEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyKeyReleasedCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerKey: onEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> EventControllerKeyModifiersCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerKey: toEventControllerKey :: (MonadIO m, IsEventControllerKey o) => o -> m EventControllerKey

+ GI.Gtk.Objects.EventControllerKey: type C_EventControllerKeyFocusInCallback = Ptr () -> Ptr () -> IO ()

+ GI.Gtk.Objects.EventControllerKey: type C_EventControllerKeyFocusOutCallback = Ptr () -> Ptr () -> IO ()

+ GI.Gtk.Objects.EventControllerKey: type C_EventControllerKeyImUpdateCallback = Ptr () -> Ptr () -> IO ()

+ GI.Gtk.Objects.EventControllerKey: type C_EventControllerKeyKeyPressedCallback = Ptr () -> Word32 -> Word32 -> CUInt -> Ptr () -> IO CInt

+ GI.Gtk.Objects.EventControllerKey: type C_EventControllerKeyKeyReleasedCallback = Ptr () -> Word32 -> Word32 -> CUInt -> Ptr () -> IO ()

+ GI.Gtk.Objects.EventControllerKey: type C_EventControllerKeyModifiersCallback = Ptr () -> CUInt -> Ptr () -> IO CInt

+ GI.Gtk.Objects.EventControllerKey: type EventControllerKeyFocusInCallback = IO ()

+ GI.Gtk.Objects.EventControllerKey: type EventControllerKeyFocusOutCallback = IO ()

+ GI.Gtk.Objects.EventControllerKey: type EventControllerKeyImUpdateCallback = IO ()

+ GI.Gtk.Objects.EventControllerKey: type EventControllerKeyKeyPressedCallback = Word32 -> Word32 -> [ModifierType] -> IO Bool

+ GI.Gtk.Objects.EventControllerKey: type EventControllerKeyKeyReleasedCallback = Word32 -> Word32 -> [ModifierType] -> IO ()

+ GI.Gtk.Objects.EventControllerKey: type EventControllerKeyModifiersCallback = [ModifierType] -> IO Bool

+ GI.Gtk.Objects.EventControllerKey: wrap_EventControllerKeyFocusInCallback :: EventControllerKeyFocusInCallback -> C_EventControllerKeyFocusInCallback

+ GI.Gtk.Objects.EventControllerKey: wrap_EventControllerKeyFocusOutCallback :: EventControllerKeyFocusOutCallback -> C_EventControllerKeyFocusOutCallback

+ GI.Gtk.Objects.EventControllerKey: wrap_EventControllerKeyImUpdateCallback :: EventControllerKeyImUpdateCallback -> C_EventControllerKeyImUpdateCallback

+ GI.Gtk.Objects.EventControllerKey: wrap_EventControllerKeyKeyPressedCallback :: EventControllerKeyKeyPressedCallback -> C_EventControllerKeyKeyPressedCallback

+ GI.Gtk.Objects.EventControllerKey: wrap_EventControllerKeyKeyReleasedCallback :: EventControllerKeyKeyReleasedCallback -> C_EventControllerKeyKeyReleasedCallback

+ GI.Gtk.Objects.EventControllerKey: wrap_EventControllerKeyModifiersCallback :: EventControllerKeyModifiersCallback -> C_EventControllerKeyModifiersCallback

+ GI.Gtk.Objects.EventControllerMotion: EventControllerMotion :: ManagedPtr EventControllerMotion -> EventControllerMotion

+ GI.Gtk.Objects.EventControllerMotion: afterEventControllerMotionEnter :: (IsEventControllerMotion a, MonadIO m) => a -> EventControllerMotionEnterCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerMotion: afterEventControllerMotionLeave :: (IsEventControllerMotion a, MonadIO m) => a -> EventControllerMotionLeaveCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerMotion: afterEventControllerMotionMotion :: (IsEventControllerMotion a, MonadIO m) => a -> EventControllerMotionMotionCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerMotion: class GObject o => IsEventControllerMotion o

+ GI.Gtk.Objects.EventControllerMotion: eventControllerMotionNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m EventControllerMotion

+ GI.Gtk.Objects.EventControllerMotion: genClosure_EventControllerMotionEnter :: EventControllerMotionEnterCallback -> IO Closure

+ GI.Gtk.Objects.EventControllerMotion: genClosure_EventControllerMotionLeave :: EventControllerMotionLeaveCallback -> IO Closure

+ GI.Gtk.Objects.EventControllerMotion: genClosure_EventControllerMotionMotion :: EventControllerMotionMotionCallback -> IO Closure

+ GI.Gtk.Objects.EventControllerMotion: instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Gtk.Objects.EventControllerMotion.EventControllerMotion a) => GI.Gtk.Objects.EventControllerMotion.IsEventControllerMotion a

+ GI.Gtk.Objects.EventControllerMotion: instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.EventControllerMotion.EventControllerMotion

+ GI.Gtk.Objects.EventControllerMotion: instance GI.GObject.Objects.Object.IsObject GI.Gtk.Objects.EventControllerMotion.EventControllerMotion

+ GI.Gtk.Objects.EventControllerMotion: instance GI.Gtk.Objects.EventController.IsEventController GI.Gtk.Objects.EventControllerMotion.EventControllerMotion

+ GI.Gtk.Objects.EventControllerMotion: instance GI.Gtk.Objects.EventControllerMotion.IsEventControllerMotion GI.Gtk.Objects.EventControllerMotion.EventControllerMotion

+ GI.Gtk.Objects.EventControllerMotion: mk_EventControllerMotionEnterCallback :: C_EventControllerMotionEnterCallback -> IO (FunPtr C_EventControllerMotionEnterCallback)

+ GI.Gtk.Objects.EventControllerMotion: mk_EventControllerMotionLeaveCallback :: C_EventControllerMotionLeaveCallback -> IO (FunPtr C_EventControllerMotionLeaveCallback)

+ GI.Gtk.Objects.EventControllerMotion: mk_EventControllerMotionMotionCallback :: C_EventControllerMotionMotionCallback -> IO (FunPtr C_EventControllerMotionMotionCallback)

+ GI.Gtk.Objects.EventControllerMotion: newtype EventControllerMotion

+ GI.Gtk.Objects.EventControllerMotion: noEventControllerMotion :: Maybe EventControllerMotion

+ GI.Gtk.Objects.EventControllerMotion: noEventControllerMotionEnterCallback :: Maybe EventControllerMotionEnterCallback

+ GI.Gtk.Objects.EventControllerMotion: noEventControllerMotionLeaveCallback :: Maybe EventControllerMotionLeaveCallback

+ GI.Gtk.Objects.EventControllerMotion: noEventControllerMotionMotionCallback :: Maybe EventControllerMotionMotionCallback

+ GI.Gtk.Objects.EventControllerMotion: onEventControllerMotionEnter :: (IsEventControllerMotion a, MonadIO m) => a -> EventControllerMotionEnterCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerMotion: onEventControllerMotionLeave :: (IsEventControllerMotion a, MonadIO m) => a -> EventControllerMotionLeaveCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerMotion: onEventControllerMotionMotion :: (IsEventControllerMotion a, MonadIO m) => a -> EventControllerMotionMotionCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerMotion: toEventControllerMotion :: (MonadIO m, IsEventControllerMotion o) => o -> m EventControllerMotion

+ GI.Gtk.Objects.EventControllerMotion: type C_EventControllerMotionEnterCallback = Ptr () -> CDouble -> CDouble -> Ptr () -> IO ()

+ GI.Gtk.Objects.EventControllerMotion: type C_EventControllerMotionLeaveCallback = Ptr () -> Ptr () -> IO ()

+ GI.Gtk.Objects.EventControllerMotion: type C_EventControllerMotionMotionCallback = Ptr () -> CDouble -> CDouble -> Ptr () -> IO ()

+ GI.Gtk.Objects.EventControllerMotion: type EventControllerMotionEnterCallback = Double " /@x@/: the x coordinate " -> Double " /@y@/: the y coordinate " -> IO ()

+ GI.Gtk.Objects.EventControllerMotion: type EventControllerMotionLeaveCallback = IO ()

+ GI.Gtk.Objects.EventControllerMotion: type EventControllerMotionMotionCallback = Double " /@x@/: the x coordinate " -> Double " /@y@/: the y coordinate " -> IO ()

+ GI.Gtk.Objects.EventControllerMotion: wrap_EventControllerMotionEnterCallback :: EventControllerMotionEnterCallback -> C_EventControllerMotionEnterCallback

+ GI.Gtk.Objects.EventControllerMotion: wrap_EventControllerMotionLeaveCallback :: EventControllerMotionLeaveCallback -> C_EventControllerMotionLeaveCallback

+ GI.Gtk.Objects.EventControllerMotion: wrap_EventControllerMotionMotionCallback :: EventControllerMotionMotionCallback -> C_EventControllerMotionMotionCallback

+ GI.Gtk.Objects.EventControllerScroll: EventControllerScroll :: ManagedPtr EventControllerScroll -> EventControllerScroll

+ GI.Gtk.Objects.EventControllerScroll: afterEventControllerScrollDecelerate :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollDecelerateCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerScroll: afterEventControllerScrollScroll :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollScrollCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerScroll: afterEventControllerScrollScrollBegin :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollScrollBeginCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerScroll: afterEventControllerScrollScrollEnd :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollScrollEndCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerScroll: class GObject o => IsEventControllerScroll o

+ GI.Gtk.Objects.EventControllerScroll: constructEventControllerScrollFlags :: IsEventControllerScroll o => [EventControllerScrollFlags] -> IO (GValueConstruct o)

+ GI.Gtk.Objects.EventControllerScroll: eventControllerScrollGetFlags :: (HasCallStack, MonadIO m, IsEventControllerScroll a) => a -> m [EventControllerScrollFlags]

+ GI.Gtk.Objects.EventControllerScroll: eventControllerScrollNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> [EventControllerScrollFlags] -> m EventControllerScroll

+ GI.Gtk.Objects.EventControllerScroll: eventControllerScrollSetFlags :: (HasCallStack, MonadIO m, IsEventControllerScroll a) => a -> [EventControllerScrollFlags] -> m ()

+ GI.Gtk.Objects.EventControllerScroll: genClosure_EventControllerScrollDecelerate :: EventControllerScrollDecelerateCallback -> IO Closure

+ GI.Gtk.Objects.EventControllerScroll: genClosure_EventControllerScrollScroll :: EventControllerScrollScrollCallback -> IO Closure

+ GI.Gtk.Objects.EventControllerScroll: genClosure_EventControllerScrollScrollBegin :: EventControllerScrollScrollBeginCallback -> IO Closure

+ GI.Gtk.Objects.EventControllerScroll: genClosure_EventControllerScrollScrollEnd :: EventControllerScrollScrollEndCallback -> IO Closure

+ GI.Gtk.Objects.EventControllerScroll: getEventControllerScrollFlags :: (MonadIO m, IsEventControllerScroll o) => o -> m [EventControllerScrollFlags]

+ GI.Gtk.Objects.EventControllerScroll: instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Gtk.Objects.EventControllerScroll.EventControllerScroll a) => GI.Gtk.Objects.EventControllerScroll.IsEventControllerScroll a

+ GI.Gtk.Objects.EventControllerScroll: instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.EventControllerScroll.EventControllerScroll

+ GI.Gtk.Objects.EventControllerScroll: instance GI.GObject.Objects.Object.IsObject GI.Gtk.Objects.EventControllerScroll.EventControllerScroll

+ GI.Gtk.Objects.EventControllerScroll: instance GI.Gtk.Objects.EventController.IsEventController GI.Gtk.Objects.EventControllerScroll.EventControllerScroll

+ GI.Gtk.Objects.EventControllerScroll: instance GI.Gtk.Objects.EventControllerScroll.IsEventControllerScroll GI.Gtk.Objects.EventControllerScroll.EventControllerScroll

+ GI.Gtk.Objects.EventControllerScroll: mk_EventControllerScrollDecelerateCallback :: C_EventControllerScrollDecelerateCallback -> IO (FunPtr C_EventControllerScrollDecelerateCallback)

+ GI.Gtk.Objects.EventControllerScroll: mk_EventControllerScrollScrollBeginCallback :: C_EventControllerScrollScrollBeginCallback -> IO (FunPtr C_EventControllerScrollScrollBeginCallback)

+ GI.Gtk.Objects.EventControllerScroll: mk_EventControllerScrollScrollCallback :: C_EventControllerScrollScrollCallback -> IO (FunPtr C_EventControllerScrollScrollCallback)

+ GI.Gtk.Objects.EventControllerScroll: mk_EventControllerScrollScrollEndCallback :: C_EventControllerScrollScrollEndCallback -> IO (FunPtr C_EventControllerScrollScrollEndCallback)

+ GI.Gtk.Objects.EventControllerScroll: newtype EventControllerScroll

+ GI.Gtk.Objects.EventControllerScroll: noEventControllerScroll :: Maybe EventControllerScroll

+ GI.Gtk.Objects.EventControllerScroll: noEventControllerScrollDecelerateCallback :: Maybe EventControllerScrollDecelerateCallback

+ GI.Gtk.Objects.EventControllerScroll: noEventControllerScrollScrollBeginCallback :: Maybe EventControllerScrollScrollBeginCallback

+ GI.Gtk.Objects.EventControllerScroll: noEventControllerScrollScrollCallback :: Maybe EventControllerScrollScrollCallback

+ GI.Gtk.Objects.EventControllerScroll: noEventControllerScrollScrollEndCallback :: Maybe EventControllerScrollScrollEndCallback

+ GI.Gtk.Objects.EventControllerScroll: onEventControllerScrollDecelerate :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollDecelerateCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerScroll: onEventControllerScrollScroll :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollScrollCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerScroll: onEventControllerScrollScrollBegin :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollScrollBeginCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerScroll: onEventControllerScrollScrollEnd :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollScrollEndCallback -> m SignalHandlerId

+ GI.Gtk.Objects.EventControllerScroll: setEventControllerScrollFlags :: (MonadIO m, IsEventControllerScroll o) => o -> [EventControllerScrollFlags] -> m ()

+ GI.Gtk.Objects.EventControllerScroll: toEventControllerScroll :: (MonadIO m, IsEventControllerScroll o) => o -> m EventControllerScroll

+ GI.Gtk.Objects.EventControllerScroll: type C_EventControllerScrollDecelerateCallback = Ptr () -> CDouble -> CDouble -> Ptr () -> IO ()

+ GI.Gtk.Objects.EventControllerScroll: type C_EventControllerScrollScrollBeginCallback = Ptr () -> Ptr () -> IO ()

+ GI.Gtk.Objects.EventControllerScroll: type C_EventControllerScrollScrollCallback = Ptr () -> CDouble -> CDouble -> Ptr () -> IO ()

+ GI.Gtk.Objects.EventControllerScroll: type C_EventControllerScrollScrollEndCallback = Ptr () -> Ptr () -> IO ()

+ GI.Gtk.Objects.EventControllerScroll: type EventControllerScrollDecelerateCallback = Double " /@velX@/: X velocity " -> Double " /@velY@/: Y velocity " -> IO ()

+ GI.Gtk.Objects.EventControllerScroll: type EventControllerScrollScrollBeginCallback = IO ()

+ GI.Gtk.Objects.EventControllerScroll: type EventControllerScrollScrollCallback = Double " /@dx@/: X delta " -> Double " /@dy@/: Y delta " -> IO ()

+ GI.Gtk.Objects.EventControllerScroll: type EventControllerScrollScrollEndCallback = IO ()

+ GI.Gtk.Objects.EventControllerScroll: wrap_EventControllerScrollDecelerateCallback :: EventControllerScrollDecelerateCallback -> C_EventControllerScrollDecelerateCallback

+ GI.Gtk.Objects.EventControllerScroll: wrap_EventControllerScrollScrollBeginCallback :: EventControllerScrollScrollBeginCallback -> C_EventControllerScrollScrollBeginCallback

+ GI.Gtk.Objects.EventControllerScroll: wrap_EventControllerScrollScrollCallback :: EventControllerScrollScrollCallback -> C_EventControllerScrollScrollCallback

+ GI.Gtk.Objects.EventControllerScroll: wrap_EventControllerScrollScrollEndCallback :: EventControllerScrollScrollEndCallback -> C_EventControllerScrollScrollEndCallback

+ GI.Gtk.Objects.FontChooserWidget: getFontChooserWidgetTweakAction :: (MonadIO m, IsFontChooserWidget o) => o -> m (Maybe Action)

+ GI.Gtk.Objects.GestureStylus: GestureStylus :: ManagedPtr GestureStylus -> GestureStylus

+ GI.Gtk.Objects.GestureStylus: afterGestureStylusDown :: (IsGestureStylus a, MonadIO m) => a -> GestureStylusDownCallback -> m SignalHandlerId

+ GI.Gtk.Objects.GestureStylus: afterGestureStylusMotion :: (IsGestureStylus a, MonadIO m) => a -> GestureStylusMotionCallback -> m SignalHandlerId

+ GI.Gtk.Objects.GestureStylus: afterGestureStylusProximity :: (IsGestureStylus a, MonadIO m) => a -> GestureStylusProximityCallback -> m SignalHandlerId

+ GI.Gtk.Objects.GestureStylus: afterGestureStylusUp :: (IsGestureStylus a, MonadIO m) => a -> GestureStylusUpCallback -> m SignalHandlerId

+ GI.Gtk.Objects.GestureStylus: class GObject o => IsGestureStylus o

+ GI.Gtk.Objects.GestureStylus: genClosure_GestureStylusDown :: GestureStylusDownCallback -> IO Closure

+ GI.Gtk.Objects.GestureStylus: genClosure_GestureStylusMotion :: GestureStylusMotionCallback -> IO Closure

+ GI.Gtk.Objects.GestureStylus: genClosure_GestureStylusProximity :: GestureStylusProximityCallback -> IO Closure

+ GI.Gtk.Objects.GestureStylus: genClosure_GestureStylusUp :: GestureStylusUpCallback -> IO Closure

+ GI.Gtk.Objects.GestureStylus: gestureStylusGetAxis :: (HasCallStack, MonadIO m, IsGestureStylus a) => a -> AxisUse -> m (Bool, Double)

+ GI.Gtk.Objects.GestureStylus: gestureStylusGetDeviceTool :: (HasCallStack, MonadIO m, IsGestureStylus a) => a -> m (Maybe DeviceTool)

+ GI.Gtk.Objects.GestureStylus: gestureStylusNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureStylus

+ GI.Gtk.Objects.GestureStylus: instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Gtk.Objects.GestureStylus.GestureStylus a) => GI.Gtk.Objects.GestureStylus.IsGestureStylus a

+ GI.Gtk.Objects.GestureStylus: instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GestureStylus.GestureStylus

+ GI.Gtk.Objects.GestureStylus: instance GI.GObject.Objects.Object.IsObject GI.Gtk.Objects.GestureStylus.GestureStylus

+ GI.Gtk.Objects.GestureStylus: instance GI.Gtk.Objects.EventController.IsEventController GI.Gtk.Objects.GestureStylus.GestureStylus

+ GI.Gtk.Objects.GestureStylus: instance GI.Gtk.Objects.Gesture.IsGesture GI.Gtk.Objects.GestureStylus.GestureStylus

+ GI.Gtk.Objects.GestureStylus: instance GI.Gtk.Objects.GestureSingle.IsGestureSingle GI.Gtk.Objects.GestureStylus.GestureStylus

+ GI.Gtk.Objects.GestureStylus: instance GI.Gtk.Objects.GestureStylus.IsGestureStylus GI.Gtk.Objects.GestureStylus.GestureStylus

+ GI.Gtk.Objects.GestureStylus: mk_GestureStylusDownCallback :: C_GestureStylusDownCallback -> IO (FunPtr C_GestureStylusDownCallback)

+ GI.Gtk.Objects.GestureStylus: mk_GestureStylusMotionCallback :: C_GestureStylusMotionCallback -> IO (FunPtr C_GestureStylusMotionCallback)

+ GI.Gtk.Objects.GestureStylus: mk_GestureStylusProximityCallback :: C_GestureStylusProximityCallback -> IO (FunPtr C_GestureStylusProximityCallback)

+ GI.Gtk.Objects.GestureStylus: mk_GestureStylusUpCallback :: C_GestureStylusUpCallback -> IO (FunPtr C_GestureStylusUpCallback)

+ GI.Gtk.Objects.GestureStylus: newtype GestureStylus

+ GI.Gtk.Objects.GestureStylus: noGestureStylus :: Maybe GestureStylus

+ GI.Gtk.Objects.GestureStylus: noGestureStylusDownCallback :: Maybe GestureStylusDownCallback

+ GI.Gtk.Objects.GestureStylus: noGestureStylusMotionCallback :: Maybe GestureStylusMotionCallback

+ GI.Gtk.Objects.GestureStylus: noGestureStylusProximityCallback :: Maybe GestureStylusProximityCallback

+ GI.Gtk.Objects.GestureStylus: noGestureStylusUpCallback :: Maybe GestureStylusUpCallback

+ GI.Gtk.Objects.GestureStylus: onGestureStylusDown :: (IsGestureStylus a, MonadIO m) => a -> GestureStylusDownCallback -> m SignalHandlerId

+ GI.Gtk.Objects.GestureStylus: onGestureStylusMotion :: (IsGestureStylus a, MonadIO m) => a -> GestureStylusMotionCallback -> m SignalHandlerId

+ GI.Gtk.Objects.GestureStylus: onGestureStylusProximity :: (IsGestureStylus a, MonadIO m) => a -> GestureStylusProximityCallback -> m SignalHandlerId

+ GI.Gtk.Objects.GestureStylus: onGestureStylusUp :: (IsGestureStylus a, MonadIO m) => a -> GestureStylusUpCallback -> m SignalHandlerId

+ GI.Gtk.Objects.GestureStylus: toGestureStylus :: (MonadIO m, IsGestureStylus o) => o -> m GestureStylus

+ GI.Gtk.Objects.GestureStylus: type C_GestureStylusDownCallback = Ptr () -> CDouble -> CDouble -> Ptr () -> IO ()

+ GI.Gtk.Objects.GestureStylus: type C_GestureStylusMotionCallback = Ptr () -> CDouble -> CDouble -> Ptr () -> IO ()

+ GI.Gtk.Objects.GestureStylus: type C_GestureStylusProximityCallback = Ptr () -> CDouble -> CDouble -> Ptr () -> IO ()

+ GI.Gtk.Objects.GestureStylus: type C_GestureStylusUpCallback = Ptr () -> CDouble -> CDouble -> Ptr () -> IO ()

+ GI.Gtk.Objects.GestureStylus: type GestureStylusDownCallback = Double -> Double -> IO ()

+ GI.Gtk.Objects.GestureStylus: type GestureStylusMotionCallback = Double -> Double -> IO ()

+ GI.Gtk.Objects.GestureStylus: type GestureStylusProximityCallback = Double -> Double -> IO ()

+ GI.Gtk.Objects.GestureStylus: type GestureStylusUpCallback = Double -> Double -> IO ()

+ GI.Gtk.Objects.GestureStylus: wrap_GestureStylusDownCallback :: GestureStylusDownCallback -> C_GestureStylusDownCallback

+ GI.Gtk.Objects.GestureStylus: wrap_GestureStylusMotionCallback :: GestureStylusMotionCallback -> C_GestureStylusMotionCallback

+ GI.Gtk.Objects.GestureStylus: wrap_GestureStylusProximityCallback :: GestureStylusProximityCallback -> C_GestureStylusProximityCallback

+ GI.Gtk.Objects.GestureStylus: wrap_GestureStylusUpCallback :: GestureStylusUpCallback -> C_GestureStylusUpCallback

+ GI.Gtk.Objects.ModelButton: constructModelButtonUseMarkup :: IsModelButton o => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ModelButton: getModelButtonUseMarkup :: (MonadIO m, IsModelButton o) => o -> m Bool

+ GI.Gtk.Objects.ModelButton: setModelButtonUseMarkup :: (MonadIO m, IsModelButton o) => o -> Bool -> m ()

+ GI.Gtk.Structs.AccelGroupEntry: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.AccelGroupEntry.AccelGroupEntry tag

+ GI.Gtk.Structs.AccelKey: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.AccelKey.AccelKey tag

+ GI.Gtk.Structs.ActionEntry: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.ActionEntry.ActionEntry tag

+ GI.Gtk.Structs.BindingArg: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.BindingArg.BindingArg tag

+ GI.Gtk.Structs.BindingEntry: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.BindingEntry.BindingEntry tag

+ GI.Gtk.Structs.BindingSet: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.BindingSet.BindingSet tag

+ GI.Gtk.Structs.BindingSignal: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.BindingSignal.BindingSignal tag

+ GI.Gtk.Structs.Border: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.Border.Border tag

+ GI.Gtk.Structs.FileFilterInfo: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.FileFilterInfo.FileFilterInfo tag

+ GI.Gtk.Structs.FixedChild: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.FixedChild.FixedChild tag

+ GI.Gtk.Structs.IMContextInfo: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.IMContextInfo.IMContextInfo tag

+ GI.Gtk.Structs.PadActionEntry: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.PadActionEntry.PadActionEntry tag

+ GI.Gtk.Structs.PageRange: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.PageRange.PageRange tag

+ GI.Gtk.Structs.RadioActionEntry: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.RadioActionEntry.RadioActionEntry tag

+ GI.Gtk.Structs.RcProperty: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.RcProperty.RcProperty tag

+ GI.Gtk.Structs.RecentData: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.RecentData.RecentData tag

+ GI.Gtk.Structs.RecentFilterInfo: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.RecentFilterInfo.RecentFilterInfo tag

+ GI.Gtk.Structs.RequestedSize: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.RequestedSize.RequestedSize tag

+ GI.Gtk.Structs.Requisition: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.Requisition.Requisition tag

+ GI.Gtk.Structs.SettingsValue: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.SettingsValue.SettingsValue tag

+ GI.Gtk.Structs.StockItem: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.StockItem.StockItem tag

+ GI.Gtk.Structs.TableChild: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TableChild.TableChild tag

+ GI.Gtk.Structs.TableRowCol: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TableRowCol.TableRowCol tag

+ GI.Gtk.Structs.TargetEntry: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TargetEntry.TargetEntry tag

+ GI.Gtk.Structs.TargetPair: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TargetPair.TargetPair tag

+ GI.Gtk.Structs.TextAppearance: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TextAppearance.TextAppearance tag

+ GI.Gtk.Structs.TextAttributes: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TextAttributes.TextAttributes tag

+ GI.Gtk.Structs.TextIter: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TextIter.TextIter tag

+ GI.Gtk.Structs.ToggleActionEntry: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.ToggleActionEntry.ToggleActionEntry tag

+ GI.Gtk.Structs.TreeIter: instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TreeIter.TreeIter tag

- GI.Gtk.Callbacks: dynamic_BuilderConnectFunc :: (HasCallStack, MonadIO m, IsBuilder a, IsObject b, IsObject c) => FunPtr C_BuilderConnectFunc -> a -> b -> Text -> Text -> Maybe (c) -> [ConnectFlags] -> Ptr () -> m ()

+ GI.Gtk.Callbacks: dynamic_BuilderConnectFunc :: (HasCallStack, MonadIO m, IsBuilder a, IsObject b, IsObject c) => FunPtr C_BuilderConnectFunc -> a -> b -> Text -> Text -> Maybe c -> [ConnectFlags] -> Ptr () -> m ()

- GI.Gtk.Callbacks: dynamic_ClipboardRichTextReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardRichTextReceivedFunc -> a -> Atom -> Maybe (Text) -> Word64 -> Ptr () -> m ()

+ GI.Gtk.Callbacks: dynamic_ClipboardRichTextReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardRichTextReceivedFunc -> a -> Atom -> Maybe Text -> Word64 -> Ptr () -> m ()

- GI.Gtk.Callbacks: dynamic_ClipboardTargetsReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardTargetsReceivedFunc -> a -> Maybe ([Atom]) -> Ptr () -> m ()

+ GI.Gtk.Callbacks: dynamic_ClipboardTargetsReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardTargetsReceivedFunc -> a -> Maybe [Atom] -> Ptr () -> m ()

- GI.Gtk.Callbacks: dynamic_ClipboardTextReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardTextReceivedFunc -> a -> Maybe (Text) -> Ptr () -> m ()

+ GI.Gtk.Callbacks: dynamic_ClipboardTextReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardTextReceivedFunc -> a -> Maybe Text -> Ptr () -> m ()

- GI.Gtk.Callbacks: dynamic_FlowBoxCreateWidgetFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_FlowBoxCreateWidgetFunc -> Maybe (a) -> Ptr () -> m Widget

+ GI.Gtk.Callbacks: dynamic_FlowBoxCreateWidgetFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_FlowBoxCreateWidgetFunc -> Maybe a -> Ptr () -> m Widget

- GI.Gtk.Callbacks: dynamic_ListBoxUpdateHeaderFunc :: (HasCallStack, MonadIO m, IsListBoxRow a, IsListBoxRow b) => FunPtr C_ListBoxUpdateHeaderFunc -> a -> Maybe (b) -> Ptr () -> m ()

+ GI.Gtk.Callbacks: dynamic_ListBoxUpdateHeaderFunc :: (HasCallStack, MonadIO m, IsListBoxRow a, IsListBoxRow b) => FunPtr C_ListBoxUpdateHeaderFunc -> a -> Maybe b -> Ptr () -> m ()

- GI.Gtk.Callbacks: dynamic_MenuPositionFunc :: (HasCallStack, MonadIO m, IsMenu a) => FunPtr C_MenuPositionFunc -> a -> Int32 -> Int32 -> Ptr () -> m ((Int32, Int32, Bool))

+ GI.Gtk.Callbacks: dynamic_MenuPositionFunc :: (HasCallStack, MonadIO m, IsMenu a) => FunPtr C_MenuPositionFunc -> a -> Int32 -> Int32 -> Ptr () -> m (Int32, Int32, Bool)

- GI.Gtk.Callbacks: dynamic_ModuleInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_ModuleInitFunc -> Maybe ([Text]) -> m ()

+ GI.Gtk.Callbacks: dynamic_ModuleInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_ModuleInitFunc -> Maybe [Text] -> m ()

- GI.Gtk.Callbacks: type AccelMapForeach = Ptr () /@data@/: User data passed to 'GI.Gtk.Objects.AccelMap.accelMapForeach' or 'GI.Gtk.Objects.AccelMap.accelMapForeachUnfiltered' -> Text /@accelPath@/: Accel path of the current accelerator -> Word32 /@accelKey@/: Key of the current accelerator -> [ModifierType] /@accelMods@/: Modifiers of the current accelerator -> Bool /@changed@/: Changed flag of the accelerator (if 'True', accelerator has changed during runtime and would need to be saved during an accelerator dump) -> IO ()

+ GI.Gtk.Callbacks: type AccelMapForeach = Ptr () " /@data@/: User data passed to 'GI.Gtk.Objects.AccelMap.accelMapForeach' or 'GI.Gtk.Objects.AccelMap.accelMapForeachUnfiltered' " -> Text " /@accelPath@/: Accel path of the current accelerator " -> Word32 " /@accelKey@/: Key of the current accelerator " -> [ModifierType] " /@accelMods@/: Modifiers of the current accelerator " -> Bool " /@changed@/: Changed flag of the accelerator (if 'True', accelerator has changed during runtime and would need to be saved during an accelerator dump) " -> IO ()

- GI.Gtk.Callbacks: type AssistantPageFunc = Int32 /@currentPage@/: The page number used to calculate the next page. -> IO Int32 __Returns:__ The next page number.

+ GI.Gtk.Callbacks: type AssistantPageFunc = Int32 " /@currentPage@/: The page number used to calculate the next page. " -> IO Int32 " __Returns:__ The next page number. "

- GI.Gtk.Callbacks: type AssistantPageFunc_WithClosures = Int32 /@currentPage@/: The page number used to calculate the next page. -> Ptr () /@data@/: user data. -> IO Int32 __Returns:__ The next page number.

+ GI.Gtk.Callbacks: type AssistantPageFunc_WithClosures = Int32 " /@currentPage@/: The page number used to calculate the next page. " -> Ptr () " /@data@/: user data. " -> IO Int32 " __Returns:__ The next page number. "

- GI.Gtk.Callbacks: type BuilderConnectFunc = Builder /@builder@/: a 'GI.Gtk.Objects.Builder.Builder' -> Object /@object@/: object to connect a signal to -> Text /@signalName@/: name of the signal -> Text /@handlerName@/: name of the handler -> Maybe Object /@connectObject@/: a 'GI.GObject.Objects.Object.Object', if non-'Nothing', use @/g_signal_connect_object()/@ -> [ConnectFlags] /@flags@/: 'GI.GObject.Flags.ConnectFlags' to use -> IO ()

+ GI.Gtk.Callbacks: type BuilderConnectFunc = Builder " /@builder@/: a 'GI.Gtk.Objects.Builder.Builder' " -> Object " /@object@/: object to connect a signal to " -> Text " /@signalName@/: name of the signal " -> Text " /@handlerName@/: name of the handler " -> Maybe Object " /@connectObject@/: a 'GI.GObject.Objects.Object.Object', if non-'Nothing', use @/g_signal_connect_object()/@ " -> [ConnectFlags] " /@flags@/: 'GI.GObject.Flags.ConnectFlags' to use " -> IO ()

- GI.Gtk.Callbacks: type BuilderConnectFunc_WithClosures = Builder /@builder@/: a 'GI.Gtk.Objects.Builder.Builder' -> Object /@object@/: object to connect a signal to -> Text /@signalName@/: name of the signal -> Text /@handlerName@/: name of the handler -> Maybe Object /@connectObject@/: a 'GI.GObject.Objects.Object.Object', if non-'Nothing', use @/g_signal_connect_object()/@ -> [ConnectFlags] /@flags@/: 'GI.GObject.Flags.ConnectFlags' to use -> Ptr () /@userData@/: user data -> IO ()

+ GI.Gtk.Callbacks: type BuilderConnectFunc_WithClosures = Builder " /@builder@/: a 'GI.Gtk.Objects.Builder.Builder' " -> Object " /@object@/: object to connect a signal to " -> Text " /@signalName@/: name of the signal " -> Text " /@handlerName@/: name of the handler " -> Maybe Object " /@connectObject@/: a 'GI.GObject.Objects.Object.Object', if non-'Nothing', use @/g_signal_connect_object()/@ " -> [ConnectFlags] " /@flags@/: 'GI.GObject.Flags.ConnectFlags' to use " -> Ptr () " /@userData@/: user data " -> IO ()

- GI.Gtk.Callbacks: type CalendarDetailFunc = Calendar /@calendar@/: a 'GI.Gtk.Objects.Calendar.Calendar'. -> Word32 /@year@/: the year for which details are needed. -> Word32 /@month@/: the month for which details are needed. -> Word32 /@day@/: the day of /@month@/ for which details are needed. -> IO (Maybe Text) __Returns:__ Newly allocated string with Pango markup with details for the specified day or 'Nothing'.

+ GI.Gtk.Callbacks: type CalendarDetailFunc = Calendar " /@calendar@/: a 'GI.Gtk.Objects.Calendar.Calendar'. " -> Word32 " /@year@/: the year for which details are needed. " -> Word32 " /@month@/: the month for which details are needed. " -> Word32 " /@day@/: the day of /@month@/ for which details are needed. " -> IO (Maybe Text) " __Returns:__ Newly allocated string with Pango markup with details for the specified day or 'Nothing'. "

- GI.Gtk.Callbacks: type CalendarDetailFunc_WithClosures = Calendar /@calendar@/: a 'GI.Gtk.Objects.Calendar.Calendar'. -> Word32 /@year@/: the year for which details are needed. -> Word32 /@month@/: the month for which details are needed. -> Word32 /@day@/: the day of /@month@/ for which details are needed. -> Ptr () /@userData@/: the data passed with 'GI.Gtk.Objects.Calendar.calendarSetDetailFunc'. -> IO (Maybe Text) __Returns:__ Newly allocated string with Pango markup with details for the specified day or 'Nothing'.

+ GI.Gtk.Callbacks: type CalendarDetailFunc_WithClosures = Calendar " /@calendar@/: a 'GI.Gtk.Objects.Calendar.Calendar'. " -> Word32 " /@year@/: the year for which details are needed. " -> Word32 " /@month@/: the month for which details are needed. " -> Word32 " /@day@/: the day of /@month@/ for which details are needed. " -> Ptr () " /@userData@/: the data passed with 'GI.Gtk.Objects.Calendar.calendarSetDetailFunc'. " -> IO (Maybe Text) " __Returns:__ Newly allocated string with Pango markup with details for the specified day or 'Nothing'. "

- GI.Gtk.Callbacks: type Callback = Widget /@widget@/: the widget to operate on -> IO ()

+ GI.Gtk.Callbacks: type Callback = Widget " /@widget@/: the widget to operate on " -> IO ()

- GI.Gtk.Callbacks: type Callback_WithClosures = Widget /@widget@/: the widget to operate on -> Ptr () /@data@/: user-supplied data -> IO ()

+ GI.Gtk.Callbacks: type Callback_WithClosures = Widget " /@widget@/: the widget to operate on " -> Ptr () " /@data@/: user-supplied data " -> IO ()

- GI.Gtk.Callbacks: type CellAllocCallback = CellRenderer /@renderer@/: the cell renderer to operate on -> Rectangle /@cellArea@/: the area allocated to /@renderer@/ inside the rectangle provided to 'GI.Gtk.Objects.CellArea.cellAreaForeachAlloc'. -> Rectangle /@cellBackground@/: the background area for /@renderer@/ inside the background area provided to 'GI.Gtk.Objects.CellArea.cellAreaForeachAlloc'. -> IO Bool __Returns:__ 'True' to stop iterating over cells.

+ GI.Gtk.Callbacks: type CellAllocCallback = CellRenderer " /@renderer@/: the cell renderer to operate on " -> Rectangle " /@cellArea@/: the area allocated to /@renderer@/ inside the rectangle provided to 'GI.Gtk.Objects.CellArea.cellAreaForeachAlloc'. " -> Rectangle " /@cellBackground@/: the background area for /@renderer@/ inside the background area provided to 'GI.Gtk.Objects.CellArea.cellAreaForeachAlloc'. " -> IO Bool " __Returns:__ 'True' to stop iterating over cells. "

- GI.Gtk.Callbacks: type CellAllocCallback_WithClosures = CellRenderer /@renderer@/: the cell renderer to operate on -> Rectangle /@cellArea@/: the area allocated to /@renderer@/ inside the rectangle provided to 'GI.Gtk.Objects.CellArea.cellAreaForeachAlloc'. -> Rectangle /@cellBackground@/: the background area for /@renderer@/ inside the background area provided to 'GI.Gtk.Objects.CellArea.cellAreaForeachAlloc'. -> Ptr () /@data@/: user-supplied data -> IO Bool __Returns:__ 'True' to stop iterating over cells.

+ GI.Gtk.Callbacks: type CellAllocCallback_WithClosures = CellRenderer " /@renderer@/: the cell renderer to operate on " -> Rectangle " /@cellArea@/: the area allocated to /@renderer@/ inside the rectangle provided to 'GI.Gtk.Objects.CellArea.cellAreaForeachAlloc'. " -> Rectangle " /@cellBackground@/: the background area for /@renderer@/ inside the background area provided to 'GI.Gtk.Objects.CellArea.cellAreaForeachAlloc'. " -> Ptr () " /@data@/: user-supplied data " -> IO Bool " __Returns:__ 'True' to stop iterating over cells. "

- GI.Gtk.Callbacks: type CellCallback = CellRenderer /@renderer@/: the cell renderer to operate on -> IO Bool __Returns:__ 'True' to stop iterating over cells.

+ GI.Gtk.Callbacks: type CellCallback = CellRenderer " /@renderer@/: the cell renderer to operate on " -> IO Bool " __Returns:__ 'True' to stop iterating over cells. "

- GI.Gtk.Callbacks: type CellCallback_WithClosures = CellRenderer /@renderer@/: the cell renderer to operate on -> Ptr () /@data@/: user-supplied data -> IO Bool __Returns:__ 'True' to stop iterating over cells.

+ GI.Gtk.Callbacks: type CellCallback_WithClosures = CellRenderer " /@renderer@/: the cell renderer to operate on " -> Ptr () " /@data@/: user-supplied data " -> IO Bool " __Returns:__ 'True' to stop iterating over cells. "

- GI.Gtk.Callbacks: type CellLayoutDataFunc = CellLayout /@cellLayout@/: a 'GI.Gtk.Interfaces.CellLayout.CellLayout' -> CellRenderer /@cell@/: the cell renderer whose value is to be set -> TreeModel /@treeModel@/: the model -> TreeIter /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' indicating the row to set the value for -> IO ()

+ GI.Gtk.Callbacks: type CellLayoutDataFunc = CellLayout " /@cellLayout@/: a 'GI.Gtk.Interfaces.CellLayout.CellLayout' " -> CellRenderer " /@cell@/: the cell renderer whose value is to be set " -> TreeModel " /@treeModel@/: the model " -> TreeIter " /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' indicating the row to set the value for " -> IO ()

- GI.Gtk.Callbacks: type CellLayoutDataFunc_WithClosures = CellLayout /@cellLayout@/: a 'GI.Gtk.Interfaces.CellLayout.CellLayout' -> CellRenderer /@cell@/: the cell renderer whose value is to be set -> TreeModel /@treeModel@/: the model -> TreeIter /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' indicating the row to set the value for -> Ptr () /@data@/: user data passed to 'GI.Gtk.Interfaces.CellLayout.cellLayoutSetCellDataFunc' -> IO ()

+ GI.Gtk.Callbacks: type CellLayoutDataFunc_WithClosures = CellLayout " /@cellLayout@/: a 'GI.Gtk.Interfaces.CellLayout.CellLayout' " -> CellRenderer " /@cell@/: the cell renderer whose value is to be set " -> TreeModel " /@treeModel@/: the model " -> TreeIter " /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' indicating the row to set the value for " -> Ptr () " /@data@/: user data passed to 'GI.Gtk.Interfaces.CellLayout.cellLayoutSetCellDataFunc' " -> IO ()

- GI.Gtk.Callbacks: type ClipboardClearFunc = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' -> Ptr () /@userDataOrOwner@/: the /@userData@/ argument passed to @/gtk_clipboard_set_with_data()/@, or the /@owner@/ argument passed to @/gtk_clipboard_set_with_owner()/@ -> IO ()

+ GI.Gtk.Callbacks: type ClipboardClearFunc = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' " -> Ptr () " /@userDataOrOwner@/: the /@userData@/ argument passed to @/gtk_clipboard_set_with_data()/@, or the /@owner@/ argument passed to @/gtk_clipboard_set_with_owner()/@ " -> IO ()

- GI.Gtk.Callbacks: type ClipboardGetFunc = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' -> SelectionData /@selectionData@/: a 'GI.Gtk.Structs.SelectionData.SelectionData' argument in which the requested data should be stored. -> Word32 /@info@/: the info field corresponding to the requested target from the 'GI.Gtk.Structs.TargetEntry.TargetEntry' array passed to @/gtk_clipboard_set_with_data()/@ or @/gtk_clipboard_set_with_owner()/@. -> Ptr () /@userDataOrOwner@/: the /@userData@/ argument passed to @/gtk_clipboard_set_with_data()/@, or the /@owner@/ argument passed to @/gtk_clipboard_set_with_owner()/@ -> IO ()

+ GI.Gtk.Callbacks: type ClipboardGetFunc = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' " -> SelectionData " /@selectionData@/: a 'GI.Gtk.Structs.SelectionData.SelectionData' argument in which the requested data should be stored. " -> Word32 " /@info@/: the info field corresponding to the requested target from the 'GI.Gtk.Structs.TargetEntry.TargetEntry' array passed to @/gtk_clipboard_set_with_data()/@ or @/gtk_clipboard_set_with_owner()/@. " -> Ptr () " /@userDataOrOwner@/: the /@userData@/ argument passed to @/gtk_clipboard_set_with_data()/@, or the /@owner@/ argument passed to @/gtk_clipboard_set_with_owner()/@ " -> IO ()

- GI.Gtk.Callbacks: type ClipboardImageReceivedFunc = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' -> Pixbuf /@pixbuf@/: the received image -> IO ()

+ GI.Gtk.Callbacks: type ClipboardImageReceivedFunc = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' " -> Pixbuf " /@pixbuf@/: the received image " -> IO ()

- GI.Gtk.Callbacks: type ClipboardImageReceivedFunc_WithClosures = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' -> Pixbuf /@pixbuf@/: the received image -> Ptr () /@data@/: the /@userData@/ supplied to 'GI.Gtk.Objects.Clipboard.clipboardRequestImage'. -> IO ()

+ GI.Gtk.Callbacks: type ClipboardImageReceivedFunc_WithClosures = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' " -> Pixbuf " /@pixbuf@/: the received image " -> Ptr () " /@data@/: the /@userData@/ supplied to 'GI.Gtk.Objects.Clipboard.clipboardRequestImage'. " -> IO ()

- GI.Gtk.Callbacks: type ClipboardReceivedFunc = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' -> SelectionData /@selectionData@/: a 'GI.Gtk.Structs.SelectionData.SelectionData' containing the data was received. If retrieving the data failed, then then length field of /@selectionData@/ will be negative. -> IO ()

+ GI.Gtk.Callbacks: type ClipboardReceivedFunc = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' " -> SelectionData " /@selectionData@/: a 'GI.Gtk.Structs.SelectionData.SelectionData' containing the data was received. If retrieving the data failed, then then length field of /@selectionData@/ will be negative. " -> IO ()

- GI.Gtk.Callbacks: type ClipboardReceivedFunc_WithClosures = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' -> SelectionData /@selectionData@/: a 'GI.Gtk.Structs.SelectionData.SelectionData' containing the data was received. If retrieving the data failed, then then length field of /@selectionData@/ will be negative. -> Ptr () /@data@/: the /@userData@/ supplied to 'GI.Gtk.Objects.Clipboard.clipboardRequestContents'. -> IO ()

+ GI.Gtk.Callbacks: type ClipboardReceivedFunc_WithClosures = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' " -> SelectionData " /@selectionData@/: a 'GI.Gtk.Structs.SelectionData.SelectionData' containing the data was received. If retrieving the data failed, then then length field of /@selectionData@/ will be negative. " -> Ptr () " /@data@/: the /@userData@/ supplied to 'GI.Gtk.Objects.Clipboard.clipboardRequestContents'. " -> IO ()

- GI.Gtk.Callbacks: type ClipboardRichTextReceivedFunc = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' -> Atom /@format@/: The format of the rich text -> Maybe Text /@text@/: the rich text received, as a UTF-8 encoded string, or 'Nothing' if retrieving the data failed. -> Word64 /@length@/: Length of the text. -> IO ()

+ GI.Gtk.Callbacks: type ClipboardRichTextReceivedFunc = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' " -> Atom " /@format@/: The format of the rich text " -> Maybe Text " /@text@/: the rich text received, as a UTF-8 encoded string, or 'Nothing' if retrieving the data failed. " -> Word64 " /@length@/: Length of the text. " -> IO ()

- GI.Gtk.Callbacks: type ClipboardRichTextReceivedFunc_WithClosures = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' -> Atom /@format@/: The format of the rich text -> Maybe Text /@text@/: the rich text received, as a UTF-8 encoded string, or 'Nothing' if retrieving the data failed. -> Word64 /@length@/: Length of the text. -> Ptr () /@data@/: the /@userData@/ supplied to 'GI.Gtk.Objects.Clipboard.clipboardRequestRichText'. -> IO ()

+ GI.Gtk.Callbacks: type ClipboardRichTextReceivedFunc_WithClosures = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' " -> Atom " /@format@/: The format of the rich text " -> Maybe Text " /@text@/: the rich text received, as a UTF-8 encoded string, or 'Nothing' if retrieving the data failed. " -> Word64 " /@length@/: Length of the text. " -> Ptr () " /@data@/: the /@userData@/ supplied to 'GI.Gtk.Objects.Clipboard.clipboardRequestRichText'. " -> IO ()

- GI.Gtk.Callbacks: type ClipboardTargetsReceivedFunc = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' -> Maybe [Atom] /@atoms@/: the supported targets, as array of 'GI.Gdk.Structs.Atom.Atom', or 'Nothing' if retrieving the data failed. -> IO ()

+ GI.Gtk.Callbacks: type ClipboardTargetsReceivedFunc = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' " -> Maybe [Atom] " /@atoms@/: the supported targets, as array of 'GI.Gdk.Structs.Atom.Atom', or 'Nothing' if retrieving the data failed. " -> IO ()

- GI.Gtk.Callbacks: type ClipboardTargetsReceivedFunc_WithClosures = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' -> Maybe [Atom] /@atoms@/: the supported targets, as array of 'GI.Gdk.Structs.Atom.Atom', or 'Nothing' if retrieving the data failed. -> Ptr () /@data@/: the /@userData@/ supplied to 'GI.Gtk.Objects.Clipboard.clipboardRequestTargets'. -> IO ()

+ GI.Gtk.Callbacks: type ClipboardTargetsReceivedFunc_WithClosures = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' " -> Maybe [Atom] " /@atoms@/: the supported targets, as array of 'GI.Gdk.Structs.Atom.Atom', or 'Nothing' if retrieving the data failed. " -> Ptr () " /@data@/: the /@userData@/ supplied to 'GI.Gtk.Objects.Clipboard.clipboardRequestTargets'. " -> IO ()

- GI.Gtk.Callbacks: type ClipboardTextReceivedFunc = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' -> Maybe Text /@text@/: the text received, as a UTF-8 encoded string, or 'Nothing' if retrieving the data failed. -> IO ()

+ GI.Gtk.Callbacks: type ClipboardTextReceivedFunc = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' " -> Maybe Text " /@text@/: the text received, as a UTF-8 encoded string, or 'Nothing' if retrieving the data failed. " -> IO ()

- GI.Gtk.Callbacks: type ClipboardTextReceivedFunc_WithClosures = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' -> Maybe Text /@text@/: the text received, as a UTF-8 encoded string, or 'Nothing' if retrieving the data failed. -> Ptr () /@data@/: the /@userData@/ supplied to 'GI.Gtk.Objects.Clipboard.clipboardRequestText'. -> IO ()

+ GI.Gtk.Callbacks: type ClipboardTextReceivedFunc_WithClosures = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' " -> Maybe Text " /@text@/: the text received, as a UTF-8 encoded string, or 'Nothing' if retrieving the data failed. " -> Ptr () " /@data@/: the /@userData@/ supplied to 'GI.Gtk.Objects.Clipboard.clipboardRequestText'. " -> IO ()

- GI.Gtk.Callbacks: type ClipboardURIReceivedFunc = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' -> [Text] /@uris@/: the received URIs -> IO ()

+ GI.Gtk.Callbacks: type ClipboardURIReceivedFunc = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' " -> [Text] " /@uris@/: the received URIs " -> IO ()

- GI.Gtk.Callbacks: type ClipboardURIReceivedFunc_WithClosures = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' -> [Text] /@uris@/: the received URIs -> Ptr () /@data@/: the /@userData@/ supplied to 'GI.Gtk.Objects.Clipboard.clipboardRequestUris'. -> IO ()

+ GI.Gtk.Callbacks: type ClipboardURIReceivedFunc_WithClosures = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' " -> [Text] " /@uris@/: the received URIs " -> Ptr () " /@data@/: the /@userData@/ supplied to 'GI.Gtk.Objects.Clipboard.clipboardRequestUris'. " -> IO ()

- GI.Gtk.Callbacks: type ColorSelectionChangePaletteFunc = [Color] /@colors@/: Array of colors -> IO ()

+ GI.Gtk.Callbacks: type ColorSelectionChangePaletteFunc = [Color] " /@colors@/: Array of colors " -> IO ()

- GI.Gtk.Callbacks: type ColorSelectionChangePaletteWithScreenFunc = Screen -> [Color] /@colors@/: Array of colors -> IO ()

+ GI.Gtk.Callbacks: type ColorSelectionChangePaletteWithScreenFunc = Screen -> [Color] " /@colors@/: Array of colors " -> IO ()

- GI.Gtk.Callbacks: type EntryCompletionMatchFunc = EntryCompletion /@completion@/: the 'GI.Gtk.Objects.EntryCompletion.EntryCompletion' -> Text /@key@/: the string to match, normalized and case-folded -> TreeIter /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' indicating the row to match -> IO Bool __Returns:__ 'True' if /@iter@/ should be displayed as a possible completion for /@key@/

+ GI.Gtk.Callbacks: type EntryCompletionMatchFunc = EntryCompletion " /@completion@/: the 'GI.Gtk.Objects.EntryCompletion.EntryCompletion' " -> Text " /@key@/: the string to match, normalized and case-folded " -> TreeIter " /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' indicating the row to match " -> IO Bool " __Returns:__ 'True' if /@iter@/ should be displayed as a possible completion for /@key@/ "

- GI.Gtk.Callbacks: type EntryCompletionMatchFunc_WithClosures = EntryCompletion /@completion@/: the 'GI.Gtk.Objects.EntryCompletion.EntryCompletion' -> Text /@key@/: the string to match, normalized and case-folded -> TreeIter /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' indicating the row to match -> Ptr () /@userData@/: user data given to 'GI.Gtk.Objects.EntryCompletion.entryCompletionSetMatchFunc' -> IO Bool __Returns:__ 'True' if /@iter@/ should be displayed as a possible completion for /@key@/

+ GI.Gtk.Callbacks: type EntryCompletionMatchFunc_WithClosures = EntryCompletion " /@completion@/: the 'GI.Gtk.Objects.EntryCompletion.EntryCompletion' " -> Text " /@key@/: the string to match, normalized and case-folded " -> TreeIter " /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' indicating the row to match " -> Ptr () " /@userData@/: user data given to 'GI.Gtk.Objects.EntryCompletion.entryCompletionSetMatchFunc' " -> IO Bool " __Returns:__ 'True' if /@iter@/ should be displayed as a possible completion for /@key@/ "

- GI.Gtk.Callbacks: type FileFilterFunc = FileFilterInfo /@filterInfo@/: a 'GI.Gtk.Structs.FileFilterInfo.FileFilterInfo' that is filled according to the /@needed@/ flags passed to 'GI.Gtk.Objects.FileFilter.fileFilterAddCustom' -> IO Bool __Returns:__ 'True' if the file should be displayed

+ GI.Gtk.Callbacks: type FileFilterFunc = FileFilterInfo " /@filterInfo@/: a 'GI.Gtk.Structs.FileFilterInfo.FileFilterInfo' that is filled according to the /@needed@/ flags passed to 'GI.Gtk.Objects.FileFilter.fileFilterAddCustom' " -> IO Bool " __Returns:__ 'True' if the file should be displayed "

- GI.Gtk.Callbacks: type FileFilterFunc_WithClosures = FileFilterInfo /@filterInfo@/: a 'GI.Gtk.Structs.FileFilterInfo.FileFilterInfo' that is filled according to the /@needed@/ flags passed to 'GI.Gtk.Objects.FileFilter.fileFilterAddCustom' -> Ptr () /@data@/: user data passed to 'GI.Gtk.Objects.FileFilter.fileFilterAddCustom' -> IO Bool __Returns:__ 'True' if the file should be displayed

+ GI.Gtk.Callbacks: type FileFilterFunc_WithClosures = FileFilterInfo " /@filterInfo@/: a 'GI.Gtk.Structs.FileFilterInfo.FileFilterInfo' that is filled according to the /@needed@/ flags passed to 'GI.Gtk.Objects.FileFilter.fileFilterAddCustom' " -> Ptr () " /@data@/: user data passed to 'GI.Gtk.Objects.FileFilter.fileFilterAddCustom' " -> IO Bool " __Returns:__ 'True' if the file should be displayed "

- GI.Gtk.Callbacks: type FlowBoxCreateWidgetFunc = Maybe Object /@item@/: the item from the model for which to create a widget for -> IO Widget __Returns:__ a 'GI.Gtk.Objects.Widget.Widget' that represents /@item@/

+ GI.Gtk.Callbacks: type FlowBoxCreateWidgetFunc = Maybe Object " /@item@/: the item from the model for which to create a widget for " -> IO Widget " __Returns:__ a 'GI.Gtk.Objects.Widget.Widget' that represents /@item@/ "

- GI.Gtk.Callbacks: type FlowBoxCreateWidgetFunc_WithClosures = Maybe Object /@item@/: the item from the model for which to create a widget for -> Ptr () /@userData@/: user data from 'GI.Gtk.Objects.FlowBox.flowBoxBindModel' -> IO Widget __Returns:__ a 'GI.Gtk.Objects.Widget.Widget' that represents /@item@/

+ GI.Gtk.Callbacks: type FlowBoxCreateWidgetFunc_WithClosures = Maybe Object " /@item@/: the item from the model for which to create a widget for " -> Ptr () " /@userData@/: user data from 'GI.Gtk.Objects.FlowBox.flowBoxBindModel' " -> IO Widget " __Returns:__ a 'GI.Gtk.Objects.Widget.Widget' that represents /@item@/ "

- GI.Gtk.Callbacks: type FlowBoxFilterFunc = FlowBoxChild /@child@/: a 'GI.Gtk.Objects.FlowBoxChild.FlowBoxChild' that may be filtered -> IO Bool __Returns:__ 'True' if the row should be visible, 'False' otherwise

+ GI.Gtk.Callbacks: type FlowBoxFilterFunc = FlowBoxChild " /@child@/: a 'GI.Gtk.Objects.FlowBoxChild.FlowBoxChild' that may be filtered " -> IO Bool " __Returns:__ 'True' if the row should be visible, 'False' otherwise "

- GI.Gtk.Callbacks: type FlowBoxFilterFunc_WithClosures = FlowBoxChild /@child@/: a 'GI.Gtk.Objects.FlowBoxChild.FlowBoxChild' that may be filtered -> Ptr () /@userData@/: user data -> IO Bool __Returns:__ 'True' if the row should be visible, 'False' otherwise

+ GI.Gtk.Callbacks: type FlowBoxFilterFunc_WithClosures = FlowBoxChild " /@child@/: a 'GI.Gtk.Objects.FlowBoxChild.FlowBoxChild' that may be filtered " -> Ptr () " /@userData@/: user data " -> IO Bool " __Returns:__ 'True' if the row should be visible, 'False' otherwise "

- GI.Gtk.Callbacks: type FlowBoxForeachFunc = FlowBox /@box@/: a 'GI.Gtk.Objects.FlowBox.FlowBox' -> FlowBoxChild /@child@/: a 'GI.Gtk.Objects.FlowBoxChild.FlowBoxChild' -> IO ()

+ GI.Gtk.Callbacks: type FlowBoxForeachFunc = FlowBox " /@box@/: a 'GI.Gtk.Objects.FlowBox.FlowBox' " -> FlowBoxChild " /@child@/: a 'GI.Gtk.Objects.FlowBoxChild.FlowBoxChild' " -> IO ()

- GI.Gtk.Callbacks: type FlowBoxForeachFunc_WithClosures = FlowBox /@box@/: a 'GI.Gtk.Objects.FlowBox.FlowBox' -> FlowBoxChild /@child@/: a 'GI.Gtk.Objects.FlowBoxChild.FlowBoxChild' -> Ptr () /@userData@/: user data -> IO ()

+ GI.Gtk.Callbacks: type FlowBoxForeachFunc_WithClosures = FlowBox " /@box@/: a 'GI.Gtk.Objects.FlowBox.FlowBox' " -> FlowBoxChild " /@child@/: a 'GI.Gtk.Objects.FlowBoxChild.FlowBoxChild' " -> Ptr () " /@userData@/: user data " -> IO ()

- GI.Gtk.Callbacks: type FlowBoxSortFunc = FlowBoxChild /@child1@/: the first child -> FlowBoxChild /@child2@/: the second child -> IO Int32 __Returns:__ \< 0 if /@child1@/ should be before /@child2@/, 0 if the are equal, and > 0 otherwise

+ GI.Gtk.Callbacks: type FlowBoxSortFunc = FlowBoxChild " /@child1@/: the first child " -> FlowBoxChild " /@child2@/: the second child " -> IO Int32 " __Returns:__ \< 0 if /@child1@/ should be before /@child2@/, 0 if the are equal, and > 0 otherwise "

- GI.Gtk.Callbacks: type FlowBoxSortFunc_WithClosures = FlowBoxChild /@child1@/: the first child -> FlowBoxChild /@child2@/: the second child -> Ptr () /@userData@/: user data -> IO Int32 __Returns:__ \< 0 if /@child1@/ should be before /@child2@/, 0 if the are equal, and > 0 otherwise

+ GI.Gtk.Callbacks: type FlowBoxSortFunc_WithClosures = FlowBoxChild " /@child1@/: the first child " -> FlowBoxChild " /@child2@/: the second child " -> Ptr () " /@userData@/: user data " -> IO Int32 " __Returns:__ \< 0 if /@child1@/ should be before /@child2@/, 0 if the are equal, and > 0 otherwise "

- GI.Gtk.Callbacks: type FontFilterFunc = FontFamily /@family@/: a 'GI.Pango.Objects.FontFamily.FontFamily' -> FontFace /@face@/: a 'GI.Pango.Objects.FontFace.FontFace' belonging to /@family@/ -> IO Bool __Returns:__ 'True' if the font should be displayed

+ GI.Gtk.Callbacks: type FontFilterFunc = FontFamily " /@family@/: a 'GI.Pango.Objects.FontFamily.FontFamily' " -> FontFace " /@face@/: a 'GI.Pango.Objects.FontFace.FontFace' belonging to /@family@/ " -> IO Bool " __Returns:__ 'True' if the font should be displayed "

- GI.Gtk.Callbacks: type FontFilterFunc_WithClosures = FontFamily /@family@/: a 'GI.Pango.Objects.FontFamily.FontFamily' -> FontFace /@face@/: a 'GI.Pango.Objects.FontFace.FontFace' belonging to /@family@/ -> Ptr () /@data@/: user data passed to 'GI.Gtk.Interfaces.FontChooser.fontChooserSetFilterFunc' -> IO Bool __Returns:__ 'True' if the font should be displayed

+ GI.Gtk.Callbacks: type FontFilterFunc_WithClosures = FontFamily " /@family@/: a 'GI.Pango.Objects.FontFamily.FontFamily' " -> FontFace " /@face@/: a 'GI.Pango.Objects.FontFace.FontFace' belonging to /@family@/ " -> Ptr () " /@data@/: user data passed to 'GI.Gtk.Interfaces.FontChooser.fontChooserSetFilterFunc' " -> IO Bool " __Returns:__ 'True' if the font should be displayed "

- GI.Gtk.Callbacks: type IconViewForeachFunc = IconView /@iconView@/: a 'GI.Gtk.Objects.IconView.IconView' -> TreePath /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' of a selected row -> IO ()

+ GI.Gtk.Callbacks: type IconViewForeachFunc = IconView " /@iconView@/: a 'GI.Gtk.Objects.IconView.IconView' " -> TreePath " /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' of a selected row " -> IO ()

- GI.Gtk.Callbacks: type IconViewForeachFunc_WithClosures = IconView /@iconView@/: a 'GI.Gtk.Objects.IconView.IconView' -> TreePath /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' of a selected row -> Ptr () /@data@/: user data -> IO ()

+ GI.Gtk.Callbacks: type IconViewForeachFunc_WithClosures = IconView " /@iconView@/: a 'GI.Gtk.Objects.IconView.IconView' " -> TreePath " /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' of a selected row " -> Ptr () " /@data@/: user data " -> IO ()

- GI.Gtk.Callbacks: type KeySnoopFunc = Widget /@grabWidget@/: the widget to which the event will be delivered -> EventKey /@event@/: the key event -> IO Int32 __Returns:__ 'True' to stop further processing of /@event@/, 'False' to continue.

+ GI.Gtk.Callbacks: type KeySnoopFunc = Widget " /@grabWidget@/: the widget to which the event will be delivered " -> EventKey " /@event@/: the key event " -> IO Int32 " __Returns:__ 'True' to stop further processing of /@event@/, 'False' to continue. "

- GI.Gtk.Callbacks: type KeySnoopFunc_WithClosures = Widget /@grabWidget@/: the widget to which the event will be delivered -> EventKey /@event@/: the key event -> Ptr () /@funcData@/: data supplied to @/gtk_key_snooper_install()/@ -> IO Int32 __Returns:__ 'True' to stop further processing of /@event@/, 'False' to continue.

+ GI.Gtk.Callbacks: type KeySnoopFunc_WithClosures = Widget " /@grabWidget@/: the widget to which the event will be delivered " -> EventKey " /@event@/: the key event " -> Ptr () " /@funcData@/: data supplied to @/gtk_key_snooper_install()/@ " -> IO Int32 " __Returns:__ 'True' to stop further processing of /@event@/, 'False' to continue. "

- GI.Gtk.Callbacks: type ListBoxCreateWidgetFunc = Object /@item@/: the item from the model for which to create a widget for -> IO Widget __Returns:__ a 'GI.Gtk.Objects.Widget.Widget' that represents /@item@/

+ GI.Gtk.Callbacks: type ListBoxCreateWidgetFunc = Object " /@item@/: the item from the model for which to create a widget for " -> IO Widget " __Returns:__ a 'GI.Gtk.Objects.Widget.Widget' that represents /@item@/ "

- GI.Gtk.Callbacks: type ListBoxCreateWidgetFunc_WithClosures = Object /@item@/: the item from the model for which to create a widget for -> Ptr () /@userData@/: user data -> IO Widget __Returns:__ a 'GI.Gtk.Objects.Widget.Widget' that represents /@item@/

+ GI.Gtk.Callbacks: type ListBoxCreateWidgetFunc_WithClosures = Object " /@item@/: the item from the model for which to create a widget for " -> Ptr () " /@userData@/: user data " -> IO Widget " __Returns:__ a 'GI.Gtk.Objects.Widget.Widget' that represents /@item@/ "

- GI.Gtk.Callbacks: type ListBoxFilterFunc = ListBoxRow /@row@/: the row that may be filtered -> IO Bool __Returns:__ 'True' if the row should be visible, 'False' otherwise

+ GI.Gtk.Callbacks: type ListBoxFilterFunc = ListBoxRow " /@row@/: the row that may be filtered " -> IO Bool " __Returns:__ 'True' if the row should be visible, 'False' otherwise "

- GI.Gtk.Callbacks: type ListBoxFilterFunc_WithClosures = ListBoxRow /@row@/: the row that may be filtered -> Ptr () /@userData@/: user data -> IO Bool __Returns:__ 'True' if the row should be visible, 'False' otherwise

+ GI.Gtk.Callbacks: type ListBoxFilterFunc_WithClosures = ListBoxRow " /@row@/: the row that may be filtered " -> Ptr () " /@userData@/: user data " -> IO Bool " __Returns:__ 'True' if the row should be visible, 'False' otherwise "

- GI.Gtk.Callbacks: type ListBoxForeachFunc = ListBox /@box@/: a 'GI.Gtk.Objects.ListBox.ListBox' -> ListBoxRow /@row@/: a 'GI.Gtk.Objects.ListBoxRow.ListBoxRow' -> IO ()

+ GI.Gtk.Callbacks: type ListBoxForeachFunc = ListBox " /@box@/: a 'GI.Gtk.Objects.ListBox.ListBox' " -> ListBoxRow " /@row@/: a 'GI.Gtk.Objects.ListBoxRow.ListBoxRow' " -> IO ()

- GI.Gtk.Callbacks: type ListBoxForeachFunc_WithClosures = ListBox /@box@/: a 'GI.Gtk.Objects.ListBox.ListBox' -> ListBoxRow /@row@/: a 'GI.Gtk.Objects.ListBoxRow.ListBoxRow' -> Ptr () /@userData@/: user data -> IO ()

+ GI.Gtk.Callbacks: type ListBoxForeachFunc_WithClosures = ListBox " /@box@/: a 'GI.Gtk.Objects.ListBox.ListBox' " -> ListBoxRow " /@row@/: a 'GI.Gtk.Objects.ListBoxRow.ListBoxRow' " -> Ptr () " /@userData@/: user data " -> IO ()

- GI.Gtk.Callbacks: type ListBoxSortFunc = ListBoxRow /@row1@/: the first row -> ListBoxRow /@row2@/: the second row -> IO Int32 __Returns:__ \< 0 if /@row1@/ should be before /@row2@/, 0 if they are equal and > 0 otherwise

+ GI.Gtk.Callbacks: type ListBoxSortFunc = ListBoxRow " /@row1@/: the first row " -> ListBoxRow " /@row2@/: the second row " -> IO Int32 " __Returns:__ \< 0 if /@row1@/ should be before /@row2@/, 0 if they are equal and > 0 otherwise "

- GI.Gtk.Callbacks: type ListBoxSortFunc_WithClosures = ListBoxRow /@row1@/: the first row -> ListBoxRow /@row2@/: the second row -> Ptr () /@userData@/: user data -> IO Int32 __Returns:__ \< 0 if /@row1@/ should be before /@row2@/, 0 if they are equal and > 0 otherwise

+ GI.Gtk.Callbacks: type ListBoxSortFunc_WithClosures = ListBoxRow " /@row1@/: the first row " -> ListBoxRow " /@row2@/: the second row " -> Ptr () " /@userData@/: user data " -> IO Int32 " __Returns:__ \< 0 if /@row1@/ should be before /@row2@/, 0 if they are equal and > 0 otherwise "

- GI.Gtk.Callbacks: type ListBoxUpdateHeaderFunc = ListBoxRow /@row@/: the row to update -> Maybe ListBoxRow /@before@/: the row before /@row@/, or 'Nothing' if it is first -> IO ()

+ GI.Gtk.Callbacks: type ListBoxUpdateHeaderFunc = ListBoxRow " /@row@/: the row to update " -> Maybe ListBoxRow " /@before@/: the row before /@row@/, or 'Nothing' if it is first " -> IO ()

- GI.Gtk.Callbacks: type ListBoxUpdateHeaderFunc_WithClosures = ListBoxRow /@row@/: the row to update -> Maybe ListBoxRow /@before@/: the row before /@row@/, or 'Nothing' if it is first -> Ptr () /@userData@/: user data -> IO ()

+ GI.Gtk.Callbacks: type ListBoxUpdateHeaderFunc_WithClosures = ListBoxRow " /@row@/: the row to update " -> Maybe ListBoxRow " /@before@/: the row before /@row@/, or 'Nothing' if it is first " -> Ptr () " /@userData@/: user data " -> IO ()

- GI.Gtk.Callbacks: type MenuDetachFunc = Widget /@attachWidget@/: the 'GI.Gtk.Objects.Widget.Widget' that the menu is being detached from. -> Menu /@menu@/: the 'GI.Gtk.Objects.Menu.Menu' being detached. -> IO ()

+ GI.Gtk.Callbacks: type MenuDetachFunc = Widget " /@attachWidget@/: the 'GI.Gtk.Objects.Widget.Widget' that the menu is being detached from. " -> Menu " /@menu@/: the 'GI.Gtk.Objects.Menu.Menu' being detached. " -> IO ()

- GI.Gtk.Callbacks: type MenuPositionFunc = Menu /@menu@/: a 'GI.Gtk.Objects.Menu.Menu'. -> Int32 /@x@/: address of the @/gint/@ representing the horizontal position where the menu shall be drawn. -> Int32 /@y@/: address of the @/gint/@ representing the vertical position where the menu shall be drawn. This is an output parameter. -> IO ((Int32, Int32, Bool))

+ GI.Gtk.Callbacks: type MenuPositionFunc = Menu " /@menu@/: a 'GI.Gtk.Objects.Menu.Menu'. " -> Int32 " /@x@/: address of the @/gint/@ representing the horizontal position where the menu shall be drawn. " -> Int32 " /@y@/: address of the @/gint/@ representing the vertical position where the menu shall be drawn. This is an output parameter. " -> IO ((Int32, Int32, Bool))

- GI.Gtk.Callbacks: type MenuPositionFunc_WithClosures = Menu /@menu@/: a 'GI.Gtk.Objects.Menu.Menu'. -> Int32 /@x@/: address of the @/gint/@ representing the horizontal position where the menu shall be drawn. -> Int32 /@y@/: address of the @/gint/@ representing the vertical position where the menu shall be drawn. This is an output parameter. -> Ptr () /@userData@/: the data supplied by the user in the 'GI.Gtk.Objects.Menu.menuPopup' /@data@/ parameter. -> IO ((Int32, Int32, Bool))

+ GI.Gtk.Callbacks: type MenuPositionFunc_WithClosures = Menu " /@menu@/: a 'GI.Gtk.Objects.Menu.Menu'. " -> Int32 " /@x@/: address of the @/gint/@ representing the horizontal position where the menu shall be drawn. " -> Int32 " /@y@/: address of the @/gint/@ representing the vertical position where the menu shall be drawn. This is an output parameter. " -> Ptr () " /@userData@/: the data supplied by the user in the 'GI.Gtk.Objects.Menu.menuPopup' /@data@/ parameter. " -> IO ((Int32, Int32, Bool))

- GI.Gtk.Callbacks: type ModuleDisplayInitFunc = Display /@display@/: an open 'GI.Gdk.Objects.Display.Display' -> IO ()

+ GI.Gtk.Callbacks: type ModuleDisplayInitFunc = Display " /@display@/: an open 'GI.Gdk.Objects.Display.Display' " -> IO ()

- GI.Gtk.Callbacks: type ModuleInitFunc = Maybe [Text] /@argv@/: GTK+ always passes 'Nothing' for this argument -> IO ()

+ GI.Gtk.Callbacks: type ModuleInitFunc = Maybe [Text] " /@argv@/: GTK+ always passes 'Nothing' for this argument " -> IO ()

- GI.Gtk.Callbacks: type PageSetupDoneFunc = PageSetup /@pageSetup@/: the 'GI.Gtk.Objects.PageSetup.PageSetup' that has been -> IO ()

+ GI.Gtk.Callbacks: type PageSetupDoneFunc = PageSetup " /@pageSetup@/: the 'GI.Gtk.Objects.PageSetup.PageSetup' that has been " -> IO ()

- GI.Gtk.Callbacks: type PageSetupDoneFunc_WithClosures = PageSetup /@pageSetup@/: the 'GI.Gtk.Objects.PageSetup.PageSetup' that has been -> Ptr () /@data@/: user data that has been passed to 'GI.Gtk.Functions.printRunPageSetupDialogAsync' -> IO ()

+ GI.Gtk.Callbacks: type PageSetupDoneFunc_WithClosures = PageSetup " /@pageSetup@/: the 'GI.Gtk.Objects.PageSetup.PageSetup' that has been " -> Ptr () " /@data@/: user data that has been passed to 'GI.Gtk.Functions.printRunPageSetupDialogAsync' " -> IO ()

- GI.Gtk.Callbacks: type RecentFilterFunc = RecentFilterInfo /@filterInfo@/: a 'GI.Gtk.Structs.RecentFilterInfo.RecentFilterInfo' that is filled according to the /@needed@/ flags passed to 'GI.Gtk.Objects.RecentFilter.recentFilterAddCustom' -> IO Bool __Returns:__ 'True' if the file should be displayed

+ GI.Gtk.Callbacks: type RecentFilterFunc = RecentFilterInfo " /@filterInfo@/: a 'GI.Gtk.Structs.RecentFilterInfo.RecentFilterInfo' that is filled according to the /@needed@/ flags passed to 'GI.Gtk.Objects.RecentFilter.recentFilterAddCustom' " -> IO Bool " __Returns:__ 'True' if the file should be displayed "

- GI.Gtk.Callbacks: type RecentFilterFunc_WithClosures = RecentFilterInfo /@filterInfo@/: a 'GI.Gtk.Structs.RecentFilterInfo.RecentFilterInfo' that is filled according to the /@needed@/ flags passed to 'GI.Gtk.Objects.RecentFilter.recentFilterAddCustom' -> Ptr () /@userData@/: user data passed to 'GI.Gtk.Objects.RecentFilter.recentFilterAddCustom' -> IO Bool __Returns:__ 'True' if the file should be displayed

+ GI.Gtk.Callbacks: type RecentFilterFunc_WithClosures = RecentFilterInfo " /@filterInfo@/: a 'GI.Gtk.Structs.RecentFilterInfo.RecentFilterInfo' that is filled according to the /@needed@/ flags passed to 'GI.Gtk.Objects.RecentFilter.recentFilterAddCustom' " -> Ptr () " /@userData@/: user data passed to 'GI.Gtk.Objects.RecentFilter.recentFilterAddCustom' " -> IO Bool " __Returns:__ 'True' if the file should be displayed "

- GI.Gtk.Callbacks: type StylePropertyParser = Text -> GValue -> IO () /(Can throw 'Data.GI.Base.GError.GError')/

+ GI.Gtk.Callbacks: type StylePropertyParser = Text -> GValue -> IO () " /(Can throw 'Data.GI.Base.GError.GError')/ "

- GI.Gtk.Callbacks: type TextBufferDeserializeFunc = TextBuffer /@registerBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' the format is registered with -> TextBuffer /@contentBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' to deserialize into -> TextIter /@iter@/: insertion point for the deserialized text -> ByteString /@data@/: data to deserialize -> Bool /@createTags@/: 'True' if deserializing may create tags -> IO () __Returns:__ 'True' on success, 'False' otherwise /(Can throw 'Data.GI.Base.GError.GError')/

+ GI.Gtk.Callbacks: type TextBufferDeserializeFunc = TextBuffer " /@registerBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' the format is registered with " -> TextBuffer " /@contentBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' to deserialize into " -> TextIter " /@iter@/: insertion point for the deserialized text " -> ByteString " /@data@/: data to deserialize " -> Bool " /@createTags@/: 'True' if deserializing may create tags " -> IO () " __Returns:__ 'True' on success, 'False' otherwise /(Can throw 'Data.GI.Base.GError.GError')/ "

- GI.Gtk.Callbacks: type TextBufferDeserializeFunc_WithClosures = TextBuffer /@registerBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' the format is registered with -> TextBuffer /@contentBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' to deserialize into -> TextIter /@iter@/: insertion point for the deserialized text -> ByteString /@data@/: data to deserialize -> Bool /@createTags@/: 'True' if deserializing may create tags -> Ptr () /@userData@/: user data that was specified when registering the format -> IO () __Returns:__ 'True' on success, 'False' otherwise /(Can throw 'Data.GI.Base.GError.GError')/

+ GI.Gtk.Callbacks: type TextBufferDeserializeFunc_WithClosures = TextBuffer " /@registerBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' the format is registered with " -> TextBuffer " /@contentBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' to deserialize into " -> TextIter " /@iter@/: insertion point for the deserialized text " -> ByteString " /@data@/: data to deserialize " -> Bool " /@createTags@/: 'True' if deserializing may create tags " -> Ptr () " /@userData@/: user data that was specified when registering the format " -> IO () " __Returns:__ 'True' on success, 'False' otherwise /(Can throw 'Data.GI.Base.GError.GError')/ "

- GI.Gtk.Callbacks: type TextBufferSerializeFunc = TextBuffer /@registerBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' for which the format is registered -> TextBuffer /@contentBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' to serialize -> TextIter /@start@/: start of the block of text to serialize -> TextIter /@end@/: end of the block of text to serialize -> Word64 /@length@/: Return location for the length of the serialized data -> IO Word8 __Returns:__ a newly-allocated array of guint8 which contains the serialized data, or 'Nothing' if an error occurred

+ GI.Gtk.Callbacks: type TextBufferSerializeFunc = TextBuffer " /@registerBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' for which the format is registered " -> TextBuffer " /@contentBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' to serialize " -> TextIter " /@start@/: start of the block of text to serialize " -> TextIter " /@end@/: end of the block of text to serialize " -> Word64 " /@length@/: Return location for the length of the serialized data " -> IO Word8 " __Returns:__ a newly-allocated array of guint8 which contains the serialized data, or 'Nothing' if an error occurred "

- GI.Gtk.Callbacks: type TextBufferSerializeFunc_WithClosures = TextBuffer /@registerBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' for which the format is registered -> TextBuffer /@contentBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' to serialize -> TextIter /@start@/: start of the block of text to serialize -> TextIter /@end@/: end of the block of text to serialize -> Word64 /@length@/: Return location for the length of the serialized data -> Ptr () /@userData@/: user data that was specified when registering the format -> IO Word8 __Returns:__ a newly-allocated array of guint8 which contains the serialized data, or 'Nothing' if an error occurred

+ GI.Gtk.Callbacks: type TextBufferSerializeFunc_WithClosures = TextBuffer " /@registerBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' for which the format is registered " -> TextBuffer " /@contentBuffer@/: the 'GI.Gtk.Objects.TextBuffer.TextBuffer' to serialize " -> TextIter " /@start@/: start of the block of text to serialize " -> TextIter " /@end@/: end of the block of text to serialize " -> Word64 " /@length@/: Return location for the length of the serialized data " -> Ptr () " /@userData@/: user data that was specified when registering the format " -> IO Word8 " __Returns:__ a newly-allocated array of guint8 which contains the serialized data, or 'Nothing' if an error occurred "

- GI.Gtk.Callbacks: type TextTagTableForeach = TextTag /@tag@/: the 'GI.Gtk.Objects.TextTag.TextTag' -> IO ()

+ GI.Gtk.Callbacks: type TextTagTableForeach = TextTag " /@tag@/: the 'GI.Gtk.Objects.TextTag.TextTag' " -> IO ()

- GI.Gtk.Callbacks: type TextTagTableForeach_WithClosures = TextTag /@tag@/: the 'GI.Gtk.Objects.TextTag.TextTag' -> Ptr () /@data@/: data passed to 'GI.Gtk.Objects.TextTagTable.textTagTableForeach' -> IO ()

+ GI.Gtk.Callbacks: type TextTagTableForeach_WithClosures = TextTag " /@tag@/: the 'GI.Gtk.Objects.TextTag.TextTag' " -> Ptr () " /@data@/: data passed to 'GI.Gtk.Objects.TextTagTable.textTagTableForeach' " -> IO ()

- GI.Gtk.Callbacks: type TickCallback = Widget /@widget@/: the widget -> FrameClock /@frameClock@/: the frame clock for the widget (same as calling 'GI.Gtk.Objects.Widget.widgetGetFrameClock') -> IO Bool __Returns:__ 'GI.GLib.Constants.SOURCE_CONTINUE' if the tick callback should continue to be called, 'GI.GLib.Constants.SOURCE_REMOVE' if the tick callback should be removed.

+ GI.Gtk.Callbacks: type TickCallback = Widget " /@widget@/: the widget " -> FrameClock " /@frameClock@/: the frame clock for the widget (same as calling 'GI.Gtk.Objects.Widget.widgetGetFrameClock') " -> IO Bool " __Returns:__ 'GI.GLib.Constants.SOURCE_CONTINUE' if the tick callback should continue to be called, 'GI.GLib.Constants.SOURCE_REMOVE' if the tick callback should be removed. "

- GI.Gtk.Callbacks: type TickCallback_WithClosures = Widget /@widget@/: the widget -> FrameClock /@frameClock@/: the frame clock for the widget (same as calling 'GI.Gtk.Objects.Widget.widgetGetFrameClock') -> Ptr () /@userData@/: user data passed to 'GI.Gtk.Objects.Widget.widgetAddTickCallback'. -> IO Bool __Returns:__ 'GI.GLib.Constants.SOURCE_CONTINUE' if the tick callback should continue to be called, 'GI.GLib.Constants.SOURCE_REMOVE' if the tick callback should be removed.

+ GI.Gtk.Callbacks: type TickCallback_WithClosures = Widget " /@widget@/: the widget " -> FrameClock " /@frameClock@/: the frame clock for the widget (same as calling 'GI.Gtk.Objects.Widget.widgetGetFrameClock') " -> Ptr () " /@userData@/: user data passed to 'GI.Gtk.Objects.Widget.widgetAddTickCallback'. " -> IO Bool " __Returns:__ 'GI.GLib.Constants.SOURCE_CONTINUE' if the tick callback should continue to be called, 'GI.GLib.Constants.SOURCE_REMOVE' if the tick callback should be removed. "

- GI.Gtk.Callbacks: type TranslateFunc = Text /@path@/: The id of the message. In 'GI.Gtk.Objects.ActionGroup.ActionGroup' this will be a label or tooltip from a 'GI.Gtk.Structs.ActionEntry.ActionEntry'. -> IO Text __Returns:__ the translated message

+ GI.Gtk.Callbacks: type TranslateFunc = Text " /@path@/: The id of the message. In 'GI.Gtk.Objects.ActionGroup.ActionGroup' this will be a label or tooltip from a 'GI.Gtk.Structs.ActionEntry.ActionEntry'. " -> IO Text " __Returns:__ the translated message "

- GI.Gtk.Callbacks: type TranslateFunc_WithClosures = Text /@path@/: The id of the message. In 'GI.Gtk.Objects.ActionGroup.ActionGroup' this will be a label or tooltip from a 'GI.Gtk.Structs.ActionEntry.ActionEntry'. -> Ptr () /@funcData@/: user data passed in when registering the function -> IO Text __Returns:__ the translated message

+ GI.Gtk.Callbacks: type TranslateFunc_WithClosures = Text " /@path@/: The id of the message. In 'GI.Gtk.Objects.ActionGroup.ActionGroup' this will be a label or tooltip from a 'GI.Gtk.Structs.ActionEntry.ActionEntry'. " -> Ptr () " /@funcData@/: user data passed in when registering the function " -> IO Text " __Returns:__ the translated message "

- GI.Gtk.Callbacks: type TreeCellDataFunc = TreeViewColumn /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -> CellRenderer /@cell@/: The 'GI.Gtk.Objects.CellRenderer.CellRenderer' that is being rendered by /@treeColumn@/ -> TreeModel /@treeModel@/: The 'GI.Gtk.Interfaces.TreeModel.TreeModel' being rendered -> TreeIter /@iter@/: A 'GI.Gtk.Structs.TreeIter.TreeIter' of the current row rendered -> IO ()

+ GI.Gtk.Callbacks: type TreeCellDataFunc = TreeViewColumn " /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' " -> CellRenderer " /@cell@/: The 'GI.Gtk.Objects.CellRenderer.CellRenderer' that is being rendered by /@treeColumn@/ " -> TreeModel " /@treeModel@/: The 'GI.Gtk.Interfaces.TreeModel.TreeModel' being rendered " -> TreeIter " /@iter@/: A 'GI.Gtk.Structs.TreeIter.TreeIter' of the current row rendered " -> IO ()

- GI.Gtk.Callbacks: type TreeCellDataFunc_WithClosures = TreeViewColumn /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' -> CellRenderer /@cell@/: The 'GI.Gtk.Objects.CellRenderer.CellRenderer' that is being rendered by /@treeColumn@/ -> TreeModel /@treeModel@/: The 'GI.Gtk.Interfaces.TreeModel.TreeModel' being rendered -> TreeIter /@iter@/: A 'GI.Gtk.Structs.TreeIter.TreeIter' of the current row rendered -> Ptr () /@data@/: user data -> IO ()

+ GI.Gtk.Callbacks: type TreeCellDataFunc_WithClosures = TreeViewColumn " /@treeColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' " -> CellRenderer " /@cell@/: The 'GI.Gtk.Objects.CellRenderer.CellRenderer' that is being rendered by /@treeColumn@/ " -> TreeModel " /@treeModel@/: The 'GI.Gtk.Interfaces.TreeModel.TreeModel' being rendered " -> TreeIter " /@iter@/: A 'GI.Gtk.Structs.TreeIter.TreeIter' of the current row rendered " -> Ptr () " /@data@/: user data " -> IO ()

- GI.Gtk.Callbacks: type TreeIterCompareFunc = TreeModel /@model@/: The 'GI.Gtk.Interfaces.TreeModel.TreeModel' the comparison is within -> TreeIter /@a@/: A 'GI.Gtk.Structs.TreeIter.TreeIter' in /@model@/ -> TreeIter /@b@/: Another 'GI.Gtk.Structs.TreeIter.TreeIter' in /@model@/ -> IO Int32 __Returns:__ a negative integer, zero or a positive integer depending on whether /@a@/ sorts before, with or after /@b@/

+ GI.Gtk.Callbacks: type TreeIterCompareFunc = TreeModel " /@model@/: The 'GI.Gtk.Interfaces.TreeModel.TreeModel' the comparison is within " -> TreeIter " /@a@/: A 'GI.Gtk.Structs.TreeIter.TreeIter' in /@model@/ " -> TreeIter " /@b@/: Another 'GI.Gtk.Structs.TreeIter.TreeIter' in /@model@/ " -> IO Int32 " __Returns:__ a negative integer, zero or a positive integer depending on whether /@a@/ sorts before, with or after /@b@/ "

- GI.Gtk.Callbacks: type TreeIterCompareFunc_WithClosures = TreeModel /@model@/: The 'GI.Gtk.Interfaces.TreeModel.TreeModel' the comparison is within -> TreeIter /@a@/: A 'GI.Gtk.Structs.TreeIter.TreeIter' in /@model@/ -> TreeIter /@b@/: Another 'GI.Gtk.Structs.TreeIter.TreeIter' in /@model@/ -> Ptr () /@userData@/: Data passed when the compare func is assigned e.g. by 'GI.Gtk.Interfaces.TreeSortable.treeSortableSetSortFunc' -> IO Int32 __Returns:__ a negative integer, zero or a positive integer depending on whether /@a@/ sorts before, with or after /@b@/

+ GI.Gtk.Callbacks: type TreeIterCompareFunc_WithClosures = TreeModel " /@model@/: The 'GI.Gtk.Interfaces.TreeModel.TreeModel' the comparison is within " -> TreeIter " /@a@/: A 'GI.Gtk.Structs.TreeIter.TreeIter' in /@model@/ " -> TreeIter " /@b@/: Another 'GI.Gtk.Structs.TreeIter.TreeIter' in /@model@/ " -> Ptr () " /@userData@/: Data passed when the compare func is assigned e.g. by 'GI.Gtk.Interfaces.TreeSortable.treeSortableSetSortFunc' " -> IO Int32 " __Returns:__ a negative integer, zero or a positive integer depending on whether /@a@/ sorts before, with or after /@b@/ "

- GI.Gtk.Callbacks: type TreeModelFilterVisibleFunc = TreeModel /@model@/: the child model of the 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter' -> TreeIter /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' pointing to the row in /@model@/ whose visibility is determined -> IO Bool __Returns:__ Whether the row indicated by /@iter@/ is visible.

+ GI.Gtk.Callbacks: type TreeModelFilterVisibleFunc = TreeModel " /@model@/: the child model of the 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter' " -> TreeIter " /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' pointing to the row in /@model@/ whose visibility is determined " -> IO Bool " __Returns:__ Whether the row indicated by /@iter@/ is visible. "

- GI.Gtk.Callbacks: type TreeModelFilterVisibleFunc_WithClosures = TreeModel /@model@/: the child model of the 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter' -> TreeIter /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' pointing to the row in /@model@/ whose visibility is determined -> Ptr () /@data@/: user data given to 'GI.Gtk.Objects.TreeModelFilter.treeModelFilterSetVisibleFunc' -> IO Bool __Returns:__ Whether the row indicated by /@iter@/ is visible.

+ GI.Gtk.Callbacks: type TreeModelFilterVisibleFunc_WithClosures = TreeModel " /@model@/: the child model of the 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter' " -> TreeIter " /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' pointing to the row in /@model@/ whose visibility is determined " -> Ptr () " /@data@/: user data given to 'GI.Gtk.Objects.TreeModelFilter.treeModelFilterSetVisibleFunc' " -> IO Bool " __Returns:__ Whether the row indicated by /@iter@/ is visible. "

- GI.Gtk.Callbacks: type TreeModelForeachFunc = TreeModel /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' being iterated -> TreePath /@path@/: the current 'GI.Gtk.Structs.TreePath.TreePath' -> TreeIter /@iter@/: the current 'GI.Gtk.Structs.TreeIter.TreeIter' -> IO Bool __Returns:__ 'True' to stop iterating, 'False' to continue

+ GI.Gtk.Callbacks: type TreeModelForeachFunc = TreeModel " /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' being iterated " -> TreePath " /@path@/: the current 'GI.Gtk.Structs.TreePath.TreePath' " -> TreeIter " /@iter@/: the current 'GI.Gtk.Structs.TreeIter.TreeIter' " -> IO Bool " __Returns:__ 'True' to stop iterating, 'False' to continue "

- GI.Gtk.Callbacks: type TreeModelForeachFunc_WithClosures = TreeModel /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' being iterated -> TreePath /@path@/: the current 'GI.Gtk.Structs.TreePath.TreePath' -> TreeIter /@iter@/: the current 'GI.Gtk.Structs.TreeIter.TreeIter' -> Ptr () /@data@/: The user data passed to 'GI.Gtk.Interfaces.TreeModel.treeModelForeach' -> IO Bool __Returns:__ 'True' to stop iterating, 'False' to continue

+ GI.Gtk.Callbacks: type TreeModelForeachFunc_WithClosures = TreeModel " /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' being iterated " -> TreePath " /@path@/: the current 'GI.Gtk.Structs.TreePath.TreePath' " -> TreeIter " /@iter@/: the current 'GI.Gtk.Structs.TreeIter.TreeIter' " -> Ptr () " /@data@/: The user data passed to 'GI.Gtk.Interfaces.TreeModel.treeModelForeach' " -> IO Bool " __Returns:__ 'True' to stop iterating, 'False' to continue "

- GI.Gtk.Callbacks: type TreeSelectionForeachFunc = TreeModel /@model@/: The 'GI.Gtk.Interfaces.TreeModel.TreeModel' being viewed -> TreePath /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' of a selected row -> TreeIter /@iter@/: A 'GI.Gtk.Structs.TreeIter.TreeIter' pointing to a selected row -> IO ()

+ GI.Gtk.Callbacks: type TreeSelectionForeachFunc = TreeModel " /@model@/: The 'GI.Gtk.Interfaces.TreeModel.TreeModel' being viewed " -> TreePath " /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' of a selected row " -> TreeIter " /@iter@/: A 'GI.Gtk.Structs.TreeIter.TreeIter' pointing to a selected row " -> IO ()

- GI.Gtk.Callbacks: type TreeSelectionForeachFunc_WithClosures = TreeModel /@model@/: The 'GI.Gtk.Interfaces.TreeModel.TreeModel' being viewed -> TreePath /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' of a selected row -> TreeIter /@iter@/: A 'GI.Gtk.Structs.TreeIter.TreeIter' pointing to a selected row -> Ptr () /@data@/: user data -> IO ()

+ GI.Gtk.Callbacks: type TreeSelectionForeachFunc_WithClosures = TreeModel " /@model@/: The 'GI.Gtk.Interfaces.TreeModel.TreeModel' being viewed " -> TreePath " /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' of a selected row " -> TreeIter " /@iter@/: A 'GI.Gtk.Structs.TreeIter.TreeIter' pointing to a selected row " -> Ptr () " /@data@/: user data " -> IO ()

- GI.Gtk.Callbacks: type TreeSelectionFunc = TreeSelection /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection' -> TreeModel /@model@/: A 'GI.Gtk.Interfaces.TreeModel.TreeModel' being viewed -> TreePath /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' of the row in question -> Bool /@pathCurrentlySelected@/: 'True', if the path is currently selected -> IO Bool __Returns:__ 'True', if the selection state of the row can be toggled

+ GI.Gtk.Callbacks: type TreeSelectionFunc = TreeSelection " /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection' " -> TreeModel " /@model@/: A 'GI.Gtk.Interfaces.TreeModel.TreeModel' being viewed " -> TreePath " /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' of the row in question " -> Bool " /@pathCurrentlySelected@/: 'True', if the path is currently selected " -> IO Bool " __Returns:__ 'True', if the selection state of the row can be toggled "

- GI.Gtk.Callbacks: type TreeSelectionFunc_WithClosures = TreeSelection /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection' -> TreeModel /@model@/: A 'GI.Gtk.Interfaces.TreeModel.TreeModel' being viewed -> TreePath /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' of the row in question -> Bool /@pathCurrentlySelected@/: 'True', if the path is currently selected -> Ptr () /@data@/: user data -> IO Bool __Returns:__ 'True', if the selection state of the row can be toggled

+ GI.Gtk.Callbacks: type TreeSelectionFunc_WithClosures = TreeSelection " /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection' " -> TreeModel " /@model@/: A 'GI.Gtk.Interfaces.TreeModel.TreeModel' being viewed " -> TreePath " /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' of the row in question " -> Bool " /@pathCurrentlySelected@/: 'True', if the path is currently selected " -> Ptr () " /@data@/: user data " -> IO Bool " __Returns:__ 'True', if the selection state of the row can be toggled "

- GI.Gtk.Callbacks: type TreeViewColumnDropFunc = TreeView /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -> TreeViewColumn /@column@/: The 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' being dragged -> TreeViewColumn /@prevColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' on one side of /@column@/ -> TreeViewColumn /@nextColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' on the other side of /@column@/ -> IO Bool __Returns:__ 'True', if /@column@/ can be dropped in this spot

+ GI.Gtk.Callbacks: type TreeViewColumnDropFunc = TreeView " /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' " -> TreeViewColumn " /@column@/: The 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' being dragged " -> TreeViewColumn " /@prevColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' on one side of /@column@/ " -> TreeViewColumn " /@nextColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' on the other side of /@column@/ " -> IO Bool " __Returns:__ 'True', if /@column@/ can be dropped in this spot "

- GI.Gtk.Callbacks: type TreeViewColumnDropFunc_WithClosures = TreeView /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -> TreeViewColumn /@column@/: The 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' being dragged -> TreeViewColumn /@prevColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' on one side of /@column@/ -> TreeViewColumn /@nextColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' on the other side of /@column@/ -> Ptr () /@data@/: user data -> IO Bool __Returns:__ 'True', if /@column@/ can be dropped in this spot

+ GI.Gtk.Callbacks: type TreeViewColumnDropFunc_WithClosures = TreeView " /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' " -> TreeViewColumn " /@column@/: The 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' being dragged " -> TreeViewColumn " /@prevColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' on one side of /@column@/ " -> TreeViewColumn " /@nextColumn@/: A 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' on the other side of /@column@/ " -> Ptr () " /@data@/: user data " -> IO Bool " __Returns:__ 'True', if /@column@/ can be dropped in this spot "

- GI.Gtk.Callbacks: type TreeViewMappingFunc = TreeView /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -> TreePath /@path@/: The path that’s expanded -> IO ()

+ GI.Gtk.Callbacks: type TreeViewMappingFunc = TreeView " /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' " -> TreePath " /@path@/: The path that’s expanded " -> IO ()

- GI.Gtk.Callbacks: type TreeViewMappingFunc_WithClosures = TreeView /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' -> TreePath /@path@/: The path that’s expanded -> Ptr () /@userData@/: user data -> IO ()

+ GI.Gtk.Callbacks: type TreeViewMappingFunc_WithClosures = TreeView " /@treeView@/: A 'GI.Gtk.Objects.TreeView.TreeView' " -> TreePath " /@path@/: The path that’s expanded " -> Ptr () " /@userData@/: user data " -> IO ()

- GI.Gtk.Callbacks: type TreeViewRowSeparatorFunc = TreeModel /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' -> TreeIter /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' pointing at a row in /@model@/ -> IO Bool __Returns:__ 'True' if the row is a separator

+ GI.Gtk.Callbacks: type TreeViewRowSeparatorFunc = TreeModel " /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' " -> TreeIter " /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' pointing at a row in /@model@/ " -> IO Bool " __Returns:__ 'True' if the row is a separator "

- GI.Gtk.Callbacks: type TreeViewRowSeparatorFunc_WithClosures = TreeModel /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' -> TreeIter /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' pointing at a row in /@model@/ -> Ptr () /@data@/: user data -> IO Bool __Returns:__ 'True' if the row is a separator

+ GI.Gtk.Callbacks: type TreeViewRowSeparatorFunc_WithClosures = TreeModel " /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' " -> TreeIter " /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' pointing at a row in /@model@/ " -> Ptr () " /@data@/: user data " -> IO Bool " __Returns:__ 'True' if the row is a separator "

- GI.Gtk.Callbacks: type TreeViewSearchEqualFunc = TreeModel /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' being searched -> Int32 /@column@/: the search column set by 'GI.Gtk.Objects.TreeView.treeViewSetSearchColumn' -> Text /@key@/: the key string to compare with -> TreeIter /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' pointing the row of /@model@/ that should be compared with /@key@/. -> IO Bool __Returns:__ 'False' if the row matches, 'True' otherwise.

+ GI.Gtk.Callbacks: type TreeViewSearchEqualFunc = TreeModel " /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' being searched " -> Int32 " /@column@/: the search column set by 'GI.Gtk.Objects.TreeView.treeViewSetSearchColumn' " -> Text " /@key@/: the key string to compare with " -> TreeIter " /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' pointing the row of /@model@/ that should be compared with /@key@/. " -> IO Bool " __Returns:__ 'False' if the row matches, 'True' otherwise. "

- GI.Gtk.Callbacks: type TreeViewSearchEqualFunc_WithClosures = TreeModel /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' being searched -> Int32 /@column@/: the search column set by 'GI.Gtk.Objects.TreeView.treeViewSetSearchColumn' -> Text /@key@/: the key string to compare with -> TreeIter /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' pointing the row of /@model@/ that should be compared with /@key@/. -> Ptr () /@searchData@/: user data from 'GI.Gtk.Objects.TreeView.treeViewSetSearchEqualFunc' -> IO Bool __Returns:__ 'False' if the row matches, 'True' otherwise.

+ GI.Gtk.Callbacks: type TreeViewSearchEqualFunc_WithClosures = TreeModel " /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' being searched " -> Int32 " /@column@/: the search column set by 'GI.Gtk.Objects.TreeView.treeViewSetSearchColumn' " -> Text " /@key@/: the key string to compare with " -> TreeIter " /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' pointing the row of /@model@/ that should be compared with /@key@/. " -> Ptr () " /@searchData@/: user data from 'GI.Gtk.Objects.TreeView.treeViewSetSearchEqualFunc' " -> IO Bool " __Returns:__ 'False' if the row matches, 'True' otherwise. "

- GI.Gtk.Functions: acceleratorGetLabelWithKeycode :: (HasCallStack, MonadIO m, IsDisplay a) => Maybe (a) -> Word32 -> Word32 -> [ModifierType] -> m Text

+ GI.Gtk.Functions: acceleratorGetLabelWithKeycode :: (HasCallStack, MonadIO m, IsDisplay a) => Maybe a -> Word32 -> Word32 -> [ModifierType] -> m Text

- GI.Gtk.Functions: acceleratorNameWithKeycode :: (HasCallStack, MonadIO m, IsDisplay a) => Maybe (a) -> Word32 -> Word32 -> [ModifierType] -> m Text

+ GI.Gtk.Functions: acceleratorNameWithKeycode :: (HasCallStack, MonadIO m, IsDisplay a) => Maybe a -> Word32 -> Word32 -> [ModifierType] -> m Text

- GI.Gtk.Functions: acceleratorParse :: (HasCallStack, MonadIO m) => Text -> m ((Word32, [ModifierType]))

+ GI.Gtk.Functions: acceleratorParse :: (HasCallStack, MonadIO m) => Text -> m (Word32, [ModifierType])

- GI.Gtk.Functions: acceleratorParseWithKeycode :: (HasCallStack, MonadIO m) => Text -> m ((Word32, [Word32], [ModifierType]))

+ GI.Gtk.Functions: acceleratorParseWithKeycode :: (HasCallStack, MonadIO m) => Text -> m (Word32, [Word32], [ModifierType])

- GI.Gtk.Functions: alternativeDialogButtonOrder :: (HasCallStack, MonadIO m, IsScreen a) => Maybe (a) -> m Bool

+ GI.Gtk.Functions: alternativeDialogButtonOrder :: (HasCallStack, MonadIO m, IsScreen a) => Maybe a -> m Bool

- GI.Gtk.Functions: getCurrentEventState :: (HasCallStack, MonadIO m) => m ((Bool, [ModifierType]))

+ GI.Gtk.Functions: getCurrentEventState :: (HasCallStack, MonadIO m) => m (Bool, [ModifierType])

- GI.Gtk.Functions: init :: (HasCallStack, MonadIO m) => Maybe ([Text]) -> m ((Maybe [Text]))

+ GI.Gtk.Functions: init :: (HasCallStack, MonadIO m) => Maybe [Text] -> m (Maybe [Text])

- GI.Gtk.Functions: initCheck :: (HasCallStack, MonadIO m) => Maybe ([Text]) -> m ((Bool, Maybe [Text]))

+ GI.Gtk.Functions: initCheck :: (HasCallStack, MonadIO m) => Maybe [Text] -> m (Bool, Maybe [Text])

- GI.Gtk.Functions: initWithArgs :: (HasCallStack, MonadIO m) => Maybe ([Text]) -> Maybe (Text) -> [OptionEntry] -> Maybe (Text) -> m ((Maybe [Text]))

+ GI.Gtk.Functions: initWithArgs :: (HasCallStack, MonadIO m) => Maybe [Text] -> Maybe Text -> [OptionEntry] -> Maybe Text -> m (Maybe [Text])

- GI.Gtk.Functions: paintArrow :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe (b) -> Maybe (Text) -> ArrowType -> Bool -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintArrow :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> ArrowType -> Bool -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: paintBox :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintBox :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: paintBoxGap :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> Int32 -> PositionType -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintBoxGap :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> PositionType -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: paintCheck :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintCheck :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: paintDiamond :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintDiamond :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: paintExpander :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> ExpanderStyle -> m ()

+ GI.Gtk.Functions: paintExpander :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> ExpanderStyle -> m ()

- GI.Gtk.Functions: paintExtension :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> Int32 -> PositionType -> m ()

+ GI.Gtk.Functions: paintExtension :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> PositionType -> m ()

- GI.Gtk.Functions: paintFlatBox :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintFlatBox :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: paintFocus :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintFocus :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: paintHandle :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> Int32 -> Orientation -> m ()

+ GI.Gtk.Functions: paintHandle :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> Orientation -> m ()

- GI.Gtk.Functions: paintHline :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintHline :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: paintLayout :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b, IsLayout c) => a -> Context -> StateType -> Bool -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> c -> m ()

+ GI.Gtk.Functions: paintLayout :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b, IsLayout c) => a -> Context -> StateType -> Bool -> Maybe b -> Maybe Text -> Int32 -> Int32 -> c -> m ()

- GI.Gtk.Functions: paintOption :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintOption :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: paintResizeGrip :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe (b) -> Maybe (Text) -> WindowEdge -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintResizeGrip :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe b -> Maybe Text -> WindowEdge -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: paintShadow :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintShadow :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: paintShadowGap :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> Int32 -> PositionType -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintShadowGap :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> PositionType -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: paintSlider :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> Int32 -> Orientation -> m ()

+ GI.Gtk.Functions: paintSlider :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> Orientation -> m ()

- GI.Gtk.Functions: paintSpinner :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe (b) -> Maybe (Text) -> Word32 -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintSpinner :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe b -> Maybe Text -> Word32 -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: paintTab :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintTab :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: paintVline :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe (b) -> Maybe (Text) -> Int32 -> Int32 -> Int32 -> m ()

+ GI.Gtk.Functions: paintVline :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> m ()

- GI.Gtk.Functions: parseArgs :: (HasCallStack, MonadIO m) => [Text] -> m ((Bool, [Text]))

+ GI.Gtk.Functions: parseArgs :: (HasCallStack, MonadIO m) => [Text] -> m (Bool, [Text])

- GI.Gtk.Functions: printRunPageSetupDialog :: (HasCallStack, MonadIO m, IsWindow a, IsPageSetup b, IsPrintSettings c) => Maybe (a) -> Maybe (b) -> c -> m PageSetup

+ GI.Gtk.Functions: printRunPageSetupDialog :: (HasCallStack, MonadIO m, IsWindow a, IsPageSetup b, IsPrintSettings c) => Maybe a -> Maybe b -> c -> m PageSetup

- GI.Gtk.Functions: printRunPageSetupDialogAsync :: (HasCallStack, MonadIO m, IsWindow a, IsPageSetup b, IsPrintSettings c) => Maybe (a) -> Maybe (b) -> c -> PageSetupDoneFunc -> m ()

+ GI.Gtk.Functions: printRunPageSetupDialogAsync :: (HasCallStack, MonadIO m, IsWindow a, IsPageSetup b, IsPrintSettings c) => Maybe a -> Maybe b -> c -> PageSetupDoneFunc -> m ()

- GI.Gtk.Functions: rcGetStyleByPaths :: (HasCallStack, MonadIO m, IsSettings a) => a -> Maybe (Text) -> Maybe (Text) -> GType -> m (Maybe Style)

+ GI.Gtk.Functions: rcGetStyleByPaths :: (HasCallStack, MonadIO m, IsSettings a) => a -> Maybe Text -> Maybe Text -> GType -> m (Maybe Style)

- GI.Gtk.Functions: rcParseColor :: (HasCallStack, MonadIO m) => Scanner -> m ((Word32, Color))

+ GI.Gtk.Functions: rcParseColor :: (HasCallStack, MonadIO m) => Scanner -> m (Word32, Color)

- GI.Gtk.Functions: rcParseColorFull :: (HasCallStack, MonadIO m, IsRcStyle a) => Scanner -> Maybe (a) -> m ((Word32, Color))

+ GI.Gtk.Functions: rcParseColorFull :: (HasCallStack, MonadIO m, IsRcStyle a) => Scanner -> Maybe a -> m (Word32, Color)

- GI.Gtk.Functions: rcParseState :: (HasCallStack, MonadIO m) => Scanner -> m ((Word32, StateType))

+ GI.Gtk.Functions: rcParseState :: (HasCallStack, MonadIO m) => Scanner -> m (Word32, StateType)

- GI.Gtk.Functions: renderBackgroundGetClip :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Double -> Double -> Double -> Double -> m (Rectangle)

+ GI.Gtk.Functions: renderBackgroundGetClip :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Double -> Double -> Double -> Double -> m Rectangle

- GI.Gtk.Functions: rgbToHsv :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m ((Double, Double, Double))

+ GI.Gtk.Functions: rgbToHsv :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m (Double, Double, Double)

- GI.Gtk.Functions: selectionOwnerSet :: (HasCallStack, MonadIO m, IsWidget a) => Maybe (a) -> Atom -> Word32 -> m Bool

+ GI.Gtk.Functions: selectionOwnerSet :: (HasCallStack, MonadIO m, IsWidget a) => Maybe a -> Atom -> Word32 -> m Bool

- GI.Gtk.Functions: selectionOwnerSetForDisplay :: (HasCallStack, MonadIO m, IsDisplay a, IsWidget b) => a -> Maybe (b) -> Atom -> Word32 -> m Bool

+ GI.Gtk.Functions: selectionOwnerSetForDisplay :: (HasCallStack, MonadIO m, IsDisplay a, IsWidget b) => a -> Maybe b -> Atom -> Word32 -> m Bool

- GI.Gtk.Functions: showUri :: (HasCallStack, MonadIO m, IsScreen a) => Maybe (a) -> Text -> Word32 -> m ()

+ GI.Gtk.Functions: showUri :: (HasCallStack, MonadIO m, IsScreen a) => Maybe a -> Text -> Word32 -> m ()

- GI.Gtk.Functions: showUriOnWindow :: (HasCallStack, MonadIO m, IsWindow a) => Maybe (a) -> Text -> Word32 -> m ()

+ GI.Gtk.Functions: showUriOnWindow :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> Text -> Word32 -> m ()

- GI.Gtk.Functions: stockLookup :: (HasCallStack, MonadIO m) => Text -> m ((Bool, StockItem))

+ GI.Gtk.Functions: stockLookup :: (HasCallStack, MonadIO m) => Text -> m (Bool, StockItem)

- GI.Gtk.Functions: testListAllTypes :: (HasCallStack, MonadIO m) => m (([GType], Word32))

+ GI.Gtk.Functions: testListAllTypes :: (HasCallStack, MonadIO m) => m ([GType], Word32)

- GI.Gtk.Functions: treeGetRowDragData :: (HasCallStack, MonadIO m) => SelectionData -> m ((Bool, Maybe TreeModel, Maybe TreePath))

+ GI.Gtk.Functions: treeGetRowDragData :: (HasCallStack, MonadIO m) => SelectionData -> m (Bool, Maybe TreeModel, Maybe TreePath)

- GI.Gtk.Interfaces.Actionable: Actionable :: (ManagedPtr Actionable) -> Actionable

+ GI.Gtk.Interfaces.Actionable: Actionable :: ManagedPtr Actionable -> Actionable

- GI.Gtk.Interfaces.Actionable: actionableSetActionName :: (HasCallStack, MonadIO m, IsActionable a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Interfaces.Actionable: actionableSetActionName :: (HasCallStack, MonadIO m, IsActionable a) => a -> Maybe Text -> m ()

- GI.Gtk.Interfaces.Actionable: constructActionableActionName :: (IsActionable o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.Actionable: constructActionableActionName :: IsActionable o => Text -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.Actionable: constructActionableActionTarget :: (IsActionable o) => GVariant -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.Actionable: constructActionableActionTarget :: IsActionable o => GVariant -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.Activatable: Activatable :: (ManagedPtr Activatable) -> Activatable

+ GI.Gtk.Interfaces.Activatable: Activatable :: ManagedPtr Activatable -> Activatable

- GI.Gtk.Interfaces.Activatable: activatableSyncActionProperties :: (HasCallStack, MonadIO m, IsActivatable a, IsAction b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Interfaces.Activatable: activatableSyncActionProperties :: (HasCallStack, MonadIO m, IsActivatable a, IsAction b) => a -> Maybe b -> m ()

- GI.Gtk.Interfaces.Activatable: constructActivatableUseActionAppearance :: (IsActivatable o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.Activatable: constructActivatableUseActionAppearance :: IsActivatable o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.AppChooser: AppChooser :: (ManagedPtr AppChooser) -> AppChooser

+ GI.Gtk.Interfaces.AppChooser: AppChooser :: ManagedPtr AppChooser -> AppChooser

- GI.Gtk.Interfaces.AppChooser: constructAppChooserContentType :: (IsAppChooser o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.AppChooser: constructAppChooserContentType :: IsAppChooser o => Text -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.Buildable: Buildable :: (ManagedPtr Buildable) -> Buildable

+ GI.Gtk.Interfaces.Buildable: Buildable :: ManagedPtr Buildable -> Buildable

- GI.Gtk.Interfaces.Buildable: buildableAddChild :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b, IsObject c) => a -> b -> c -> Maybe (Text) -> m ()

+ GI.Gtk.Interfaces.Buildable: buildableAddChild :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b, IsObject c) => a -> b -> c -> Maybe Text -> m ()

- GI.Gtk.Interfaces.Buildable: buildableCustomFinished :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b, IsObject c) => a -> b -> Maybe (c) -> Text -> Ptr () -> m ()

+ GI.Gtk.Interfaces.Buildable: buildableCustomFinished :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b, IsObject c) => a -> b -> Maybe c -> Text -> Ptr () -> m ()

- GI.Gtk.Interfaces.Buildable: buildableCustomTagEnd :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b, IsObject c) => a -> b -> Maybe (c) -> Text -> Ptr () -> m ()

+ GI.Gtk.Interfaces.Buildable: buildableCustomTagEnd :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b, IsObject c) => a -> b -> Maybe c -> Text -> Ptr () -> m ()

- GI.Gtk.Interfaces.Buildable: buildableCustomTagStart :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b, IsObject c) => a -> b -> Maybe (c) -> Text -> m ((Bool, MarkupParser, Ptr ()))

+ GI.Gtk.Interfaces.Buildable: buildableCustomTagStart :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b, IsObject c) => a -> b -> Maybe c -> Text -> m (Bool, MarkupParser, Ptr ())

- GI.Gtk.Interfaces.CellAccessibleParent: CellAccessibleParent :: (ManagedPtr CellAccessibleParent) -> CellAccessibleParent

+ GI.Gtk.Interfaces.CellAccessibleParent: CellAccessibleParent :: ManagedPtr CellAccessibleParent -> CellAccessibleParent

- GI.Gtk.Interfaces.CellEditable: CellEditable :: (ManagedPtr CellEditable) -> CellEditable

+ GI.Gtk.Interfaces.CellEditable: CellEditable :: ManagedPtr CellEditable -> CellEditable

- GI.Gtk.Interfaces.CellEditable: cellEditableStartEditing :: (HasCallStack, MonadIO m, IsCellEditable a) => a -> Maybe (Event) -> m ()

+ GI.Gtk.Interfaces.CellEditable: cellEditableStartEditing :: (HasCallStack, MonadIO m, IsCellEditable a) => a -> Maybe Event -> m ()

- GI.Gtk.Interfaces.CellEditable: constructCellEditableEditingCanceled :: (IsCellEditable o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.CellEditable: constructCellEditableEditingCanceled :: IsCellEditable o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.CellLayout: CellLayout :: (ManagedPtr CellLayout) -> CellLayout

+ GI.Gtk.Interfaces.CellLayout: CellLayout :: ManagedPtr CellLayout -> CellLayout

- GI.Gtk.Interfaces.CellLayout: cellLayoutSetCellDataFunc :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Maybe (CellLayoutDataFunc) -> m ()

+ GI.Gtk.Interfaces.CellLayout: cellLayoutSetCellDataFunc :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Maybe CellLayoutDataFunc -> m ()

- GI.Gtk.Interfaces.ColorChooser: ColorChooser :: (ManagedPtr ColorChooser) -> ColorChooser

+ GI.Gtk.Interfaces.ColorChooser: ColorChooser :: ManagedPtr ColorChooser -> ColorChooser

- GI.Gtk.Interfaces.ColorChooser: colorChooserAddPalette :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> Orientation -> Int32 -> Maybe ([RGBA]) -> m ()

+ GI.Gtk.Interfaces.ColorChooser: colorChooserAddPalette :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> Orientation -> Int32 -> Maybe [RGBA] -> m ()

- GI.Gtk.Interfaces.ColorChooser: colorChooserGetRgba :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> m (RGBA)

+ GI.Gtk.Interfaces.ColorChooser: colorChooserGetRgba :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> m RGBA

- GI.Gtk.Interfaces.ColorChooser: constructColorChooserRgba :: (IsColorChooser o) => RGBA -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.ColorChooser: constructColorChooserRgba :: IsColorChooser o => RGBA -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.ColorChooser: constructColorChooserUseAlpha :: (IsColorChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.ColorChooser: constructColorChooserUseAlpha :: IsColorChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.ColorChooser: type ColorChooserColorActivatedCallback = RGBA /@color@/: the color -> IO ()

+ GI.Gtk.Interfaces.ColorChooser: type ColorChooserColorActivatedCallback = RGBA " /@color@/: the color " -> IO ()

- GI.Gtk.Interfaces.Editable: Editable :: (ManagedPtr Editable) -> Editable

+ GI.Gtk.Interfaces.Editable: Editable :: ManagedPtr Editable -> Editable

- GI.Gtk.Interfaces.Editable: editableGetSelectionBounds :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ((Bool, Int32, Int32))

+ GI.Gtk.Interfaces.Editable: editableGetSelectionBounds :: (HasCallStack, MonadIO m, IsEditable a) => a -> m (Bool, Int32, Int32)

- GI.Gtk.Interfaces.Editable: editableInsertText :: (HasCallStack, MonadIO m, IsEditable a) => a -> Text -> Int32 -> Int32 -> m (Int32)

+ GI.Gtk.Interfaces.Editable: editableInsertText :: (HasCallStack, MonadIO m, IsEditable a) => a -> Text -> Int32 -> Int32 -> m Int32

- GI.Gtk.Interfaces.Editable: type EditableDeleteTextCallback = Int32 /@startPos@/: the starting position -> Int32 /@endPos@/: the end position -> IO ()

+ GI.Gtk.Interfaces.Editable: type EditableDeleteTextCallback = Int32 " /@startPos@/: the starting position " -> Int32 " /@endPos@/: the end position " -> IO ()

- GI.Gtk.Interfaces.Editable: type EditableInsertTextCallback = Text /@newText@/: the new text to insert -> Int32 /@newTextLength@/: the length of the new text, in bytes, or -1 if new_text is nul-terminated -> Int32 /@position@/: the position, in characters, at which to insert the new text. this is an in-out parameter. After the signal emission is finished, it should point after the newly inserted text. -> IO (Int32)

+ GI.Gtk.Interfaces.Editable: type EditableInsertTextCallback = Text " /@newText@/: the new text to insert " -> Int32 " /@newTextLength@/: the length of the new text, in bytes, or -1 if new_text is nul-terminated " -> Int32 " /@position@/: the position, in characters, at which to insert the new text. this is an in-out parameter. After the signal emission is finished, it should point after the newly inserted text. " -> IO (Int32)

- GI.Gtk.Interfaces.FileChooser: FileChooser :: (ManagedPtr FileChooser) -> FileChooser

+ GI.Gtk.Interfaces.FileChooser: FileChooser :: ManagedPtr FileChooser -> FileChooser

- GI.Gtk.Interfaces.FileChooser: constructFileChooserAction :: (IsFileChooser o) => FileChooserAction -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.FileChooser: constructFileChooserAction :: IsFileChooser o => FileChooserAction -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.FileChooser: constructFileChooserCreateFolders :: (IsFileChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.FileChooser: constructFileChooserCreateFolders :: IsFileChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.FileChooser: constructFileChooserDoOverwriteConfirmation :: (IsFileChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.FileChooser: constructFileChooserDoOverwriteConfirmation :: IsFileChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.FileChooser: constructFileChooserLocalOnly :: (IsFileChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.FileChooser: constructFileChooserLocalOnly :: IsFileChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.FileChooser: constructFileChooserPreviewWidgetActive :: (IsFileChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.FileChooser: constructFileChooserPreviewWidgetActive :: IsFileChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.FileChooser: constructFileChooserSelectMultiple :: (IsFileChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.FileChooser: constructFileChooserSelectMultiple :: IsFileChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.FileChooser: constructFileChooserShowHidden :: (IsFileChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.FileChooser: constructFileChooserShowHidden :: IsFileChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.FileChooser: constructFileChooserUsePreviewLabel :: (IsFileChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.FileChooser: constructFileChooserUsePreviewLabel :: IsFileChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.FileChooser: fileChooserAddChoice :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> Text -> Maybe ([Text]) -> Maybe ([Text]) -> m ()

+ GI.Gtk.Interfaces.FileChooser: fileChooserAddChoice :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> Text -> Maybe [Text] -> Maybe [Text] -> m ()

- GI.Gtk.Interfaces.FileChooser: type FileChooserConfirmOverwriteCallback = IO FileChooserConfirmation __Returns:__ a 'GI.Gtk.Enums.FileChooserConfirmation' value that indicates which action to take after emitting the signal.

+ GI.Gtk.Interfaces.FileChooser: type FileChooserConfirmOverwriteCallback = IO FileChooserConfirmation " __Returns:__ a 'GI.Gtk.Enums.FileChooserConfirmation' value that indicates which action to take after emitting the signal. "

- GI.Gtk.Interfaces.FontChooser: FontChooser :: (ManagedPtr FontChooser) -> FontChooser

+ GI.Gtk.Interfaces.FontChooser: FontChooser :: ManagedPtr FontChooser -> FontChooser

- GI.Gtk.Interfaces.FontChooser: constructFontChooserFont :: (IsFontChooser o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.FontChooser: constructFontChooserFont :: IsFontChooser o => Text -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.FontChooser: constructFontChooserFontDesc :: (IsFontChooser o) => FontDescription -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.FontChooser: constructFontChooserFontDesc :: IsFontChooser o => FontDescription -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.FontChooser: constructFontChooserPreviewText :: (IsFontChooser o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.FontChooser: constructFontChooserPreviewText :: IsFontChooser o => Text -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.FontChooser: constructFontChooserShowPreviewEntry :: (IsFontChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.FontChooser: constructFontChooserShowPreviewEntry :: IsFontChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.FontChooser: fontChooserSetFilterFunc :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Maybe (FontFilterFunc) -> m ()

+ GI.Gtk.Interfaces.FontChooser: fontChooserSetFilterFunc :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Maybe FontFilterFunc -> m ()

- GI.Gtk.Interfaces.FontChooser: fontChooserSetFontMap :: (HasCallStack, MonadIO m, IsFontChooser a, IsFontMap b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Interfaces.FontChooser: fontChooserSetFontMap :: (HasCallStack, MonadIO m, IsFontChooser a, IsFontMap b) => a -> Maybe b -> m ()

- GI.Gtk.Interfaces.FontChooser: type FontChooserFontActivatedCallback = Text /@fontname@/: the font name -> IO ()

+ GI.Gtk.Interfaces.FontChooser: type FontChooserFontActivatedCallback = Text " /@fontname@/: the font name " -> IO ()

- GI.Gtk.Interfaces.Orientable: Orientable :: (ManagedPtr Orientable) -> Orientable

+ GI.Gtk.Interfaces.Orientable: Orientable :: ManagedPtr Orientable -> Orientable

- GI.Gtk.Interfaces.Orientable: constructOrientableOrientation :: (IsOrientable o) => Orientation -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.Orientable: constructOrientableOrientation :: IsOrientable o => Orientation -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.PrintOperationPreview: PrintOperationPreview :: (ManagedPtr PrintOperationPreview) -> PrintOperationPreview

+ GI.Gtk.Interfaces.PrintOperationPreview: PrintOperationPreview :: ManagedPtr PrintOperationPreview -> PrintOperationPreview

- GI.Gtk.Interfaces.PrintOperationPreview: type PrintOperationPreviewGotPageSizeCallback = PrintContext /@context@/: the current 'GI.Gtk.Objects.PrintContext.PrintContext' -> PageSetup /@pageSetup@/: the 'GI.Gtk.Objects.PageSetup.PageSetup' for the current page -> IO ()

+ GI.Gtk.Interfaces.PrintOperationPreview: type PrintOperationPreviewGotPageSizeCallback = PrintContext " /@context@/: the current 'GI.Gtk.Objects.PrintContext.PrintContext' " -> PageSetup " /@pageSetup@/: the 'GI.Gtk.Objects.PageSetup.PageSetup' for the current page " -> IO ()

- GI.Gtk.Interfaces.PrintOperationPreview: type PrintOperationPreviewReadyCallback = PrintContext /@context@/: the current 'GI.Gtk.Objects.PrintContext.PrintContext' -> IO ()

+ GI.Gtk.Interfaces.PrintOperationPreview: type PrintOperationPreviewReadyCallback = PrintContext " /@context@/: the current 'GI.Gtk.Objects.PrintContext.PrintContext' " -> IO ()

- GI.Gtk.Interfaces.RecentChooser: RecentChooser :: (ManagedPtr RecentChooser) -> RecentChooser

+ GI.Gtk.Interfaces.RecentChooser: RecentChooser :: ManagedPtr RecentChooser -> RecentChooser

- GI.Gtk.Interfaces.RecentChooser: constructRecentChooserLimit :: (IsRecentChooser o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.RecentChooser: constructRecentChooserLimit :: IsRecentChooser o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.RecentChooser: constructRecentChooserLocalOnly :: (IsRecentChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.RecentChooser: constructRecentChooserLocalOnly :: IsRecentChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.RecentChooser: constructRecentChooserSelectMultiple :: (IsRecentChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.RecentChooser: constructRecentChooserSelectMultiple :: IsRecentChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.RecentChooser: constructRecentChooserShowIcons :: (IsRecentChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.RecentChooser: constructRecentChooserShowIcons :: IsRecentChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.RecentChooser: constructRecentChooserShowNotFound :: (IsRecentChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.RecentChooser: constructRecentChooserShowNotFound :: IsRecentChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.RecentChooser: constructRecentChooserShowPrivate :: (IsRecentChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.RecentChooser: constructRecentChooserShowPrivate :: IsRecentChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.RecentChooser: constructRecentChooserShowTips :: (IsRecentChooser o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.RecentChooser: constructRecentChooserShowTips :: IsRecentChooser o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.RecentChooser: constructRecentChooserSortType :: (IsRecentChooser o) => RecentSortType -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.RecentChooser: constructRecentChooserSortType :: IsRecentChooser o => RecentSortType -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.RecentChooser: recentChooserGetUris :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m (([Text], Word64))

+ GI.Gtk.Interfaces.RecentChooser: recentChooserGetUris :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m ([Text], Word64)

- GI.Gtk.Interfaces.RecentChooser: recentChooserSetFilter :: (HasCallStack, MonadIO m, IsRecentChooser a, IsRecentFilter b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Interfaces.RecentChooser: recentChooserSetFilter :: (HasCallStack, MonadIO m, IsRecentChooser a, IsRecentFilter b) => a -> Maybe b -> m ()

- GI.Gtk.Interfaces.Scrollable: Scrollable :: (ManagedPtr Scrollable) -> Scrollable

+ GI.Gtk.Interfaces.Scrollable: Scrollable :: ManagedPtr Scrollable -> Scrollable

- GI.Gtk.Interfaces.Scrollable: constructScrollableHscrollPolicy :: (IsScrollable o) => ScrollablePolicy -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.Scrollable: constructScrollableHscrollPolicy :: IsScrollable o => ScrollablePolicy -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.Scrollable: constructScrollableVscrollPolicy :: (IsScrollable o) => ScrollablePolicy -> IO (GValueConstruct o)

+ GI.Gtk.Interfaces.Scrollable: constructScrollableVscrollPolicy :: IsScrollable o => ScrollablePolicy -> IO (GValueConstruct o)

- GI.Gtk.Interfaces.Scrollable: scrollableGetBorder :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m ((Bool, Border))

+ GI.Gtk.Interfaces.Scrollable: scrollableGetBorder :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m (Bool, Border)

- GI.Gtk.Interfaces.Scrollable: scrollableSetHadjustment :: (HasCallStack, MonadIO m, IsScrollable a, IsAdjustment b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Interfaces.Scrollable: scrollableSetHadjustment :: (HasCallStack, MonadIO m, IsScrollable a, IsAdjustment b) => a -> Maybe b -> m ()

- GI.Gtk.Interfaces.Scrollable: scrollableSetVadjustment :: (HasCallStack, MonadIO m, IsScrollable a, IsAdjustment b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Interfaces.Scrollable: scrollableSetVadjustment :: (HasCallStack, MonadIO m, IsScrollable a, IsAdjustment b) => a -> Maybe b -> m ()

- GI.Gtk.Interfaces.StyleProvider: StyleProvider :: (ManagedPtr StyleProvider) -> StyleProvider

+ GI.Gtk.Interfaces.StyleProvider: StyleProvider :: ManagedPtr StyleProvider -> StyleProvider

- GI.Gtk.Interfaces.StyleProvider: styleProviderGetStyleProperty :: (HasCallStack, MonadIO m, IsStyleProvider a) => a -> WidgetPath -> [StateFlags] -> GParamSpec -> m ((Bool, GValue))

+ GI.Gtk.Interfaces.StyleProvider: styleProviderGetStyleProperty :: (HasCallStack, MonadIO m, IsStyleProvider a) => a -> WidgetPath -> [StateFlags] -> GParamSpec -> m (Bool, GValue)

- GI.Gtk.Interfaces.ToolShell: ToolShell :: (ManagedPtr ToolShell) -> ToolShell

+ GI.Gtk.Interfaces.ToolShell: ToolShell :: ManagedPtr ToolShell -> ToolShell

- GI.Gtk.Interfaces.TreeDragDest: TreeDragDest :: (ManagedPtr TreeDragDest) -> TreeDragDest

+ GI.Gtk.Interfaces.TreeDragDest: TreeDragDest :: ManagedPtr TreeDragDest -> TreeDragDest

- GI.Gtk.Interfaces.TreeDragSource: TreeDragSource :: (ManagedPtr TreeDragSource) -> TreeDragSource

+ GI.Gtk.Interfaces.TreeDragSource: TreeDragSource :: ManagedPtr TreeDragSource -> TreeDragSource

- GI.Gtk.Interfaces.TreeModel: TreeModel :: (ManagedPtr TreeModel) -> TreeModel

+ GI.Gtk.Interfaces.TreeModel: TreeModel :: ManagedPtr TreeModel -> TreeModel

- GI.Gtk.Interfaces.TreeModel: treeModelFilterNew :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe (TreePath) -> m TreeModel

+ GI.Gtk.Interfaces.TreeModel: treeModelFilterNew :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreePath -> m TreeModel

- GI.Gtk.Interfaces.TreeModel: treeModelGetIter :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> m ((Bool, TreeIter))

+ GI.Gtk.Interfaces.TreeModel: treeModelGetIter :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> m (Bool, TreeIter)

- GI.Gtk.Interfaces.TreeModel: treeModelGetIterFirst :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m ((Bool, TreeIter))

+ GI.Gtk.Interfaces.TreeModel: treeModelGetIterFirst :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m (Bool, TreeIter)

- GI.Gtk.Interfaces.TreeModel: treeModelGetIterFromString :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Text -> m ((Bool, TreeIter))

+ GI.Gtk.Interfaces.TreeModel: treeModelGetIterFromString :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Text -> m (Bool, TreeIter)

- GI.Gtk.Interfaces.TreeModel: treeModelGetValue :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> Int32 -> m (GValue)

+ GI.Gtk.Interfaces.TreeModel: treeModelGetValue :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> Int32 -> m GValue

- GI.Gtk.Interfaces.TreeModel: treeModelIterChildren :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe (TreeIter) -> m ((Bool, TreeIter))

+ GI.Gtk.Interfaces.TreeModel: treeModelIterChildren :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreeIter -> m (Bool, TreeIter)

- GI.Gtk.Interfaces.TreeModel: treeModelIterNChildren :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe (TreeIter) -> m Int32

+ GI.Gtk.Interfaces.TreeModel: treeModelIterNChildren :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreeIter -> m Int32

- GI.Gtk.Interfaces.TreeModel: treeModelIterNthChild :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe (TreeIter) -> Int32 -> m ((Bool, TreeIter))

+ GI.Gtk.Interfaces.TreeModel: treeModelIterNthChild :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreeIter -> Int32 -> m (Bool, TreeIter)

- GI.Gtk.Interfaces.TreeModel: treeModelIterParent :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m ((Bool, TreeIter))

+ GI.Gtk.Interfaces.TreeModel: treeModelIterParent :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m (Bool, TreeIter)

- GI.Gtk.Interfaces.TreeModel: treeModelRowsReordered :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> Maybe (TreeIter) -> [Int32] -> m ()

+ GI.Gtk.Interfaces.TreeModel: treeModelRowsReordered :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> Maybe TreeIter -> [Int32] -> m ()

- GI.Gtk.Interfaces.TreeModel: type TreeModelRowChangedCallback = TreePath /@path@/: a 'GI.Gtk.Structs.TreePath.TreePath'-struct identifying the changed row -> TreeIter /@iter@/: a valid 'GI.Gtk.Structs.TreeIter.TreeIter'-struct pointing to the changed row -> IO ()

+ GI.Gtk.Interfaces.TreeModel: type TreeModelRowChangedCallback = TreePath " /@path@/: a 'GI.Gtk.Structs.TreePath.TreePath'-struct identifying the changed row " -> TreeIter " /@iter@/: a valid 'GI.Gtk.Structs.TreeIter.TreeIter'-struct pointing to the changed row " -> IO ()

- GI.Gtk.Interfaces.TreeModel: type TreeModelRowDeletedCallback = TreePath /@path@/: a 'GI.Gtk.Structs.TreePath.TreePath'-struct identifying the row -> IO ()

+ GI.Gtk.Interfaces.TreeModel: type TreeModelRowDeletedCallback = TreePath " /@path@/: a 'GI.Gtk.Structs.TreePath.TreePath'-struct identifying the row " -> IO ()

- GI.Gtk.Interfaces.TreeModel: type TreeModelRowHasChildToggledCallback = TreePath /@path@/: a 'GI.Gtk.Structs.TreePath.TreePath'-struct identifying the row -> TreeIter /@iter@/: a valid 'GI.Gtk.Structs.TreeIter.TreeIter'-struct pointing to the row -> IO ()

+ GI.Gtk.Interfaces.TreeModel: type TreeModelRowHasChildToggledCallback = TreePath " /@path@/: a 'GI.Gtk.Structs.TreePath.TreePath'-struct identifying the row " -> TreeIter " /@iter@/: a valid 'GI.Gtk.Structs.TreeIter.TreeIter'-struct pointing to the row " -> IO ()

- GI.Gtk.Interfaces.TreeModel: type TreeModelRowInsertedCallback = TreePath /@path@/: a 'GI.Gtk.Structs.TreePath.TreePath'-struct identifying the new row -> TreeIter /@iter@/: a valid 'GI.Gtk.Structs.TreeIter.TreeIter'-struct pointing to the new row -> IO ()

+ GI.Gtk.Interfaces.TreeModel: type TreeModelRowInsertedCallback = TreePath " /@path@/: a 'GI.Gtk.Structs.TreePath.TreePath'-struct identifying the new row " -> TreeIter " /@iter@/: a valid 'GI.Gtk.Structs.TreeIter.TreeIter'-struct pointing to the new row " -> IO ()

- GI.Gtk.Interfaces.TreeSortable: TreeSortable :: (ManagedPtr TreeSortable) -> TreeSortable

+ GI.Gtk.Interfaces.TreeSortable: TreeSortable :: ManagedPtr TreeSortable -> TreeSortable

- GI.Gtk.Interfaces.TreeSortable: treeSortableGetSortColumnId :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> m ((Bool, Int32, SortType))

+ GI.Gtk.Interfaces.TreeSortable: treeSortableGetSortColumnId :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> m (Bool, Int32, SortType)

- GI.Gtk.Objects.AboutDialog: AboutDialog :: (ManagedPtr AboutDialog) -> AboutDialog

+ GI.Gtk.Objects.AboutDialog: AboutDialog :: ManagedPtr AboutDialog -> AboutDialog

- GI.Gtk.Objects.AboutDialog: aboutDialogSetComments :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.AboutDialog: aboutDialogSetComments :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.AboutDialog: aboutDialogSetCopyright :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.AboutDialog: aboutDialogSetCopyright :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.AboutDialog: aboutDialogSetLicense :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.AboutDialog: aboutDialogSetLicense :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.AboutDialog: aboutDialogSetLogo :: (HasCallStack, MonadIO m, IsAboutDialog a, IsPixbuf b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.AboutDialog: aboutDialogSetLogo :: (HasCallStack, MonadIO m, IsAboutDialog a, IsPixbuf b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.AboutDialog: aboutDialogSetLogoIconName :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.AboutDialog: aboutDialogSetLogoIconName :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.AboutDialog: aboutDialogSetTranslatorCredits :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.AboutDialog: aboutDialogSetTranslatorCredits :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.AboutDialog: aboutDialogSetVersion :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.AboutDialog: aboutDialogSetVersion :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.AboutDialog: aboutDialogSetWebsite :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.AboutDialog: aboutDialogSetWebsite :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.AboutDialog: constructAboutDialogArtists :: (IsAboutDialog o) => [Text] -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AboutDialog: constructAboutDialogArtists :: IsAboutDialog o => [Text] -> IO (GValueConstruct o)

- GI.Gtk.Objects.AboutDialog: constructAboutDialogAuthors :: (IsAboutDialog o) => [Text] -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AboutDialog: constructAboutDialogAuthors :: IsAboutDialog o => [Text] -> IO (GValueConstruct o)

- GI.Gtk.Objects.AboutDialog: constructAboutDialogComments :: (IsAboutDialog o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AboutDialog: constructAboutDialogComments :: IsAboutDialog o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.AboutDialog: constructAboutDialogCopyright :: (IsAboutDialog o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AboutDialog: constructAboutDialogCopyright :: IsAboutDialog o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.AboutDialog: constructAboutDialogDocumenters :: (IsAboutDialog o) => [Text] -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AboutDialog: constructAboutDialogDocumenters :: IsAboutDialog o => [Text] -> IO (GValueConstruct o)

- GI.Gtk.Objects.AboutDialog: constructAboutDialogLicense :: (IsAboutDialog o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AboutDialog: constructAboutDialogLicense :: IsAboutDialog o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.AboutDialog: constructAboutDialogLicenseType :: (IsAboutDialog o) => License -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AboutDialog: constructAboutDialogLicenseType :: IsAboutDialog o => License -> IO (GValueConstruct o)

- GI.Gtk.Objects.AboutDialog: constructAboutDialogLogoIconName :: (IsAboutDialog o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AboutDialog: constructAboutDialogLogoIconName :: IsAboutDialog o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.AboutDialog: constructAboutDialogProgramName :: (IsAboutDialog o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AboutDialog: constructAboutDialogProgramName :: IsAboutDialog o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.AboutDialog: constructAboutDialogTranslatorCredits :: (IsAboutDialog o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AboutDialog: constructAboutDialogTranslatorCredits :: IsAboutDialog o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.AboutDialog: constructAboutDialogVersion :: (IsAboutDialog o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AboutDialog: constructAboutDialogVersion :: IsAboutDialog o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.AboutDialog: constructAboutDialogWebsite :: (IsAboutDialog o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AboutDialog: constructAboutDialogWebsite :: IsAboutDialog o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.AboutDialog: constructAboutDialogWebsiteLabel :: (IsAboutDialog o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AboutDialog: constructAboutDialogWebsiteLabel :: IsAboutDialog o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.AboutDialog: constructAboutDialogWrapLicense :: (IsAboutDialog o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AboutDialog: constructAboutDialogWrapLicense :: IsAboutDialog o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.AboutDialog: type AboutDialogActivateLinkCallback = Text /@uri@/: the URI that is activated -> IO Bool __Returns:__ 'True' if the link has been activated

+ GI.Gtk.Objects.AboutDialog: type AboutDialogActivateLinkCallback = Text " /@uri@/: the URI that is activated " -> IO Bool " __Returns:__ 'True' if the link has been activated "

- GI.Gtk.Objects.AccelGroup: AccelGroup :: (ManagedPtr AccelGroup) -> AccelGroup

+ GI.Gtk.Objects.AccelGroup: AccelGroup :: ManagedPtr AccelGroup -> AccelGroup

- GI.Gtk.Objects.AccelGroup: accelGroupDisconnect :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> Maybe (Closure) -> m Bool

+ GI.Gtk.Objects.AccelGroup: accelGroupDisconnect :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> Maybe Closure -> m Bool

- GI.Gtk.Objects.AccelGroup: type AccelGroupAccelActivateCallback = Object /@acceleratable@/: the object on which the accelerator was activated -> Word32 /@keyval@/: the accelerator keyval -> [ModifierType] /@modifier@/: the modifier combination of the accelerator -> IO Bool __Returns:__ 'True' if the accelerator was activated

+ GI.Gtk.Objects.AccelGroup: type AccelGroupAccelActivateCallback = Object " /@acceleratable@/: the object on which the accelerator was activated " -> Word32 " /@keyval@/: the accelerator keyval " -> [ModifierType] " /@modifier@/: the modifier combination of the accelerator " -> IO Bool " __Returns:__ 'True' if the accelerator was activated "

- GI.Gtk.Objects.AccelGroup: type AccelGroupAccelChangedCallback = Word32 /@keyval@/: the accelerator keyval -> [ModifierType] /@modifier@/: the modifier combination of the accelerator -> Closure /@accelClosure@/: the 'GI.GObject.Structs.Closure.Closure' of the accelerator -> IO ()

+ GI.Gtk.Objects.AccelGroup: type AccelGroupAccelChangedCallback = Word32 " /@keyval@/: the accelerator keyval " -> [ModifierType] " /@modifier@/: the modifier combination of the accelerator " -> Closure " /@accelClosure@/: the 'GI.GObject.Structs.Closure.Closure' of the accelerator " -> IO ()

- GI.Gtk.Objects.AccelLabel: AccelLabel :: (ManagedPtr AccelLabel) -> AccelLabel

+ GI.Gtk.Objects.AccelLabel: AccelLabel :: ManagedPtr AccelLabel -> AccelLabel

- GI.Gtk.Objects.AccelLabel: accelLabelGetAccel :: (HasCallStack, MonadIO m, IsAccelLabel a) => a -> m ((Word32, [ModifierType]))

+ GI.Gtk.Objects.AccelLabel: accelLabelGetAccel :: (HasCallStack, MonadIO m, IsAccelLabel a) => a -> m (Word32, [ModifierType])

- GI.Gtk.Objects.AccelLabel: accelLabelSetAccelClosure :: (HasCallStack, MonadIO m, IsAccelLabel a) => a -> Maybe (Closure) -> m ()

+ GI.Gtk.Objects.AccelLabel: accelLabelSetAccelClosure :: (HasCallStack, MonadIO m, IsAccelLabel a) => a -> Maybe Closure -> m ()

- GI.Gtk.Objects.AccelLabel: accelLabelSetAccelWidget :: (HasCallStack, MonadIO m, IsAccelLabel a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.AccelLabel: accelLabelSetAccelWidget :: (HasCallStack, MonadIO m, IsAccelLabel a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.AccelLabel: constructAccelLabelAccelClosure :: (IsAccelLabel o) => Closure -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AccelLabel: constructAccelLabelAccelClosure :: IsAccelLabel o => Closure -> IO (GValueConstruct o)

- GI.Gtk.Objects.AccelMap: AccelMap :: (ManagedPtr AccelMap) -> AccelMap

+ GI.Gtk.Objects.AccelMap: AccelMap :: ManagedPtr AccelMap -> AccelMap

- GI.Gtk.Objects.AccelMap: accelMapLookupEntry :: (HasCallStack, MonadIO m) => Text -> m ((Bool, AccelKey))

+ GI.Gtk.Objects.AccelMap: accelMapLookupEntry :: (HasCallStack, MonadIO m) => Text -> m (Bool, AccelKey)

- GI.Gtk.Objects.AccelMap: type AccelMapChangedCallback = Text /@accelPath@/: the path of the accelerator that changed -> Word32 /@accelKey@/: the key value for the new accelerator -> [ModifierType] /@accelMods@/: the modifier mask for the new accelerator -> IO ()

+ GI.Gtk.Objects.AccelMap: type AccelMapChangedCallback = Text " /@accelPath@/: the path of the accelerator that changed " -> Word32 " /@accelKey@/: the key value for the new accelerator " -> [ModifierType] " /@accelMods@/: the modifier mask for the new accelerator " -> IO ()

- GI.Gtk.Objects.Accessible: Accessible :: (ManagedPtr Accessible) -> Accessible

+ GI.Gtk.Objects.Accessible: Accessible :: ManagedPtr Accessible -> Accessible

- GI.Gtk.Objects.Accessible: accessibleSetWidget :: (HasCallStack, MonadIO m, IsAccessible a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Accessible: accessibleSetWidget :: (HasCallStack, MonadIO m, IsAccessible a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Action: Action :: (ManagedPtr Action) -> Action

+ GI.Gtk.Objects.Action: Action :: ManagedPtr Action -> Action

- GI.Gtk.Objects.Action: actionNew :: (HasCallStack, MonadIO m) => Text -> Maybe (Text) -> Maybe (Text) -> Maybe (Text) -> m Action

+ GI.Gtk.Objects.Action: actionNew :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> m Action

- GI.Gtk.Objects.Action: actionSetAccelGroup :: (HasCallStack, MonadIO m, IsAction a, IsAccelGroup b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Action: actionSetAccelGroup :: (HasCallStack, MonadIO m, IsAction a, IsAccelGroup b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Action: constructActionAlwaysShowImage :: (IsAction o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Action: constructActionAlwaysShowImage :: IsAction o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Action: constructActionHideIfEmpty :: (IsAction o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Action: constructActionHideIfEmpty :: IsAction o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Action: constructActionIconName :: (IsAction o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Action: constructActionIconName :: IsAction o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Action: constructActionIsImportant :: (IsAction o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Action: constructActionIsImportant :: IsAction o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Action: constructActionLabel :: (IsAction o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Action: constructActionLabel :: IsAction o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Action: constructActionName :: (IsAction o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Action: constructActionName :: IsAction o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Action: constructActionSensitive :: (IsAction o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Action: constructActionSensitive :: IsAction o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Action: constructActionShortLabel :: (IsAction o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Action: constructActionShortLabel :: IsAction o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Action: constructActionStockId :: (IsAction o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Action: constructActionStockId :: IsAction o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Action: constructActionTooltip :: (IsAction o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Action: constructActionTooltip :: IsAction o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Action: constructActionVisible :: (IsAction o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Action: constructActionVisible :: IsAction o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Action: constructActionVisibleHorizontal :: (IsAction o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Action: constructActionVisibleHorizontal :: IsAction o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Action: constructActionVisibleOverflown :: (IsAction o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Action: constructActionVisibleOverflown :: IsAction o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Action: constructActionVisibleVertical :: (IsAction o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Action: constructActionVisibleVertical :: IsAction o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ActionBar: ActionBar :: (ManagedPtr ActionBar) -> ActionBar

+ GI.Gtk.Objects.ActionBar: ActionBar :: ManagedPtr ActionBar -> ActionBar

- GI.Gtk.Objects.ActionBar: actionBarSetCenterWidget :: (HasCallStack, MonadIO m, IsActionBar a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.ActionBar: actionBarSetCenterWidget :: (HasCallStack, MonadIO m, IsActionBar a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.ActionGroup: ActionGroup :: (ManagedPtr ActionGroup) -> ActionGroup

+ GI.Gtk.Objects.ActionGroup: ActionGroup :: ManagedPtr ActionGroup -> ActionGroup

- GI.Gtk.Objects.ActionGroup: actionGroupAddActionWithAccel :: (HasCallStack, MonadIO m, IsActionGroup a, IsAction b) => a -> b -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.ActionGroup: actionGroupAddActionWithAccel :: (HasCallStack, MonadIO m, IsActionGroup a, IsAction b) => a -> b -> Maybe Text -> m ()

- GI.Gtk.Objects.ActionGroup: actionGroupSetAccelGroup :: (HasCallStack, MonadIO m, IsActionGroup a, IsAccelGroup b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.ActionGroup: actionGroupSetAccelGroup :: (HasCallStack, MonadIO m, IsActionGroup a, IsAccelGroup b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.ActionGroup: actionGroupSetTranslationDomain :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.ActionGroup: actionGroupSetTranslationDomain :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.ActionGroup: constructActionGroupName :: (IsActionGroup o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ActionGroup: constructActionGroupName :: IsActionGroup o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ActionGroup: constructActionGroupSensitive :: (IsActionGroup o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ActionGroup: constructActionGroupSensitive :: IsActionGroup o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ActionGroup: constructActionGroupVisible :: (IsActionGroup o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ActionGroup: constructActionGroupVisible :: IsActionGroup o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ActionGroup: type ActionGroupConnectProxyCallback = Action /@action@/: the action -> Widget /@proxy@/: the proxy -> IO ()

+ GI.Gtk.Objects.ActionGroup: type ActionGroupConnectProxyCallback = Action " /@action@/: the action " -> Widget " /@proxy@/: the proxy " -> IO ()

- GI.Gtk.Objects.ActionGroup: type ActionGroupDisconnectProxyCallback = Action /@action@/: the action -> Widget /@proxy@/: the proxy -> IO ()

+ GI.Gtk.Objects.ActionGroup: type ActionGroupDisconnectProxyCallback = Action " /@action@/: the action " -> Widget " /@proxy@/: the proxy " -> IO ()

- GI.Gtk.Objects.ActionGroup: type ActionGroupPostActivateCallback = Action /@action@/: the action -> IO ()

+ GI.Gtk.Objects.ActionGroup: type ActionGroupPostActivateCallback = Action " /@action@/: the action " -> IO ()

- GI.Gtk.Objects.ActionGroup: type ActionGroupPreActivateCallback = Action /@action@/: the action -> IO ()

+ GI.Gtk.Objects.ActionGroup: type ActionGroupPreActivateCallback = Action " /@action@/: the action " -> IO ()

- GI.Gtk.Objects.Adjustment: Adjustment :: (ManagedPtr Adjustment) -> Adjustment

+ GI.Gtk.Objects.Adjustment: Adjustment :: ManagedPtr Adjustment -> Adjustment

- GI.Gtk.Objects.Adjustment: constructAdjustmentLower :: (IsAdjustment o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Adjustment: constructAdjustmentLower :: IsAdjustment o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.Adjustment: constructAdjustmentPageIncrement :: (IsAdjustment o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Adjustment: constructAdjustmentPageIncrement :: IsAdjustment o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.Adjustment: constructAdjustmentPageSize :: (IsAdjustment o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Adjustment: constructAdjustmentPageSize :: IsAdjustment o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.Adjustment: constructAdjustmentStepIncrement :: (IsAdjustment o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Adjustment: constructAdjustmentStepIncrement :: IsAdjustment o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.Adjustment: constructAdjustmentUpper :: (IsAdjustment o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Adjustment: constructAdjustmentUpper :: IsAdjustment o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.Adjustment: constructAdjustmentValue :: (IsAdjustment o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Adjustment: constructAdjustmentValue :: IsAdjustment o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.Alignment: Alignment :: (ManagedPtr Alignment) -> Alignment

+ GI.Gtk.Objects.Alignment: Alignment :: ManagedPtr Alignment -> Alignment

- GI.Gtk.Objects.Alignment: alignmentGetPadding :: (HasCallStack, MonadIO m, IsAlignment a) => a -> m ((Word32, Word32, Word32, Word32))

+ GI.Gtk.Objects.Alignment: alignmentGetPadding :: (HasCallStack, MonadIO m, IsAlignment a) => a -> m (Word32, Word32, Word32, Word32)

- GI.Gtk.Objects.Alignment: constructAlignmentBottomPadding :: (IsAlignment o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Alignment: constructAlignmentBottomPadding :: IsAlignment o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Alignment: constructAlignmentLeftPadding :: (IsAlignment o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Alignment: constructAlignmentLeftPadding :: IsAlignment o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Alignment: constructAlignmentRightPadding :: (IsAlignment o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Alignment: constructAlignmentRightPadding :: IsAlignment o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Alignment: constructAlignmentTopPadding :: (IsAlignment o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Alignment: constructAlignmentTopPadding :: IsAlignment o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Alignment: constructAlignmentXalign :: (IsAlignment o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Alignment: constructAlignmentXalign :: IsAlignment o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.Alignment: constructAlignmentXscale :: (IsAlignment o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Alignment: constructAlignmentXscale :: IsAlignment o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.Alignment: constructAlignmentYalign :: (IsAlignment o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Alignment: constructAlignmentYalign :: IsAlignment o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.Alignment: constructAlignmentYscale :: (IsAlignment o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Alignment: constructAlignmentYscale :: IsAlignment o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.AppChooserButton: AppChooserButton :: (ManagedPtr AppChooserButton) -> AppChooserButton

+ GI.Gtk.Objects.AppChooserButton: AppChooserButton :: ManagedPtr AppChooserButton -> AppChooserButton

- GI.Gtk.Objects.AppChooserButton: constructAppChooserButtonHeading :: (IsAppChooserButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AppChooserButton: constructAppChooserButtonHeading :: IsAppChooserButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.AppChooserButton: constructAppChooserButtonShowDefaultItem :: (IsAppChooserButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AppChooserButton: constructAppChooserButtonShowDefaultItem :: IsAppChooserButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.AppChooserButton: constructAppChooserButtonShowDialogItem :: (IsAppChooserButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AppChooserButton: constructAppChooserButtonShowDialogItem :: IsAppChooserButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.AppChooserButton: type AppChooserButtonCustomItemActivatedCallback = Text /@itemName@/: the name of the activated item -> IO ()

+ GI.Gtk.Objects.AppChooserButton: type AppChooserButtonCustomItemActivatedCallback = Text " /@itemName@/: the name of the activated item " -> IO ()

- GI.Gtk.Objects.AppChooserDialog: AppChooserDialog :: (ManagedPtr AppChooserDialog) -> AppChooserDialog

+ GI.Gtk.Objects.AppChooserDialog: AppChooserDialog :: ManagedPtr AppChooserDialog -> AppChooserDialog

- GI.Gtk.Objects.AppChooserDialog: appChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a, IsFile b) => Maybe (a) -> [DialogFlags] -> b -> m AppChooserDialog

+ GI.Gtk.Objects.AppChooserDialog: appChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a, IsFile b) => Maybe a -> [DialogFlags] -> b -> m AppChooserDialog

- GI.Gtk.Objects.AppChooserDialog: appChooserDialogNewForContentType :: (HasCallStack, MonadIO m, IsWindow a) => Maybe (a) -> [DialogFlags] -> Text -> m AppChooserDialog

+ GI.Gtk.Objects.AppChooserDialog: appChooserDialogNewForContentType :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> [DialogFlags] -> Text -> m AppChooserDialog

- GI.Gtk.Objects.AppChooserDialog: constructAppChooserDialogHeading :: (IsAppChooserDialog o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AppChooserDialog: constructAppChooserDialogHeading :: IsAppChooserDialog o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.AppChooserWidget: AppChooserWidget :: (ManagedPtr AppChooserWidget) -> AppChooserWidget

+ GI.Gtk.Objects.AppChooserWidget: AppChooserWidget :: ManagedPtr AppChooserWidget -> AppChooserWidget

- GI.Gtk.Objects.AppChooserWidget: constructAppChooserWidgetDefaultText :: (IsAppChooserWidget o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AppChooserWidget: constructAppChooserWidgetDefaultText :: IsAppChooserWidget o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.AppChooserWidget: constructAppChooserWidgetShowAll :: (IsAppChooserWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AppChooserWidget: constructAppChooserWidgetShowAll :: IsAppChooserWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.AppChooserWidget: constructAppChooserWidgetShowDefault :: (IsAppChooserWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AppChooserWidget: constructAppChooserWidgetShowDefault :: IsAppChooserWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.AppChooserWidget: constructAppChooserWidgetShowFallback :: (IsAppChooserWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AppChooserWidget: constructAppChooserWidgetShowFallback :: IsAppChooserWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.AppChooserWidget: constructAppChooserWidgetShowOther :: (IsAppChooserWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AppChooserWidget: constructAppChooserWidgetShowOther :: IsAppChooserWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.AppChooserWidget: constructAppChooserWidgetShowRecommended :: (IsAppChooserWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AppChooserWidget: constructAppChooserWidgetShowRecommended :: IsAppChooserWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.AppChooserWidget: type AppChooserWidgetApplicationActivatedCallback = AppInfo /@application@/: the activated 'GI.Gio.Interfaces.AppInfo.AppInfo' -> IO ()

+ GI.Gtk.Objects.AppChooserWidget: type AppChooserWidgetApplicationActivatedCallback = AppInfo " /@application@/: the activated 'GI.Gio.Interfaces.AppInfo.AppInfo' " -> IO ()

- GI.Gtk.Objects.AppChooserWidget: type AppChooserWidgetApplicationSelectedCallback = AppInfo /@application@/: the selected 'GI.Gio.Interfaces.AppInfo.AppInfo' -> IO ()

+ GI.Gtk.Objects.AppChooserWidget: type AppChooserWidgetApplicationSelectedCallback = AppInfo " /@application@/: the selected 'GI.Gio.Interfaces.AppInfo.AppInfo' " -> IO ()

- GI.Gtk.Objects.AppChooserWidget: type AppChooserWidgetPopulatePopupCallback = Menu /@menu@/: the 'GI.Gtk.Objects.Menu.Menu' to populate -> AppInfo /@application@/: the current 'GI.Gio.Interfaces.AppInfo.AppInfo' -> IO ()

+ GI.Gtk.Objects.AppChooserWidget: type AppChooserWidgetPopulatePopupCallback = Menu " /@menu@/: the 'GI.Gtk.Objects.Menu.Menu' to populate " -> AppInfo " /@application@/: the current 'GI.Gio.Interfaces.AppInfo.AppInfo' " -> IO ()

- GI.Gtk.Objects.Application: Application :: (ManagedPtr Application) -> Application

+ GI.Gtk.Objects.Application: Application :: ManagedPtr Application -> Application

- GI.Gtk.Objects.Application: applicationAddAccelerator :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> Text -> Maybe (GVariant) -> m ()

+ GI.Gtk.Objects.Application: applicationAddAccelerator :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> Text -> Maybe GVariant -> m ()

- GI.Gtk.Objects.Application: applicationInhibit :: (HasCallStack, MonadIO m, IsApplication a, IsWindow b) => a -> Maybe (b) -> [ApplicationInhibitFlags] -> Maybe (Text) -> m Word32

+ GI.Gtk.Objects.Application: applicationInhibit :: (HasCallStack, MonadIO m, IsApplication a, IsWindow b) => a -> Maybe b -> [ApplicationInhibitFlags] -> Maybe Text -> m Word32

- GI.Gtk.Objects.Application: applicationNew :: (HasCallStack, MonadIO m) => Maybe (Text) -> [ApplicationFlags] -> m (Maybe Application)

+ GI.Gtk.Objects.Application: applicationNew :: (HasCallStack, MonadIO m) => Maybe Text -> [ApplicationFlags] -> m (Maybe Application)

- GI.Gtk.Objects.Application: applicationRemoveAccelerator :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> Maybe (GVariant) -> m ()

+ GI.Gtk.Objects.Application: applicationRemoveAccelerator :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> Maybe GVariant -> m ()

- GI.Gtk.Objects.Application: applicationSetAppMenu :: (HasCallStack, MonadIO m, IsApplication a, IsMenuModel b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Application: applicationSetAppMenu :: (HasCallStack, MonadIO m, IsApplication a, IsMenuModel b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Application: applicationSetMenubar :: (HasCallStack, MonadIO m, IsApplication a, IsMenuModel b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Application: applicationSetMenubar :: (HasCallStack, MonadIO m, IsApplication a, IsMenuModel b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Application: constructApplicationRegisterSession :: (IsApplication o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Application: constructApplicationRegisterSession :: IsApplication o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Application: type ApplicationWindowAddedCallback = Window /@window@/: the newly-added 'GI.Gtk.Objects.Window.Window' -> IO ()

+ GI.Gtk.Objects.Application: type ApplicationWindowAddedCallback = Window " /@window@/: the newly-added 'GI.Gtk.Objects.Window.Window' " -> IO ()

- GI.Gtk.Objects.Application: type ApplicationWindowRemovedCallback = Window /@window@/: the 'GI.Gtk.Objects.Window.Window' that is being removed -> IO ()

+ GI.Gtk.Objects.Application: type ApplicationWindowRemovedCallback = Window " /@window@/: the 'GI.Gtk.Objects.Window.Window' that is being removed " -> IO ()

- GI.Gtk.Objects.ApplicationWindow: ApplicationWindow :: (ManagedPtr ApplicationWindow) -> ApplicationWindow

+ GI.Gtk.Objects.ApplicationWindow: ApplicationWindow :: ManagedPtr ApplicationWindow -> ApplicationWindow

- GI.Gtk.Objects.ApplicationWindow: applicationWindowSetHelpOverlay :: (HasCallStack, MonadIO m, IsApplicationWindow a, IsShortcutsWindow b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.ApplicationWindow: applicationWindowSetHelpOverlay :: (HasCallStack, MonadIO m, IsApplicationWindow a, IsShortcutsWindow b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.ApplicationWindow: constructApplicationWindowShowMenubar :: (IsApplicationWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ApplicationWindow: constructApplicationWindowShowMenubar :: IsApplicationWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Arrow: Arrow :: (ManagedPtr Arrow) -> Arrow

+ GI.Gtk.Objects.Arrow: Arrow :: ManagedPtr Arrow -> Arrow

- GI.Gtk.Objects.Arrow: constructArrowArrowType :: (IsArrow o) => ArrowType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Arrow: constructArrowArrowType :: IsArrow o => ArrowType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Arrow: constructArrowShadowType :: (IsArrow o) => ShadowType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Arrow: constructArrowShadowType :: IsArrow o => ShadowType -> IO (GValueConstruct o)

- GI.Gtk.Objects.ArrowAccessible: ArrowAccessible :: (ManagedPtr ArrowAccessible) -> ArrowAccessible

+ GI.Gtk.Objects.ArrowAccessible: ArrowAccessible :: ManagedPtr ArrowAccessible -> ArrowAccessible

- GI.Gtk.Objects.AspectFrame: AspectFrame :: (ManagedPtr AspectFrame) -> AspectFrame

+ GI.Gtk.Objects.AspectFrame: AspectFrame :: ManagedPtr AspectFrame -> AspectFrame

- GI.Gtk.Objects.AspectFrame: aspectFrameNew :: (HasCallStack, MonadIO m) => Maybe (Text) -> Float -> Float -> Float -> Bool -> m AspectFrame

+ GI.Gtk.Objects.AspectFrame: aspectFrameNew :: (HasCallStack, MonadIO m) => Maybe Text -> Float -> Float -> Float -> Bool -> m AspectFrame

- GI.Gtk.Objects.AspectFrame: constructAspectFrameObeyChild :: (IsAspectFrame o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AspectFrame: constructAspectFrameObeyChild :: IsAspectFrame o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.AspectFrame: constructAspectFrameRatio :: (IsAspectFrame o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AspectFrame: constructAspectFrameRatio :: IsAspectFrame o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.AspectFrame: constructAspectFrameXalign :: (IsAspectFrame o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AspectFrame: constructAspectFrameXalign :: IsAspectFrame o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.AspectFrame: constructAspectFrameYalign :: (IsAspectFrame o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.AspectFrame: constructAspectFrameYalign :: IsAspectFrame o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.Assistant: Assistant :: (ManagedPtr Assistant) -> Assistant

+ GI.Gtk.Objects.Assistant: Assistant :: ManagedPtr Assistant -> Assistant

- GI.Gtk.Objects.Assistant: assistantSetForwardPageFunc :: (HasCallStack, MonadIO m, IsAssistant a) => a -> Maybe (AssistantPageFunc) -> m ()

+ GI.Gtk.Objects.Assistant: assistantSetForwardPageFunc :: (HasCallStack, MonadIO m, IsAssistant a) => a -> Maybe AssistantPageFunc -> m ()

- GI.Gtk.Objects.Assistant: assistantSetPageHeaderImage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b, IsPixbuf c) => a -> b -> Maybe (c) -> m ()

+ GI.Gtk.Objects.Assistant: assistantSetPageHeaderImage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b, IsPixbuf c) => a -> b -> Maybe c -> m ()

- GI.Gtk.Objects.Assistant: assistantSetPageSideImage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b, IsPixbuf c) => a -> b -> Maybe (c) -> m ()

+ GI.Gtk.Objects.Assistant: assistantSetPageSideImage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b, IsPixbuf c) => a -> b -> Maybe c -> m ()

- GI.Gtk.Objects.Assistant: constructAssistantUseHeaderBar :: (IsAssistant o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Assistant: constructAssistantUseHeaderBar :: IsAssistant o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Assistant: type AssistantPrepareCallback = Widget /@page@/: the current page -> IO ()

+ GI.Gtk.Objects.Assistant: type AssistantPrepareCallback = Widget " /@page@/: the current page " -> IO ()

- GI.Gtk.Objects.Bin: Bin :: (ManagedPtr Bin) -> Bin

+ GI.Gtk.Objects.Bin: Bin :: ManagedPtr Bin -> Bin

- GI.Gtk.Objects.BooleanCellAccessible: BooleanCellAccessible :: (ManagedPtr BooleanCellAccessible) -> BooleanCellAccessible

+ GI.Gtk.Objects.BooleanCellAccessible: BooleanCellAccessible :: ManagedPtr BooleanCellAccessible -> BooleanCellAccessible

- GI.Gtk.Objects.Box: Box :: (ManagedPtr Box) -> Box

+ GI.Gtk.Objects.Box: Box :: ManagedPtr Box -> Box

- GI.Gtk.Objects.Box: boxQueryChildPacking :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> b -> m ((Bool, Bool, Word32, PackType))

+ GI.Gtk.Objects.Box: boxQueryChildPacking :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> b -> m (Bool, Bool, Word32, PackType)

- GI.Gtk.Objects.Box: boxSetCenterWidget :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Box: boxSetCenterWidget :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Box: constructBoxBaselinePosition :: (IsBox o) => BaselinePosition -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Box: constructBoxBaselinePosition :: IsBox o => BaselinePosition -> IO (GValueConstruct o)

- GI.Gtk.Objects.Box: constructBoxHomogeneous :: (IsBox o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Box: constructBoxHomogeneous :: IsBox o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Box: constructBoxSpacing :: (IsBox o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Box: constructBoxSpacing :: IsBox o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Builder: Builder :: (ManagedPtr Builder) -> Builder

+ GI.Gtk.Objects.Builder: Builder :: ManagedPtr Builder -> Builder

- GI.Gtk.Objects.Builder: builderSetTranslationDomain :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Builder: builderSetTranslationDomain :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.Builder: builderValueFromString :: (HasCallStack, MonadIO m, IsBuilder a) => a -> GParamSpec -> Text -> m (GValue)

+ GI.Gtk.Objects.Builder: builderValueFromString :: (HasCallStack, MonadIO m, IsBuilder a) => a -> GParamSpec -> Text -> m GValue

- GI.Gtk.Objects.Builder: builderValueFromStringType :: (HasCallStack, MonadIO m, IsBuilder a) => a -> GType -> Text -> m (GValue)

+ GI.Gtk.Objects.Builder: builderValueFromStringType :: (HasCallStack, MonadIO m, IsBuilder a) => a -> GType -> Text -> m GValue

- GI.Gtk.Objects.Builder: constructBuilderTranslationDomain :: (IsBuilder o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Builder: constructBuilderTranslationDomain :: IsBuilder o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Button: Button :: (ManagedPtr Button) -> Button

+ GI.Gtk.Objects.Button: Button :: ManagedPtr Button -> Button

- GI.Gtk.Objects.Button: buttonGetAlignment :: (HasCallStack, MonadIO m, IsButton a) => a -> m ((Float, Float))

+ GI.Gtk.Objects.Button: buttonGetAlignment :: (HasCallStack, MonadIO m, IsButton a) => a -> m (Float, Float)

- GI.Gtk.Objects.Button: buttonNewFromIconName :: (HasCallStack, MonadIO m) => Maybe (Text) -> Int32 -> m Button

+ GI.Gtk.Objects.Button: buttonNewFromIconName :: (HasCallStack, MonadIO m) => Maybe Text -> Int32 -> m Button

- GI.Gtk.Objects.Button: buttonSetImage :: (HasCallStack, MonadIO m, IsButton a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Button: buttonSetImage :: (HasCallStack, MonadIO m, IsButton a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Button: constructButtonAlwaysShowImage :: (IsButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Button: constructButtonAlwaysShowImage :: IsButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Button: constructButtonImagePosition :: (IsButton o) => PositionType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Button: constructButtonImagePosition :: IsButton o => PositionType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Button: constructButtonLabel :: (IsButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Button: constructButtonLabel :: IsButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Button: constructButtonRelief :: (IsButton o) => ReliefStyle -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Button: constructButtonRelief :: IsButton o => ReliefStyle -> IO (GValueConstruct o)

- GI.Gtk.Objects.Button: constructButtonUseStock :: (IsButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Button: constructButtonUseStock :: IsButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Button: constructButtonUseUnderline :: (IsButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Button: constructButtonUseUnderline :: IsButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Button: constructButtonXalign :: (IsButton o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Button: constructButtonXalign :: IsButton o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.Button: constructButtonYalign :: (IsButton o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Button: constructButtonYalign :: IsButton o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.ButtonAccessible: ButtonAccessible :: (ManagedPtr ButtonAccessible) -> ButtonAccessible

+ GI.Gtk.Objects.ButtonAccessible: ButtonAccessible :: ManagedPtr ButtonAccessible -> ButtonAccessible

- GI.Gtk.Objects.ButtonBox: ButtonBox :: (ManagedPtr ButtonBox) -> ButtonBox

+ GI.Gtk.Objects.ButtonBox: ButtonBox :: ManagedPtr ButtonBox -> ButtonBox

- GI.Gtk.Objects.ButtonBox: constructButtonBoxLayoutStyle :: (IsButtonBox o) => ButtonBoxStyle -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ButtonBox: constructButtonBoxLayoutStyle :: IsButtonBox o => ButtonBoxStyle -> IO (GValueConstruct o)

- GI.Gtk.Objects.Calendar: Calendar :: (ManagedPtr Calendar) -> Calendar

+ GI.Gtk.Objects.Calendar: Calendar :: ManagedPtr Calendar -> Calendar

- GI.Gtk.Objects.Calendar: calendarGetDate :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m ((Word32, Word32, Word32))

+ GI.Gtk.Objects.Calendar: calendarGetDate :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m (Word32, Word32, Word32)

- GI.Gtk.Objects.Calendar: constructCalendarDay :: (IsCalendar o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Calendar: constructCalendarDay :: IsCalendar o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Calendar: constructCalendarDetailHeightRows :: (IsCalendar o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Calendar: constructCalendarDetailHeightRows :: IsCalendar o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Calendar: constructCalendarDetailWidthChars :: (IsCalendar o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Calendar: constructCalendarDetailWidthChars :: IsCalendar o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Calendar: constructCalendarMonth :: (IsCalendar o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Calendar: constructCalendarMonth :: IsCalendar o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Calendar: constructCalendarNoMonthChange :: (IsCalendar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Calendar: constructCalendarNoMonthChange :: IsCalendar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Calendar: constructCalendarShowDayNames :: (IsCalendar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Calendar: constructCalendarShowDayNames :: IsCalendar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Calendar: constructCalendarShowDetails :: (IsCalendar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Calendar: constructCalendarShowDetails :: IsCalendar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Calendar: constructCalendarShowHeading :: (IsCalendar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Calendar: constructCalendarShowHeading :: IsCalendar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Calendar: constructCalendarShowWeekNumbers :: (IsCalendar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Calendar: constructCalendarShowWeekNumbers :: IsCalendar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Calendar: constructCalendarYear :: (IsCalendar o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Calendar: constructCalendarYear :: IsCalendar o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellAccessible: CellAccessible :: (ManagedPtr CellAccessible) -> CellAccessible

+ GI.Gtk.Objects.CellAccessible: CellAccessible :: ManagedPtr CellAccessible -> CellAccessible

- GI.Gtk.Objects.CellArea: CellArea :: (ManagedPtr CellArea) -> CellArea

+ GI.Gtk.Objects.CellArea: CellArea :: ManagedPtr CellArea -> CellArea

- GI.Gtk.Objects.CellArea: cellAreaGetCellAllocation :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c, IsCellRenderer d) => a -> b -> c -> d -> Rectangle -> m (Rectangle)

+ GI.Gtk.Objects.CellArea: cellAreaGetCellAllocation :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c, IsCellRenderer d) => a -> b -> c -> d -> Rectangle -> m Rectangle

- GI.Gtk.Objects.CellArea: cellAreaGetCellAtPosition :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Rectangle -> Int32 -> Int32 -> m ((CellRenderer, Rectangle))

+ GI.Gtk.Objects.CellArea: cellAreaGetCellAtPosition :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Rectangle -> Int32 -> Int32 -> m (CellRenderer, Rectangle)

- GI.Gtk.Objects.CellArea: cellAreaGetPreferredHeight :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellArea: cellAreaGetPreferredHeight :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> m (Int32, Int32)

- GI.Gtk.Objects.CellArea: cellAreaGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellArea: cellAreaGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.CellArea: cellAreaGetPreferredWidth :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellArea: cellAreaGetPreferredWidth :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> m (Int32, Int32)

- GI.Gtk.Objects.CellArea: cellAreaGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellArea: cellAreaGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.CellArea: cellAreaInnerCellArea :: (HasCallStack, MonadIO m, IsCellArea a, IsWidget b) => a -> b -> Rectangle -> m (Rectangle)

+ GI.Gtk.Objects.CellArea: cellAreaInnerCellArea :: (HasCallStack, MonadIO m, IsCellArea a, IsWidget b) => a -> b -> Rectangle -> m Rectangle

- GI.Gtk.Objects.CellArea: cellAreaRequestRenderer :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b, IsWidget c) => a -> b -> Orientation -> c -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellArea: cellAreaRequestRenderer :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b, IsWidget c) => a -> b -> Orientation -> c -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.CellArea: type CellAreaAddEditableCallback = CellRenderer /@renderer@/: the 'GI.Gtk.Objects.CellRenderer.CellRenderer' that started the edited -> CellEditable /@editable@/: the 'GI.Gtk.Interfaces.CellEditable.CellEditable' widget to add -> Rectangle /@cellArea@/: the 'GI.Gtk.Objects.Widget.Widget' relative 'GI.Gdk.Structs.Rectangle.Rectangle' coordinates where /@editable@/ should be added -> Text /@path@/: the 'GI.Gtk.Structs.TreePath.TreePath' string this edit was initiated for -> IO ()

+ GI.Gtk.Objects.CellArea: type CellAreaAddEditableCallback = CellRenderer " /@renderer@/: the 'GI.Gtk.Objects.CellRenderer.CellRenderer' that started the edited " -> CellEditable " /@editable@/: the 'GI.Gtk.Interfaces.CellEditable.CellEditable' widget to add " -> Rectangle " /@cellArea@/: the 'GI.Gtk.Objects.Widget.Widget' relative 'GI.Gdk.Structs.Rectangle.Rectangle' coordinates where /@editable@/ should be added " -> Text " /@path@/: the 'GI.Gtk.Structs.TreePath.TreePath' string this edit was initiated for " -> IO ()

- GI.Gtk.Objects.CellArea: type CellAreaApplyAttributesCallback = TreeModel /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' to apply the attributes from -> TreeIter /@iter@/: the 'GI.Gtk.Structs.TreeIter.TreeIter' indicating which row to apply the attributes of -> Bool /@isExpander@/: whether the view shows children for this row -> Bool /@isExpanded@/: whether the view is currently showing the children of this row -> IO ()

+ GI.Gtk.Objects.CellArea: type CellAreaApplyAttributesCallback = TreeModel " /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' to apply the attributes from " -> TreeIter " /@iter@/: the 'GI.Gtk.Structs.TreeIter.TreeIter' indicating which row to apply the attributes of " -> Bool " /@isExpander@/: whether the view shows children for this row " -> Bool " /@isExpanded@/: whether the view is currently showing the children of this row " -> IO ()

- GI.Gtk.Objects.CellArea: type CellAreaFocusChangedCallback = CellRenderer /@renderer@/: the 'GI.Gtk.Objects.CellRenderer.CellRenderer' that has focus -> Text /@path@/: the current 'GI.Gtk.Structs.TreePath.TreePath' string set for /@area@/ -> IO ()

+ GI.Gtk.Objects.CellArea: type CellAreaFocusChangedCallback = CellRenderer " /@renderer@/: the 'GI.Gtk.Objects.CellRenderer.CellRenderer' that has focus " -> Text " /@path@/: the current 'GI.Gtk.Structs.TreePath.TreePath' string set for /@area@/ " -> IO ()

- GI.Gtk.Objects.CellArea: type CellAreaRemoveEditableCallback = CellRenderer /@renderer@/: the 'GI.Gtk.Objects.CellRenderer.CellRenderer' that finished editeding -> CellEditable /@editable@/: the 'GI.Gtk.Interfaces.CellEditable.CellEditable' widget to remove -> IO ()

+ GI.Gtk.Objects.CellArea: type CellAreaRemoveEditableCallback = CellRenderer " /@renderer@/: the 'GI.Gtk.Objects.CellRenderer.CellRenderer' that finished editeding " -> CellEditable " /@editable@/: the 'GI.Gtk.Interfaces.CellEditable.CellEditable' widget to remove " -> IO ()

- GI.Gtk.Objects.CellAreaBox: CellAreaBox :: (ManagedPtr CellAreaBox) -> CellAreaBox

+ GI.Gtk.Objects.CellAreaBox: CellAreaBox :: ManagedPtr CellAreaBox -> CellAreaBox

- GI.Gtk.Objects.CellAreaBox: constructCellAreaBoxSpacing :: (IsCellAreaBox o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellAreaBox: constructCellAreaBoxSpacing :: IsCellAreaBox o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellAreaContext: CellAreaContext :: (ManagedPtr CellAreaContext) -> CellAreaContext

+ GI.Gtk.Objects.CellAreaContext: CellAreaContext :: ManagedPtr CellAreaContext -> CellAreaContext

- GI.Gtk.Objects.CellAreaContext: cellAreaContextGetAllocation :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellAreaContext: cellAreaContextGetAllocation :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.CellAreaContext: cellAreaContextGetPreferredHeight :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellAreaContext: cellAreaContextGetPreferredHeight :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.CellAreaContext: cellAreaContextGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellAreaContext: cellAreaContextGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.CellAreaContext: cellAreaContextGetPreferredWidth :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellAreaContext: cellAreaContextGetPreferredWidth :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.CellAreaContext: cellAreaContextGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellAreaContext: cellAreaContextGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.CellRenderer: CellRenderer :: (ManagedPtr CellRenderer) -> CellRenderer

+ GI.Gtk.Objects.CellRenderer: CellRenderer :: ManagedPtr CellRenderer -> CellRenderer

- GI.Gtk.Objects.CellRenderer: cellRendererGetAlignedArea :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> [CellRendererState] -> Rectangle -> m (Rectangle)

+ GI.Gtk.Objects.CellRenderer: cellRendererGetAlignedArea :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> [CellRendererState] -> Rectangle -> m Rectangle

- GI.Gtk.Objects.CellRenderer: cellRendererGetAlignment :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m ((Float, Float))

+ GI.Gtk.Objects.CellRenderer: cellRendererGetAlignment :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m (Float, Float)

- GI.Gtk.Objects.CellRenderer: cellRendererGetFixedSize :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellRenderer: cellRendererGetFixedSize :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.CellRenderer: cellRendererGetPadding :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellRenderer: cellRendererGetPadding :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.CellRenderer: cellRendererGetPreferredHeight :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellRenderer: cellRendererGetPreferredHeight :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> m (Int32, Int32)

- GI.Gtk.Objects.CellRenderer: cellRendererGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellRenderer: cellRendererGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.CellRenderer: cellRendererGetPreferredSize :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> m ((Requisition, Requisition))

+ GI.Gtk.Objects.CellRenderer: cellRendererGetPreferredSize :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> m (Requisition, Requisition)

- GI.Gtk.Objects.CellRenderer: cellRendererGetPreferredWidth :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellRenderer: cellRendererGetPreferredWidth :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> m (Int32, Int32)

- GI.Gtk.Objects.CellRenderer: cellRendererGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.CellRenderer: cellRendererGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.CellRenderer: cellRendererGetSize :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> Maybe (Rectangle) -> m ((Int32, Int32, Int32, Int32))

+ GI.Gtk.Objects.CellRenderer: cellRendererGetSize :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> Maybe Rectangle -> m (Int32, Int32, Int32, Int32)

- GI.Gtk.Objects.CellRenderer: cellRendererGetState :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> Maybe (b) -> [CellRendererState] -> m [StateFlags]

+ GI.Gtk.Objects.CellRenderer: cellRendererGetState :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> Maybe b -> [CellRendererState] -> m [StateFlags]

- GI.Gtk.Objects.CellRenderer: cellRendererStartEditing :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> Maybe (Event) -> b -> Text -> Rectangle -> Rectangle -> [CellRendererState] -> m (Maybe CellEditable)

+ GI.Gtk.Objects.CellRenderer: cellRendererStartEditing :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> Maybe Event -> b -> Text -> Rectangle -> Rectangle -> [CellRendererState] -> m (Maybe CellEditable)

- GI.Gtk.Objects.CellRenderer: constructCellRendererCellBackground :: (IsCellRenderer o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererCellBackground :: IsCellRenderer o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: constructCellRendererCellBackgroundGdk :: (IsCellRenderer o) => Color -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererCellBackgroundGdk :: IsCellRenderer o => Color -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: constructCellRendererCellBackgroundRgba :: (IsCellRenderer o) => RGBA -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererCellBackgroundRgba :: IsCellRenderer o => RGBA -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: constructCellRendererCellBackgroundSet :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererCellBackgroundSet :: IsCellRenderer o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: constructCellRendererHeight :: (IsCellRenderer o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererHeight :: IsCellRenderer o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: constructCellRendererIsExpanded :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererIsExpanded :: IsCellRenderer o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: constructCellRendererIsExpander :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererIsExpander :: IsCellRenderer o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: constructCellRendererMode :: (IsCellRenderer o) => CellRendererMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererMode :: IsCellRenderer o => CellRendererMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: constructCellRendererSensitive :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererSensitive :: IsCellRenderer o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: constructCellRendererVisible :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererVisible :: IsCellRenderer o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: constructCellRendererWidth :: (IsCellRenderer o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererWidth :: IsCellRenderer o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: constructCellRendererXalign :: (IsCellRenderer o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererXalign :: IsCellRenderer o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: constructCellRendererXpad :: (IsCellRenderer o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererXpad :: IsCellRenderer o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: constructCellRendererYalign :: (IsCellRenderer o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererYalign :: IsCellRenderer o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: constructCellRendererYpad :: (IsCellRenderer o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRenderer: constructCellRendererYpad :: IsCellRenderer o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRenderer: type CellRendererEditingStartedCallback = CellEditable /@editable@/: the 'GI.Gtk.Interfaces.CellEditable.CellEditable' -> Text /@path@/: the path identifying the edited cell -> IO ()

+ GI.Gtk.Objects.CellRenderer: type CellRendererEditingStartedCallback = CellEditable " /@editable@/: the 'GI.Gtk.Interfaces.CellEditable.CellEditable' " -> Text " /@path@/: the path identifying the edited cell " -> IO ()

- GI.Gtk.Objects.CellRendererAccel: CellRendererAccel :: (ManagedPtr CellRendererAccel) -> CellRendererAccel

+ GI.Gtk.Objects.CellRendererAccel: CellRendererAccel :: ManagedPtr CellRendererAccel -> CellRendererAccel

- GI.Gtk.Objects.CellRendererAccel: constructCellRendererAccelAccelKey :: (IsCellRendererAccel o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererAccel: constructCellRendererAccelAccelKey :: IsCellRendererAccel o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererAccel: constructCellRendererAccelAccelMode :: (IsCellRendererAccel o) => CellRendererAccelMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererAccel: constructCellRendererAccelAccelMode :: IsCellRendererAccel o => CellRendererAccelMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererAccel: constructCellRendererAccelAccelMods :: (IsCellRendererAccel o) => [ModifierType] -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererAccel: constructCellRendererAccelAccelMods :: IsCellRendererAccel o => [ModifierType] -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererAccel: constructCellRendererAccelKeycode :: (IsCellRendererAccel o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererAccel: constructCellRendererAccelKeycode :: IsCellRendererAccel o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererAccel: type CellRendererAccelAccelClearedCallback = Text /@pathString@/: the path identifying the row of the edited cell -> IO ()

+ GI.Gtk.Objects.CellRendererAccel: type CellRendererAccelAccelClearedCallback = Text " /@pathString@/: the path identifying the row of the edited cell " -> IO ()

- GI.Gtk.Objects.CellRendererAccel: type CellRendererAccelAccelEditedCallback = Text /@pathString@/: the path identifying the row of the edited cell -> Word32 /@accelKey@/: the new accelerator keyval -> [ModifierType] /@accelMods@/: the new acclerator modifier mask -> Word32 /@hardwareKeycode@/: the keycode of the new accelerator -> IO ()

+ GI.Gtk.Objects.CellRendererAccel: type CellRendererAccelAccelEditedCallback = Text " /@pathString@/: the path identifying the row of the edited cell " -> Word32 " /@accelKey@/: the new accelerator keyval " -> [ModifierType] " /@accelMods@/: the new acclerator modifier mask " -> Word32 " /@hardwareKeycode@/: the keycode of the new accelerator " -> IO ()

- GI.Gtk.Objects.CellRendererCombo: CellRendererCombo :: (ManagedPtr CellRendererCombo) -> CellRendererCombo

+ GI.Gtk.Objects.CellRendererCombo: CellRendererCombo :: ManagedPtr CellRendererCombo -> CellRendererCombo

- GI.Gtk.Objects.CellRendererCombo: constructCellRendererComboHasEntry :: (IsCellRendererCombo o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererCombo: constructCellRendererComboHasEntry :: IsCellRendererCombo o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererCombo: constructCellRendererComboTextColumn :: (IsCellRendererCombo o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererCombo: constructCellRendererComboTextColumn :: IsCellRendererCombo o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererCombo: type CellRendererComboChangedCallback = Text /@pathString@/: a string of the path identifying the edited cell (relative to the tree view model) -> TreeIter /@newIter@/: the new iter selected in the combo box (relative to the combo box model) -> IO ()

+ GI.Gtk.Objects.CellRendererCombo: type CellRendererComboChangedCallback = Text " /@pathString@/: a string of the path identifying the edited cell (relative to the tree view model) " -> TreeIter " /@newIter@/: the new iter selected in the combo box (relative to the combo box model) " -> IO ()

- GI.Gtk.Objects.CellRendererPixbuf: CellRendererPixbuf :: (ManagedPtr CellRendererPixbuf) -> CellRendererPixbuf

+ GI.Gtk.Objects.CellRendererPixbuf: CellRendererPixbuf :: ManagedPtr CellRendererPixbuf -> CellRendererPixbuf

- GI.Gtk.Objects.CellRendererPixbuf: constructCellRendererPixbufFollowState :: (IsCellRendererPixbuf o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererPixbuf: constructCellRendererPixbufFollowState :: IsCellRendererPixbuf o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererPixbuf: constructCellRendererPixbufIconName :: (IsCellRendererPixbuf o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererPixbuf: constructCellRendererPixbufIconName :: IsCellRendererPixbuf o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererPixbuf: constructCellRendererPixbufStockDetail :: (IsCellRendererPixbuf o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererPixbuf: constructCellRendererPixbufStockDetail :: IsCellRendererPixbuf o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererPixbuf: constructCellRendererPixbufStockId :: (IsCellRendererPixbuf o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererPixbuf: constructCellRendererPixbufStockId :: IsCellRendererPixbuf o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererPixbuf: constructCellRendererPixbufStockSize :: (IsCellRendererPixbuf o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererPixbuf: constructCellRendererPixbufStockSize :: IsCellRendererPixbuf o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererPixbuf: constructCellRendererPixbufSurface :: (IsCellRendererPixbuf o) => Surface -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererPixbuf: constructCellRendererPixbufSurface :: IsCellRendererPixbuf o => Surface -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererProgress: CellRendererProgress :: (ManagedPtr CellRendererProgress) -> CellRendererProgress

+ GI.Gtk.Objects.CellRendererProgress: CellRendererProgress :: ManagedPtr CellRendererProgress -> CellRendererProgress

- GI.Gtk.Objects.CellRendererProgress: constructCellRendererProgressInverted :: (IsCellRendererProgress o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererProgress: constructCellRendererProgressInverted :: IsCellRendererProgress o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererProgress: constructCellRendererProgressPulse :: (IsCellRendererProgress o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererProgress: constructCellRendererProgressPulse :: IsCellRendererProgress o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererProgress: constructCellRendererProgressText :: (IsCellRendererProgress o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererProgress: constructCellRendererProgressText :: IsCellRendererProgress o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererProgress: constructCellRendererProgressTextXalign :: (IsCellRendererProgress o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererProgress: constructCellRendererProgressTextXalign :: IsCellRendererProgress o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererProgress: constructCellRendererProgressTextYalign :: (IsCellRendererProgress o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererProgress: constructCellRendererProgressTextYalign :: IsCellRendererProgress o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererProgress: constructCellRendererProgressValue :: (IsCellRendererProgress o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererProgress: constructCellRendererProgressValue :: IsCellRendererProgress o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererSpin: CellRendererSpin :: (ManagedPtr CellRendererSpin) -> CellRendererSpin

+ GI.Gtk.Objects.CellRendererSpin: CellRendererSpin :: ManagedPtr CellRendererSpin -> CellRendererSpin

- GI.Gtk.Objects.CellRendererSpin: constructCellRendererSpinClimbRate :: (IsCellRendererSpin o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererSpin: constructCellRendererSpinClimbRate :: IsCellRendererSpin o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererSpin: constructCellRendererSpinDigits :: (IsCellRendererSpin o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererSpin: constructCellRendererSpinDigits :: IsCellRendererSpin o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererSpinner: CellRendererSpinner :: (ManagedPtr CellRendererSpinner) -> CellRendererSpinner

+ GI.Gtk.Objects.CellRendererSpinner: CellRendererSpinner :: ManagedPtr CellRendererSpinner -> CellRendererSpinner

- GI.Gtk.Objects.CellRendererSpinner: constructCellRendererSpinnerActive :: (IsCellRendererSpinner o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererSpinner: constructCellRendererSpinnerActive :: IsCellRendererSpinner o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererSpinner: constructCellRendererSpinnerPulse :: (IsCellRendererSpinner o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererSpinner: constructCellRendererSpinnerPulse :: IsCellRendererSpinner o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererSpinner: constructCellRendererSpinnerSize :: (IsCellRendererSpinner o) => IconSize -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererSpinner: constructCellRendererSpinnerSize :: IsCellRendererSpinner o => IconSize -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: CellRendererText :: (ManagedPtr CellRendererText) -> CellRendererText

+ GI.Gtk.Objects.CellRendererText: CellRendererText :: ManagedPtr CellRendererText -> CellRendererText

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextAlignSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextAlignSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextAlignment :: (IsCellRendererText o) => Alignment -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextAlignment :: IsCellRendererText o => Alignment -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextAttributes :: (IsCellRendererText o) => AttrList -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextAttributes :: IsCellRendererText o => AttrList -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextBackground :: (IsCellRendererText o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextBackground :: IsCellRendererText o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextBackgroundGdk :: (IsCellRendererText o) => Color -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextBackgroundGdk :: IsCellRendererText o => Color -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextBackgroundRgba :: (IsCellRendererText o) => RGBA -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextBackgroundRgba :: IsCellRendererText o => RGBA -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextBackgroundSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextBackgroundSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextEditable :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextEditable :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextEditableSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextEditableSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextEllipsize :: (IsCellRendererText o) => EllipsizeMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextEllipsize :: IsCellRendererText o => EllipsizeMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextEllipsizeSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextEllipsizeSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextFamily :: (IsCellRendererText o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextFamily :: IsCellRendererText o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextFamilySet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextFamilySet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextFont :: (IsCellRendererText o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextFont :: IsCellRendererText o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextFontDesc :: (IsCellRendererText o) => FontDescription -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextFontDesc :: IsCellRendererText o => FontDescription -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextForeground :: (IsCellRendererText o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextForeground :: IsCellRendererText o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextForegroundGdk :: (IsCellRendererText o) => Color -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextForegroundGdk :: IsCellRendererText o => Color -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextForegroundRgba :: (IsCellRendererText o) => RGBA -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextForegroundRgba :: IsCellRendererText o => RGBA -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextForegroundSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextForegroundSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextLanguage :: (IsCellRendererText o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextLanguage :: IsCellRendererText o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextLanguageSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextLanguageSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextMarkup :: (IsCellRendererText o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextMarkup :: IsCellRendererText o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextMaxWidthChars :: (IsCellRendererText o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextMaxWidthChars :: IsCellRendererText o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextPlaceholderText :: (IsCellRendererText o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextPlaceholderText :: IsCellRendererText o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextRise :: (IsCellRendererText o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextRise :: IsCellRendererText o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextRiseSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextRiseSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextScale :: (IsCellRendererText o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextScale :: IsCellRendererText o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextScaleSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextScaleSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextSingleParagraphMode :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextSingleParagraphMode :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextSize :: (IsCellRendererText o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextSize :: IsCellRendererText o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextSizePoints :: (IsCellRendererText o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextSizePoints :: IsCellRendererText o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextSizeSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextSizeSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextStretch :: (IsCellRendererText o) => Stretch -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextStretch :: IsCellRendererText o => Stretch -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextStretchSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextStretchSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextStrikethrough :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextStrikethrough :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextStrikethroughSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextStrikethroughSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextStyle :: (IsCellRendererText o) => Style -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextStyle :: IsCellRendererText o => Style -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextStyleSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextStyleSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextText :: (IsCellRendererText o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextText :: IsCellRendererText o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextUnderline :: (IsCellRendererText o) => Underline -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextUnderline :: IsCellRendererText o => Underline -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextUnderlineSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextUnderlineSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextVariant :: (IsCellRendererText o) => Variant -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextVariant :: IsCellRendererText o => Variant -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextVariantSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextVariantSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextWeight :: (IsCellRendererText o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextWeight :: IsCellRendererText o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextWeightSet :: (IsCellRendererText o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextWeightSet :: IsCellRendererText o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextWidthChars :: (IsCellRendererText o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextWidthChars :: IsCellRendererText o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextWrapMode :: (IsCellRendererText o) => WrapMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextWrapMode :: IsCellRendererText o => WrapMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: constructCellRendererTextWrapWidth :: (IsCellRendererText o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererText: constructCellRendererTextWrapWidth :: IsCellRendererText o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererText: type CellRendererTextEditedCallback = Text /@path@/: the path identifying the edited cell -> Text /@newText@/: the new text -> IO ()

+ GI.Gtk.Objects.CellRendererText: type CellRendererTextEditedCallback = Text " /@path@/: the path identifying the edited cell " -> Text " /@newText@/: the new text " -> IO ()

- GI.Gtk.Objects.CellRendererToggle: CellRendererToggle :: (ManagedPtr CellRendererToggle) -> CellRendererToggle

+ GI.Gtk.Objects.CellRendererToggle: CellRendererToggle :: ManagedPtr CellRendererToggle -> CellRendererToggle

- GI.Gtk.Objects.CellRendererToggle: constructCellRendererToggleActivatable :: (IsCellRendererToggle o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererToggle: constructCellRendererToggleActivatable :: IsCellRendererToggle o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererToggle: constructCellRendererToggleActive :: (IsCellRendererToggle o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererToggle: constructCellRendererToggleActive :: IsCellRendererToggle o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererToggle: constructCellRendererToggleInconsistent :: (IsCellRendererToggle o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererToggle: constructCellRendererToggleInconsistent :: IsCellRendererToggle o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererToggle: constructCellRendererToggleIndicatorSize :: (IsCellRendererToggle o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererToggle: constructCellRendererToggleIndicatorSize :: IsCellRendererToggle o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererToggle: constructCellRendererToggleRadio :: (IsCellRendererToggle o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellRendererToggle: constructCellRendererToggleRadio :: IsCellRendererToggle o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellRendererToggle: type CellRendererToggleToggledCallback = Text /@path@/: string representation of 'GI.Gtk.Structs.TreePath.TreePath' describing the event location -> IO ()

+ GI.Gtk.Objects.CellRendererToggle: type CellRendererToggleToggledCallback = Text " /@path@/: string representation of 'GI.Gtk.Structs.TreePath.TreePath' describing the event location " -> IO ()

- GI.Gtk.Objects.CellView: CellView :: (ManagedPtr CellView) -> CellView

+ GI.Gtk.Objects.CellView: CellView :: ManagedPtr CellView -> CellView

- GI.Gtk.Objects.CellView: cellViewGetSizeOfRow :: (HasCallStack, MonadIO m, IsCellView a) => a -> TreePath -> m ((Bool, Requisition))

+ GI.Gtk.Objects.CellView: cellViewGetSizeOfRow :: (HasCallStack, MonadIO m, IsCellView a) => a -> TreePath -> m (Bool, Requisition)

- GI.Gtk.Objects.CellView: cellViewSetDisplayedRow :: (HasCallStack, MonadIO m, IsCellView a) => a -> Maybe (TreePath) -> m ()

+ GI.Gtk.Objects.CellView: cellViewSetDisplayedRow :: (HasCallStack, MonadIO m, IsCellView a) => a -> Maybe TreePath -> m ()

- GI.Gtk.Objects.CellView: cellViewSetModel :: (HasCallStack, MonadIO m, IsCellView a, IsTreeModel b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.CellView: cellViewSetModel :: (HasCallStack, MonadIO m, IsCellView a, IsTreeModel b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.CellView: constructCellViewBackground :: (IsCellView o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellView: constructCellViewBackground :: IsCellView o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellView: constructCellViewBackgroundGdk :: (IsCellView o) => Color -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellView: constructCellViewBackgroundGdk :: IsCellView o => Color -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellView: constructCellViewBackgroundRgba :: (IsCellView o) => RGBA -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellView: constructCellViewBackgroundRgba :: IsCellView o => RGBA -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellView: constructCellViewBackgroundSet :: (IsCellView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellView: constructCellViewBackgroundSet :: IsCellView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellView: constructCellViewDrawSensitive :: (IsCellView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellView: constructCellViewDrawSensitive :: IsCellView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CellView: constructCellViewFitModel :: (IsCellView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CellView: constructCellViewFitModel :: IsCellView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CheckButton: CheckButton :: (ManagedPtr CheckButton) -> CheckButton

+ GI.Gtk.Objects.CheckButton: CheckButton :: ManagedPtr CheckButton -> CheckButton

- GI.Gtk.Objects.CheckMenuItem: CheckMenuItem :: (ManagedPtr CheckMenuItem) -> CheckMenuItem

+ GI.Gtk.Objects.CheckMenuItem: CheckMenuItem :: ManagedPtr CheckMenuItem -> CheckMenuItem

- GI.Gtk.Objects.CheckMenuItem: constructCheckMenuItemActive :: (IsCheckMenuItem o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CheckMenuItem: constructCheckMenuItemActive :: IsCheckMenuItem o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CheckMenuItem: constructCheckMenuItemDrawAsRadio :: (IsCheckMenuItem o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CheckMenuItem: constructCheckMenuItemDrawAsRadio :: IsCheckMenuItem o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CheckMenuItem: constructCheckMenuItemInconsistent :: (IsCheckMenuItem o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.CheckMenuItem: constructCheckMenuItemInconsistent :: IsCheckMenuItem o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.CheckMenuItemAccessible: CheckMenuItemAccessible :: (ManagedPtr CheckMenuItemAccessible) -> CheckMenuItemAccessible

+ GI.Gtk.Objects.CheckMenuItemAccessible: CheckMenuItemAccessible :: ManagedPtr CheckMenuItemAccessible -> CheckMenuItemAccessible

- GI.Gtk.Objects.Clipboard: Clipboard :: (ManagedPtr Clipboard) -> Clipboard

+ GI.Gtk.Objects.Clipboard: Clipboard :: ManagedPtr Clipboard -> Clipboard

- GI.Gtk.Objects.Clipboard: clipboardSetCanStore :: (HasCallStack, MonadIO m, IsClipboard a) => a -> Maybe ([TargetEntry]) -> m ()

+ GI.Gtk.Objects.Clipboard: clipboardSetCanStore :: (HasCallStack, MonadIO m, IsClipboard a) => a -> Maybe [TargetEntry] -> m ()

- GI.Gtk.Objects.Clipboard: clipboardWaitForTargets :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m ((Bool, [Atom]))

+ GI.Gtk.Objects.Clipboard: clipboardWaitForTargets :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m (Bool, [Atom])

- GI.Gtk.Objects.Clipboard: type ClipboardOwnerChangeCallback = EventOwnerChange /@event@/: the /@gdkEventOwnerChange@/ event -> IO ()

+ GI.Gtk.Objects.Clipboard: type ClipboardOwnerChangeCallback = EventOwnerChange " /@event@/: the /@gdkEventOwnerChange@/ event " -> IO ()

- GI.Gtk.Objects.ColorButton: ColorButton :: (ManagedPtr ColorButton) -> ColorButton

+ GI.Gtk.Objects.ColorButton: ColorButton :: ManagedPtr ColorButton -> ColorButton

- GI.Gtk.Objects.ColorButton: colorButtonGetColor :: (HasCallStack, MonadIO m, IsColorButton a) => a -> m (Color)

+ GI.Gtk.Objects.ColorButton: colorButtonGetColor :: (HasCallStack, MonadIO m, IsColorButton a) => a -> m Color

- GI.Gtk.Objects.ColorButton: constructColorButtonAlpha :: (IsColorButton o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ColorButton: constructColorButtonAlpha :: IsColorButton o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.ColorButton: constructColorButtonColor :: (IsColorButton o) => Color -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ColorButton: constructColorButtonColor :: IsColorButton o => Color -> IO (GValueConstruct o)

- GI.Gtk.Objects.ColorButton: constructColorButtonRgba :: (IsColorButton o) => RGBA -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ColorButton: constructColorButtonRgba :: IsColorButton o => RGBA -> IO (GValueConstruct o)

- GI.Gtk.Objects.ColorButton: constructColorButtonShowEditor :: (IsColorButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ColorButton: constructColorButtonShowEditor :: IsColorButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ColorButton: constructColorButtonTitle :: (IsColorButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ColorButton: constructColorButtonTitle :: IsColorButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ColorButton: constructColorButtonUseAlpha :: (IsColorButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ColorButton: constructColorButtonUseAlpha :: IsColorButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ColorChooserDialog: ColorChooserDialog :: (ManagedPtr ColorChooserDialog) -> ColorChooserDialog

+ GI.Gtk.Objects.ColorChooserDialog: ColorChooserDialog :: ManagedPtr ColorChooserDialog -> ColorChooserDialog

- GI.Gtk.Objects.ColorChooserDialog: colorChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe (Text) -> Maybe (a) -> m ColorChooserDialog

+ GI.Gtk.Objects.ColorChooserDialog: colorChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe Text -> Maybe a -> m ColorChooserDialog

- GI.Gtk.Objects.ColorChooserDialog: constructColorChooserDialogShowEditor :: (IsColorChooserDialog o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ColorChooserDialog: constructColorChooserDialogShowEditor :: IsColorChooserDialog o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ColorChooserWidget: ColorChooserWidget :: (ManagedPtr ColorChooserWidget) -> ColorChooserWidget

+ GI.Gtk.Objects.ColorChooserWidget: ColorChooserWidget :: ManagedPtr ColorChooserWidget -> ColorChooserWidget

- GI.Gtk.Objects.ColorChooserWidget: constructColorChooserWidgetShowEditor :: (IsColorChooserWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ColorChooserWidget: constructColorChooserWidgetShowEditor :: IsColorChooserWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ColorSelection: ColorSelection :: (ManagedPtr ColorSelection) -> ColorSelection

+ GI.Gtk.Objects.ColorSelection: ColorSelection :: ManagedPtr ColorSelection -> ColorSelection

- GI.Gtk.Objects.ColorSelection: colorSelectionGetCurrentColor :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m (Color)

+ GI.Gtk.Objects.ColorSelection: colorSelectionGetCurrentColor :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m Color

- GI.Gtk.Objects.ColorSelection: colorSelectionGetCurrentRgba :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m (RGBA)

+ GI.Gtk.Objects.ColorSelection: colorSelectionGetCurrentRgba :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m RGBA

- GI.Gtk.Objects.ColorSelection: colorSelectionGetPreviousColor :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m (Color)

+ GI.Gtk.Objects.ColorSelection: colorSelectionGetPreviousColor :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m Color

- GI.Gtk.Objects.ColorSelection: colorSelectionGetPreviousRgba :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m (RGBA)

+ GI.Gtk.Objects.ColorSelection: colorSelectionGetPreviousRgba :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m RGBA

- GI.Gtk.Objects.ColorSelection: colorSelectionPaletteFromString :: (HasCallStack, MonadIO m) => Text -> m ((Bool, [Color]))

+ GI.Gtk.Objects.ColorSelection: colorSelectionPaletteFromString :: (HasCallStack, MonadIO m) => Text -> m (Bool, [Color])

- GI.Gtk.Objects.ColorSelection: constructColorSelectionCurrentAlpha :: (IsColorSelection o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ColorSelection: constructColorSelectionCurrentAlpha :: IsColorSelection o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.ColorSelection: constructColorSelectionCurrentColor :: (IsColorSelection o) => Color -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ColorSelection: constructColorSelectionCurrentColor :: IsColorSelection o => Color -> IO (GValueConstruct o)

- GI.Gtk.Objects.ColorSelection: constructColorSelectionCurrentRgba :: (IsColorSelection o) => RGBA -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ColorSelection: constructColorSelectionCurrentRgba :: IsColorSelection o => RGBA -> IO (GValueConstruct o)

- GI.Gtk.Objects.ColorSelection: constructColorSelectionHasOpacityControl :: (IsColorSelection o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ColorSelection: constructColorSelectionHasOpacityControl :: IsColorSelection o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ColorSelection: constructColorSelectionHasPalette :: (IsColorSelection o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ColorSelection: constructColorSelectionHasPalette :: IsColorSelection o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ColorSelectionDialog: ColorSelectionDialog :: (ManagedPtr ColorSelectionDialog) -> ColorSelectionDialog

+ GI.Gtk.Objects.ColorSelectionDialog: ColorSelectionDialog :: ManagedPtr ColorSelectionDialog -> ColorSelectionDialog

- GI.Gtk.Objects.ComboBox: ComboBox :: (ManagedPtr ComboBox) -> ComboBox

+ GI.Gtk.Objects.ComboBox: ComboBox :: ManagedPtr ComboBox -> ComboBox

- GI.Gtk.Objects.ComboBox: comboBoxGetActiveIter :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m ((Bool, TreeIter))

+ GI.Gtk.Objects.ComboBox: comboBoxGetActiveIter :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m (Bool, TreeIter)

- GI.Gtk.Objects.ComboBox: comboBoxSetActiveId :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Maybe (Text) -> m Bool

+ GI.Gtk.Objects.ComboBox: comboBoxSetActiveId :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Maybe Text -> m Bool

- GI.Gtk.Objects.ComboBox: comboBoxSetActiveIter :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Maybe (TreeIter) -> m ()

+ GI.Gtk.Objects.ComboBox: comboBoxSetActiveIter :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Maybe TreeIter -> m ()

- GI.Gtk.Objects.ComboBox: comboBoxSetModel :: (HasCallStack, MonadIO m, IsComboBox a, IsTreeModel b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.ComboBox: comboBoxSetModel :: (HasCallStack, MonadIO m, IsComboBox a, IsTreeModel b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.ComboBox: constructComboBoxActive :: (IsComboBox o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ComboBox: constructComboBoxActive :: IsComboBox o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.ComboBox: constructComboBoxActiveId :: (IsComboBox o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ComboBox: constructComboBoxActiveId :: IsComboBox o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ComboBox: constructComboBoxAddTearoffs :: (IsComboBox o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ComboBox: constructComboBoxAddTearoffs :: IsComboBox o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ComboBox: constructComboBoxButtonSensitivity :: (IsComboBox o) => SensitivityType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ComboBox: constructComboBoxButtonSensitivity :: IsComboBox o => SensitivityType -> IO (GValueConstruct o)

- GI.Gtk.Objects.ComboBox: constructComboBoxColumnSpanColumn :: (IsComboBox o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ComboBox: constructComboBoxColumnSpanColumn :: IsComboBox o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.ComboBox: constructComboBoxEntryTextColumn :: (IsComboBox o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ComboBox: constructComboBoxEntryTextColumn :: IsComboBox o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.ComboBox: constructComboBoxHasEntry :: (IsComboBox o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ComboBox: constructComboBoxHasEntry :: IsComboBox o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ComboBox: constructComboBoxHasFrame :: (IsComboBox o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ComboBox: constructComboBoxHasFrame :: IsComboBox o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ComboBox: constructComboBoxIdColumn :: (IsComboBox o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ComboBox: constructComboBoxIdColumn :: IsComboBox o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.ComboBox: constructComboBoxPopupFixedWidth :: (IsComboBox o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ComboBox: constructComboBoxPopupFixedWidth :: IsComboBox o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ComboBox: constructComboBoxRowSpanColumn :: (IsComboBox o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ComboBox: constructComboBoxRowSpanColumn :: IsComboBox o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.ComboBox: constructComboBoxTearoffTitle :: (IsComboBox o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ComboBox: constructComboBoxTearoffTitle :: IsComboBox o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ComboBox: constructComboBoxWrapWidth :: (IsComboBox o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ComboBox: constructComboBoxWrapWidth :: IsComboBox o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.ComboBox: type ComboBoxFormatEntryTextCallback = Text /@path@/: the GtkTreePath string from the combo box\'s current model to format text for -> IO Text __Returns:__ a newly allocated string representing /@path@/ for the current GtkComboBox model.

+ GI.Gtk.Objects.ComboBox: type ComboBoxFormatEntryTextCallback = Text " /@path@/: the GtkTreePath string from the combo box\'s current model to format text for " -> IO Text " __Returns:__ a newly allocated string representing /@path@/ for the current GtkComboBox model. "

- GI.Gtk.Objects.ComboBox: type ComboBoxMoveActiveCallback = ScrollType /@scrollType@/: a 'GI.Gtk.Enums.ScrollType' -> IO ()

+ GI.Gtk.Objects.ComboBox: type ComboBoxMoveActiveCallback = ScrollType " /@scrollType@/: a 'GI.Gtk.Enums.ScrollType' " -> IO ()

- GI.Gtk.Objects.ComboBoxAccessible: ComboBoxAccessible :: (ManagedPtr ComboBoxAccessible) -> ComboBoxAccessible

+ GI.Gtk.Objects.ComboBoxAccessible: ComboBoxAccessible :: ManagedPtr ComboBoxAccessible -> ComboBoxAccessible

- GI.Gtk.Objects.ComboBoxText: ComboBoxText :: (ManagedPtr ComboBoxText) -> ComboBoxText

+ GI.Gtk.Objects.ComboBoxText: ComboBoxText :: ManagedPtr ComboBoxText -> ComboBoxText

- GI.Gtk.Objects.ComboBoxText: comboBoxTextAppend :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Maybe (Text) -> Text -> m ()

+ GI.Gtk.Objects.ComboBoxText: comboBoxTextAppend :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Maybe Text -> Text -> m ()

- GI.Gtk.Objects.ComboBoxText: comboBoxTextInsert :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Int32 -> Maybe (Text) -> Text -> m ()

+ GI.Gtk.Objects.ComboBoxText: comboBoxTextInsert :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Int32 -> Maybe Text -> Text -> m ()

- GI.Gtk.Objects.ComboBoxText: comboBoxTextPrepend :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Maybe (Text) -> Text -> m ()

+ GI.Gtk.Objects.ComboBoxText: comboBoxTextPrepend :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Maybe Text -> Text -> m ()

- GI.Gtk.Objects.Container: Container :: (ManagedPtr Container) -> Container

+ GI.Gtk.Objects.Container: Container :: ManagedPtr Container -> Container

- GI.Gtk.Objects.Container: constructContainerBorderWidth :: (IsContainer o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Container: constructContainerBorderWidth :: IsContainer o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Container: constructContainerResizeMode :: (IsContainer o) => ResizeMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Container: constructContainerResizeMode :: IsContainer o => ResizeMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.Container: containerGetFocusChain :: (HasCallStack, MonadIO m, IsContainer a) => a -> m ((Bool, [Widget]))

+ GI.Gtk.Objects.Container: containerGetFocusChain :: (HasCallStack, MonadIO m, IsContainer a) => a -> m (Bool, [Widget])

- GI.Gtk.Objects.Container: containerSetFocusChild :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Container: containerSetFocusChild :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.ContainerAccessible: ContainerAccessible :: (ManagedPtr ContainerAccessible) -> ContainerAccessible

+ GI.Gtk.Objects.ContainerAccessible: ContainerAccessible :: ManagedPtr ContainerAccessible -> ContainerAccessible

- GI.Gtk.Objects.ContainerCellAccessible: ContainerCellAccessible :: (ManagedPtr ContainerCellAccessible) -> ContainerCellAccessible

+ GI.Gtk.Objects.ContainerCellAccessible: ContainerCellAccessible :: ManagedPtr ContainerCellAccessible -> ContainerCellAccessible

- GI.Gtk.Objects.CssProvider: CssProvider :: (ManagedPtr CssProvider) -> CssProvider

+ GI.Gtk.Objects.CssProvider: CssProvider :: ManagedPtr CssProvider -> CssProvider

- GI.Gtk.Objects.CssProvider: cssProviderGetNamed :: (HasCallStack, MonadIO m) => Text -> Maybe (Text) -> m CssProvider

+ GI.Gtk.Objects.CssProvider: cssProviderGetNamed :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> m CssProvider

- GI.Gtk.Objects.CssProvider: type CssProviderParsingErrorCallback = CssSection /@section@/: section the error happened in -> GError /@error@/: The parsing error -> IO ()

+ GI.Gtk.Objects.CssProvider: type CssProviderParsingErrorCallback = CssSection " /@section@/: section the error happened in " -> GError " /@error@/: The parsing error " -> IO ()

- GI.Gtk.Objects.Dialog: Dialog :: (ManagedPtr Dialog) -> Dialog

+ GI.Gtk.Objects.Dialog: Dialog :: ManagedPtr Dialog -> Dialog

- GI.Gtk.Objects.Dialog: constructDialogUseHeaderBar :: (IsDialog o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Dialog: constructDialogUseHeaderBar :: IsDialog o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Dialog: type DialogResponseCallback = Int32 /@responseId@/: the response ID -> IO ()

+ GI.Gtk.Objects.Dialog: type DialogResponseCallback = Int32 " /@responseId@/: the response ID " -> IO ()

- GI.Gtk.Objects.DrawingArea: DrawingArea :: (ManagedPtr DrawingArea) -> DrawingArea

+ GI.Gtk.Objects.DrawingArea: DrawingArea :: ManagedPtr DrawingArea -> DrawingArea

- GI.Gtk.Objects.Entry: Entry :: (ManagedPtr Entry) -> Entry

+ GI.Gtk.Objects.Entry: Entry :: ManagedPtr Entry -> Entry

- GI.Gtk.Objects.Entry: constructEntryActivatesDefault :: (IsEntry o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryActivatesDefault :: IsEntry o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryAttributes :: (IsEntry o) => AttrList -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryAttributes :: IsEntry o => AttrList -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryCapsLockWarning :: (IsEntry o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryCapsLockWarning :: IsEntry o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryEditable :: (IsEntry o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryEditable :: IsEntry o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryHasFrame :: (IsEntry o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryHasFrame :: IsEntry o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryImModule :: (IsEntry o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryImModule :: IsEntry o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryInnerBorder :: (IsEntry o) => Border -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryInnerBorder :: IsEntry o => Border -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryInputHints :: (IsEntry o) => [InputHints] -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryInputHints :: IsEntry o => [InputHints] -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryInputPurpose :: (IsEntry o) => InputPurpose -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryInputPurpose :: IsEntry o => InputPurpose -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryInvisibleChar :: (IsEntry o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryInvisibleChar :: IsEntry o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryInvisibleCharSet :: (IsEntry o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryInvisibleCharSet :: IsEntry o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryMaxLength :: (IsEntry o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryMaxLength :: IsEntry o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryMaxWidthChars :: (IsEntry o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryMaxWidthChars :: IsEntry o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryOverwriteMode :: (IsEntry o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryOverwriteMode :: IsEntry o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryPlaceholderText :: (IsEntry o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryPlaceholderText :: IsEntry o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryPopulateAll :: (IsEntry o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryPopulateAll :: IsEntry o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryPrimaryIconActivatable :: (IsEntry o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryPrimaryIconActivatable :: IsEntry o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryPrimaryIconName :: (IsEntry o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryPrimaryIconName :: IsEntry o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryPrimaryIconSensitive :: (IsEntry o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryPrimaryIconSensitive :: IsEntry o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryPrimaryIconStock :: (IsEntry o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryPrimaryIconStock :: IsEntry o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryPrimaryIconTooltipMarkup :: (IsEntry o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryPrimaryIconTooltipMarkup :: IsEntry o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryPrimaryIconTooltipText :: (IsEntry o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryPrimaryIconTooltipText :: IsEntry o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryProgressFraction :: (IsEntry o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryProgressFraction :: IsEntry o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryProgressPulseStep :: (IsEntry o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryProgressPulseStep :: IsEntry o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntrySecondaryIconActivatable :: (IsEntry o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntrySecondaryIconActivatable :: IsEntry o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntrySecondaryIconName :: (IsEntry o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntrySecondaryIconName :: IsEntry o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntrySecondaryIconSensitive :: (IsEntry o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntrySecondaryIconSensitive :: IsEntry o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntrySecondaryIconStock :: (IsEntry o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntrySecondaryIconStock :: IsEntry o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntrySecondaryIconTooltipMarkup :: (IsEntry o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntrySecondaryIconTooltipMarkup :: IsEntry o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntrySecondaryIconTooltipText :: (IsEntry o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntrySecondaryIconTooltipText :: IsEntry o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryShadowType :: (IsEntry o) => ShadowType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryShadowType :: IsEntry o => ShadowType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryShowEmojiIcon :: (IsEntry o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryShowEmojiIcon :: IsEntry o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryTabs :: (IsEntry o) => TabArray -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryTabs :: IsEntry o => TabArray -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryText :: (IsEntry o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryText :: IsEntry o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryTruncateMultiline :: (IsEntry o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryTruncateMultiline :: IsEntry o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryVisibility :: (IsEntry o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryVisibility :: IsEntry o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryWidthChars :: (IsEntry o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryWidthChars :: IsEntry o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: constructEntryXalign :: (IsEntry o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Entry: constructEntryXalign :: IsEntry o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.Entry: entryGetIconArea :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Rectangle)

+ GI.Gtk.Objects.Entry: entryGetIconArea :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Rectangle

- GI.Gtk.Objects.Entry: entryGetLayoutOffsets :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.Entry: entryGetLayoutOffsets :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.Entry: entryGetTextArea :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Rectangle)

+ GI.Gtk.Objects.Entry: entryGetTextArea :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Rectangle

- GI.Gtk.Objects.Entry: entrySetCompletion :: (HasCallStack, MonadIO m, IsEntry a, IsEntryCompletion b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Entry: entrySetCompletion :: (HasCallStack, MonadIO m, IsEntry a, IsEntryCompletion b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Entry: entrySetCursorHadjustment :: (HasCallStack, MonadIO m, IsEntry a, IsAdjustment b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Entry: entrySetCursorHadjustment :: (HasCallStack, MonadIO m, IsEntry a, IsAdjustment b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Entry: entrySetIconFromGicon :: (HasCallStack, MonadIO m, IsEntry a, IsIcon b) => a -> EntryIconPosition -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Entry: entrySetIconFromGicon :: (HasCallStack, MonadIO m, IsEntry a, IsIcon b) => a -> EntryIconPosition -> Maybe b -> m ()

- GI.Gtk.Objects.Entry: entrySetIconFromIconName :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Entry: entrySetIconFromIconName :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

- GI.Gtk.Objects.Entry: entrySetIconFromPixbuf :: (HasCallStack, MonadIO m, IsEntry a, IsPixbuf b) => a -> EntryIconPosition -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Entry: entrySetIconFromPixbuf :: (HasCallStack, MonadIO m, IsEntry a, IsPixbuf b) => a -> EntryIconPosition -> Maybe b -> m ()

- GI.Gtk.Objects.Entry: entrySetIconFromStock :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Entry: entrySetIconFromStock :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

- GI.Gtk.Objects.Entry: entrySetIconTooltipMarkup :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Entry: entrySetIconTooltipMarkup :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

- GI.Gtk.Objects.Entry: entrySetIconTooltipText :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Entry: entrySetIconTooltipText :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

- GI.Gtk.Objects.Entry: entrySetInnerBorder :: (HasCallStack, MonadIO m, IsEntry a) => a -> Maybe (Border) -> m ()

+ GI.Gtk.Objects.Entry: entrySetInnerBorder :: (HasCallStack, MonadIO m, IsEntry a) => a -> Maybe Border -> m ()

- GI.Gtk.Objects.Entry: entrySetPlaceholderText :: (HasCallStack, MonadIO m, IsEntry a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Entry: entrySetPlaceholderText :: (HasCallStack, MonadIO m, IsEntry a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.Entry: type EntryDeleteFromCursorCallback = DeleteType /@type@/: the granularity of the deletion, as a 'GI.Gtk.Enums.DeleteType' -> Int32 /@count@/: the number of /@type@/ units to delete -> IO ()

+ GI.Gtk.Objects.Entry: type EntryDeleteFromCursorCallback = DeleteType " /@type@/: the granularity of the deletion, as a 'GI.Gtk.Enums.DeleteType' " -> Int32 " /@count@/: the number of /@type@/ units to delete " -> IO ()

- GI.Gtk.Objects.Entry: type EntryIconPressCallback = EntryIconPosition /@iconPos@/: The position of the clicked icon -> EventButton /@event@/: the button press event -> IO ()

+ GI.Gtk.Objects.Entry: type EntryIconPressCallback = EntryIconPosition " /@iconPos@/: The position of the clicked icon " -> EventButton " /@event@/: the button press event " -> IO ()

- GI.Gtk.Objects.Entry: type EntryIconReleaseCallback = EntryIconPosition /@iconPos@/: The position of the clicked icon -> EventButton /@event@/: the button release event -> IO ()

+ GI.Gtk.Objects.Entry: type EntryIconReleaseCallback = EntryIconPosition " /@iconPos@/: The position of the clicked icon " -> EventButton " /@event@/: the button release event " -> IO ()

- GI.Gtk.Objects.Entry: type EntryInsertAtCursorCallback = Text /@string@/: the string to insert -> IO ()

+ GI.Gtk.Objects.Entry: type EntryInsertAtCursorCallback = Text " /@string@/: the string to insert " -> IO ()

- GI.Gtk.Objects.Entry: type EntryMoveCursorCallback = MovementStep /@step@/: the granularity of the move, as a 'GI.Gtk.Enums.MovementStep' -> Int32 /@count@/: the number of /@step@/ units to move -> Bool /@extendSelection@/: 'True' if the move should extend the selection -> IO ()

+ GI.Gtk.Objects.Entry: type EntryMoveCursorCallback = MovementStep " /@step@/: the granularity of the move, as a 'GI.Gtk.Enums.MovementStep' " -> Int32 " /@count@/: the number of /@step@/ units to move " -> Bool " /@extendSelection@/: 'True' if the move should extend the selection " -> IO ()

- GI.Gtk.Objects.Entry: type EntryPopulatePopupCallback = Widget /@widget@/: the container that is being populated -> IO ()

+ GI.Gtk.Objects.Entry: type EntryPopulatePopupCallback = Widget " /@widget@/: the container that is being populated " -> IO ()

- GI.Gtk.Objects.Entry: type EntryPreeditChangedCallback = Text /@preedit@/: the current preedit string -> IO ()

+ GI.Gtk.Objects.Entry: type EntryPreeditChangedCallback = Text " /@preedit@/: the current preedit string " -> IO ()

- GI.Gtk.Objects.EntryAccessible: EntryAccessible :: (ManagedPtr EntryAccessible) -> EntryAccessible

+ GI.Gtk.Objects.EntryAccessible: EntryAccessible :: ManagedPtr EntryAccessible -> EntryAccessible

- GI.Gtk.Objects.EntryBuffer: EntryBuffer :: (ManagedPtr EntryBuffer) -> EntryBuffer

+ GI.Gtk.Objects.EntryBuffer: EntryBuffer :: ManagedPtr EntryBuffer -> EntryBuffer

- GI.Gtk.Objects.EntryBuffer: constructEntryBufferMaxLength :: (IsEntryBuffer o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.EntryBuffer: constructEntryBufferMaxLength :: IsEntryBuffer o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.EntryBuffer: constructEntryBufferText :: (IsEntryBuffer o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.EntryBuffer: constructEntryBufferText :: IsEntryBuffer o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.EntryBuffer: entryBufferNew :: (HasCallStack, MonadIO m) => Maybe (Text) -> Int32 -> m EntryBuffer

+ GI.Gtk.Objects.EntryBuffer: entryBufferNew :: (HasCallStack, MonadIO m) => Maybe Text -> Int32 -> m EntryBuffer

- GI.Gtk.Objects.EntryBuffer: type EntryBufferDeletedTextCallback = Word32 /@position@/: the position the text was deleted at. -> Word32 /@nChars@/: The number of characters that were deleted. -> IO ()

+ GI.Gtk.Objects.EntryBuffer: type EntryBufferDeletedTextCallback = Word32 " /@position@/: the position the text was deleted at. " -> Word32 " /@nChars@/: The number of characters that were deleted. " -> IO ()

- GI.Gtk.Objects.EntryBuffer: type EntryBufferInsertedTextCallback = Word32 /@position@/: the position the text was inserted at. -> Text /@chars@/: The text that was inserted. -> Word32 /@nChars@/: The number of characters that were inserted. -> IO ()

+ GI.Gtk.Objects.EntryBuffer: type EntryBufferInsertedTextCallback = Word32 " /@position@/: the position the text was inserted at. " -> Text " /@chars@/: The text that was inserted. " -> Word32 " /@nChars@/: The number of characters that were inserted. " -> IO ()

- GI.Gtk.Objects.EntryCompletion: EntryCompletion :: (ManagedPtr EntryCompletion) -> EntryCompletion

+ GI.Gtk.Objects.EntryCompletion: EntryCompletion :: ManagedPtr EntryCompletion -> EntryCompletion

- GI.Gtk.Objects.EntryCompletion: constructEntryCompletionInlineCompletion :: (IsEntryCompletion o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.EntryCompletion: constructEntryCompletionInlineCompletion :: IsEntryCompletion o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.EntryCompletion: constructEntryCompletionInlineSelection :: (IsEntryCompletion o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.EntryCompletion: constructEntryCompletionInlineSelection :: IsEntryCompletion o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.EntryCompletion: constructEntryCompletionMinimumKeyLength :: (IsEntryCompletion o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.EntryCompletion: constructEntryCompletionMinimumKeyLength :: IsEntryCompletion o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.EntryCompletion: constructEntryCompletionPopupCompletion :: (IsEntryCompletion o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.EntryCompletion: constructEntryCompletionPopupCompletion :: IsEntryCompletion o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.EntryCompletion: constructEntryCompletionPopupSetWidth :: (IsEntryCompletion o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.EntryCompletion: constructEntryCompletionPopupSetWidth :: IsEntryCompletion o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.EntryCompletion: constructEntryCompletionPopupSingleMatch :: (IsEntryCompletion o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.EntryCompletion: constructEntryCompletionPopupSingleMatch :: IsEntryCompletion o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.EntryCompletion: constructEntryCompletionTextColumn :: (IsEntryCompletion o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.EntryCompletion: constructEntryCompletionTextColumn :: IsEntryCompletion o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.EntryCompletion: entryCompletionSetModel :: (HasCallStack, MonadIO m, IsEntryCompletion a, IsTreeModel b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.EntryCompletion: entryCompletionSetModel :: (HasCallStack, MonadIO m, IsEntryCompletion a, IsTreeModel b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.EntryCompletion: type EntryCompletionActionActivatedCallback = Int32 /@index@/: the index of the activated action -> IO ()

+ GI.Gtk.Objects.EntryCompletion: type EntryCompletionActionActivatedCallback = Int32 " /@index@/: the index of the activated action " -> IO ()

- GI.Gtk.Objects.EntryCompletion: type EntryCompletionCursorOnMatchCallback = TreeModel /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' containing the matches -> TreeIter /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' positioned at the selected match -> IO Bool __Returns:__ 'True' if the signal has been handled

+ GI.Gtk.Objects.EntryCompletion: type EntryCompletionCursorOnMatchCallback = TreeModel " /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' containing the matches " -> TreeIter " /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' positioned at the selected match " -> IO Bool " __Returns:__ 'True' if the signal has been handled "

- GI.Gtk.Objects.EntryCompletion: type EntryCompletionInsertPrefixCallback = Text /@prefix@/: the common prefix of all possible completions -> IO Bool __Returns:__ 'True' if the signal has been handled

+ GI.Gtk.Objects.EntryCompletion: type EntryCompletionInsertPrefixCallback = Text " /@prefix@/: the common prefix of all possible completions " -> IO Bool " __Returns:__ 'True' if the signal has been handled "

- GI.Gtk.Objects.EntryCompletion: type EntryCompletionMatchSelectedCallback = TreeModel /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' containing the matches -> TreeIter /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' positioned at the selected match -> IO Bool __Returns:__ 'True' if the signal has been handled

+ GI.Gtk.Objects.EntryCompletion: type EntryCompletionMatchSelectedCallback = TreeModel " /@model@/: the 'GI.Gtk.Interfaces.TreeModel.TreeModel' containing the matches " -> TreeIter " /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter' positioned at the selected match " -> IO Bool " __Returns:__ 'True' if the signal has been handled "

- GI.Gtk.Objects.EntryIconAccessible: EntryIconAccessible :: (ManagedPtr EntryIconAccessible) -> EntryIconAccessible

+ GI.Gtk.Objects.EntryIconAccessible: EntryIconAccessible :: ManagedPtr EntryIconAccessible -> EntryIconAccessible

- GI.Gtk.Objects.EventBox: EventBox :: (ManagedPtr EventBox) -> EventBox

+ GI.Gtk.Objects.EventBox: EventBox :: ManagedPtr EventBox -> EventBox

- GI.Gtk.Objects.EventBox: constructEventBoxAboveChild :: (IsEventBox o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.EventBox: constructEventBoxAboveChild :: IsEventBox o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.EventBox: constructEventBoxVisibleWindow :: (IsEventBox o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.EventBox: constructEventBoxVisibleWindow :: IsEventBox o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.EventController: EventController :: (ManagedPtr EventController) -> EventController

+ GI.Gtk.Objects.EventController: EventController :: ManagedPtr EventController -> EventController

- GI.Gtk.Objects.EventController: constructEventControllerPropagationPhase :: (IsEventController o) => PropagationPhase -> IO (GValueConstruct o)

+ GI.Gtk.Objects.EventController: constructEventControllerPropagationPhase :: IsEventController o => PropagationPhase -> IO (GValueConstruct o)

- GI.Gtk.Objects.Expander: Expander :: (ManagedPtr Expander) -> Expander

+ GI.Gtk.Objects.Expander: Expander :: ManagedPtr Expander -> Expander

- GI.Gtk.Objects.Expander: constructExpanderExpanded :: (IsExpander o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Expander: constructExpanderExpanded :: IsExpander o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Expander: constructExpanderLabel :: (IsExpander o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Expander: constructExpanderLabel :: IsExpander o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Expander: constructExpanderLabelFill :: (IsExpander o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Expander: constructExpanderLabelFill :: IsExpander o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Expander: constructExpanderResizeToplevel :: (IsExpander o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Expander: constructExpanderResizeToplevel :: IsExpander o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Expander: constructExpanderSpacing :: (IsExpander o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Expander: constructExpanderSpacing :: IsExpander o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Expander: constructExpanderUseMarkup :: (IsExpander o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Expander: constructExpanderUseMarkup :: IsExpander o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Expander: constructExpanderUseUnderline :: (IsExpander o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Expander: constructExpanderUseUnderline :: IsExpander o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Expander: expanderNew :: (HasCallStack, MonadIO m) => Maybe (Text) -> m Expander

+ GI.Gtk.Objects.Expander: expanderNew :: (HasCallStack, MonadIO m) => Maybe Text -> m Expander

- GI.Gtk.Objects.Expander: expanderNewWithMnemonic :: (HasCallStack, MonadIO m) => Maybe (Text) -> m Expander

+ GI.Gtk.Objects.Expander: expanderNewWithMnemonic :: (HasCallStack, MonadIO m) => Maybe Text -> m Expander

- GI.Gtk.Objects.Expander: expanderSetLabel :: (HasCallStack, MonadIO m, IsExpander a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Expander: expanderSetLabel :: (HasCallStack, MonadIO m, IsExpander a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.Expander: expanderSetLabelWidget :: (HasCallStack, MonadIO m, IsExpander a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Expander: expanderSetLabelWidget :: (HasCallStack, MonadIO m, IsExpander a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.ExpanderAccessible: ExpanderAccessible :: (ManagedPtr ExpanderAccessible) -> ExpanderAccessible

+ GI.Gtk.Objects.ExpanderAccessible: ExpanderAccessible :: ManagedPtr ExpanderAccessible -> ExpanderAccessible

- GI.Gtk.Objects.FileChooserButton: FileChooserButton :: (ManagedPtr FileChooserButton) -> FileChooserButton

+ GI.Gtk.Objects.FileChooserButton: FileChooserButton :: ManagedPtr FileChooserButton -> FileChooserButton

- GI.Gtk.Objects.FileChooserButton: constructFileChooserButtonTitle :: (IsFileChooserButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FileChooserButton: constructFileChooserButtonTitle :: IsFileChooserButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.FileChooserButton: constructFileChooserButtonWidthChars :: (IsFileChooserButton o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FileChooserButton: constructFileChooserButtonWidthChars :: IsFileChooserButton o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.FileChooserDialog: FileChooserDialog :: (ManagedPtr FileChooserDialog) -> FileChooserDialog

+ GI.Gtk.Objects.FileChooserDialog: FileChooserDialog :: ManagedPtr FileChooserDialog -> FileChooserDialog

- GI.Gtk.Objects.FileChooserNative: FileChooserNative :: (ManagedPtr FileChooserNative) -> FileChooserNative

+ GI.Gtk.Objects.FileChooserNative: FileChooserNative :: ManagedPtr FileChooserNative -> FileChooserNative

- GI.Gtk.Objects.FileChooserNative: constructFileChooserNativeAcceptLabel :: (IsFileChooserNative o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FileChooserNative: constructFileChooserNativeAcceptLabel :: IsFileChooserNative o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.FileChooserNative: constructFileChooserNativeCancelLabel :: (IsFileChooserNative o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FileChooserNative: constructFileChooserNativeCancelLabel :: IsFileChooserNative o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.FileChooserNative: fileChooserNativeNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe (Text) -> Maybe (a) -> FileChooserAction -> Maybe (Text) -> Maybe (Text) -> m FileChooserNative

+ GI.Gtk.Objects.FileChooserNative: fileChooserNativeNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe Text -> Maybe a -> FileChooserAction -> Maybe Text -> Maybe Text -> m FileChooserNative

- GI.Gtk.Objects.FileChooserNative: fileChooserNativeSetAcceptLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.FileChooserNative: fileChooserNativeSetAcceptLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.FileChooserNative: fileChooserNativeSetCancelLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.FileChooserNative: fileChooserNativeSetCancelLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.FileChooserWidget: FileChooserWidget :: (ManagedPtr FileChooserWidget) -> FileChooserWidget

+ GI.Gtk.Objects.FileChooserWidget: FileChooserWidget :: ManagedPtr FileChooserWidget -> FileChooserWidget

- GI.Gtk.Objects.FileChooserWidget: constructFileChooserWidgetSearchMode :: (IsFileChooserWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FileChooserWidget: constructFileChooserWidgetSearchMode :: IsFileChooserWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.FileChooserWidget: type FileChooserWidgetLocationPopupCallback = Text /@path@/: a string that gets put in the text entry for the file name -> IO ()

+ GI.Gtk.Objects.FileChooserWidget: type FileChooserWidgetLocationPopupCallback = Text " /@path@/: a string that gets put in the text entry for the file name " -> IO ()

- GI.Gtk.Objects.FileChooserWidget: type FileChooserWidgetQuickBookmarkCallback = Int32 /@bookmarkIndex@/: the number of the bookmark to switch to -> IO ()

+ GI.Gtk.Objects.FileChooserWidget: type FileChooserWidgetQuickBookmarkCallback = Int32 " /@bookmarkIndex@/: the number of the bookmark to switch to " -> IO ()

- GI.Gtk.Objects.FileFilter: FileFilter :: (ManagedPtr FileFilter) -> FileFilter

+ GI.Gtk.Objects.FileFilter: FileFilter :: ManagedPtr FileFilter -> FileFilter

- GI.Gtk.Objects.FileFilter: fileFilterSetName :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.FileFilter: fileFilterSetName :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.Fixed: Fixed :: (ManagedPtr Fixed) -> Fixed

+ GI.Gtk.Objects.Fixed: Fixed :: ManagedPtr Fixed -> Fixed

- GI.Gtk.Objects.FlowBox: FlowBox :: (ManagedPtr FlowBox) -> FlowBox

+ GI.Gtk.Objects.FlowBox: FlowBox :: ManagedPtr FlowBox -> FlowBox

- GI.Gtk.Objects.FlowBox: constructFlowBoxActivateOnSingleClick :: (IsFlowBox o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FlowBox: constructFlowBoxActivateOnSingleClick :: IsFlowBox o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.FlowBox: constructFlowBoxColumnSpacing :: (IsFlowBox o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FlowBox: constructFlowBoxColumnSpacing :: IsFlowBox o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.FlowBox: constructFlowBoxHomogeneous :: (IsFlowBox o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FlowBox: constructFlowBoxHomogeneous :: IsFlowBox o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.FlowBox: constructFlowBoxMaxChildrenPerLine :: (IsFlowBox o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FlowBox: constructFlowBoxMaxChildrenPerLine :: IsFlowBox o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.FlowBox: constructFlowBoxMinChildrenPerLine :: (IsFlowBox o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FlowBox: constructFlowBoxMinChildrenPerLine :: IsFlowBox o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.FlowBox: constructFlowBoxRowSpacing :: (IsFlowBox o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FlowBox: constructFlowBoxRowSpacing :: IsFlowBox o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.FlowBox: constructFlowBoxSelectionMode :: (IsFlowBox o) => SelectionMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FlowBox: constructFlowBoxSelectionMode :: IsFlowBox o => SelectionMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.FlowBox: flowBoxBindModel :: (HasCallStack, MonadIO m, IsFlowBox a, IsListModel b) => a -> Maybe (b) -> FlowBoxCreateWidgetFunc -> m ()

+ GI.Gtk.Objects.FlowBox: flowBoxBindModel :: (HasCallStack, MonadIO m, IsFlowBox a, IsListModel b) => a -> Maybe b -> FlowBoxCreateWidgetFunc -> m ()

- GI.Gtk.Objects.FlowBox: flowBoxSetFilterFunc :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Maybe (FlowBoxFilterFunc) -> m ()

+ GI.Gtk.Objects.FlowBox: flowBoxSetFilterFunc :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Maybe FlowBoxFilterFunc -> m ()

- GI.Gtk.Objects.FlowBox: flowBoxSetSortFunc :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Maybe (FlowBoxSortFunc) -> m ()

+ GI.Gtk.Objects.FlowBox: flowBoxSetSortFunc :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Maybe FlowBoxSortFunc -> m ()

- GI.Gtk.Objects.FlowBox: type FlowBoxChildActivatedCallback = FlowBoxChild /@child@/: the child that is activated -> IO ()

+ GI.Gtk.Objects.FlowBox: type FlowBoxChildActivatedCallback = FlowBoxChild " /@child@/: the child that is activated " -> IO ()

- GI.Gtk.Objects.FlowBox: type FlowBoxMoveCursorCallback = MovementStep /@step@/: the granularity fo the move, as a 'GI.Gtk.Enums.MovementStep' -> Int32 /@count@/: the number of /@step@/ units to move -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.FlowBox: type FlowBoxMoveCursorCallback = MovementStep " /@step@/: the granularity fo the move, as a 'GI.Gtk.Enums.MovementStep' " -> Int32 " /@count@/: the number of /@step@/ units to move " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.FlowBoxAccessible: FlowBoxAccessible :: (ManagedPtr FlowBoxAccessible) -> FlowBoxAccessible

+ GI.Gtk.Objects.FlowBoxAccessible: FlowBoxAccessible :: ManagedPtr FlowBoxAccessible -> FlowBoxAccessible

- GI.Gtk.Objects.FlowBoxChild: FlowBoxChild :: (ManagedPtr FlowBoxChild) -> FlowBoxChild

+ GI.Gtk.Objects.FlowBoxChild: FlowBoxChild :: ManagedPtr FlowBoxChild -> FlowBoxChild

- GI.Gtk.Objects.FlowBoxChildAccessible: FlowBoxChildAccessible :: (ManagedPtr FlowBoxChildAccessible) -> FlowBoxChildAccessible

+ GI.Gtk.Objects.FlowBoxChildAccessible: FlowBoxChildAccessible :: ManagedPtr FlowBoxChildAccessible -> FlowBoxChildAccessible

- GI.Gtk.Objects.FontButton: FontButton :: (ManagedPtr FontButton) -> FontButton

+ GI.Gtk.Objects.FontButton: FontButton :: ManagedPtr FontButton -> FontButton

- GI.Gtk.Objects.FontButton: constructFontButtonFontName :: (IsFontButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FontButton: constructFontButtonFontName :: IsFontButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.FontButton: constructFontButtonShowSize :: (IsFontButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FontButton: constructFontButtonShowSize :: IsFontButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.FontButton: constructFontButtonShowStyle :: (IsFontButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FontButton: constructFontButtonShowStyle :: IsFontButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.FontButton: constructFontButtonTitle :: (IsFontButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FontButton: constructFontButtonTitle :: IsFontButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.FontButton: constructFontButtonUseFont :: (IsFontButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FontButton: constructFontButtonUseFont :: IsFontButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.FontButton: constructFontButtonUseSize :: (IsFontButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FontButton: constructFontButtonUseSize :: IsFontButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.FontChooserDialog: FontChooserDialog :: (ManagedPtr FontChooserDialog) -> FontChooserDialog

+ GI.Gtk.Objects.FontChooserDialog: FontChooserDialog :: ManagedPtr FontChooserDialog -> FontChooserDialog

- GI.Gtk.Objects.FontChooserDialog: fontChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe (Text) -> Maybe (a) -> m FontChooserDialog

+ GI.Gtk.Objects.FontChooserDialog: fontChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe Text -> Maybe a -> m FontChooserDialog

- GI.Gtk.Objects.FontChooserWidget: FontChooserWidget :: (ManagedPtr FontChooserWidget) -> FontChooserWidget

+ GI.Gtk.Objects.FontChooserWidget: FontChooserWidget :: ManagedPtr FontChooserWidget -> FontChooserWidget

- GI.Gtk.Objects.FontSelection: FontSelection :: (ManagedPtr FontSelection) -> FontSelection

+ GI.Gtk.Objects.FontSelection: FontSelection :: ManagedPtr FontSelection -> FontSelection

- GI.Gtk.Objects.FontSelection: constructFontSelectionFontName :: (IsFontSelection o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FontSelection: constructFontSelectionFontName :: IsFontSelection o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.FontSelection: constructFontSelectionPreviewText :: (IsFontSelection o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.FontSelection: constructFontSelectionPreviewText :: IsFontSelection o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.FontSelectionDialog: FontSelectionDialog :: (ManagedPtr FontSelectionDialog) -> FontSelectionDialog

+ GI.Gtk.Objects.FontSelectionDialog: FontSelectionDialog :: ManagedPtr FontSelectionDialog -> FontSelectionDialog

- GI.Gtk.Objects.Frame: Frame :: (ManagedPtr Frame) -> Frame

+ GI.Gtk.Objects.Frame: Frame :: ManagedPtr Frame -> Frame

- GI.Gtk.Objects.Frame: constructFrameLabel :: (IsFrame o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Frame: constructFrameLabel :: IsFrame o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Frame: constructFrameLabelXalign :: (IsFrame o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Frame: constructFrameLabelXalign :: IsFrame o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.Frame: constructFrameLabelYalign :: (IsFrame o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Frame: constructFrameLabelYalign :: IsFrame o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.Frame: constructFrameShadowType :: (IsFrame o) => ShadowType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Frame: constructFrameShadowType :: IsFrame o => ShadowType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Frame: frameGetLabelAlign :: (HasCallStack, MonadIO m, IsFrame a) => a -> m ((Float, Float))

+ GI.Gtk.Objects.Frame: frameGetLabelAlign :: (HasCallStack, MonadIO m, IsFrame a) => a -> m (Float, Float)

- GI.Gtk.Objects.Frame: frameNew :: (HasCallStack, MonadIO m) => Maybe (Text) -> m Frame

+ GI.Gtk.Objects.Frame: frameNew :: (HasCallStack, MonadIO m) => Maybe Text -> m Frame

- GI.Gtk.Objects.Frame: frameSetLabel :: (HasCallStack, MonadIO m, IsFrame a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Frame: frameSetLabel :: (HasCallStack, MonadIO m, IsFrame a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.Frame: frameSetLabelWidget :: (HasCallStack, MonadIO m, IsFrame a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Frame: frameSetLabelWidget :: (HasCallStack, MonadIO m, IsFrame a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.FrameAccessible: FrameAccessible :: (ManagedPtr FrameAccessible) -> FrameAccessible

+ GI.Gtk.Objects.FrameAccessible: FrameAccessible :: ManagedPtr FrameAccessible -> FrameAccessible

- GI.Gtk.Objects.GLArea: GLArea :: (ManagedPtr GLArea) -> GLArea

+ GI.Gtk.Objects.GLArea: GLArea :: ManagedPtr GLArea -> GLArea

- GI.Gtk.Objects.GLArea: constructGLAreaAutoRender :: (IsGLArea o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.GLArea: constructGLAreaAutoRender :: IsGLArea o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.GLArea: constructGLAreaHasAlpha :: (IsGLArea o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.GLArea: constructGLAreaHasAlpha :: IsGLArea o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.GLArea: constructGLAreaHasDepthBuffer :: (IsGLArea o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.GLArea: constructGLAreaHasDepthBuffer :: IsGLArea o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.GLArea: constructGLAreaHasStencilBuffer :: (IsGLArea o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.GLArea: constructGLAreaHasStencilBuffer :: IsGLArea o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.GLArea: constructGLAreaUseEs :: (IsGLArea o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.GLArea: constructGLAreaUseEs :: IsGLArea o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.GLArea: gLAreaGetRequiredVersion :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.GLArea: gLAreaGetRequiredVersion :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.GLArea: gLAreaSetError :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Maybe (GError) -> m ()

+ GI.Gtk.Objects.GLArea: gLAreaSetError :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Maybe GError -> m ()

- GI.Gtk.Objects.GLArea: type GLAreaCreateContextCallback = IO GLContext __Returns:__ a newly created 'GI.Gdk.Objects.GLContext.GLContext'; the 'GI.Gtk.Objects.GLArea.GLArea' widget will take ownership of the returned value.

+ GI.Gtk.Objects.GLArea: type GLAreaCreateContextCallback = IO GLContext " __Returns:__ a newly created 'GI.Gdk.Objects.GLContext.GLContext'; the 'GI.Gtk.Objects.GLArea.GLArea' widget will take ownership of the returned value. "

- GI.Gtk.Objects.GLArea: type GLAreaRenderCallback = GLContext /@context@/: the 'GI.Gdk.Objects.GLContext.GLContext' used by /@area@/ -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.GLArea: type GLAreaRenderCallback = GLContext " /@context@/: the 'GI.Gdk.Objects.GLContext.GLContext' used by /@area@/ " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.GLArea: type GLAreaResizeCallback = Int32 /@width@/: the width of the viewport -> Int32 /@height@/: the height of the viewport -> IO ()

+ GI.Gtk.Objects.GLArea: type GLAreaResizeCallback = Int32 " /@width@/: the width of the viewport " -> Int32 " /@height@/: the height of the viewport " -> IO ()

- GI.Gtk.Objects.Gesture: Gesture :: (ManagedPtr Gesture) -> Gesture

+ GI.Gtk.Objects.Gesture: Gesture :: ManagedPtr Gesture -> Gesture

- GI.Gtk.Objects.Gesture: constructGestureNPoints :: (IsGesture o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Gesture: constructGestureNPoints :: IsGesture o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Gesture: gestureGetBoundingBox :: (HasCallStack, MonadIO m, IsGesture a) => a -> m ((Bool, Rectangle))

+ GI.Gtk.Objects.Gesture: gestureGetBoundingBox :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Bool, Rectangle)

- GI.Gtk.Objects.Gesture: gestureGetBoundingBoxCenter :: (HasCallStack, MonadIO m, IsGesture a) => a -> m ((Bool, Double, Double))

+ GI.Gtk.Objects.Gesture: gestureGetBoundingBoxCenter :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Bool, Double, Double)

- GI.Gtk.Objects.Gesture: gestureGetLastEvent :: (HasCallStack, MonadIO m, IsGesture a) => a -> EventSequence -> m (Maybe Event)

+ GI.Gtk.Objects.Gesture: gestureGetLastEvent :: (HasCallStack, MonadIO m, IsGesture a) => a -> Maybe EventSequence -> m (Maybe Event)

- GI.Gtk.Objects.Gesture: gestureGetPoint :: (HasCallStack, MonadIO m, IsGesture a) => a -> Maybe (EventSequence) -> m ((Bool, Double, Double))

+ GI.Gtk.Objects.Gesture: gestureGetPoint :: (HasCallStack, MonadIO m, IsGesture a) => a -> Maybe EventSequence -> m (Bool, Double, Double)

- GI.Gtk.Objects.Gesture: gestureHandlesSequence :: (HasCallStack, MonadIO m, IsGesture a) => a -> Maybe (EventSequence) -> m Bool

+ GI.Gtk.Objects.Gesture: gestureHandlesSequence :: (HasCallStack, MonadIO m, IsGesture a) => a -> Maybe EventSequence -> m Bool

- GI.Gtk.Objects.Gesture: gestureSetWindow :: (HasCallStack, MonadIO m, IsGesture a, IsWindow b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Gesture: gestureSetWindow :: (HasCallStack, MonadIO m, IsGesture a, IsWindow b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Gesture: type GestureBeginCallback = EventSequence /@sequence@/: the 'GI.Gdk.Structs.EventSequence.EventSequence' that made the gesture to be recognized -> IO ()

+ GI.Gtk.Objects.Gesture: type GestureBeginCallback = EventSequence " /@sequence@/: the 'GI.Gdk.Structs.EventSequence.EventSequence' that made the gesture to be recognized " -> IO ()

- GI.Gtk.Objects.Gesture: type GestureCancelCallback = EventSequence /@sequence@/: the 'GI.Gdk.Structs.EventSequence.EventSequence' that was cancelled -> IO ()

+ GI.Gtk.Objects.Gesture: type GestureCancelCallback = EventSequence " /@sequence@/: the 'GI.Gdk.Structs.EventSequence.EventSequence' that was cancelled " -> IO ()

- GI.Gtk.Objects.Gesture: type GestureEndCallback = EventSequence /@sequence@/: the 'GI.Gdk.Structs.EventSequence.EventSequence' that made gesture recognition to finish -> IO ()

+ GI.Gtk.Objects.Gesture: type GestureEndCallback = EventSequence " /@sequence@/: the 'GI.Gdk.Structs.EventSequence.EventSequence' that made gesture recognition to finish " -> IO ()

- GI.Gtk.Objects.Gesture: type GestureSequenceStateChangedCallback = EventSequence /@sequence@/: the 'GI.Gdk.Structs.EventSequence.EventSequence' that was cancelled -> EventSequenceState /@state@/: the new sequence state -> IO ()

+ GI.Gtk.Objects.Gesture: type GestureSequenceStateChangedCallback = EventSequence " /@sequence@/: the 'GI.Gdk.Structs.EventSequence.EventSequence' that was cancelled " -> EventSequenceState " /@state@/: the new sequence state " -> IO ()

- GI.Gtk.Objects.Gesture: type GestureUpdateCallback = EventSequence /@sequence@/: the 'GI.Gdk.Structs.EventSequence.EventSequence' that was updated -> IO ()

+ GI.Gtk.Objects.Gesture: type GestureUpdateCallback = EventSequence " /@sequence@/: the 'GI.Gdk.Structs.EventSequence.EventSequence' that was updated " -> IO ()

- GI.Gtk.Objects.GestureDrag: GestureDrag :: (ManagedPtr GestureDrag) -> GestureDrag

+ GI.Gtk.Objects.GestureDrag: GestureDrag :: ManagedPtr GestureDrag -> GestureDrag

- GI.Gtk.Objects.GestureDrag: gestureDragGetOffset :: (HasCallStack, MonadIO m, IsGestureDrag a) => a -> m ((Bool, Double, Double))

+ GI.Gtk.Objects.GestureDrag: gestureDragGetOffset :: (HasCallStack, MonadIO m, IsGestureDrag a) => a -> m (Bool, Double, Double)

- GI.Gtk.Objects.GestureDrag: gestureDragGetStartPoint :: (HasCallStack, MonadIO m, IsGestureDrag a) => a -> m ((Bool, Double, Double))

+ GI.Gtk.Objects.GestureDrag: gestureDragGetStartPoint :: (HasCallStack, MonadIO m, IsGestureDrag a) => a -> m (Bool, Double, Double)

- GI.Gtk.Objects.GestureDrag: type GestureDragDragBeginCallback = Double /@startX@/: X coordinate, relative to the widget allocation -> Double /@startY@/: Y coordinate, relative to the widget allocation -> IO ()

+ GI.Gtk.Objects.GestureDrag: type GestureDragDragBeginCallback = Double " /@startX@/: X coordinate, relative to the widget allocation " -> Double " /@startY@/: Y coordinate, relative to the widget allocation " -> IO ()

- GI.Gtk.Objects.GestureDrag: type GestureDragDragEndCallback = Double /@offsetX@/: X offset, relative to the start point -> Double /@offsetY@/: Y offset, relative to the start point -> IO ()

+ GI.Gtk.Objects.GestureDrag: type GestureDragDragEndCallback = Double " /@offsetX@/: X offset, relative to the start point " -> Double " /@offsetY@/: Y offset, relative to the start point " -> IO ()

- GI.Gtk.Objects.GestureDrag: type GestureDragDragUpdateCallback = Double /@offsetX@/: X offset, relative to the start point -> Double /@offsetY@/: Y offset, relative to the start point -> IO ()

+ GI.Gtk.Objects.GestureDrag: type GestureDragDragUpdateCallback = Double " /@offsetX@/: X offset, relative to the start point " -> Double " /@offsetY@/: Y offset, relative to the start point " -> IO ()

- GI.Gtk.Objects.GestureLongPress: GestureLongPress :: (ManagedPtr GestureLongPress) -> GestureLongPress

+ GI.Gtk.Objects.GestureLongPress: GestureLongPress :: ManagedPtr GestureLongPress -> GestureLongPress

- GI.Gtk.Objects.GestureLongPress: constructGestureLongPressDelayFactor :: (IsGestureLongPress o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.GestureLongPress: constructGestureLongPressDelayFactor :: IsGestureLongPress o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.GestureLongPress: type GestureLongPressPressedCallback = Double /@x@/: the X coordinate where the press happened, relative to the widget allocation -> Double /@y@/: the Y coordinate where the press happened, relative to the widget allocation -> IO ()

+ GI.Gtk.Objects.GestureLongPress: type GestureLongPressPressedCallback = Double " /@x@/: the X coordinate where the press happened, relative to the widget allocation " -> Double " /@y@/: the Y coordinate where the press happened, relative to the widget allocation " -> IO ()

- GI.Gtk.Objects.GestureMultiPress: GestureMultiPress :: (ManagedPtr GestureMultiPress) -> GestureMultiPress

+ GI.Gtk.Objects.GestureMultiPress: GestureMultiPress :: ManagedPtr GestureMultiPress -> GestureMultiPress

- GI.Gtk.Objects.GestureMultiPress: gestureMultiPressGetArea :: (HasCallStack, MonadIO m, IsGestureMultiPress a) => a -> m ((Bool, Rectangle))

+ GI.Gtk.Objects.GestureMultiPress: gestureMultiPressGetArea :: (HasCallStack, MonadIO m, IsGestureMultiPress a) => a -> m (Bool, Rectangle)

- GI.Gtk.Objects.GestureMultiPress: gestureMultiPressSetArea :: (HasCallStack, MonadIO m, IsGestureMultiPress a) => a -> Maybe (Rectangle) -> m ()

+ GI.Gtk.Objects.GestureMultiPress: gestureMultiPressSetArea :: (HasCallStack, MonadIO m, IsGestureMultiPress a) => a -> Maybe Rectangle -> m ()

- GI.Gtk.Objects.GestureMultiPress: type GestureMultiPressPressedCallback = Int32 /@nPress@/: how many touch\/button presses happened with this one -> Double /@x@/: The X coordinate, in widget allocation coordinates -> Double /@y@/: The Y coordinate, in widget allocation coordinates -> IO ()

+ GI.Gtk.Objects.GestureMultiPress: type GestureMultiPressPressedCallback = Int32 " /@nPress@/: how many touch\/button presses happened with this one " -> Double " /@x@/: The X coordinate, in widget allocation coordinates " -> Double " /@y@/: The Y coordinate, in widget allocation coordinates " -> IO ()

- GI.Gtk.Objects.GestureMultiPress: type GestureMultiPressReleasedCallback = Int32 /@nPress@/: number of press that is paired with this release -> Double /@x@/: The X coordinate, in widget allocation coordinates -> Double /@y@/: The Y coordinate, in widget allocation coordinates -> IO ()

+ GI.Gtk.Objects.GestureMultiPress: type GestureMultiPressReleasedCallback = Int32 " /@nPress@/: number of press that is paired with this release " -> Double " /@x@/: The X coordinate, in widget allocation coordinates " -> Double " /@y@/: The Y coordinate, in widget allocation coordinates " -> IO ()

- GI.Gtk.Objects.GesturePan: GesturePan :: (ManagedPtr GesturePan) -> GesturePan

+ GI.Gtk.Objects.GesturePan: GesturePan :: ManagedPtr GesturePan -> GesturePan

- GI.Gtk.Objects.GesturePan: constructGesturePanOrientation :: (IsGesturePan o) => Orientation -> IO (GValueConstruct o)

+ GI.Gtk.Objects.GesturePan: constructGesturePanOrientation :: IsGesturePan o => Orientation -> IO (GValueConstruct o)

- GI.Gtk.Objects.GesturePan: type GesturePanPanCallback = PanDirection /@direction@/: current direction of the pan gesture -> Double /@offset@/: Offset along the gesture orientation -> IO ()

+ GI.Gtk.Objects.GesturePan: type GesturePanPanCallback = PanDirection " /@direction@/: current direction of the pan gesture " -> Double " /@offset@/: Offset along the gesture orientation " -> IO ()

- GI.Gtk.Objects.GestureRotate: GestureRotate :: (ManagedPtr GestureRotate) -> GestureRotate

+ GI.Gtk.Objects.GestureRotate: GestureRotate :: ManagedPtr GestureRotate -> GestureRotate

- GI.Gtk.Objects.GestureRotate: type GestureRotateAngleChangedCallback = Double /@angle@/: Current angle in radians -> Double /@angleDelta@/: Difference with the starting angle, in radians -> IO ()

+ GI.Gtk.Objects.GestureRotate: type GestureRotateAngleChangedCallback = Double " /@angle@/: Current angle in radians " -> Double " /@angleDelta@/: Difference with the starting angle, in radians " -> IO ()

- GI.Gtk.Objects.GestureSingle: GestureSingle :: (ManagedPtr GestureSingle) -> GestureSingle

+ GI.Gtk.Objects.GestureSingle: GestureSingle :: ManagedPtr GestureSingle -> GestureSingle

- GI.Gtk.Objects.GestureSingle: constructGestureSingleButton :: (IsGestureSingle o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.GestureSingle: constructGestureSingleButton :: IsGestureSingle o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.GestureSingle: constructGestureSingleExclusive :: (IsGestureSingle o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.GestureSingle: constructGestureSingleExclusive :: IsGestureSingle o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.GestureSingle: constructGestureSingleTouchOnly :: (IsGestureSingle o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.GestureSingle: constructGestureSingleTouchOnly :: IsGestureSingle o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.GestureSwipe: GestureSwipe :: (ManagedPtr GestureSwipe) -> GestureSwipe

+ GI.Gtk.Objects.GestureSwipe: GestureSwipe :: ManagedPtr GestureSwipe -> GestureSwipe

- GI.Gtk.Objects.GestureSwipe: gestureSwipeGetVelocity :: (HasCallStack, MonadIO m, IsGestureSwipe a) => a -> m ((Bool, Double, Double))

+ GI.Gtk.Objects.GestureSwipe: gestureSwipeGetVelocity :: (HasCallStack, MonadIO m, IsGestureSwipe a) => a -> m (Bool, Double, Double)

- GI.Gtk.Objects.GestureSwipe: type GestureSwipeSwipeCallback = Double /@velocityX@/: velocity in the X axis, in pixels\/sec -> Double /@velocityY@/: velocity in the Y axis, in pixels\/sec -> IO ()

+ GI.Gtk.Objects.GestureSwipe: type GestureSwipeSwipeCallback = Double " /@velocityX@/: velocity in the X axis, in pixels\/sec " -> Double " /@velocityY@/: velocity in the Y axis, in pixels\/sec " -> IO ()

- GI.Gtk.Objects.GestureZoom: GestureZoom :: (ManagedPtr GestureZoom) -> GestureZoom

+ GI.Gtk.Objects.GestureZoom: GestureZoom :: ManagedPtr GestureZoom -> GestureZoom

- GI.Gtk.Objects.GestureZoom: type GestureZoomScaleChangedCallback = Double /@scale@/: Scale delta, taking the initial state as 1:1 -> IO ()

+ GI.Gtk.Objects.GestureZoom: type GestureZoomScaleChangedCallback = Double " /@scale@/: Scale delta, taking the initial state as 1:1 " -> IO ()

- GI.Gtk.Objects.Grid: Grid :: (ManagedPtr Grid) -> Grid

+ GI.Gtk.Objects.Grid: Grid :: ManagedPtr Grid -> Grid

- GI.Gtk.Objects.Grid: constructGridBaselineRow :: (IsGrid o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Grid: constructGridBaselineRow :: IsGrid o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Grid: constructGridColumnHomogeneous :: (IsGrid o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Grid: constructGridColumnHomogeneous :: IsGrid o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Grid: constructGridColumnSpacing :: (IsGrid o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Grid: constructGridColumnSpacing :: IsGrid o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Grid: constructGridRowHomogeneous :: (IsGrid o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Grid: constructGridRowHomogeneous :: IsGrid o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Grid: constructGridRowSpacing :: (IsGrid o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Grid: constructGridRowSpacing :: IsGrid o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Grid: gridAttachNextTo :: (HasCallStack, MonadIO m, IsGrid a, IsWidget b, IsWidget c) => a -> b -> Maybe (c) -> PositionType -> Int32 -> Int32 -> m ()

+ GI.Gtk.Objects.Grid: gridAttachNextTo :: (HasCallStack, MonadIO m, IsGrid a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> PositionType -> Int32 -> Int32 -> m ()

- GI.Gtk.Objects.HBox: HBox :: (ManagedPtr HBox) -> HBox

+ GI.Gtk.Objects.HBox: HBox :: ManagedPtr HBox -> HBox

- GI.Gtk.Objects.HButtonBox: HButtonBox :: (ManagedPtr HButtonBox) -> HButtonBox

+ GI.Gtk.Objects.HButtonBox: HButtonBox :: ManagedPtr HButtonBox -> HButtonBox

- GI.Gtk.Objects.HPaned: HPaned :: (ManagedPtr HPaned) -> HPaned

+ GI.Gtk.Objects.HPaned: HPaned :: ManagedPtr HPaned -> HPaned

- GI.Gtk.Objects.HSV: HSV :: (ManagedPtr HSV) -> HSV

+ GI.Gtk.Objects.HSV: HSV :: ManagedPtr HSV -> HSV

- GI.Gtk.Objects.HSV: hSVGetColor :: (HasCallStack, MonadIO m, IsHSV a) => a -> m ((Double, Double, Double))

+ GI.Gtk.Objects.HSV: hSVGetColor :: (HasCallStack, MonadIO m, IsHSV a) => a -> m (Double, Double, Double)

- GI.Gtk.Objects.HSV: hSVGetMetrics :: (HasCallStack, MonadIO m, IsHSV a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.HSV: hSVGetMetrics :: (HasCallStack, MonadIO m, IsHSV a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.HSV: hSVToRgb :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m ((Double, Double, Double))

+ GI.Gtk.Objects.HSV: hSVToRgb :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m (Double, Double, Double)

- GI.Gtk.Objects.HScale: HScale :: (ManagedPtr HScale) -> HScale

+ GI.Gtk.Objects.HScale: HScale :: ManagedPtr HScale -> HScale

- GI.Gtk.Objects.HScale: hScaleNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe (a) -> m HScale

+ GI.Gtk.Objects.HScale: hScaleNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe a -> m HScale

- GI.Gtk.Objects.HScrollbar: HScrollbar :: (ManagedPtr HScrollbar) -> HScrollbar

+ GI.Gtk.Objects.HScrollbar: HScrollbar :: ManagedPtr HScrollbar -> HScrollbar

- GI.Gtk.Objects.HScrollbar: hScrollbarNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe (a) -> m HScrollbar

+ GI.Gtk.Objects.HScrollbar: hScrollbarNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe a -> m HScrollbar

- GI.Gtk.Objects.HSeparator: HSeparator :: (ManagedPtr HSeparator) -> HSeparator

+ GI.Gtk.Objects.HSeparator: HSeparator :: ManagedPtr HSeparator -> HSeparator

- GI.Gtk.Objects.HandleBox: HandleBox :: (ManagedPtr HandleBox) -> HandleBox

+ GI.Gtk.Objects.HandleBox: HandleBox :: ManagedPtr HandleBox -> HandleBox

- GI.Gtk.Objects.HandleBox: constructHandleBoxHandlePosition :: (IsHandleBox o) => PositionType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.HandleBox: constructHandleBoxHandlePosition :: IsHandleBox o => PositionType -> IO (GValueConstruct o)

- GI.Gtk.Objects.HandleBox: constructHandleBoxShadowType :: (IsHandleBox o) => ShadowType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.HandleBox: constructHandleBoxShadowType :: IsHandleBox o => ShadowType -> IO (GValueConstruct o)

- GI.Gtk.Objects.HandleBox: constructHandleBoxSnapEdge :: (IsHandleBox o) => PositionType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.HandleBox: constructHandleBoxSnapEdge :: IsHandleBox o => PositionType -> IO (GValueConstruct o)

- GI.Gtk.Objects.HandleBox: constructHandleBoxSnapEdgeSet :: (IsHandleBox o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.HandleBox: constructHandleBoxSnapEdgeSet :: IsHandleBox o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.HandleBox: type HandleBoxChildAttachedCallback = Widget /@widget@/: the child widget of the handlebox. (this argument provides no extra information and is here only for backwards-compatibility) -> IO ()

+ GI.Gtk.Objects.HandleBox: type HandleBoxChildAttachedCallback = Widget " /@widget@/: the child widget of the handlebox. (this argument provides no extra information and is here only for backwards-compatibility) " -> IO ()

- GI.Gtk.Objects.HandleBox: type HandleBoxChildDetachedCallback = Widget /@widget@/: the child widget of the handlebox. (this argument provides no extra information and is here only for backwards-compatibility) -> IO ()

+ GI.Gtk.Objects.HandleBox: type HandleBoxChildDetachedCallback = Widget " /@widget@/: the child widget of the handlebox. (this argument provides no extra information and is here only for backwards-compatibility) " -> IO ()

- GI.Gtk.Objects.HeaderBar: HeaderBar :: (ManagedPtr HeaderBar) -> HeaderBar

+ GI.Gtk.Objects.HeaderBar: HeaderBar :: ManagedPtr HeaderBar -> HeaderBar

- GI.Gtk.Objects.HeaderBar: constructHeaderBarDecorationLayout :: (IsHeaderBar o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.HeaderBar: constructHeaderBarDecorationLayout :: IsHeaderBar o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.HeaderBar: constructHeaderBarDecorationLayoutSet :: (IsHeaderBar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.HeaderBar: constructHeaderBarDecorationLayoutSet :: IsHeaderBar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.HeaderBar: constructHeaderBarHasSubtitle :: (IsHeaderBar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.HeaderBar: constructHeaderBarHasSubtitle :: IsHeaderBar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.HeaderBar: constructHeaderBarShowCloseButton :: (IsHeaderBar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.HeaderBar: constructHeaderBarShowCloseButton :: IsHeaderBar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.HeaderBar: constructHeaderBarSpacing :: (IsHeaderBar o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.HeaderBar: constructHeaderBarSpacing :: IsHeaderBar o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.HeaderBar: constructHeaderBarSubtitle :: (IsHeaderBar o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.HeaderBar: constructHeaderBarSubtitle :: IsHeaderBar o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.HeaderBar: constructHeaderBarTitle :: (IsHeaderBar o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.HeaderBar: constructHeaderBarTitle :: IsHeaderBar o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.HeaderBar: headerBarSetCustomTitle :: (HasCallStack, MonadIO m, IsHeaderBar a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.HeaderBar: headerBarSetCustomTitle :: (HasCallStack, MonadIO m, IsHeaderBar a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.HeaderBar: headerBarSetDecorationLayout :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.HeaderBar: headerBarSetDecorationLayout :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.HeaderBar: headerBarSetSubtitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.HeaderBar: headerBarSetSubtitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.HeaderBar: headerBarSetTitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.HeaderBar: headerBarSetTitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.IMContext: IMContext :: (ManagedPtr IMContext) -> IMContext

+ GI.Gtk.Objects.IMContext: IMContext :: ManagedPtr IMContext -> IMContext

- GI.Gtk.Objects.IMContext: constructIMContextInputHints :: (IsIMContext o) => [InputHints] -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IMContext: constructIMContextInputHints :: IsIMContext o => [InputHints] -> IO (GValueConstruct o)

- GI.Gtk.Objects.IMContext: constructIMContextInputPurpose :: (IsIMContext o) => InputPurpose -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IMContext: constructIMContextInputPurpose :: IsIMContext o => InputPurpose -> IO (GValueConstruct o)

- GI.Gtk.Objects.IMContext: iMContextGetPreeditString :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m ((Text, AttrList, Int32))

+ GI.Gtk.Objects.IMContext: iMContextGetPreeditString :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m (Text, AttrList, Int32)

- GI.Gtk.Objects.IMContext: iMContextGetSurrounding :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m ((Bool, Text, Int32))

+ GI.Gtk.Objects.IMContext: iMContextGetSurrounding :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m (Bool, Text, Int32)

- GI.Gtk.Objects.IMContext: iMContextSetClientWindow :: (HasCallStack, MonadIO m, IsIMContext a, IsWindow b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.IMContext: iMContextSetClientWindow :: (HasCallStack, MonadIO m, IsIMContext a, IsWindow b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.IMContext: type IMContextCommitCallback = Text /@str@/: the completed character(s) entered by the user -> IO ()

+ GI.Gtk.Objects.IMContext: type IMContextCommitCallback = Text " /@str@/: the completed character(s) entered by the user " -> IO ()

- GI.Gtk.Objects.IMContext: type IMContextDeleteSurroundingCallback = Int32 /@offset@/: the character offset from the cursor position of the text to be deleted. A negative value indicates a position before the cursor. -> Int32 /@nChars@/: the number of characters to be deleted -> IO Bool __Returns:__ 'True' if the signal was handled.

+ GI.Gtk.Objects.IMContext: type IMContextDeleteSurroundingCallback = Int32 " /@offset@/: the character offset from the cursor position of the text to be deleted. A negative value indicates a position before the cursor. " -> Int32 " /@nChars@/: the number of characters to be deleted " -> IO Bool " __Returns:__ 'True' if the signal was handled. "

- GI.Gtk.Objects.IMContext: type IMContextRetrieveSurroundingCallback = IO Bool __Returns:__ 'True' if the signal was handled.

+ GI.Gtk.Objects.IMContext: type IMContextRetrieveSurroundingCallback = IO Bool " __Returns:__ 'True' if the signal was handled. "

- GI.Gtk.Objects.IMContextSimple: IMContextSimple :: (ManagedPtr IMContextSimple) -> IMContextSimple

+ GI.Gtk.Objects.IMContextSimple: IMContextSimple :: ManagedPtr IMContextSimple -> IMContextSimple

- GI.Gtk.Objects.IMMulticontext: IMMulticontext :: (ManagedPtr IMMulticontext) -> IMMulticontext

+ GI.Gtk.Objects.IMMulticontext: IMMulticontext :: ManagedPtr IMMulticontext -> IMMulticontext

- GI.Gtk.Objects.IconFactory: IconFactory :: (ManagedPtr IconFactory) -> IconFactory

+ GI.Gtk.Objects.IconFactory: IconFactory :: ManagedPtr IconFactory -> IconFactory

- GI.Gtk.Objects.IconInfo: IconInfo :: (ManagedPtr IconInfo) -> IconInfo

+ GI.Gtk.Objects.IconInfo: IconInfo :: ManagedPtr IconInfo -> IconInfo

- GI.Gtk.Objects.IconInfo: iconInfoGetAttachPoints :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m ((Bool, [Point]))

+ GI.Gtk.Objects.IconInfo: iconInfoGetAttachPoints :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m (Bool, [Point])

- GI.Gtk.Objects.IconInfo: iconInfoGetEmbeddedRect :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m ((Bool, Rectangle))

+ GI.Gtk.Objects.IconInfo: iconInfoGetEmbeddedRect :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m (Bool, Rectangle)

- GI.Gtk.Objects.IconInfo: iconInfoLoadIconAsync :: (HasCallStack, MonadIO m, IsIconInfo a, IsCancellable b) => a -> Maybe (b) -> Maybe (AsyncReadyCallback) -> m ()

+ GI.Gtk.Objects.IconInfo: iconInfoLoadIconAsync :: (HasCallStack, MonadIO m, IsIconInfo a, IsCancellable b) => a -> Maybe b -> Maybe AsyncReadyCallback -> m ()

- GI.Gtk.Objects.IconInfo: iconInfoLoadSurface :: (HasCallStack, MonadIO m, IsIconInfo a, IsWindow b) => a -> Maybe (b) -> m Surface

+ GI.Gtk.Objects.IconInfo: iconInfoLoadSurface :: (HasCallStack, MonadIO m, IsIconInfo a, IsWindow b) => a -> Maybe b -> m Surface

- GI.Gtk.Objects.IconInfo: iconInfoLoadSymbolic :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> RGBA -> Maybe (RGBA) -> Maybe (RGBA) -> Maybe (RGBA) -> m ((Pixbuf, Bool))

+ GI.Gtk.Objects.IconInfo: iconInfoLoadSymbolic :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> RGBA -> Maybe RGBA -> Maybe RGBA -> Maybe RGBA -> m (Pixbuf, Bool)

- GI.Gtk.Objects.IconInfo: iconInfoLoadSymbolicAsync :: (HasCallStack, MonadIO m, IsIconInfo a, IsCancellable b) => a -> RGBA -> Maybe (RGBA) -> Maybe (RGBA) -> Maybe (RGBA) -> Maybe (b) -> Maybe (AsyncReadyCallback) -> m ()

+ GI.Gtk.Objects.IconInfo: iconInfoLoadSymbolicAsync :: (HasCallStack, MonadIO m, IsIconInfo a, IsCancellable b) => a -> RGBA -> Maybe RGBA -> Maybe RGBA -> Maybe RGBA -> Maybe b -> Maybe AsyncReadyCallback -> m ()

- GI.Gtk.Objects.IconInfo: iconInfoLoadSymbolicFinish :: (HasCallStack, MonadIO m, IsIconInfo a, IsAsyncResult b) => a -> b -> m ((Pixbuf, Bool))

+ GI.Gtk.Objects.IconInfo: iconInfoLoadSymbolicFinish :: (HasCallStack, MonadIO m, IsIconInfo a, IsAsyncResult b) => a -> b -> m (Pixbuf, Bool)

- GI.Gtk.Objects.IconInfo: iconInfoLoadSymbolicForContext :: (HasCallStack, MonadIO m, IsIconInfo a, IsStyleContext b) => a -> b -> m ((Pixbuf, Bool))

+ GI.Gtk.Objects.IconInfo: iconInfoLoadSymbolicForContext :: (HasCallStack, MonadIO m, IsIconInfo a, IsStyleContext b) => a -> b -> m (Pixbuf, Bool)

- GI.Gtk.Objects.IconInfo: iconInfoLoadSymbolicForContextAsync :: (HasCallStack, MonadIO m, IsIconInfo a, IsStyleContext b, IsCancellable c) => a -> b -> Maybe (c) -> Maybe (AsyncReadyCallback) -> m ()

+ GI.Gtk.Objects.IconInfo: iconInfoLoadSymbolicForContextAsync :: (HasCallStack, MonadIO m, IsIconInfo a, IsStyleContext b, IsCancellable c) => a -> b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

- GI.Gtk.Objects.IconInfo: iconInfoLoadSymbolicForContextFinish :: (HasCallStack, MonadIO m, IsIconInfo a, IsAsyncResult b) => a -> b -> m ((Pixbuf, Bool))

+ GI.Gtk.Objects.IconInfo: iconInfoLoadSymbolicForContextFinish :: (HasCallStack, MonadIO m, IsIconInfo a, IsAsyncResult b) => a -> b -> m (Pixbuf, Bool)

- GI.Gtk.Objects.IconInfo: iconInfoLoadSymbolicForStyle :: (HasCallStack, MonadIO m, IsIconInfo a, IsStyle b) => a -> b -> StateType -> m ((Pixbuf, Bool))

+ GI.Gtk.Objects.IconInfo: iconInfoLoadSymbolicForStyle :: (HasCallStack, MonadIO m, IsIconInfo a, IsStyle b) => a -> b -> StateType -> m (Pixbuf, Bool)

- GI.Gtk.Objects.IconTheme: IconTheme :: (ManagedPtr IconTheme) -> IconTheme

+ GI.Gtk.Objects.IconTheme: IconTheme :: ManagedPtr IconTheme -> IconTheme

- GI.Gtk.Objects.IconTheme: iconThemeGetSearchPath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> m ([[Char]])

+ GI.Gtk.Objects.IconTheme: iconThemeGetSearchPath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> m [[Char]]

- GI.Gtk.Objects.IconTheme: iconThemeListIcons :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Maybe (Text) -> m [Text]

+ GI.Gtk.Objects.IconTheme: iconThemeListIcons :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Maybe Text -> m [Text]

- GI.Gtk.Objects.IconTheme: iconThemeLoadSurface :: (HasCallStack, MonadIO m, IsIconTheme a, IsWindow b) => a -> Text -> Int32 -> Int32 -> Maybe (b) -> [IconLookupFlags] -> m (Maybe Surface)

+ GI.Gtk.Objects.IconTheme: iconThemeLoadSurface :: (HasCallStack, MonadIO m, IsIconTheme a, IsWindow b) => a -> Text -> Int32 -> Int32 -> Maybe b -> [IconLookupFlags] -> m (Maybe Surface)

- GI.Gtk.Objects.IconTheme: iconThemeSetCustomTheme :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.IconTheme: iconThemeSetCustomTheme :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.IconView: IconView :: (ManagedPtr IconView) -> IconView

+ GI.Gtk.Objects.IconView: IconView :: ManagedPtr IconView -> IconView

- GI.Gtk.Objects.IconView: constructIconViewActivateOnSingleClick :: (IsIconView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewActivateOnSingleClick :: IsIconView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: constructIconViewColumnSpacing :: (IsIconView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewColumnSpacing :: IsIconView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: constructIconViewColumns :: (IsIconView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewColumns :: IsIconView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: constructIconViewItemOrientation :: (IsIconView o) => Orientation -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewItemOrientation :: IsIconView o => Orientation -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: constructIconViewItemPadding :: (IsIconView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewItemPadding :: IsIconView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: constructIconViewItemWidth :: (IsIconView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewItemWidth :: IsIconView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: constructIconViewMargin :: (IsIconView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewMargin :: IsIconView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: constructIconViewMarkupColumn :: (IsIconView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewMarkupColumn :: IsIconView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: constructIconViewPixbufColumn :: (IsIconView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewPixbufColumn :: IsIconView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: constructIconViewReorderable :: (IsIconView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewReorderable :: IsIconView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: constructIconViewRowSpacing :: (IsIconView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewRowSpacing :: IsIconView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: constructIconViewSelectionMode :: (IsIconView o) => SelectionMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewSelectionMode :: IsIconView o => SelectionMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: constructIconViewSpacing :: (IsIconView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewSpacing :: IsIconView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: constructIconViewTextColumn :: (IsIconView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewTextColumn :: IsIconView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: constructIconViewTooltipColumn :: (IsIconView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.IconView: constructIconViewTooltipColumn :: IsIconView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.IconView: iconViewConvertWidgetToBinWindowCoords :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.IconView: iconViewConvertWidgetToBinWindowCoords :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.IconView: iconViewGetCellRect :: (HasCallStack, MonadIO m, IsIconView a, IsCellRenderer b) => a -> TreePath -> Maybe (b) -> m ((Bool, Rectangle))

+ GI.Gtk.Objects.IconView: iconViewGetCellRect :: (HasCallStack, MonadIO m, IsIconView a, IsCellRenderer b) => a -> TreePath -> Maybe b -> m (Bool, Rectangle)

- GI.Gtk.Objects.IconView: iconViewGetCursor :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ((Bool, TreePath, CellRenderer))

+ GI.Gtk.Objects.IconView: iconViewGetCursor :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (Bool, TreePath, CellRenderer)

- GI.Gtk.Objects.IconView: iconViewGetDestItemAtPos :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m ((Bool, TreePath, IconViewDropPosition))

+ GI.Gtk.Objects.IconView: iconViewGetDestItemAtPos :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m (Bool, TreePath, IconViewDropPosition)

- GI.Gtk.Objects.IconView: iconViewGetDragDestItem :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ((TreePath, IconViewDropPosition))

+ GI.Gtk.Objects.IconView: iconViewGetDragDestItem :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (TreePath, IconViewDropPosition)

- GI.Gtk.Objects.IconView: iconViewGetItemAtPos :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m ((Bool, TreePath, CellRenderer))

+ GI.Gtk.Objects.IconView: iconViewGetItemAtPos :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m (Bool, TreePath, CellRenderer)

- GI.Gtk.Objects.IconView: iconViewGetTooltipContext :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> Bool -> m ((Bool, Int32, Int32, TreeModel, TreePath, TreeIter))

+ GI.Gtk.Objects.IconView: iconViewGetTooltipContext :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> Bool -> m (Bool, Int32, Int32, TreeModel, TreePath, TreeIter)

- GI.Gtk.Objects.IconView: iconViewGetVisibleRange :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ((Bool, TreePath, TreePath))

+ GI.Gtk.Objects.IconView: iconViewGetVisibleRange :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (Bool, TreePath, TreePath)

- GI.Gtk.Objects.IconView: iconViewSetCursor :: (HasCallStack, MonadIO m, IsIconView a, IsCellRenderer b) => a -> TreePath -> Maybe (b) -> Bool -> m ()

+ GI.Gtk.Objects.IconView: iconViewSetCursor :: (HasCallStack, MonadIO m, IsIconView a, IsCellRenderer b) => a -> TreePath -> Maybe b -> Bool -> m ()

- GI.Gtk.Objects.IconView: iconViewSetDragDestItem :: (HasCallStack, MonadIO m, IsIconView a) => a -> Maybe (TreePath) -> IconViewDropPosition -> m ()

+ GI.Gtk.Objects.IconView: iconViewSetDragDestItem :: (HasCallStack, MonadIO m, IsIconView a) => a -> Maybe TreePath -> IconViewDropPosition -> m ()

- GI.Gtk.Objects.IconView: iconViewSetModel :: (HasCallStack, MonadIO m, IsIconView a, IsTreeModel b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.IconView: iconViewSetModel :: (HasCallStack, MonadIO m, IsIconView a, IsTreeModel b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.IconView: iconViewSetTooltipCell :: (HasCallStack, MonadIO m, IsIconView a, IsTooltip b, IsCellRenderer c) => a -> b -> TreePath -> Maybe (c) -> m ()

+ GI.Gtk.Objects.IconView: iconViewSetTooltipCell :: (HasCallStack, MonadIO m, IsIconView a, IsTooltip b, IsCellRenderer c) => a -> b -> TreePath -> Maybe c -> m ()

- GI.Gtk.Objects.IconView: type IconViewItemActivatedCallback = TreePath /@path@/: the 'GI.Gtk.Structs.TreePath.TreePath' for the activated item -> IO ()

+ GI.Gtk.Objects.IconView: type IconViewItemActivatedCallback = TreePath " /@path@/: the 'GI.Gtk.Structs.TreePath.TreePath' for the activated item " -> IO ()

- GI.Gtk.Objects.IconView: type IconViewMoveCursorCallback = MovementStep /@step@/: the granularity of the move, as a 'GI.Gtk.Enums.MovementStep' -> Int32 /@count@/: the number of /@step@/ units to move -> IO Bool

+ GI.Gtk.Objects.IconView: type IconViewMoveCursorCallback = MovementStep " /@step@/: the granularity of the move, as a 'GI.Gtk.Enums.MovementStep' " -> Int32 " /@count@/: the number of /@step@/ units to move " -> IO Bool

- GI.Gtk.Objects.IconViewAccessible: IconViewAccessible :: (ManagedPtr IconViewAccessible) -> IconViewAccessible

+ GI.Gtk.Objects.IconViewAccessible: IconViewAccessible :: ManagedPtr IconViewAccessible -> IconViewAccessible

- GI.Gtk.Objects.Image: Image :: (ManagedPtr Image) -> Image

+ GI.Gtk.Objects.Image: Image :: ManagedPtr Image -> Image

- GI.Gtk.Objects.Image: constructImageFile :: (IsImage o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Image: constructImageFile :: IsImage o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Image: constructImageIconName :: (IsImage o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Image: constructImageIconName :: IsImage o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Image: constructImageIconSet :: (IsImage o) => IconSet -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Image: constructImageIconSet :: IsImage o => IconSet -> IO (GValueConstruct o)

- GI.Gtk.Objects.Image: constructImageIconSize :: (IsImage o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Image: constructImageIconSize :: IsImage o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Image: constructImagePixelSize :: (IsImage o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Image: constructImagePixelSize :: IsImage o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Image: constructImageResource :: (IsImage o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Image: constructImageResource :: IsImage o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Image: constructImageStock :: (IsImage o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Image: constructImageStock :: IsImage o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Image: constructImageSurface :: (IsImage o) => Surface -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Image: constructImageSurface :: IsImage o => Surface -> IO (GValueConstruct o)

- GI.Gtk.Objects.Image: constructImageUseFallback :: (IsImage o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Image: constructImageUseFallback :: IsImage o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Image: imageGetGicon :: (HasCallStack, MonadIO m, IsImage a) => a -> m ((Icon, Int32))

+ GI.Gtk.Objects.Image: imageGetGicon :: (HasCallStack, MonadIO m, IsImage a) => a -> m (Icon, Int32)

- GI.Gtk.Objects.Image: imageGetIconName :: (HasCallStack, MonadIO m, IsImage a) => a -> m ((Text, Int32))

+ GI.Gtk.Objects.Image: imageGetIconName :: (HasCallStack, MonadIO m, IsImage a) => a -> m (Text, Int32)

- GI.Gtk.Objects.Image: imageGetIconSet :: (HasCallStack, MonadIO m, IsImage a) => a -> m ((IconSet, Int32))

+ GI.Gtk.Objects.Image: imageGetIconSet :: (HasCallStack, MonadIO m, IsImage a) => a -> m (IconSet, Int32)

- GI.Gtk.Objects.Image: imageGetStock :: (HasCallStack, MonadIO m, IsImage a) => a -> m ((Text, Int32))

+ GI.Gtk.Objects.Image: imageGetStock :: (HasCallStack, MonadIO m, IsImage a) => a -> m (Text, Int32)

- GI.Gtk.Objects.Image: imageNewFromIconName :: (HasCallStack, MonadIO m) => Maybe (Text) -> Int32 -> m Image

+ GI.Gtk.Objects.Image: imageNewFromIconName :: (HasCallStack, MonadIO m) => Maybe Text -> Int32 -> m Image

- GI.Gtk.Objects.Image: imageNewFromPixbuf :: (HasCallStack, MonadIO m, IsPixbuf a) => Maybe (a) -> m Image

+ GI.Gtk.Objects.Image: imageNewFromPixbuf :: (HasCallStack, MonadIO m, IsPixbuf a) => Maybe a -> m Image

- GI.Gtk.Objects.Image: imageNewFromSurface :: (HasCallStack, MonadIO m) => Maybe (Surface) -> m Image

+ GI.Gtk.Objects.Image: imageNewFromSurface :: (HasCallStack, MonadIO m) => Maybe Surface -> m Image

- GI.Gtk.Objects.Image: imageSetFromFile :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe ([Char]) -> m ()

+ GI.Gtk.Objects.Image: imageSetFromFile :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe [Char] -> m ()

- GI.Gtk.Objects.Image: imageSetFromIconName :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe (Text) -> Int32 -> m ()

+ GI.Gtk.Objects.Image: imageSetFromIconName :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe Text -> Int32 -> m ()

- GI.Gtk.Objects.Image: imageSetFromPixbuf :: (HasCallStack, MonadIO m, IsImage a, IsPixbuf b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Image: imageSetFromPixbuf :: (HasCallStack, MonadIO m, IsImage a, IsPixbuf b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Image: imageSetFromResource :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Image: imageSetFromResource :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.Image: imageSetFromSurface :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe (Surface) -> m ()

+ GI.Gtk.Objects.Image: imageSetFromSurface :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe Surface -> m ()

- GI.Gtk.Objects.ImageAccessible: ImageAccessible :: (ManagedPtr ImageAccessible) -> ImageAccessible

+ GI.Gtk.Objects.ImageAccessible: ImageAccessible :: ManagedPtr ImageAccessible -> ImageAccessible

- GI.Gtk.Objects.ImageCellAccessible: ImageCellAccessible :: (ManagedPtr ImageCellAccessible) -> ImageCellAccessible

+ GI.Gtk.Objects.ImageCellAccessible: ImageCellAccessible :: ManagedPtr ImageCellAccessible -> ImageCellAccessible

- GI.Gtk.Objects.ImageMenuItem: ImageMenuItem :: (ManagedPtr ImageMenuItem) -> ImageMenuItem

+ GI.Gtk.Objects.ImageMenuItem: ImageMenuItem :: ManagedPtr ImageMenuItem -> ImageMenuItem

- GI.Gtk.Objects.ImageMenuItem: constructImageMenuItemAlwaysShowImage :: (IsImageMenuItem o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ImageMenuItem: constructImageMenuItemAlwaysShowImage :: IsImageMenuItem o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ImageMenuItem: constructImageMenuItemUseStock :: (IsImageMenuItem o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ImageMenuItem: constructImageMenuItemUseStock :: IsImageMenuItem o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ImageMenuItem: imageMenuItemNewFromStock :: (HasCallStack, MonadIO m, IsAccelGroup a) => Text -> Maybe (a) -> m ImageMenuItem

+ GI.Gtk.Objects.ImageMenuItem: imageMenuItemNewFromStock :: (HasCallStack, MonadIO m, IsAccelGroup a) => Text -> Maybe a -> m ImageMenuItem

- GI.Gtk.Objects.ImageMenuItem: imageMenuItemSetImage :: (HasCallStack, MonadIO m, IsImageMenuItem a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.ImageMenuItem: imageMenuItemSetImage :: (HasCallStack, MonadIO m, IsImageMenuItem a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.InfoBar: InfoBar :: (ManagedPtr InfoBar) -> InfoBar

+ GI.Gtk.Objects.InfoBar: InfoBar :: ManagedPtr InfoBar -> InfoBar

- GI.Gtk.Objects.InfoBar: constructInfoBarMessageType :: (IsInfoBar o) => MessageType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.InfoBar: constructInfoBarMessageType :: IsInfoBar o => MessageType -> IO (GValueConstruct o)

- GI.Gtk.Objects.InfoBar: constructInfoBarRevealed :: (IsInfoBar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.InfoBar: constructInfoBarRevealed :: IsInfoBar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.InfoBar: constructInfoBarShowCloseButton :: (IsInfoBar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.InfoBar: constructInfoBarShowCloseButton :: IsInfoBar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.InfoBar: type InfoBarResponseCallback = Int32 /@responseId@/: the response ID -> IO ()

+ GI.Gtk.Objects.InfoBar: type InfoBarResponseCallback = Int32 " /@responseId@/: the response ID " -> IO ()

- GI.Gtk.Objects.Invisible: Invisible :: (ManagedPtr Invisible) -> Invisible

+ GI.Gtk.Objects.Invisible: Invisible :: ManagedPtr Invisible -> Invisible

- GI.Gtk.Objects.Label: Label :: (ManagedPtr Label) -> Label

+ GI.Gtk.Objects.Label: Label :: ManagedPtr Label -> Label

- GI.Gtk.Objects.Label: constructLabelAngle :: (IsLabel o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelAngle :: IsLabel o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelAttributes :: (IsLabel o) => AttrList -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelAttributes :: IsLabel o => AttrList -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelEllipsize :: (IsLabel o) => EllipsizeMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelEllipsize :: IsLabel o => EllipsizeMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelJustify :: (IsLabel o) => Justification -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelJustify :: IsLabel o => Justification -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelLabel :: (IsLabel o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelLabel :: IsLabel o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelLines :: (IsLabel o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelLines :: IsLabel o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelMaxWidthChars :: (IsLabel o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelMaxWidthChars :: IsLabel o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelPattern :: (IsLabel o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelPattern :: IsLabel o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelSelectable :: (IsLabel o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelSelectable :: IsLabel o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelSingleLineMode :: (IsLabel o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelSingleLineMode :: IsLabel o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelTrackVisitedLinks :: (IsLabel o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelTrackVisitedLinks :: IsLabel o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelUseMarkup :: (IsLabel o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelUseMarkup :: IsLabel o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelUseUnderline :: (IsLabel o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelUseUnderline :: IsLabel o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelWidthChars :: (IsLabel o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelWidthChars :: IsLabel o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelWrap :: (IsLabel o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelWrap :: IsLabel o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelWrapMode :: (IsLabel o) => WrapMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelWrapMode :: IsLabel o => WrapMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelXalign :: (IsLabel o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelXalign :: IsLabel o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: constructLabelYalign :: (IsLabel o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Label: constructLabelYalign :: IsLabel o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.Label: labelGetLayoutOffsets :: (HasCallStack, MonadIO m, IsLabel a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.Label: labelGetLayoutOffsets :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.Label: labelGetSelectionBounds :: (HasCallStack, MonadIO m, IsLabel a) => a -> m ((Bool, Int32, Int32))

+ GI.Gtk.Objects.Label: labelGetSelectionBounds :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Bool, Int32, Int32)

- GI.Gtk.Objects.Label: labelNew :: (HasCallStack, MonadIO m) => Maybe (Text) -> m Label

+ GI.Gtk.Objects.Label: labelNew :: (HasCallStack, MonadIO m) => Maybe Text -> m Label

- GI.Gtk.Objects.Label: labelNewWithMnemonic :: (HasCallStack, MonadIO m) => Maybe (Text) -> m Label

+ GI.Gtk.Objects.Label: labelNewWithMnemonic :: (HasCallStack, MonadIO m) => Maybe Text -> m Label

- GI.Gtk.Objects.Label: labelSetAttributes :: (HasCallStack, MonadIO m, IsLabel a) => a -> Maybe (AttrList) -> m ()

+ GI.Gtk.Objects.Label: labelSetAttributes :: (HasCallStack, MonadIO m, IsLabel a) => a -> Maybe AttrList -> m ()

- GI.Gtk.Objects.Label: labelSetMnemonicWidget :: (HasCallStack, MonadIO m, IsLabel a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Label: labelSetMnemonicWidget :: (HasCallStack, MonadIO m, IsLabel a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Label: type LabelActivateLinkCallback = Text /@uri@/: the URI that is activated -> IO Bool __Returns:__ 'True' if the link has been activated

+ GI.Gtk.Objects.Label: type LabelActivateLinkCallback = Text " /@uri@/: the URI that is activated " -> IO Bool " __Returns:__ 'True' if the link has been activated "

- GI.Gtk.Objects.Label: type LabelMoveCursorCallback = MovementStep /@step@/: the granularity of the move, as a 'GI.Gtk.Enums.MovementStep' -> Int32 /@count@/: the number of /@step@/ units to move -> Bool /@extendSelection@/: 'True' if the move should extend the selection -> IO ()

+ GI.Gtk.Objects.Label: type LabelMoveCursorCallback = MovementStep " /@step@/: the granularity of the move, as a 'GI.Gtk.Enums.MovementStep' " -> Int32 " /@count@/: the number of /@step@/ units to move " -> Bool " /@extendSelection@/: 'True' if the move should extend the selection " -> IO ()

- GI.Gtk.Objects.Label: type LabelPopulatePopupCallback = Menu /@menu@/: the menu that is being populated -> IO ()

+ GI.Gtk.Objects.Label: type LabelPopulatePopupCallback = Menu " /@menu@/: the menu that is being populated " -> IO ()

- GI.Gtk.Objects.LabelAccessible: LabelAccessible :: (ManagedPtr LabelAccessible) -> LabelAccessible

+ GI.Gtk.Objects.LabelAccessible: LabelAccessible :: ManagedPtr LabelAccessible -> LabelAccessible

- GI.Gtk.Objects.Layout: Layout :: (ManagedPtr Layout) -> Layout

+ GI.Gtk.Objects.Layout: Layout :: ManagedPtr Layout -> Layout

- GI.Gtk.Objects.Layout: constructLayoutHeight :: (IsLayout o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Layout: constructLayoutHeight :: IsLayout o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Layout: constructLayoutWidth :: (IsLayout o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Layout: constructLayoutWidth :: IsLayout o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Layout: layoutGetSize :: (HasCallStack, MonadIO m, IsLayout a) => a -> m ((Word32, Word32))

+ GI.Gtk.Objects.Layout: layoutGetSize :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Word32, Word32)

- GI.Gtk.Objects.Layout: layoutNew :: (HasCallStack, MonadIO m, IsAdjustment a, IsAdjustment b) => Maybe (a) -> Maybe (b) -> m Layout

+ GI.Gtk.Objects.Layout: layoutNew :: (HasCallStack, MonadIO m, IsAdjustment a, IsAdjustment b) => Maybe a -> Maybe b -> m Layout

- GI.Gtk.Objects.Layout: layoutSetHadjustment :: (HasCallStack, MonadIO m, IsLayout a, IsAdjustment b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Layout: layoutSetHadjustment :: (HasCallStack, MonadIO m, IsLayout a, IsAdjustment b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Layout: layoutSetVadjustment :: (HasCallStack, MonadIO m, IsLayout a, IsAdjustment b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Layout: layoutSetVadjustment :: (HasCallStack, MonadIO m, IsLayout a, IsAdjustment b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.LevelBar: LevelBar :: (ManagedPtr LevelBar) -> LevelBar

+ GI.Gtk.Objects.LevelBar: LevelBar :: ManagedPtr LevelBar -> LevelBar

- GI.Gtk.Objects.LevelBar: constructLevelBarInverted :: (IsLevelBar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.LevelBar: constructLevelBarInverted :: IsLevelBar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.LevelBar: constructLevelBarMaxValue :: (IsLevelBar o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.LevelBar: constructLevelBarMaxValue :: IsLevelBar o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.LevelBar: constructLevelBarMinValue :: (IsLevelBar o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.LevelBar: constructLevelBarMinValue :: IsLevelBar o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.LevelBar: constructLevelBarMode :: (IsLevelBar o) => LevelBarMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.LevelBar: constructLevelBarMode :: IsLevelBar o => LevelBarMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.LevelBar: constructLevelBarValue :: (IsLevelBar o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.LevelBar: constructLevelBarValue :: IsLevelBar o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.LevelBar: levelBarGetOffsetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Maybe (Text) -> m ((Bool, Double))

+ GI.Gtk.Objects.LevelBar: levelBarGetOffsetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Maybe Text -> m (Bool, Double)

- GI.Gtk.Objects.LevelBar: levelBarRemoveOffsetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.LevelBar: levelBarRemoveOffsetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.LevelBar: type LevelBarOffsetChangedCallback = Text /@name@/: the name of the offset that changed value -> IO ()

+ GI.Gtk.Objects.LevelBar: type LevelBarOffsetChangedCallback = Text " /@name@/: the name of the offset that changed value " -> IO ()

- GI.Gtk.Objects.LevelBarAccessible: LevelBarAccessible :: (ManagedPtr LevelBarAccessible) -> LevelBarAccessible

+ GI.Gtk.Objects.LevelBarAccessible: LevelBarAccessible :: ManagedPtr LevelBarAccessible -> LevelBarAccessible

- GI.Gtk.Objects.LinkButton: LinkButton :: (ManagedPtr LinkButton) -> LinkButton

+ GI.Gtk.Objects.LinkButton: LinkButton :: ManagedPtr LinkButton -> LinkButton

- GI.Gtk.Objects.LinkButton: constructLinkButtonUri :: (IsLinkButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.LinkButton: constructLinkButtonUri :: IsLinkButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.LinkButton: constructLinkButtonVisited :: (IsLinkButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.LinkButton: constructLinkButtonVisited :: IsLinkButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.LinkButton: linkButtonNewWithLabel :: (HasCallStack, MonadIO m) => Text -> Maybe (Text) -> m LinkButton

+ GI.Gtk.Objects.LinkButton: linkButtonNewWithLabel :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> m LinkButton

- GI.Gtk.Objects.LinkButtonAccessible: LinkButtonAccessible :: (ManagedPtr LinkButtonAccessible) -> LinkButtonAccessible

+ GI.Gtk.Objects.LinkButtonAccessible: LinkButtonAccessible :: ManagedPtr LinkButtonAccessible -> LinkButtonAccessible

- GI.Gtk.Objects.ListBox: ListBox :: (ManagedPtr ListBox) -> ListBox

+ GI.Gtk.Objects.ListBox: ListBox :: ManagedPtr ListBox -> ListBox

- GI.Gtk.Objects.ListBox: constructListBoxActivateOnSingleClick :: (IsListBox o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ListBox: constructListBoxActivateOnSingleClick :: IsListBox o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ListBox: constructListBoxSelectionMode :: (IsListBox o) => SelectionMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ListBox: constructListBoxSelectionMode :: IsListBox o => SelectionMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.ListBox: listBoxBindModel :: (HasCallStack, MonadIO m, IsListBox a, IsListModel b) => a -> Maybe (b) -> Maybe (ListBoxCreateWidgetFunc) -> m ()

+ GI.Gtk.Objects.ListBox: listBoxBindModel :: (HasCallStack, MonadIO m, IsListBox a, IsListModel b) => a -> Maybe b -> Maybe ListBoxCreateWidgetFunc -> m ()

- GI.Gtk.Objects.ListBox: listBoxSelectRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.ListBox: listBoxSelectRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.ListBox: listBoxSetAdjustment :: (HasCallStack, MonadIO m, IsListBox a, IsAdjustment b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.ListBox: listBoxSetAdjustment :: (HasCallStack, MonadIO m, IsListBox a, IsAdjustment b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.ListBox: listBoxSetFilterFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe (ListBoxFilterFunc) -> m ()

+ GI.Gtk.Objects.ListBox: listBoxSetFilterFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxFilterFunc -> m ()

- GI.Gtk.Objects.ListBox: listBoxSetHeaderFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe (ListBoxUpdateHeaderFunc) -> m ()

+ GI.Gtk.Objects.ListBox: listBoxSetHeaderFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxUpdateHeaderFunc -> m ()

- GI.Gtk.Objects.ListBox: listBoxSetPlaceholder :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.ListBox: listBoxSetPlaceholder :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.ListBox: listBoxSetSortFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe (ListBoxSortFunc) -> m ()

+ GI.Gtk.Objects.ListBox: listBoxSetSortFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxSortFunc -> m ()

- GI.Gtk.Objects.ListBox: type ListBoxRowActivatedCallback = ListBoxRow /@row@/: the activated row -> IO ()

+ GI.Gtk.Objects.ListBox: type ListBoxRowActivatedCallback = ListBoxRow " /@row@/: the activated row " -> IO ()

- GI.Gtk.Objects.ListBox: type ListBoxRowSelectedCallback = Maybe ListBoxRow /@row@/: the selected row -> IO ()

+ GI.Gtk.Objects.ListBox: type ListBoxRowSelectedCallback = Maybe ListBoxRow " /@row@/: the selected row " -> IO ()

- GI.Gtk.Objects.ListBoxAccessible: ListBoxAccessible :: (ManagedPtr ListBoxAccessible) -> ListBoxAccessible

+ GI.Gtk.Objects.ListBoxAccessible: ListBoxAccessible :: ManagedPtr ListBoxAccessible -> ListBoxAccessible

- GI.Gtk.Objects.ListBoxRow: ListBoxRow :: (ManagedPtr ListBoxRow) -> ListBoxRow

+ GI.Gtk.Objects.ListBoxRow: ListBoxRow :: ManagedPtr ListBoxRow -> ListBoxRow

- GI.Gtk.Objects.ListBoxRow: constructListBoxRowActivatable :: (IsListBoxRow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ListBoxRow: constructListBoxRowActivatable :: IsListBoxRow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ListBoxRow: constructListBoxRowSelectable :: (IsListBoxRow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ListBoxRow: constructListBoxRowSelectable :: IsListBoxRow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ListBoxRow: listBoxRowSetHeader :: (HasCallStack, MonadIO m, IsListBoxRow a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.ListBoxRow: listBoxRowSetHeader :: (HasCallStack, MonadIO m, IsListBoxRow a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.ListBoxRowAccessible: ListBoxRowAccessible :: (ManagedPtr ListBoxRowAccessible) -> ListBoxRowAccessible

+ GI.Gtk.Objects.ListBoxRowAccessible: ListBoxRowAccessible :: ManagedPtr ListBoxRowAccessible -> ListBoxRowAccessible

- GI.Gtk.Objects.ListStore: ListStore :: (ManagedPtr ListStore) -> ListStore

+ GI.Gtk.Objects.ListStore: ListStore :: ManagedPtr ListStore -> ListStore

- GI.Gtk.Objects.ListStore: listStoreAppend :: (HasCallStack, MonadIO m, IsListStore a) => a -> m (TreeIter)

+ GI.Gtk.Objects.ListStore: listStoreAppend :: (HasCallStack, MonadIO m, IsListStore a) => a -> m TreeIter

- GI.Gtk.Objects.ListStore: listStoreInsert :: (HasCallStack, MonadIO m, IsListStore a) => a -> Int32 -> m (TreeIter)

+ GI.Gtk.Objects.ListStore: listStoreInsert :: (HasCallStack, MonadIO m, IsListStore a) => a -> Int32 -> m TreeIter

- GI.Gtk.Objects.ListStore: listStoreInsertAfter :: (HasCallStack, MonadIO m, IsListStore a) => a -> Maybe (TreeIter) -> m (TreeIter)

+ GI.Gtk.Objects.ListStore: listStoreInsertAfter :: (HasCallStack, MonadIO m, IsListStore a) => a -> Maybe TreeIter -> m TreeIter

- GI.Gtk.Objects.ListStore: listStoreInsertBefore :: (HasCallStack, MonadIO m, IsListStore a) => a -> Maybe (TreeIter) -> m (TreeIter)

+ GI.Gtk.Objects.ListStore: listStoreInsertBefore :: (HasCallStack, MonadIO m, IsListStore a) => a -> Maybe TreeIter -> m TreeIter

- GI.Gtk.Objects.ListStore: listStoreInsertWithValuesv :: (HasCallStack, MonadIO m, IsListStore a) => a -> Int32 -> [Int32] -> [GValue] -> m (TreeIter)

+ GI.Gtk.Objects.ListStore: listStoreInsertWithValuesv :: (HasCallStack, MonadIO m, IsListStore a) => a -> Int32 -> [Int32] -> [GValue] -> m TreeIter

- GI.Gtk.Objects.ListStore: listStoreMoveAfter :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> Maybe (TreeIter) -> m ()

+ GI.Gtk.Objects.ListStore: listStoreMoveAfter :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

- GI.Gtk.Objects.ListStore: listStoreMoveBefore :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> Maybe (TreeIter) -> m ()

+ GI.Gtk.Objects.ListStore: listStoreMoveBefore :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

- GI.Gtk.Objects.ListStore: listStorePrepend :: (HasCallStack, MonadIO m, IsListStore a) => a -> m (TreeIter)

+ GI.Gtk.Objects.ListStore: listStorePrepend :: (HasCallStack, MonadIO m, IsListStore a) => a -> m TreeIter

- GI.Gtk.Objects.LockButton: LockButton :: (ManagedPtr LockButton) -> LockButton

+ GI.Gtk.Objects.LockButton: LockButton :: ManagedPtr LockButton -> LockButton

- GI.Gtk.Objects.LockButton: constructLockButtonTextLock :: (IsLockButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.LockButton: constructLockButtonTextLock :: IsLockButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.LockButton: constructLockButtonTextUnlock :: (IsLockButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.LockButton: constructLockButtonTextUnlock :: IsLockButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.LockButton: constructLockButtonTooltipLock :: (IsLockButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.LockButton: constructLockButtonTooltipLock :: IsLockButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.LockButton: constructLockButtonTooltipNotAuthorized :: (IsLockButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.LockButton: constructLockButtonTooltipNotAuthorized :: IsLockButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.LockButton: constructLockButtonTooltipUnlock :: (IsLockButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.LockButton: constructLockButtonTooltipUnlock :: IsLockButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.LockButton: lockButtonNew :: (HasCallStack, MonadIO m, IsPermission a) => Maybe (a) -> m LockButton

+ GI.Gtk.Objects.LockButton: lockButtonNew :: (HasCallStack, MonadIO m, IsPermission a) => Maybe a -> m LockButton

- GI.Gtk.Objects.LockButton: lockButtonSetPermission :: (HasCallStack, MonadIO m, IsLockButton a, IsPermission b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.LockButton: lockButtonSetPermission :: (HasCallStack, MonadIO m, IsLockButton a, IsPermission b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.LockButtonAccessible: LockButtonAccessible :: (ManagedPtr LockButtonAccessible) -> LockButtonAccessible

+ GI.Gtk.Objects.LockButtonAccessible: LockButtonAccessible :: ManagedPtr LockButtonAccessible -> LockButtonAccessible

- GI.Gtk.Objects.Menu: Menu :: (ManagedPtr Menu) -> Menu

+ GI.Gtk.Objects.Menu: Menu :: ManagedPtr Menu -> Menu

- GI.Gtk.Objects.Menu: constructMenuAccelPath :: (IsMenu o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Menu: constructMenuAccelPath :: IsMenu o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Menu: constructMenuActive :: (IsMenu o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Menu: constructMenuActive :: IsMenu o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Menu: constructMenuAnchorHints :: (IsMenu o) => [AnchorHints] -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Menu: constructMenuAnchorHints :: IsMenu o => [AnchorHints] -> IO (GValueConstruct o)

- GI.Gtk.Objects.Menu: constructMenuMenuTypeHint :: (IsMenu o) => WindowTypeHint -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Menu: constructMenuMenuTypeHint :: IsMenu o => WindowTypeHint -> IO (GValueConstruct o)

- GI.Gtk.Objects.Menu: constructMenuMonitor :: (IsMenu o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Menu: constructMenuMonitor :: IsMenu o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Menu: constructMenuRectAnchorDx :: (IsMenu o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Menu: constructMenuRectAnchorDx :: IsMenu o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Menu: constructMenuRectAnchorDy :: (IsMenu o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Menu: constructMenuRectAnchorDy :: IsMenu o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Menu: constructMenuReserveToggleSize :: (IsMenu o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Menu: constructMenuReserveToggleSize :: IsMenu o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Menu: constructMenuTearoffState :: (IsMenu o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Menu: constructMenuTearoffState :: IsMenu o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Menu: constructMenuTearoffTitle :: (IsMenu o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Menu: constructMenuTearoffTitle :: IsMenu o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Menu: menuAttachToWidget :: (HasCallStack, MonadIO m, IsMenu a, IsWidget b) => a -> b -> Maybe (MenuDetachFunc) -> m ()

+ GI.Gtk.Objects.Menu: menuAttachToWidget :: (HasCallStack, MonadIO m, IsMenu a, IsWidget b) => a -> b -> Maybe MenuDetachFunc -> m ()

- GI.Gtk.Objects.Menu: menuPopup :: (HasCallStack, MonadIO m, IsMenu a, IsWidget b, IsWidget c) => a -> Maybe (b) -> Maybe (c) -> Maybe (MenuPositionFunc) -> Word32 -> Word32 -> m ()

+ GI.Gtk.Objects.Menu: menuPopup :: (HasCallStack, MonadIO m, IsMenu a, IsWidget b, IsWidget c) => a -> Maybe b -> Maybe c -> Maybe MenuPositionFunc -> Word32 -> Word32 -> m ()

- GI.Gtk.Objects.Menu: menuPopupAtPointer :: (HasCallStack, MonadIO m, IsMenu a) => a -> Maybe (Event) -> m ()

+ GI.Gtk.Objects.Menu: menuPopupAtPointer :: (HasCallStack, MonadIO m, IsMenu a) => a -> Maybe Event -> m ()

- GI.Gtk.Objects.Menu: menuPopupAtRect :: (HasCallStack, MonadIO m, IsMenu a, IsWindow b) => a -> b -> Rectangle -> Gravity -> Gravity -> Maybe (Event) -> m ()

+ GI.Gtk.Objects.Menu: menuPopupAtRect :: (HasCallStack, MonadIO m, IsMenu a, IsWindow b) => a -> b -> Rectangle -> Gravity -> Gravity -> Maybe Event -> m ()

- GI.Gtk.Objects.Menu: menuPopupAtWidget :: (HasCallStack, MonadIO m, IsMenu a, IsWidget b) => a -> b -> Gravity -> Gravity -> Maybe (Event) -> m ()

+ GI.Gtk.Objects.Menu: menuPopupAtWidget :: (HasCallStack, MonadIO m, IsMenu a, IsWidget b) => a -> b -> Gravity -> Gravity -> Maybe Event -> m ()

- GI.Gtk.Objects.Menu: menuPopupForDevice :: (HasCallStack, MonadIO m, IsMenu a, IsDevice b, IsWidget c, IsWidget d) => a -> Maybe (b) -> Maybe (c) -> Maybe (d) -> Maybe (MenuPositionFunc) -> Word32 -> Word32 -> m ()

+ GI.Gtk.Objects.Menu: menuPopupForDevice :: (HasCallStack, MonadIO m, IsMenu a, IsDevice b, IsWidget c, IsWidget d) => a -> Maybe b -> Maybe c -> Maybe d -> Maybe MenuPositionFunc -> Word32 -> Word32 -> m ()

- GI.Gtk.Objects.Menu: menuSetAccelGroup :: (HasCallStack, MonadIO m, IsMenu a, IsAccelGroup b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Menu: menuSetAccelGroup :: (HasCallStack, MonadIO m, IsMenu a, IsAccelGroup b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Menu: menuSetAccelPath :: (HasCallStack, MonadIO m, IsMenu a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Menu: menuSetAccelPath :: (HasCallStack, MonadIO m, IsMenu a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.Menu: menuSetScreen :: (HasCallStack, MonadIO m, IsMenu a, IsScreen b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Menu: menuSetScreen :: (HasCallStack, MonadIO m, IsMenu a, IsScreen b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Menu: menuSetTitle :: (HasCallStack, MonadIO m, IsMenu a) => a -> Text -> m ()

+ GI.Gtk.Objects.Menu: menuSetTitle :: (HasCallStack, MonadIO m, IsMenu a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.Menu: type MenuMoveScrollCallback = ScrollType /@scrollType@/: a 'GI.Gtk.Enums.ScrollType' -> IO ()

+ GI.Gtk.Objects.Menu: type MenuMoveScrollCallback = ScrollType " /@scrollType@/: a 'GI.Gtk.Enums.ScrollType' " -> IO ()

- GI.Gtk.Objects.Menu: type MenuPoppedUpCallback = Ptr () /@flippedRect@/: the position of /@menu@/ after any possible flipping or 'Nothing' if the backend can\'t obtain it -> Ptr () /@finalRect@/: the final position of /@menu@/ or 'Nothing' if the backend can\'t obtain it -> Bool /@flippedX@/: 'True' if the anchors were flipped horizontally -> Bool /@flippedY@/: 'True' if the anchors were flipped vertically -> IO ()

+ GI.Gtk.Objects.Menu: type MenuPoppedUpCallback = Ptr () " /@flippedRect@/: the position of /@menu@/ after any possible flipping or 'Nothing' if the backend can\'t obtain it " -> Ptr () " /@finalRect@/: the final position of /@menu@/ or 'Nothing' if the backend can\'t obtain it " -> Bool " /@flippedX@/: 'True' if the anchors were flipped horizontally " -> Bool " /@flippedY@/: 'True' if the anchors were flipped vertically " -> IO ()

- GI.Gtk.Objects.MenuAccessible: MenuAccessible :: (ManagedPtr MenuAccessible) -> MenuAccessible

+ GI.Gtk.Objects.MenuAccessible: MenuAccessible :: ManagedPtr MenuAccessible -> MenuAccessible

- GI.Gtk.Objects.MenuBar: MenuBar :: (ManagedPtr MenuBar) -> MenuBar

+ GI.Gtk.Objects.MenuBar: MenuBar :: ManagedPtr MenuBar -> MenuBar

- GI.Gtk.Objects.MenuBar: constructMenuBarChildPackDirection :: (IsMenuBar o) => PackDirection -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MenuBar: constructMenuBarChildPackDirection :: IsMenuBar o => PackDirection -> IO (GValueConstruct o)

- GI.Gtk.Objects.MenuBar: constructMenuBarPackDirection :: (IsMenuBar o) => PackDirection -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MenuBar: constructMenuBarPackDirection :: IsMenuBar o => PackDirection -> IO (GValueConstruct o)

- GI.Gtk.Objects.MenuButton: MenuButton :: (ManagedPtr MenuButton) -> MenuButton

+ GI.Gtk.Objects.MenuButton: MenuButton :: ManagedPtr MenuButton -> MenuButton

- GI.Gtk.Objects.MenuButton: constructMenuButtonDirection :: (IsMenuButton o) => ArrowType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MenuButton: constructMenuButtonDirection :: IsMenuButton o => ArrowType -> IO (GValueConstruct o)

- GI.Gtk.Objects.MenuButton: constructMenuButtonUsePopover :: (IsMenuButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MenuButton: constructMenuButtonUsePopover :: IsMenuButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.MenuButton: menuButtonSetAlignWidget :: (HasCallStack, MonadIO m, IsMenuButton a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.MenuButton: menuButtonSetAlignWidget :: (HasCallStack, MonadIO m, IsMenuButton a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.MenuButton: menuButtonSetMenuModel :: (HasCallStack, MonadIO m, IsMenuButton a, IsMenuModel b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.MenuButton: menuButtonSetMenuModel :: (HasCallStack, MonadIO m, IsMenuButton a, IsMenuModel b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.MenuButton: menuButtonSetPopover :: (HasCallStack, MonadIO m, IsMenuButton a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.MenuButton: menuButtonSetPopover :: (HasCallStack, MonadIO m, IsMenuButton a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.MenuButton: menuButtonSetPopup :: (HasCallStack, MonadIO m, IsMenuButton a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.MenuButton: menuButtonSetPopup :: (HasCallStack, MonadIO m, IsMenuButton a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.MenuButtonAccessible: MenuButtonAccessible :: (ManagedPtr MenuButtonAccessible) -> MenuButtonAccessible

+ GI.Gtk.Objects.MenuButtonAccessible: MenuButtonAccessible :: ManagedPtr MenuButtonAccessible -> MenuButtonAccessible

- GI.Gtk.Objects.MenuItem: MenuItem :: (ManagedPtr MenuItem) -> MenuItem

+ GI.Gtk.Objects.MenuItem: MenuItem :: ManagedPtr MenuItem -> MenuItem

- GI.Gtk.Objects.MenuItem: constructMenuItemAccelPath :: (IsMenuItem o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MenuItem: constructMenuItemAccelPath :: IsMenuItem o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.MenuItem: constructMenuItemLabel :: (IsMenuItem o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MenuItem: constructMenuItemLabel :: IsMenuItem o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.MenuItem: constructMenuItemRightJustified :: (IsMenuItem o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MenuItem: constructMenuItemRightJustified :: IsMenuItem o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.MenuItem: constructMenuItemUseUnderline :: (IsMenuItem o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MenuItem: constructMenuItemUseUnderline :: IsMenuItem o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.MenuItem: menuItemSetAccelPath :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.MenuItem: menuItemSetAccelPath :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.MenuItem: menuItemSetSubmenu :: (HasCallStack, MonadIO m, IsMenuItem a, IsMenu b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.MenuItem: menuItemSetSubmenu :: (HasCallStack, MonadIO m, IsMenuItem a, IsMenu b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.MenuItem: menuItemToggleSizeRequest :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Int32 -> m (Int32)

+ GI.Gtk.Objects.MenuItem: menuItemToggleSizeRequest :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Int32 -> m Int32

- GI.Gtk.Objects.MenuItemAccessible: MenuItemAccessible :: (ManagedPtr MenuItemAccessible) -> MenuItemAccessible

+ GI.Gtk.Objects.MenuItemAccessible: MenuItemAccessible :: ManagedPtr MenuItemAccessible -> MenuItemAccessible

- GI.Gtk.Objects.MenuShell: MenuShell :: (ManagedPtr MenuShell) -> MenuShell

+ GI.Gtk.Objects.MenuShell: MenuShell :: ManagedPtr MenuShell -> MenuShell

- GI.Gtk.Objects.MenuShell: constructMenuShellTakeFocus :: (IsMenuShell o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MenuShell: constructMenuShellTakeFocus :: IsMenuShell o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.MenuShell: menuShellBindModel :: (HasCallStack, MonadIO m, IsMenuShell a, IsMenuModel b) => a -> Maybe (b) -> Maybe (Text) -> Bool -> m ()

+ GI.Gtk.Objects.MenuShell: menuShellBindModel :: (HasCallStack, MonadIO m, IsMenuShell a, IsMenuModel b) => a -> Maybe b -> Maybe Text -> Bool -> m ()

- GI.Gtk.Objects.MenuShell: type MenuShellActivateCurrentCallback = Bool /@forceHide@/: if 'True', hide the menu after activating the menu item -> IO ()

+ GI.Gtk.Objects.MenuShell: type MenuShellActivateCurrentCallback = Bool " /@forceHide@/: if 'True', hide the menu after activating the menu item " -> IO ()

- GI.Gtk.Objects.MenuShell: type MenuShellCycleFocusCallback = DirectionType /@direction@/: the direction to cycle in -> IO ()

+ GI.Gtk.Objects.MenuShell: type MenuShellCycleFocusCallback = DirectionType " /@direction@/: the direction to cycle in " -> IO ()

- GI.Gtk.Objects.MenuShell: type MenuShellInsertCallback = Widget /@child@/: the 'GI.Gtk.Objects.MenuItem.MenuItem' that is being inserted -> Int32 /@position@/: the position at which the insert occurs -> IO ()

+ GI.Gtk.Objects.MenuShell: type MenuShellInsertCallback = Widget " /@child@/: the 'GI.Gtk.Objects.MenuItem.MenuItem' that is being inserted " -> Int32 " /@position@/: the position at which the insert occurs " -> IO ()

- GI.Gtk.Objects.MenuShell: type MenuShellMoveCurrentCallback = MenuDirectionType /@direction@/: the direction to move -> IO ()

+ GI.Gtk.Objects.MenuShell: type MenuShellMoveCurrentCallback = MenuDirectionType " /@direction@/: the direction to move " -> IO ()

- GI.Gtk.Objects.MenuShell: type MenuShellMoveSelectedCallback = Int32 /@distance@/: +1 to move to the next item, -1 to move to the previous -> IO Bool __Returns:__ 'True' to stop the signal emission, 'False' to continue

+ GI.Gtk.Objects.MenuShell: type MenuShellMoveSelectedCallback = Int32 " /@distance@/: +1 to move to the next item, -1 to move to the previous " -> IO Bool " __Returns:__ 'True' to stop the signal emission, 'False' to continue "

- GI.Gtk.Objects.MenuShellAccessible: MenuShellAccessible :: (ManagedPtr MenuShellAccessible) -> MenuShellAccessible

+ GI.Gtk.Objects.MenuShellAccessible: MenuShellAccessible :: ManagedPtr MenuShellAccessible -> MenuShellAccessible

- GI.Gtk.Objects.MenuToolButton: MenuToolButton :: (ManagedPtr MenuToolButton) -> MenuToolButton

+ GI.Gtk.Objects.MenuToolButton: MenuToolButton :: ManagedPtr MenuToolButton -> MenuToolButton

- GI.Gtk.Objects.MenuToolButton: menuToolButtonNew :: (HasCallStack, MonadIO m, IsWidget a) => Maybe (a) -> Maybe (Text) -> m MenuToolButton

+ GI.Gtk.Objects.MenuToolButton: menuToolButtonNew :: (HasCallStack, MonadIO m, IsWidget a) => Maybe a -> Maybe Text -> m MenuToolButton

- GI.Gtk.Objects.MessageDialog: MessageDialog :: (ManagedPtr MessageDialog) -> MessageDialog

+ GI.Gtk.Objects.MessageDialog: MessageDialog :: ManagedPtr MessageDialog -> MessageDialog

- GI.Gtk.Objects.MessageDialog: constructMessageDialogButtons :: (IsMessageDialog o) => ButtonsType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MessageDialog: constructMessageDialogButtons :: IsMessageDialog o => ButtonsType -> IO (GValueConstruct o)

- GI.Gtk.Objects.MessageDialog: constructMessageDialogMessageType :: (IsMessageDialog o) => MessageType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MessageDialog: constructMessageDialogMessageType :: IsMessageDialog o => MessageType -> IO (GValueConstruct o)

- GI.Gtk.Objects.MessageDialog: constructMessageDialogSecondaryText :: (IsMessageDialog o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MessageDialog: constructMessageDialogSecondaryText :: IsMessageDialog o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.MessageDialog: constructMessageDialogSecondaryUseMarkup :: (IsMessageDialog o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MessageDialog: constructMessageDialogSecondaryUseMarkup :: IsMessageDialog o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.MessageDialog: constructMessageDialogText :: (IsMessageDialog o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MessageDialog: constructMessageDialogText :: IsMessageDialog o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.MessageDialog: constructMessageDialogUseMarkup :: (IsMessageDialog o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.MessageDialog: constructMessageDialogUseMarkup :: IsMessageDialog o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Misc: Misc :: (ManagedPtr Misc) -> Misc

+ GI.Gtk.Objects.Misc: Misc :: ManagedPtr Misc -> Misc

- GI.Gtk.Objects.Misc: constructMiscXalign :: (IsMisc o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Misc: constructMiscXalign :: IsMisc o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.Misc: constructMiscXpad :: (IsMisc o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Misc: constructMiscXpad :: IsMisc o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Misc: constructMiscYalign :: (IsMisc o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Misc: constructMiscYalign :: IsMisc o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.Misc: constructMiscYpad :: (IsMisc o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Misc: constructMiscYpad :: IsMisc o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Misc: miscGetAlignment :: (HasCallStack, MonadIO m, IsMisc a) => a -> m ((Float, Float))

+ GI.Gtk.Objects.Misc: miscGetAlignment :: (HasCallStack, MonadIO m, IsMisc a) => a -> m (Float, Float)

- GI.Gtk.Objects.Misc: miscGetPadding :: (HasCallStack, MonadIO m, IsMisc a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.Misc: miscGetPadding :: (HasCallStack, MonadIO m, IsMisc a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.ModelButton: ModelButton :: (ManagedPtr ModelButton) -> ModelButton

+ GI.Gtk.Objects.ModelButton: ModelButton :: ManagedPtr ModelButton -> ModelButton

- GI.Gtk.Objects.ModelButton: constructModelButtonActive :: (IsModelButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ModelButton: constructModelButtonActive :: IsModelButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ModelButton: constructModelButtonCentered :: (IsModelButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ModelButton: constructModelButtonCentered :: IsModelButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ModelButton: constructModelButtonIconic :: (IsModelButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ModelButton: constructModelButtonIconic :: IsModelButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ModelButton: constructModelButtonInverted :: (IsModelButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ModelButton: constructModelButtonInverted :: IsModelButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ModelButton: constructModelButtonMenuName :: (IsModelButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ModelButton: constructModelButtonMenuName :: IsModelButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ModelButton: constructModelButtonRole :: (IsModelButton o) => ButtonRole -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ModelButton: constructModelButtonRole :: IsModelButton o => ButtonRole -> IO (GValueConstruct o)

- GI.Gtk.Objects.ModelButton: constructModelButtonText :: (IsModelButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ModelButton: constructModelButtonText :: IsModelButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.MountOperation: MountOperation :: (ManagedPtr MountOperation) -> MountOperation

+ GI.Gtk.Objects.MountOperation: MountOperation :: ManagedPtr MountOperation -> MountOperation

- GI.Gtk.Objects.MountOperation: mountOperationNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe (a) -> m MountOperation

+ GI.Gtk.Objects.MountOperation: mountOperationNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> m MountOperation

- GI.Gtk.Objects.MountOperation: mountOperationSetParent :: (HasCallStack, MonadIO m, IsMountOperation a, IsWindow b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.MountOperation: mountOperationSetParent :: (HasCallStack, MonadIO m, IsMountOperation a, IsWindow b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.NativeDialog: NativeDialog :: (ManagedPtr NativeDialog) -> NativeDialog

+ GI.Gtk.Objects.NativeDialog: NativeDialog :: ManagedPtr NativeDialog -> NativeDialog

- GI.Gtk.Objects.NativeDialog: constructNativeDialogModal :: (IsNativeDialog o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.NativeDialog: constructNativeDialogModal :: IsNativeDialog o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.NativeDialog: constructNativeDialogTitle :: (IsNativeDialog o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.NativeDialog: constructNativeDialogTitle :: IsNativeDialog o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.NativeDialog: constructNativeDialogVisible :: (IsNativeDialog o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.NativeDialog: constructNativeDialogVisible :: IsNativeDialog o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.NativeDialog: nativeDialogSetTransientFor :: (HasCallStack, MonadIO m, IsNativeDialog a, IsWindow b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.NativeDialog: nativeDialogSetTransientFor :: (HasCallStack, MonadIO m, IsNativeDialog a, IsWindow b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.NativeDialog: type NativeDialogResponseCallback = Int32 /@responseId@/: the response ID -> IO ()

+ GI.Gtk.Objects.NativeDialog: type NativeDialogResponseCallback = Int32 " /@responseId@/: the response ID " -> IO ()

- GI.Gtk.Objects.Notebook: Notebook :: (ManagedPtr Notebook) -> Notebook

+ GI.Gtk.Objects.Notebook: Notebook :: ManagedPtr Notebook -> Notebook

- GI.Gtk.Objects.Notebook: constructNotebookEnablePopup :: (IsNotebook o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Notebook: constructNotebookEnablePopup :: IsNotebook o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Notebook: constructNotebookGroupName :: (IsNotebook o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Notebook: constructNotebookGroupName :: IsNotebook o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Notebook: constructNotebookPage :: (IsNotebook o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Notebook: constructNotebookPage :: IsNotebook o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Notebook: constructNotebookScrollable :: (IsNotebook o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Notebook: constructNotebookScrollable :: IsNotebook o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Notebook: constructNotebookShowBorder :: (IsNotebook o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Notebook: constructNotebookShowBorder :: IsNotebook o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Notebook: constructNotebookShowTabs :: (IsNotebook o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Notebook: constructNotebookShowTabs :: IsNotebook o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Notebook: constructNotebookTabPos :: (IsNotebook o) => PositionType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Notebook: constructNotebookTabPos :: IsNotebook o => PositionType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Notebook: notebookAppendPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe (c) -> m Int32

+ GI.Gtk.Objects.Notebook: notebookAppendPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m Int32

- GI.Gtk.Objects.Notebook: notebookAppendPageMenu :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d) => a -> b -> Maybe (c) -> Maybe (d) -> m Int32

+ GI.Gtk.Objects.Notebook: notebookAppendPageMenu :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d) => a -> b -> Maybe c -> Maybe d -> m Int32

- GI.Gtk.Objects.Notebook: notebookInsertPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe (c) -> Int32 -> m Int32

+ GI.Gtk.Objects.Notebook: notebookInsertPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> Int32 -> m Int32

- GI.Gtk.Objects.Notebook: notebookInsertPageMenu :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d) => a -> b -> Maybe (c) -> Maybe (d) -> Int32 -> m Int32

+ GI.Gtk.Objects.Notebook: notebookInsertPageMenu :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d) => a -> b -> Maybe c -> Maybe d -> Int32 -> m Int32

- GI.Gtk.Objects.Notebook: notebookPrependPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe (c) -> m Int32

+ GI.Gtk.Objects.Notebook: notebookPrependPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m Int32

- GI.Gtk.Objects.Notebook: notebookPrependPageMenu :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d) => a -> b -> Maybe (c) -> Maybe (d) -> m Int32

+ GI.Gtk.Objects.Notebook: notebookPrependPageMenu :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d) => a -> b -> Maybe c -> Maybe d -> m Int32

- GI.Gtk.Objects.Notebook: notebookSetGroupName :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Notebook: notebookSetGroupName :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.Notebook: notebookSetMenuLabel :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe (c) -> m ()

+ GI.Gtk.Objects.Notebook: notebookSetMenuLabel :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m ()

- GI.Gtk.Objects.Notebook: notebookSetTabLabel :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe (c) -> m ()

+ GI.Gtk.Objects.Notebook: notebookSetTabLabel :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m ()

- GI.Gtk.Objects.Notebook: type NotebookCreateWindowCallback = Widget /@page@/: the tab of /@notebook@/ that is being detached -> Int32 /@x@/: the X coordinate where the drop happens -> Int32 /@y@/: the Y coordinate where the drop happens -> IO Notebook __Returns:__ a 'GI.Gtk.Objects.Notebook.Notebook' that /@page@/ should be added to, or 'Nothing'.

+ GI.Gtk.Objects.Notebook: type NotebookCreateWindowCallback = Widget " /@page@/: the tab of /@notebook@/ that is being detached " -> Int32 " /@x@/: the X coordinate where the drop happens " -> Int32 " /@y@/: the Y coordinate where the drop happens " -> IO Notebook " __Returns:__ a 'GI.Gtk.Objects.Notebook.Notebook' that /@page@/ should be added to, or 'Nothing'. "

- GI.Gtk.Objects.Notebook: type NotebookPageAddedCallback = Widget /@child@/: the child 'GI.Gtk.Objects.Widget.Widget' affected -> Word32 /@pageNum@/: the new page number for /@child@/ -> IO ()

+ GI.Gtk.Objects.Notebook: type NotebookPageAddedCallback = Widget " /@child@/: the child 'GI.Gtk.Objects.Widget.Widget' affected " -> Word32 " /@pageNum@/: the new page number for /@child@/ " -> IO ()

- GI.Gtk.Objects.Notebook: type NotebookPageRemovedCallback = Widget /@child@/: the child 'GI.Gtk.Objects.Widget.Widget' affected -> Word32 /@pageNum@/: the /@child@/ page number -> IO ()

+ GI.Gtk.Objects.Notebook: type NotebookPageRemovedCallback = Widget " /@child@/: the child 'GI.Gtk.Objects.Widget.Widget' affected " -> Word32 " /@pageNum@/: the /@child@/ page number " -> IO ()

- GI.Gtk.Objects.Notebook: type NotebookPageReorderedCallback = Widget /@child@/: the child 'GI.Gtk.Objects.Widget.Widget' affected -> Word32 /@pageNum@/: the new page number for /@child@/ -> IO ()

+ GI.Gtk.Objects.Notebook: type NotebookPageReorderedCallback = Widget " /@child@/: the child 'GI.Gtk.Objects.Widget.Widget' affected " -> Word32 " /@pageNum@/: the new page number for /@child@/ " -> IO ()

- GI.Gtk.Objects.Notebook: type NotebookSwitchPageCallback = Widget /@page@/: the new current page -> Word32 /@pageNum@/: the index of the page -> IO ()

+ GI.Gtk.Objects.Notebook: type NotebookSwitchPageCallback = Widget " /@page@/: the new current page " -> Word32 " /@pageNum@/: the index of the page " -> IO ()

- GI.Gtk.Objects.NotebookAccessible: NotebookAccessible :: (ManagedPtr NotebookAccessible) -> NotebookAccessible

+ GI.Gtk.Objects.NotebookAccessible: NotebookAccessible :: ManagedPtr NotebookAccessible -> NotebookAccessible

- GI.Gtk.Objects.NotebookPageAccessible: NotebookPageAccessible :: (ManagedPtr NotebookPageAccessible) -> NotebookPageAccessible

+ GI.Gtk.Objects.NotebookPageAccessible: NotebookPageAccessible :: ManagedPtr NotebookPageAccessible -> NotebookPageAccessible

- GI.Gtk.Objects.NumerableIcon: NumerableIcon :: (ManagedPtr NumerableIcon) -> NumerableIcon

+ GI.Gtk.Objects.NumerableIcon: NumerableIcon :: ManagedPtr NumerableIcon -> NumerableIcon

- GI.Gtk.Objects.NumerableIcon: constructNumerableIconBackgroundIconName :: (IsNumerableIcon o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.NumerableIcon: constructNumerableIconBackgroundIconName :: IsNumerableIcon o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.NumerableIcon: constructNumerableIconCount :: (IsNumerableIcon o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.NumerableIcon: constructNumerableIconCount :: IsNumerableIcon o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.NumerableIcon: constructNumerableIconLabel :: (IsNumerableIcon o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.NumerableIcon: constructNumerableIconLabel :: IsNumerableIcon o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.NumerableIcon: numerableIconSetBackgroundGicon :: (HasCallStack, MonadIO m, IsNumerableIcon a, IsIcon b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.NumerableIcon: numerableIconSetBackgroundGicon :: (HasCallStack, MonadIO m, IsNumerableIcon a, IsIcon b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.NumerableIcon: numerableIconSetBackgroundIconName :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.NumerableIcon: numerableIconSetBackgroundIconName :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.NumerableIcon: numerableIconSetLabel :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.NumerableIcon: numerableIconSetLabel :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.OffscreenWindow: OffscreenWindow :: (ManagedPtr OffscreenWindow) -> OffscreenWindow

+ GI.Gtk.Objects.OffscreenWindow: OffscreenWindow :: ManagedPtr OffscreenWindow -> OffscreenWindow

- GI.Gtk.Objects.Overlay: Overlay :: (ManagedPtr Overlay) -> Overlay

+ GI.Gtk.Objects.Overlay: Overlay :: ManagedPtr Overlay -> Overlay

- GI.Gtk.Objects.PadController: PadController :: (ManagedPtr PadController) -> PadController

+ GI.Gtk.Objects.PadController: PadController :: ManagedPtr PadController -> PadController

- GI.Gtk.Objects.PadController: padControllerNew :: (HasCallStack, MonadIO m, IsWindow a, IsActionGroup b, IsDevice c) => a -> b -> Maybe (c) -> m PadController

+ GI.Gtk.Objects.PadController: padControllerNew :: (HasCallStack, MonadIO m, IsWindow a, IsActionGroup b, IsDevice c) => a -> b -> Maybe c -> m PadController

- GI.Gtk.Objects.PageSetup: PageSetup :: (ManagedPtr PageSetup) -> PageSetup

+ GI.Gtk.Objects.PageSetup: PageSetup :: ManagedPtr PageSetup -> PageSetup

- GI.Gtk.Objects.PageSetup: pageSetupLoadKeyFile :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> KeyFile -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.PageSetup: pageSetupLoadKeyFile :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> KeyFile -> Maybe Text -> m ()

- GI.Gtk.Objects.PageSetup: pageSetupNewFromKeyFile :: (HasCallStack, MonadIO m) => KeyFile -> Maybe (Text) -> m PageSetup

+ GI.Gtk.Objects.PageSetup: pageSetupNewFromKeyFile :: (HasCallStack, MonadIO m) => KeyFile -> Maybe Text -> m PageSetup

- GI.Gtk.Objects.Paned: Paned :: (ManagedPtr Paned) -> Paned

+ GI.Gtk.Objects.Paned: Paned :: ManagedPtr Paned -> Paned

- GI.Gtk.Objects.Paned: constructPanedPosition :: (IsPaned o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Paned: constructPanedPosition :: IsPaned o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Paned: constructPanedPositionSet :: (IsPaned o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Paned: constructPanedPositionSet :: IsPaned o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Paned: constructPanedWideHandle :: (IsPaned o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Paned: constructPanedWideHandle :: IsPaned o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Paned: type PanedCycleChildFocusCallback = Bool /@reversed@/: whether cycling backward or forward -> IO Bool

+ GI.Gtk.Objects.Paned: type PanedCycleChildFocusCallback = Bool " /@reversed@/: whether cycling backward or forward " -> IO Bool

- GI.Gtk.Objects.Paned: type PanedCycleHandleFocusCallback = Bool /@reversed@/: whether cycling backward or forward -> IO Bool

+ GI.Gtk.Objects.Paned: type PanedCycleHandleFocusCallback = Bool " /@reversed@/: whether cycling backward or forward " -> IO Bool

- GI.Gtk.Objects.Paned: type PanedMoveHandleCallback = ScrollType /@scrollType@/: a 'GI.Gtk.Enums.ScrollType' -> IO Bool

+ GI.Gtk.Objects.Paned: type PanedMoveHandleCallback = ScrollType " /@scrollType@/: a 'GI.Gtk.Enums.ScrollType' " -> IO Bool

- GI.Gtk.Objects.PanedAccessible: PanedAccessible :: (ManagedPtr PanedAccessible) -> PanedAccessible

+ GI.Gtk.Objects.PanedAccessible: PanedAccessible :: ManagedPtr PanedAccessible -> PanedAccessible

- GI.Gtk.Objects.PlacesSidebar: PlacesSidebar :: (ManagedPtr PlacesSidebar) -> PlacesSidebar

+ GI.Gtk.Objects.PlacesSidebar: PlacesSidebar :: ManagedPtr PlacesSidebar -> PlacesSidebar

- GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarLocalOnly :: (IsPlacesSidebar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarLocalOnly :: IsPlacesSidebar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarOpenFlags :: (IsPlacesSidebar o) => [PlacesOpenFlags] -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarOpenFlags :: IsPlacesSidebar o => [PlacesOpenFlags] -> IO (GValueConstruct o)

- GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarPopulateAll :: (IsPlacesSidebar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarPopulateAll :: IsPlacesSidebar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarShowConnectToServer :: (IsPlacesSidebar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarShowConnectToServer :: IsPlacesSidebar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarShowDesktop :: (IsPlacesSidebar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarShowDesktop :: IsPlacesSidebar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarShowEnterLocation :: (IsPlacesSidebar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarShowEnterLocation :: IsPlacesSidebar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarShowOtherLocations :: (IsPlacesSidebar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarShowOtherLocations :: IsPlacesSidebar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarShowRecent :: (IsPlacesSidebar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarShowRecent :: IsPlacesSidebar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarShowStarredLocation :: (IsPlacesSidebar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarShowStarredLocation :: IsPlacesSidebar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarShowTrash :: (IsPlacesSidebar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PlacesSidebar: constructPlacesSidebarShowTrash :: IsPlacesSidebar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PlacesSidebar: placesSidebarSetLocation :: (HasCallStack, MonadIO m, IsPlacesSidebar a, IsFile b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.PlacesSidebar: placesSidebarSetLocation :: (HasCallStack, MonadIO m, IsPlacesSidebar a, IsFile b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarDragActionAskCallback = Int32 /@actions@/: Possible drag actions that need to be asked for. -> IO Int32 __Returns:__ the final drag action that the sidebar should pass to the drag side of the drag-and-drop operation.

+ GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarDragActionAskCallback = Int32 " /@actions@/: Possible drag actions that need to be asked for. " -> IO Int32 " __Returns:__ the final drag action that the sidebar should pass to the drag side of the drag-and-drop operation. "

- GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarDragActionRequestedCallback = DragContext /@context@/: 'GI.Gdk.Objects.DragContext.DragContext' with information about the drag operation -> File /@destFile@/: 'GI.Gio.Interfaces.File.File' with the tentative location that is being hovered for a drop -> [File] /@sourceFileList@/: List of 'GI.Gio.Interfaces.File.File' that are being dragged -> IO Int32 __Returns:__ The drag action to use, for example, @/GDK_ACTION_COPY/@ or @/GDK_ACTION_MOVE/@, or 0 if no action is allowed here (i.e. drops are not allowed in the specified /@destFile@/).

+ GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarDragActionRequestedCallback = DragContext " /@context@/: 'GI.Gdk.Objects.DragContext.DragContext' with information about the drag operation " -> File " /@destFile@/: 'GI.Gio.Interfaces.File.File' with the tentative location that is being hovered for a drop " -> [File] " /@sourceFileList@/: List of 'GI.Gio.Interfaces.File.File' that are being dragged " -> IO Int32 " __Returns:__ The drag action to use, for example, @/GDK_ACTION_COPY/@ or @/GDK_ACTION_MOVE/@, or 0 if no action is allowed here (i.e. drops are not allowed in the specified /@destFile@/). "

- GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarDragPerformDropCallback = File /@destFile@/: Destination 'GI.Gio.Interfaces.File.File'. -> [File] /@sourceFileList@/: 'GI.GLib.Structs.List.List' of 'GI.Gio.Interfaces.File.File' that got dropped. -> Int32 /@action@/: Drop action to perform. -> IO ()

+ GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarDragPerformDropCallback = File " /@destFile@/: Destination 'GI.Gio.Interfaces.File.File'. " -> [File] " /@sourceFileList@/: 'GI.GLib.Structs.List.List' of 'GI.Gio.Interfaces.File.File' that got dropped. " -> Int32 " /@action@/: Drop action to perform. " -> IO ()

- GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarMountCallback = MountOperation /@mountOperation@/: the 'GI.Gio.Objects.MountOperation.MountOperation' that is going to start. -> IO ()

+ GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarMountCallback = MountOperation " /@mountOperation@/: the 'GI.Gio.Objects.MountOperation.MountOperation' that is going to start. " -> IO ()

- GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarOpenLocationCallback = File /@location@/: 'GI.Gio.Interfaces.File.File' to which the caller should switch. -> [PlacesOpenFlags] /@openFlags@/: a single value from 'GI.Gtk.Flags.PlacesOpenFlags' specifying how the /@location@/ should be opened. -> IO ()

+ GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarOpenLocationCallback = File " /@location@/: 'GI.Gio.Interfaces.File.File' to which the caller should switch. " -> [PlacesOpenFlags] " /@openFlags@/: a single value from 'GI.Gtk.Flags.PlacesOpenFlags' specifying how the /@location@/ should be opened. " -> IO ()

- GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarPopulatePopupCallback = Widget /@container@/: a 'GI.Gtk.Objects.Menu.Menu' or another 'GI.Gtk.Objects.Container.Container' -> Maybe File /@selectedItem@/: 'GI.Gio.Interfaces.File.File' with the item to which the popup should refer, or 'Nothing' in the case of a /@selectedVolume@/. -> Maybe Volume /@selectedVolume@/: 'GI.Gio.Interfaces.Volume.Volume' if the selected item is a volume, or 'Nothing' if it is a file. -> IO ()

+ GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarPopulatePopupCallback = Widget " /@container@/: a 'GI.Gtk.Objects.Menu.Menu' or another 'GI.Gtk.Objects.Container.Container' " -> Maybe File " /@selectedItem@/: 'GI.Gio.Interfaces.File.File' with the item to which the popup should refer, or 'Nothing' in the case of a /@selectedVolume@/. " -> Maybe Volume " /@selectedVolume@/: 'GI.Gio.Interfaces.Volume.Volume' if the selected item is a volume, or 'Nothing' if it is a file. " -> IO ()

- GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarShowErrorMessageCallback = Text /@primary@/: primary message with a summary of the error to show. -> Text /@secondary@/: secondary message with details of the error to show. -> IO ()

+ GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarShowErrorMessageCallback = Text " /@primary@/: primary message with a summary of the error to show. " -> Text " /@secondary@/: secondary message with details of the error to show. " -> IO ()

- GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarShowOtherLocationsWithFlagsCallback = [PlacesOpenFlags] /@openFlags@/: a single value from 'GI.Gtk.Flags.PlacesOpenFlags' specifying how it should be opened. -> IO ()

+ GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarShowOtherLocationsWithFlagsCallback = [PlacesOpenFlags] " /@openFlags@/: a single value from 'GI.Gtk.Flags.PlacesOpenFlags' specifying how it should be opened. " -> IO ()

- GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarShowStarredLocationCallback = [PlacesOpenFlags] -> IO ()

+ GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarShowStarredLocationCallback = [PlacesOpenFlags] " /@openFlags@/: a single value from 'GI.Gtk.Flags.PlacesOpenFlags' specifying how the starred file should be opened. " -> IO ()

- GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarUnmountCallback = MountOperation /@mountOperation@/: the 'GI.Gio.Objects.MountOperation.MountOperation' that is going to start. -> IO ()

+ GI.Gtk.Objects.PlacesSidebar: type PlacesSidebarUnmountCallback = MountOperation " /@mountOperation@/: the 'GI.Gio.Objects.MountOperation.MountOperation' that is going to start. " -> IO ()

- GI.Gtk.Objects.Plug: Plug :: (ManagedPtr Plug) -> Plug

+ GI.Gtk.Objects.Plug: Plug :: ManagedPtr Plug -> Plug

- GI.Gtk.Objects.Popover: Popover :: (ManagedPtr Popover) -> Popover

+ GI.Gtk.Objects.Popover: Popover :: ManagedPtr Popover -> Popover

- GI.Gtk.Objects.Popover: constructPopoverConstrainTo :: (IsPopover o) => PopoverConstraint -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Popover: constructPopoverConstrainTo :: IsPopover o => PopoverConstraint -> IO (GValueConstruct o)

- GI.Gtk.Objects.Popover: constructPopoverModal :: (IsPopover o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Popover: constructPopoverModal :: IsPopover o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Popover: constructPopoverPointingTo :: (IsPopover o) => Rectangle -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Popover: constructPopoverPointingTo :: IsPopover o => Rectangle -> IO (GValueConstruct o)

- GI.Gtk.Objects.Popover: constructPopoverPosition :: (IsPopover o) => PositionType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Popover: constructPopoverPosition :: IsPopover o => PositionType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Popover: constructPopoverTransitionsEnabled :: (IsPopover o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Popover: constructPopoverTransitionsEnabled :: IsPopover o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Popover: popoverBindModel :: (HasCallStack, MonadIO m, IsPopover a, IsMenuModel b) => a -> Maybe (b) -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Popover: popoverBindModel :: (HasCallStack, MonadIO m, IsPopover a, IsMenuModel b) => a -> Maybe b -> Maybe Text -> m ()

- GI.Gtk.Objects.Popover: popoverGetPointingTo :: (HasCallStack, MonadIO m, IsPopover a) => a -> m ((Bool, Rectangle))

+ GI.Gtk.Objects.Popover: popoverGetPointingTo :: (HasCallStack, MonadIO m, IsPopover a) => a -> m (Bool, Rectangle)

- GI.Gtk.Objects.Popover: popoverNew :: (HasCallStack, MonadIO m, IsWidget a) => Maybe (a) -> m Popover

+ GI.Gtk.Objects.Popover: popoverNew :: (HasCallStack, MonadIO m, IsWidget a) => Maybe a -> m Popover

- GI.Gtk.Objects.Popover: popoverNewFromModel :: (HasCallStack, MonadIO m, IsWidget a, IsMenuModel b) => Maybe (a) -> b -> m Popover

+ GI.Gtk.Objects.Popover: popoverNewFromModel :: (HasCallStack, MonadIO m, IsWidget a, IsMenuModel b) => Maybe a -> b -> m Popover

- GI.Gtk.Objects.Popover: popoverSetDefaultWidget :: (HasCallStack, MonadIO m, IsPopover a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Popover: popoverSetDefaultWidget :: (HasCallStack, MonadIO m, IsPopover a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Popover: popoverSetRelativeTo :: (HasCallStack, MonadIO m, IsPopover a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Popover: popoverSetRelativeTo :: (HasCallStack, MonadIO m, IsPopover a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.PopoverAccessible: PopoverAccessible :: (ManagedPtr PopoverAccessible) -> PopoverAccessible

+ GI.Gtk.Objects.PopoverAccessible: PopoverAccessible :: ManagedPtr PopoverAccessible -> PopoverAccessible

- GI.Gtk.Objects.PopoverMenu: PopoverMenu :: (ManagedPtr PopoverMenu) -> PopoverMenu

+ GI.Gtk.Objects.PopoverMenu: PopoverMenu :: ManagedPtr PopoverMenu -> PopoverMenu

- GI.Gtk.Objects.PopoverMenu: constructPopoverMenuVisibleSubmenu :: (IsPopoverMenu o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PopoverMenu: constructPopoverMenuVisibleSubmenu :: IsPopoverMenu o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.PrintContext: PrintContext :: (ManagedPtr PrintContext) -> PrintContext

+ GI.Gtk.Objects.PrintContext: PrintContext :: ManagedPtr PrintContext -> PrintContext

- GI.Gtk.Objects.PrintContext: printContextGetHardMargins :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m ((Bool, Double, Double, Double, Double))

+ GI.Gtk.Objects.PrintContext: printContextGetHardMargins :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m (Bool, Double, Double, Double, Double)

- GI.Gtk.Objects.PrintOperation: PrintOperation :: (ManagedPtr PrintOperation) -> PrintOperation

+ GI.Gtk.Objects.PrintOperation: PrintOperation :: ManagedPtr PrintOperation -> PrintOperation

- GI.Gtk.Objects.PrintOperation: constructPrintOperationAllowAsync :: (IsPrintOperation o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PrintOperation: constructPrintOperationAllowAsync :: IsPrintOperation o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PrintOperation: constructPrintOperationCurrentPage :: (IsPrintOperation o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PrintOperation: constructPrintOperationCurrentPage :: IsPrintOperation o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.PrintOperation: constructPrintOperationCustomTabLabel :: (IsPrintOperation o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PrintOperation: constructPrintOperationCustomTabLabel :: IsPrintOperation o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.PrintOperation: constructPrintOperationEmbedPageSetup :: (IsPrintOperation o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PrintOperation: constructPrintOperationEmbedPageSetup :: IsPrintOperation o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PrintOperation: constructPrintOperationExportFilename :: (IsPrintOperation o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PrintOperation: constructPrintOperationExportFilename :: IsPrintOperation o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.PrintOperation: constructPrintOperationHasSelection :: (IsPrintOperation o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PrintOperation: constructPrintOperationHasSelection :: IsPrintOperation o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PrintOperation: constructPrintOperationJobName :: (IsPrintOperation o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PrintOperation: constructPrintOperationJobName :: IsPrintOperation o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.PrintOperation: constructPrintOperationNPages :: (IsPrintOperation o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PrintOperation: constructPrintOperationNPages :: IsPrintOperation o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.PrintOperation: constructPrintOperationShowProgress :: (IsPrintOperation o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PrintOperation: constructPrintOperationShowProgress :: IsPrintOperation o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PrintOperation: constructPrintOperationSupportSelection :: (IsPrintOperation o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PrintOperation: constructPrintOperationSupportSelection :: IsPrintOperation o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PrintOperation: constructPrintOperationTrackPrintStatus :: (IsPrintOperation o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PrintOperation: constructPrintOperationTrackPrintStatus :: IsPrintOperation o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PrintOperation: constructPrintOperationUnit :: (IsPrintOperation o) => Unit -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PrintOperation: constructPrintOperationUnit :: IsPrintOperation o => Unit -> IO (GValueConstruct o)

- GI.Gtk.Objects.PrintOperation: constructPrintOperationUseFullPage :: (IsPrintOperation o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.PrintOperation: constructPrintOperationUseFullPage :: IsPrintOperation o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.PrintOperation: printOperationRun :: (HasCallStack, MonadIO m, IsPrintOperation a, IsWindow b) => a -> PrintOperationAction -> Maybe (b) -> m PrintOperationResult

+ GI.Gtk.Objects.PrintOperation: printOperationRun :: (HasCallStack, MonadIO m, IsPrintOperation a, IsWindow b) => a -> PrintOperationAction -> Maybe b -> m PrintOperationResult

- GI.Gtk.Objects.PrintOperation: printOperationSetCustomTabLabel :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.PrintOperation: printOperationSetCustomTabLabel :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.PrintOperation: printOperationSetDefaultPageSetup :: (HasCallStack, MonadIO m, IsPrintOperation a, IsPageSetup b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.PrintOperation: printOperationSetDefaultPageSetup :: (HasCallStack, MonadIO m, IsPrintOperation a, IsPageSetup b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.PrintOperation: printOperationSetPrintSettings :: (HasCallStack, MonadIO m, IsPrintOperation a, IsPrintSettings b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.PrintOperation: printOperationSetPrintSettings :: (HasCallStack, MonadIO m, IsPrintOperation a, IsPrintSettings b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.PrintOperation: type PrintOperationBeginPrintCallback = PrintContext /@context@/: the 'GI.Gtk.Objects.PrintContext.PrintContext' for the current operation -> IO ()

+ GI.Gtk.Objects.PrintOperation: type PrintOperationBeginPrintCallback = PrintContext " /@context@/: the 'GI.Gtk.Objects.PrintContext.PrintContext' for the current operation " -> IO ()

- GI.Gtk.Objects.PrintOperation: type PrintOperationCreateCustomWidgetCallback = IO Object __Returns:__ A custom widget that gets embedded in the print dialog, or 'Nothing'

+ GI.Gtk.Objects.PrintOperation: type PrintOperationCreateCustomWidgetCallback = IO Object " __Returns:__ A custom widget that gets embedded in the print dialog, or 'Nothing' "

- GI.Gtk.Objects.PrintOperation: type PrintOperationCustomWidgetApplyCallback = Widget /@widget@/: the custom widget added in create-custom-widget -> IO ()

+ GI.Gtk.Objects.PrintOperation: type PrintOperationCustomWidgetApplyCallback = Widget " /@widget@/: the custom widget added in create-custom-widget " -> IO ()

- GI.Gtk.Objects.PrintOperation: type PrintOperationDoneCallback = PrintOperationResult /@result@/: the result of the print operation -> IO ()

+ GI.Gtk.Objects.PrintOperation: type PrintOperationDoneCallback = PrintOperationResult " /@result@/: the result of the print operation " -> IO ()

- GI.Gtk.Objects.PrintOperation: type PrintOperationDrawPageCallback = PrintContext /@context@/: the 'GI.Gtk.Objects.PrintContext.PrintContext' for the current operation -> Int32 /@pageNr@/: the number of the currently printed page (0-based) -> IO ()

+ GI.Gtk.Objects.PrintOperation: type PrintOperationDrawPageCallback = PrintContext " /@context@/: the 'GI.Gtk.Objects.PrintContext.PrintContext' for the current operation " -> Int32 " /@pageNr@/: the number of the currently printed page (0-based) " -> IO ()

- GI.Gtk.Objects.PrintOperation: type PrintOperationEndPrintCallback = PrintContext /@context@/: the 'GI.Gtk.Objects.PrintContext.PrintContext' for the current operation -> IO ()

+ GI.Gtk.Objects.PrintOperation: type PrintOperationEndPrintCallback = PrintContext " /@context@/: the 'GI.Gtk.Objects.PrintContext.PrintContext' for the current operation " -> IO ()

- GI.Gtk.Objects.PrintOperation: type PrintOperationPaginateCallback = PrintContext /@context@/: the 'GI.Gtk.Objects.PrintContext.PrintContext' for the current operation -> IO Bool __Returns:__ 'True' if pagination is complete

+ GI.Gtk.Objects.PrintOperation: type PrintOperationPaginateCallback = PrintContext " /@context@/: the 'GI.Gtk.Objects.PrintContext.PrintContext' for the current operation " -> IO Bool " __Returns:__ 'True' if pagination is complete "

- GI.Gtk.Objects.PrintOperation: type PrintOperationPreviewCallback = PrintOperationPreview /@preview@/: the 'GI.Gtk.Interfaces.PrintOperationPreview.PrintOperationPreview' for the current operation -> PrintContext /@context@/: the 'GI.Gtk.Objects.PrintContext.PrintContext' that will be used -> Maybe Window /@parent@/: the 'GI.Gtk.Objects.Window.Window' to use as window parent, or 'Nothing' -> IO Bool __Returns:__ 'True' if the listener wants to take over control of the preview

+ GI.Gtk.Objects.PrintOperation: type PrintOperationPreviewCallback = PrintOperationPreview " /@preview@/: the 'GI.Gtk.Interfaces.PrintOperationPreview.PrintOperationPreview' for the current operation " -> PrintContext " /@context@/: the 'GI.Gtk.Objects.PrintContext.PrintContext' that will be used " -> Maybe Window " /@parent@/: the 'GI.Gtk.Objects.Window.Window' to use as window parent, or 'Nothing' " -> IO Bool " __Returns:__ 'True' if the listener wants to take over control of the preview "

- GI.Gtk.Objects.PrintOperation: type PrintOperationRequestPageSetupCallback = PrintContext /@context@/: the 'GI.Gtk.Objects.PrintContext.PrintContext' for the current operation -> Int32 /@pageNr@/: the number of the currently printed page (0-based) -> PageSetup /@setup@/: the 'GI.Gtk.Objects.PageSetup.PageSetup' -> IO ()

+ GI.Gtk.Objects.PrintOperation: type PrintOperationRequestPageSetupCallback = PrintContext " /@context@/: the 'GI.Gtk.Objects.PrintContext.PrintContext' for the current operation " -> Int32 " /@pageNr@/: the number of the currently printed page (0-based) " -> PageSetup " /@setup@/: the 'GI.Gtk.Objects.PageSetup.PageSetup' " -> IO ()

- GI.Gtk.Objects.PrintOperation: type PrintOperationUpdateCustomWidgetCallback = Widget /@widget@/: the custom widget added in create-custom-widget -> PageSetup /@setup@/: actual page setup -> PrintSettings /@settings@/: actual print settings -> IO ()

+ GI.Gtk.Objects.PrintOperation: type PrintOperationUpdateCustomWidgetCallback = Widget " /@widget@/: the custom widget added in create-custom-widget " -> PageSetup " /@setup@/: actual page setup " -> PrintSettings " /@settings@/: actual print settings " -> IO ()

- GI.Gtk.Objects.PrintSettings: PrintSettings :: (ManagedPtr PrintSettings) -> PrintSettings

+ GI.Gtk.Objects.PrintSettings: PrintSettings :: ManagedPtr PrintSettings -> PrintSettings

- GI.Gtk.Objects.PrintSettings: printSettingsLoadKeyFile :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> KeyFile -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.PrintSettings: printSettingsLoadKeyFile :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> KeyFile -> Maybe Text -> m ()

- GI.Gtk.Objects.PrintSettings: printSettingsNewFromKeyFile :: (HasCallStack, MonadIO m) => KeyFile -> Maybe (Text) -> m PrintSettings

+ GI.Gtk.Objects.PrintSettings: printSettingsNewFromKeyFile :: (HasCallStack, MonadIO m) => KeyFile -> Maybe Text -> m PrintSettings

- GI.Gtk.Objects.PrintSettings: printSettingsSet :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.PrintSettings: printSettingsSet :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Maybe Text -> m ()

- GI.Gtk.Objects.ProgressBar: ProgressBar :: (ManagedPtr ProgressBar) -> ProgressBar

+ GI.Gtk.Objects.ProgressBar: ProgressBar :: ManagedPtr ProgressBar -> ProgressBar

- GI.Gtk.Objects.ProgressBar: constructProgressBarEllipsize :: (IsProgressBar o) => EllipsizeMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ProgressBar: constructProgressBarEllipsize :: IsProgressBar o => EllipsizeMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.ProgressBar: constructProgressBarFraction :: (IsProgressBar o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ProgressBar: constructProgressBarFraction :: IsProgressBar o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.ProgressBar: constructProgressBarInverted :: (IsProgressBar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ProgressBar: constructProgressBarInverted :: IsProgressBar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ProgressBar: constructProgressBarPulseStep :: (IsProgressBar o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ProgressBar: constructProgressBarPulseStep :: IsProgressBar o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.ProgressBar: constructProgressBarShowText :: (IsProgressBar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ProgressBar: constructProgressBarShowText :: IsProgressBar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ProgressBar: constructProgressBarText :: (IsProgressBar o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ProgressBar: constructProgressBarText :: IsProgressBar o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ProgressBar: progressBarSetText :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.ProgressBar: progressBarSetText :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.ProgressBarAccessible: ProgressBarAccessible :: (ManagedPtr ProgressBarAccessible) -> ProgressBarAccessible

+ GI.Gtk.Objects.ProgressBarAccessible: ProgressBarAccessible :: ManagedPtr ProgressBarAccessible -> ProgressBarAccessible

- GI.Gtk.Objects.RadioAction: RadioAction :: (ManagedPtr RadioAction) -> RadioAction

+ GI.Gtk.Objects.RadioAction: RadioAction :: ManagedPtr RadioAction -> RadioAction

- GI.Gtk.Objects.RadioAction: constructRadioActionCurrentValue :: (IsRadioAction o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.RadioAction: constructRadioActionCurrentValue :: IsRadioAction o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.RadioAction: constructRadioActionValue :: (IsRadioAction o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.RadioAction: constructRadioActionValue :: IsRadioAction o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.RadioAction: radioActionJoinGroup :: (HasCallStack, MonadIO m, IsRadioAction a, IsRadioAction b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.RadioAction: radioActionJoinGroup :: (HasCallStack, MonadIO m, IsRadioAction a, IsRadioAction b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.RadioAction: radioActionNew :: (HasCallStack, MonadIO m) => Text -> Maybe (Text) -> Maybe (Text) -> Maybe (Text) -> Int32 -> m RadioAction

+ GI.Gtk.Objects.RadioAction: radioActionNew :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> Int32 -> m RadioAction

- GI.Gtk.Objects.RadioAction: type RadioActionChangedCallback = RadioAction /@current@/: the member of /@action@/\'s group which has just been activated -> IO ()

+ GI.Gtk.Objects.RadioAction: type RadioActionChangedCallback = RadioAction " /@current@/: the member of /@action@/\'s group which has just been activated " -> IO ()

- GI.Gtk.Objects.RadioButton: RadioButton :: (ManagedPtr RadioButton) -> RadioButton

+ GI.Gtk.Objects.RadioButton: RadioButton :: ManagedPtr RadioButton -> RadioButton

- GI.Gtk.Objects.RadioButton: radioButtonJoinGroup :: (HasCallStack, MonadIO m, IsRadioButton a, IsRadioButton b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.RadioButton: radioButtonJoinGroup :: (HasCallStack, MonadIO m, IsRadioButton a, IsRadioButton b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.RadioButton: radioButtonNewFromWidget :: (HasCallStack, MonadIO m, IsRadioButton a) => Maybe (a) -> m RadioButton

+ GI.Gtk.Objects.RadioButton: radioButtonNewFromWidget :: (HasCallStack, MonadIO m, IsRadioButton a) => Maybe a -> m RadioButton

- GI.Gtk.Objects.RadioButton: radioButtonNewWithLabelFromWidget :: (HasCallStack, MonadIO m, IsRadioButton a) => Maybe (a) -> Text -> m RadioButton

+ GI.Gtk.Objects.RadioButton: radioButtonNewWithLabelFromWidget :: (HasCallStack, MonadIO m, IsRadioButton a) => Maybe a -> Text -> m RadioButton

- GI.Gtk.Objects.RadioButton: radioButtonNewWithMnemonicFromWidget :: (HasCallStack, MonadIO m, IsRadioButton a) => Maybe (a) -> Text -> m RadioButton

+ GI.Gtk.Objects.RadioButton: radioButtonNewWithMnemonicFromWidget :: (HasCallStack, MonadIO m, IsRadioButton a) => Maybe a -> Text -> m RadioButton

- GI.Gtk.Objects.RadioButtonAccessible: RadioButtonAccessible :: (ManagedPtr RadioButtonAccessible) -> RadioButtonAccessible

+ GI.Gtk.Objects.RadioButtonAccessible: RadioButtonAccessible :: ManagedPtr RadioButtonAccessible -> RadioButtonAccessible

- GI.Gtk.Objects.RadioMenuItem: RadioMenuItem :: (ManagedPtr RadioMenuItem) -> RadioMenuItem

+ GI.Gtk.Objects.RadioMenuItem: RadioMenuItem :: ManagedPtr RadioMenuItem -> RadioMenuItem

- GI.Gtk.Objects.RadioMenuItem: radioMenuItemJoinGroup :: (HasCallStack, MonadIO m, IsRadioMenuItem a, IsRadioMenuItem b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.RadioMenuItem: radioMenuItemJoinGroup :: (HasCallStack, MonadIO m, IsRadioMenuItem a, IsRadioMenuItem b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.RadioMenuItem: radioMenuItemNewFromWidget :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => Maybe (a) -> m RadioMenuItem

+ GI.Gtk.Objects.RadioMenuItem: radioMenuItemNewFromWidget :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => Maybe a -> m RadioMenuItem

- GI.Gtk.Objects.RadioMenuItem: radioMenuItemNewWithLabelFromWidget :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => Maybe (a) -> Maybe (Text) -> m RadioMenuItem

+ GI.Gtk.Objects.RadioMenuItem: radioMenuItemNewWithLabelFromWidget :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => Maybe a -> Maybe Text -> m RadioMenuItem

- GI.Gtk.Objects.RadioMenuItem: radioMenuItemNewWithMnemonicFromWidget :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => Maybe (a) -> Maybe (Text) -> m RadioMenuItem

+ GI.Gtk.Objects.RadioMenuItem: radioMenuItemNewWithMnemonicFromWidget :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => Maybe a -> Maybe Text -> m RadioMenuItem

- GI.Gtk.Objects.RadioMenuItemAccessible: RadioMenuItemAccessible :: (ManagedPtr RadioMenuItemAccessible) -> RadioMenuItemAccessible

+ GI.Gtk.Objects.RadioMenuItemAccessible: RadioMenuItemAccessible :: ManagedPtr RadioMenuItemAccessible -> RadioMenuItemAccessible

- GI.Gtk.Objects.RadioToolButton: RadioToolButton :: (ManagedPtr RadioToolButton) -> RadioToolButton

+ GI.Gtk.Objects.RadioToolButton: RadioToolButton :: ManagedPtr RadioToolButton -> RadioToolButton

- GI.Gtk.Objects.RadioToolButton: radioToolButtonNewFromWidget :: (HasCallStack, MonadIO m, IsRadioToolButton a) => Maybe (a) -> m RadioToolButton

+ GI.Gtk.Objects.RadioToolButton: radioToolButtonNewFromWidget :: (HasCallStack, MonadIO m, IsRadioToolButton a) => Maybe a -> m RadioToolButton

- GI.Gtk.Objects.RadioToolButton: radioToolButtonNewWithStockFromWidget :: (HasCallStack, MonadIO m, IsRadioToolButton a) => Maybe (a) -> Text -> m RadioToolButton

+ GI.Gtk.Objects.RadioToolButton: radioToolButtonNewWithStockFromWidget :: (HasCallStack, MonadIO m, IsRadioToolButton a) => Maybe a -> Text -> m RadioToolButton

- GI.Gtk.Objects.Range: Range :: (ManagedPtr Range) -> Range

+ GI.Gtk.Objects.Range: Range :: ManagedPtr Range -> Range

- GI.Gtk.Objects.Range: constructRangeFillLevel :: (IsRange o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Range: constructRangeFillLevel :: IsRange o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.Range: constructRangeInverted :: (IsRange o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Range: constructRangeInverted :: IsRange o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Range: constructRangeLowerStepperSensitivity :: (IsRange o) => SensitivityType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Range: constructRangeLowerStepperSensitivity :: IsRange o => SensitivityType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Range: constructRangeRestrictToFillLevel :: (IsRange o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Range: constructRangeRestrictToFillLevel :: IsRange o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Range: constructRangeRoundDigits :: (IsRange o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Range: constructRangeRoundDigits :: IsRange o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Range: constructRangeShowFillLevel :: (IsRange o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Range: constructRangeShowFillLevel :: IsRange o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Range: constructRangeUpperStepperSensitivity :: (IsRange o) => SensitivityType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Range: constructRangeUpperStepperSensitivity :: IsRange o => SensitivityType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Range: rangeGetRangeRect :: (HasCallStack, MonadIO m, IsRange a) => a -> m (Rectangle)

+ GI.Gtk.Objects.Range: rangeGetRangeRect :: (HasCallStack, MonadIO m, IsRange a) => a -> m Rectangle

- GI.Gtk.Objects.Range: rangeGetSliderRange :: (HasCallStack, MonadIO m, IsRange a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.Range: rangeGetSliderRange :: (HasCallStack, MonadIO m, IsRange a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.Range: type RangeAdjustBoundsCallback = Double /@value@/: the value before we clamp -> IO ()

+ GI.Gtk.Objects.Range: type RangeAdjustBoundsCallback = Double " /@value@/: the value before we clamp " -> IO ()

- GI.Gtk.Objects.Range: type RangeChangeValueCallback = ScrollType /@scroll@/: the type of scroll action that was performed -> Double /@value@/: the new value resulting from the scroll action -> IO Bool __Returns:__ 'True' to prevent other handlers from being invoked for the signal, 'False' to propagate the signal further

+ GI.Gtk.Objects.Range: type RangeChangeValueCallback = ScrollType " /@scroll@/: the type of scroll action that was performed " -> Double " /@value@/: the new value resulting from the scroll action " -> IO Bool " __Returns:__ 'True' to prevent other handlers from being invoked for the signal, 'False' to propagate the signal further "

- GI.Gtk.Objects.Range: type RangeMoveSliderCallback = ScrollType /@step@/: how to move the slider -> IO ()

+ GI.Gtk.Objects.Range: type RangeMoveSliderCallback = ScrollType " /@step@/: how to move the slider " -> IO ()

- GI.Gtk.Objects.RangeAccessible: RangeAccessible :: (ManagedPtr RangeAccessible) -> RangeAccessible

+ GI.Gtk.Objects.RangeAccessible: RangeAccessible :: ManagedPtr RangeAccessible -> RangeAccessible

- GI.Gtk.Objects.RcStyle: RcStyle :: (ManagedPtr RcStyle) -> RcStyle

+ GI.Gtk.Objects.RcStyle: RcStyle :: ManagedPtr RcStyle -> RcStyle

- GI.Gtk.Objects.RecentAction: RecentAction :: (ManagedPtr RecentAction) -> RecentAction

+ GI.Gtk.Objects.RecentAction: RecentAction :: ManagedPtr RecentAction -> RecentAction

- GI.Gtk.Objects.RecentAction: constructRecentActionShowNumbers :: (IsRecentAction o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.RecentAction: constructRecentActionShowNumbers :: IsRecentAction o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.RecentAction: recentActionNew :: (HasCallStack, MonadIO m) => Text -> Maybe (Text) -> Maybe (Text) -> Maybe (Text) -> m RecentAction

+ GI.Gtk.Objects.RecentAction: recentActionNew :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> m RecentAction

- GI.Gtk.Objects.RecentAction: recentActionNewForManager :: (HasCallStack, MonadIO m, IsRecentManager a) => Text -> Maybe (Text) -> Maybe (Text) -> Maybe (Text) -> Maybe (a) -> m RecentAction

+ GI.Gtk.Objects.RecentAction: recentActionNewForManager :: (HasCallStack, MonadIO m, IsRecentManager a) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> Maybe a -> m RecentAction

- GI.Gtk.Objects.RecentChooserDialog: RecentChooserDialog :: (ManagedPtr RecentChooserDialog) -> RecentChooserDialog

+ GI.Gtk.Objects.RecentChooserDialog: RecentChooserDialog :: ManagedPtr RecentChooserDialog -> RecentChooserDialog

- GI.Gtk.Objects.RecentChooserMenu: RecentChooserMenu :: (ManagedPtr RecentChooserMenu) -> RecentChooserMenu

+ GI.Gtk.Objects.RecentChooserMenu: RecentChooserMenu :: ManagedPtr RecentChooserMenu -> RecentChooserMenu

- GI.Gtk.Objects.RecentChooserMenu: constructRecentChooserMenuShowNumbers :: (IsRecentChooserMenu o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.RecentChooserMenu: constructRecentChooserMenuShowNumbers :: IsRecentChooserMenu o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.RecentChooserWidget: RecentChooserWidget :: (ManagedPtr RecentChooserWidget) -> RecentChooserWidget

+ GI.Gtk.Objects.RecentChooserWidget: RecentChooserWidget :: ManagedPtr RecentChooserWidget -> RecentChooserWidget

- GI.Gtk.Objects.RecentFilter: RecentFilter :: (ManagedPtr RecentFilter) -> RecentFilter

+ GI.Gtk.Objects.RecentFilter: RecentFilter :: ManagedPtr RecentFilter -> RecentFilter

- GI.Gtk.Objects.RecentManager: RecentManager :: (ManagedPtr RecentManager) -> RecentManager

+ GI.Gtk.Objects.RecentManager: RecentManager :: ManagedPtr RecentManager -> RecentManager

- GI.Gtk.Objects.RecentManager: constructRecentManagerFilename :: (IsRecentManager o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.RecentManager: constructRecentManagerFilename :: IsRecentManager o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.RecentManager: recentManagerMoveItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.RecentManager: recentManagerMoveItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> Maybe Text -> m ()

- GI.Gtk.Objects.RendererCellAccessible: RendererCellAccessible :: (ManagedPtr RendererCellAccessible) -> RendererCellAccessible

+ GI.Gtk.Objects.RendererCellAccessible: RendererCellAccessible :: ManagedPtr RendererCellAccessible -> RendererCellAccessible

- GI.Gtk.Objects.Revealer: Revealer :: (ManagedPtr Revealer) -> Revealer

+ GI.Gtk.Objects.Revealer: Revealer :: ManagedPtr Revealer -> Revealer

- GI.Gtk.Objects.Revealer: constructRevealerRevealChild :: (IsRevealer o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Revealer: constructRevealerRevealChild :: IsRevealer o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Revealer: constructRevealerTransitionDuration :: (IsRevealer o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Revealer: constructRevealerTransitionDuration :: IsRevealer o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Revealer: constructRevealerTransitionType :: (IsRevealer o) => RevealerTransitionType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Revealer: constructRevealerTransitionType :: IsRevealer o => RevealerTransitionType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Scale: Scale :: (ManagedPtr Scale) -> Scale

+ GI.Gtk.Objects.Scale: Scale :: ManagedPtr Scale -> Scale

- GI.Gtk.Objects.Scale: constructScaleDigits :: (IsScale o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Scale: constructScaleDigits :: IsScale o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Scale: constructScaleDrawValue :: (IsScale o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Scale: constructScaleDrawValue :: IsScale o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Scale: constructScaleHasOrigin :: (IsScale o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Scale: constructScaleHasOrigin :: IsScale o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Scale: constructScaleValuePos :: (IsScale o) => PositionType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Scale: constructScaleValuePos :: IsScale o => PositionType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Scale: scaleAddMark :: (HasCallStack, MonadIO m, IsScale a) => a -> Double -> PositionType -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Scale: scaleAddMark :: (HasCallStack, MonadIO m, IsScale a) => a -> Double -> PositionType -> Maybe Text -> m ()

- GI.Gtk.Objects.Scale: scaleGetLayoutOffsets :: (HasCallStack, MonadIO m, IsScale a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.Scale: scaleGetLayoutOffsets :: (HasCallStack, MonadIO m, IsScale a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.Scale: scaleNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Orientation -> Maybe (a) -> m Scale

+ GI.Gtk.Objects.Scale: scaleNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Orientation -> Maybe a -> m Scale

- GI.Gtk.Objects.Scale: type ScaleFormatValueCallback = Double /@value@/: the value to format -> IO Text __Returns:__ allocated string representing /@value@/

+ GI.Gtk.Objects.Scale: type ScaleFormatValueCallback = Double " /@value@/: the value to format " -> IO Text " __Returns:__ allocated string representing /@value@/ "

- GI.Gtk.Objects.ScaleAccessible: ScaleAccessible :: (ManagedPtr ScaleAccessible) -> ScaleAccessible

+ GI.Gtk.Objects.ScaleAccessible: ScaleAccessible :: ManagedPtr ScaleAccessible -> ScaleAccessible

- GI.Gtk.Objects.ScaleButton: ScaleButton :: (ManagedPtr ScaleButton) -> ScaleButton

+ GI.Gtk.Objects.ScaleButton: ScaleButton :: ManagedPtr ScaleButton -> ScaleButton

- GI.Gtk.Objects.ScaleButton: constructScaleButtonIcons :: (IsScaleButton o) => [Text] -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScaleButton: constructScaleButtonIcons :: IsScaleButton o => [Text] -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScaleButton: constructScaleButtonSize :: (IsScaleButton o) => IconSize -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScaleButton: constructScaleButtonSize :: IsScaleButton o => IconSize -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScaleButton: constructScaleButtonValue :: (IsScaleButton o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScaleButton: constructScaleButtonValue :: IsScaleButton o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScaleButton: scaleButtonNew :: (HasCallStack, MonadIO m) => Int32 -> Double -> Double -> Double -> Maybe ([Text]) -> m ScaleButton

+ GI.Gtk.Objects.ScaleButton: scaleButtonNew :: (HasCallStack, MonadIO m) => Int32 -> Double -> Double -> Double -> Maybe [Text] -> m ScaleButton

- GI.Gtk.Objects.ScaleButton: type ScaleButtonValueChangedCallback = Double /@value@/: the new value -> IO ()

+ GI.Gtk.Objects.ScaleButton: type ScaleButtonValueChangedCallback = Double " /@value@/: the new value " -> IO ()

- GI.Gtk.Objects.ScaleButtonAccessible: ScaleButtonAccessible :: (ManagedPtr ScaleButtonAccessible) -> ScaleButtonAccessible

+ GI.Gtk.Objects.ScaleButtonAccessible: ScaleButtonAccessible :: ManagedPtr ScaleButtonAccessible -> ScaleButtonAccessible

- GI.Gtk.Objects.Scrollbar: Scrollbar :: (ManagedPtr Scrollbar) -> Scrollbar

+ GI.Gtk.Objects.Scrollbar: Scrollbar :: ManagedPtr Scrollbar -> Scrollbar

- GI.Gtk.Objects.Scrollbar: scrollbarNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Orientation -> Maybe (a) -> m Scrollbar

+ GI.Gtk.Objects.Scrollbar: scrollbarNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Orientation -> Maybe a -> m Scrollbar

- GI.Gtk.Objects.ScrolledWindow: ScrolledWindow :: (ManagedPtr ScrolledWindow) -> ScrolledWindow

+ GI.Gtk.Objects.ScrolledWindow: ScrolledWindow :: ManagedPtr ScrolledWindow -> ScrolledWindow

- GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowHscrollbarPolicy :: (IsScrolledWindow o) => PolicyType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowHscrollbarPolicy :: IsScrolledWindow o => PolicyType -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowKineticScrolling :: (IsScrolledWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowKineticScrolling :: IsScrolledWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowMaxContentHeight :: (IsScrolledWindow o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowMaxContentHeight :: IsScrolledWindow o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowMaxContentWidth :: (IsScrolledWindow o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowMaxContentWidth :: IsScrolledWindow o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowMinContentHeight :: (IsScrolledWindow o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowMinContentHeight :: IsScrolledWindow o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowMinContentWidth :: (IsScrolledWindow o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowMinContentWidth :: IsScrolledWindow o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowOverlayScrolling :: (IsScrolledWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowOverlayScrolling :: IsScrolledWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowPropagateNaturalHeight :: (IsScrolledWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowPropagateNaturalHeight :: IsScrolledWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowPropagateNaturalWidth :: (IsScrolledWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowPropagateNaturalWidth :: IsScrolledWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowShadowType :: (IsScrolledWindow o) => ShadowType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowShadowType :: IsScrolledWindow o => ShadowType -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowVscrollbarPolicy :: (IsScrolledWindow o) => PolicyType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowVscrollbarPolicy :: IsScrolledWindow o => PolicyType -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowWindowPlacement :: (IsScrolledWindow o) => CornerType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowWindowPlacement :: IsScrolledWindow o => CornerType -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowWindowPlacementSet :: (IsScrolledWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ScrolledWindow: constructScrolledWindowWindowPlacementSet :: IsScrolledWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ScrolledWindow: scrolledWindowGetPolicy :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m ((PolicyType, PolicyType))

+ GI.Gtk.Objects.ScrolledWindow: scrolledWindowGetPolicy :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m (PolicyType, PolicyType)

- GI.Gtk.Objects.ScrolledWindow: scrolledWindowNew :: (HasCallStack, MonadIO m, IsAdjustment a, IsAdjustment b) => Maybe (a) -> Maybe (b) -> m ScrolledWindow

+ GI.Gtk.Objects.ScrolledWindow: scrolledWindowNew :: (HasCallStack, MonadIO m, IsAdjustment a, IsAdjustment b) => Maybe a -> Maybe b -> m ScrolledWindow

- GI.Gtk.Objects.ScrolledWindow: type ScrolledWindowEdgeOvershotCallback = PositionType /@pos@/: edge side that was hit -> IO ()

+ GI.Gtk.Objects.ScrolledWindow: type ScrolledWindowEdgeOvershotCallback = PositionType " /@pos@/: edge side that was hit " -> IO ()

- GI.Gtk.Objects.ScrolledWindow: type ScrolledWindowEdgeReachedCallback = PositionType /@pos@/: edge side that was reached -> IO ()

+ GI.Gtk.Objects.ScrolledWindow: type ScrolledWindowEdgeReachedCallback = PositionType " /@pos@/: edge side that was reached " -> IO ()

- GI.Gtk.Objects.ScrolledWindow: type ScrolledWindowMoveFocusOutCallback = DirectionType /@directionType@/: either 'GI.Gtk.Enums.DirectionTypeTabForward' or 'GI.Gtk.Enums.DirectionTypeTabBackward' -> IO ()

+ GI.Gtk.Objects.ScrolledWindow: type ScrolledWindowMoveFocusOutCallback = DirectionType " /@directionType@/: either 'GI.Gtk.Enums.DirectionTypeTabForward' or 'GI.Gtk.Enums.DirectionTypeTabBackward' " -> IO ()

- GI.Gtk.Objects.ScrolledWindow: type ScrolledWindowScrollChildCallback = ScrollType /@scroll@/: a 'GI.Gtk.Enums.ScrollType' describing how much to scroll -> Bool /@horizontal@/: whether the keybinding scrolls the child horizontally or not -> IO Bool

+ GI.Gtk.Objects.ScrolledWindow: type ScrolledWindowScrollChildCallback = ScrollType " /@scroll@/: a 'GI.Gtk.Enums.ScrollType' describing how much to scroll " -> Bool " /@horizontal@/: whether the keybinding scrolls the child horizontally or not " -> IO Bool

- GI.Gtk.Objects.ScrolledWindowAccessible: ScrolledWindowAccessible :: (ManagedPtr ScrolledWindowAccessible) -> ScrolledWindowAccessible

+ GI.Gtk.Objects.ScrolledWindowAccessible: ScrolledWindowAccessible :: ManagedPtr ScrolledWindowAccessible -> ScrolledWindowAccessible

- GI.Gtk.Objects.SearchBar: SearchBar :: (ManagedPtr SearchBar) -> SearchBar

+ GI.Gtk.Objects.SearchBar: SearchBar :: ManagedPtr SearchBar -> SearchBar

- GI.Gtk.Objects.SearchBar: constructSearchBarSearchModeEnabled :: (IsSearchBar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.SearchBar: constructSearchBarSearchModeEnabled :: IsSearchBar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.SearchBar: constructSearchBarShowCloseButton :: (IsSearchBar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.SearchBar: constructSearchBarShowCloseButton :: IsSearchBar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.SearchEntry: SearchEntry :: (ManagedPtr SearchEntry) -> SearchEntry

+ GI.Gtk.Objects.SearchEntry: SearchEntry :: ManagedPtr SearchEntry -> SearchEntry

- GI.Gtk.Objects.Separator: Separator :: (ManagedPtr Separator) -> Separator

+ GI.Gtk.Objects.Separator: Separator :: ManagedPtr Separator -> Separator

- GI.Gtk.Objects.SeparatorMenuItem: SeparatorMenuItem :: (ManagedPtr SeparatorMenuItem) -> SeparatorMenuItem

+ GI.Gtk.Objects.SeparatorMenuItem: SeparatorMenuItem :: ManagedPtr SeparatorMenuItem -> SeparatorMenuItem

- GI.Gtk.Objects.SeparatorToolItem: SeparatorToolItem :: (ManagedPtr SeparatorToolItem) -> SeparatorToolItem

+ GI.Gtk.Objects.SeparatorToolItem: SeparatorToolItem :: ManagedPtr SeparatorToolItem -> SeparatorToolItem

- GI.Gtk.Objects.SeparatorToolItem: constructSeparatorToolItemDraw :: (IsSeparatorToolItem o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.SeparatorToolItem: constructSeparatorToolItemDraw :: IsSeparatorToolItem o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: Settings :: (ManagedPtr Settings) -> Settings

+ GI.Gtk.Objects.Settings: Settings :: ManagedPtr Settings -> Settings

- GI.Gtk.Objects.Settings: constructSettingsGtkAlternativeButtonOrder :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkAlternativeButtonOrder :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkAlternativeSortArrows :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkAlternativeSortArrows :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkApplicationPreferDarkTheme :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkApplicationPreferDarkTheme :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkAutoMnemonics :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkAutoMnemonics :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkButtonImages :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkButtonImages :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkCanChangeAccels :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkCanChangeAccels :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkColorPalette :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkColorPalette :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkColorScheme :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkColorScheme :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkCursorBlink :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkCursorBlink :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkCursorBlinkTime :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkCursorBlinkTime :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkCursorBlinkTimeout :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkCursorBlinkTimeout :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkCursorThemeName :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkCursorThemeName :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkCursorThemeSize :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkCursorThemeSize :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkDecorationLayout :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkDecorationLayout :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkDialogsUseHeader :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkDialogsUseHeader :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkDndDragThreshold :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkDndDragThreshold :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkDoubleClickDistance :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkDoubleClickDistance :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkDoubleClickTime :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkDoubleClickTime :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkEnableAccels :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkEnableAccels :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkEnableAnimations :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkEnableAnimations :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkEnableEventSounds :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkEnableEventSounds :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkEnableInputFeedbackSounds :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkEnableInputFeedbackSounds :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkEnableMnemonics :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkEnableMnemonics :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkEnablePrimaryPaste :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkEnablePrimaryPaste :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkEnableTooltips :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkEnableTooltips :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkEntryPasswordHintTimeout :: (IsSettings o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkEntryPasswordHintTimeout :: IsSettings o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkEntrySelectOnFocus :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkEntrySelectOnFocus :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkErrorBell :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkErrorBell :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkFallbackIconTheme :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkFallbackIconTheme :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkFileChooserBackend :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkFileChooserBackend :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkFontName :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkFontName :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkFontconfigTimestamp :: (IsSettings o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkFontconfigTimestamp :: IsSettings o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkIconSizes :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkIconSizes :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkIconThemeName :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkIconThemeName :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkImModule :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkImModule :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkImPreeditStyle :: (IsSettings o) => IMPreeditStyle -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkImPreeditStyle :: IsSettings o => IMPreeditStyle -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkImStatusStyle :: (IsSettings o) => IMStatusStyle -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkImStatusStyle :: IsSettings o => IMStatusStyle -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkKeyThemeName :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkKeyThemeName :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkKeynavCursorOnly :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkKeynavCursorOnly :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkKeynavUseCaret :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkKeynavUseCaret :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkKeynavWrapAround :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkKeynavWrapAround :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkLabelSelectOnFocus :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkLabelSelectOnFocus :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkLongPressTime :: (IsSettings o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkLongPressTime :: IsSettings o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkMenuBarAccel :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkMenuBarAccel :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkMenuBarPopupDelay :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkMenuBarPopupDelay :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkMenuImages :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkMenuImages :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkMenuPopdownDelay :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkMenuPopdownDelay :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkMenuPopupDelay :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkMenuPopupDelay :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkModules :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkModules :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkPrimaryButtonWarpsSlider :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkPrimaryButtonWarpsSlider :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkPrintBackends :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkPrintBackends :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkPrintPreviewCommand :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkPrintPreviewCommand :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkRecentFilesEnabled :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkRecentFilesEnabled :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkRecentFilesLimit :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkRecentFilesLimit :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkRecentFilesMaxAge :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkRecentFilesMaxAge :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkScrolledWindowPlacement :: (IsSettings o) => CornerType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkScrolledWindowPlacement :: IsSettings o => CornerType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkShellShowsAppMenu :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkShellShowsAppMenu :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkShellShowsDesktop :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkShellShowsDesktop :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkShellShowsMenubar :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkShellShowsMenubar :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkShowInputMethodMenu :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkShowInputMethodMenu :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkShowUnicodeMenu :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkShowUnicodeMenu :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkSoundThemeName :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkSoundThemeName :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkSplitCursor :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkSplitCursor :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkThemeName :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkThemeName :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkTimeoutExpand :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkTimeoutExpand :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkTimeoutInitial :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkTimeoutInitial :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkTimeoutRepeat :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkTimeoutRepeat :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkTitlebarDoubleClick :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkTitlebarDoubleClick :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkTitlebarMiddleClick :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkTitlebarMiddleClick :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkTitlebarRightClick :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkTitlebarRightClick :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkToolbarIconSize :: (IsSettings o) => IconSize -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkToolbarIconSize :: IsSettings o => IconSize -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkToolbarStyle :: (IsSettings o) => ToolbarStyle -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkToolbarStyle :: IsSettings o => ToolbarStyle -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkTooltipBrowseModeTimeout :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkTooltipBrowseModeTimeout :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkTooltipBrowseTimeout :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkTooltipBrowseTimeout :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkTooltipTimeout :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkTooltipTimeout :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkTouchscreenMode :: (IsSettings o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkTouchscreenMode :: IsSettings o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkVisibleFocus :: (IsSettings o) => PolicyType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkVisibleFocus :: IsSettings o => PolicyType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkXftAntialias :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkXftAntialias :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkXftDpi :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkXftDpi :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkXftHinting :: (IsSettings o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkXftHinting :: IsSettings o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkXftHintstyle :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkXftHintstyle :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Settings: constructSettingsGtkXftRgba :: (IsSettings o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Settings: constructSettingsGtkXftRgba :: IsSettings o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutLabel: ShortcutLabel :: (ManagedPtr ShortcutLabel) -> ShortcutLabel

+ GI.Gtk.Objects.ShortcutLabel: ShortcutLabel :: ManagedPtr ShortcutLabel -> ShortcutLabel

- GI.Gtk.Objects.ShortcutLabel: constructShortcutLabelAccelerator :: (IsShortcutLabel o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutLabel: constructShortcutLabelAccelerator :: IsShortcutLabel o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutLabel: constructShortcutLabelDisabledText :: (IsShortcutLabel o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutLabel: constructShortcutLabelDisabledText :: IsShortcutLabel o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsGroup: ShortcutsGroup :: (ManagedPtr ShortcutsGroup) -> ShortcutsGroup

+ GI.Gtk.Objects.ShortcutsGroup: ShortcutsGroup :: ManagedPtr ShortcutsGroup -> ShortcutsGroup

- GI.Gtk.Objects.ShortcutsGroup: constructShortcutsGroupTitle :: (IsShortcutsGroup o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsGroup: constructShortcutsGroupTitle :: IsShortcutsGroup o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsGroup: constructShortcutsGroupView :: (IsShortcutsGroup o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsGroup: constructShortcutsGroupView :: IsShortcutsGroup o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsSection: ShortcutsSection :: (ManagedPtr ShortcutsSection) -> ShortcutsSection

+ GI.Gtk.Objects.ShortcutsSection: ShortcutsSection :: ManagedPtr ShortcutsSection -> ShortcutsSection

- GI.Gtk.Objects.ShortcutsSection: constructShortcutsSectionMaxHeight :: (IsShortcutsSection o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsSection: constructShortcutsSectionMaxHeight :: IsShortcutsSection o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsSection: constructShortcutsSectionSectionName :: (IsShortcutsSection o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsSection: constructShortcutsSectionSectionName :: IsShortcutsSection o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsSection: constructShortcutsSectionTitle :: (IsShortcutsSection o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsSection: constructShortcutsSectionTitle :: IsShortcutsSection o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsSection: constructShortcutsSectionViewName :: (IsShortcutsSection o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsSection: constructShortcutsSectionViewName :: IsShortcutsSection o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsShortcut: ShortcutsShortcut :: (ManagedPtr ShortcutsShortcut) -> ShortcutsShortcut

+ GI.Gtk.Objects.ShortcutsShortcut: ShortcutsShortcut :: ManagedPtr ShortcutsShortcut -> ShortcutsShortcut

- GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutAccelerator :: (IsShortcutsShortcut o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutAccelerator :: IsShortcutsShortcut o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutActionName :: (IsShortcutsShortcut o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutActionName :: IsShortcutsShortcut o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutDirection :: (IsShortcutsShortcut o) => TextDirection -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutDirection :: IsShortcutsShortcut o => TextDirection -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutIconSet :: (IsShortcutsShortcut o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutIconSet :: IsShortcutsShortcut o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutShortcutType :: (IsShortcutsShortcut o) => ShortcutType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutShortcutType :: IsShortcutsShortcut o => ShortcutType -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutSubtitle :: (IsShortcutsShortcut o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutSubtitle :: IsShortcutsShortcut o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutSubtitleSet :: (IsShortcutsShortcut o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutSubtitleSet :: IsShortcutsShortcut o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutTitle :: (IsShortcutsShortcut o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsShortcut: constructShortcutsShortcutTitle :: IsShortcutsShortcut o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsWindow: ShortcutsWindow :: (ManagedPtr ShortcutsWindow) -> ShortcutsWindow

+ GI.Gtk.Objects.ShortcutsWindow: ShortcutsWindow :: ManagedPtr ShortcutsWindow -> ShortcutsWindow

- GI.Gtk.Objects.ShortcutsWindow: constructShortcutsWindowSectionName :: (IsShortcutsWindow o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsWindow: constructShortcutsWindowSectionName :: IsShortcutsWindow o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ShortcutsWindow: constructShortcutsWindowViewName :: (IsShortcutsWindow o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ShortcutsWindow: constructShortcutsWindowViewName :: IsShortcutsWindow o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.SizeGroup: SizeGroup :: (ManagedPtr SizeGroup) -> SizeGroup

+ GI.Gtk.Objects.SizeGroup: SizeGroup :: ManagedPtr SizeGroup -> SizeGroup

- GI.Gtk.Objects.SizeGroup: constructSizeGroupIgnoreHidden :: (IsSizeGroup o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.SizeGroup: constructSizeGroupIgnoreHidden :: IsSizeGroup o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.SizeGroup: constructSizeGroupMode :: (IsSizeGroup o) => SizeGroupMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.SizeGroup: constructSizeGroupMode :: IsSizeGroup o => SizeGroupMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.Socket: Socket :: (ManagedPtr Socket) -> Socket

+ GI.Gtk.Objects.Socket: Socket :: ManagedPtr Socket -> Socket

- GI.Gtk.Objects.Socket: type SocketPlugRemovedCallback = IO Bool __Returns:__ 'True' to stop other handlers from being invoked.

+ GI.Gtk.Objects.Socket: type SocketPlugRemovedCallback = IO Bool " __Returns:__ 'True' to stop other handlers from being invoked. "

- GI.Gtk.Objects.SpinButton: SpinButton :: (ManagedPtr SpinButton) -> SpinButton

+ GI.Gtk.Objects.SpinButton: SpinButton :: ManagedPtr SpinButton -> SpinButton

- GI.Gtk.Objects.SpinButton: constructSpinButtonClimbRate :: (IsSpinButton o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.SpinButton: constructSpinButtonClimbRate :: IsSpinButton o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.SpinButton: constructSpinButtonDigits :: (IsSpinButton o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.SpinButton: constructSpinButtonDigits :: IsSpinButton o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.SpinButton: constructSpinButtonNumeric :: (IsSpinButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.SpinButton: constructSpinButtonNumeric :: IsSpinButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.SpinButton: constructSpinButtonSnapToTicks :: (IsSpinButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.SpinButton: constructSpinButtonSnapToTicks :: IsSpinButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.SpinButton: constructSpinButtonUpdatePolicy :: (IsSpinButton o) => SpinButtonUpdatePolicy -> IO (GValueConstruct o)

+ GI.Gtk.Objects.SpinButton: constructSpinButtonUpdatePolicy :: IsSpinButton o => SpinButtonUpdatePolicy -> IO (GValueConstruct o)

- GI.Gtk.Objects.SpinButton: constructSpinButtonValue :: (IsSpinButton o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.SpinButton: constructSpinButtonValue :: IsSpinButton o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.SpinButton: constructSpinButtonWrap :: (IsSpinButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.SpinButton: constructSpinButtonWrap :: IsSpinButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.SpinButton: spinButtonConfigure :: (HasCallStack, MonadIO m, IsSpinButton a, IsAdjustment b) => a -> Maybe (b) -> Double -> Word32 -> m ()

+ GI.Gtk.Objects.SpinButton: spinButtonConfigure :: (HasCallStack, MonadIO m, IsSpinButton a, IsAdjustment b) => a -> Maybe b -> Double -> Word32 -> m ()

- GI.Gtk.Objects.SpinButton: spinButtonGetIncrements :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m ((Double, Double))

+ GI.Gtk.Objects.SpinButton: spinButtonGetIncrements :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m (Double, Double)

- GI.Gtk.Objects.SpinButton: spinButtonGetRange :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m ((Double, Double))

+ GI.Gtk.Objects.SpinButton: spinButtonGetRange :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m (Double, Double)

- GI.Gtk.Objects.SpinButton: spinButtonNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe (a) -> Double -> Word32 -> m SpinButton

+ GI.Gtk.Objects.SpinButton: spinButtonNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe a -> Double -> Word32 -> m SpinButton

- GI.Gtk.Objects.SpinButton: type SpinButtonChangeValueCallback = ScrollType /@scroll@/: a 'GI.Gtk.Enums.ScrollType' to specify the speed and amount of change -> IO ()

+ GI.Gtk.Objects.SpinButton: type SpinButtonChangeValueCallback = ScrollType " /@scroll@/: a 'GI.Gtk.Enums.ScrollType' to specify the speed and amount of change " -> IO ()

- GI.Gtk.Objects.SpinButton: type SpinButtonInputCallback = IO ((Int32, Double)) __Returns:__ 'True' for a successful conversion, 'False' if the input was not handled, and 'GI.Gtk.Constants.INPUT_ERROR' if the conversion failed.

+ GI.Gtk.Objects.SpinButton: type SpinButtonInputCallback = IO ((Int32, Double)) " __Returns:__ 'True' for a successful conversion, 'False' if the input was not handled, and 'GI.Gtk.Constants.INPUT_ERROR' if the conversion failed. "

- GI.Gtk.Objects.SpinButton: type SpinButtonOutputCallback = IO Bool __Returns:__ 'True' if the value has been displayed

+ GI.Gtk.Objects.SpinButton: type SpinButtonOutputCallback = IO Bool " __Returns:__ 'True' if the value has been displayed "

- GI.Gtk.Objects.SpinButtonAccessible: SpinButtonAccessible :: (ManagedPtr SpinButtonAccessible) -> SpinButtonAccessible

+ GI.Gtk.Objects.SpinButtonAccessible: SpinButtonAccessible :: ManagedPtr SpinButtonAccessible -> SpinButtonAccessible

- GI.Gtk.Objects.Spinner: Spinner :: (ManagedPtr Spinner) -> Spinner

+ GI.Gtk.Objects.Spinner: Spinner :: ManagedPtr Spinner -> Spinner

- GI.Gtk.Objects.Spinner: constructSpinnerActive :: (IsSpinner o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Spinner: constructSpinnerActive :: IsSpinner o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.SpinnerAccessible: SpinnerAccessible :: (ManagedPtr SpinnerAccessible) -> SpinnerAccessible

+ GI.Gtk.Objects.SpinnerAccessible: SpinnerAccessible :: ManagedPtr SpinnerAccessible -> SpinnerAccessible

- GI.Gtk.Objects.Stack: Stack :: (ManagedPtr Stack) -> Stack

+ GI.Gtk.Objects.Stack: Stack :: ManagedPtr Stack -> Stack

- GI.Gtk.Objects.Stack: constructStackHhomogeneous :: (IsStack o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Stack: constructStackHhomogeneous :: IsStack o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Stack: constructStackHomogeneous :: (IsStack o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Stack: constructStackHomogeneous :: IsStack o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Stack: constructStackInterpolateSize :: (IsStack o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Stack: constructStackInterpolateSize :: IsStack o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Stack: constructStackTransitionDuration :: (IsStack o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Stack: constructStackTransitionDuration :: IsStack o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Stack: constructStackTransitionType :: (IsStack o) => StackTransitionType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Stack: constructStackTransitionType :: IsStack o => StackTransitionType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Stack: constructStackVhomogeneous :: (IsStack o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Stack: constructStackVhomogeneous :: IsStack o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Stack: constructStackVisibleChildName :: (IsStack o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Stack: constructStackVisibleChildName :: IsStack o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.StackAccessible: StackAccessible :: (ManagedPtr StackAccessible) -> StackAccessible

+ GI.Gtk.Objects.StackAccessible: StackAccessible :: ManagedPtr StackAccessible -> StackAccessible

- GI.Gtk.Objects.StackSidebar: StackSidebar :: (ManagedPtr StackSidebar) -> StackSidebar

+ GI.Gtk.Objects.StackSidebar: StackSidebar :: ManagedPtr StackSidebar -> StackSidebar

- GI.Gtk.Objects.StackSwitcher: StackSwitcher :: (ManagedPtr StackSwitcher) -> StackSwitcher

+ GI.Gtk.Objects.StackSwitcher: StackSwitcher :: ManagedPtr StackSwitcher -> StackSwitcher

- GI.Gtk.Objects.StackSwitcher: constructStackSwitcherIconSize :: (IsStackSwitcher o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.StackSwitcher: constructStackSwitcherIconSize :: IsStackSwitcher o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.StackSwitcher: stackSwitcherSetStack :: (HasCallStack, MonadIO m, IsStackSwitcher a, IsStack b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.StackSwitcher: stackSwitcherSetStack :: (HasCallStack, MonadIO m, IsStackSwitcher a, IsStack b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.StatusIcon: StatusIcon :: (ManagedPtr StatusIcon) -> StatusIcon

+ GI.Gtk.Objects.StatusIcon: StatusIcon :: ManagedPtr StatusIcon -> StatusIcon

- GI.Gtk.Objects.StatusIcon: constructStatusIconFile :: (IsStatusIcon o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.StatusIcon: constructStatusIconFile :: IsStatusIcon o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.StatusIcon: constructStatusIconHasTooltip :: (IsStatusIcon o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.StatusIcon: constructStatusIconHasTooltip :: IsStatusIcon o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.StatusIcon: constructStatusIconIconName :: (IsStatusIcon o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.StatusIcon: constructStatusIconIconName :: IsStatusIcon o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.StatusIcon: constructStatusIconStock :: (IsStatusIcon o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.StatusIcon: constructStatusIconStock :: IsStatusIcon o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.StatusIcon: constructStatusIconTitle :: (IsStatusIcon o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.StatusIcon: constructStatusIconTitle :: IsStatusIcon o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.StatusIcon: constructStatusIconTooltipMarkup :: (IsStatusIcon o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.StatusIcon: constructStatusIconTooltipMarkup :: IsStatusIcon o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.StatusIcon: constructStatusIconTooltipText :: (IsStatusIcon o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.StatusIcon: constructStatusIconTooltipText :: IsStatusIcon o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.StatusIcon: constructStatusIconVisible :: (IsStatusIcon o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.StatusIcon: constructStatusIconVisible :: IsStatusIcon o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.StatusIcon: statusIconGetGeometry :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m ((Bool, Screen, Rectangle, Orientation))

+ GI.Gtk.Objects.StatusIcon: statusIconGetGeometry :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m (Bool, Screen, Rectangle, Orientation)

- GI.Gtk.Objects.StatusIcon: statusIconPositionMenu :: (HasCallStack, MonadIO m, IsMenu a, IsStatusIcon b) => a -> Int32 -> Int32 -> b -> m ((Int32, Int32, Bool))

+ GI.Gtk.Objects.StatusIcon: statusIconPositionMenu :: (HasCallStack, MonadIO m, IsMenu a, IsStatusIcon b) => a -> Int32 -> Int32 -> b -> m (Int32, Int32, Bool)

- GI.Gtk.Objects.StatusIcon: statusIconSetFromPixbuf :: (HasCallStack, MonadIO m, IsStatusIcon a, IsPixbuf b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.StatusIcon: statusIconSetFromPixbuf :: (HasCallStack, MonadIO m, IsStatusIcon a, IsPixbuf b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.StatusIcon: statusIconSetTooltipMarkup :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.StatusIcon: statusIconSetTooltipMarkup :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.StatusIcon: type StatusIconButtonPressEventCallback = EventButton /@event@/: the 'GI.Gdk.Structs.EventButton.EventButton' which triggered this signal -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.StatusIcon: type StatusIconButtonPressEventCallback = EventButton " /@event@/: the 'GI.Gdk.Structs.EventButton.EventButton' which triggered this signal " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.StatusIcon: type StatusIconButtonReleaseEventCallback = EventButton /@event@/: the 'GI.Gdk.Structs.EventButton.EventButton' which triggered this signal -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.StatusIcon: type StatusIconButtonReleaseEventCallback = EventButton " /@event@/: the 'GI.Gdk.Structs.EventButton.EventButton' which triggered this signal " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.StatusIcon: type StatusIconPopupMenuCallback = Word32 /@button@/: the button that was pressed, or 0 if the signal is not emitted in response to a button press event -> Word32 /@activateTime@/: the timestamp of the event that triggered the signal emission -> IO ()

+ GI.Gtk.Objects.StatusIcon: type StatusIconPopupMenuCallback = Word32 " /@button@/: the button that was pressed, or 0 if the signal is not emitted in response to a button press event " -> Word32 " /@activateTime@/: the timestamp of the event that triggered the signal emission " -> IO ()

- GI.Gtk.Objects.StatusIcon: type StatusIconQueryTooltipCallback = Int32 /@x@/: the x coordinate of the cursor position where the request has been emitted, relative to /@statusIcon@/ -> Int32 /@y@/: the y coordinate of the cursor position where the request has been emitted, relative to /@statusIcon@/ -> Bool /@keyboardMode@/: 'True' if the tooltip was trigged using the keyboard -> Tooltip /@tooltip@/: a 'GI.Gtk.Objects.Tooltip.Tooltip' -> IO Bool __Returns:__ 'True' if /@tooltip@/ should be shown right now, 'False' otherwise.

+ GI.Gtk.Objects.StatusIcon: type StatusIconQueryTooltipCallback = Int32 " /@x@/: the x coordinate of the cursor position where the request has been emitted, relative to /@statusIcon@/ " -> Int32 " /@y@/: the y coordinate of the cursor position where the request has been emitted, relative to /@statusIcon@/ " -> Bool " /@keyboardMode@/: 'True' if the tooltip was trigged using the keyboard " -> Tooltip " /@tooltip@/: a 'GI.Gtk.Objects.Tooltip.Tooltip' " -> IO Bool " __Returns:__ 'True' if /@tooltip@/ should be shown right now, 'False' otherwise. "

- GI.Gtk.Objects.StatusIcon: type StatusIconScrollEventCallback = EventScroll /@event@/: the 'GI.Gdk.Structs.EventScroll.EventScroll' which triggered this signal -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.StatusIcon: type StatusIconScrollEventCallback = EventScroll " /@event@/: the 'GI.Gdk.Structs.EventScroll.EventScroll' which triggered this signal " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.StatusIcon: type StatusIconSizeChangedCallback = Int32 /@size@/: the new size -> IO Bool __Returns:__ 'True' if the icon was updated for the new size. Otherwise, GTK+ will scale the icon as necessary.

+ GI.Gtk.Objects.StatusIcon: type StatusIconSizeChangedCallback = Int32 " /@size@/: the new size " -> IO Bool " __Returns:__ 'True' if the icon was updated for the new size. Otherwise, GTK+ will scale the icon as necessary. "

- GI.Gtk.Objects.Statusbar: Statusbar :: (ManagedPtr Statusbar) -> Statusbar

+ GI.Gtk.Objects.Statusbar: Statusbar :: ManagedPtr Statusbar -> Statusbar

- GI.Gtk.Objects.Statusbar: type StatusbarTextPoppedCallback = Word32 /@contextId@/: the context id of the relevant message\/statusbar -> Text /@text@/: the message that was just popped -> IO ()

+ GI.Gtk.Objects.Statusbar: type StatusbarTextPoppedCallback = Word32 " /@contextId@/: the context id of the relevant message\/statusbar " -> Text " /@text@/: the message that was just popped " -> IO ()

- GI.Gtk.Objects.Statusbar: type StatusbarTextPushedCallback = Word32 /@contextId@/: the context id of the relevant message\/statusbar -> Text /@text@/: the message that was pushed -> IO ()

+ GI.Gtk.Objects.Statusbar: type StatusbarTextPushedCallback = Word32 " /@contextId@/: the context id of the relevant message\/statusbar " -> Text " /@text@/: the message that was pushed " -> IO ()

- GI.Gtk.Objects.StatusbarAccessible: StatusbarAccessible :: (ManagedPtr StatusbarAccessible) -> StatusbarAccessible

+ GI.Gtk.Objects.StatusbarAccessible: StatusbarAccessible :: ManagedPtr StatusbarAccessible -> StatusbarAccessible

- GI.Gtk.Objects.Style: Style :: (ManagedPtr Style) -> Style

+ GI.Gtk.Objects.Style: Style :: ManagedPtr Style -> Style

- GI.Gtk.Objects.Style: styleGetStyleProperty :: (HasCallStack, MonadIO m, IsStyle a) => a -> GType -> Text -> m (GValue)

+ GI.Gtk.Objects.Style: styleGetStyleProperty :: (HasCallStack, MonadIO m, IsStyle a) => a -> GType -> Text -> m GValue

- GI.Gtk.Objects.Style: styleLookupColor :: (HasCallStack, MonadIO m, IsStyle a) => a -> Text -> m ((Bool, Color))

+ GI.Gtk.Objects.Style: styleLookupColor :: (HasCallStack, MonadIO m, IsStyle a) => a -> Text -> m (Bool, Color)

- GI.Gtk.Objects.Style: styleRenderIcon :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> IconSource -> TextDirection -> StateType -> Int32 -> Maybe (b) -> Maybe (Text) -> m Pixbuf

+ GI.Gtk.Objects.Style: styleRenderIcon :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> IconSource -> TextDirection -> StateType -> Int32 -> Maybe b -> Maybe Text -> m Pixbuf

- GI.Gtk.Objects.StyleContext: StyleContext :: (ManagedPtr StyleContext) -> StyleContext

+ GI.Gtk.Objects.StyleContext: StyleContext :: ManagedPtr StyleContext -> StyleContext

- GI.Gtk.Objects.StyleContext: constructStyleContextDirection :: (IsStyleContext o) => TextDirection -> IO (GValueConstruct o)

+ GI.Gtk.Objects.StyleContext: constructStyleContextDirection :: IsStyleContext o => TextDirection -> IO (GValueConstruct o)

- GI.Gtk.Objects.StyleContext: styleContextGetBackgroundColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m (RGBA)

+ GI.Gtk.Objects.StyleContext: styleContextGetBackgroundColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m RGBA

- GI.Gtk.Objects.StyleContext: styleContextGetBorder :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m (Border)

+ GI.Gtk.Objects.StyleContext: styleContextGetBorder :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m Border

- GI.Gtk.Objects.StyleContext: styleContextGetBorderColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m (RGBA)

+ GI.Gtk.Objects.StyleContext: styleContextGetBorderColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m RGBA

- GI.Gtk.Objects.StyleContext: styleContextGetColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m (RGBA)

+ GI.Gtk.Objects.StyleContext: styleContextGetColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m RGBA

- GI.Gtk.Objects.StyleContext: styleContextGetMargin :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m (Border)

+ GI.Gtk.Objects.StyleContext: styleContextGetMargin :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m Border

- GI.Gtk.Objects.StyleContext: styleContextGetPadding :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m (Border)

+ GI.Gtk.Objects.StyleContext: styleContextGetPadding :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m Border

- GI.Gtk.Objects.StyleContext: styleContextGetProperty :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> [StateFlags] -> m (GValue)

+ GI.Gtk.Objects.StyleContext: styleContextGetProperty :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> [StateFlags] -> m GValue

- GI.Gtk.Objects.StyleContext: styleContextHasRegion :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m ((Bool, [RegionFlags]))

+ GI.Gtk.Objects.StyleContext: styleContextHasRegion :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m (Bool, [RegionFlags])

- GI.Gtk.Objects.StyleContext: styleContextLookupColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m ((Bool, RGBA))

+ GI.Gtk.Objects.StyleContext: styleContextLookupColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m (Bool, RGBA)

- GI.Gtk.Objects.StyleContext: styleContextSetParent :: (HasCallStack, MonadIO m, IsStyleContext a, IsStyleContext b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.StyleContext: styleContextSetParent :: (HasCallStack, MonadIO m, IsStyleContext a, IsStyleContext b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.StyleContext: styleContextStateIsRunning :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> StateType -> m ((Bool, Double))

+ GI.Gtk.Objects.StyleContext: styleContextStateIsRunning :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> StateType -> m (Bool, Double)

- GI.Gtk.Objects.StyleProperties: StyleProperties :: (ManagedPtr StyleProperties) -> StyleProperties

+ GI.Gtk.Objects.StyleProperties: StyleProperties :: ManagedPtr StyleProperties -> StyleProperties

- GI.Gtk.Objects.StyleProperties: stylePropertiesGetProperty :: (HasCallStack, MonadIO m, IsStyleProperties a) => a -> Text -> [StateFlags] -> m ((Bool, GValue))

+ GI.Gtk.Objects.StyleProperties: stylePropertiesGetProperty :: (HasCallStack, MonadIO m, IsStyleProperties a) => a -> Text -> [StateFlags] -> m (Bool, GValue)

- GI.Gtk.Objects.Switch: Switch :: (ManagedPtr Switch) -> Switch

+ GI.Gtk.Objects.Switch: Switch :: ManagedPtr Switch -> Switch

- GI.Gtk.Objects.Switch: constructSwitchActive :: (IsSwitch o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Switch: constructSwitchActive :: IsSwitch o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Switch: constructSwitchState :: (IsSwitch o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Switch: constructSwitchState :: IsSwitch o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Switch: type SwitchStateSetCallback = Bool /@state@/: the new state of the switch -> IO Bool __Returns:__ 'True' to stop the signal emission

+ GI.Gtk.Objects.Switch: type SwitchStateSetCallback = Bool " /@state@/: the new state of the switch " -> IO Bool " __Returns:__ 'True' to stop the signal emission "

- GI.Gtk.Objects.SwitchAccessible: SwitchAccessible :: (ManagedPtr SwitchAccessible) -> SwitchAccessible

+ GI.Gtk.Objects.SwitchAccessible: SwitchAccessible :: ManagedPtr SwitchAccessible -> SwitchAccessible

- GI.Gtk.Objects.Table: Table :: (ManagedPtr Table) -> Table

+ GI.Gtk.Objects.Table: Table :: ManagedPtr Table -> Table

- GI.Gtk.Objects.Table: constructTableColumnSpacing :: (IsTable o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Table: constructTableColumnSpacing :: IsTable o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Table: constructTableHomogeneous :: (IsTable o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Table: constructTableHomogeneous :: IsTable o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Table: constructTableNColumns :: (IsTable o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Table: constructTableNColumns :: IsTable o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Table: constructTableNRows :: (IsTable o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Table: constructTableNRows :: IsTable o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Table: constructTableRowSpacing :: (IsTable o) => Word32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Table: constructTableRowSpacing :: IsTable o => Word32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Table: tableGetSize :: (HasCallStack, MonadIO m, IsTable a) => a -> m ((Word32, Word32))

+ GI.Gtk.Objects.Table: tableGetSize :: (HasCallStack, MonadIO m, IsTable a) => a -> m (Word32, Word32)

- GI.Gtk.Objects.TearoffMenuItem: TearoffMenuItem :: (ManagedPtr TearoffMenuItem) -> TearoffMenuItem

+ GI.Gtk.Objects.TearoffMenuItem: TearoffMenuItem :: ManagedPtr TearoffMenuItem -> TearoffMenuItem

- GI.Gtk.Objects.TextBuffer: TextBuffer :: (ManagedPtr TextBuffer) -> TextBuffer

+ GI.Gtk.Objects.TextBuffer: TextBuffer :: ManagedPtr TextBuffer -> TextBuffer

- GI.Gtk.Objects.TextBuffer: constructTextBufferText :: (IsTextBuffer o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextBuffer: constructTextBufferText :: IsTextBuffer o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextBuffer: textBufferCreateMark :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Maybe (Text) -> TextIter -> Bool -> m TextMark

+ GI.Gtk.Objects.TextBuffer: textBufferCreateMark :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Maybe Text -> TextIter -> Bool -> m TextMark

- GI.Gtk.Objects.TextBuffer: textBufferGetBounds :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m ((TextIter, TextIter))

+ GI.Gtk.Objects.TextBuffer: textBufferGetBounds :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m (TextIter, TextIter)

- GI.Gtk.Objects.TextBuffer: textBufferGetEndIter :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m (TextIter)

+ GI.Gtk.Objects.TextBuffer: textBufferGetEndIter :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextIter

- GI.Gtk.Objects.TextBuffer: textBufferGetIterAtChildAnchor :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextChildAnchor b) => a -> b -> m (TextIter)

+ GI.Gtk.Objects.TextBuffer: textBufferGetIterAtChildAnchor :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextChildAnchor b) => a -> b -> m TextIter

- GI.Gtk.Objects.TextBuffer: textBufferGetIterAtLine :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> m (TextIter)

+ GI.Gtk.Objects.TextBuffer: textBufferGetIterAtLine :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> m TextIter

- GI.Gtk.Objects.TextBuffer: textBufferGetIterAtLineIndex :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> Int32 -> m (TextIter)

+ GI.Gtk.Objects.TextBuffer: textBufferGetIterAtLineIndex :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> Int32 -> m TextIter

- GI.Gtk.Objects.TextBuffer: textBufferGetIterAtLineOffset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> Int32 -> m (TextIter)

+ GI.Gtk.Objects.TextBuffer: textBufferGetIterAtLineOffset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> Int32 -> m TextIter

- GI.Gtk.Objects.TextBuffer: textBufferGetIterAtMark :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextMark b) => a -> b -> m (TextIter)

+ GI.Gtk.Objects.TextBuffer: textBufferGetIterAtMark :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextMark b) => a -> b -> m TextIter

- GI.Gtk.Objects.TextBuffer: textBufferGetIterAtOffset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> m (TextIter)

+ GI.Gtk.Objects.TextBuffer: textBufferGetIterAtOffset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> m TextIter

- GI.Gtk.Objects.TextBuffer: textBufferGetSelectionBounds :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m ((Bool, TextIter, TextIter))

+ GI.Gtk.Objects.TextBuffer: textBufferGetSelectionBounds :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m (Bool, TextIter, TextIter)

- GI.Gtk.Objects.TextBuffer: textBufferGetStartIter :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m (TextIter)

+ GI.Gtk.Objects.TextBuffer: textBufferGetStartIter :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextIter

- GI.Gtk.Objects.TextBuffer: textBufferNew :: (HasCallStack, MonadIO m, IsTextTagTable a) => Maybe (a) -> m TextBuffer

+ GI.Gtk.Objects.TextBuffer: textBufferNew :: (HasCallStack, MonadIO m, IsTextTagTable a) => Maybe a -> m TextBuffer

- GI.Gtk.Objects.TextBuffer: textBufferPasteClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> Maybe (TextIter) -> Bool -> m ()

+ GI.Gtk.Objects.TextBuffer: textBufferPasteClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> Maybe TextIter -> Bool -> m ()

- GI.Gtk.Objects.TextBuffer: textBufferRegisterDeserializeTagset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Maybe (Text) -> m Atom

+ GI.Gtk.Objects.TextBuffer: textBufferRegisterDeserializeTagset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Maybe Text -> m Atom

- GI.Gtk.Objects.TextBuffer: textBufferRegisterSerializeTagset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Maybe (Text) -> m Atom

+ GI.Gtk.Objects.TextBuffer: textBufferRegisterSerializeTagset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Maybe Text -> m Atom

- GI.Gtk.Objects.TextBuffer: type TextBufferApplyTagCallback = TextTag /@tag@/: the applied tag -> TextIter /@start@/: the start of the range the tag is applied to -> TextIter /@end@/: the end of the range the tag is applied to -> IO ()

+ GI.Gtk.Objects.TextBuffer: type TextBufferApplyTagCallback = TextTag " /@tag@/: the applied tag " -> TextIter " /@start@/: the start of the range the tag is applied to " -> TextIter " /@end@/: the end of the range the tag is applied to " -> IO ()

- GI.Gtk.Objects.TextBuffer: type TextBufferDeleteRangeCallback = TextIter /@start@/: the start of the range to be deleted -> TextIter /@end@/: the end of the range to be deleted -> IO ()

+ GI.Gtk.Objects.TextBuffer: type TextBufferDeleteRangeCallback = TextIter " /@start@/: the start of the range to be deleted " -> TextIter " /@end@/: the end of the range to be deleted " -> IO ()

- GI.Gtk.Objects.TextBuffer: type TextBufferInsertChildAnchorCallback = TextIter /@location@/: position to insert /@anchor@/ in /@textbuffer@/ -> TextChildAnchor /@anchor@/: the 'GI.Gtk.Objects.TextChildAnchor.TextChildAnchor' to be inserted -> IO ()

+ GI.Gtk.Objects.TextBuffer: type TextBufferInsertChildAnchorCallback = TextIter " /@location@/: position to insert /@anchor@/ in /@textbuffer@/ " -> TextChildAnchor " /@anchor@/: the 'GI.Gtk.Objects.TextChildAnchor.TextChildAnchor' to be inserted " -> IO ()

- GI.Gtk.Objects.TextBuffer: type TextBufferInsertPixbufCallback = TextIter /@location@/: position to insert /@pixbuf@/ in /@textbuffer@/ -> Pixbuf /@pixbuf@/: the 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' to be inserted -> IO ()

+ GI.Gtk.Objects.TextBuffer: type TextBufferInsertPixbufCallback = TextIter " /@location@/: position to insert /@pixbuf@/ in /@textbuffer@/ " -> Pixbuf " /@pixbuf@/: the 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' to be inserted " -> IO ()

- GI.Gtk.Objects.TextBuffer: type TextBufferInsertTextCallback = TextIter /@location@/: position to insert /@text@/ in /@textbuffer@/ -> Text /@text@/: the UTF-8 text to be inserted -> Int32 /@len@/: length of the inserted text in bytes -> IO ()

+ GI.Gtk.Objects.TextBuffer: type TextBufferInsertTextCallback = TextIter " /@location@/: position to insert /@text@/ in /@textbuffer@/ " -> Text " /@text@/: the UTF-8 text to be inserted " -> Int32 " /@len@/: length of the inserted text in bytes " -> IO ()

- GI.Gtk.Objects.TextBuffer: type TextBufferMarkDeletedCallback = TextMark /@mark@/: The mark that was deleted -> IO ()

+ GI.Gtk.Objects.TextBuffer: type TextBufferMarkDeletedCallback = TextMark " /@mark@/: The mark that was deleted " -> IO ()

- GI.Gtk.Objects.TextBuffer: type TextBufferMarkSetCallback = TextIter /@location@/: The location of /@mark@/ in /@textbuffer@/ -> TextMark /@mark@/: The mark that is set -> IO ()

+ GI.Gtk.Objects.TextBuffer: type TextBufferMarkSetCallback = TextIter " /@location@/: The location of /@mark@/ in /@textbuffer@/ " -> TextMark " /@mark@/: The mark that is set " -> IO ()

- GI.Gtk.Objects.TextBuffer: type TextBufferPasteDoneCallback = Clipboard /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' pasted from -> IO ()

+ GI.Gtk.Objects.TextBuffer: type TextBufferPasteDoneCallback = Clipboard " /@clipboard@/: the 'GI.Gtk.Objects.Clipboard.Clipboard' pasted from " -> IO ()

- GI.Gtk.Objects.TextBuffer: type TextBufferRemoveTagCallback = TextTag /@tag@/: the tag to be removed -> TextIter /@start@/: the start of the range the tag is removed from -> TextIter /@end@/: the end of the range the tag is removed from -> IO ()

+ GI.Gtk.Objects.TextBuffer: type TextBufferRemoveTagCallback = TextTag " /@tag@/: the tag to be removed " -> TextIter " /@start@/: the start of the range the tag is removed from " -> TextIter " /@end@/: the end of the range the tag is removed from " -> IO ()

- GI.Gtk.Objects.TextCellAccessible: TextCellAccessible :: (ManagedPtr TextCellAccessible) -> TextCellAccessible

+ GI.Gtk.Objects.TextCellAccessible: TextCellAccessible :: ManagedPtr TextCellAccessible -> TextCellAccessible

- GI.Gtk.Objects.TextChildAnchor: TextChildAnchor :: (ManagedPtr TextChildAnchor) -> TextChildAnchor

+ GI.Gtk.Objects.TextChildAnchor: TextChildAnchor :: ManagedPtr TextChildAnchor -> TextChildAnchor

- GI.Gtk.Objects.TextMark: TextMark :: (ManagedPtr TextMark) -> TextMark

+ GI.Gtk.Objects.TextMark: TextMark :: ManagedPtr TextMark -> TextMark

- GI.Gtk.Objects.TextMark: constructTextMarkLeftGravity :: (IsTextMark o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextMark: constructTextMarkLeftGravity :: IsTextMark o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextMark: constructTextMarkName :: (IsTextMark o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextMark: constructTextMarkName :: IsTextMark o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextMark: textMarkNew :: (HasCallStack, MonadIO m) => Maybe (Text) -> Bool -> m TextMark

+ GI.Gtk.Objects.TextMark: textMarkNew :: (HasCallStack, MonadIO m) => Maybe Text -> Bool -> m TextMark

- GI.Gtk.Objects.TextTag: TextTag :: (ManagedPtr TextTag) -> TextTag

+ GI.Gtk.Objects.TextTag: TextTag :: ManagedPtr TextTag -> TextTag

- GI.Gtk.Objects.TextTag: constructTextTagAccumulativeMargin :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagAccumulativeMargin :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagBackground :: (IsTextTag o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagBackground :: IsTextTag o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagBackgroundFullHeight :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagBackgroundFullHeight :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagBackgroundFullHeightSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagBackgroundFullHeightSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagBackgroundGdk :: (IsTextTag o) => Color -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagBackgroundGdk :: IsTextTag o => Color -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagBackgroundRgba :: (IsTextTag o) => RGBA -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagBackgroundRgba :: IsTextTag o => RGBA -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagBackgroundSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagBackgroundSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagDirection :: (IsTextTag o) => TextDirection -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagDirection :: IsTextTag o => TextDirection -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagEditable :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagEditable :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagEditableSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagEditableSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagFallback :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagFallback :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagFallbackSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagFallbackSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagFamily :: (IsTextTag o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagFamily :: IsTextTag o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagFamilySet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagFamilySet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagFont :: (IsTextTag o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagFont :: IsTextTag o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagFontDesc :: (IsTextTag o) => FontDescription -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagFontDesc :: IsTextTag o => FontDescription -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagFontFeatures :: (IsTextTag o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagFontFeatures :: IsTextTag o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagFontFeaturesSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagFontFeaturesSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagForeground :: (IsTextTag o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagForeground :: IsTextTag o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagForegroundGdk :: (IsTextTag o) => Color -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagForegroundGdk :: IsTextTag o => Color -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagForegroundRgba :: (IsTextTag o) => RGBA -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagForegroundRgba :: IsTextTag o => RGBA -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagForegroundSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagForegroundSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagIndent :: (IsTextTag o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagIndent :: IsTextTag o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagIndentSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagIndentSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagInvisible :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagInvisible :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagInvisibleSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagInvisibleSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagJustification :: (IsTextTag o) => Justification -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagJustification :: IsTextTag o => Justification -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagJustificationSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagJustificationSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagLanguage :: (IsTextTag o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagLanguage :: IsTextTag o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagLanguageSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagLanguageSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagLeftMargin :: (IsTextTag o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagLeftMargin :: IsTextTag o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagLeftMarginSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagLeftMarginSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagLetterSpacing :: (IsTextTag o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagLetterSpacing :: IsTextTag o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagLetterSpacingSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagLetterSpacingSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagName :: (IsTextTag o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagName :: IsTextTag o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagParagraphBackground :: (IsTextTag o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagParagraphBackground :: IsTextTag o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagParagraphBackgroundGdk :: (IsTextTag o) => Color -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagParagraphBackgroundGdk :: IsTextTag o => Color -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagParagraphBackgroundRgba :: (IsTextTag o) => RGBA -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagParagraphBackgroundRgba :: IsTextTag o => RGBA -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagParagraphBackgroundSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagParagraphBackgroundSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagPixelsAboveLines :: (IsTextTag o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagPixelsAboveLines :: IsTextTag o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagPixelsAboveLinesSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagPixelsAboveLinesSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagPixelsBelowLines :: (IsTextTag o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagPixelsBelowLines :: IsTextTag o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagPixelsBelowLinesSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagPixelsBelowLinesSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagPixelsInsideWrap :: (IsTextTag o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagPixelsInsideWrap :: IsTextTag o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagPixelsInsideWrapSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagPixelsInsideWrapSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagRightMargin :: (IsTextTag o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagRightMargin :: IsTextTag o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagRightMarginSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagRightMarginSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagRise :: (IsTextTag o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagRise :: IsTextTag o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagRiseSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagRiseSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagScale :: (IsTextTag o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagScale :: IsTextTag o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagScaleSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagScaleSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagSize :: (IsTextTag o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagSize :: IsTextTag o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagSizePoints :: (IsTextTag o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagSizePoints :: IsTextTag o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagSizeSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagSizeSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagStretch :: (IsTextTag o) => Stretch -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagStretch :: IsTextTag o => Stretch -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagStretchSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagStretchSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagStrikethrough :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagStrikethrough :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagStrikethroughRgba :: (IsTextTag o) => RGBA -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagStrikethroughRgba :: IsTextTag o => RGBA -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagStrikethroughRgbaSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagStrikethroughRgbaSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagStrikethroughSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagStrikethroughSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagStyle :: (IsTextTag o) => Style -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagStyle :: IsTextTag o => Style -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagStyleSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagStyleSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagTabs :: (IsTextTag o) => TabArray -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagTabs :: IsTextTag o => TabArray -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagTabsSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagTabsSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagUnderline :: (IsTextTag o) => Underline -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagUnderline :: IsTextTag o => Underline -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagUnderlineRgba :: (IsTextTag o) => RGBA -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagUnderlineRgba :: IsTextTag o => RGBA -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagUnderlineRgbaSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagUnderlineRgbaSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagUnderlineSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagUnderlineSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagVariant :: (IsTextTag o) => Variant -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagVariant :: IsTextTag o => Variant -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagVariantSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagVariantSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagWeight :: (IsTextTag o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagWeight :: IsTextTag o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagWeightSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagWeightSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagWrapMode :: (IsTextTag o) => WrapMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagWrapMode :: IsTextTag o => WrapMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: constructTextTagWrapModeSet :: (IsTextTag o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextTag: constructTextTagWrapModeSet :: IsTextTag o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextTag: textTagNew :: (HasCallStack, MonadIO m) => Maybe (Text) -> m TextTag

+ GI.Gtk.Objects.TextTag: textTagNew :: (HasCallStack, MonadIO m) => Maybe Text -> m TextTag

- GI.Gtk.Objects.TextTag: type TextTagEventCallback = Object /@object@/: the object the event was fired from (typically a 'GI.Gtk.Objects.TextView.TextView') -> Event /@event@/: the event which triggered the signal -> TextIter /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter' pointing at the location the event occurred -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.TextTag: type TextTagEventCallback = Object " /@object@/: the object the event was fired from (typically a 'GI.Gtk.Objects.TextView.TextView') " -> Event " /@event@/: the event which triggered the signal " -> TextIter " /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter' pointing at the location the event occurred " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.TextTagTable: TextTagTable :: (ManagedPtr TextTagTable) -> TextTagTable

+ GI.Gtk.Objects.TextTagTable: TextTagTable :: ManagedPtr TextTagTable -> TextTagTable

- GI.Gtk.Objects.TextTagTable: type TextTagTableTagAddedCallback = TextTag /@tag@/: the added tag. -> IO ()

+ GI.Gtk.Objects.TextTagTable: type TextTagTableTagAddedCallback = TextTag " /@tag@/: the added tag. " -> IO ()

- GI.Gtk.Objects.TextTagTable: type TextTagTableTagChangedCallback = TextTag /@tag@/: the changed tag. -> Bool /@sizeChanged@/: whether the change affects the 'GI.Gtk.Objects.TextView.TextView' layout. -> IO ()

+ GI.Gtk.Objects.TextTagTable: type TextTagTableTagChangedCallback = TextTag " /@tag@/: the changed tag. " -> Bool " /@sizeChanged@/: whether the change affects the 'GI.Gtk.Objects.TextView.TextView' layout. " -> IO ()

- GI.Gtk.Objects.TextTagTable: type TextTagTableTagRemovedCallback = TextTag /@tag@/: the removed tag. -> IO ()

+ GI.Gtk.Objects.TextTagTable: type TextTagTableTagRemovedCallback = TextTag " /@tag@/: the removed tag. " -> IO ()

- GI.Gtk.Objects.TextView: TextView :: (ManagedPtr TextView) -> TextView

+ GI.Gtk.Objects.TextView: TextView :: ManagedPtr TextView -> TextView

- GI.Gtk.Objects.TextView: constructTextViewAcceptsTab :: (IsTextView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewAcceptsTab :: IsTextView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewBottomMargin :: (IsTextView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewBottomMargin :: IsTextView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewCursorVisible :: (IsTextView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewCursorVisible :: IsTextView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewEditable :: (IsTextView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewEditable :: IsTextView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewImModule :: (IsTextView o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewImModule :: IsTextView o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewIndent :: (IsTextView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewIndent :: IsTextView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewInputHints :: (IsTextView o) => [InputHints] -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewInputHints :: IsTextView o => [InputHints] -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewInputPurpose :: (IsTextView o) => InputPurpose -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewInputPurpose :: IsTextView o => InputPurpose -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewJustification :: (IsTextView o) => Justification -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewJustification :: IsTextView o => Justification -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewLeftMargin :: (IsTextView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewLeftMargin :: IsTextView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewMonospace :: (IsTextView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewMonospace :: IsTextView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewOverwrite :: (IsTextView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewOverwrite :: IsTextView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewPixelsAboveLines :: (IsTextView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewPixelsAboveLines :: IsTextView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewPixelsBelowLines :: (IsTextView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewPixelsBelowLines :: IsTextView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewPixelsInsideWrap :: (IsTextView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewPixelsInsideWrap :: IsTextView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewPopulateAll :: (IsTextView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewPopulateAll :: IsTextView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewRightMargin :: (IsTextView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewRightMargin :: IsTextView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewTabs :: (IsTextView o) => TabArray -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewTabs :: IsTextView o => TabArray -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewTopMargin :: (IsTextView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewTopMargin :: IsTextView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: constructTextViewWrapMode :: (IsTextView o) => WrapMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TextView: constructTextViewWrapMode :: IsTextView o => WrapMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.TextView: textViewBufferToWindowCoords :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> Int32 -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.TextView: textViewBufferToWindowCoords :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> Int32 -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.TextView: textViewGetCursorLocations :: (HasCallStack, MonadIO m, IsTextView a) => a -> Maybe (TextIter) -> m ((Rectangle, Rectangle))

+ GI.Gtk.Objects.TextView: textViewGetCursorLocations :: (HasCallStack, MonadIO m, IsTextView a) => a -> Maybe TextIter -> m (Rectangle, Rectangle)

- GI.Gtk.Objects.TextView: textViewGetIterAtLocation :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> Int32 -> m ((Bool, TextIter))

+ GI.Gtk.Objects.TextView: textViewGetIterAtLocation :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> Int32 -> m (Bool, TextIter)

- GI.Gtk.Objects.TextView: textViewGetIterAtPosition :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> Int32 -> m ((Bool, TextIter, Int32))

+ GI.Gtk.Objects.TextView: textViewGetIterAtPosition :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> Int32 -> m (Bool, TextIter, Int32)

- GI.Gtk.Objects.TextView: textViewGetIterLocation :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m (Rectangle)

+ GI.Gtk.Objects.TextView: textViewGetIterLocation :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Rectangle

- GI.Gtk.Objects.TextView: textViewGetLineAtY :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ((TextIter, Int32))

+ GI.Gtk.Objects.TextView: textViewGetLineAtY :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m (TextIter, Int32)

- GI.Gtk.Objects.TextView: textViewGetLineYrange :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m ((Int32, Int32))

+ GI.Gtk.Objects.TextView: textViewGetLineYrange :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m (Int32, Int32)

- GI.Gtk.Objects.TextView: textViewGetVisibleRect :: (HasCallStack, MonadIO m, IsTextView a) => a -> m (Rectangle)

+ GI.Gtk.Objects.TextView: textViewGetVisibleRect :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Rectangle

- GI.Gtk.Objects.TextView: textViewSetBuffer :: (HasCallStack, MonadIO m, IsTextView a, IsTextBuffer b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.TextView: textViewSetBuffer :: (HasCallStack, MonadIO m, IsTextView a, IsTextBuffer b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.TextView: textViewWindowToBufferCoords :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> Int32 -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.TextView: textViewWindowToBufferCoords :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> Int32 -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.TextView: type TextViewDeleteFromCursorCallback = DeleteType /@type@/: the granularity of the deletion, as a 'GI.Gtk.Enums.DeleteType' -> Int32 /@count@/: the number of /@type@/ units to delete -> IO ()

+ GI.Gtk.Objects.TextView: type TextViewDeleteFromCursorCallback = DeleteType " /@type@/: the granularity of the deletion, as a 'GI.Gtk.Enums.DeleteType' " -> Int32 " /@count@/: the number of /@type@/ units to delete " -> IO ()

- GI.Gtk.Objects.TextView: type TextViewExtendSelectionCallback = TextExtendSelection /@granularity@/: the granularity type -> TextIter /@location@/: the location where to extend the selection -> TextIter /@start@/: where the selection should start -> TextIter /@end@/: where the selection should end -> IO Bool __Returns:__ 'GI.Gdk.Constants.EVENT_STOP' to stop other handlers from being invoked for the event. 'GI.Gdk.Constants.EVENT_PROPAGATE' to propagate the event further.

+ GI.Gtk.Objects.TextView: type TextViewExtendSelectionCallback = TextExtendSelection " /@granularity@/: the granularity type " -> TextIter " /@location@/: the location where to extend the selection " -> TextIter " /@start@/: where the selection should start " -> TextIter " /@end@/: where the selection should end " -> IO Bool " __Returns:__ 'GI.Gdk.Constants.EVENT_STOP' to stop other handlers from being invoked for the event. 'GI.Gdk.Constants.EVENT_PROPAGATE' to propagate the event further. "

- GI.Gtk.Objects.TextView: type TextViewInsertAtCursorCallback = Text /@string@/: the string to insert -> IO ()

+ GI.Gtk.Objects.TextView: type TextViewInsertAtCursorCallback = Text " /@string@/: the string to insert " -> IO ()

- GI.Gtk.Objects.TextView: type TextViewMoveCursorCallback = MovementStep /@step@/: the granularity of the move, as a 'GI.Gtk.Enums.MovementStep' -> Int32 /@count@/: the number of /@step@/ units to move -> Bool /@extendSelection@/: 'True' if the move should extend the selection -> IO ()

+ GI.Gtk.Objects.TextView: type TextViewMoveCursorCallback = MovementStep " /@step@/: the granularity of the move, as a 'GI.Gtk.Enums.MovementStep' " -> Int32 " /@count@/: the number of /@step@/ units to move " -> Bool " /@extendSelection@/: 'True' if the move should extend the selection " -> IO ()

- GI.Gtk.Objects.TextView: type TextViewMoveViewportCallback = ScrollStep /@step@/: the granularity of the movement, as a 'GI.Gtk.Enums.ScrollStep' -> Int32 /@count@/: the number of /@step@/ units to move -> IO ()

+ GI.Gtk.Objects.TextView: type TextViewMoveViewportCallback = ScrollStep " /@step@/: the granularity of the movement, as a 'GI.Gtk.Enums.ScrollStep' " -> Int32 " /@count@/: the number of /@step@/ units to move " -> IO ()

- GI.Gtk.Objects.TextView: type TextViewPopulatePopupCallback = Widget /@popup@/: the container that is being populated -> IO ()

+ GI.Gtk.Objects.TextView: type TextViewPopulatePopupCallback = Widget " /@popup@/: the container that is being populated " -> IO ()

- GI.Gtk.Objects.TextView: type TextViewPreeditChangedCallback = Text /@preedit@/: the current preedit string -> IO ()

+ GI.Gtk.Objects.TextView: type TextViewPreeditChangedCallback = Text " /@preedit@/: the current preedit string " -> IO ()

- GI.Gtk.Objects.TextView: type TextViewSelectAllCallback = Bool /@select@/: 'True' to select, 'False' to unselect -> IO ()

+ GI.Gtk.Objects.TextView: type TextViewSelectAllCallback = Bool " /@select@/: 'True' to select, 'False' to unselect " -> IO ()

- GI.Gtk.Objects.TextViewAccessible: TextViewAccessible :: (ManagedPtr TextViewAccessible) -> TextViewAccessible

+ GI.Gtk.Objects.TextViewAccessible: TextViewAccessible :: ManagedPtr TextViewAccessible -> TextViewAccessible

- GI.Gtk.Objects.ThemingEngine: ThemingEngine :: (ManagedPtr ThemingEngine) -> ThemingEngine

+ GI.Gtk.Objects.ThemingEngine: ThemingEngine :: ManagedPtr ThemingEngine -> ThemingEngine

- GI.Gtk.Objects.ThemingEngine: constructThemingEngineName :: (IsThemingEngine o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ThemingEngine: constructThemingEngineName :: IsThemingEngine o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ThemingEngine: themingEngineGetBackgroundColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m (RGBA)

+ GI.Gtk.Objects.ThemingEngine: themingEngineGetBackgroundColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m RGBA

- GI.Gtk.Objects.ThemingEngine: themingEngineGetBorder :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m (Border)

+ GI.Gtk.Objects.ThemingEngine: themingEngineGetBorder :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m Border

- GI.Gtk.Objects.ThemingEngine: themingEngineGetBorderColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m (RGBA)

+ GI.Gtk.Objects.ThemingEngine: themingEngineGetBorderColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m RGBA

- GI.Gtk.Objects.ThemingEngine: themingEngineGetColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m (RGBA)

+ GI.Gtk.Objects.ThemingEngine: themingEngineGetColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m RGBA

- GI.Gtk.Objects.ThemingEngine: themingEngineGetMargin :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m (Border)

+ GI.Gtk.Objects.ThemingEngine: themingEngineGetMargin :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m Border

- GI.Gtk.Objects.ThemingEngine: themingEngineGetPadding :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m (Border)

+ GI.Gtk.Objects.ThemingEngine: themingEngineGetPadding :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m Border

- GI.Gtk.Objects.ThemingEngine: themingEngineGetProperty :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> [StateFlags] -> m (GValue)

+ GI.Gtk.Objects.ThemingEngine: themingEngineGetProperty :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> [StateFlags] -> m GValue

- GI.Gtk.Objects.ThemingEngine: themingEngineGetStyleProperty :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> m (GValue)

+ GI.Gtk.Objects.ThemingEngine: themingEngineGetStyleProperty :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> m GValue

- GI.Gtk.Objects.ThemingEngine: themingEngineHasRegion :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> m ((Bool, [RegionFlags]))

+ GI.Gtk.Objects.ThemingEngine: themingEngineHasRegion :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> m (Bool, [RegionFlags])

- GI.Gtk.Objects.ThemingEngine: themingEngineLookupColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> m ((Bool, RGBA))

+ GI.Gtk.Objects.ThemingEngine: themingEngineLookupColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> m (Bool, RGBA)

- GI.Gtk.Objects.ThemingEngine: themingEngineStateIsRunning :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> StateType -> m ((Bool, Double))

+ GI.Gtk.Objects.ThemingEngine: themingEngineStateIsRunning :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> StateType -> m (Bool, Double)

- GI.Gtk.Objects.ToggleAction: ToggleAction :: (ManagedPtr ToggleAction) -> ToggleAction

+ GI.Gtk.Objects.ToggleAction: ToggleAction :: ManagedPtr ToggleAction -> ToggleAction

- GI.Gtk.Objects.ToggleAction: constructToggleActionActive :: (IsToggleAction o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToggleAction: constructToggleActionActive :: IsToggleAction o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToggleAction: constructToggleActionDrawAsRadio :: (IsToggleAction o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToggleAction: constructToggleActionDrawAsRadio :: IsToggleAction o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToggleAction: toggleActionNew :: (HasCallStack, MonadIO m) => Text -> Maybe (Text) -> Maybe (Text) -> Maybe (Text) -> m ToggleAction

+ GI.Gtk.Objects.ToggleAction: toggleActionNew :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> m ToggleAction

- GI.Gtk.Objects.ToggleButton: ToggleButton :: (ManagedPtr ToggleButton) -> ToggleButton

+ GI.Gtk.Objects.ToggleButton: ToggleButton :: ManagedPtr ToggleButton -> ToggleButton

- GI.Gtk.Objects.ToggleButton: constructToggleButtonActive :: (IsToggleButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToggleButton: constructToggleButtonActive :: IsToggleButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToggleButton: constructToggleButtonDrawIndicator :: (IsToggleButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToggleButton: constructToggleButtonDrawIndicator :: IsToggleButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToggleButton: constructToggleButtonInconsistent :: (IsToggleButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToggleButton: constructToggleButtonInconsistent :: IsToggleButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToggleButtonAccessible: ToggleButtonAccessible :: (ManagedPtr ToggleButtonAccessible) -> ToggleButtonAccessible

+ GI.Gtk.Objects.ToggleButtonAccessible: ToggleButtonAccessible :: ManagedPtr ToggleButtonAccessible -> ToggleButtonAccessible

- GI.Gtk.Objects.ToggleToolButton: ToggleToolButton :: (ManagedPtr ToggleToolButton) -> ToggleToolButton

+ GI.Gtk.Objects.ToggleToolButton: ToggleToolButton :: ManagedPtr ToggleToolButton -> ToggleToolButton

- GI.Gtk.Objects.ToggleToolButton: constructToggleToolButtonActive :: (IsToggleToolButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToggleToolButton: constructToggleToolButtonActive :: IsToggleToolButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToolButton: ToolButton :: (ManagedPtr ToolButton) -> ToolButton

+ GI.Gtk.Objects.ToolButton: ToolButton :: ManagedPtr ToolButton -> ToolButton

- GI.Gtk.Objects.ToolButton: constructToolButtonIconName :: (IsToolButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToolButton: constructToolButtonIconName :: IsToolButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToolButton: constructToolButtonLabel :: (IsToolButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToolButton: constructToolButtonLabel :: IsToolButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToolButton: constructToolButtonStockId :: (IsToolButton o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToolButton: constructToolButtonStockId :: IsToolButton o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToolButton: constructToolButtonUseUnderline :: (IsToolButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToolButton: constructToolButtonUseUnderline :: IsToolButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToolButton: toolButtonNew :: (HasCallStack, MonadIO m, IsWidget a) => Maybe (a) -> Maybe (Text) -> m ToolButton

+ GI.Gtk.Objects.ToolButton: toolButtonNew :: (HasCallStack, MonadIO m, IsWidget a) => Maybe a -> Maybe Text -> m ToolButton

- GI.Gtk.Objects.ToolButton: toolButtonSetIconName :: (HasCallStack, MonadIO m, IsToolButton a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.ToolButton: toolButtonSetIconName :: (HasCallStack, MonadIO m, IsToolButton a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.ToolButton: toolButtonSetIconWidget :: (HasCallStack, MonadIO m, IsToolButton a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.ToolButton: toolButtonSetIconWidget :: (HasCallStack, MonadIO m, IsToolButton a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.ToolButton: toolButtonSetLabel :: (HasCallStack, MonadIO m, IsToolButton a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.ToolButton: toolButtonSetLabel :: (HasCallStack, MonadIO m, IsToolButton a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.ToolButton: toolButtonSetLabelWidget :: (HasCallStack, MonadIO m, IsToolButton a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.ToolButton: toolButtonSetLabelWidget :: (HasCallStack, MonadIO m, IsToolButton a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.ToolButton: toolButtonSetStockId :: (HasCallStack, MonadIO m, IsToolButton a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.ToolButton: toolButtonSetStockId :: (HasCallStack, MonadIO m, IsToolButton a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.ToolItem: ToolItem :: (ManagedPtr ToolItem) -> ToolItem

+ GI.Gtk.Objects.ToolItem: ToolItem :: ManagedPtr ToolItem -> ToolItem

- GI.Gtk.Objects.ToolItem: constructToolItemIsImportant :: (IsToolItem o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToolItem: constructToolItemIsImportant :: IsToolItem o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToolItem: constructToolItemVisibleHorizontal :: (IsToolItem o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToolItem: constructToolItemVisibleHorizontal :: IsToolItem o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToolItem: constructToolItemVisibleVertical :: (IsToolItem o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToolItem: constructToolItemVisibleVertical :: IsToolItem o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToolItem: toolItemSetProxyMenuItem :: (HasCallStack, MonadIO m, IsToolItem a, IsWidget b) => a -> Text -> Maybe (b) -> m ()

+ GI.Gtk.Objects.ToolItem: toolItemSetProxyMenuItem :: (HasCallStack, MonadIO m, IsToolItem a, IsWidget b) => a -> Text -> Maybe b -> m ()

- GI.Gtk.Objects.ToolItem: type ToolItemCreateMenuProxyCallback = IO Bool __Returns:__ 'True' if the signal was handled, 'False' if not

+ GI.Gtk.Objects.ToolItem: type ToolItemCreateMenuProxyCallback = IO Bool " __Returns:__ 'True' if the signal was handled, 'False' if not "

- GI.Gtk.Objects.ToolItemGroup: ToolItemGroup :: (ManagedPtr ToolItemGroup) -> ToolItemGroup

+ GI.Gtk.Objects.ToolItemGroup: ToolItemGroup :: ManagedPtr ToolItemGroup -> ToolItemGroup

- GI.Gtk.Objects.ToolItemGroup: constructToolItemGroupCollapsed :: (IsToolItemGroup o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToolItemGroup: constructToolItemGroupCollapsed :: IsToolItemGroup o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToolItemGroup: constructToolItemGroupEllipsize :: (IsToolItemGroup o) => EllipsizeMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToolItemGroup: constructToolItemGroupEllipsize :: IsToolItemGroup o => EllipsizeMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToolItemGroup: constructToolItemGroupHeaderRelief :: (IsToolItemGroup o) => ReliefStyle -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToolItemGroup: constructToolItemGroupHeaderRelief :: IsToolItemGroup o => ReliefStyle -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToolItemGroup: constructToolItemGroupLabel :: (IsToolItemGroup o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToolItemGroup: constructToolItemGroupLabel :: IsToolItemGroup o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToolPalette: ToolPalette :: (ManagedPtr ToolPalette) -> ToolPalette

+ GI.Gtk.Objects.ToolPalette: ToolPalette :: ManagedPtr ToolPalette -> ToolPalette

- GI.Gtk.Objects.ToolPalette: constructToolPaletteIconSize :: (IsToolPalette o) => IconSize -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToolPalette: constructToolPaletteIconSize :: IsToolPalette o => IconSize -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToolPalette: constructToolPaletteIconSizeSet :: (IsToolPalette o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToolPalette: constructToolPaletteIconSizeSet :: IsToolPalette o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.ToolPalette: constructToolPaletteToolbarStyle :: (IsToolPalette o) => ToolbarStyle -> IO (GValueConstruct o)

+ GI.Gtk.Objects.ToolPalette: constructToolPaletteToolbarStyle :: IsToolPalette o => ToolbarStyle -> IO (GValueConstruct o)

- GI.Gtk.Objects.Toolbar: Toolbar :: (ManagedPtr Toolbar) -> Toolbar

+ GI.Gtk.Objects.Toolbar: Toolbar :: ManagedPtr Toolbar -> Toolbar

- GI.Gtk.Objects.Toolbar: constructToolbarIconSize :: (IsToolbar o) => IconSize -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Toolbar: constructToolbarIconSize :: IsToolbar o => IconSize -> IO (GValueConstruct o)

- GI.Gtk.Objects.Toolbar: constructToolbarIconSizeSet :: (IsToolbar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Toolbar: constructToolbarIconSizeSet :: IsToolbar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Toolbar: constructToolbarShowArrow :: (IsToolbar o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Toolbar: constructToolbarShowArrow :: IsToolbar o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Toolbar: constructToolbarToolbarStyle :: (IsToolbar o) => ToolbarStyle -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Toolbar: constructToolbarToolbarStyle :: IsToolbar o => ToolbarStyle -> IO (GValueConstruct o)

- GI.Gtk.Objects.Toolbar: toolbarSetDropHighlightItem :: (HasCallStack, MonadIO m, IsToolbar a, IsToolItem b) => a -> Maybe (b) -> Int32 -> m ()

+ GI.Gtk.Objects.Toolbar: toolbarSetDropHighlightItem :: (HasCallStack, MonadIO m, IsToolbar a, IsToolItem b) => a -> Maybe b -> Int32 -> m ()

- GI.Gtk.Objects.Toolbar: type ToolbarFocusHomeOrEndCallback = Bool /@focusHome@/: 'True' if the first item should be focused -> IO Bool __Returns:__ 'True' if the signal was handled, 'False' if not

+ GI.Gtk.Objects.Toolbar: type ToolbarFocusHomeOrEndCallback = Bool " /@focusHome@/: 'True' if the first item should be focused " -> IO Bool " __Returns:__ 'True' if the signal was handled, 'False' if not "

- GI.Gtk.Objects.Toolbar: type ToolbarOrientationChangedCallback = Orientation /@orientation@/: the new 'GI.Gtk.Enums.Orientation' of the toolbar -> IO ()

+ GI.Gtk.Objects.Toolbar: type ToolbarOrientationChangedCallback = Orientation " /@orientation@/: the new 'GI.Gtk.Enums.Orientation' of the toolbar " -> IO ()

- GI.Gtk.Objects.Toolbar: type ToolbarPopupContextMenuCallback = Int32 /@x@/: the x coordinate of the point where the menu should appear -> Int32 /@y@/: the y coordinate of the point where the menu should appear -> Int32 /@button@/: the mouse button the user pressed, or -1 -> IO Bool __Returns:__ return 'True' if the signal was handled, 'False' if not

+ GI.Gtk.Objects.Toolbar: type ToolbarPopupContextMenuCallback = Int32 " /@x@/: the x coordinate of the point where the menu should appear " -> Int32 " /@y@/: the y coordinate of the point where the menu should appear " -> Int32 " /@button@/: the mouse button the user pressed, or -1 " -> IO Bool " __Returns:__ return 'True' if the signal was handled, 'False' if not "

- GI.Gtk.Objects.Toolbar: type ToolbarStyleChangedCallback = ToolbarStyle /@style@/: the new 'GI.Gtk.Enums.ToolbarStyle' of the toolbar -> IO ()

+ GI.Gtk.Objects.Toolbar: type ToolbarStyleChangedCallback = ToolbarStyle " /@style@/: the new 'GI.Gtk.Enums.ToolbarStyle' of the toolbar " -> IO ()

- GI.Gtk.Objects.Tooltip: Tooltip :: (ManagedPtr Tooltip) -> Tooltip

+ GI.Gtk.Objects.Tooltip: Tooltip :: ManagedPtr Tooltip -> Tooltip

- GI.Gtk.Objects.Tooltip: tooltipSetCustom :: (HasCallStack, MonadIO m, IsTooltip a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Tooltip: tooltipSetCustom :: (HasCallStack, MonadIO m, IsTooltip a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Tooltip: tooltipSetIcon :: (HasCallStack, MonadIO m, IsTooltip a, IsPixbuf b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Tooltip: tooltipSetIcon :: (HasCallStack, MonadIO m, IsTooltip a, IsPixbuf b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Tooltip: tooltipSetIconFromGicon :: (HasCallStack, MonadIO m, IsTooltip a, IsIcon b) => a -> Maybe (b) -> Int32 -> m ()

+ GI.Gtk.Objects.Tooltip: tooltipSetIconFromGicon :: (HasCallStack, MonadIO m, IsTooltip a, IsIcon b) => a -> Maybe b -> Int32 -> m ()

- GI.Gtk.Objects.Tooltip: tooltipSetIconFromIconName :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe (Text) -> Int32 -> m ()

+ GI.Gtk.Objects.Tooltip: tooltipSetIconFromIconName :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe Text -> Int32 -> m ()

- GI.Gtk.Objects.Tooltip: tooltipSetIconFromStock :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe (Text) -> Int32 -> m ()

+ GI.Gtk.Objects.Tooltip: tooltipSetIconFromStock :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe Text -> Int32 -> m ()

- GI.Gtk.Objects.Tooltip: tooltipSetMarkup :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Tooltip: tooltipSetMarkup :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.Tooltip: tooltipSetText :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Tooltip: tooltipSetText :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.ToplevelAccessible: ToplevelAccessible :: (ManagedPtr ToplevelAccessible) -> ToplevelAccessible

+ GI.Gtk.Objects.ToplevelAccessible: ToplevelAccessible :: ManagedPtr ToplevelAccessible -> ToplevelAccessible

- GI.Gtk.Objects.TreeModelFilter: TreeModelFilter :: (ManagedPtr TreeModelFilter) -> TreeModelFilter

+ GI.Gtk.Objects.TreeModelFilter: TreeModelFilter :: ManagedPtr TreeModelFilter -> TreeModelFilter

- GI.Gtk.Objects.TreeModelFilter: constructTreeModelFilterVirtualRoot :: (IsTreeModelFilter o) => TreePath -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeModelFilter: constructTreeModelFilterVirtualRoot :: IsTreeModelFilter o => TreePath -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeModelFilter: treeModelFilterConvertChildIterToIter :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreeIter -> m ((Bool, TreeIter))

+ GI.Gtk.Objects.TreeModelFilter: treeModelFilterConvertChildIterToIter :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreeIter -> m (Bool, TreeIter)

- GI.Gtk.Objects.TreeModelFilter: treeModelFilterConvertIterToChildIter :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreeIter -> m (TreeIter)

+ GI.Gtk.Objects.TreeModelFilter: treeModelFilterConvertIterToChildIter :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreeIter -> m TreeIter

- GI.Gtk.Objects.TreeModelSort: TreeModelSort :: (ManagedPtr TreeModelSort) -> TreeModelSort

+ GI.Gtk.Objects.TreeModelSort: TreeModelSort :: ManagedPtr TreeModelSort -> TreeModelSort

- GI.Gtk.Objects.TreeModelSort: treeModelSortConvertChildIterToIter :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreeIter -> m ((Bool, TreeIter))

+ GI.Gtk.Objects.TreeModelSort: treeModelSortConvertChildIterToIter :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreeIter -> m (Bool, TreeIter)

- GI.Gtk.Objects.TreeModelSort: treeModelSortConvertIterToChildIter :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreeIter -> m (TreeIter)

+ GI.Gtk.Objects.TreeModelSort: treeModelSortConvertIterToChildIter :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreeIter -> m TreeIter

- GI.Gtk.Objects.TreeSelection: TreeSelection :: (ManagedPtr TreeSelection) -> TreeSelection

+ GI.Gtk.Objects.TreeSelection: TreeSelection :: ManagedPtr TreeSelection -> TreeSelection

- GI.Gtk.Objects.TreeSelection: constructTreeSelectionMode :: (IsTreeSelection o) => SelectionMode -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeSelection: constructTreeSelectionMode :: IsTreeSelection o => SelectionMode -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeSelection: treeSelectionGetSelected :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m ((Bool, TreeModel, TreeIter))

+ GI.Gtk.Objects.TreeSelection: treeSelectionGetSelected :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m (Bool, TreeModel, TreeIter)

- GI.Gtk.Objects.TreeSelection: treeSelectionGetSelectedRows :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m (([TreePath], TreeModel))

+ GI.Gtk.Objects.TreeSelection: treeSelectionGetSelectedRows :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m ([TreePath], TreeModel)

- GI.Gtk.Objects.TreeStore: TreeStore :: (ManagedPtr TreeStore) -> TreeStore

+ GI.Gtk.Objects.TreeStore: TreeStore :: ManagedPtr TreeStore -> TreeStore

- GI.Gtk.Objects.TreeStore: treeStoreAppend :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe (TreeIter) -> m (TreeIter)

+ GI.Gtk.Objects.TreeStore: treeStoreAppend :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> m TreeIter

- GI.Gtk.Objects.TreeStore: treeStoreInsert :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe (TreeIter) -> Int32 -> m (TreeIter)

+ GI.Gtk.Objects.TreeStore: treeStoreInsert :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Int32 -> m TreeIter

- GI.Gtk.Objects.TreeStore: treeStoreInsertAfter :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe (TreeIter) -> Maybe (TreeIter) -> m (TreeIter)

+ GI.Gtk.Objects.TreeStore: treeStoreInsertAfter :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Maybe TreeIter -> m TreeIter

- GI.Gtk.Objects.TreeStore: treeStoreInsertBefore :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe (TreeIter) -> Maybe (TreeIter) -> m (TreeIter)

+ GI.Gtk.Objects.TreeStore: treeStoreInsertBefore :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Maybe TreeIter -> m TreeIter

- GI.Gtk.Objects.TreeStore: treeStoreInsertWithValues :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe (TreeIter) -> Int32 -> [Int32] -> [GValue] -> m (TreeIter)

+ GI.Gtk.Objects.TreeStore: treeStoreInsertWithValues :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Int32 -> [Int32] -> [GValue] -> m TreeIter

- GI.Gtk.Objects.TreeStore: treeStoreMoveAfter :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> Maybe (TreeIter) -> m ()

+ GI.Gtk.Objects.TreeStore: treeStoreMoveAfter :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

- GI.Gtk.Objects.TreeStore: treeStoreMoveBefore :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> Maybe (TreeIter) -> m ()

+ GI.Gtk.Objects.TreeStore: treeStoreMoveBefore :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

- GI.Gtk.Objects.TreeStore: treeStorePrepend :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe (TreeIter) -> m (TreeIter)

+ GI.Gtk.Objects.TreeStore: treeStorePrepend :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> m TreeIter

- GI.Gtk.Objects.TreeView: TreeView :: (ManagedPtr TreeView) -> TreeView

+ GI.Gtk.Objects.TreeView: TreeView :: ManagedPtr TreeView -> TreeView

- GI.Gtk.Objects.TreeView: constructTreeViewActivateOnSingleClick :: (IsTreeView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewActivateOnSingleClick :: IsTreeView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewEnableGridLines :: (IsTreeView o) => TreeViewGridLines -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewEnableGridLines :: IsTreeView o => TreeViewGridLines -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewEnableSearch :: (IsTreeView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewEnableSearch :: IsTreeView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewEnableTreeLines :: (IsTreeView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewEnableTreeLines :: IsTreeView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewFixedHeightMode :: (IsTreeView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewFixedHeightMode :: IsTreeView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewHeadersClickable :: (IsTreeView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewHeadersClickable :: IsTreeView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewHeadersVisible :: (IsTreeView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewHeadersVisible :: IsTreeView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewHoverExpand :: (IsTreeView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewHoverExpand :: IsTreeView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewHoverSelection :: (IsTreeView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewHoverSelection :: IsTreeView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewLevelIndentation :: (IsTreeView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewLevelIndentation :: IsTreeView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewReorderable :: (IsTreeView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewReorderable :: IsTreeView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewRubberBanding :: (IsTreeView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewRubberBanding :: IsTreeView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewRulesHint :: (IsTreeView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewRulesHint :: IsTreeView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewSearchColumn :: (IsTreeView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewSearchColumn :: IsTreeView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewShowExpanders :: (IsTreeView o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewShowExpanders :: IsTreeView o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: constructTreeViewTooltipColumn :: (IsTreeView o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeView: constructTreeViewTooltipColumn :: IsTreeView o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeView: treeViewConvertBinWindowToTreeCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.TreeView: treeViewConvertBinWindowToTreeCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.TreeView: treeViewConvertBinWindowToWidgetCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.TreeView: treeViewConvertBinWindowToWidgetCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.TreeView: treeViewConvertTreeToBinWindowCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.TreeView: treeViewConvertTreeToBinWindowCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.TreeView: treeViewConvertTreeToWidgetCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.TreeView: treeViewConvertTreeToWidgetCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.TreeView: treeViewConvertWidgetToBinWindowCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.TreeView: treeViewConvertWidgetToBinWindowCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.TreeView: treeViewConvertWidgetToTreeCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.TreeView: treeViewConvertWidgetToTreeCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.TreeView: treeViewGetBackgroundArea :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe (TreePath) -> Maybe (b) -> m (Rectangle)

+ GI.Gtk.Objects.TreeView: treeViewGetBackgroundArea :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe TreePath -> Maybe b -> m Rectangle

- GI.Gtk.Objects.TreeView: treeViewGetCellArea :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe (TreePath) -> Maybe (b) -> m (Rectangle)

+ GI.Gtk.Objects.TreeView: treeViewGetCellArea :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe TreePath -> Maybe b -> m Rectangle

- GI.Gtk.Objects.TreeView: treeViewGetCursor :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ((Maybe TreePath, Maybe TreeViewColumn))

+ GI.Gtk.Objects.TreeView: treeViewGetCursor :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Maybe TreePath, Maybe TreeViewColumn)

- GI.Gtk.Objects.TreeView: treeViewGetDestRowAtPos :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m ((Bool, Maybe TreePath, TreeViewDropPosition))

+ GI.Gtk.Objects.TreeView: treeViewGetDestRowAtPos :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Bool, Maybe TreePath, TreeViewDropPosition)

- GI.Gtk.Objects.TreeView: treeViewGetDragDestRow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ((Maybe TreePath, TreeViewDropPosition))

+ GI.Gtk.Objects.TreeView: treeViewGetDragDestRow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Maybe TreePath, TreeViewDropPosition)

- GI.Gtk.Objects.TreeView: treeViewGetPathAtPos :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m ((Bool, Maybe TreePath, Maybe TreeViewColumn, Int32, Int32))

+ GI.Gtk.Objects.TreeView: treeViewGetPathAtPos :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Bool, Maybe TreePath, Maybe TreeViewColumn, Int32, Int32)

- GI.Gtk.Objects.TreeView: treeViewGetTooltipContext :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> Bool -> m ((Bool, Int32, Int32, Maybe TreeModel, TreePath, TreeIter))

+ GI.Gtk.Objects.TreeView: treeViewGetTooltipContext :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> Bool -> m (Bool, Int32, Int32, Maybe TreeModel, TreePath, TreeIter)

- GI.Gtk.Objects.TreeView: treeViewGetVisibleRange :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ((Bool, TreePath, TreePath))

+ GI.Gtk.Objects.TreeView: treeViewGetVisibleRange :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Bool, TreePath, TreePath)

- GI.Gtk.Objects.TreeView: treeViewGetVisibleRect :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Rectangle)

+ GI.Gtk.Objects.TreeView: treeViewGetVisibleRect :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Rectangle

- GI.Gtk.Objects.TreeView: treeViewIsBlankAtPos :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m ((Bool, Maybe TreePath, Maybe TreeViewColumn, Int32, Int32))

+ GI.Gtk.Objects.TreeView: treeViewIsBlankAtPos :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Bool, Maybe TreePath, Maybe TreeViewColumn, Int32, Int32)

- GI.Gtk.Objects.TreeView: treeViewMoveColumnAfter :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsTreeViewColumn c) => a -> b -> Maybe (c) -> m ()

+ GI.Gtk.Objects.TreeView: treeViewMoveColumnAfter :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsTreeViewColumn c) => a -> b -> Maybe c -> m ()

- GI.Gtk.Objects.TreeView: treeViewScrollToCell :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe (TreePath) -> Maybe (b) -> Bool -> Float -> Float -> m ()

+ GI.Gtk.Objects.TreeView: treeViewScrollToCell :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe TreePath -> Maybe b -> Bool -> Float -> Float -> m ()

- GI.Gtk.Objects.TreeView: treeViewSetColumnDragFunction :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe (TreeViewColumnDropFunc) -> m ()

+ GI.Gtk.Objects.TreeView: treeViewSetColumnDragFunction :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreeViewColumnDropFunc -> m ()

- GI.Gtk.Objects.TreeView: treeViewSetCursor :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> TreePath -> Maybe (b) -> Bool -> m ()

+ GI.Gtk.Objects.TreeView: treeViewSetCursor :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> TreePath -> Maybe b -> Bool -> m ()

- GI.Gtk.Objects.TreeView: treeViewSetCursorOnCell :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsCellRenderer c) => a -> TreePath -> Maybe (b) -> Maybe (c) -> Bool -> m ()

+ GI.Gtk.Objects.TreeView: treeViewSetCursorOnCell :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsCellRenderer c) => a -> TreePath -> Maybe b -> Maybe c -> Bool -> m ()

- GI.Gtk.Objects.TreeView: treeViewSetDestroyCountFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe (TreeDestroyCountFunc) -> m ()

+ GI.Gtk.Objects.TreeView: treeViewSetDestroyCountFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreeDestroyCountFunc -> m ()

- GI.Gtk.Objects.TreeView: treeViewSetDragDestRow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe (TreePath) -> TreeViewDropPosition -> m ()

+ GI.Gtk.Objects.TreeView: treeViewSetDragDestRow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreePath -> TreeViewDropPosition -> m ()

- GI.Gtk.Objects.TreeView: treeViewSetHadjustment :: (HasCallStack, MonadIO m, IsTreeView a, IsAdjustment b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.TreeView: treeViewSetHadjustment :: (HasCallStack, MonadIO m, IsTreeView a, IsAdjustment b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.TreeView: treeViewSetModel :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeModel b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.TreeView: treeViewSetModel :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeModel b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.TreeView: treeViewSetRowSeparatorFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe (TreeViewRowSeparatorFunc) -> m ()

+ GI.Gtk.Objects.TreeView: treeViewSetRowSeparatorFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreeViewRowSeparatorFunc -> m ()

- GI.Gtk.Objects.TreeView: treeViewSetSearchEntry :: (HasCallStack, MonadIO m, IsTreeView a, IsEntry b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.TreeView: treeViewSetSearchEntry :: (HasCallStack, MonadIO m, IsTreeView a, IsEntry b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.TreeView: treeViewSetSearchPositionFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe (TreeViewSearchPositionFunc) -> m ()

+ GI.Gtk.Objects.TreeView: treeViewSetSearchPositionFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreeViewSearchPositionFunc -> m ()

- GI.Gtk.Objects.TreeView: treeViewSetTooltipCell :: (HasCallStack, MonadIO m, IsTreeView a, IsTooltip b, IsTreeViewColumn c, IsCellRenderer d) => a -> b -> Maybe (TreePath) -> Maybe (c) -> Maybe (d) -> m ()

+ GI.Gtk.Objects.TreeView: treeViewSetTooltipCell :: (HasCallStack, MonadIO m, IsTreeView a, IsTooltip b, IsTreeViewColumn c, IsCellRenderer d) => a -> b -> Maybe TreePath -> Maybe c -> Maybe d -> m ()

- GI.Gtk.Objects.TreeView: treeViewSetVadjustment :: (HasCallStack, MonadIO m, IsTreeView a, IsAdjustment b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.TreeView: treeViewSetVadjustment :: (HasCallStack, MonadIO m, IsTreeView a, IsAdjustment b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.TreeView: type TreeViewMoveCursorCallback = MovementStep /@step@/: the granularity of the move, as a 'GI.Gtk.Enums.MovementStep'. 'GI.Gtk.Enums.MovementStepLogicalPositions', 'GI.Gtk.Enums.MovementStepVisualPositions', 'GI.Gtk.Enums.MovementStepDisplayLines', 'GI.Gtk.Enums.MovementStepPages' and 'GI.Gtk.Enums.MovementStepBufferEnds' are supported. 'GI.Gtk.Enums.MovementStepLogicalPositions' and 'GI.Gtk.Enums.MovementStepVisualPositions' are treated identically. -> Int32 /@direction@/: the direction to move: +1 to move forwards; -1 to move backwards. The resulting movement is undefined for all other values. -> IO Bool __Returns:__ 'True' if /@step@/ is supported, 'False' otherwise.

+ GI.Gtk.Objects.TreeView: type TreeViewMoveCursorCallback = MovementStep " /@step@/: the granularity of the move, as a 'GI.Gtk.Enums.MovementStep'. 'GI.Gtk.Enums.MovementStepLogicalPositions', 'GI.Gtk.Enums.MovementStepVisualPositions', 'GI.Gtk.Enums.MovementStepDisplayLines', 'GI.Gtk.Enums.MovementStepPages' and 'GI.Gtk.Enums.MovementStepBufferEnds' are supported. 'GI.Gtk.Enums.MovementStepLogicalPositions' and 'GI.Gtk.Enums.MovementStepVisualPositions' are treated identically. " -> Int32 " /@direction@/: the direction to move: +1 to move forwards; -1 to move backwards. The resulting movement is undefined for all other values. " -> IO Bool " __Returns:__ 'True' if /@step@/ is supported, 'False' otherwise. "

- GI.Gtk.Objects.TreeView: type TreeViewRowActivatedCallback = TreePath /@path@/: the 'GI.Gtk.Structs.TreePath.TreePath' for the activated row -> TreeViewColumn /@column@/: the 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' in which the activation occurred -> IO ()

+ GI.Gtk.Objects.TreeView: type TreeViewRowActivatedCallback = TreePath " /@path@/: the 'GI.Gtk.Structs.TreePath.TreePath' for the activated row " -> TreeViewColumn " /@column@/: the 'GI.Gtk.Objects.TreeViewColumn.TreeViewColumn' in which the activation occurred " -> IO ()

- GI.Gtk.Objects.TreeView: type TreeViewRowCollapsedCallback = TreeIter /@iter@/: the tree iter of the collapsed row -> TreePath /@path@/: a tree path that points to the row -> IO ()

+ GI.Gtk.Objects.TreeView: type TreeViewRowCollapsedCallback = TreeIter " /@iter@/: the tree iter of the collapsed row " -> TreePath " /@path@/: a tree path that points to the row " -> IO ()

- GI.Gtk.Objects.TreeView: type TreeViewRowExpandedCallback = TreeIter /@iter@/: the tree iter of the expanded row -> TreePath /@path@/: a tree path that points to the row -> IO ()

+ GI.Gtk.Objects.TreeView: type TreeViewRowExpandedCallback = TreeIter " /@iter@/: the tree iter of the expanded row " -> TreePath " /@path@/: a tree path that points to the row " -> IO ()

- GI.Gtk.Objects.TreeView: type TreeViewTestCollapseRowCallback = TreeIter /@iter@/: the tree iter of the row to collapse -> TreePath /@path@/: a tree path that points to the row -> IO Bool __Returns:__ 'False' to allow collapsing, 'True' to reject

+ GI.Gtk.Objects.TreeView: type TreeViewTestCollapseRowCallback = TreeIter " /@iter@/: the tree iter of the row to collapse " -> TreePath " /@path@/: a tree path that points to the row " -> IO Bool " __Returns:__ 'False' to allow collapsing, 'True' to reject "

- GI.Gtk.Objects.TreeView: type TreeViewTestExpandRowCallback = TreeIter /@iter@/: the tree iter of the row to expand -> TreePath /@path@/: a tree path that points to the row -> IO Bool __Returns:__ 'False' to allow expansion, 'True' to reject

+ GI.Gtk.Objects.TreeView: type TreeViewTestExpandRowCallback = TreeIter " /@iter@/: the tree iter of the row to expand " -> TreePath " /@path@/: a tree path that points to the row " -> IO Bool " __Returns:__ 'False' to allow expansion, 'True' to reject "

- GI.Gtk.Objects.TreeViewAccessible: TreeViewAccessible :: (ManagedPtr TreeViewAccessible) -> TreeViewAccessible

+ GI.Gtk.Objects.TreeViewAccessible: TreeViewAccessible :: ManagedPtr TreeViewAccessible -> TreeViewAccessible

- GI.Gtk.Objects.TreeViewColumn: TreeViewColumn :: (ManagedPtr TreeViewColumn) -> TreeViewColumn

+ GI.Gtk.Objects.TreeViewColumn: TreeViewColumn :: ManagedPtr TreeViewColumn -> TreeViewColumn

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnAlignment :: (IsTreeViewColumn o) => Float -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnAlignment :: IsTreeViewColumn o => Float -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnClickable :: (IsTreeViewColumn o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnClickable :: IsTreeViewColumn o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnExpand :: (IsTreeViewColumn o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnExpand :: IsTreeViewColumn o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnFixedWidth :: (IsTreeViewColumn o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnFixedWidth :: IsTreeViewColumn o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnMaxWidth :: (IsTreeViewColumn o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnMaxWidth :: IsTreeViewColumn o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnMinWidth :: (IsTreeViewColumn o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnMinWidth :: IsTreeViewColumn o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnReorderable :: (IsTreeViewColumn o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnReorderable :: IsTreeViewColumn o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnResizable :: (IsTreeViewColumn o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnResizable :: IsTreeViewColumn o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnSizing :: (IsTreeViewColumn o) => TreeViewColumnSizing -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnSizing :: IsTreeViewColumn o => TreeViewColumnSizing -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnSortColumnId :: (IsTreeViewColumn o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnSortColumnId :: IsTreeViewColumn o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnSortIndicator :: (IsTreeViewColumn o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnSortIndicator :: IsTreeViewColumn o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnSortOrder :: (IsTreeViewColumn o) => SortType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnSortOrder :: IsTreeViewColumn o => SortType -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnSpacing :: (IsTreeViewColumn o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnSpacing :: IsTreeViewColumn o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnTitle :: (IsTreeViewColumn o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnTitle :: IsTreeViewColumn o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnVisible :: (IsTreeViewColumn o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.TreeViewColumn: constructTreeViewColumnVisible :: IsTreeViewColumn o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.TreeViewColumn: treeViewColumnCellGetPosition :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> m ((Bool, Int32, Int32))

+ GI.Gtk.Objects.TreeViewColumn: treeViewColumnCellGetPosition :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> m (Bool, Int32, Int32)

- GI.Gtk.Objects.TreeViewColumn: treeViewColumnCellGetSize :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Maybe (Rectangle) -> m ((Int32, Int32, Int32, Int32))

+ GI.Gtk.Objects.TreeViewColumn: treeViewColumnCellGetSize :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Maybe Rectangle -> m (Int32, Int32, Int32, Int32)

- GI.Gtk.Objects.TreeViewColumn: treeViewColumnSetCellDataFunc :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> Maybe (TreeCellDataFunc) -> m ()

+ GI.Gtk.Objects.TreeViewColumn: treeViewColumnSetCellDataFunc :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> Maybe TreeCellDataFunc -> m ()

- GI.Gtk.Objects.TreeViewColumn: treeViewColumnSetWidget :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.TreeViewColumn: treeViewColumnSetWidget :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.UIManager: UIManager :: (ManagedPtr UIManager) -> UIManager

+ GI.Gtk.Objects.UIManager: UIManager :: ManagedPtr UIManager -> UIManager

- GI.Gtk.Objects.UIManager: constructUIManagerAddTearoffs :: (IsUIManager o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.UIManager: constructUIManagerAddTearoffs :: IsUIManager o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.UIManager: type UIManagerAddWidgetCallback = Widget /@widget@/: the added widget -> IO ()

+ GI.Gtk.Objects.UIManager: type UIManagerAddWidgetCallback = Widget " /@widget@/: the added widget " -> IO ()

- GI.Gtk.Objects.UIManager: type UIManagerConnectProxyCallback = Action /@action@/: the action -> Widget /@proxy@/: the proxy -> IO ()

+ GI.Gtk.Objects.UIManager: type UIManagerConnectProxyCallback = Action " /@action@/: the action " -> Widget " /@proxy@/: the proxy " -> IO ()

- GI.Gtk.Objects.UIManager: type UIManagerDisconnectProxyCallback = Action /@action@/: the action -> Widget /@proxy@/: the proxy -> IO ()

+ GI.Gtk.Objects.UIManager: type UIManagerDisconnectProxyCallback = Action " /@action@/: the action " -> Widget " /@proxy@/: the proxy " -> IO ()

- GI.Gtk.Objects.UIManager: type UIManagerPostActivateCallback = Action /@action@/: the action -> IO ()

+ GI.Gtk.Objects.UIManager: type UIManagerPostActivateCallback = Action " /@action@/: the action " -> IO ()

- GI.Gtk.Objects.UIManager: type UIManagerPreActivateCallback = Action /@action@/: the action -> IO ()

+ GI.Gtk.Objects.UIManager: type UIManagerPreActivateCallback = Action " /@action@/: the action " -> IO ()

- GI.Gtk.Objects.UIManager: uIManagerAddUi :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Word32 -> Text -> Text -> Maybe (Text) -> [UIManagerItemType] -> Bool -> m ()

+ GI.Gtk.Objects.UIManager: uIManagerAddUi :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Word32 -> Text -> Text -> Maybe Text -> [UIManagerItemType] -> Bool -> m ()

- GI.Gtk.Objects.VBox: VBox :: (ManagedPtr VBox) -> VBox

+ GI.Gtk.Objects.VBox: VBox :: ManagedPtr VBox -> VBox

- GI.Gtk.Objects.VButtonBox: VButtonBox :: (ManagedPtr VButtonBox) -> VButtonBox

+ GI.Gtk.Objects.VButtonBox: VButtonBox :: ManagedPtr VButtonBox -> VButtonBox

- GI.Gtk.Objects.VPaned: VPaned :: (ManagedPtr VPaned) -> VPaned

+ GI.Gtk.Objects.VPaned: VPaned :: ManagedPtr VPaned -> VPaned

- GI.Gtk.Objects.VScale: VScale :: (ManagedPtr VScale) -> VScale

+ GI.Gtk.Objects.VScale: VScale :: ManagedPtr VScale -> VScale

- GI.Gtk.Objects.VScrollbar: VScrollbar :: (ManagedPtr VScrollbar) -> VScrollbar

+ GI.Gtk.Objects.VScrollbar: VScrollbar :: ManagedPtr VScrollbar -> VScrollbar

- GI.Gtk.Objects.VScrollbar: vScrollbarNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe (a) -> m VScrollbar

+ GI.Gtk.Objects.VScrollbar: vScrollbarNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe a -> m VScrollbar

- GI.Gtk.Objects.VSeparator: VSeparator :: (ManagedPtr VSeparator) -> VSeparator

+ GI.Gtk.Objects.VSeparator: VSeparator :: ManagedPtr VSeparator -> VSeparator

- GI.Gtk.Objects.Viewport: Viewport :: (ManagedPtr Viewport) -> Viewport

+ GI.Gtk.Objects.Viewport: Viewport :: ManagedPtr Viewport -> Viewport

- GI.Gtk.Objects.Viewport: constructViewportShadowType :: (IsViewport o) => ShadowType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Viewport: constructViewportShadowType :: IsViewport o => ShadowType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Viewport: viewportNew :: (HasCallStack, MonadIO m, IsAdjustment a, IsAdjustment b) => Maybe (a) -> Maybe (b) -> m Viewport

+ GI.Gtk.Objects.Viewport: viewportNew :: (HasCallStack, MonadIO m, IsAdjustment a, IsAdjustment b) => Maybe a -> Maybe b -> m Viewport

- GI.Gtk.Objects.Viewport: viewportSetHadjustment :: (HasCallStack, MonadIO m, IsViewport a, IsAdjustment b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Viewport: viewportSetHadjustment :: (HasCallStack, MonadIO m, IsViewport a, IsAdjustment b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Viewport: viewportSetVadjustment :: (HasCallStack, MonadIO m, IsViewport a, IsAdjustment b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Viewport: viewportSetVadjustment :: (HasCallStack, MonadIO m, IsViewport a, IsAdjustment b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.VolumeButton: VolumeButton :: (ManagedPtr VolumeButton) -> VolumeButton

+ GI.Gtk.Objects.VolumeButton: VolumeButton :: ManagedPtr VolumeButton -> VolumeButton

- GI.Gtk.Objects.VolumeButton: constructVolumeButtonUseSymbolic :: (IsVolumeButton o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.VolumeButton: constructVolumeButtonUseSymbolic :: IsVolumeButton o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: Widget :: (ManagedPtr Widget) -> Widget

+ GI.Gtk.Objects.Widget: Widget :: ManagedPtr Widget -> Widget

- GI.Gtk.Objects.Widget: constructWidgetAppPaintable :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetAppPaintable :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetCanDefault :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetCanDefault :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetCanFocus :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetCanFocus :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetDoubleBuffered :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetDoubleBuffered :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetEvents :: (IsWidget o) => [EventMask] -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetEvents :: IsWidget o => [EventMask] -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetExpand :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetExpand :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetFocusOnClick :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetFocusOnClick :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetHalign :: (IsWidget o) => Align -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetHalign :: IsWidget o => Align -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetHasDefault :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetHasDefault :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetHasFocus :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetHasFocus :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetHasTooltip :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetHasTooltip :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetHeightRequest :: (IsWidget o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetHeightRequest :: IsWidget o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetHexpand :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetHexpand :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetHexpandSet :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetHexpandSet :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetIsFocus :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetIsFocus :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetMargin :: (IsWidget o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetMargin :: IsWidget o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetMarginBottom :: (IsWidget o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetMarginBottom :: IsWidget o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetMarginEnd :: (IsWidget o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetMarginEnd :: IsWidget o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetMarginLeft :: (IsWidget o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetMarginLeft :: IsWidget o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetMarginRight :: (IsWidget o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetMarginRight :: IsWidget o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetMarginStart :: (IsWidget o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetMarginStart :: IsWidget o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetMarginTop :: (IsWidget o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetMarginTop :: IsWidget o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetName :: (IsWidget o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetName :: IsWidget o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetNoShowAll :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetNoShowAll :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetOpacity :: (IsWidget o) => Double -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetOpacity :: IsWidget o => Double -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetReceivesDefault :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetReceivesDefault :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetSensitive :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetSensitive :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetTooltipMarkup :: (IsWidget o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetTooltipMarkup :: IsWidget o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetTooltipText :: (IsWidget o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetTooltipText :: IsWidget o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetValign :: (IsWidget o) => Align -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetValign :: IsWidget o => Align -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetVexpand :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetVexpand :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetVexpandSet :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetVexpandSet :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetVisible :: (IsWidget o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetVisible :: IsWidget o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: constructWidgetWidthRequest :: (IsWidget o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Widget: constructWidgetWidthRequest :: IsWidget o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Widget: type WidgetButtonPressEventCallback = EventButton /@event@/: the 'GI.Gdk.Structs.EventButton.EventButton' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetButtonPressEventCallback = EventButton " /@event@/: the 'GI.Gdk.Structs.EventButton.EventButton' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetButtonReleaseEventCallback = EventButton /@event@/: the 'GI.Gdk.Structs.EventButton.EventButton' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetButtonReleaseEventCallback = EventButton " /@event@/: the 'GI.Gdk.Structs.EventButton.EventButton' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetCanActivateAccelCallback = Word32 /@signalId@/: the ID of a signal installed on /@widget@/ -> IO Bool __Returns:__ 'True' if the signal can be activated.

+ GI.Gtk.Objects.Widget: type WidgetCanActivateAccelCallback = Word32 " /@signalId@/: the ID of a signal installed on /@widget@/ " -> IO Bool " __Returns:__ 'True' if the signal can be activated. "

- GI.Gtk.Objects.Widget: type WidgetChildNotifyCallback = GParamSpec /@childProperty@/: the 'GI.GObject.Objects.ParamSpec.ParamSpec' of the changed child property -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetChildNotifyCallback = GParamSpec " /@childProperty@/: the 'GI.GObject.Objects.ParamSpec.ParamSpec' of the changed child property " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetConfigureEventCallback = EventConfigure /@event@/: the 'GI.Gdk.Structs.EventConfigure.EventConfigure' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetConfigureEventCallback = EventConfigure " /@event@/: the 'GI.Gdk.Structs.EventConfigure.EventConfigure' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetDamageEventCallback = EventExpose /@event@/: the 'GI.Gdk.Structs.EventExpose.EventExpose' event -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetDamageEventCallback = EventExpose " /@event@/: the 'GI.Gdk.Structs.EventExpose.EventExpose' event " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetDeleteEventCallback = Event /@event@/: the event which triggered this signal -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetDeleteEventCallback = Event " /@event@/: the event which triggered this signal " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetDestroyEventCallback = Event /@event@/: the event which triggered this signal -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetDestroyEventCallback = Event " /@event@/: the event which triggered this signal " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetDirectionChangedCallback = TextDirection /@previousDirection@/: the previous text direction of /@widget@/ -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetDirectionChangedCallback = TextDirection " /@previousDirection@/: the previous text direction of /@widget@/ " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetDragBeginCallback = DragContext /@context@/: the drag context -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetDragBeginCallback = DragContext " /@context@/: the drag context " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetDragDataDeleteCallback = DragContext /@context@/: the drag context -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetDragDataDeleteCallback = DragContext " /@context@/: the drag context " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetDragDataGetCallback = DragContext /@context@/: the drag context -> SelectionData /@data@/: the 'GI.Gtk.Structs.SelectionData.SelectionData' to be filled with the dragged data -> Word32 /@info@/: the info that has been registered with the target in the 'GI.Gtk.Structs.TargetList.TargetList' -> Word32 /@time@/: the timestamp at which the data was requested -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetDragDataGetCallback = DragContext " /@context@/: the drag context " -> SelectionData " /@data@/: the 'GI.Gtk.Structs.SelectionData.SelectionData' to be filled with the dragged data " -> Word32 " /@info@/: the info that has been registered with the target in the 'GI.Gtk.Structs.TargetList.TargetList' " -> Word32 " /@time@/: the timestamp at which the data was requested " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetDragDataReceivedCallback = DragContext /@context@/: the drag context -> Int32 /@x@/: where the drop happened -> Int32 /@y@/: where the drop happened -> SelectionData /@data@/: the received data -> Word32 /@info@/: the info that has been registered with the target in the 'GI.Gtk.Structs.TargetList.TargetList' -> Word32 /@time@/: the timestamp at which the data was received -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetDragDataReceivedCallback = DragContext " /@context@/: the drag context " -> Int32 " /@x@/: where the drop happened " -> Int32 " /@y@/: where the drop happened " -> SelectionData " /@data@/: the received data " -> Word32 " /@info@/: the info that has been registered with the target in the 'GI.Gtk.Structs.TargetList.TargetList' " -> Word32 " /@time@/: the timestamp at which the data was received " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetDragDropCallback = DragContext /@context@/: the drag context -> Int32 /@x@/: the x coordinate of the current cursor position -> Int32 /@y@/: the y coordinate of the current cursor position -> Word32 /@time@/: the timestamp of the motion event -> IO Bool __Returns:__ whether the cursor position is in a drop zone

+ GI.Gtk.Objects.Widget: type WidgetDragDropCallback = DragContext " /@context@/: the drag context " -> Int32 " /@x@/: the x coordinate of the current cursor position " -> Int32 " /@y@/: the y coordinate of the current cursor position " -> Word32 " /@time@/: the timestamp of the motion event " -> IO Bool " __Returns:__ whether the cursor position is in a drop zone "

- GI.Gtk.Objects.Widget: type WidgetDragEndCallback = DragContext /@context@/: the drag context -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetDragEndCallback = DragContext " /@context@/: the drag context " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetDragFailedCallback = DragContext /@context@/: the drag context -> DragResult /@result@/: the result of the drag operation -> IO Bool __Returns:__ 'True' if the failed drag operation has been already handled.

+ GI.Gtk.Objects.Widget: type WidgetDragFailedCallback = DragContext " /@context@/: the drag context " -> DragResult " /@result@/: the result of the drag operation " -> IO Bool " __Returns:__ 'True' if the failed drag operation has been already handled. "

- GI.Gtk.Objects.Widget: type WidgetDragLeaveCallback = DragContext /@context@/: the drag context -> Word32 /@time@/: the timestamp of the motion event -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetDragLeaveCallback = DragContext " /@context@/: the drag context " -> Word32 " /@time@/: the timestamp of the motion event " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetDragMotionCallback = DragContext /@context@/: the drag context -> Int32 /@x@/: the x coordinate of the current cursor position -> Int32 /@y@/: the y coordinate of the current cursor position -> Word32 /@time@/: the timestamp of the motion event -> IO Bool __Returns:__ whether the cursor position is in a drop zone

+ GI.Gtk.Objects.Widget: type WidgetDragMotionCallback = DragContext " /@context@/: the drag context " -> Int32 " /@x@/: the x coordinate of the current cursor position " -> Int32 " /@y@/: the y coordinate of the current cursor position " -> Word32 " /@time@/: the timestamp of the motion event " -> IO Bool " __Returns:__ whether the cursor position is in a drop zone "

- GI.Gtk.Objects.Widget: type WidgetDrawCallback = Context /@cr@/: the cairo context to draw to -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetDrawCallback = Context " /@cr@/: the cairo context to draw to " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetEnterNotifyEventCallback = EventCrossing /@event@/: the 'GI.Gdk.Structs.EventCrossing.EventCrossing' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetEnterNotifyEventCallback = EventCrossing " /@event@/: the 'GI.Gdk.Structs.EventCrossing.EventCrossing' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetEventAfterCallback = Event /@event@/: the 'GI.Gdk.Unions.Event.Event' which triggered this signal -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetEventAfterCallback = Event " /@event@/: the 'GI.Gdk.Unions.Event.Event' which triggered this signal " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetEventCallback = Event /@event@/: the 'GI.Gdk.Unions.Event.Event' which triggered this signal -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event and to cancel the emission of the second specific ::event signal. 'False' to propagate the event further and to allow the emission of the second signal. The ::event-after signal is emitted regardless of the return value.

+ GI.Gtk.Objects.Widget: type WidgetEventCallback = Event " /@event@/: the 'GI.Gdk.Unions.Event.Event' which triggered this signal " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event and to cancel the emission of the second specific ::event signal. 'False' to propagate the event further and to allow the emission of the second signal. The ::event-after signal is emitted regardless of the return value. "

- GI.Gtk.Objects.Widget: type WidgetFocusCallback = DirectionType -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetFocusCallback = DirectionType -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetFocusInEventCallback = EventFocus /@event@/: the 'GI.Gdk.Structs.EventFocus.EventFocus' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetFocusInEventCallback = EventFocus " /@event@/: the 'GI.Gdk.Structs.EventFocus.EventFocus' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetFocusOutEventCallback = EventFocus /@event@/: the 'GI.Gdk.Structs.EventFocus.EventFocus' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetFocusOutEventCallback = EventFocus " /@event@/: the 'GI.Gdk.Structs.EventFocus.EventFocus' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetGrabBrokenEventCallback = EventGrabBroken /@event@/: the 'GI.Gdk.Structs.EventGrabBroken.EventGrabBroken' event -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetGrabBrokenEventCallback = EventGrabBroken " /@event@/: the 'GI.Gdk.Structs.EventGrabBroken.EventGrabBroken' event " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetGrabNotifyCallback = Bool /@wasGrabbed@/: 'False' if the widget becomes shadowed, 'True' if it becomes unshadowed -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetGrabNotifyCallback = Bool " /@wasGrabbed@/: 'False' if the widget becomes shadowed, 'True' if it becomes unshadowed " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetHierarchyChangedCallback = Maybe Widget /@previousToplevel@/: the previous toplevel ancestor, or 'Nothing' if the widget was previously unanchored -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetHierarchyChangedCallback = Maybe Widget " /@previousToplevel@/: the previous toplevel ancestor, or 'Nothing' if the widget was previously unanchored " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetKeyPressEventCallback = EventKey /@event@/: the 'GI.Gdk.Structs.EventKey.EventKey' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetKeyPressEventCallback = EventKey " /@event@/: the 'GI.Gdk.Structs.EventKey.EventKey' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetKeyReleaseEventCallback = EventKey /@event@/: the 'GI.Gdk.Structs.EventKey.EventKey' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetKeyReleaseEventCallback = EventKey " /@event@/: the 'GI.Gdk.Structs.EventKey.EventKey' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetKeynavFailedCallback = DirectionType /@direction@/: the direction of movement -> IO Bool __Returns:__ 'True' if stopping keyboard navigation is fine, 'False' if the emitting widget should try to handle the keyboard navigation attempt in its parent container(s).

+ GI.Gtk.Objects.Widget: type WidgetKeynavFailedCallback = DirectionType " /@direction@/: the direction of movement " -> IO Bool " __Returns:__ 'True' if stopping keyboard navigation is fine, 'False' if the emitting widget should try to handle the keyboard navigation attempt in its parent container(s). "

- GI.Gtk.Objects.Widget: type WidgetLeaveNotifyEventCallback = EventCrossing /@event@/: the 'GI.Gdk.Structs.EventCrossing.EventCrossing' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetLeaveNotifyEventCallback = EventCrossing " /@event@/: the 'GI.Gdk.Structs.EventCrossing.EventCrossing' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetMapEventCallback = EventAny /@event@/: the 'GI.Gdk.Structs.EventAny.EventAny' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetMapEventCallback = EventAny " /@event@/: the 'GI.Gdk.Structs.EventAny.EventAny' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetMnemonicActivateCallback = Bool /@groupCycling@/: 'True' if there are other widgets with the same mnemonic -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetMnemonicActivateCallback = Bool " /@groupCycling@/: 'True' if there are other widgets with the same mnemonic " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetMotionNotifyEventCallback = EventMotion /@event@/: the 'GI.Gdk.Structs.EventMotion.EventMotion' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetMotionNotifyEventCallback = EventMotion " /@event@/: the 'GI.Gdk.Structs.EventMotion.EventMotion' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetParentSetCallback = Maybe Widget /@oldParent@/: the previous parent, or 'Nothing' if the widget just got its initial parent. -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetParentSetCallback = Maybe Widget " /@oldParent@/: the previous parent, or 'Nothing' if the widget just got its initial parent. " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetPopupMenuCallback = IO Bool __Returns:__ 'True' if a menu was activated

+ GI.Gtk.Objects.Widget: type WidgetPopupMenuCallback = IO Bool " __Returns:__ 'True' if a menu was activated "

- GI.Gtk.Objects.Widget: type WidgetPropertyNotifyEventCallback = EventProperty /@event@/: the 'GI.Gdk.Structs.EventProperty.EventProperty' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetPropertyNotifyEventCallback = EventProperty " /@event@/: the 'GI.Gdk.Structs.EventProperty.EventProperty' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetProximityInEventCallback = EventProximity /@event@/: the 'GI.Gdk.Structs.EventProximity.EventProximity' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetProximityInEventCallback = EventProximity " /@event@/: the 'GI.Gdk.Structs.EventProximity.EventProximity' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetProximityOutEventCallback = EventProximity /@event@/: the 'GI.Gdk.Structs.EventProximity.EventProximity' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetProximityOutEventCallback = EventProximity " /@event@/: the 'GI.Gdk.Structs.EventProximity.EventProximity' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetQueryTooltipCallback = Int32 /@x@/: the x coordinate of the cursor position where the request has been emitted, relative to /@widget@/\'s left side -> Int32 /@y@/: the y coordinate of the cursor position where the request has been emitted, relative to /@widget@/\'s top -> Bool /@keyboardMode@/: 'True' if the tooltip was triggered using the keyboard -> Tooltip /@tooltip@/: a 'GI.Gtk.Objects.Tooltip.Tooltip' -> IO Bool __Returns:__ 'True' if /@tooltip@/ should be shown right now, 'False' otherwise.

+ GI.Gtk.Objects.Widget: type WidgetQueryTooltipCallback = Int32 " /@x@/: the x coordinate of the cursor position where the request has been emitted, relative to /@widget@/\'s left side " -> Int32 " /@y@/: the y coordinate of the cursor position where the request has been emitted, relative to /@widget@/\'s top " -> Bool " /@keyboardMode@/: 'True' if the tooltip was triggered using the keyboard " -> Tooltip " /@tooltip@/: a 'GI.Gtk.Objects.Tooltip.Tooltip' " -> IO Bool " __Returns:__ 'True' if /@tooltip@/ should be shown right now, 'False' otherwise. "

- GI.Gtk.Objects.Widget: type WidgetScreenChangedCallback = Maybe Screen /@previousScreen@/: the previous screen, or 'Nothing' if the widget was not associated with a screen before -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetScreenChangedCallback = Maybe Screen " /@previousScreen@/: the previous screen, or 'Nothing' if the widget was not associated with a screen before " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetScrollEventCallback = EventScroll /@event@/: the 'GI.Gdk.Structs.EventScroll.EventScroll' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetScrollEventCallback = EventScroll " /@event@/: the 'GI.Gdk.Structs.EventScroll.EventScroll' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetSelectionClearEventCallback = EventSelection /@event@/: the 'GI.Gdk.Structs.EventSelection.EventSelection' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetSelectionClearEventCallback = EventSelection " /@event@/: the 'GI.Gdk.Structs.EventSelection.EventSelection' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetSelectionNotifyEventCallback = EventSelection -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetSelectionNotifyEventCallback = EventSelection -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetSelectionRequestEventCallback = EventSelection /@event@/: the 'GI.Gdk.Structs.EventSelection.EventSelection' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetSelectionRequestEventCallback = EventSelection " /@event@/: the 'GI.Gdk.Structs.EventSelection.EventSelection' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetShowHelpCallback = WidgetHelpType -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetShowHelpCallback = WidgetHelpType -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetSizeAllocateCallback = Rectangle /@allocation@/: the region which has been allocated to the widget. -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetSizeAllocateCallback = Rectangle " /@allocation@/: the region which has been allocated to the widget. " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetStateChangedCallback = StateType /@state@/: the previous state -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetStateChangedCallback = StateType " /@state@/: the previous state " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetStateFlagsChangedCallback = [StateFlags] /@flags@/: The previous state flags. -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetStateFlagsChangedCallback = [StateFlags] " /@flags@/: The previous state flags. " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetStyleSetCallback = Maybe Style /@previousStyle@/: the previous style, or 'Nothing' if the widget just got its initial style -> IO ()

+ GI.Gtk.Objects.Widget: type WidgetStyleSetCallback = Maybe Style " /@previousStyle@/: the previous style, or 'Nothing' if the widget just got its initial style " -> IO ()

- GI.Gtk.Objects.Widget: type WidgetUnmapEventCallback = EventAny /@event@/: the 'GI.Gdk.Structs.EventAny.EventAny' which triggered this signal -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetUnmapEventCallback = EventAny " /@event@/: the 'GI.Gdk.Structs.EventAny.EventAny' which triggered this signal " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetVisibilityNotifyEventCallback = EventVisibility /@event@/: the 'GI.Gdk.Structs.EventVisibility.EventVisibility' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetVisibilityNotifyEventCallback = EventVisibility " /@event@/: the 'GI.Gdk.Structs.EventVisibility.EventVisibility' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: type WidgetWindowStateEventCallback = EventWindowState /@event@/: the 'GI.Gdk.Structs.EventWindowState.EventWindowState' which triggered this signal. -> IO Bool __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further.

+ GI.Gtk.Objects.Widget: type WidgetWindowStateEventCallback = EventWindowState " /@event@/: the 'GI.Gdk.Structs.EventWindowState.EventWindowState' which triggered this signal. " -> IO Bool " __Returns:__ 'True' to stop other handlers from being invoked for the event. 'False' to propagate the event further. "

- GI.Gtk.Objects.Widget: widgetClassPath :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ((Word32, Text, Text))

+ GI.Gtk.Objects.Widget: widgetClassPath :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Word32, Text, Text)

- GI.Gtk.Objects.Widget: widgetCreatePangoLayout :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe (Text) -> m Layout

+ GI.Gtk.Objects.Widget: widgetCreatePangoLayout :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Text -> m Layout

- GI.Gtk.Objects.Widget: widgetDestroyed :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m (Widget)

+ GI.Gtk.Objects.Widget: widgetDestroyed :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m Widget

- GI.Gtk.Objects.Widget: widgetDragBegin :: (HasCallStack, MonadIO m, IsWidget a) => a -> TargetList -> [DragAction] -> Int32 -> Maybe (Event) -> m DragContext

+ GI.Gtk.Objects.Widget: widgetDragBegin :: (HasCallStack, MonadIO m, IsWidget a) => a -> TargetList -> [DragAction] -> Int32 -> Maybe Event -> m DragContext

- GI.Gtk.Objects.Widget: widgetDragBeginWithCoordinates :: (HasCallStack, MonadIO m, IsWidget a) => a -> TargetList -> [DragAction] -> Int32 -> Maybe (Event) -> Int32 -> Int32 -> m DragContext

+ GI.Gtk.Objects.Widget: widgetDragBeginWithCoordinates :: (HasCallStack, MonadIO m, IsWidget a) => a -> TargetList -> [DragAction] -> Int32 -> Maybe Event -> Int32 -> Int32 -> m DragContext

- GI.Gtk.Objects.Widget: widgetDragDestFindTarget :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => a -> b -> Maybe (TargetList) -> m (Maybe Atom)

+ GI.Gtk.Objects.Widget: widgetDragDestFindTarget :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => a -> b -> Maybe TargetList -> m (Maybe Atom)

- GI.Gtk.Objects.Widget: widgetDragDestSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> [DestDefaults] -> Maybe ([TargetEntry]) -> [DragAction] -> m ()

+ GI.Gtk.Objects.Widget: widgetDragDestSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> [DestDefaults] -> Maybe [TargetEntry] -> [DragAction] -> m ()

- GI.Gtk.Objects.Widget: widgetDragDestSetTargetList :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe (TargetList) -> m ()

+ GI.Gtk.Objects.Widget: widgetDragDestSetTargetList :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe TargetList -> m ()

- GI.Gtk.Objects.Widget: widgetDragSourceSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> [ModifierType] -> Maybe ([TargetEntry]) -> [DragAction] -> m ()

+ GI.Gtk.Objects.Widget: widgetDragSourceSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> [ModifierType] -> Maybe [TargetEntry] -> [DragAction] -> m ()

- GI.Gtk.Objects.Widget: widgetDragSourceSetTargetList :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe (TargetList) -> m ()

+ GI.Gtk.Objects.Widget: widgetDragSourceSetTargetList :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe TargetList -> m ()

- GI.Gtk.Objects.Widget: widgetGetAllocatedSize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ((Rectangle, Int32))

+ GI.Gtk.Objects.Widget: widgetGetAllocatedSize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Rectangle, Int32)

- GI.Gtk.Objects.Widget: widgetGetAllocation :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Rectangle)

+ GI.Gtk.Objects.Widget: widgetGetAllocation :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Rectangle

- GI.Gtk.Objects.Widget: widgetGetChildRequisition :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Requisition)

+ GI.Gtk.Objects.Widget: widgetGetChildRequisition :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Requisition

- GI.Gtk.Objects.Widget: widgetGetClip :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Rectangle)

+ GI.Gtk.Objects.Widget: widgetGetClip :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Rectangle

- GI.Gtk.Objects.Widget: widgetGetPointer :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.Widget: widgetGetPointer :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.Widget: widgetGetPreferredHeight :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.Widget: widgetGetPreferredHeight :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.Widget: widgetGetPreferredHeightAndBaselineForWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ((Int32, Int32, Int32, Int32))

+ GI.Gtk.Objects.Widget: widgetGetPreferredHeightAndBaselineForWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m (Int32, Int32, Int32, Int32)

- GI.Gtk.Objects.Widget: widgetGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.Widget: widgetGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.Widget: widgetGetPreferredSize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ((Requisition, Requisition))

+ GI.Gtk.Objects.Widget: widgetGetPreferredSize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Requisition, Requisition)

- GI.Gtk.Objects.Widget: widgetGetPreferredWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.Widget: widgetGetPreferredWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.Widget: widgetGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ((Int32, Int32))

+ GI.Gtk.Objects.Widget: widgetGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m (Int32, Int32)

- GI.Gtk.Objects.Widget: widgetGetRequisition :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Requisition)

+ GI.Gtk.Objects.Widget: widgetGetRequisition :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Requisition

- GI.Gtk.Objects.Widget: widgetGetSizeRequest :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.Widget: widgetGetSizeRequest :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.Widget: widgetInputShapeCombineRegion :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe (Region) -> m ()

+ GI.Gtk.Objects.Widget: widgetInputShapeCombineRegion :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Region -> m ()

- GI.Gtk.Objects.Widget: widgetInsertActionGroup :: (HasCallStack, MonadIO m, IsWidget a, IsActionGroup b) => a -> Text -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Widget: widgetInsertActionGroup :: (HasCallStack, MonadIO m, IsWidget a, IsActionGroup b) => a -> Text -> Maybe b -> m ()

- GI.Gtk.Objects.Widget: widgetIntersect :: (HasCallStack, MonadIO m, IsWidget a) => a -> Rectangle -> m ((Bool, Maybe Rectangle))

+ GI.Gtk.Objects.Widget: widgetIntersect :: (HasCallStack, MonadIO m, IsWidget a) => a -> Rectangle -> m (Bool, Maybe Rectangle)

- GI.Gtk.Objects.Widget: widgetModifyBase :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe (Color) -> m ()

+ GI.Gtk.Objects.Widget: widgetModifyBase :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe Color -> m ()

- GI.Gtk.Objects.Widget: widgetModifyBg :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe (Color) -> m ()

+ GI.Gtk.Objects.Widget: widgetModifyBg :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe Color -> m ()

- GI.Gtk.Objects.Widget: widgetModifyCursor :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe (Color) -> Maybe (Color) -> m ()

+ GI.Gtk.Objects.Widget: widgetModifyCursor :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Color -> Maybe Color -> m ()

- GI.Gtk.Objects.Widget: widgetModifyFg :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe (Color) -> m ()

+ GI.Gtk.Objects.Widget: widgetModifyFg :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe Color -> m ()

- GI.Gtk.Objects.Widget: widgetModifyFont :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe (FontDescription) -> m ()

+ GI.Gtk.Objects.Widget: widgetModifyFont :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe FontDescription -> m ()

- GI.Gtk.Objects.Widget: widgetModifyText :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe (Color) -> m ()

+ GI.Gtk.Objects.Widget: widgetModifyText :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe Color -> m ()

- GI.Gtk.Objects.Widget: widgetOverrideBackgroundColor :: (HasCallStack, MonadIO m, IsWidget a) => a -> [StateFlags] -> Maybe (RGBA) -> m ()

+ GI.Gtk.Objects.Widget: widgetOverrideBackgroundColor :: (HasCallStack, MonadIO m, IsWidget a) => a -> [StateFlags] -> Maybe RGBA -> m ()

- GI.Gtk.Objects.Widget: widgetOverrideColor :: (HasCallStack, MonadIO m, IsWidget a) => a -> [StateFlags] -> Maybe (RGBA) -> m ()

+ GI.Gtk.Objects.Widget: widgetOverrideColor :: (HasCallStack, MonadIO m, IsWidget a) => a -> [StateFlags] -> Maybe RGBA -> m ()

- GI.Gtk.Objects.Widget: widgetOverrideCursor :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe (RGBA) -> Maybe (RGBA) -> m ()

+ GI.Gtk.Objects.Widget: widgetOverrideCursor :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe RGBA -> Maybe RGBA -> m ()

- GI.Gtk.Objects.Widget: widgetOverrideFont :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe (FontDescription) -> m ()

+ GI.Gtk.Objects.Widget: widgetOverrideFont :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe FontDescription -> m ()

- GI.Gtk.Objects.Widget: widgetOverrideSymbolicColor :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> Maybe (RGBA) -> m ()

+ GI.Gtk.Objects.Widget: widgetOverrideSymbolicColor :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> Maybe RGBA -> m ()

- GI.Gtk.Objects.Widget: widgetPath :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ((Word32, Text, Text))

+ GI.Gtk.Objects.Widget: widgetPath :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Word32, Text, Text)

- GI.Gtk.Objects.Widget: widgetRenderIcon :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> Int32 -> Maybe (Text) -> m (Maybe Pixbuf)

+ GI.Gtk.Objects.Widget: widgetRenderIcon :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> Int32 -> Maybe Text -> m (Maybe Pixbuf)

- GI.Gtk.Objects.Widget: widgetSetAccelPath :: (HasCallStack, MonadIO m, IsWidget a, IsAccelGroup b) => a -> Maybe (Text) -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Widget: widgetSetAccelPath :: (HasCallStack, MonadIO m, IsWidget a, IsAccelGroup b) => a -> Maybe Text -> Maybe b -> m ()

- GI.Gtk.Objects.Widget: widgetSetFontMap :: (HasCallStack, MonadIO m, IsWidget a, IsFontMap b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Widget: widgetSetFontMap :: (HasCallStack, MonadIO m, IsWidget a, IsFontMap b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Widget: widgetSetFontOptions :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe (FontOptions) -> m ()

+ GI.Gtk.Objects.Widget: widgetSetFontOptions :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe FontOptions -> m ()

- GI.Gtk.Objects.Widget: widgetSetStyle :: (HasCallStack, MonadIO m, IsWidget a, IsStyle b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Widget: widgetSetStyle :: (HasCallStack, MonadIO m, IsWidget a, IsStyle b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Widget: widgetSetTooltipMarkup :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Widget: widgetSetTooltipMarkup :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.Widget: widgetSetTooltipText :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Widget: widgetSetTooltipText :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.Widget: widgetSetTooltipWindow :: (HasCallStack, MonadIO m, IsWidget a, IsWindow b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Widget: widgetSetTooltipWindow :: (HasCallStack, MonadIO m, IsWidget a, IsWindow b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Widget: widgetSetVisual :: (HasCallStack, MonadIO m, IsWidget a, IsVisual b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Widget: widgetSetVisual :: (HasCallStack, MonadIO m, IsWidget a, IsVisual b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Widget: widgetShapeCombineRegion :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe (Region) -> m ()

+ GI.Gtk.Objects.Widget: widgetShapeCombineRegion :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Region -> m ()

- GI.Gtk.Objects.Widget: widgetSizeRequest :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Requisition)

+ GI.Gtk.Objects.Widget: widgetSizeRequest :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Requisition

- GI.Gtk.Objects.Widget: widgetTranslateCoordinates :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> Int32 -> Int32 -> m ((Bool, Int32, Int32))

+ GI.Gtk.Objects.Widget: widgetTranslateCoordinates :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> Int32 -> Int32 -> m (Bool, Int32, Int32)

- GI.Gtk.Objects.WidgetAccessible: WidgetAccessible :: (ManagedPtr WidgetAccessible) -> WidgetAccessible

+ GI.Gtk.Objects.WidgetAccessible: WidgetAccessible :: ManagedPtr WidgetAccessible -> WidgetAccessible

- GI.Gtk.Objects.Window: Window :: (ManagedPtr Window) -> Window

+ GI.Gtk.Objects.Window: Window :: ManagedPtr Window -> Window

- GI.Gtk.Objects.Window: constructWindowAcceptFocus :: (IsWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowAcceptFocus :: IsWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowDecorated :: (IsWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowDecorated :: IsWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowDefaultHeight :: (IsWindow o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowDefaultHeight :: IsWindow o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowDefaultWidth :: (IsWindow o) => Int32 -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowDefaultWidth :: IsWindow o => Int32 -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowDeletable :: (IsWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowDeletable :: IsWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowDestroyWithParent :: (IsWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowDestroyWithParent :: IsWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowFocusOnMap :: (IsWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowFocusOnMap :: IsWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowFocusVisible :: (IsWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowFocusVisible :: IsWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowGravity :: (IsWindow o) => Gravity -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowGravity :: IsWindow o => Gravity -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowHasResizeGrip :: (IsWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowHasResizeGrip :: IsWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowHideTitlebarWhenMaximized :: (IsWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowHideTitlebarWhenMaximized :: IsWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowIconName :: (IsWindow o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowIconName :: IsWindow o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowMnemonicsVisible :: (IsWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowMnemonicsVisible :: IsWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowModal :: (IsWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowModal :: IsWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowResizable :: (IsWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowResizable :: IsWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowRole :: (IsWindow o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowRole :: IsWindow o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowSkipPagerHint :: (IsWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowSkipPagerHint :: IsWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowSkipTaskbarHint :: (IsWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowSkipTaskbarHint :: IsWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowStartupId :: (IsWindow o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowStartupId :: IsWindow o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowTitle :: (IsWindow o) => Text -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowTitle :: IsWindow o => Text -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowType :: (IsWindow o) => WindowType -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowType :: IsWindow o => WindowType -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowTypeHint :: (IsWindow o) => WindowTypeHint -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowTypeHint :: IsWindow o => WindowTypeHint -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowUrgencyHint :: (IsWindow o) => Bool -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowUrgencyHint :: IsWindow o => Bool -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: constructWindowWindowPosition :: (IsWindow o) => WindowPosition -> IO (GValueConstruct o)

+ GI.Gtk.Objects.Window: constructWindowWindowPosition :: IsWindow o => WindowPosition -> IO (GValueConstruct o)

- GI.Gtk.Objects.Window: type WindowEnableDebuggingCallback = Bool /@toggle@/: toggle the debugger -> IO Bool __Returns:__ 'True' if the key binding was handled

+ GI.Gtk.Objects.Window: type WindowEnableDebuggingCallback = Bool " /@toggle@/: toggle the debugger " -> IO Bool " __Returns:__ 'True' if the key binding was handled "

- GI.Gtk.Objects.Window: windowGetDefaultSize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.Window: windowGetDefaultSize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.Window: windowGetPosition :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.Window: windowGetPosition :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.Window: windowGetResizeGripArea :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ((Bool, Rectangle))

+ GI.Gtk.Objects.Window: windowGetResizeGripArea :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Bool, Rectangle)

- GI.Gtk.Objects.Window: windowGetSize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ((Int32, Int32))

+ GI.Gtk.Objects.Window: windowGetSize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Int32, Int32)

- GI.Gtk.Objects.Window: windowSetApplication :: (HasCallStack, MonadIO m, IsWindow a, IsApplication b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Window: windowSetApplication :: (HasCallStack, MonadIO m, IsWindow a, IsApplication b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Window: windowSetAttachedTo :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Window: windowSetAttachedTo :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Window: windowSetDefault :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Window: windowSetDefault :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Window: windowSetFocus :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Window: windowSetFocus :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Window: windowSetGeometryHints :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe (b) -> Maybe (Geometry) -> [WindowHints] -> m ()

+ GI.Gtk.Objects.Window: windowSetGeometryHints :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> Maybe Geometry -> [WindowHints] -> m ()

- GI.Gtk.Objects.Window: windowSetIcon :: (HasCallStack, MonadIO m, IsWindow a, IsPixbuf b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Window: windowSetIcon :: (HasCallStack, MonadIO m, IsWindow a, IsPixbuf b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Window: windowSetIconName :: (HasCallStack, MonadIO m, IsWindow a) => a -> Maybe (Text) -> m ()

+ GI.Gtk.Objects.Window: windowSetIconName :: (HasCallStack, MonadIO m, IsWindow a) => a -> Maybe Text -> m ()

- GI.Gtk.Objects.Window: windowSetTitlebar :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Window: windowSetTitlebar :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.Window: windowSetTransientFor :: (HasCallStack, MonadIO m, IsWindow a, IsWindow b) => a -> Maybe (b) -> m ()

+ GI.Gtk.Objects.Window: windowSetTransientFor :: (HasCallStack, MonadIO m, IsWindow a, IsWindow b) => a -> Maybe b -> m ()

- GI.Gtk.Objects.WindowAccessible: WindowAccessible :: (ManagedPtr WindowAccessible) -> WindowAccessible

+ GI.Gtk.Objects.WindowAccessible: WindowAccessible :: ManagedPtr WindowAccessible -> WindowAccessible

- GI.Gtk.Objects.WindowGroup: WindowGroup :: (ManagedPtr WindowGroup) -> WindowGroup

+ GI.Gtk.Objects.WindowGroup: WindowGroup :: ManagedPtr WindowGroup -> WindowGroup

- GI.Gtk.Structs.AccelGroupEntry: AccelGroupEntry :: (ManagedPtr AccelGroupEntry) -> AccelGroupEntry

+ GI.Gtk.Structs.AccelGroupEntry: AccelGroupEntry :: ManagedPtr AccelGroupEntry -> AccelGroupEntry

- GI.Gtk.Structs.AccelKey: AccelKey :: (ManagedPtr AccelKey) -> AccelKey

+ GI.Gtk.Structs.AccelKey: AccelKey :: ManagedPtr AccelKey -> AccelKey

- GI.Gtk.Structs.ActionEntry: ActionEntry :: (ManagedPtr ActionEntry) -> ActionEntry

+ GI.Gtk.Structs.ActionEntry: ActionEntry :: ManagedPtr ActionEntry -> ActionEntry

- GI.Gtk.Structs.BindingArg: BindingArg :: (ManagedPtr BindingArg) -> BindingArg

+ GI.Gtk.Structs.BindingArg: BindingArg :: ManagedPtr BindingArg -> BindingArg

- GI.Gtk.Structs.BindingEntry: BindingEntry :: (ManagedPtr BindingEntry) -> BindingEntry

+ GI.Gtk.Structs.BindingEntry: BindingEntry :: ManagedPtr BindingEntry -> BindingEntry

- GI.Gtk.Structs.BindingSet: BindingSet :: (ManagedPtr BindingSet) -> BindingSet

+ GI.Gtk.Structs.BindingSet: BindingSet :: ManagedPtr BindingSet -> BindingSet

- GI.Gtk.Structs.BindingSet: getBindingSetClassBranchPspecs :: MonadIO m => BindingSet -> m ([Ptr ()])

+ GI.Gtk.Structs.BindingSet: getBindingSetClassBranchPspecs :: MonadIO m => BindingSet -> m [Ptr ()]

- GI.Gtk.Structs.BindingSet: getBindingSetWidgetClassPspecs :: MonadIO m => BindingSet -> m ([Ptr ()])

+ GI.Gtk.Structs.BindingSet: getBindingSetWidgetClassPspecs :: MonadIO m => BindingSet -> m [Ptr ()]

- GI.Gtk.Structs.BindingSet: getBindingSetWidgetPathPspecs :: MonadIO m => BindingSet -> m ([Ptr ()])

+ GI.Gtk.Structs.BindingSet: getBindingSetWidgetPathPspecs :: MonadIO m => BindingSet -> m [Ptr ()]

- GI.Gtk.Structs.BindingSignal: BindingSignal :: (ManagedPtr BindingSignal) -> BindingSignal

+ GI.Gtk.Structs.BindingSignal: BindingSignal :: ManagedPtr BindingSignal -> BindingSignal

- GI.Gtk.Structs.Border: Border :: (ManagedPtr Border) -> Border

+ GI.Gtk.Structs.Border: Border :: ManagedPtr Border -> Border

- GI.Gtk.Structs.CssSection: CssSection :: (ManagedPtr CssSection) -> CssSection

+ GI.Gtk.Structs.CssSection: CssSection :: ManagedPtr CssSection -> CssSection

- GI.Gtk.Structs.FileFilterInfo: FileFilterInfo :: (ManagedPtr FileFilterInfo) -> FileFilterInfo

+ GI.Gtk.Structs.FileFilterInfo: FileFilterInfo :: ManagedPtr FileFilterInfo -> FileFilterInfo

- GI.Gtk.Structs.FixedChild: FixedChild :: (ManagedPtr FixedChild) -> FixedChild

+ GI.Gtk.Structs.FixedChild: FixedChild :: ManagedPtr FixedChild -> FixedChild

- GI.Gtk.Structs.Gradient: Gradient :: (ManagedPtr Gradient) -> Gradient

+ GI.Gtk.Structs.Gradient: Gradient :: ManagedPtr Gradient -> Gradient

- GI.Gtk.Structs.Gradient: gradientResolve :: (HasCallStack, MonadIO m, IsStyleProperties a) => Gradient -> a -> m ((Bool, Pattern))

+ GI.Gtk.Structs.Gradient: gradientResolve :: (HasCallStack, MonadIO m, IsStyleProperties a) => Gradient -> a -> m (Bool, Pattern)

- GI.Gtk.Structs.IMContextInfo: IMContextInfo :: (ManagedPtr IMContextInfo) -> IMContextInfo

+ GI.Gtk.Structs.IMContextInfo: IMContextInfo :: ManagedPtr IMContextInfo -> IMContextInfo

- GI.Gtk.Structs.IconSet: IconSet :: (ManagedPtr IconSet) -> IconSet

+ GI.Gtk.Structs.IconSet: IconSet :: ManagedPtr IconSet -> IconSet

- GI.Gtk.Structs.IconSet: iconSetGetSizes :: (HasCallStack, MonadIO m) => IconSet -> m ([Int32])

+ GI.Gtk.Structs.IconSet: iconSetGetSizes :: (HasCallStack, MonadIO m) => IconSet -> m [Int32]

- GI.Gtk.Structs.IconSet: iconSetRenderIcon :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => IconSet -> Maybe (a) -> TextDirection -> StateType -> Int32 -> Maybe (b) -> Maybe (Text) -> m Pixbuf

+ GI.Gtk.Structs.IconSet: iconSetRenderIcon :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => IconSet -> Maybe a -> TextDirection -> StateType -> Int32 -> Maybe b -> Maybe Text -> m Pixbuf

- GI.Gtk.Structs.IconSet: iconSetRenderIconSurface :: (HasCallStack, MonadIO m, IsStyleContext a, IsWindow b) => IconSet -> a -> Int32 -> Int32 -> Maybe (b) -> m Surface

+ GI.Gtk.Structs.IconSet: iconSetRenderIconSurface :: (HasCallStack, MonadIO m, IsStyleContext a, IsWindow b) => IconSet -> a -> Int32 -> Int32 -> Maybe b -> m Surface

- GI.Gtk.Structs.IconSource: IconSource :: (ManagedPtr IconSource) -> IconSource

+ GI.Gtk.Structs.IconSource: IconSource :: ManagedPtr IconSource -> IconSource

- GI.Gtk.Structs.IconSource: iconSourceSetIconName :: (HasCallStack, MonadIO m) => IconSource -> Maybe (Text) -> m ()

+ GI.Gtk.Structs.IconSource: iconSourceSetIconName :: (HasCallStack, MonadIO m) => IconSource -> Maybe Text -> m ()

- GI.Gtk.Structs.LabelSelectionInfo: LabelSelectionInfo :: (ManagedPtr LabelSelectionInfo) -> LabelSelectionInfo

+ GI.Gtk.Structs.LabelSelectionInfo: LabelSelectionInfo :: ManagedPtr LabelSelectionInfo -> LabelSelectionInfo

- GI.Gtk.Structs.PadActionEntry: PadActionEntry :: (ManagedPtr PadActionEntry) -> PadActionEntry

+ GI.Gtk.Structs.PadActionEntry: PadActionEntry :: ManagedPtr PadActionEntry -> PadActionEntry

- GI.Gtk.Structs.PageRange: PageRange :: (ManagedPtr PageRange) -> PageRange

+ GI.Gtk.Structs.PageRange: PageRange :: ManagedPtr PageRange -> PageRange

- GI.Gtk.Structs.PaperSize: PaperSize :: (ManagedPtr PaperSize) -> PaperSize

+ GI.Gtk.Structs.PaperSize: PaperSize :: ManagedPtr PaperSize -> PaperSize

- GI.Gtk.Structs.PaperSize: paperSizeNew :: (HasCallStack, MonadIO m) => Maybe (Text) -> m PaperSize

+ GI.Gtk.Structs.PaperSize: paperSizeNew :: (HasCallStack, MonadIO m) => Maybe Text -> m PaperSize

- GI.Gtk.Structs.RadioActionEntry: RadioActionEntry :: (ManagedPtr RadioActionEntry) -> RadioActionEntry

+ GI.Gtk.Structs.RadioActionEntry: RadioActionEntry :: ManagedPtr RadioActionEntry -> RadioActionEntry

- GI.Gtk.Structs.RcContext: RcContext :: (ManagedPtr RcContext) -> RcContext

+ GI.Gtk.Structs.RcContext: RcContext :: ManagedPtr RcContext -> RcContext

- GI.Gtk.Structs.RcProperty: RcProperty :: (ManagedPtr RcProperty) -> RcProperty

+ GI.Gtk.Structs.RcProperty: RcProperty :: ManagedPtr RcProperty -> RcProperty

- GI.Gtk.Structs.RecentData: RecentData :: (ManagedPtr RecentData) -> RecentData

+ GI.Gtk.Structs.RecentData: RecentData :: ManagedPtr RecentData -> RecentData

- GI.Gtk.Structs.RecentFilterInfo: RecentFilterInfo :: (ManagedPtr RecentFilterInfo) -> RecentFilterInfo

+ GI.Gtk.Structs.RecentFilterInfo: RecentFilterInfo :: ManagedPtr RecentFilterInfo -> RecentFilterInfo

- GI.Gtk.Structs.RecentInfo: RecentInfo :: (ManagedPtr RecentInfo) -> RecentInfo

+ GI.Gtk.Structs.RecentInfo: RecentInfo :: ManagedPtr RecentInfo -> RecentInfo

- GI.Gtk.Structs.RecentInfo: recentInfoCreateAppInfo :: (HasCallStack, MonadIO m) => RecentInfo -> Maybe (Text) -> m (Maybe AppInfo)

+ GI.Gtk.Structs.RecentInfo: recentInfoCreateAppInfo :: (HasCallStack, MonadIO m) => RecentInfo -> Maybe Text -> m (Maybe AppInfo)

- GI.Gtk.Structs.RecentInfo: recentInfoGetApplicationInfo :: (HasCallStack, MonadIO m) => RecentInfo -> Text -> m ((Bool, Text, Word32, CLong))

+ GI.Gtk.Structs.RecentInfo: recentInfoGetApplicationInfo :: (HasCallStack, MonadIO m) => RecentInfo -> Text -> m (Bool, Text, Word32, CLong)

- GI.Gtk.Structs.RecentInfo: recentInfoGetApplications :: (HasCallStack, MonadIO m) => RecentInfo -> m (([Text], Word64))

+ GI.Gtk.Structs.RecentInfo: recentInfoGetApplications :: (HasCallStack, MonadIO m) => RecentInfo -> m ([Text], Word64)

- GI.Gtk.Structs.RecentInfo: recentInfoGetGroups :: (HasCallStack, MonadIO m) => RecentInfo -> m (([Text], Word64))

+ GI.Gtk.Structs.RecentInfo: recentInfoGetGroups :: (HasCallStack, MonadIO m) => RecentInfo -> m ([Text], Word64)

- GI.Gtk.Structs.RequestedSize: RequestedSize :: (ManagedPtr RequestedSize) -> RequestedSize

+ GI.Gtk.Structs.RequestedSize: RequestedSize :: ManagedPtr RequestedSize -> RequestedSize

- GI.Gtk.Structs.Requisition: Requisition :: (ManagedPtr Requisition) -> Requisition

+ GI.Gtk.Structs.Requisition: Requisition :: ManagedPtr Requisition -> Requisition

- GI.Gtk.Structs.SelectionData: SelectionData :: (ManagedPtr SelectionData) -> SelectionData

+ GI.Gtk.Structs.SelectionData: SelectionData :: ManagedPtr SelectionData -> SelectionData

- GI.Gtk.Structs.SelectionData: selectionDataGetTargets :: (HasCallStack, MonadIO m) => SelectionData -> m ((Bool, [Atom]))

+ GI.Gtk.Structs.SelectionData: selectionDataGetTargets :: (HasCallStack, MonadIO m) => SelectionData -> m (Bool, [Atom])

- GI.Gtk.Structs.SettingsValue: SettingsValue :: (ManagedPtr SettingsValue) -> SettingsValue

+ GI.Gtk.Structs.SettingsValue: SettingsValue :: ManagedPtr SettingsValue -> SettingsValue

- GI.Gtk.Structs.StockItem: StockItem :: (ManagedPtr StockItem) -> StockItem

+ GI.Gtk.Structs.StockItem: StockItem :: ManagedPtr StockItem -> StockItem

- GI.Gtk.Structs.SymbolicColor: SymbolicColor :: (ManagedPtr SymbolicColor) -> SymbolicColor

+ GI.Gtk.Structs.SymbolicColor: SymbolicColor :: ManagedPtr SymbolicColor -> SymbolicColor

- GI.Gtk.Structs.SymbolicColor: symbolicColorResolve :: (HasCallStack, MonadIO m, IsStyleProperties a) => SymbolicColor -> Maybe (a) -> m ((Bool, RGBA))

+ GI.Gtk.Structs.SymbolicColor: symbolicColorResolve :: (HasCallStack, MonadIO m, IsStyleProperties a) => SymbolicColor -> Maybe a -> m (Bool, RGBA)

- GI.Gtk.Structs.TableChild: TableChild :: (ManagedPtr TableChild) -> TableChild

+ GI.Gtk.Structs.TableChild: TableChild :: ManagedPtr TableChild -> TableChild

- GI.Gtk.Structs.TableRowCol: TableRowCol :: (ManagedPtr TableRowCol) -> TableRowCol

+ GI.Gtk.Structs.TableRowCol: TableRowCol :: ManagedPtr TableRowCol -> TableRowCol

- GI.Gtk.Structs.TargetEntry: TargetEntry :: (ManagedPtr TargetEntry) -> TargetEntry

+ GI.Gtk.Structs.TargetEntry: TargetEntry :: ManagedPtr TargetEntry -> TargetEntry

- GI.Gtk.Structs.TargetList: TargetList :: (ManagedPtr TargetList) -> TargetList

+ GI.Gtk.Structs.TargetList: TargetList :: ManagedPtr TargetList -> TargetList

- GI.Gtk.Structs.TargetList: targetListFind :: (HasCallStack, MonadIO m) => TargetList -> Atom -> m ((Bool, Word32))

+ GI.Gtk.Structs.TargetList: targetListFind :: (HasCallStack, MonadIO m) => TargetList -> Atom -> m (Bool, Word32)

- GI.Gtk.Structs.TargetList: targetListNew :: (HasCallStack, MonadIO m) => Maybe ([TargetEntry]) -> m TargetList

+ GI.Gtk.Structs.TargetList: targetListNew :: (HasCallStack, MonadIO m) => Maybe [TargetEntry] -> m TargetList

- GI.Gtk.Structs.TargetPair: TargetPair :: (ManagedPtr TargetPair) -> TargetPair

+ GI.Gtk.Structs.TargetPair: TargetPair :: ManagedPtr TargetPair -> TargetPair

- GI.Gtk.Structs.TextAppearance: TextAppearance :: (ManagedPtr TextAppearance) -> TextAppearance

+ GI.Gtk.Structs.TextAppearance: TextAppearance :: ManagedPtr TextAppearance -> TextAppearance

- GI.Gtk.Structs.TextAttributes: TextAttributes :: (ManagedPtr TextAttributes) -> TextAttributes

+ GI.Gtk.Structs.TextAttributes: TextAttributes :: ManagedPtr TextAttributes -> TextAttributes

- GI.Gtk.Structs.TextBTree: TextBTree :: (ManagedPtr TextBTree) -> TextBTree

+ GI.Gtk.Structs.TextBTree: TextBTree :: ManagedPtr TextBTree -> TextBTree

- GI.Gtk.Structs.TextIter: TextIter :: (ManagedPtr TextIter) -> TextIter

+ GI.Gtk.Structs.TextIter: TextIter :: ManagedPtr TextIter -> TextIter

- GI.Gtk.Structs.TextIter: textIterBackwardFindChar :: (HasCallStack, MonadIO m) => TextIter -> TextCharPredicate -> Maybe (TextIter) -> m Bool

+ GI.Gtk.Structs.TextIter: textIterBackwardFindChar :: (HasCallStack, MonadIO m) => TextIter -> TextCharPredicate -> Maybe TextIter -> m Bool

- GI.Gtk.Structs.TextIter: textIterBackwardSearch :: (HasCallStack, MonadIO m) => TextIter -> Text -> [TextSearchFlags] -> Maybe (TextIter) -> m ((Bool, TextIter, TextIter))

+ GI.Gtk.Structs.TextIter: textIterBackwardSearch :: (HasCallStack, MonadIO m) => TextIter -> Text -> [TextSearchFlags] -> Maybe TextIter -> m (Bool, TextIter, TextIter)

- GI.Gtk.Structs.TextIter: textIterBackwardToTagToggle :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe (a) -> m Bool

+ GI.Gtk.Structs.TextIter: textIterBackwardToTagToggle :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

- GI.Gtk.Structs.TextIter: textIterBeginsTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe (a) -> m Bool

+ GI.Gtk.Structs.TextIter: textIterBeginsTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

- GI.Gtk.Structs.TextIter: textIterEndsTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe (a) -> m Bool

+ GI.Gtk.Structs.TextIter: textIterEndsTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

- GI.Gtk.Structs.TextIter: textIterForwardFindChar :: (HasCallStack, MonadIO m) => TextIter -> TextCharPredicate -> Maybe (TextIter) -> m Bool

+ GI.Gtk.Structs.TextIter: textIterForwardFindChar :: (HasCallStack, MonadIO m) => TextIter -> TextCharPredicate -> Maybe TextIter -> m Bool

- GI.Gtk.Structs.TextIter: textIterForwardSearch :: (HasCallStack, MonadIO m) => TextIter -> Text -> [TextSearchFlags] -> Maybe (TextIter) -> m ((Bool, TextIter, TextIter))

+ GI.Gtk.Structs.TextIter: textIterForwardSearch :: (HasCallStack, MonadIO m) => TextIter -> Text -> [TextSearchFlags] -> Maybe TextIter -> m (Bool, TextIter, TextIter)

- GI.Gtk.Structs.TextIter: textIterForwardToTagToggle :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe (a) -> m Bool

+ GI.Gtk.Structs.TextIter: textIterForwardToTagToggle :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

- GI.Gtk.Structs.TextIter: textIterGetAttributes :: (HasCallStack, MonadIO m) => TextIter -> m ((Bool, TextAttributes))

+ GI.Gtk.Structs.TextIter: textIterGetAttributes :: (HasCallStack, MonadIO m) => TextIter -> m (Bool, TextAttributes)

- GI.Gtk.Structs.TextIter: textIterStartsTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe (a) -> m Bool

+ GI.Gtk.Structs.TextIter: textIterStartsTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

- GI.Gtk.Structs.TextIter: textIterTogglesTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe (a) -> m Bool

+ GI.Gtk.Structs.TextIter: textIterTogglesTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

- GI.Gtk.Structs.ThemeEngine: ThemeEngine :: (ManagedPtr ThemeEngine) -> ThemeEngine

+ GI.Gtk.Structs.ThemeEngine: ThemeEngine :: ManagedPtr ThemeEngine -> ThemeEngine

- GI.Gtk.Structs.ToggleActionEntry: ToggleActionEntry :: (ManagedPtr ToggleActionEntry) -> ToggleActionEntry

+ GI.Gtk.Structs.ToggleActionEntry: ToggleActionEntry :: ManagedPtr ToggleActionEntry -> ToggleActionEntry

- GI.Gtk.Structs.TreeIter: TreeIter :: (ManagedPtr TreeIter) -> TreeIter

+ GI.Gtk.Structs.TreeIter: TreeIter :: ManagedPtr TreeIter -> TreeIter

- GI.Gtk.Structs.TreePath: TreePath :: (ManagedPtr TreePath) -> TreePath

+ GI.Gtk.Structs.TreePath: TreePath :: ManagedPtr TreePath -> TreePath

- GI.Gtk.Structs.TreeRowReference: TreeRowReference :: (ManagedPtr TreeRowReference) -> TreeRowReference

+ GI.Gtk.Structs.TreeRowReference: TreeRowReference :: ManagedPtr TreeRowReference -> TreeRowReference

- GI.Gtk.Structs.WidgetPath: WidgetPath :: (ManagedPtr WidgetPath) -> WidgetPath

+ GI.Gtk.Structs.WidgetPath: WidgetPath :: ManagedPtr WidgetPath -> WidgetPath

- GI.Gtk.Structs.WidgetPath: widgetPathIterHasQregion :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Word32 -> m ((Bool, [RegionFlags]))

+ GI.Gtk.Structs.WidgetPath: widgetPathIterHasQregion :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Word32 -> m (Bool, [RegionFlags])

- GI.Gtk.Structs.WidgetPath: widgetPathIterHasRegion :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m ((Bool, [RegionFlags]))

+ GI.Gtk.Structs.WidgetPath: widgetPathIterHasRegion :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m (Bool, [RegionFlags])

- GI.Gtk.Structs.WidgetPath: widgetPathIterSetObjectName :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Maybe (Text) -> m ()

+ GI.Gtk.Structs.WidgetPath: widgetPathIterSetObjectName :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Maybe Text -> m ()

- GI.Gtk.Structs.WindowGeometryInfo: WindowGeometryInfo :: (ManagedPtr WindowGeometryInfo) -> WindowGeometryInfo

+ GI.Gtk.Structs.WindowGeometryInfo: WindowGeometryInfo :: ManagedPtr WindowGeometryInfo -> WindowGeometryInfo

Files

ChangeLog.md +4/−0
Gtk.overrides +3/−0
LICENSE +14/−0
README.md +1/−1
gi-gtk.cabal +1/−1

ChangeLog.md view

@@ -1,3 +1,7 @@+### 3.0.26+++ Make sure that the @data@ argument of [CellLayoutDataFunc](https://hackage.haskell.org/package/gi-gtk/docs/GI-Gtk-Callbacks.html#t:CellLayoutDataFunc) is properly anotated as a closure argument.+ ### 3.0.25  + Update stack version to 12.10

Gtk.overrides view

@@ -18,6 +18,9 @@ # https://github.com/haskell-gi/haskell-gi/issues/104 set-attr Gtk/Builder/add_callback_symbol/@parameters/callback_symbol scope notified +# Not properly annotated in older versions of gtk+set-attr Gtk/CellLayoutDataFunc/@parameters/data closure 4+ # Missing nullable return annotation, see # https://github.com/haskell-gi/haskell-gi/issues/192 set-attr Gtk/TreePath/get_indices_with_depth/@return-value nullable 1

LICENSE view

@@ -1,3 +1,17 @@+The gi-gtk library and included works are provided under the terms of the+GNU Library General Public License (LGPL) version 2.1 with the following+exception:++Static linking of applications or any other source to the gi-gtk library+does not constitute a modified or derivative work and does not require+the author(s) to provide source code for said work, to link against the+shared gi-gtk libraries, or to link their applications against a+user-supplied version of gi-gtk. If you link applications to a modified+version of gi-gtk, then the changes to gi-gtk must be provided under the+terms of the LGPL.++----------------------------------------------------------------------------+                   GNU LESSER GENERAL PUBLIC LICENSE                        Version 2.1, February 1999

README.md view

@@ -1,6 +1,6 @@ # Documentation Autogenerated documentation for this package can be found at -[https://hackage.haskell.org/package/gi-gtk-3.0.25/docs/GI-Gtk.html](https://hackage.haskell.org/package/gi-gtk-3.0.25/docs/GI-Gtk.html)+[https://hackage.haskell.org/package/gi-gtk-3.0.26/docs/GI-Gtk.html](https://hackage.haskell.org/package/gi-gtk-3.0.26/docs/GI-Gtk.html)  For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki).

gi-gtk.cabal view

@@ -1,5 +1,5 @@ name:                 gi-gtk-version:              3.0.25+version:              3.0.26 synopsis:             Gtk bindings description:          Bindings for Gtk, autogenerated by haskell-gi. homepage:             https://github.com/haskell-gi/haskell-gi