{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A combined button and dropdown widget.
-- 
-- @AdwSplitButton@ is typically used to present a set of actions in a menu,
-- but allow access to one of them with a single click.
-- 
-- The API is very similar to t'GI.Gtk.Objects.Button.Button' and t'GI.Gtk.Objects.MenuButton.MenuButton', see
-- their documentation for details.
-- 
-- == CSS nodes
-- 
-- >splitbutton[.image-button][.text-button]
-- >├── button
-- >│   ╰── <content>
-- >├── separator
-- >╰── menubutton
-- >    ╰── button.toggle
-- >        ╰── arrow
-- 
-- 
-- @AdwSplitButton@\'s CSS node is called @splitbutton@. It contains the css
-- nodes: @button@, @separator@, @menubutton@. See t'GI.Gtk.Objects.MenuButton.MenuButton'
-- documentation for the @menubutton@ contents.
-- 
-- The main CSS node will contain the @.image-button@ or @.text-button@ style
-- classes matching the button contents. The nested button nodes will never
-- contain them.
-- 
-- == Accessibility
-- 
-- @AdwSplitButton@ uses the @GTK_ACCESSIBLE_ROLE_BUTTON@ role.
-- 
-- /Since: 1.0/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Adw.Objects.SplitButton
    ( 

-- * Exported types
    SplitButton(..)                         ,
    IsSplitButton                           ,
    toSplitButton                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [popdown]("GI.Adw.Objects.SplitButton#g:method:popdown"), [popup]("GI.Adw.Objects.SplitButton#g:method:popup"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getActionName]("GI.Gtk.Interfaces.Actionable#g:method:getActionName"), [getActionTargetValue]("GI.Gtk.Interfaces.Actionable#g:method:getActionTargetValue"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChild]("GI.Adw.Objects.SplitButton#g:method:getChild"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Adw.Objects.SplitButton#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getIconName]("GI.Adw.Objects.SplitButton#g:method:getIconName"), [getLabel]("GI.Adw.Objects.SplitButton#g:method:getLabel"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getMenuModel]("GI.Adw.Objects.SplitButton#g:method:getMenuModel"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPopover]("GI.Adw.Objects.SplitButton#g:method:getPopover"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getUseUnderline]("GI.Adw.Objects.SplitButton#g:method:getUseUnderline"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
-- 
-- ==== Setters
-- [setActionName]("GI.Gtk.Interfaces.Actionable#g:method:setActionName"), [setActionTargetValue]("GI.Gtk.Interfaces.Actionable#g:method:setActionTargetValue"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChild]("GI.Adw.Objects.SplitButton#g:method:setChild"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDetailedActionName]("GI.Gtk.Interfaces.Actionable#g:method:setDetailedActionName"), [setDirection]("GI.Adw.Objects.SplitButton#g:method:setDirection"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setIconName]("GI.Adw.Objects.SplitButton#g:method:setIconName"), [setLabel]("GI.Adw.Objects.SplitButton#g:method:setLabel"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setMenuModel]("GI.Adw.Objects.SplitButton#g:method:setMenuModel"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setPopover]("GI.Adw.Objects.SplitButton#g:method:setPopover"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setUseUnderline]("GI.Adw.Objects.SplitButton#g:method:setUseUnderline"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible").

#if defined(ENABLE_OVERLOADING)
    ResolveSplitButtonMethod                ,
#endif

-- ** getChild #method:getChild#

#if defined(ENABLE_OVERLOADING)
    SplitButtonGetChildMethodInfo           ,
#endif
    splitButtonGetChild                     ,


-- ** getDirection #method:getDirection#

#if defined(ENABLE_OVERLOADING)
    SplitButtonGetDirectionMethodInfo       ,
#endif
    splitButtonGetDirection                 ,


-- ** getIconName #method:getIconName#

#if defined(ENABLE_OVERLOADING)
    SplitButtonGetIconNameMethodInfo        ,
#endif
    splitButtonGetIconName                  ,


-- ** getLabel #method:getLabel#

#if defined(ENABLE_OVERLOADING)
    SplitButtonGetLabelMethodInfo           ,
#endif
    splitButtonGetLabel                     ,


-- ** getMenuModel #method:getMenuModel#

#if defined(ENABLE_OVERLOADING)
    SplitButtonGetMenuModelMethodInfo       ,
#endif
    splitButtonGetMenuModel                 ,


-- ** getPopover #method:getPopover#

#if defined(ENABLE_OVERLOADING)
    SplitButtonGetPopoverMethodInfo         ,
#endif
    splitButtonGetPopover                   ,


-- ** getUseUnderline #method:getUseUnderline#

#if defined(ENABLE_OVERLOADING)
    SplitButtonGetUseUnderlineMethodInfo    ,
#endif
    splitButtonGetUseUnderline              ,


-- ** new #method:new#

    splitButtonNew                          ,


-- ** popdown #method:popdown#

#if defined(ENABLE_OVERLOADING)
    SplitButtonPopdownMethodInfo            ,
#endif
    splitButtonPopdown                      ,


-- ** popup #method:popup#

#if defined(ENABLE_OVERLOADING)
    SplitButtonPopupMethodInfo              ,
#endif
    splitButtonPopup                        ,


-- ** setChild #method:setChild#

#if defined(ENABLE_OVERLOADING)
    SplitButtonSetChildMethodInfo           ,
#endif
    splitButtonSetChild                     ,


-- ** setDirection #method:setDirection#

#if defined(ENABLE_OVERLOADING)
    SplitButtonSetDirectionMethodInfo       ,
#endif
    splitButtonSetDirection                 ,


-- ** setIconName #method:setIconName#

#if defined(ENABLE_OVERLOADING)
    SplitButtonSetIconNameMethodInfo        ,
#endif
    splitButtonSetIconName                  ,


-- ** setLabel #method:setLabel#

#if defined(ENABLE_OVERLOADING)
    SplitButtonSetLabelMethodInfo           ,
#endif
    splitButtonSetLabel                     ,


-- ** setMenuModel #method:setMenuModel#

#if defined(ENABLE_OVERLOADING)
    SplitButtonSetMenuModelMethodInfo       ,
#endif
    splitButtonSetMenuModel                 ,


-- ** setPopover #method:setPopover#

#if defined(ENABLE_OVERLOADING)
    SplitButtonSetPopoverMethodInfo         ,
#endif
    splitButtonSetPopover                   ,


-- ** setUseUnderline #method:setUseUnderline#

#if defined(ENABLE_OVERLOADING)
    SplitButtonSetUseUnderlineMethodInfo    ,
#endif
    splitButtonSetUseUnderline              ,




 -- * Properties


-- ** child #attr:child#
-- | The child widget.
-- 
-- Setting the child widget will set [SplitButton:label]("GI.Adw.Objects.SplitButton#g:attr:label") and
-- [SplitButton:iconName]("GI.Adw.Objects.SplitButton#g:attr:iconName") to @NULL@.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SplitButtonChildPropertyInfo            ,
#endif
    clearSplitButtonChild                   ,
    constructSplitButtonChild               ,
    getSplitButtonChild                     ,
    setSplitButtonChild                     ,
#if defined(ENABLE_OVERLOADING)
    splitButtonChild                        ,
#endif


-- ** direction #attr:direction#
-- | The direction in which the popup will be popped up.
-- 
-- The dropdown arrow icon will point at the same direction.
-- 
-- If the does not fit in the available space in the given direction,
-- GTK will its best to keep it inside the screen and fully visible.
-- 
-- If you pass @GTK_ARROW_NONE@, it\'s equivalent to @GTK_ARROW_DOWN@.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SplitButtonDirectionPropertyInfo        ,
#endif
    constructSplitButtonDirection           ,
    getSplitButtonDirection                 ,
    setSplitButtonDirection                 ,
#if defined(ENABLE_OVERLOADING)
    splitButtonDirection                    ,
#endif


-- ** iconName #attr:iconName#
-- | The name of the icon used to automatically populate the button.
-- 
-- Setting the icon name will set [SplitButton:label]("GI.Adw.Objects.SplitButton#g:attr:label") and
-- [SplitButton:child]("GI.Adw.Objects.SplitButton#g:attr:child") to @NULL@.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SplitButtonIconNamePropertyInfo         ,
#endif
    constructSplitButtonIconName            ,
    getSplitButtonIconName                  ,
    setSplitButtonIconName                  ,
#if defined(ENABLE_OVERLOADING)
    splitButtonIconName                     ,
#endif


-- ** label #attr:label#
-- | The label for the button.
-- 
-- Setting the label will set [SplitButton:iconName]("GI.Adw.Objects.SplitButton#g:attr:iconName") and
-- [SplitButton:child]("GI.Adw.Objects.SplitButton#g:attr:child") to @NULL@.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SplitButtonLabelPropertyInfo            ,
#endif
    constructSplitButtonLabel               ,
    getSplitButtonLabel                     ,
    setSplitButtonLabel                     ,
#if defined(ENABLE_OVERLOADING)
    splitButtonLabel                        ,
#endif


-- ** menuModel #attr:menuModel#
-- | The @GMenuModel@ from which the popup will be created.
-- 
-- If the menu model is @NULL@, the dropdown is disabled.
-- 
-- A t'GI.Gtk.Objects.Popover.Popover' will be created from the menu model with
-- 'GI.Gtk.Objects.PopoverMenu.popoverMenuNewFromModel'. Actions will be connected
-- as documented for this function.
-- 
-- If [SplitButton:popover]("GI.Adw.Objects.SplitButton#g:attr:popover") is already set, it will be
-- dissociated from the button, and the property is set to @NULL@.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SplitButtonMenuModelPropertyInfo        ,
#endif
    clearSplitButtonMenuModel               ,
    constructSplitButtonMenuModel           ,
    getSplitButtonMenuModel                 ,
    setSplitButtonMenuModel                 ,
#if defined(ENABLE_OVERLOADING)
    splitButtonMenuModel                    ,
#endif


-- ** popover #attr:popover#
-- | The @GtkPopover@ that will be popped up when the dropdown is clicked.
-- 
-- If the popover is @NULL@, the dropdown is disabled.
-- 
-- If [SplitButton:menuModel]("GI.Adw.Objects.SplitButton#g:attr:menuModel") is set, the menu model is
-- dissociated from the button, and the property is set to @NULL@.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SplitButtonPopoverPropertyInfo          ,
#endif
    clearSplitButtonPopover                 ,
    constructSplitButtonPopover             ,
    getSplitButtonPopover                   ,
    setSplitButtonPopover                   ,
#if defined(ENABLE_OVERLOADING)
    splitButtonPopover                      ,
#endif


-- ** useUnderline #attr:useUnderline#
-- | Whether an underline in the text indicates a mnemonic.
-- 
-- See [SplitButton:label]("GI.Adw.Objects.SplitButton#g:attr:label").
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SplitButtonUseUnderlinePropertyInfo     ,
#endif
    constructSplitButtonUseUnderline        ,
    getSplitButtonUseUnderline              ,
    setSplitButtonUseUnderline              ,
#if defined(ENABLE_OVERLOADING)
    splitButtonUseUnderline                 ,
#endif




 -- * Signals


-- ** activate #signal:activate#

    SplitButtonActivateCallback             ,
#if defined(ENABLE_OVERLOADING)
    SplitButtonActivateSignalInfo           ,
#endif
    afterSplitButtonActivate                ,
    onSplitButtonActivate                   ,


-- ** clicked #signal:clicked#

    SplitButtonClickedCallback              ,
#if defined(ENABLE_OVERLOADING)
    SplitButtonClickedSignalInfo            ,
#endif
    afterSplitButtonClicked                 ,
    onSplitButtonClicked                    ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
import qualified GI.Gtk.Enums as Gtk.Enums
import qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import qualified GI.Gtk.Interfaces.Actionable as Gtk.Actionable
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import qualified GI.Gtk.Objects.Popover as Gtk.Popover
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

-- | Memory-managed wrapper type.
newtype SplitButton = SplitButton (SP.ManagedPtr SplitButton)
    deriving (SplitButton -> SplitButton -> Bool
(SplitButton -> SplitButton -> Bool)
-> (SplitButton -> SplitButton -> Bool) -> Eq SplitButton
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SplitButton -> SplitButton -> Bool
$c/= :: SplitButton -> SplitButton -> Bool
== :: SplitButton -> SplitButton -> Bool
$c== :: SplitButton -> SplitButton -> Bool
Eq)

instance SP.ManagedPtrNewtype SplitButton where
    toManagedPtr :: SplitButton -> ManagedPtr SplitButton
toManagedPtr (SplitButton ManagedPtr SplitButton
p) = ManagedPtr SplitButton
p

foreign import ccall "adw_split_button_get_type"
    c_adw_split_button_get_type :: IO B.Types.GType

instance B.Types.TypedObject SplitButton where
    glibType :: IO GType
glibType = IO GType
c_adw_split_button_get_type

instance B.Types.GObject SplitButton

-- | Type class for types which can be safely cast to `SplitButton`, for instance with `toSplitButton`.
class (SP.GObject o, O.IsDescendantOf SplitButton o) => IsSplitButton o
instance (SP.GObject o, O.IsDescendantOf SplitButton o) => IsSplitButton o

instance O.HasParentTypes SplitButton
type instance O.ParentTypes SplitButton = '[Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.Actionable.Actionable, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget]

-- | Cast to `SplitButton`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toSplitButton :: (MIO.MonadIO m, IsSplitButton o) => o -> m SplitButton
toSplitButton :: forall (m :: * -> *) o.
(MonadIO m, IsSplitButton o) =>
o -> m SplitButton
toSplitButton = IO SplitButton -> m SplitButton
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO SplitButton -> m SplitButton)
-> (o -> IO SplitButton) -> o -> m SplitButton
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr SplitButton -> SplitButton) -> o -> IO SplitButton
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr SplitButton -> SplitButton
SplitButton

-- | Convert 'SplitButton' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe SplitButton) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_adw_split_button_get_type
    gvalueSet_ :: Ptr GValue -> Maybe SplitButton -> IO ()
gvalueSet_ Ptr GValue
gv Maybe SplitButton
P.Nothing = Ptr GValue -> Ptr SplitButton -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr SplitButton
forall a. Ptr a
FP.nullPtr :: FP.Ptr SplitButton)
    gvalueSet_ Ptr GValue
gv (P.Just SplitButton
obj) = SplitButton -> (Ptr SplitButton -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SplitButton
obj (Ptr GValue -> Ptr SplitButton -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe SplitButton)
gvalueGet_ Ptr GValue
gv = do
        Ptr SplitButton
ptr <- Ptr GValue -> IO (Ptr SplitButton)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr SplitButton)
        if Ptr SplitButton
ptr Ptr SplitButton -> Ptr SplitButton -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr SplitButton
forall a. Ptr a
FP.nullPtr
        then SplitButton -> Maybe SplitButton
forall a. a -> Maybe a
P.Just (SplitButton -> Maybe SplitButton)
-> IO SplitButton -> IO (Maybe SplitButton)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr SplitButton -> SplitButton)
-> Ptr SplitButton -> IO SplitButton
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr SplitButton -> SplitButton
SplitButton Ptr SplitButton
ptr
        else Maybe SplitButton -> IO (Maybe SplitButton)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SplitButton
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveSplitButtonMethod (t :: Symbol) (o :: *) :: * where
    ResolveSplitButtonMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveSplitButtonMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveSplitButtonMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveSplitButtonMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveSplitButtonMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveSplitButtonMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveSplitButtonMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveSplitButtonMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveSplitButtonMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveSplitButtonMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveSplitButtonMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveSplitButtonMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveSplitButtonMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveSplitButtonMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveSplitButtonMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveSplitButtonMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveSplitButtonMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveSplitButtonMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveSplitButtonMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveSplitButtonMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveSplitButtonMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveSplitButtonMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveSplitButtonMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveSplitButtonMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveSplitButtonMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveSplitButtonMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveSplitButtonMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveSplitButtonMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveSplitButtonMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveSplitButtonMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveSplitButtonMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveSplitButtonMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveSplitButtonMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveSplitButtonMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveSplitButtonMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveSplitButtonMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveSplitButtonMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveSplitButtonMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveSplitButtonMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveSplitButtonMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveSplitButtonMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveSplitButtonMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveSplitButtonMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveSplitButtonMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveSplitButtonMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveSplitButtonMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveSplitButtonMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveSplitButtonMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveSplitButtonMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveSplitButtonMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveSplitButtonMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveSplitButtonMethod "popdown" o = SplitButtonPopdownMethodInfo
    ResolveSplitButtonMethod "popup" o = SplitButtonPopupMethodInfo
    ResolveSplitButtonMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveSplitButtonMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveSplitButtonMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveSplitButtonMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveSplitButtonMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveSplitButtonMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveSplitButtonMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveSplitButtonMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveSplitButtonMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveSplitButtonMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveSplitButtonMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveSplitButtonMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveSplitButtonMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveSplitButtonMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveSplitButtonMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveSplitButtonMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveSplitButtonMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveSplitButtonMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveSplitButtonMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveSplitButtonMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveSplitButtonMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveSplitButtonMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveSplitButtonMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveSplitButtonMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveSplitButtonMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveSplitButtonMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveSplitButtonMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveSplitButtonMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveSplitButtonMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveSplitButtonMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveSplitButtonMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveSplitButtonMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveSplitButtonMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveSplitButtonMethod "getActionName" o = Gtk.Actionable.ActionableGetActionNameMethodInfo
    ResolveSplitButtonMethod "getActionTargetValue" o = Gtk.Actionable.ActionableGetActionTargetValueMethodInfo
    ResolveSplitButtonMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveSplitButtonMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveSplitButtonMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveSplitButtonMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveSplitButtonMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveSplitButtonMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveSplitButtonMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveSplitButtonMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveSplitButtonMethod "getChild" o = SplitButtonGetChildMethodInfo
    ResolveSplitButtonMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveSplitButtonMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveSplitButtonMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveSplitButtonMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveSplitButtonMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveSplitButtonMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveSplitButtonMethod "getDirection" o = SplitButtonGetDirectionMethodInfo
    ResolveSplitButtonMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveSplitButtonMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveSplitButtonMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveSplitButtonMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveSplitButtonMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveSplitButtonMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveSplitButtonMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveSplitButtonMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveSplitButtonMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveSplitButtonMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveSplitButtonMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveSplitButtonMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveSplitButtonMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveSplitButtonMethod "getIconName" o = SplitButtonGetIconNameMethodInfo
    ResolveSplitButtonMethod "getLabel" o = SplitButtonGetLabelMethodInfo
    ResolveSplitButtonMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveSplitButtonMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveSplitButtonMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveSplitButtonMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveSplitButtonMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveSplitButtonMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveSplitButtonMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveSplitButtonMethod "getMenuModel" o = SplitButtonGetMenuModelMethodInfo
    ResolveSplitButtonMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveSplitButtonMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveSplitButtonMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveSplitButtonMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveSplitButtonMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveSplitButtonMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveSplitButtonMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveSplitButtonMethod "getPopover" o = SplitButtonGetPopoverMethodInfo
    ResolveSplitButtonMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveSplitButtonMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveSplitButtonMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveSplitButtonMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveSplitButtonMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveSplitButtonMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveSplitButtonMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveSplitButtonMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveSplitButtonMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveSplitButtonMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveSplitButtonMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveSplitButtonMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveSplitButtonMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveSplitButtonMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveSplitButtonMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveSplitButtonMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveSplitButtonMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveSplitButtonMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveSplitButtonMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveSplitButtonMethod "getUseUnderline" o = SplitButtonGetUseUnderlineMethodInfo
    ResolveSplitButtonMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveSplitButtonMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveSplitButtonMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveSplitButtonMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveSplitButtonMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveSplitButtonMethod "setActionName" o = Gtk.Actionable.ActionableSetActionNameMethodInfo
    ResolveSplitButtonMethod "setActionTargetValue" o = Gtk.Actionable.ActionableSetActionTargetValueMethodInfo
    ResolveSplitButtonMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveSplitButtonMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveSplitButtonMethod "setChild" o = SplitButtonSetChildMethodInfo
    ResolveSplitButtonMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveSplitButtonMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveSplitButtonMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveSplitButtonMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveSplitButtonMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveSplitButtonMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveSplitButtonMethod "setDetailedActionName" o = Gtk.Actionable.ActionableSetDetailedActionNameMethodInfo
    ResolveSplitButtonMethod "setDirection" o = SplitButtonSetDirectionMethodInfo
    ResolveSplitButtonMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveSplitButtonMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveSplitButtonMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveSplitButtonMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveSplitButtonMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveSplitButtonMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveSplitButtonMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveSplitButtonMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveSplitButtonMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveSplitButtonMethod "setIconName" o = SplitButtonSetIconNameMethodInfo
    ResolveSplitButtonMethod "setLabel" o = SplitButtonSetLabelMethodInfo
    ResolveSplitButtonMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveSplitButtonMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveSplitButtonMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveSplitButtonMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveSplitButtonMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveSplitButtonMethod "setMenuModel" o = SplitButtonSetMenuModelMethodInfo
    ResolveSplitButtonMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveSplitButtonMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveSplitButtonMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveSplitButtonMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveSplitButtonMethod "setPopover" o = SplitButtonSetPopoverMethodInfo
    ResolveSplitButtonMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveSplitButtonMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveSplitButtonMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveSplitButtonMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveSplitButtonMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveSplitButtonMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveSplitButtonMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveSplitButtonMethod "setUseUnderline" o = SplitButtonSetUseUnderlineMethodInfo
    ResolveSplitButtonMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveSplitButtonMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveSplitButtonMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveSplitButtonMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveSplitButtonMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveSplitButtonMethod t SplitButton, O.OverloadedMethod info SplitButton p) => OL.IsLabel t (SplitButton -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveSplitButtonMethod t SplitButton, O.OverloadedMethod info SplitButton p, R.HasField t SplitButton p) => R.HasField t SplitButton p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveSplitButtonMethod t SplitButton, O.OverloadedMethodInfo info SplitButton) => OL.IsLabel t (O.MethodProxy info SplitButton) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal SplitButton::activate
-- | Emitted to animate press then release.
-- 
-- This is an action signal. Applications should never connect
-- to this signal, but use the [SplitButton::clicked]("GI.Adw.Objects.SplitButton#g:signal:clicked") signal.
-- 
-- /Since: 1.0/
type SplitButtonActivateCallback =
    IO ()

type C_SplitButtonActivateCallback =
    Ptr SplitButton ->                      -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_SplitButtonActivateCallback`.
foreign import ccall "wrapper"
    mk_SplitButtonActivateCallback :: C_SplitButtonActivateCallback -> IO (FunPtr C_SplitButtonActivateCallback)

wrap_SplitButtonActivateCallback :: 
    GObject a => (a -> SplitButtonActivateCallback) ->
    C_SplitButtonActivateCallback
wrap_SplitButtonActivateCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_SplitButtonActivateCallback
wrap_SplitButtonActivateCallback a -> IO ()
gi'cb Ptr SplitButton
gi'selfPtr Ptr ()
_ = do
    Ptr SplitButton -> (SplitButton -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr SplitButton
gi'selfPtr ((SplitButton -> IO ()) -> IO ())
-> (SplitButton -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SplitButton
gi'self -> a -> IO ()
gi'cb (SplitButton -> a
Coerce.coerce SplitButton
gi'self) 


-- | Connect a signal handler for the [activate](#signal:activate) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' splitButton #activate callback
-- @
-- 
-- 
onSplitButtonActivate :: (IsSplitButton a, MonadIO m) => a -> ((?self :: a) => SplitButtonActivateCallback) -> m SignalHandlerId
onSplitButtonActivate :: forall a (m :: * -> *).
(IsSplitButton a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onSplitButtonActivate a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_SplitButtonActivateCallback
wrapped' = (a -> IO ()) -> C_SplitButtonActivateCallback
forall a.
GObject a =>
(a -> IO ()) -> C_SplitButtonActivateCallback
wrap_SplitButtonActivateCallback a -> IO ()
wrapped
    FunPtr C_SplitButtonActivateCallback
wrapped'' <- C_SplitButtonActivateCallback
-> IO (FunPtr C_SplitButtonActivateCallback)
mk_SplitButtonActivateCallback C_SplitButtonActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_SplitButtonActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate" FunPtr C_SplitButtonActivateCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [activate](#signal:activate) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' splitButton #activate callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterSplitButtonActivate :: (IsSplitButton a, MonadIO m) => a -> ((?self :: a) => SplitButtonActivateCallback) -> m SignalHandlerId
afterSplitButtonActivate :: forall a (m :: * -> *).
(IsSplitButton a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterSplitButtonActivate a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_SplitButtonActivateCallback
wrapped' = (a -> IO ()) -> C_SplitButtonActivateCallback
forall a.
GObject a =>
(a -> IO ()) -> C_SplitButtonActivateCallback
wrap_SplitButtonActivateCallback a -> IO ()
wrapped
    FunPtr C_SplitButtonActivateCallback
wrapped'' <- C_SplitButtonActivateCallback
-> IO (FunPtr C_SplitButtonActivateCallback)
mk_SplitButtonActivateCallback C_SplitButtonActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_SplitButtonActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate" FunPtr C_SplitButtonActivateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data SplitButtonActivateSignalInfo
instance SignalInfo SplitButtonActivateSignalInfo where
    type HaskellCallbackType SplitButtonActivateSignalInfo = SplitButtonActivateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SplitButtonActivateCallback cb
        cb'' <- mk_SplitButtonActivateCallback cb'
        connectSignalFunPtr obj "activate" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton::activate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#g:signal:activate"})

#endif

-- signal SplitButton::clicked
-- | Emitted when the button has been activated (pressed and released).
-- 
-- /Since: 1.0/
type SplitButtonClickedCallback =
    IO ()

type C_SplitButtonClickedCallback =
    Ptr SplitButton ->                      -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_SplitButtonClickedCallback`.
foreign import ccall "wrapper"
    mk_SplitButtonClickedCallback :: C_SplitButtonClickedCallback -> IO (FunPtr C_SplitButtonClickedCallback)

wrap_SplitButtonClickedCallback :: 
    GObject a => (a -> SplitButtonClickedCallback) ->
    C_SplitButtonClickedCallback
wrap_SplitButtonClickedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_SplitButtonActivateCallback
wrap_SplitButtonClickedCallback a -> IO ()
gi'cb Ptr SplitButton
gi'selfPtr Ptr ()
_ = do
    Ptr SplitButton -> (SplitButton -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr SplitButton
gi'selfPtr ((SplitButton -> IO ()) -> IO ())
-> (SplitButton -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SplitButton
gi'self -> a -> IO ()
gi'cb (SplitButton -> a
Coerce.coerce SplitButton
gi'self) 


-- | Connect a signal handler for the [clicked](#signal:clicked) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' splitButton #clicked callback
-- @
-- 
-- 
onSplitButtonClicked :: (IsSplitButton a, MonadIO m) => a -> ((?self :: a) => SplitButtonClickedCallback) -> m SignalHandlerId
onSplitButtonClicked :: forall a (m :: * -> *).
(IsSplitButton a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onSplitButtonClicked a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_SplitButtonActivateCallback
wrapped' = (a -> IO ()) -> C_SplitButtonActivateCallback
forall a.
GObject a =>
(a -> IO ()) -> C_SplitButtonActivateCallback
wrap_SplitButtonClickedCallback a -> IO ()
wrapped
    FunPtr C_SplitButtonActivateCallback
wrapped'' <- C_SplitButtonActivateCallback
-> IO (FunPtr C_SplitButtonActivateCallback)
mk_SplitButtonClickedCallback C_SplitButtonActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_SplitButtonActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"clicked" FunPtr C_SplitButtonActivateCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [clicked](#signal:clicked) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' splitButton #clicked callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterSplitButtonClicked :: (IsSplitButton a, MonadIO m) => a -> ((?self :: a) => SplitButtonClickedCallback) -> m SignalHandlerId
afterSplitButtonClicked :: forall a (m :: * -> *).
(IsSplitButton a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterSplitButtonClicked a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_SplitButtonActivateCallback
wrapped' = (a -> IO ()) -> C_SplitButtonActivateCallback
forall a.
GObject a =>
(a -> IO ()) -> C_SplitButtonActivateCallback
wrap_SplitButtonClickedCallback a -> IO ()
wrapped
    FunPtr C_SplitButtonActivateCallback
wrapped'' <- C_SplitButtonActivateCallback
-> IO (FunPtr C_SplitButtonActivateCallback)
mk_SplitButtonClickedCallback C_SplitButtonActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_SplitButtonActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"clicked" FunPtr C_SplitButtonActivateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data SplitButtonClickedSignalInfo
instance SignalInfo SplitButtonClickedSignalInfo where
    type HaskellCallbackType SplitButtonClickedSignalInfo = SplitButtonClickedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SplitButtonClickedCallback cb
        cb'' <- mk_SplitButtonClickedCallback cb'
        connectSignalFunPtr obj "clicked" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton::clicked"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#g:signal:clicked"})

#endif

-- VVV Prop "child"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@child@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' splitButton #child
-- @
getSplitButtonChild :: (MonadIO m, IsSplitButton o) => o -> m (Maybe Gtk.Widget.Widget)
getSplitButtonChild :: forall (m :: * -> *) o.
(MonadIO m, IsSplitButton o) =>
o -> m (Maybe Widget)
getSplitButtonChild o
obj = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Widget -> Widget) -> IO (Maybe Widget)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"child" ManagedPtr Widget -> Widget
Gtk.Widget.Widget

-- | Set the value of the “@child@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' splitButton [ #child 'Data.GI.Base.Attributes.:=' value ]
-- @
setSplitButtonChild :: (MonadIO m, IsSplitButton o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setSplitButtonChild :: forall (m :: * -> *) o a.
(MonadIO m, IsSplitButton o, IsWidget a) =>
o -> a -> m ()
setSplitButtonChild o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"child" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@child@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSplitButtonChild :: (IsSplitButton o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructSplitButtonChild :: forall o (m :: * -> *) a.
(IsSplitButton o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructSplitButtonChild a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"child" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@child@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #child
-- @
clearSplitButtonChild :: (MonadIO m, IsSplitButton o) => o -> m ()
clearSplitButtonChild :: forall (m :: * -> *) o. (MonadIO m, IsSplitButton o) => o -> m ()
clearSplitButtonChild o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"child" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data SplitButtonChildPropertyInfo
instance AttrInfo SplitButtonChildPropertyInfo where
    type AttrAllowedOps SplitButtonChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SplitButtonChildPropertyInfo = IsSplitButton
    type AttrSetTypeConstraint SplitButtonChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint SplitButtonChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType SplitButtonChildPropertyInfo = Gtk.Widget.Widget
    type AttrGetType SplitButtonChildPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel SplitButtonChildPropertyInfo = "child"
    type AttrOrigin SplitButtonChildPropertyInfo = SplitButton
    attrGet = getSplitButtonChild
    attrSet = setSplitButtonChild
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructSplitButtonChild
    attrClear = clearSplitButtonChild
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.child"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#g:attr:child"
        })
#endif

-- VVV Prop "direction"
   -- Type: TInterface (Name {namespace = "Gtk", name = "ArrowType"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@direction@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' splitButton #direction
-- @
getSplitButtonDirection :: (MonadIO m, IsSplitButton o) => o -> m Gtk.Enums.ArrowType
getSplitButtonDirection :: forall (m :: * -> *) o.
(MonadIO m, IsSplitButton o) =>
o -> m ArrowType
getSplitButtonDirection o
obj = IO ArrowType -> m ArrowType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ArrowType -> m ArrowType) -> IO ArrowType -> m ArrowType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO ArrowType
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"direction"

-- | Set the value of the “@direction@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' splitButton [ #direction 'Data.GI.Base.Attributes.:=' value ]
-- @
setSplitButtonDirection :: (MonadIO m, IsSplitButton o) => o -> Gtk.Enums.ArrowType -> m ()
setSplitButtonDirection :: forall (m :: * -> *) o.
(MonadIO m, IsSplitButton o) =>
o -> ArrowType -> m ()
setSplitButtonDirection o
obj ArrowType
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ArrowType -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"direction" ArrowType
val

-- | Construct a `GValueConstruct` with valid value for the “@direction@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSplitButtonDirection :: (IsSplitButton o, MIO.MonadIO m) => Gtk.Enums.ArrowType -> m (GValueConstruct o)
constructSplitButtonDirection :: forall o (m :: * -> *).
(IsSplitButton o, MonadIO m) =>
ArrowType -> m (GValueConstruct o)
constructSplitButtonDirection ArrowType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> ArrowType -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"direction" ArrowType
val

#if defined(ENABLE_OVERLOADING)
data SplitButtonDirectionPropertyInfo
instance AttrInfo SplitButtonDirectionPropertyInfo where
    type AttrAllowedOps SplitButtonDirectionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SplitButtonDirectionPropertyInfo = IsSplitButton
    type AttrSetTypeConstraint SplitButtonDirectionPropertyInfo = (~) Gtk.Enums.ArrowType
    type AttrTransferTypeConstraint SplitButtonDirectionPropertyInfo = (~) Gtk.Enums.ArrowType
    type AttrTransferType SplitButtonDirectionPropertyInfo = Gtk.Enums.ArrowType
    type AttrGetType SplitButtonDirectionPropertyInfo = Gtk.Enums.ArrowType
    type AttrLabel SplitButtonDirectionPropertyInfo = "direction"
    type AttrOrigin SplitButtonDirectionPropertyInfo = SplitButton
    attrGet = getSplitButtonDirection
    attrSet = setSplitButtonDirection
    attrTransfer _ v = do
        return v
    attrConstruct = constructSplitButtonDirection
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.direction"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#g:attr:direction"
        })
#endif

-- VVV Prop "icon-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just False)

-- | Get the value of the “@icon-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' splitButton #iconName
-- @
getSplitButtonIconName :: (MonadIO m, IsSplitButton o) => o -> m (Maybe T.Text)
getSplitButtonIconName :: forall (m :: * -> *) o.
(MonadIO m, IsSplitButton o) =>
o -> m (Maybe Text)
getSplitButtonIconName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"icon-name"

-- | Set the value of the “@icon-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' splitButton [ #iconName 'Data.GI.Base.Attributes.:=' value ]
-- @
setSplitButtonIconName :: (MonadIO m, IsSplitButton o) => o -> T.Text -> m ()
setSplitButtonIconName :: forall (m :: * -> *) o.
(MonadIO m, IsSplitButton o) =>
o -> Text -> m ()
setSplitButtonIconName o
obj Text
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"icon-name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@icon-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSplitButtonIconName :: (IsSplitButton o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructSplitButtonIconName :: forall o (m :: * -> *).
(IsSplitButton o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructSplitButtonIconName Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"icon-name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data SplitButtonIconNamePropertyInfo
instance AttrInfo SplitButtonIconNamePropertyInfo where
    type AttrAllowedOps SplitButtonIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SplitButtonIconNamePropertyInfo = IsSplitButton
    type AttrSetTypeConstraint SplitButtonIconNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint SplitButtonIconNamePropertyInfo = (~) T.Text
    type AttrTransferType SplitButtonIconNamePropertyInfo = T.Text
    type AttrGetType SplitButtonIconNamePropertyInfo = (Maybe T.Text)
    type AttrLabel SplitButtonIconNamePropertyInfo = "icon-name"
    type AttrOrigin SplitButtonIconNamePropertyInfo = SplitButton
    attrGet = getSplitButtonIconName
    attrSet = setSplitButtonIconName
    attrTransfer _ v = do
        return v
    attrConstruct = constructSplitButtonIconName
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.iconName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#g:attr:iconName"
        })
#endif

-- VVV Prop "label"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just False)

-- | Get the value of the “@label@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' splitButton #label
-- @
getSplitButtonLabel :: (MonadIO m, IsSplitButton o) => o -> m (Maybe T.Text)
getSplitButtonLabel :: forall (m :: * -> *) o.
(MonadIO m, IsSplitButton o) =>
o -> m (Maybe Text)
getSplitButtonLabel o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"label"

-- | Set the value of the “@label@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' splitButton [ #label 'Data.GI.Base.Attributes.:=' value ]
-- @
setSplitButtonLabel :: (MonadIO m, IsSplitButton o) => o -> T.Text -> m ()
setSplitButtonLabel :: forall (m :: * -> *) o.
(MonadIO m, IsSplitButton o) =>
o -> Text -> m ()
setSplitButtonLabel o
obj Text
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"label" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@label@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSplitButtonLabel :: (IsSplitButton o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructSplitButtonLabel :: forall o (m :: * -> *).
(IsSplitButton o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructSplitButtonLabel Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"label" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data SplitButtonLabelPropertyInfo
instance AttrInfo SplitButtonLabelPropertyInfo where
    type AttrAllowedOps SplitButtonLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SplitButtonLabelPropertyInfo = IsSplitButton
    type AttrSetTypeConstraint SplitButtonLabelPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint SplitButtonLabelPropertyInfo = (~) T.Text
    type AttrTransferType SplitButtonLabelPropertyInfo = T.Text
    type AttrGetType SplitButtonLabelPropertyInfo = (Maybe T.Text)
    type AttrLabel SplitButtonLabelPropertyInfo = "label"
    type AttrOrigin SplitButtonLabelPropertyInfo = SplitButton
    attrGet = getSplitButtonLabel
    attrSet = setSplitButtonLabel
    attrTransfer _ v = do
        return v
    attrConstruct = constructSplitButtonLabel
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.label"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#g:attr:label"
        })
#endif

-- VVV Prop "menu-model"
   -- Type: TInterface (Name {namespace = "Gio", name = "MenuModel"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@menu-model@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' splitButton #menuModel
-- @
getSplitButtonMenuModel :: (MonadIO m, IsSplitButton o) => o -> m (Maybe Gio.MenuModel.MenuModel)
getSplitButtonMenuModel :: forall (m :: * -> *) o.
(MonadIO m, IsSplitButton o) =>
o -> m (Maybe MenuModel)
getSplitButtonMenuModel o
obj = IO (Maybe MenuModel) -> m (Maybe MenuModel)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe MenuModel) -> m (Maybe MenuModel))
-> IO (Maybe MenuModel) -> m (Maybe MenuModel)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr MenuModel -> MenuModel)
-> IO (Maybe MenuModel)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"menu-model" ManagedPtr MenuModel -> MenuModel
Gio.MenuModel.MenuModel

-- | Set the value of the “@menu-model@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' splitButton [ #menuModel 'Data.GI.Base.Attributes.:=' value ]
-- @
setSplitButtonMenuModel :: (MonadIO m, IsSplitButton o, Gio.MenuModel.IsMenuModel a) => o -> a -> m ()
setSplitButtonMenuModel :: forall (m :: * -> *) o a.
(MonadIO m, IsSplitButton o, IsMenuModel a) =>
o -> a -> m ()
setSplitButtonMenuModel o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"menu-model" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@menu-model@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSplitButtonMenuModel :: (IsSplitButton o, MIO.MonadIO m, Gio.MenuModel.IsMenuModel a) => a -> m (GValueConstruct o)
constructSplitButtonMenuModel :: forall o (m :: * -> *) a.
(IsSplitButton o, MonadIO m, IsMenuModel a) =>
a -> m (GValueConstruct o)
constructSplitButtonMenuModel a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"menu-model" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@menu-model@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #menuModel
-- @
clearSplitButtonMenuModel :: (MonadIO m, IsSplitButton o) => o -> m ()
clearSplitButtonMenuModel :: forall (m :: * -> *) o. (MonadIO m, IsSplitButton o) => o -> m ()
clearSplitButtonMenuModel o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe MenuModel -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"menu-model" (Maybe MenuModel
forall a. Maybe a
Nothing :: Maybe Gio.MenuModel.MenuModel)

#if defined(ENABLE_OVERLOADING)
data SplitButtonMenuModelPropertyInfo
instance AttrInfo SplitButtonMenuModelPropertyInfo where
    type AttrAllowedOps SplitButtonMenuModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SplitButtonMenuModelPropertyInfo = IsSplitButton
    type AttrSetTypeConstraint SplitButtonMenuModelPropertyInfo = Gio.MenuModel.IsMenuModel
    type AttrTransferTypeConstraint SplitButtonMenuModelPropertyInfo = Gio.MenuModel.IsMenuModel
    type AttrTransferType SplitButtonMenuModelPropertyInfo = Gio.MenuModel.MenuModel
    type AttrGetType SplitButtonMenuModelPropertyInfo = (Maybe Gio.MenuModel.MenuModel)
    type AttrLabel SplitButtonMenuModelPropertyInfo = "menu-model"
    type AttrOrigin SplitButtonMenuModelPropertyInfo = SplitButton
    attrGet = getSplitButtonMenuModel
    attrSet = setSplitButtonMenuModel
    attrTransfer _ v = do
        unsafeCastTo Gio.MenuModel.MenuModel v
    attrConstruct = constructSplitButtonMenuModel
    attrClear = clearSplitButtonMenuModel
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.menuModel"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#g:attr:menuModel"
        })
#endif

-- VVV Prop "popover"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Popover"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@popover@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' splitButton #popover
-- @
getSplitButtonPopover :: (MonadIO m, IsSplitButton o) => o -> m (Maybe Gtk.Popover.Popover)
getSplitButtonPopover :: forall (m :: * -> *) o.
(MonadIO m, IsSplitButton o) =>
o -> m (Maybe Popover)
getSplitButtonPopover o
obj = IO (Maybe Popover) -> m (Maybe Popover)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Popover) -> m (Maybe Popover))
-> IO (Maybe Popover) -> m (Maybe Popover)
forall a b. (a -> b) -> a -> b
$ o
-> String -> (ManagedPtr Popover -> Popover) -> IO (Maybe Popover)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"popover" ManagedPtr Popover -> Popover
Gtk.Popover.Popover

-- | Set the value of the “@popover@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' splitButton [ #popover 'Data.GI.Base.Attributes.:=' value ]
-- @
setSplitButtonPopover :: (MonadIO m, IsSplitButton o, Gtk.Popover.IsPopover a) => o -> a -> m ()
setSplitButtonPopover :: forall (m :: * -> *) o a.
(MonadIO m, IsSplitButton o, IsPopover a) =>
o -> a -> m ()
setSplitButtonPopover o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"popover" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@popover@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSplitButtonPopover :: (IsSplitButton o, MIO.MonadIO m, Gtk.Popover.IsPopover a) => a -> m (GValueConstruct o)
constructSplitButtonPopover :: forall o (m :: * -> *) a.
(IsSplitButton o, MonadIO m, IsPopover a) =>
a -> m (GValueConstruct o)
constructSplitButtonPopover a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"popover" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@popover@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #popover
-- @
clearSplitButtonPopover :: (MonadIO m, IsSplitButton o) => o -> m ()
clearSplitButtonPopover :: forall (m :: * -> *) o. (MonadIO m, IsSplitButton o) => o -> m ()
clearSplitButtonPopover o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Popover -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"popover" (Maybe Popover
forall a. Maybe a
Nothing :: Maybe Gtk.Popover.Popover)

#if defined(ENABLE_OVERLOADING)
data SplitButtonPopoverPropertyInfo
instance AttrInfo SplitButtonPopoverPropertyInfo where
    type AttrAllowedOps SplitButtonPopoverPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SplitButtonPopoverPropertyInfo = IsSplitButton
    type AttrSetTypeConstraint SplitButtonPopoverPropertyInfo = Gtk.Popover.IsPopover
    type AttrTransferTypeConstraint SplitButtonPopoverPropertyInfo = Gtk.Popover.IsPopover
    type AttrTransferType SplitButtonPopoverPropertyInfo = Gtk.Popover.Popover
    type AttrGetType SplitButtonPopoverPropertyInfo = (Maybe Gtk.Popover.Popover)
    type AttrLabel SplitButtonPopoverPropertyInfo = "popover"
    type AttrOrigin SplitButtonPopoverPropertyInfo = SplitButton
    attrGet = getSplitButtonPopover
    attrSet = setSplitButtonPopover
    attrTransfer _ v = do
        unsafeCastTo Gtk.Popover.Popover v
    attrConstruct = constructSplitButtonPopover
    attrClear = clearSplitButtonPopover
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.popover"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#g:attr:popover"
        })
#endif

-- VVV Prop "use-underline"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@use-underline@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' splitButton #useUnderline
-- @
getSplitButtonUseUnderline :: (MonadIO m, IsSplitButton o) => o -> m Bool
getSplitButtonUseUnderline :: forall (m :: * -> *) o. (MonadIO m, IsSplitButton o) => o -> m Bool
getSplitButtonUseUnderline o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"use-underline"

-- | Set the value of the “@use-underline@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' splitButton [ #useUnderline 'Data.GI.Base.Attributes.:=' value ]
-- @
setSplitButtonUseUnderline :: (MonadIO m, IsSplitButton o) => o -> Bool -> m ()
setSplitButtonUseUnderline :: forall (m :: * -> *) o.
(MonadIO m, IsSplitButton o) =>
o -> Bool -> m ()
setSplitButtonUseUnderline o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"use-underline" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@use-underline@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSplitButtonUseUnderline :: (IsSplitButton o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSplitButtonUseUnderline :: forall o (m :: * -> *).
(IsSplitButton o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSplitButtonUseUnderline Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"use-underline" Bool
val

#if defined(ENABLE_OVERLOADING)
data SplitButtonUseUnderlinePropertyInfo
instance AttrInfo SplitButtonUseUnderlinePropertyInfo where
    type AttrAllowedOps SplitButtonUseUnderlinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SplitButtonUseUnderlinePropertyInfo = IsSplitButton
    type AttrSetTypeConstraint SplitButtonUseUnderlinePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SplitButtonUseUnderlinePropertyInfo = (~) Bool
    type AttrTransferType SplitButtonUseUnderlinePropertyInfo = Bool
    type AttrGetType SplitButtonUseUnderlinePropertyInfo = Bool
    type AttrLabel SplitButtonUseUnderlinePropertyInfo = "use-underline"
    type AttrOrigin SplitButtonUseUnderlinePropertyInfo = SplitButton
    attrGet = getSplitButtonUseUnderline
    attrSet = setSplitButtonUseUnderline
    attrTransfer _ v = do
        return v
    attrConstruct = constructSplitButtonUseUnderline
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.useUnderline"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#g:attr:useUnderline"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SplitButton
type instance O.AttributeList SplitButton = SplitButtonAttributeList
type SplitButtonAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", SplitButtonChildPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("direction", SplitButtonDirectionPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("iconName", SplitButtonIconNamePropertyInfo), '("label", SplitButtonLabelPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("menuModel", SplitButtonMenuModelPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("popover", SplitButtonPopoverPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useUnderline", SplitButtonUseUnderlinePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
splitButtonChild :: AttrLabelProxy "child"
splitButtonChild = AttrLabelProxy

splitButtonDirection :: AttrLabelProxy "direction"
splitButtonDirection = AttrLabelProxy

splitButtonIconName :: AttrLabelProxy "iconName"
splitButtonIconName = AttrLabelProxy

splitButtonLabel :: AttrLabelProxy "label"
splitButtonLabel = AttrLabelProxy

splitButtonMenuModel :: AttrLabelProxy "menuModel"
splitButtonMenuModel = AttrLabelProxy

splitButtonPopover :: AttrLabelProxy "popover"
splitButtonPopover = AttrLabelProxy

splitButtonUseUnderline :: AttrLabelProxy "useUnderline"
splitButtonUseUnderline = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList SplitButton = SplitButtonSignalList
type SplitButtonSignalList = ('[ '("activate", SplitButtonActivateSignalInfo), '("clicked", SplitButtonClickedSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, *)])

#endif

-- method SplitButton::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "SplitButton" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_new" adw_split_button_new :: 
    IO (Ptr SplitButton)

-- | Creates a new @AdwSplitButton@.
-- 
-- /Since: 1.0/
splitButtonNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m SplitButton
    -- ^ __Returns:__ the newly created @AdwSplitButton@
splitButtonNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m SplitButton
splitButtonNew  = IO SplitButton -> m SplitButton
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SplitButton -> m SplitButton)
-> IO SplitButton -> m SplitButton
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
result <- IO (Ptr SplitButton)
adw_split_button_new
    Text -> Ptr SplitButton -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"splitButtonNew" Ptr SplitButton
result
    SplitButton
result' <- ((ManagedPtr SplitButton -> SplitButton)
-> Ptr SplitButton -> IO SplitButton
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr SplitButton -> SplitButton
SplitButton) Ptr SplitButton
result
    SplitButton -> IO SplitButton
forall (m :: * -> *) a. Monad m => a -> m a
return SplitButton
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SplitButton::get_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Widget" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_get_child" adw_split_button_get_child :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    IO (Ptr Gtk.Widget.Widget)

-- | Gets the child widget.
-- 
-- /Since: 1.0/
splitButtonGetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the child widget
splitButtonGetChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSplitButton a) =>
a -> m (Maybe Widget)
splitButtonGetChild a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr SplitButton -> IO (Ptr Widget)
adw_split_button_get_child Ptr SplitButton
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

#if defined(ENABLE_OVERLOADING)
data SplitButtonGetChildMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsSplitButton a) => O.OverloadedMethod SplitButtonGetChildMethodInfo a signature where
    overloadedMethod = splitButtonGetChild

instance O.OverloadedMethodInfo SplitButtonGetChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonGetChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonGetChild"
        })


#endif

-- method SplitButton::get_direction
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "ArrowType" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_get_direction" adw_split_button_get_direction :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    IO CUInt

-- | Gets the direction in which the popup will be popped up.
-- 
-- /Since: 1.0/
splitButtonGetDirection ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> m Gtk.Enums.ArrowType
    -- ^ __Returns:__ the direction
splitButtonGetDirection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSplitButton a) =>
a -> m ArrowType
splitButtonGetDirection a
self = IO ArrowType -> m ArrowType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ArrowType -> m ArrowType) -> IO ArrowType -> m ArrowType
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr SplitButton -> IO CUInt
adw_split_button_get_direction Ptr SplitButton
self'
    let result' :: ArrowType
result' = (Int -> ArrowType
forall a. Enum a => Int -> a
toEnum (Int -> ArrowType) -> (CUInt -> Int) -> CUInt -> ArrowType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    ArrowType -> IO ArrowType
forall (m :: * -> *) a. Monad m => a -> m a
return ArrowType
result'

#if defined(ENABLE_OVERLOADING)
data SplitButtonGetDirectionMethodInfo
instance (signature ~ (m Gtk.Enums.ArrowType), MonadIO m, IsSplitButton a) => O.OverloadedMethod SplitButtonGetDirectionMethodInfo a signature where
    overloadedMethod = splitButtonGetDirection

instance O.OverloadedMethodInfo SplitButtonGetDirectionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonGetDirection",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonGetDirection"
        })


#endif

-- method SplitButton::get_icon_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_get_icon_name" adw_split_button_get_icon_name :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    IO CString

-- | Gets the name of the icon used to automatically populate the button.
-- 
-- If the icon name has not been set with 'GI.Adw.Objects.SplitButton.splitButtonSetIconName'
-- the return value will be @NULL@.
-- 
-- /Since: 1.0/
splitButtonGetIconName ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the icon name
splitButtonGetIconName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSplitButton a) =>
a -> m (Maybe Text)
splitButtonGetIconName a
self = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr SplitButton -> IO CString
adw_split_button_get_icon_name Ptr SplitButton
self'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data SplitButtonGetIconNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsSplitButton a) => O.OverloadedMethod SplitButtonGetIconNameMethodInfo a signature where
    overloadedMethod = splitButtonGetIconName

instance O.OverloadedMethodInfo SplitButtonGetIconNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonGetIconName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonGetIconName"
        })


#endif

-- method SplitButton::get_label
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_get_label" adw_split_button_get_label :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    IO CString

-- | Gets the label for /@self@/.
-- 
-- /Since: 1.0/
splitButtonGetLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the label for /@self@/
splitButtonGetLabel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSplitButton a) =>
a -> m (Maybe Text)
splitButtonGetLabel a
self = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr SplitButton -> IO CString
adw_split_button_get_label Ptr SplitButton
self'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data SplitButtonGetLabelMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsSplitButton a) => O.OverloadedMethod SplitButtonGetLabelMethodInfo a signature where
    overloadedMethod = splitButtonGetLabel

instance O.OverloadedMethodInfo SplitButtonGetLabelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonGetLabel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonGetLabel"
        })


#endif

-- method SplitButton::get_menu_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "MenuModel" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_get_menu_model" adw_split_button_get_menu_model :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    IO (Ptr Gio.MenuModel.MenuModel)

-- | Gets the menu model from which the popup will be created.
-- 
-- /Since: 1.0/
splitButtonGetMenuModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> m (Maybe Gio.MenuModel.MenuModel)
    -- ^ __Returns:__ the menu model
splitButtonGetMenuModel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSplitButton a) =>
a -> m (Maybe MenuModel)
splitButtonGetMenuModel a
self = IO (Maybe MenuModel) -> m (Maybe MenuModel)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe MenuModel) -> m (Maybe MenuModel))
-> IO (Maybe MenuModel) -> m (Maybe MenuModel)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr MenuModel
result <- Ptr SplitButton -> IO (Ptr MenuModel)
adw_split_button_get_menu_model Ptr SplitButton
self'
    Maybe MenuModel
maybeResult <- Ptr MenuModel
-> (Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr MenuModel
result ((Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel))
-> (Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel)
forall a b. (a -> b) -> a -> b
$ \Ptr MenuModel
result' -> do
        MenuModel
result'' <- ((ManagedPtr MenuModel -> MenuModel)
-> Ptr MenuModel -> IO MenuModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr MenuModel -> MenuModel
Gio.MenuModel.MenuModel) Ptr MenuModel
result'
        MenuModel -> IO MenuModel
forall (m :: * -> *) a. Monad m => a -> m a
return MenuModel
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe MenuModel -> IO (Maybe MenuModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MenuModel
maybeResult

#if defined(ENABLE_OVERLOADING)
data SplitButtonGetMenuModelMethodInfo
instance (signature ~ (m (Maybe Gio.MenuModel.MenuModel)), MonadIO m, IsSplitButton a) => O.OverloadedMethod SplitButtonGetMenuModelMethodInfo a signature where
    overloadedMethod = splitButtonGetMenuModel

instance O.OverloadedMethodInfo SplitButtonGetMenuModelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonGetMenuModel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonGetMenuModel"
        })


#endif

-- method SplitButton::get_popover
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Popover" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_get_popover" adw_split_button_get_popover :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    IO (Ptr Gtk.Popover.Popover)

-- | Gets the popover that will be popped up when the dropdown is clicked.
-- 
-- /Since: 1.0/
splitButtonGetPopover ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> m (Maybe Gtk.Popover.Popover)
    -- ^ __Returns:__ the popover
splitButtonGetPopover :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSplitButton a) =>
a -> m (Maybe Popover)
splitButtonGetPopover a
self = IO (Maybe Popover) -> m (Maybe Popover)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Popover) -> m (Maybe Popover))
-> IO (Maybe Popover) -> m (Maybe Popover)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Popover
result <- Ptr SplitButton -> IO (Ptr Popover)
adw_split_button_get_popover Ptr SplitButton
self'
    Maybe Popover
maybeResult <- Ptr Popover -> (Ptr Popover -> IO Popover) -> IO (Maybe Popover)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Popover
result ((Ptr Popover -> IO Popover) -> IO (Maybe Popover))
-> (Ptr Popover -> IO Popover) -> IO (Maybe Popover)
forall a b. (a -> b) -> a -> b
$ \Ptr Popover
result' -> do
        Popover
result'' <- ((ManagedPtr Popover -> Popover) -> Ptr Popover -> IO Popover
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Popover -> Popover
Gtk.Popover.Popover) Ptr Popover
result'
        Popover -> IO Popover
forall (m :: * -> *) a. Monad m => a -> m a
return Popover
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Popover -> IO (Maybe Popover)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Popover
maybeResult

#if defined(ENABLE_OVERLOADING)
data SplitButtonGetPopoverMethodInfo
instance (signature ~ (m (Maybe Gtk.Popover.Popover)), MonadIO m, IsSplitButton a) => O.OverloadedMethod SplitButtonGetPopoverMethodInfo a signature where
    overloadedMethod = splitButtonGetPopover

instance O.OverloadedMethodInfo SplitButtonGetPopoverMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonGetPopover",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonGetPopover"
        })


#endif

-- method SplitButton::get_use_underline
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_get_use_underline" adw_split_button_get_use_underline :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    IO CInt

-- | Gets whether an underline in the text indicates a mnemonic.
-- 
-- /Since: 1.0/
splitButtonGetUseUnderline ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> m Bool
    -- ^ __Returns:__ whether an underline in the text indicates a mnemonic
splitButtonGetUseUnderline :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSplitButton a) =>
a -> m Bool
splitButtonGetUseUnderline a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr SplitButton -> IO CInt
adw_split_button_get_use_underline Ptr SplitButton
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SplitButtonGetUseUnderlineMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSplitButton a) => O.OverloadedMethod SplitButtonGetUseUnderlineMethodInfo a signature where
    overloadedMethod = splitButtonGetUseUnderline

instance O.OverloadedMethodInfo SplitButtonGetUseUnderlineMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonGetUseUnderline",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonGetUseUnderline"
        })


#endif

-- method SplitButton::popdown
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_popdown" adw_split_button_popdown :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    IO ()

-- | Dismisses the menu.
-- 
-- /Since: 1.0/
splitButtonPopdown ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> m ()
splitButtonPopdown :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSplitButton a) =>
a -> m ()
splitButtonPopdown a
self = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SplitButton -> IO ()
adw_split_button_popdown Ptr SplitButton
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SplitButtonPopdownMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSplitButton a) => O.OverloadedMethod SplitButtonPopdownMethodInfo a signature where
    overloadedMethod = splitButtonPopdown

instance O.OverloadedMethodInfo SplitButtonPopdownMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonPopdown",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonPopdown"
        })


#endif

-- method SplitButton::popup
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_popup" adw_split_button_popup :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    IO ()

-- | Pops up the menu.
-- 
-- /Since: 1.0/
splitButtonPopup ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> m ()
splitButtonPopup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSplitButton a) =>
a -> m ()
splitButtonPopup a
self = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SplitButton -> IO ()
adw_split_button_popup Ptr SplitButton
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SplitButtonPopupMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSplitButton a) => O.OverloadedMethod SplitButtonPopupMethodInfo a signature where
    overloadedMethod = splitButtonPopup

instance O.OverloadedMethodInfo SplitButtonPopupMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonPopup",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonPopup"
        })


#endif

-- method SplitButton::set_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new child widget"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_set_child" adw_split_button_set_child :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the child widget.
-- 
-- /Since: 1.0/
splitButtonSetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> Maybe (b)
    -- ^ /@child@/: the new child widget
    -> m ()
splitButtonSetChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSplitButton a, IsWidget b) =>
a -> Maybe b -> m ()
splitButtonSetChild a
self Maybe b
child = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeChild <- case Maybe b
child of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jChild -> do
            Ptr Widget
jChild' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jChild
            Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jChild'
    Ptr SplitButton -> Ptr Widget -> IO ()
adw_split_button_set_child Ptr SplitButton
self' Ptr Widget
maybeChild
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
child b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SplitButtonSetChildMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSplitButton a, Gtk.Widget.IsWidget b) => O.OverloadedMethod SplitButtonSetChildMethodInfo a signature where
    overloadedMethod = splitButtonSetChild

instance O.OverloadedMethodInfo SplitButtonSetChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonSetChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonSetChild"
        })


#endif

-- method SplitButton::set_direction
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "direction"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ArrowType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the direction" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_set_direction" adw_split_button_set_direction :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    CUInt ->                                -- direction : TInterface (Name {namespace = "Gtk", name = "ArrowType"})
    IO ()

-- | Sets the direction in which the popup will be popped up.
-- 
-- /Since: 1.0/
splitButtonSetDirection ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> Gtk.Enums.ArrowType
    -- ^ /@direction@/: the direction
    -> m ()
splitButtonSetDirection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSplitButton a) =>
a -> ArrowType -> m ()
splitButtonSetDirection a
self ArrowType
direction = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let direction' :: CUInt
direction' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ArrowType -> Int) -> ArrowType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ArrowType -> Int
forall a. Enum a => a -> Int
fromEnum) ArrowType
direction
    Ptr SplitButton -> CUInt -> IO ()
adw_split_button_set_direction Ptr SplitButton
self' CUInt
direction'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SplitButtonSetDirectionMethodInfo
instance (signature ~ (Gtk.Enums.ArrowType -> m ()), MonadIO m, IsSplitButton a) => O.OverloadedMethod SplitButtonSetDirectionMethodInfo a signature where
    overloadedMethod = splitButtonSetDirection

instance O.OverloadedMethodInfo SplitButtonSetDirectionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonSetDirection",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonSetDirection"
        })


#endif

-- method SplitButton::set_icon_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "icon_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the icon name to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_set_icon_name" adw_split_button_set_icon_name :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    CString ->                              -- icon_name : TBasicType TUTF8
    IO ()

-- | Sets the name of the icon used to automatically populate the button.
-- 
-- /Since: 1.0/
splitButtonSetIconName ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> T.Text
    -- ^ /@iconName@/: the icon name to set
    -> m ()
splitButtonSetIconName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSplitButton a) =>
a -> Text -> m ()
splitButtonSetIconName a
self Text
iconName = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
iconName' <- Text -> IO CString
textToCString Text
iconName
    Ptr SplitButton -> CString -> IO ()
adw_split_button_set_icon_name Ptr SplitButton
self' CString
iconName'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
iconName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SplitButtonSetIconNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsSplitButton a) => O.OverloadedMethod SplitButtonSetIconNameMethodInfo a signature where
    overloadedMethod = splitButtonSetIconName

instance O.OverloadedMethodInfo SplitButtonSetIconNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonSetIconName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonSetIconName"
        })


#endif

-- method SplitButton::set_label
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "label"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the label to set" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_set_label" adw_split_button_set_label :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    CString ->                              -- label : TBasicType TUTF8
    IO ()

-- | Sets the label for /@self@/.
-- 
-- /Since: 1.0/
splitButtonSetLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> T.Text
    -- ^ /@label@/: the label to set
    -> m ()
splitButtonSetLabel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSplitButton a) =>
a -> Text -> m ()
splitButtonSetLabel a
self Text
label = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
label' <- Text -> IO CString
textToCString Text
label
    Ptr SplitButton -> CString -> IO ()
adw_split_button_set_label Ptr SplitButton
self' CString
label'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
label'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SplitButtonSetLabelMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsSplitButton a) => O.OverloadedMethod SplitButtonSetLabelMethodInfo a signature where
    overloadedMethod = splitButtonSetLabel

instance O.OverloadedMethodInfo SplitButtonSetLabelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonSetLabel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonSetLabel"
        })


#endif

-- method SplitButton::set_menu_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "menu_model"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuModel" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the menu model" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_set_menu_model" adw_split_button_set_menu_model :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    Ptr Gio.MenuModel.MenuModel ->          -- menu_model : TInterface (Name {namespace = "Gio", name = "MenuModel"})
    IO ()

-- | Sets the menu model from which the popup will be created.
-- 
-- /Since: 1.0/
splitButtonSetMenuModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a, Gio.MenuModel.IsMenuModel b) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> Maybe (b)
    -- ^ /@menuModel@/: the menu model
    -> m ()
splitButtonSetMenuModel :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSplitButton a, IsMenuModel b) =>
a -> Maybe b -> m ()
splitButtonSetMenuModel a
self Maybe b
menuModel = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr MenuModel
maybeMenuModel <- case Maybe b
menuModel of
        Maybe b
Nothing -> Ptr MenuModel -> IO (Ptr MenuModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
forall a. Ptr a
nullPtr
        Just b
jMenuModel -> do
            Ptr MenuModel
jMenuModel' <- b -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jMenuModel
            Ptr MenuModel -> IO (Ptr MenuModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
jMenuModel'
    Ptr SplitButton -> Ptr MenuModel -> IO ()
adw_split_button_set_menu_model Ptr SplitButton
self' Ptr MenuModel
maybeMenuModel
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
menuModel b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SplitButtonSetMenuModelMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSplitButton a, Gio.MenuModel.IsMenuModel b) => O.OverloadedMethod SplitButtonSetMenuModelMethodInfo a signature where
    overloadedMethod = splitButtonSetMenuModel

instance O.OverloadedMethodInfo SplitButtonSetMenuModelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonSetMenuModel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonSetMenuModel"
        })


#endif

-- method SplitButton::set_popover
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "popover"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Popover" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the popover" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_set_popover" adw_split_button_set_popover :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    Ptr Gtk.Popover.Popover ->              -- popover : TInterface (Name {namespace = "Gtk", name = "Popover"})
    IO ()

-- | Sets the popover that will be popped up when the dropdown is clicked.
-- 
-- /Since: 1.0/
splitButtonSetPopover ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a, Gtk.Popover.IsPopover b) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> Maybe (b)
    -- ^ /@popover@/: the popover
    -> m ()
splitButtonSetPopover :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSplitButton a, IsPopover b) =>
a -> Maybe b -> m ()
splitButtonSetPopover a
self Maybe b
popover = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Popover
maybePopover <- case Maybe b
popover of
        Maybe b
Nothing -> Ptr Popover -> IO (Ptr Popover)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Popover
forall a. Ptr a
nullPtr
        Just b
jPopover -> do
            Ptr Popover
jPopover' <- b -> IO (Ptr Popover)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jPopover
            Ptr Popover -> IO (Ptr Popover)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Popover
jPopover'
    Ptr SplitButton -> Ptr Popover -> IO ()
adw_split_button_set_popover Ptr SplitButton
self' Ptr Popover
maybePopover
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
popover b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SplitButtonSetPopoverMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSplitButton a, Gtk.Popover.IsPopover b) => O.OverloadedMethod SplitButtonSetPopoverMethodInfo a signature where
    overloadedMethod = splitButtonSetPopover

instance O.OverloadedMethodInfo SplitButtonSetPopoverMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonSetPopover",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonSetPopover"
        })


#endif

-- method SplitButton::set_use_underline
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SplitButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `AdwSplitButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "use_underline"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether an underline in the text indicates a mnemonic"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_split_button_set_use_underline" adw_split_button_set_use_underline :: 
    Ptr SplitButton ->                      -- self : TInterface (Name {namespace = "Adw", name = "SplitButton"})
    CInt ->                                 -- use_underline : TBasicType TBoolean
    IO ()

-- | Sets whether an underline in the text indicates a mnemonic.
-- 
-- /Since: 1.0/
splitButtonSetUseUnderline ::
    (B.CallStack.HasCallStack, MonadIO m, IsSplitButton a) =>
    a
    -- ^ /@self@/: a @AdwSplitButton@
    -> Bool
    -- ^ /@useUnderline@/: whether an underline in the text indicates a mnemonic
    -> m ()
splitButtonSetUseUnderline :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSplitButton a) =>
a -> Bool -> m ()
splitButtonSetUseUnderline a
self Bool
useUnderline = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SplitButton
self' <- a -> IO (Ptr SplitButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let useUnderline' :: CInt
useUnderline' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
useUnderline
    Ptr SplitButton -> CInt -> IO ()
adw_split_button_set_use_underline Ptr SplitButton
self' CInt
useUnderline'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SplitButtonSetUseUnderlineMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSplitButton a) => O.OverloadedMethod SplitButtonSetUseUnderlineMethodInfo a signature where
    overloadedMethod = splitButtonSetUseUnderline

instance O.OverloadedMethodInfo SplitButtonSetUseUnderlineMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SplitButton.splitButtonSetUseUnderline",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-SplitButton.html#v:splitButtonSetUseUnderline"
        })


#endif