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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Dazzle.Interfaces.DockItem
    ( 

-- * Exported types
    DockItem(..)                            ,
    IsDockItem                              ,
    toDockItem                              ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [addAccelerator]("GI.Gtk.Objects.Widget#g:method:addAccelerator"), [addChild]("GI.Gtk.Interfaces.Buildable#g:method:addChild"), [addDeviceEvents]("GI.Gtk.Objects.Widget#g:method:addDeviceEvents"), [addEvents]("GI.Gtk.Objects.Widget#g:method:addEvents"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [adopt]("GI.Dazzle.Interfaces.DockItem#g:method:adopt"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [canActivateAccel]("GI.Gtk.Objects.Widget#g:method:canActivateAccel"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [childNotify]("GI.Gtk.Objects.Widget#g:method:childNotify"), [classPath]("GI.Gtk.Objects.Widget#g:method:classPath"), [close]("GI.Dazzle.Interfaces.DockItem#g:method:close"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [constructChild]("GI.Gtk.Interfaces.Buildable#g:method:constructChild"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [customFinished]("GI.Gtk.Interfaces.Buildable#g:method:customFinished"), [customTagEnd]("GI.Gtk.Interfaces.Buildable#g:method:customTagEnd"), [customTagStart]("GI.Gtk.Interfaces.Buildable#g:method:customTagStart"), [destroy]("GI.Gtk.Objects.Widget#g:method:destroy"), [destroyed]("GI.Gtk.Objects.Widget#g:method:destroyed"), [deviceIsShadowed]("GI.Gtk.Objects.Widget#g:method:deviceIsShadowed"), [dragBegin]("GI.Gtk.Objects.Widget#g:method:dragBegin"), [dragBeginWithCoordinates]("GI.Gtk.Objects.Widget#g:method:dragBeginWithCoordinates"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [dragDestAddImageTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddImageTargets"), [dragDestAddTextTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddTextTargets"), [dragDestAddUriTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddUriTargets"), [dragDestFindTarget]("GI.Gtk.Objects.Widget#g:method:dragDestFindTarget"), [dragDestGetTargetList]("GI.Gtk.Objects.Widget#g:method:dragDestGetTargetList"), [dragDestGetTrackMotion]("GI.Gtk.Objects.Widget#g:method:dragDestGetTrackMotion"), [dragDestSet]("GI.Gtk.Objects.Widget#g:method:dragDestSet"), [dragDestSetProxy]("GI.Gtk.Objects.Widget#g:method:dragDestSetProxy"), [dragDestSetTargetList]("GI.Gtk.Objects.Widget#g:method:dragDestSetTargetList"), [dragDestSetTrackMotion]("GI.Gtk.Objects.Widget#g:method:dragDestSetTrackMotion"), [dragDestUnset]("GI.Gtk.Objects.Widget#g:method:dragDestUnset"), [dragGetData]("GI.Gtk.Objects.Widget#g:method:dragGetData"), [dragHighlight]("GI.Gtk.Objects.Widget#g:method:dragHighlight"), [dragSourceAddImageTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddImageTargets"), [dragSourceAddTextTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddTextTargets"), [dragSourceAddUriTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddUriTargets"), [dragSourceGetTargetList]("GI.Gtk.Objects.Widget#g:method:dragSourceGetTargetList"), [dragSourceSet]("GI.Gtk.Objects.Widget#g:method:dragSourceSet"), [dragSourceSetIconGicon]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconGicon"), [dragSourceSetIconName]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconName"), [dragSourceSetIconPixbuf]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconPixbuf"), [dragSourceSetIconStock]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconStock"), [dragSourceSetTargetList]("GI.Gtk.Objects.Widget#g:method:dragSourceSetTargetList"), [dragSourceUnset]("GI.Gtk.Objects.Widget#g:method:dragSourceUnset"), [dragUnhighlight]("GI.Gtk.Objects.Widget#g:method:dragUnhighlight"), [draw]("GI.Gtk.Objects.Widget#g:method:draw"), [emitPresented]("GI.Dazzle.Interfaces.DockItem#g:method:emitPresented"), [ensureStyle]("GI.Gtk.Objects.Widget#g:method:ensureStyle"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [event]("GI.Gtk.Objects.Widget#g:method:event"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeChildNotify]("GI.Gtk.Objects.Widget#g:method:freezeChildNotify"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabAdd]("GI.Gtk.Objects.Widget#g:method:grabAdd"), [grabDefault]("GI.Gtk.Objects.Widget#g:method:grabDefault"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [grabRemove]("GI.Gtk.Objects.Widget#g:method:grabRemove"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasGrab]("GI.Gtk.Objects.Widget#g:method:hasGrab"), [hasRcStyle]("GI.Gtk.Objects.Widget#g:method:hasRcStyle"), [hasScreen]("GI.Gtk.Objects.Widget#g:method:hasScreen"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hasWidgets]("GI.Dazzle.Interfaces.DockItem#g:method:hasWidgets"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [hideOnDelete]("GI.Gtk.Objects.Widget#g:method:hideOnDelete"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [inputShapeCombineRegion]("GI.Gtk.Objects.Widget#g:method:inputShapeCombineRegion"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [intersect]("GI.Gtk.Objects.Widget#g:method:intersect"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isComposited]("GI.Gtk.Objects.Widget#g:method:isComposited"), [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"), [isToplevel]("GI.Gtk.Objects.Widget#g:method:isToplevel"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listAccelClosures]("GI.Gtk.Objects.Widget#g:method:listAccelClosures"), [listActionPrefixes]("GI.Gtk.Objects.Widget#g:method:listActionPrefixes"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [minimize]("GI.Dazzle.Interfaces.DockItem#g:method:minimize"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [modifyBase]("GI.Gtk.Objects.Widget#g:method:modifyBase"), [modifyBg]("GI.Gtk.Objects.Widget#g:method:modifyBg"), [modifyCursor]("GI.Gtk.Objects.Widget#g:method:modifyCursor"), [modifyFg]("GI.Gtk.Objects.Widget#g:method:modifyFg"), [modifyFont]("GI.Gtk.Objects.Widget#g:method:modifyFont"), [modifyStyle]("GI.Gtk.Objects.Widget#g:method:modifyStyle"), [modifyText]("GI.Gtk.Objects.Widget#g:method:modifyText"), [needsAttention]("GI.Dazzle.Interfaces.DockItem#g:method:needsAttention"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [overrideBackgroundColor]("GI.Gtk.Objects.Widget#g:method:overrideBackgroundColor"), [overrideColor]("GI.Gtk.Objects.Widget#g:method:overrideColor"), [overrideCursor]("GI.Gtk.Objects.Widget#g:method:overrideCursor"), [overrideFont]("GI.Gtk.Objects.Widget#g:method:overrideFont"), [overrideSymbolicColor]("GI.Gtk.Objects.Widget#g:method:overrideSymbolicColor"), [parserFinished]("GI.Gtk.Interfaces.Buildable#g:method:parserFinished"), [path]("GI.Gtk.Objects.Widget#g:method:path"), [present]("GI.Dazzle.Interfaces.DockItem#g:method:present"), [presentChild]("GI.Dazzle.Interfaces.DockItem#g:method:presentChild"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueComputeExpand]("GI.Gtk.Objects.Widget#g:method:queueComputeExpand"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueDrawArea]("GI.Gtk.Objects.Widget#g:method:queueDrawArea"), [queueDrawRegion]("GI.Gtk.Objects.Widget#g:method:queueDrawRegion"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [queueResizeNoRedraw]("GI.Gtk.Objects.Widget#g:method:queueResizeNoRedraw"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refGicon]("GI.Dazzle.Interfaces.DockItem#g:method:refGicon"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [regionIntersect]("GI.Gtk.Objects.Widget#g:method:regionIntersect"), [registerWindow]("GI.Gtk.Objects.Widget#g:method:registerWindow"), [release]("GI.Dazzle.Interfaces.DockItem#g:method:release"), [removeAccelerator]("GI.Gtk.Objects.Widget#g:method:removeAccelerator"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [renderIcon]("GI.Gtk.Objects.Widget#g:method:renderIcon"), [renderIconPixbuf]("GI.Gtk.Objects.Widget#g:method:renderIconPixbuf"), [reparent]("GI.Gtk.Objects.Widget#g:method:reparent"), [resetRcStyles]("GI.Gtk.Objects.Widget#g:method:resetRcStyles"), [resetStyle]("GI.Gtk.Objects.Widget#g:method:resetStyle"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [sendExpose]("GI.Gtk.Objects.Widget#g:method:sendExpose"), [sendFocusChange]("GI.Gtk.Objects.Widget#g:method:sendFocusChange"), [shapeCombineRegion]("GI.Gtk.Objects.Widget#g:method:shapeCombineRegion"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [showAll]("GI.Gtk.Objects.Widget#g:method:showAll"), [showNow]("GI.Gtk.Objects.Widget#g:method:showNow"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [sizeAllocateWithBaseline]("GI.Gtk.Objects.Widget#g:method:sizeAllocateWithBaseline"), [sizeRequest]("GI.Gtk.Objects.Widget#g:method:sizeRequest"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [styleAttach]("GI.Gtk.Objects.Widget#g:method:styleAttach"), [styleGetProperty]("GI.Gtk.Objects.Widget#g:method:styleGetProperty"), [thawChildNotify]("GI.Gtk.Objects.Widget#g:method:thawChildNotify"), [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"), [unregisterWindow]("GI.Gtk.Objects.Widget#g:method:unregisterWindow"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateVisibility]("GI.Dazzle.Interfaces.DockItem#g:method:updateVisibility"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessible]("GI.Gtk.Objects.Widget#g:method:getAccessible"), [getActionGroup]("GI.Gtk.Objects.Widget#g:method:getActionGroup"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedSize]("GI.Gtk.Objects.Widget#g:method:getAllocatedSize"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAppPaintable]("GI.Gtk.Objects.Widget#g:method:getAppPaintable"), [getCanClose]("GI.Dazzle.Interfaces.DockItem#g:method:getCanClose"), [getCanDefault]("GI.Gtk.Objects.Widget#g:method:getCanDefault"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanMinimize]("GI.Dazzle.Interfaces.DockItem#g:method:getCanMinimize"), [getChildRequisition]("GI.Gtk.Objects.Widget#g:method:getChildRequisition"), [getChildVisible]("GI.Dazzle.Interfaces.DockItem#g:method:getChildVisible"), [getClip]("GI.Gtk.Objects.Widget#g:method:getClip"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getCompositeName]("GI.Gtk.Objects.Widget#g:method:getCompositeName"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDeviceEnabled]("GI.Gtk.Objects.Widget#g:method:getDeviceEnabled"), [getDeviceEvents]("GI.Gtk.Objects.Widget#g:method:getDeviceEvents"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getDoubleBuffered]("GI.Gtk.Objects.Widget#g:method:getDoubleBuffered"), [getEvents]("GI.Gtk.Objects.Widget#g:method:getEvents"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [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"), [getHasWindow]("GI.Gtk.Objects.Widget#g:method:getHasWindow"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getIconName]("GI.Dazzle.Interfaces.DockItem#g:method:getIconName"), [getInternalChild]("GI.Gtk.Interfaces.Buildable#g:method:getInternalChild"), [getManager]("GI.Dazzle.Interfaces.DockItem#g:method:getManager"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginLeft]("GI.Gtk.Objects.Widget#g:method:getMarginLeft"), [getMarginRight]("GI.Gtk.Objects.Widget#g:method:getMarginRight"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getModifierMask]("GI.Gtk.Objects.Widget#g:method:getModifierMask"), [getModifierStyle]("GI.Gtk.Objects.Widget#g:method:getModifierStyle"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNoShowAll]("GI.Gtk.Objects.Widget#g:method:getNoShowAll"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Dazzle.Interfaces.DockItem#g:method:getParent"), [getParentWindow]("GI.Gtk.Objects.Widget#g:method:getParentWindow"), [getPath]("GI.Gtk.Objects.Widget#g:method:getPath"), [getPointer]("GI.Gtk.Objects.Widget#g:method:getPointer"), [getPreferredHeight]("GI.Gtk.Objects.Widget#g:method:getPreferredHeight"), [getPreferredHeightAndBaselineForWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredHeightAndBaselineForWidth"), [getPreferredHeightForWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredHeightForWidth"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPreferredWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredWidth"), [getPreferredWidthForHeight]("GI.Gtk.Objects.Widget#g:method:getPreferredWidthForHeight"), [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"), [getRequisition]("GI.Gtk.Objects.Widget#g:method:getRequisition"), [getRootWindow]("GI.Gtk.Objects.Widget#g:method:getRootWindow"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getScreen]("GI.Gtk.Objects.Widget#g:method:getScreen"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getState]("GI.Gtk.Objects.Widget#g:method:getState"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyle]("GI.Gtk.Objects.Widget#g:method:getStyle"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:getSupportMultidevice"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTitle]("GI.Dazzle.Interfaces.DockItem#g:method:getTitle"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTooltipWindow]("GI.Gtk.Objects.Widget#g:method:getTooltipWindow"), [getToplevel]("GI.Gtk.Objects.Widget#g:method:getToplevel"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getValignWithBaseline]("GI.Gtk.Objects.Widget#g:method:getValignWithBaseline"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getVisual]("GI.Gtk.Objects.Widget#g:method:getVisual"), [getWindow]("GI.Gtk.Objects.Widget#g:method:getWindow").
-- 
-- ==== Setters
-- [setAccelPath]("GI.Gtk.Objects.Widget#g:method:setAccelPath"), [setAllocation]("GI.Gtk.Objects.Widget#g:method:setAllocation"), [setAppPaintable]("GI.Gtk.Objects.Widget#g:method:setAppPaintable"), [setBuildableProperty]("GI.Gtk.Interfaces.Buildable#g:method:setBuildableProperty"), [setCanDefault]("GI.Gtk.Objects.Widget#g:method:setCanDefault"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setChildVisible]("GI.Dazzle.Interfaces.DockItem#g:method:setChildVisible"), [setClip]("GI.Gtk.Objects.Widget#g:method:setClip"), [setCompositeName]("GI.Gtk.Objects.Widget#g:method:setCompositeName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDeviceEnabled]("GI.Gtk.Objects.Widget#g:method:setDeviceEnabled"), [setDeviceEvents]("GI.Gtk.Objects.Widget#g:method:setDeviceEvents"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setDoubleBuffered]("GI.Gtk.Objects.Widget#g:method:setDoubleBuffered"), [setEvents]("GI.Gtk.Objects.Widget#g:method:setEvents"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [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"), [setHasWindow]("GI.Gtk.Objects.Widget#g:method:setHasWindow"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setManager]("GI.Dazzle.Interfaces.DockItem#g:method:setManager"), [setMapped]("GI.Gtk.Objects.Widget#g:method:setMapped"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginLeft]("GI.Gtk.Objects.Widget#g:method:setMarginLeft"), [setMarginRight]("GI.Gtk.Objects.Widget#g:method:setMarginRight"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setNoShowAll]("GI.Gtk.Objects.Widget#g:method:setNoShowAll"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setParentWindow]("GI.Gtk.Objects.Widget#g:method:setParentWindow"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRealized]("GI.Gtk.Objects.Widget#g:method:setRealized"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setRedrawOnAllocate]("GI.Gtk.Objects.Widget#g:method:setRedrawOnAllocate"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setState]("GI.Gtk.Objects.Widget#g:method:setState"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setStyle]("GI.Gtk.Objects.Widget#g:method:setStyle"), [setSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:setSupportMultidevice"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTooltipWindow]("GI.Gtk.Objects.Widget#g:method:setTooltipWindow"), [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"), [setVisual]("GI.Gtk.Objects.Widget#g:method:setVisual"), [setWindow]("GI.Gtk.Objects.Widget#g:method:setWindow").

#if defined(ENABLE_OVERLOADING)
    ResolveDockItemMethod                   ,
#endif

-- ** adopt #method:adopt#

#if defined(ENABLE_OVERLOADING)
    DockItemAdoptMethodInfo                 ,
#endif
    dockItemAdopt                           ,


-- ** close #method:close#

#if defined(ENABLE_OVERLOADING)
    DockItemCloseMethodInfo                 ,
#endif
    dockItemClose                           ,


-- ** emitPresented #method:emitPresented#

#if defined(ENABLE_OVERLOADING)
    DockItemEmitPresentedMethodInfo         ,
#endif
    dockItemEmitPresented                   ,


-- ** getCanClose #method:getCanClose#

#if defined(ENABLE_OVERLOADING)
    DockItemGetCanCloseMethodInfo           ,
#endif
    dockItemGetCanClose                     ,


-- ** getCanMinimize #method:getCanMinimize#

#if defined(ENABLE_OVERLOADING)
    DockItemGetCanMinimizeMethodInfo        ,
#endif
    dockItemGetCanMinimize                  ,


-- ** getChildVisible #method:getChildVisible#

#if defined(ENABLE_OVERLOADING)
    DockItemGetChildVisibleMethodInfo       ,
#endif
    dockItemGetChildVisible                 ,


-- ** getIconName #method:getIconName#

#if defined(ENABLE_OVERLOADING)
    DockItemGetIconNameMethodInfo           ,
#endif
    dockItemGetIconName                     ,


-- ** getManager #method:getManager#

#if defined(ENABLE_OVERLOADING)
    DockItemGetManagerMethodInfo            ,
#endif
    dockItemGetManager                      ,


-- ** getParent #method:getParent#

#if defined(ENABLE_OVERLOADING)
    DockItemGetParentMethodInfo             ,
#endif
    dockItemGetParent                       ,


-- ** getTitle #method:getTitle#

#if defined(ENABLE_OVERLOADING)
    DockItemGetTitleMethodInfo              ,
#endif
    dockItemGetTitle                        ,


-- ** hasWidgets #method:hasWidgets#

#if defined(ENABLE_OVERLOADING)
    DockItemHasWidgetsMethodInfo            ,
#endif
    dockItemHasWidgets                      ,


-- ** minimize #method:minimize#

#if defined(ENABLE_OVERLOADING)
    DockItemMinimizeMethodInfo              ,
#endif
    dockItemMinimize                        ,


-- ** needsAttention #method:needsAttention#

#if defined(ENABLE_OVERLOADING)
    DockItemNeedsAttentionMethodInfo        ,
#endif
    dockItemNeedsAttention                  ,


-- ** present #method:present#

#if defined(ENABLE_OVERLOADING)
    DockItemPresentMethodInfo               ,
#endif
    dockItemPresent                         ,


-- ** presentChild #method:presentChild#

#if defined(ENABLE_OVERLOADING)
    DockItemPresentChildMethodInfo          ,
#endif
    dockItemPresentChild                    ,


-- ** refGicon #method:refGicon#

#if defined(ENABLE_OVERLOADING)
    DockItemRefGiconMethodInfo              ,
#endif
    dockItemRefGicon                        ,


-- ** release #method:release#

#if defined(ENABLE_OVERLOADING)
    DockItemReleaseMethodInfo               ,
#endif
    dockItemRelease                         ,


-- ** setChildVisible #method:setChildVisible#

#if defined(ENABLE_OVERLOADING)
    DockItemSetChildVisibleMethodInfo       ,
#endif
    dockItemSetChildVisible                 ,


-- ** setManager #method:setManager#

#if defined(ENABLE_OVERLOADING)
    DockItemSetManagerMethodInfo            ,
#endif
    dockItemSetManager                      ,


-- ** updateVisibility #method:updateVisibility#

#if defined(ENABLE_OVERLOADING)
    DockItemUpdateVisibilityMethodInfo      ,
#endif
    dockItemUpdateVisibility                ,




 -- * Signals


-- ** managerSet #signal:managerSet#

    DockItemManagerSetCallback              ,
#if defined(ENABLE_OVERLOADING)
    DockItemManagerSetSignalInfo            ,
#endif
    afterDockItemManagerSet                 ,
    onDockItemManagerSet                    ,


-- ** needsAttention #signal:needsAttention#

    DockItemNeedsAttentionCallback          ,
#if defined(ENABLE_OVERLOADING)
    DockItemNeedsAttentionSignalInfo        ,
#endif
    afterDockItemNeedsAttention             ,
    onDockItemNeedsAttention                ,


-- ** presented #signal:presented#

    DockItemPresentedCallback               ,
#if defined(ENABLE_OVERLOADING)
    DockItemPresentedSignalInfo             ,
#endif
    afterDockItemPresented                  ,
    onDockItemPresented                     ,




    ) 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.GHashTable as B.GHT
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.Kind as DK
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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.Dazzle.Interfaces.Dock as Dazzle.Dock
import {-# SOURCE #-} qualified GI.Dazzle.Objects.DockManager as Dazzle.DockManager
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import qualified GI.Gtk.Enums as Gtk.Enums
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Objects.Container as Gtk.Container
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

#else
import {-# SOURCE #-} qualified GI.Dazzle.Objects.DockManager as Dazzle.DockManager
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import qualified GI.Gtk.Enums as Gtk.Enums
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

#endif

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

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

foreign import ccall "dzl_dock_item_get_type"
    c_dzl_dock_item_get_type :: IO B.Types.GType

instance B.Types.TypedObject DockItem where
    glibType :: IO GType
glibType = IO GType
c_dzl_dock_item_get_type

instance B.Types.GObject DockItem

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

instance O.HasParentTypes DockItem
type instance O.ParentTypes DockItem = '[GObject.Object.Object, Gtk.Widget.Widget]

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

-- | Convert 'DockItem' 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 DockItem) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_dzl_dock_item_get_type
    gvalueSet_ :: Ptr GValue -> Maybe DockItem -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DockItem
P.Nothing = Ptr GValue -> Ptr DockItem -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr DockItem
forall a. Ptr a
FP.nullPtr :: FP.Ptr DockItem)
    gvalueSet_ Ptr GValue
gv (P.Just DockItem
obj) = DockItem -> (Ptr DockItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DockItem
obj (Ptr GValue -> Ptr DockItem -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe DockItem)
gvalueGet_ Ptr GValue
gv = do
        Ptr DockItem
ptr <- Ptr GValue -> IO (Ptr DockItem)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DockItem)
        if Ptr DockItem
ptr Ptr DockItem -> Ptr DockItem -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr DockItem
forall a. Ptr a
FP.nullPtr
        then DockItem -> Maybe DockItem
forall a. a -> Maybe a
P.Just (DockItem -> Maybe DockItem) -> IO DockItem -> IO (Maybe DockItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr DockItem -> DockItem) -> Ptr DockItem -> IO DockItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr DockItem -> DockItem
DockItem Ptr DockItem
ptr
        else Maybe DockItem -> IO (Maybe DockItem)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DockItem
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DockItem
type instance O.AttributeList DockItem = DockItemAttributeList
type DockItemAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("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), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveDockItemMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveDockItemMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveDockItemMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
    ResolveDockItemMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveDockItemMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
    ResolveDockItemMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
    ResolveDockItemMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveDockItemMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveDockItemMethod "adopt" o = DockItemAdoptMethodInfo
    ResolveDockItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDockItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDockItemMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
    ResolveDockItemMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveDockItemMethod "childNotify" o = Gtk.Widget.WidgetChildNotifyMethodInfo
    ResolveDockItemMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
    ResolveDockItemMethod "close" o = DockItemCloseMethodInfo
    ResolveDockItemMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveDockItemMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveDockItemMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveDockItemMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveDockItemMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveDockItemMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveDockItemMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveDockItemMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
    ResolveDockItemMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
    ResolveDockItemMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
    ResolveDockItemMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
    ResolveDockItemMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
    ResolveDockItemMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveDockItemMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
    ResolveDockItemMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
    ResolveDockItemMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
    ResolveDockItemMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
    ResolveDockItemMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
    ResolveDockItemMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
    ResolveDockItemMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
    ResolveDockItemMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
    ResolveDockItemMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
    ResolveDockItemMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
    ResolveDockItemMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
    ResolveDockItemMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
    ResolveDockItemMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
    ResolveDockItemMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
    ResolveDockItemMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
    ResolveDockItemMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
    ResolveDockItemMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
    ResolveDockItemMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
    ResolveDockItemMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
    ResolveDockItemMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
    ResolveDockItemMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
    ResolveDockItemMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
    ResolveDockItemMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
    ResolveDockItemMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
    ResolveDockItemMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
    ResolveDockItemMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
    ResolveDockItemMethod "emitPresented" o = DockItemEmitPresentedMethodInfo
    ResolveDockItemMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
    ResolveDockItemMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveDockItemMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
    ResolveDockItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDockItemMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
    ResolveDockItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDockItemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDockItemMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
    ResolveDockItemMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
    ResolveDockItemMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveDockItemMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
    ResolveDockItemMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveDockItemMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveDockItemMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
    ResolveDockItemMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
    ResolveDockItemMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
    ResolveDockItemMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveDockItemMethod "hasWidgets" o = DockItemHasWidgetsMethodInfo
    ResolveDockItemMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveDockItemMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
    ResolveDockItemMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveDockItemMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveDockItemMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
    ResolveDockItemMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveDockItemMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
    ResolveDockItemMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveDockItemMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
    ResolveDockItemMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveDockItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDockItemMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveDockItemMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveDockItemMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
    ResolveDockItemMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveDockItemMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveDockItemMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
    ResolveDockItemMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
    ResolveDockItemMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveDockItemMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveDockItemMethod "minimize" o = DockItemMinimizeMethodInfo
    ResolveDockItemMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveDockItemMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
    ResolveDockItemMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
    ResolveDockItemMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
    ResolveDockItemMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
    ResolveDockItemMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
    ResolveDockItemMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
    ResolveDockItemMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
    ResolveDockItemMethod "needsAttention" o = DockItemNeedsAttentionMethodInfo
    ResolveDockItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDockItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDockItemMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
    ResolveDockItemMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
    ResolveDockItemMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
    ResolveDockItemMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
    ResolveDockItemMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
    ResolveDockItemMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveDockItemMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
    ResolveDockItemMethod "present" o = DockItemPresentMethodInfo
    ResolveDockItemMethod "presentChild" o = DockItemPresentChildMethodInfo
    ResolveDockItemMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveDockItemMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
    ResolveDockItemMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveDockItemMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
    ResolveDockItemMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
    ResolveDockItemMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveDockItemMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
    ResolveDockItemMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveDockItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDockItemMethod "refGicon" o = DockItemRefGiconMethodInfo
    ResolveDockItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDockItemMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
    ResolveDockItemMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
    ResolveDockItemMethod "release" o = DockItemReleaseMethodInfo
    ResolveDockItemMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
    ResolveDockItemMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveDockItemMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveDockItemMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
    ResolveDockItemMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
    ResolveDockItemMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
    ResolveDockItemMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
    ResolveDockItemMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
    ResolveDockItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDockItemMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
    ResolveDockItemMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
    ResolveDockItemMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
    ResolveDockItemMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveDockItemMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
    ResolveDockItemMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
    ResolveDockItemMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveDockItemMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
    ResolveDockItemMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
    ResolveDockItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDockItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDockItemMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
    ResolveDockItemMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
    ResolveDockItemMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
    ResolveDockItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDockItemMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveDockItemMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveDockItemMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveDockItemMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveDockItemMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveDockItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDockItemMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
    ResolveDockItemMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveDockItemMethod "updateVisibility" o = DockItemUpdateVisibilityMethodInfo
    ResolveDockItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDockItemMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
    ResolveDockItemMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
    ResolveDockItemMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveDockItemMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveDockItemMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
    ResolveDockItemMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveDockItemMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveDockItemMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveDockItemMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
    ResolveDockItemMethod "getCanClose" o = DockItemGetCanCloseMethodInfo
    ResolveDockItemMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
    ResolveDockItemMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveDockItemMethod "getCanMinimize" o = DockItemGetCanMinimizeMethodInfo
    ResolveDockItemMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
    ResolveDockItemMethod "getChildVisible" o = DockItemGetChildVisibleMethodInfo
    ResolveDockItemMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
    ResolveDockItemMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveDockItemMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
    ResolveDockItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDockItemMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
    ResolveDockItemMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
    ResolveDockItemMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveDockItemMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveDockItemMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
    ResolveDockItemMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
    ResolveDockItemMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveDockItemMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveDockItemMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveDockItemMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveDockItemMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveDockItemMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveDockItemMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
    ResolveDockItemMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveDockItemMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveDockItemMethod "getIconName" o = DockItemGetIconNameMethodInfo
    ResolveDockItemMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveDockItemMethod "getManager" o = DockItemGetManagerMethodInfo
    ResolveDockItemMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveDockItemMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveDockItemMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveDockItemMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
    ResolveDockItemMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
    ResolveDockItemMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveDockItemMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveDockItemMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
    ResolveDockItemMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
    ResolveDockItemMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveDockItemMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
    ResolveDockItemMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveDockItemMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveDockItemMethod "getParent" o = DockItemGetParentMethodInfo
    ResolveDockItemMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
    ResolveDockItemMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
    ResolveDockItemMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
    ResolveDockItemMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
    ResolveDockItemMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
    ResolveDockItemMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
    ResolveDockItemMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveDockItemMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
    ResolveDockItemMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
    ResolveDockItemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDockItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDockItemMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveDockItemMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveDockItemMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveDockItemMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
    ResolveDockItemMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
    ResolveDockItemMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveDockItemMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
    ResolveDockItemMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveDockItemMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveDockItemMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveDockItemMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
    ResolveDockItemMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveDockItemMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
    ResolveDockItemMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveDockItemMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
    ResolveDockItemMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveDockItemMethod "getTitle" o = DockItemGetTitleMethodInfo
    ResolveDockItemMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveDockItemMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveDockItemMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
    ResolveDockItemMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
    ResolveDockItemMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveDockItemMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
    ResolveDockItemMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveDockItemMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveDockItemMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveDockItemMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
    ResolveDockItemMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
    ResolveDockItemMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
    ResolveDockItemMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
    ResolveDockItemMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
    ResolveDockItemMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveDockItemMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
    ResolveDockItemMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveDockItemMethod "setChildVisible" o = DockItemSetChildVisibleMethodInfo
    ResolveDockItemMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
    ResolveDockItemMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
    ResolveDockItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDockItemMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveDockItemMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
    ResolveDockItemMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
    ResolveDockItemMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveDockItemMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
    ResolveDockItemMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
    ResolveDockItemMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveDockItemMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveDockItemMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveDockItemMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveDockItemMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveDockItemMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
    ResolveDockItemMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveDockItemMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveDockItemMethod "setManager" o = DockItemSetManagerMethodInfo
    ResolveDockItemMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
    ResolveDockItemMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveDockItemMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveDockItemMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
    ResolveDockItemMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
    ResolveDockItemMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveDockItemMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveDockItemMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveDockItemMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
    ResolveDockItemMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveDockItemMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveDockItemMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
    ResolveDockItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDockItemMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
    ResolveDockItemMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveDockItemMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
    ResolveDockItemMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveDockItemMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveDockItemMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
    ResolveDockItemMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveDockItemMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
    ResolveDockItemMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
    ResolveDockItemMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveDockItemMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveDockItemMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
    ResolveDockItemMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveDockItemMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveDockItemMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveDockItemMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveDockItemMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
    ResolveDockItemMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
    ResolveDockItemMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDockItemMethod t DockItem, O.OverloadedMethod info DockItem p) => OL.IsLabel t (DockItem -> 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 ~ ResolveDockItemMethod t DockItem, O.OverloadedMethod info DockItem p, R.HasField t DockItem p) => R.HasField t DockItem p where
    getField = O.overloadedMethod @info

#endif

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

#endif

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

foreign import ccall "dzl_dock_item_adopt" dzl_dock_item_adopt :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    Ptr DockItem ->                         -- child : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO CInt

-- | /No description available in the introspection data./
dockItemAdopt ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a, IsDockItem b) =>
    a
    -> b
    -> m Bool
dockItemAdopt :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDockItem a, IsDockItem b) =>
a -> b -> m Bool
dockItemAdopt a
self b
child = IO Bool -> m Bool
forall a. IO a -> m a
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 DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockItem
child' <- b -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    CInt
result <- Ptr DockItem -> Ptr DockItem -> IO CInt
dzl_dock_item_adopt Ptr DockItem
self' Ptr DockItem
child'
    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
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DockItemAdoptMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsDockItem a, IsDockItem b) => O.OverloadedMethod DockItemAdoptMethodInfo a signature where
    overloadedMethod = dockItemAdopt

instance O.OverloadedMethodInfo DockItemAdoptMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemAdopt",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemAdopt"
        })


#endif

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

foreign import ccall "dzl_dock_item_close" dzl_dock_item_close :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO CInt

-- | This function will request that the dock item close itself.
dockItemClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Interfaces.DockItem.DockItem'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the dock item was closed
dockItemClose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockItem a) =>
a -> m Bool
dockItemClose a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr DockItem -> IO CInt
dzl_dock_item_close Ptr DockItem
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DockItemCloseMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDockItem a) => O.OverloadedMethod DockItemCloseMethodInfo a signature where
    overloadedMethod = dockItemClose

instance O.OverloadedMethodInfo DockItemCloseMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemClose",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemClose"
        })


#endif

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

foreign import ccall "dzl_dock_item_emit_presented" dzl_dock_item_emit_presented :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO ()

-- | Emits the [DockItem::presented]("GI.Dazzle.Interfaces.DockItem#g:signal:presented") signal.
-- 
-- Containers should emit this when their descendant has been presented as the
-- current visible child. This allows dock items to do lazy initialization of
-- content once the widgetry is visible to the user.
-- 
-- Currently, this is best effort, as there are a number of situations that
-- make covering all cases problematic.
-- 
-- /Since: 3.30/
dockItemEmitPresented ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Interfaces.DockItem.DockItem'
    -> m ()
dockItemEmitPresented :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockItem a) =>
a -> m ()
dockItemEmitPresented a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockItem -> IO ()
dzl_dock_item_emit_presented Ptr DockItem
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DockItemEmitPresentedMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDockItem a) => O.OverloadedMethod DockItemEmitPresentedMethodInfo a signature where
    overloadedMethod = dockItemEmitPresented

instance O.OverloadedMethodInfo DockItemEmitPresentedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemEmitPresented",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemEmitPresented"
        })


#endif

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

foreign import ccall "dzl_dock_item_get_can_close" dzl_dock_item_get_can_close :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO CInt

-- | If this dock item can be closed by the user, this virtual function should be
-- implemented by the panel and return 'P.True'.
dockItemGetCanClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Interfaces.DockItem.DockItem'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the dock item can be closed by the user, otherwise 'P.False'.
dockItemGetCanClose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockItem a) =>
a -> m Bool
dockItemGetCanClose a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr DockItem -> IO CInt
dzl_dock_item_get_can_close Ptr DockItem
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DockItemGetCanCloseMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDockItem a) => O.OverloadedMethod DockItemGetCanCloseMethodInfo a signature where
    overloadedMethod = dockItemGetCanClose

instance O.OverloadedMethodInfo DockItemGetCanCloseMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemGetCanClose",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemGetCanClose"
        })


#endif

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

foreign import ccall "dzl_dock_item_get_can_minimize" dzl_dock_item_get_can_minimize :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO CInt

-- | /No description available in the introspection data./
dockItemGetCanMinimize ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Interfaces.DockItem.DockItem'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the widget can be minimized.
dockItemGetCanMinimize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockItem a) =>
a -> m Bool
dockItemGetCanMinimize a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr DockItem -> IO CInt
dzl_dock_item_get_can_minimize Ptr DockItem
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DockItemGetCanMinimizeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDockItem a) => O.OverloadedMethod DockItemGetCanMinimizeMethodInfo a signature where
    overloadedMethod = dockItemGetCanMinimize

instance O.OverloadedMethodInfo DockItemGetCanMinimizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemGetCanMinimize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemGetCanMinimize"
        })


#endif

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

foreign import ccall "dzl_dock_item_get_child_visible" dzl_dock_item_get_child_visible :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    Ptr DockItem ->                         -- child : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO CInt

-- | /No description available in the introspection data./
dockItemGetChildVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a, IsDockItem b) =>
    a
    -> b
    -> m Bool
dockItemGetChildVisible :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDockItem a, IsDockItem b) =>
a -> b -> m Bool
dockItemGetChildVisible a
self b
child = IO Bool -> m Bool
forall a. IO a -> m a
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 DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockItem
child' <- b -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    CInt
result <- Ptr DockItem -> Ptr DockItem -> IO CInt
dzl_dock_item_get_child_visible Ptr DockItem
self' Ptr DockItem
child'
    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
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DockItemGetChildVisibleMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsDockItem a, IsDockItem b) => O.OverloadedMethod DockItemGetChildVisibleMethodInfo a signature where
    overloadedMethod = dockItemGetChildVisible

instance O.OverloadedMethodInfo DockItemGetChildVisibleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemGetChildVisible",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemGetChildVisible"
        })


#endif

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

foreign import ccall "dzl_dock_item_get_icon_name" dzl_dock_item_get_icon_name :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO CString

-- | Gets the icon_name for the t'GI.Dazzle.Interfaces.DockItem.DockItem'.
-- 
-- Generally, you want to use a t'GI.Dazzle.Objects.DockWidget.DockWidget' which has a \"icon-name\" property
-- you can set. But this can be helpful for integration of various container
-- widgets.
dockItemGetIconName ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Interfaces.DockItem.DockItem'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ A newly allocated string or 'P.Nothing'.
dockItemGetIconName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockItem a) =>
a -> m (Maybe Text)
dockItemGetIconName a
self = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
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 DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr DockItem -> IO CString
dzl_dock_item_get_icon_name Ptr DockItem
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'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo DockItemGetIconNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemGetIconName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemGetIconName"
        })


#endif

-- method DockItem::get_manager
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlDockItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Dazzle" , name = "DockManager" })
-- throws : False
-- Skip return : False

foreign import ccall "dzl_dock_item_get_manager" dzl_dock_item_get_manager :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO (Ptr Dazzle.DockManager.DockManager)

-- | Gets the dock manager for this dock item.
dockItemGetManager ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Interfaces.DockItem.DockItem'
    -> m (Maybe Dazzle.DockManager.DockManager)
    -- ^ __Returns:__ A @/DzlDockmanager/@.
dockItemGetManager :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockItem a) =>
a -> m (Maybe DockManager)
dockItemGetManager a
self = IO (Maybe DockManager) -> m (Maybe DockManager)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DockManager) -> m (Maybe DockManager))
-> IO (Maybe DockManager) -> m (Maybe DockManager)
forall a b. (a -> b) -> a -> b
$ do
    Ptr DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockManager
result <- Ptr DockItem -> IO (Ptr DockManager)
dzl_dock_item_get_manager Ptr DockItem
self'
    Maybe DockManager
maybeResult <- Ptr DockManager
-> (Ptr DockManager -> IO DockManager) -> IO (Maybe DockManager)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DockManager
result ((Ptr DockManager -> IO DockManager) -> IO (Maybe DockManager))
-> (Ptr DockManager -> IO DockManager) -> IO (Maybe DockManager)
forall a b. (a -> b) -> a -> b
$ \Ptr DockManager
result' -> do
        DockManager
result'' <- ((ManagedPtr DockManager -> DockManager)
-> Ptr DockManager -> IO DockManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DockManager -> DockManager
Dazzle.DockManager.DockManager) Ptr DockManager
result'
        DockManager -> IO DockManager
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DockManager
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe DockManager -> IO (Maybe DockManager)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DockManager
maybeResult

#if defined(ENABLE_OVERLOADING)
data DockItemGetManagerMethodInfo
instance (signature ~ (m (Maybe Dazzle.DockManager.DockManager)), MonadIO m, IsDockItem a) => O.OverloadedMethod DockItemGetManagerMethodInfo a signature where
    overloadedMethod = dockItemGetManager

instance O.OverloadedMethodInfo DockItemGetManagerMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemGetManager",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemGetManager"
        })


#endif

-- method DockItem::get_parent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Dazzle" , name = "DockItem" })
-- throws : False
-- Skip return : False

foreign import ccall "dzl_dock_item_get_parent" dzl_dock_item_get_parent :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO (Ptr DockItem)

-- | Gets the parent t'GI.Dazzle.Interfaces.DockItem.DockItem', or 'P.Nothing'.
dockItemGetParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a) =>
    a
    -> m (Maybe DockItem)
    -- ^ __Returns:__ A t'GI.Dazzle.Interfaces.DockItem.DockItem' or 'P.Nothing'.
dockItemGetParent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockItem a) =>
a -> m (Maybe DockItem)
dockItemGetParent a
self = IO (Maybe DockItem) -> m (Maybe DockItem)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DockItem) -> m (Maybe DockItem))
-> IO (Maybe DockItem) -> m (Maybe DockItem)
forall a b. (a -> b) -> a -> b
$ do
    Ptr DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockItem
result <- Ptr DockItem -> IO (Ptr DockItem)
dzl_dock_item_get_parent Ptr DockItem
self'
    Maybe DockItem
maybeResult <- Ptr DockItem
-> (Ptr DockItem -> IO DockItem) -> IO (Maybe DockItem)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DockItem
result ((Ptr DockItem -> IO DockItem) -> IO (Maybe DockItem))
-> (Ptr DockItem -> IO DockItem) -> IO (Maybe DockItem)
forall a b. (a -> b) -> a -> b
$ \Ptr DockItem
result' -> do
        DockItem
result'' <- ((ManagedPtr DockItem -> DockItem) -> Ptr DockItem -> IO DockItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DockItem -> DockItem
DockItem) Ptr DockItem
result'
        DockItem -> IO DockItem
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DockItem
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe DockItem -> IO (Maybe DockItem)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DockItem
maybeResult

#if defined(ENABLE_OVERLOADING)
data DockItemGetParentMethodInfo
instance (signature ~ (m (Maybe DockItem)), MonadIO m, IsDockItem a) => O.OverloadedMethod DockItemGetParentMethodInfo a signature where
    overloadedMethod = dockItemGetParent

instance O.OverloadedMethodInfo DockItemGetParentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemGetParent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemGetParent"
        })


#endif

-- method DockItem::get_title
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlDockItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "dzl_dock_item_get_title" dzl_dock_item_get_title :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO CString

-- | Gets the title for the t'GI.Dazzle.Interfaces.DockItem.DockItem'.
-- 
-- Generally, you want to use a t'GI.Dazzle.Objects.DockWidget.DockWidget' which has a \"title\" property you
-- can set. But this can be helpful for integration of various container
-- widgets.
dockItemGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Interfaces.DockItem.DockItem'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ A newly allocated string or 'P.Nothing'.
dockItemGetTitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockItem a) =>
a -> m (Maybe Text)
dockItemGetTitle a
self = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
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 DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr DockItem -> IO CString
dzl_dock_item_get_title Ptr DockItem
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'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo DockItemGetTitleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemGetTitle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemGetTitle"
        })


#endif

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

foreign import ccall "dzl_dock_item_has_widgets" dzl_dock_item_has_widgets :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO CInt

-- | /No description available in the introspection data./
dockItemHasWidgets ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a) =>
    a
    -> m Bool
dockItemHasWidgets :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockItem a) =>
a -> m Bool
dockItemHasWidgets a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr DockItem -> IO CInt
dzl_dock_item_has_widgets Ptr DockItem
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DockItemHasWidgetsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDockItem a) => O.OverloadedMethod DockItemHasWidgetsMethodInfo a signature where
    overloadedMethod = dockItemHasWidgets

instance O.OverloadedMethodInfo DockItemHasWidgetsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemHasWidgets",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemHasWidgets"
        })


#endif

-- method DockItem::minimize
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #DzlDockItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlDockItem that is a child of @self"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PositionType" }
--           , direction = DirectionInout
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A location for a #GtkPositionType"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dzl_dock_item_minimize" dzl_dock_item_minimize :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    Ptr DockItem ->                         -- child : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    Ptr CUInt ->                            -- position : TInterface (Name {namespace = "Gtk", name = "PositionType"})
    IO CInt

-- | This requests that /@self@/ minimize /@child@/ if it knows how.
-- 
-- If not, it should suggest the gravity for /@child@/ if it knows how to
-- determine that. For example, a t'GI.Dazzle.Objects.DockBin.DockBin' might know if the widget was part
-- of the right panel and therefore may set /@position@/ to 'GI.Gtk.Enums.PositionTypeRight'.
dockItemMinimize ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a, IsDockItem b) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Interfaces.DockItem.DockItem'
    -> b
    -- ^ /@child@/: A t'GI.Dazzle.Interfaces.DockItem.DockItem' that is a child of /@self@/
    -> Gtk.Enums.PositionType
    -- ^ /@position@/: A location for a t'GI.Gtk.Enums.PositionType'
    -> m ((Bool, Gtk.Enums.PositionType))
    -- ^ __Returns:__ 'P.True' if /@child@/ was minimized. Otherwise 'P.False' and /@position@/
    --   may be updated to a suggested position.
dockItemMinimize :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDockItem a, IsDockItem b) =>
a -> b -> PositionType -> m (Bool, PositionType)
dockItemMinimize a
self b
child PositionType
position = IO (Bool, PositionType) -> m (Bool, PositionType)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, PositionType) -> m (Bool, PositionType))
-> IO (Bool, PositionType) -> m (Bool, PositionType)
forall a b. (a -> b) -> a -> b
$ do
    Ptr DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockItem
child' <- b -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    let position' :: CUInt
position' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PositionType -> Int) -> PositionType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PositionType -> Int
forall a. Enum a => a -> Int
fromEnum) PositionType
position
    Ptr CUInt
position'' <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr CUInt
position'' CUInt
position'
    CInt
result <- Ptr DockItem -> Ptr DockItem -> Ptr CUInt -> IO CInt
dzl_dock_item_minimize Ptr DockItem
self' Ptr DockItem
child' Ptr CUInt
position''
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CUInt
position''' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
position''
    let position'''' :: PositionType
position'''' = (Int -> PositionType
forall a. Enum a => Int -> a
toEnum (Int -> PositionType) -> (CUInt -> Int) -> CUInt -> PositionType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
position'''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
position''
    (Bool, PositionType) -> IO (Bool, PositionType)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', PositionType
position'''')

#if defined(ENABLE_OVERLOADING)
data DockItemMinimizeMethodInfo
instance (signature ~ (b -> Gtk.Enums.PositionType -> m ((Bool, Gtk.Enums.PositionType))), MonadIO m, IsDockItem a, IsDockItem b) => O.OverloadedMethod DockItemMinimizeMethodInfo a signature where
    overloadedMethod = dockItemMinimize

instance O.OverloadedMethodInfo DockItemMinimizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemMinimize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemMinimize"
        })


#endif

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

foreign import ccall "dzl_dock_item_needs_attention" dzl_dock_item_needs_attention :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO ()

-- | Emits the \"needs-attention\" signal.
-- 
-- /Since: 3.34/
dockItemNeedsAttention ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Interfaces.DockItem.DockItem'
    -> m ()
dockItemNeedsAttention :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockItem a) =>
a -> m ()
dockItemNeedsAttention a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockItem -> IO ()
dzl_dock_item_needs_attention Ptr DockItem
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DockItemNeedsAttentionMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDockItem a) => O.OverloadedMethod DockItemNeedsAttentionMethodInfo a signature where
    overloadedMethod = dockItemNeedsAttention

instance O.OverloadedMethodInfo DockItemNeedsAttentionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemNeedsAttention",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemNeedsAttention"
        })


#endif

-- method DockItem::present
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlDockItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_dock_item_present" dzl_dock_item_present :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO ()

-- | This widget will walk the widget hierarchy to ensure that the
-- dock item is visible to the user.
dockItemPresent ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Interfaces.DockItem.DockItem'
    -> m ()
dockItemPresent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockItem a) =>
a -> m ()
dockItemPresent a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockItem -> IO ()
dzl_dock_item_present Ptr DockItem
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DockItemPresentMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDockItem a) => O.OverloadedMethod DockItemPresentMethodInfo a signature where
    overloadedMethod = dockItemPresent

instance O.OverloadedMethodInfo DockItemPresentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemPresent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemPresent"
        })


#endif

-- method DockItem::present_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_dock_item_present_child" dzl_dock_item_present_child :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    Ptr DockItem ->                         -- child : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO ()

-- | /No description available in the introspection data./
dockItemPresentChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a, IsDockItem b) =>
    a
    -> b
    -> m ()
dockItemPresentChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDockItem a, IsDockItem b) =>
a -> b -> m ()
dockItemPresentChild a
self b
child = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockItem
child' <- b -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr DockItem -> Ptr DockItem -> IO ()
dzl_dock_item_present_child Ptr DockItem
self' Ptr DockItem
child'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DockItemPresentChildMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDockItem a, IsDockItem b) => O.OverloadedMethod DockItemPresentChildMethodInfo a signature where
    overloadedMethod = dockItemPresentChild

instance O.OverloadedMethodInfo DockItemPresentChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemPresentChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemPresentChild"
        })


#endif

-- method DockItem::ref_gicon
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #DzlDockItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "Icon" })
-- throws : False
-- Skip return : False

foreign import ccall "dzl_dock_item_ref_gicon" dzl_dock_item_ref_gicon :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO (Ptr Gio.Icon.Icon)

-- | Gets a t'GI.Gio.Interfaces.Icon.Icon' for the dock item, if any has been set.
-- 
-- If an icon-name has been set, a new t'GI.Gio.Interfaces.Icon.Icon' for that icon-name
-- may be returned.
-- 
-- /Since: 3.34/
dockItemRefGicon ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Interfaces.DockItem.DockItem'
    -> m (Maybe Gio.Icon.Icon)
    -- ^ __Returns:__ a t'GI.Gio.Interfaces.Icon.Icon' or 'P.Nothing'
dockItemRefGicon :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockItem a) =>
a -> m (Maybe Icon)
dockItemRefGicon a
self = IO (Maybe Icon) -> m (Maybe Icon)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Icon) -> m (Maybe Icon))
-> IO (Maybe Icon) -> m (Maybe Icon)
forall a b. (a -> b) -> a -> b
$ do
    Ptr DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Icon
result <- Ptr DockItem -> IO (Ptr Icon)
dzl_dock_item_ref_gicon Ptr DockItem
self'
    Maybe Icon
maybeResult <- Ptr Icon -> (Ptr Icon -> IO Icon) -> IO (Maybe Icon)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Icon
result ((Ptr Icon -> IO Icon) -> IO (Maybe Icon))
-> (Ptr Icon -> IO Icon) -> IO (Maybe Icon)
forall a b. (a -> b) -> a -> b
$ \Ptr Icon
result' -> do
        Icon
result'' <- ((ManagedPtr Icon -> Icon) -> Ptr Icon -> IO Icon
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Icon -> Icon
Gio.Icon.Icon) Ptr Icon
result'
        Icon -> IO Icon
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Icon
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Icon -> IO (Maybe Icon)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Icon
maybeResult

#if defined(ENABLE_OVERLOADING)
data DockItemRefGiconMethodInfo
instance (signature ~ (m (Maybe Gio.Icon.Icon)), MonadIO m, IsDockItem a) => O.OverloadedMethod DockItemRefGiconMethodInfo a signature where
    overloadedMethod = dockItemRefGicon

instance O.OverloadedMethodInfo DockItemRefGiconMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemRefGicon",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemRefGicon"
        })


#endif

-- method DockItem::release
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlDockItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_dock_item_release" dzl_dock_item_release :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    Ptr DockItem ->                         -- child : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO ()

-- | This virtual method should remove /@child@/ from /@self@/ if the
-- dock item knows how to do so. For example, the t'GI.Dazzle.Objects.DockStack.DockStack'
-- will remove /@child@/ from it\'s internal t'GI.Gtk.Objects.Stack.Stack'.
-- 
-- After the virtual function has been executed, child tracking
-- will be removed so that t'GI.Dazzle.Interfaces.DockItem.DockItem' implementations do not
-- need to implement themselves.
dockItemRelease ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a, IsDockItem b) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Interfaces.DockItem.DockItem'
    -> b
    -> m ()
dockItemRelease :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDockItem a, IsDockItem b) =>
a -> b -> m ()
dockItemRelease a
self b
child = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockItem
child' <- b -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr DockItem -> Ptr DockItem -> IO ()
dzl_dock_item_release Ptr DockItem
self' Ptr DockItem
child'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DockItemReleaseMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDockItem a, IsDockItem b) => O.OverloadedMethod DockItemReleaseMethodInfo a signature where
    overloadedMethod = dockItemRelease

instance O.OverloadedMethodInfo DockItemReleaseMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemRelease",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemRelease"
        })


#endif

-- method DockItem::set_child_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_visible"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_dock_item_set_child_visible" dzl_dock_item_set_child_visible :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    Ptr DockItem ->                         -- child : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    CInt ->                                 -- child_visible : TBasicType TBoolean
    IO ()

-- | /No description available in the introspection data./
dockItemSetChildVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a, IsDockItem b) =>
    a
    -> b
    -> Bool
    -> m ()
dockItemSetChildVisible :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDockItem a, IsDockItem b) =>
a -> b -> Bool -> m ()
dockItemSetChildVisible a
self b
child Bool
childVisible = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockItem
child' <- b -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    let childVisible' :: CInt
childVisible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
childVisible
    Ptr DockItem -> Ptr DockItem -> CInt -> IO ()
dzl_dock_item_set_child_visible Ptr DockItem
self' Ptr DockItem
child' CInt
childVisible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DockItemSetChildVisibleMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsDockItem a, IsDockItem b) => O.OverloadedMethod DockItemSetChildVisibleMethodInfo a signature where
    overloadedMethod = dockItemSetChildVisible

instance O.OverloadedMethodInfo DockItemSetChildVisibleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemSetChildVisible",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemSetChildVisible"
        })


#endif

-- method DockItem::set_manager
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlDockItem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "manager"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockManager" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlDockManager" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_dock_item_set_manager" dzl_dock_item_set_manager :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    Ptr Dazzle.DockManager.DockManager ->   -- manager : TInterface (Name {namespace = "Dazzle", name = "DockManager"})
    IO ()

-- | Sets the dock manager for this t'GI.Dazzle.Interfaces.DockItem.DockItem'.
dockItemSetManager ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a, Dazzle.DockManager.IsDockManager b) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Interfaces.DockItem.DockItem'
    -> Maybe (b)
    -- ^ /@manager@/: A t'GI.Dazzle.Objects.DockManager.DockManager'
    -> m ()
dockItemSetManager :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDockItem a, IsDockManager b) =>
a -> Maybe b -> m ()
dockItemSetManager a
self Maybe b
manager = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockManager
maybeManager <- case Maybe b
manager of
        Maybe b
Nothing -> Ptr DockManager -> IO (Ptr DockManager)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr DockManager
forall a. Ptr a
nullPtr
        Just b
jManager -> do
            Ptr DockManager
jManager' <- b -> IO (Ptr DockManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jManager
            Ptr DockManager -> IO (Ptr DockManager)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr DockManager
jManager'
    Ptr DockItem -> Ptr DockManager -> IO ()
dzl_dock_item_set_manager Ptr DockItem
self' Ptr DockManager
maybeManager
    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
manager b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DockItemSetManagerMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDockItem a, Dazzle.DockManager.IsDockManager b) => O.OverloadedMethod DockItemSetManagerMethodInfo a signature where
    overloadedMethod = dockItemSetManager

instance O.OverloadedMethodInfo DockItemSetManagerMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemSetManager",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemSetManager"
        })


#endif

-- method DockItem::update_visibility
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_dock_item_update_visibility" dzl_dock_item_update_visibility :: 
    Ptr DockItem ->                         -- self : TInterface (Name {namespace = "Dazzle", name = "DockItem"})
    IO ()

-- | /No description available in the introspection data./
dockItemUpdateVisibility ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockItem a) =>
    a
    -> m ()
dockItemUpdateVisibility :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockItem a) =>
a -> m ()
dockItemUpdateVisibility a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DockItem
self' <- a -> IO (Ptr DockItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockItem -> IO ()
dzl_dock_item_update_visibility Ptr DockItem
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DockItemUpdateVisibilityMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDockItem a) => O.OverloadedMethod DockItemUpdateVisibilityMethodInfo a signature where
    overloadedMethod = dockItemUpdateVisibility

instance O.OverloadedMethodInfo DockItemUpdateVisibilityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem.dockItemUpdateVisibility",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#v:dockItemUpdateVisibility"
        })


#endif

-- signal DockItem::manager-set
-- | /No description available in the introspection data./
type DockItemManagerSetCallback =
    Dazzle.DockManager.DockManager
    -> IO ()

type C_DockItemManagerSetCallback =
    Ptr DockItem ->                         -- object
    Ptr Dazzle.DockManager.DockManager ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_DockItemManagerSetCallback :: 
    GObject a => (a -> DockItemManagerSetCallback) ->
    C_DockItemManagerSetCallback
wrap_DockItemManagerSetCallback :: forall a.
GObject a =>
(a -> DockItemManagerSetCallback) -> C_DockItemManagerSetCallback
wrap_DockItemManagerSetCallback a -> DockItemManagerSetCallback
gi'cb Ptr DockItem
gi'selfPtr Ptr DockManager
object Ptr ()
_ = do
    DockManager
object' <- ((ManagedPtr DockManager -> DockManager)
-> Ptr DockManager -> IO DockManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DockManager -> DockManager
Dazzle.DockManager.DockManager) Ptr DockManager
object
    Ptr DockItem -> (DockItem -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr DockItem
gi'selfPtr ((DockItem -> IO ()) -> IO ()) -> (DockItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \DockItem
gi'self -> a -> DockItemManagerSetCallback
gi'cb (DockItem -> a
forall a b. Coercible a b => a -> b
Coerce.coerce DockItem
gi'self)  DockManager
object'


-- | Connect a signal handler for the [managerSet](#signal:managerSet) 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' dockItem #managerSet callback
-- @
-- 
-- 
onDockItemManagerSet :: (IsDockItem a, MonadIO m) => a -> ((?self :: a) => DockItemManagerSetCallback) -> m SignalHandlerId
onDockItemManagerSet :: forall a (m :: * -> *).
(IsDockItem a, MonadIO m) =>
a
-> ((?self::a) => DockItemManagerSetCallback) -> m SignalHandlerId
onDockItemManagerSet a
obj (?self::a) => DockItemManagerSetCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 -> DockItemManagerSetCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DockItemManagerSetCallback
DockItemManagerSetCallback
cb
    let wrapped' :: C_DockItemManagerSetCallback
wrapped' = (a -> DockItemManagerSetCallback) -> C_DockItemManagerSetCallback
forall a.
GObject a =>
(a -> DockItemManagerSetCallback) -> C_DockItemManagerSetCallback
wrap_DockItemManagerSetCallback a -> DockItemManagerSetCallback
wrapped
    FunPtr C_DockItemManagerSetCallback
wrapped'' <- C_DockItemManagerSetCallback
-> IO (FunPtr C_DockItemManagerSetCallback)
mk_DockItemManagerSetCallback C_DockItemManagerSetCallback
wrapped'
    a
-> Text
-> FunPtr C_DockItemManagerSetCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"manager-set" FunPtr C_DockItemManagerSetCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [managerSet](#signal:managerSet) 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' dockItem #managerSet callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterDockItemManagerSet :: (IsDockItem a, MonadIO m) => a -> ((?self :: a) => DockItemManagerSetCallback) -> m SignalHandlerId
afterDockItemManagerSet :: forall a (m :: * -> *).
(IsDockItem a, MonadIO m) =>
a
-> ((?self::a) => DockItemManagerSetCallback) -> m SignalHandlerId
afterDockItemManagerSet a
obj (?self::a) => DockItemManagerSetCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 -> DockItemManagerSetCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DockItemManagerSetCallback
DockItemManagerSetCallback
cb
    let wrapped' :: C_DockItemManagerSetCallback
wrapped' = (a -> DockItemManagerSetCallback) -> C_DockItemManagerSetCallback
forall a.
GObject a =>
(a -> DockItemManagerSetCallback) -> C_DockItemManagerSetCallback
wrap_DockItemManagerSetCallback a -> DockItemManagerSetCallback
wrapped
    FunPtr C_DockItemManagerSetCallback
wrapped'' <- C_DockItemManagerSetCallback
-> IO (FunPtr C_DockItemManagerSetCallback)
mk_DockItemManagerSetCallback C_DockItemManagerSetCallback
wrapped'
    a
-> Text
-> FunPtr C_DockItemManagerSetCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"manager-set" FunPtr C_DockItemManagerSetCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DockItemManagerSetSignalInfo
instance SignalInfo DockItemManagerSetSignalInfo where
    type HaskellCallbackType DockItemManagerSetSignalInfo = DockItemManagerSetCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DockItemManagerSetCallback cb
        cb'' <- mk_DockItemManagerSetCallback cb'
        connectSignalFunPtr obj "manager-set" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem::manager-set"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#g:signal:managerSet"})

#endif

-- signal DockItem::needs-attention
-- | /No description available in the introspection data./
type DockItemNeedsAttentionCallback =
    IO ()

type C_DockItemNeedsAttentionCallback =
    Ptr DockItem ->                         -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_DockItemNeedsAttentionCallback :: 
    GObject a => (a -> DockItemNeedsAttentionCallback) ->
    C_DockItemNeedsAttentionCallback
wrap_DockItemNeedsAttentionCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_DockItemNeedsAttentionCallback
wrap_DockItemNeedsAttentionCallback a -> IO ()
gi'cb Ptr DockItem
gi'selfPtr Ptr ()
_ = do
    Ptr DockItem -> (DockItem -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr DockItem
gi'selfPtr ((DockItem -> IO ()) -> IO ()) -> (DockItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \DockItem
gi'self -> a -> IO ()
gi'cb (DockItem -> a
forall a b. Coercible a b => a -> b
Coerce.coerce DockItem
gi'self) 


-- | Connect a signal handler for the [needsAttention](#signal:needsAttention) 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' dockItem #needsAttention callback
-- @
-- 
-- 
onDockItemNeedsAttention :: (IsDockItem a, MonadIO m) => a -> ((?self :: a) => DockItemNeedsAttentionCallback) -> m SignalHandlerId
onDockItemNeedsAttention :: forall a (m :: * -> *).
(IsDockItem a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onDockItemNeedsAttention a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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_DockItemNeedsAttentionCallback
wrapped' = (a -> IO ()) -> C_DockItemNeedsAttentionCallback
forall a.
GObject a =>
(a -> IO ()) -> C_DockItemNeedsAttentionCallback
wrap_DockItemNeedsAttentionCallback a -> IO ()
wrapped
    FunPtr C_DockItemNeedsAttentionCallback
wrapped'' <- C_DockItemNeedsAttentionCallback
-> IO (FunPtr C_DockItemNeedsAttentionCallback)
mk_DockItemNeedsAttentionCallback C_DockItemNeedsAttentionCallback
wrapped'
    a
-> Text
-> FunPtr C_DockItemNeedsAttentionCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"needs-attention" FunPtr C_DockItemNeedsAttentionCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [needsAttention](#signal:needsAttention) 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' dockItem #needsAttention callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterDockItemNeedsAttention :: (IsDockItem a, MonadIO m) => a -> ((?self :: a) => DockItemNeedsAttentionCallback) -> m SignalHandlerId
afterDockItemNeedsAttention :: forall a (m :: * -> *).
(IsDockItem a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterDockItemNeedsAttention a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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_DockItemNeedsAttentionCallback
wrapped' = (a -> IO ()) -> C_DockItemNeedsAttentionCallback
forall a.
GObject a =>
(a -> IO ()) -> C_DockItemNeedsAttentionCallback
wrap_DockItemNeedsAttentionCallback a -> IO ()
wrapped
    FunPtr C_DockItemNeedsAttentionCallback
wrapped'' <- C_DockItemNeedsAttentionCallback
-> IO (FunPtr C_DockItemNeedsAttentionCallback)
mk_DockItemNeedsAttentionCallback C_DockItemNeedsAttentionCallback
wrapped'
    a
-> Text
-> FunPtr C_DockItemNeedsAttentionCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"needs-attention" FunPtr C_DockItemNeedsAttentionCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DockItemNeedsAttentionSignalInfo
instance SignalInfo DockItemNeedsAttentionSignalInfo where
    type HaskellCallbackType DockItemNeedsAttentionSignalInfo = DockItemNeedsAttentionCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DockItemNeedsAttentionCallback cb
        cb'' <- mk_DockItemNeedsAttentionCallback cb'
        connectSignalFunPtr obj "needs-attention" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem::needs-attention"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#g:signal:needsAttention"})

#endif

-- signal DockItem::presented
-- | /No description available in the introspection data./
type DockItemPresentedCallback =
    IO ()

type C_DockItemPresentedCallback =
    Ptr DockItem ->                         -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_DockItemPresentedCallback :: 
    GObject a => (a -> DockItemPresentedCallback) ->
    C_DockItemPresentedCallback
wrap_DockItemPresentedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_DockItemNeedsAttentionCallback
wrap_DockItemPresentedCallback a -> IO ()
gi'cb Ptr DockItem
gi'selfPtr Ptr ()
_ = do
    Ptr DockItem -> (DockItem -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr DockItem
gi'selfPtr ((DockItem -> IO ()) -> IO ()) -> (DockItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \DockItem
gi'self -> a -> IO ()
gi'cb (DockItem -> a
forall a b. Coercible a b => a -> b
Coerce.coerce DockItem
gi'self) 


-- | Connect a signal handler for the [presented](#signal:presented) 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' dockItem #presented callback
-- @
-- 
-- 
onDockItemPresented :: (IsDockItem a, MonadIO m) => a -> ((?self :: a) => DockItemPresentedCallback) -> m SignalHandlerId
onDockItemPresented :: forall a (m :: * -> *).
(IsDockItem a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onDockItemPresented a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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_DockItemNeedsAttentionCallback
wrapped' = (a -> IO ()) -> C_DockItemNeedsAttentionCallback
forall a.
GObject a =>
(a -> IO ()) -> C_DockItemNeedsAttentionCallback
wrap_DockItemPresentedCallback a -> IO ()
wrapped
    FunPtr C_DockItemNeedsAttentionCallback
wrapped'' <- C_DockItemNeedsAttentionCallback
-> IO (FunPtr C_DockItemNeedsAttentionCallback)
mk_DockItemPresentedCallback C_DockItemNeedsAttentionCallback
wrapped'
    a
-> Text
-> FunPtr C_DockItemNeedsAttentionCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"presented" FunPtr C_DockItemNeedsAttentionCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [presented](#signal:presented) 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' dockItem #presented callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterDockItemPresented :: (IsDockItem a, MonadIO m) => a -> ((?self :: a) => DockItemPresentedCallback) -> m SignalHandlerId
afterDockItemPresented :: forall a (m :: * -> *).
(IsDockItem a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterDockItemPresented a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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_DockItemNeedsAttentionCallback
wrapped' = (a -> IO ()) -> C_DockItemNeedsAttentionCallback
forall a.
GObject a =>
(a -> IO ()) -> C_DockItemNeedsAttentionCallback
wrap_DockItemPresentedCallback a -> IO ()
wrapped
    FunPtr C_DockItemNeedsAttentionCallback
wrapped'' <- C_DockItemNeedsAttentionCallback
-> IO (FunPtr C_DockItemNeedsAttentionCallback)
mk_DockItemPresentedCallback C_DockItemNeedsAttentionCallback
wrapped'
    a
-> Text
-> FunPtr C_DockItemNeedsAttentionCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"presented" FunPtr C_DockItemNeedsAttentionCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DockItemPresentedSignalInfo
instance SignalInfo DockItemPresentedSignalInfo where
    type HaskellCallbackType DockItemPresentedSignalInfo = DockItemPresentedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DockItemPresentedCallback cb
        cb'' <- mk_DockItemPresentedCallback cb'
        connectSignalFunPtr obj "presented" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Interfaces.DockItem::presented"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Interfaces-DockItem.html#g:signal:presented"})

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DockItem = DockItemSignalList
type DockItemSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("managerSet", DockItemManagerSetSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("needsAttention", DockItemNeedsAttentionSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("presented", DockItemPresentedSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, DK.Type)])

#endif