{-# LANGUAGE 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.Handy.Objects.Squeezer
    ( 

-- * Exported types
    Squeezer(..)                            ,
    IsSqueezer                              ,
    toSqueezer                              ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [add]("GI.Gtk.Objects.Container#g:method:add"), [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"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [canActivateAccel]("GI.Gtk.Objects.Widget#g:method:canActivateAccel"), [checkResize]("GI.Gtk.Objects.Container#g:method:checkResize"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [childGetProperty]("GI.Gtk.Objects.Container#g:method:childGetProperty"), [childNotify]("GI.Gtk.Objects.Container#g:method:childNotify"), [childNotifyByPspec]("GI.Gtk.Objects.Container#g:method:childNotifyByPspec"), [childSetProperty]("GI.Gtk.Objects.Container#g:method:childSetProperty"), [childType]("GI.Gtk.Objects.Container#g:method:childType"), [classPath]("GI.Gtk.Objects.Widget#g:method:classPath"), [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"), [ensureStyle]("GI.Gtk.Objects.Widget#g:method:ensureStyle"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [event]("GI.Gtk.Objects.Widget#g:method:event"), [forall]("GI.Gtk.Objects.Container#g:method:forall"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.Gtk.Objects.Container#g:method:foreach"), [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"), [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"), [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"), [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"), [propagateDraw]("GI.Gtk.Objects.Container#g:method:propagateDraw"), [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"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [regionIntersect]("GI.Gtk.Objects.Widget#g:method:regionIntersect"), [registerWindow]("GI.Gtk.Objects.Widget#g:method:registerWindow"), [remove]("GI.Gtk.Objects.Container#g:method:remove"), [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"), [resizeChildren]("GI.Gtk.Objects.Container#g:method:resizeChildren"), [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"), [unsetFocusChain]("GI.Gtk.Objects.Container#g:method:unsetFocusChain"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [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"), [getBorderWidth]("GI.Gtk.Objects.Container#g:method:getBorderWidth"), [getCanDefault]("GI.Gtk.Objects.Widget#g:method:getCanDefault"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getChildEnabled]("GI.Handy.Objects.Squeezer#g:method:getChildEnabled"), [getChildRequisition]("GI.Gtk.Objects.Widget#g:method:getChildRequisition"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getChildren]("GI.Gtk.Objects.Container#g:method:getChildren"), [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"), [getFocusChain]("GI.Gtk.Objects.Container#g:method:getFocusChain"), [getFocusChild]("GI.Gtk.Objects.Container#g:method:getFocusChild"), [getFocusHadjustment]("GI.Gtk.Objects.Container#g:method:getFocusHadjustment"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusVadjustment]("GI.Gtk.Objects.Container#g:method:getFocusVadjustment"), [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"), [getHomogeneous]("GI.Handy.Objects.Squeezer#g:method:getHomogeneous"), [getInternalChild]("GI.Gtk.Interfaces.Buildable#g:method:getInternalChild"), [getInterpolateSize]("GI.Handy.Objects.Squeezer#g:method:getInterpolateSize"), [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"), [getOrientation]("GI.Gtk.Interfaces.Orientable#g:method:getOrientation"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getParentWindow]("GI.Gtk.Objects.Widget#g:method:getParentWindow"), [getPath]("GI.Gtk.Objects.Widget#g:method:getPath"), [getPathForChild]("GI.Gtk.Objects.Container#g:method:getPathForChild"), [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"), [getResizeMode]("GI.Gtk.Objects.Container#g:method:getResizeMode"), [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"), [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"), [getTransitionDuration]("GI.Handy.Objects.Squeezer#g:method:getTransitionDuration"), [getTransitionRunning]("GI.Handy.Objects.Squeezer#g:method:getTransitionRunning"), [getTransitionType]("GI.Handy.Objects.Squeezer#g:method:getTransitionType"), [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"), [getVisibleChild]("GI.Handy.Objects.Squeezer#g:method:getVisibleChild"), [getVisual]("GI.Gtk.Objects.Widget#g:method:getVisual"), [getWindow]("GI.Gtk.Objects.Widget#g:method:getWindow"), [getXalign]("GI.Handy.Objects.Squeezer#g:method:getXalign"), [getYalign]("GI.Handy.Objects.Squeezer#g:method:getYalign").
-- 
-- ==== 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"), [setBorderWidth]("GI.Gtk.Objects.Container#g:method:setBorderWidth"), [setBuildableProperty]("GI.Gtk.Interfaces.Buildable#g:method:setBuildableProperty"), [setCanDefault]("GI.Gtk.Objects.Widget#g:method:setCanDefault"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setChildEnabled]("GI.Handy.Objects.Squeezer#g:method:setChildEnabled"), [setChildVisible]("GI.Gtk.Objects.Widget#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"), [setFocusChain]("GI.Gtk.Objects.Container#g:method:setFocusChain"), [setFocusChild]("GI.Gtk.Objects.Container#g:method:setFocusChild"), [setFocusHadjustment]("GI.Gtk.Objects.Container#g:method:setFocusHadjustment"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusVadjustment]("GI.Gtk.Objects.Container#g:method:setFocusVadjustment"), [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"), [setHomogeneous]("GI.Handy.Objects.Squeezer#g:method:setHomogeneous"), [setInterpolateSize]("GI.Handy.Objects.Squeezer#g:method:setInterpolateSize"), [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"), [setOrientation]("GI.Gtk.Interfaces.Orientable#g:method:setOrientation"), [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"), [setReallocateRedraws]("GI.Gtk.Objects.Container#g:method:setReallocateRedraws"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setRedrawOnAllocate]("GI.Gtk.Objects.Widget#g:method:setRedrawOnAllocate"), [setResizeMode]("GI.Gtk.Objects.Container#g:method:setResizeMode"), [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"), [setTransitionDuration]("GI.Handy.Objects.Squeezer#g:method:setTransitionDuration"), [setTransitionType]("GI.Handy.Objects.Squeezer#g:method:setTransitionType"), [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"), [setXalign]("GI.Handy.Objects.Squeezer#g:method:setXalign"), [setYalign]("GI.Handy.Objects.Squeezer#g:method:setYalign").

#if defined(ENABLE_OVERLOADING)
    ResolveSqueezerMethod                   ,
#endif

-- ** getChildEnabled #method:getChildEnabled#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetChildEnabledMethodInfo       ,
#endif
    squeezerGetChildEnabled                 ,


-- ** getHomogeneous #method:getHomogeneous#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetHomogeneousMethodInfo        ,
#endif
    squeezerGetHomogeneous                  ,


-- ** getInterpolateSize #method:getInterpolateSize#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetInterpolateSizeMethodInfo    ,
#endif
    squeezerGetInterpolateSize              ,


-- ** getTransitionDuration #method:getTransitionDuration#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetTransitionDurationMethodInfo ,
#endif
    squeezerGetTransitionDuration           ,


-- ** getTransitionRunning #method:getTransitionRunning#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetTransitionRunningMethodInfo  ,
#endif
    squeezerGetTransitionRunning            ,


-- ** getTransitionType #method:getTransitionType#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetTransitionTypeMethodInfo     ,
#endif
    squeezerGetTransitionType               ,


-- ** getVisibleChild #method:getVisibleChild#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetVisibleChildMethodInfo       ,
#endif
    squeezerGetVisibleChild                 ,


-- ** getXalign #method:getXalign#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetXalignMethodInfo             ,
#endif
    squeezerGetXalign                       ,


-- ** getYalign #method:getYalign#

#if defined(ENABLE_OVERLOADING)
    SqueezerGetYalignMethodInfo             ,
#endif
    squeezerGetYalign                       ,


-- ** new #method:new#

    squeezerNew                             ,


-- ** setChildEnabled #method:setChildEnabled#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetChildEnabledMethodInfo       ,
#endif
    squeezerSetChildEnabled                 ,


-- ** setHomogeneous #method:setHomogeneous#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetHomogeneousMethodInfo        ,
#endif
    squeezerSetHomogeneous                  ,


-- ** setInterpolateSize #method:setInterpolateSize#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetInterpolateSizeMethodInfo    ,
#endif
    squeezerSetInterpolateSize              ,


-- ** setTransitionDuration #method:setTransitionDuration#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetTransitionDurationMethodInfo ,
#endif
    squeezerSetTransitionDuration           ,


-- ** setTransitionType #method:setTransitionType#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetTransitionTypeMethodInfo     ,
#endif
    squeezerSetTransitionType               ,


-- ** setXalign #method:setXalign#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetXalignMethodInfo             ,
#endif
    squeezerSetXalign                       ,


-- ** setYalign #method:setYalign#

#if defined(ENABLE_OVERLOADING)
    SqueezerSetYalignMethodInfo             ,
#endif
    squeezerSetYalign                       ,




 -- * Properties


-- ** homogeneous #attr:homogeneous#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    SqueezerHomogeneousPropertyInfo         ,
#endif
    constructSqueezerHomogeneous            ,
    getSqueezerHomogeneous                  ,
    setSqueezerHomogeneous                  ,
#if defined(ENABLE_OVERLOADING)
    squeezerHomogeneous                     ,
#endif


-- ** interpolateSize #attr:interpolateSize#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    SqueezerInterpolateSizePropertyInfo     ,
#endif
    constructSqueezerInterpolateSize        ,
    getSqueezerInterpolateSize              ,
    setSqueezerInterpolateSize              ,
#if defined(ENABLE_OVERLOADING)
    squeezerInterpolateSize                 ,
#endif


-- ** transitionDuration #attr:transitionDuration#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    SqueezerTransitionDurationPropertyInfo  ,
#endif
    constructSqueezerTransitionDuration     ,
    getSqueezerTransitionDuration           ,
    setSqueezerTransitionDuration           ,
#if defined(ENABLE_OVERLOADING)
    squeezerTransitionDuration              ,
#endif


-- ** transitionRunning #attr:transitionRunning#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    SqueezerTransitionRunningPropertyInfo   ,
#endif
    getSqueezerTransitionRunning            ,
#if defined(ENABLE_OVERLOADING)
    squeezerTransitionRunning               ,
#endif


-- ** transitionType #attr:transitionType#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    SqueezerTransitionTypePropertyInfo      ,
#endif
    constructSqueezerTransitionType         ,
    getSqueezerTransitionType               ,
    setSqueezerTransitionType               ,
#if defined(ENABLE_OVERLOADING)
    squeezerTransitionType                  ,
#endif


-- ** visibleChild #attr:visibleChild#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    SqueezerVisibleChildPropertyInfo        ,
#endif
    getSqueezerVisibleChild                 ,
#if defined(ENABLE_OVERLOADING)
    squeezerVisibleChild                    ,
#endif


-- ** xalign #attr:xalign#
-- | The xalign property determines the horizontal alignment of the children
-- inside the squeezer\'s size allocation.
-- Compare this to t'GI.Gtk.Objects.Widget.Widget':@/halign/@, which determines how the squeezer\'s size
-- allocation is positioned in the space available for the squeezer.
-- The range goes from 0 (start) to 1 (end).
-- 
-- This will affect the position of children too wide to fit in the squeezer
-- as they are fading out.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerXalignPropertyInfo              ,
#endif
    constructSqueezerXalign                 ,
    getSqueezerXalign                       ,
    setSqueezerXalign                       ,
#if defined(ENABLE_OVERLOADING)
    squeezerXalign                          ,
#endif


-- ** yalign #attr:yalign#
-- | The yalign property determines the vertical alignment of the children inside
-- the squeezer\'s size allocation.
-- Compare this to t'GI.Gtk.Objects.Widget.Widget':@/valign/@, which determines how the squeezer\'s size
-- allocation is positioned in the space available for the squeezer.
-- The range goes from 0 (top) to 1 (bottom).
-- 
-- This will affect the position of children too tall to fit in the squeezer
-- as they are fading out.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    SqueezerYalignPropertyInfo              ,
#endif
    constructSqueezerYalign                 ,
    getSqueezerYalign                       ,
    setSqueezerYalign                       ,
#if defined(ENABLE_OVERLOADING)
    squeezerYalign                          ,
#endif




    ) where

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

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

import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.Orientable as Gtk.Orientable
import qualified GI.Gtk.Objects.Container as Gtk.Container
import qualified GI.Gtk.Objects.Widget as Gtk.Widget
import {-# SOURCE #-} qualified GI.Handy.Enums as Handy.Enums

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

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

foreign import ccall "hdy_squeezer_get_type"
    c_hdy_squeezer_get_type :: IO B.Types.GType

instance B.Types.TypedObject Squeezer where
    glibType :: IO GType
glibType = IO GType
c_hdy_squeezer_get_type

instance B.Types.GObject Squeezer

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

instance O.HasParentTypes Squeezer
type instance O.ParentTypes Squeezer = '[Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable, Gtk.Orientable.Orientable]

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

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

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

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

#endif

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

#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data SqueezerHomogeneousPropertyInfo
instance AttrInfo SqueezerHomogeneousPropertyInfo where
    type AttrAllowedOps SqueezerHomogeneousPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerHomogeneousPropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerHomogeneousPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SqueezerHomogeneousPropertyInfo = (~) Bool
    type AttrTransferType SqueezerHomogeneousPropertyInfo = Bool
    type AttrGetType SqueezerHomogeneousPropertyInfo = Bool
    type AttrLabel SqueezerHomogeneousPropertyInfo = "homogeneous"
    type AttrOrigin SqueezerHomogeneousPropertyInfo = Squeezer
    attrGet = getSqueezerHomogeneous
    attrSet = setSqueezerHomogeneous
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerHomogeneous
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.homogeneous"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#g:attr:homogeneous"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data SqueezerInterpolateSizePropertyInfo
instance AttrInfo SqueezerInterpolateSizePropertyInfo where
    type AttrAllowedOps SqueezerInterpolateSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerInterpolateSizePropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerInterpolateSizePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SqueezerInterpolateSizePropertyInfo = (~) Bool
    type AttrTransferType SqueezerInterpolateSizePropertyInfo = Bool
    type AttrGetType SqueezerInterpolateSizePropertyInfo = Bool
    type AttrLabel SqueezerInterpolateSizePropertyInfo = "interpolate-size"
    type AttrOrigin SqueezerInterpolateSizePropertyInfo = Squeezer
    attrGet = getSqueezerInterpolateSize
    attrSet = setSqueezerInterpolateSize
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerInterpolateSize
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.interpolateSize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#g:attr:interpolateSize"
        })
#endif

-- VVV Prop "transition-duration"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@transition-duration@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' squeezer #transitionDuration
-- @
getSqueezerTransitionDuration :: (MonadIO m, IsSqueezer o) => o -> m Word32
getSqueezerTransitionDuration :: forall (m :: * -> *) o. (MonadIO m, IsSqueezer o) => o -> m Word32
getSqueezerTransitionDuration o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"transition-duration"

-- | Set the value of the “@transition-duration@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' squeezer [ #transitionDuration 'Data.GI.Base.Attributes.:=' value ]
-- @
setSqueezerTransitionDuration :: (MonadIO m, IsSqueezer o) => o -> Word32 -> m ()
setSqueezerTransitionDuration :: forall (m :: * -> *) o.
(MonadIO m, IsSqueezer o) =>
o -> Word32 -> m ()
setSqueezerTransitionDuration o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"transition-duration" Word32
val

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

#if defined(ENABLE_OVERLOADING)
data SqueezerTransitionDurationPropertyInfo
instance AttrInfo SqueezerTransitionDurationPropertyInfo where
    type AttrAllowedOps SqueezerTransitionDurationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerTransitionDurationPropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerTransitionDurationPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint SqueezerTransitionDurationPropertyInfo = (~) Word32
    type AttrTransferType SqueezerTransitionDurationPropertyInfo = Word32
    type AttrGetType SqueezerTransitionDurationPropertyInfo = Word32
    type AttrLabel SqueezerTransitionDurationPropertyInfo = "transition-duration"
    type AttrOrigin SqueezerTransitionDurationPropertyInfo = Squeezer
    attrGet = getSqueezerTransitionDuration
    attrSet = setSqueezerTransitionDuration
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerTransitionDuration
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.transitionDuration"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#g:attr:transitionDuration"
        })
#endif

-- VVV Prop "transition-running"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data SqueezerTransitionRunningPropertyInfo
instance AttrInfo SqueezerTransitionRunningPropertyInfo where
    type AttrAllowedOps SqueezerTransitionRunningPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint SqueezerTransitionRunningPropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerTransitionRunningPropertyInfo = (~) ()
    type AttrTransferTypeConstraint SqueezerTransitionRunningPropertyInfo = (~) ()
    type AttrTransferType SqueezerTransitionRunningPropertyInfo = ()
    type AttrGetType SqueezerTransitionRunningPropertyInfo = Bool
    type AttrLabel SqueezerTransitionRunningPropertyInfo = "transition-running"
    type AttrOrigin SqueezerTransitionRunningPropertyInfo = Squeezer
    attrGet = getSqueezerTransitionRunning
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.transitionRunning"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#g:attr:transitionRunning"
        })
#endif

-- VVV Prop "transition-type"
   -- Type: TInterface (Name {namespace = "Handy", name = "SqueezerTransitionType"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

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

#if defined(ENABLE_OVERLOADING)
data SqueezerTransitionTypePropertyInfo
instance AttrInfo SqueezerTransitionTypePropertyInfo where
    type AttrAllowedOps SqueezerTransitionTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerTransitionTypePropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerTransitionTypePropertyInfo = (~) Handy.Enums.SqueezerTransitionType
    type AttrTransferTypeConstraint SqueezerTransitionTypePropertyInfo = (~) Handy.Enums.SqueezerTransitionType
    type AttrTransferType SqueezerTransitionTypePropertyInfo = Handy.Enums.SqueezerTransitionType
    type AttrGetType SqueezerTransitionTypePropertyInfo = Handy.Enums.SqueezerTransitionType
    type AttrLabel SqueezerTransitionTypePropertyInfo = "transition-type"
    type AttrOrigin SqueezerTransitionTypePropertyInfo = Squeezer
    attrGet = getSqueezerTransitionType
    attrSet = setSqueezerTransitionType
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerTransitionType
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.transitionType"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#g:attr:transitionType"
        })
#endif

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

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

#if defined(ENABLE_OVERLOADING)
data SqueezerVisibleChildPropertyInfo
instance AttrInfo SqueezerVisibleChildPropertyInfo where
    type AttrAllowedOps SqueezerVisibleChildPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SqueezerVisibleChildPropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerVisibleChildPropertyInfo = (~) ()
    type AttrTransferTypeConstraint SqueezerVisibleChildPropertyInfo = (~) ()
    type AttrTransferType SqueezerVisibleChildPropertyInfo = ()
    type AttrGetType SqueezerVisibleChildPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel SqueezerVisibleChildPropertyInfo = "visible-child"
    type AttrOrigin SqueezerVisibleChildPropertyInfo = Squeezer
    attrGet = getSqueezerVisibleChild
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.visibleChild"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#g:attr:visibleChild"
        })
#endif

-- VVV Prop "xalign"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

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

#if defined(ENABLE_OVERLOADING)
data SqueezerXalignPropertyInfo
instance AttrInfo SqueezerXalignPropertyInfo where
    type AttrAllowedOps SqueezerXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerXalignPropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerXalignPropertyInfo = (~) Float
    type AttrTransferTypeConstraint SqueezerXalignPropertyInfo = (~) Float
    type AttrTransferType SqueezerXalignPropertyInfo = Float
    type AttrGetType SqueezerXalignPropertyInfo = Float
    type AttrLabel SqueezerXalignPropertyInfo = "xalign"
    type AttrOrigin SqueezerXalignPropertyInfo = Squeezer
    attrGet = getSqueezerXalign
    attrSet = setSqueezerXalign
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerXalign
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.xalign"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#g:attr:xalign"
        })
#endif

-- VVV Prop "yalign"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

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

#if defined(ENABLE_OVERLOADING)
data SqueezerYalignPropertyInfo
instance AttrInfo SqueezerYalignPropertyInfo where
    type AttrAllowedOps SqueezerYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SqueezerYalignPropertyInfo = IsSqueezer
    type AttrSetTypeConstraint SqueezerYalignPropertyInfo = (~) Float
    type AttrTransferTypeConstraint SqueezerYalignPropertyInfo = (~) Float
    type AttrTransferType SqueezerYalignPropertyInfo = Float
    type AttrGetType SqueezerYalignPropertyInfo = Float
    type AttrLabel SqueezerYalignPropertyInfo = "yalign"
    type AttrOrigin SqueezerYalignPropertyInfo = Squeezer
    attrGet = getSqueezerYalign
    attrSet = setSqueezerYalign
    attrTransfer _ v = do
        return v
    attrConstruct = constructSqueezerYalign
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.yalign"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#g:attr:yalign"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Squeezer
type instance O.AttributeList Squeezer = SqueezerAttributeList
type SqueezerAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("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), '("homogeneous", SqueezerHomogeneousPropertyInfo), '("interpolateSize", SqueezerInterpolateSizePropertyInfo), '("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), '("orientation", Gtk.Orientable.OrientableOrientationPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("transitionDuration", SqueezerTransitionDurationPropertyInfo), '("transitionRunning", SqueezerTransitionRunningPropertyInfo), '("transitionType", SqueezerTransitionTypePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("visibleChild", SqueezerVisibleChildPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("xalign", SqueezerXalignPropertyInfo), '("yalign", SqueezerYalignPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
squeezerHomogeneous :: AttrLabelProxy "homogeneous"
squeezerHomogeneous = AttrLabelProxy

squeezerInterpolateSize :: AttrLabelProxy "interpolateSize"
squeezerInterpolateSize = AttrLabelProxy

squeezerTransitionDuration :: AttrLabelProxy "transitionDuration"
squeezerTransitionDuration = AttrLabelProxy

squeezerTransitionRunning :: AttrLabelProxy "transitionRunning"
squeezerTransitionRunning = AttrLabelProxy

squeezerTransitionType :: AttrLabelProxy "transitionType"
squeezerTransitionType = AttrLabelProxy

squeezerVisibleChild :: AttrLabelProxy "visibleChild"
squeezerVisibleChild = AttrLabelProxy

squeezerXalign :: AttrLabelProxy "xalign"
squeezerXalign = AttrLabelProxy

squeezerYalign :: AttrLabelProxy "yalign"
squeezerYalign = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Squeezer = SqueezerSignalList
type SqueezerSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("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), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("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), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("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, *)])

#endif

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

foreign import ccall "hdy_squeezer_new" hdy_squeezer_new :: 
    IO (Ptr Squeezer)

-- | Creates a new t'GI.Handy.Objects.Squeezer.Squeezer' container.
squeezerNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Squeezer
    -- ^ __Returns:__ a new t'GI.Handy.Objects.Squeezer.Squeezer'
squeezerNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Squeezer
squeezerNew  = IO Squeezer -> m Squeezer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Squeezer -> m Squeezer) -> IO Squeezer -> m Squeezer
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
result <- IO (Ptr Squeezer)
hdy_squeezer_new
    Text -> Ptr Squeezer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"squeezerNew" Ptr Squeezer
result
    Squeezer
result' <- ((ManagedPtr Squeezer -> Squeezer) -> Ptr Squeezer -> IO Squeezer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Squeezer -> Squeezer
Squeezer) Ptr Squeezer
result
    Squeezer -> IO Squeezer
forall (m :: * -> *) a. Monad m => a -> m a
return Squeezer
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Squeezer::get_child_enabled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdySqueezer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a child of @self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "hdy_squeezer_get_child_enabled" hdy_squeezer_get_child_enabled :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

-- | Gets whether /@child@/ is enabled.
-- 
-- See 'GI.Handy.Objects.Squeezer.squeezerSetChildEnabled'.
squeezerGetChildEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Squeezer.Squeezer'
    -> b
    -- ^ /@child@/: a child of /@self@/
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@child@/ is enabled, 'P.False' otherwise.
squeezerGetChildEnabled :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSqueezer a, IsWidget b) =>
a -> b -> m Bool
squeezerGetChildEnabled a
self b
child = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    CInt
result <- Ptr Squeezer -> Ptr Widget -> IO CInt
hdy_squeezer_get_child_enabled Ptr Squeezer
self' Ptr Widget
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 (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetChildEnabledMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsSqueezer a, Gtk.Widget.IsWidget b) => O.OverloadedMethod SqueezerGetChildEnabledMethodInfo a signature where
    overloadedMethod = squeezerGetChildEnabled

instance O.OverloadedMethodInfo SqueezerGetChildEnabledMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerGetChildEnabled",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerGetChildEnabled"
        })


#endif

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

foreign import ccall "hdy_squeezer_get_homogeneous" hdy_squeezer_get_homogeneous :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    IO CInt

-- | Gets whether /@self@/ is homogeneous.
-- 
-- See 'GI.Handy.Objects.Squeezer.squeezerSetHomogeneous'.
-- 
-- /Since: 0.0.10/
squeezerGetHomogeneous ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Squeezer.Squeezer'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@self@/ is homogeneous, 'P.False' is not
squeezerGetHomogeneous :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m Bool
squeezerGetHomogeneous a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Squeezer -> IO CInt
hdy_squeezer_get_homogeneous Ptr Squeezer
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetHomogeneousMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetHomogeneousMethodInfo a signature where
    overloadedMethod = squeezerGetHomogeneous

instance O.OverloadedMethodInfo SqueezerGetHomogeneousMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerGetHomogeneous",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerGetHomogeneous"
        })


#endif

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

foreign import ccall "hdy_squeezer_get_interpolate_size" hdy_squeezer_get_interpolate_size :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    IO CInt

-- | Gets whether /@self@/ should interpolate its size on visible child change.
-- 
-- See 'GI.Handy.Objects.Squeezer.squeezerSetInterpolateSize'.
-- 
-- /Since: 0.0.10/
squeezerGetInterpolateSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: A t'GI.Handy.Objects.Squeezer.Squeezer'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@self@/ interpolates its size on visible child change, 'P.False' if not
squeezerGetInterpolateSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m Bool
squeezerGetInterpolateSize a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Squeezer -> IO CInt
hdy_squeezer_get_interpolate_size Ptr Squeezer
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetInterpolateSizeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetInterpolateSizeMethodInfo a signature where
    overloadedMethod = squeezerGetInterpolateSize

instance O.OverloadedMethodInfo SqueezerGetInterpolateSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerGetInterpolateSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerGetInterpolateSize"
        })


#endif

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

foreign import ccall "hdy_squeezer_get_transition_duration" hdy_squeezer_get_transition_duration :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    IO Word32

-- | Gets the amount of time (in milliseconds) that transitions between children
-- in /@self@/ will take.
squeezerGetTransitionDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Squeezer.Squeezer'
    -> m Word32
    -- ^ __Returns:__ the transition duration
squeezerGetTransitionDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m Word32
squeezerGetTransitionDuration a
self = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Squeezer -> IO Word32
hdy_squeezer_get_transition_duration Ptr Squeezer
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data SqueezerGetTransitionDurationMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetTransitionDurationMethodInfo a signature where
    overloadedMethod = squeezerGetTransitionDuration

instance O.OverloadedMethodInfo SqueezerGetTransitionDurationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerGetTransitionDuration",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerGetTransitionDuration"
        })


#endif

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

foreign import ccall "hdy_squeezer_get_transition_running" hdy_squeezer_get_transition_running :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    IO CInt

-- | Gets whether /@self@/ is currently in a transition from one child to another.
squeezerGetTransitionRunning ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Squeezer.Squeezer'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the transition is currently running, 'P.False' otherwise.
squeezerGetTransitionRunning :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m Bool
squeezerGetTransitionRunning a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Squeezer -> IO CInt
hdy_squeezer_get_transition_running Ptr Squeezer
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetTransitionRunningMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetTransitionRunningMethodInfo a signature where
    overloadedMethod = squeezerGetTransitionRunning

instance O.OverloadedMethodInfo SqueezerGetTransitionRunningMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerGetTransitionRunning",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerGetTransitionRunning"
        })


#endif

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

foreign import ccall "hdy_squeezer_get_transition_type" hdy_squeezer_get_transition_type :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    IO CUInt

-- | Gets the type of animation that will be used for transitions between children
-- in /@self@/.
squeezerGetTransitionType ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Squeezer.Squeezer'
    -> m Handy.Enums.SqueezerTransitionType
    -- ^ __Returns:__ the current transition type of /@self@/
squeezerGetTransitionType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m SqueezerTransitionType
squeezerGetTransitionType a
self = IO SqueezerTransitionType -> m SqueezerTransitionType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SqueezerTransitionType -> m SqueezerTransitionType)
-> IO SqueezerTransitionType -> m SqueezerTransitionType
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Squeezer -> IO CUInt
hdy_squeezer_get_transition_type Ptr Squeezer
self'
    let result' :: SqueezerTransitionType
result' = (Int -> SqueezerTransitionType
forall a. Enum a => Int -> a
toEnum (Int -> SqueezerTransitionType)
-> (CUInt -> Int) -> CUInt -> SqueezerTransitionType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    SqueezerTransitionType -> IO SqueezerTransitionType
forall (m :: * -> *) a. Monad m => a -> m a
return SqueezerTransitionType
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetTransitionTypeMethodInfo
instance (signature ~ (m Handy.Enums.SqueezerTransitionType), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetTransitionTypeMethodInfo a signature where
    overloadedMethod = squeezerGetTransitionType

instance O.OverloadedMethodInfo SqueezerGetTransitionTypeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerGetTransitionType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerGetTransitionType"
        })


#endif

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

foreign import ccall "hdy_squeezer_get_visible_child" hdy_squeezer_get_visible_child :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    IO (Ptr Gtk.Widget.Widget)

-- | Gets the currently visible child of /@self@/, or 'P.Nothing' if there are no visible
-- children.
squeezerGetVisibleChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Squeezer.Squeezer'
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the visible child of the t'GI.Handy.Objects.Squeezer.Squeezer'
squeezerGetVisibleChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m (Maybe Widget)
squeezerGetVisibleChild a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr Squeezer -> IO (Ptr Widget)
hdy_squeezer_get_visible_child Ptr Squeezer
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

instance O.OverloadedMethodInfo SqueezerGetVisibleChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerGetVisibleChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerGetVisibleChild"
        })


#endif

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

foreign import ccall "hdy_squeezer_get_xalign" hdy_squeezer_get_xalign :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    IO CFloat

-- | Gets the t'GI.Handy.Objects.Squeezer.Squeezer':@/xalign/@ property for /@self@/.
-- 
-- /Since: 1.0/
squeezerGetXalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Squeezer.Squeezer'
    -> m Float
    -- ^ __Returns:__ the xalign property
squeezerGetXalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m Float
squeezerGetXalign a
self = IO Float -> m Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Squeezer -> IO CFloat
hdy_squeezer_get_xalign Ptr Squeezer
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetXalignMethodInfo
instance (signature ~ (m Float), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetXalignMethodInfo a signature where
    overloadedMethod = squeezerGetXalign

instance O.OverloadedMethodInfo SqueezerGetXalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerGetXalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerGetXalign"
        })


#endif

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

foreign import ccall "hdy_squeezer_get_yalign" hdy_squeezer_get_yalign :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    IO CFloat

-- | Gets the t'GI.Handy.Objects.Squeezer.Squeezer':@/yalign/@ property for /@self@/.
-- 
-- /Since: 1.0/
squeezerGetYalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Squeezer.Squeezer'
    -> m Float
    -- ^ __Returns:__ the yalign property
squeezerGetYalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> m Float
squeezerGetYalign a
self = IO Float -> m Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Squeezer -> IO CFloat
hdy_squeezer_get_yalign Ptr Squeezer
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data SqueezerGetYalignMethodInfo
instance (signature ~ (m Float), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerGetYalignMethodInfo a signature where
    overloadedMethod = squeezerGetYalign

instance O.OverloadedMethodInfo SqueezerGetYalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerGetYalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerGetYalign"
        })


#endif

-- method Squeezer::set_child_enabled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdySqueezer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a child of @self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enabled"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE to enable the child, %FALSE to disable it"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_squeezer_set_child_enabled" hdy_squeezer_set_child_enabled :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

-- | Make /@self@/ enable or disable /@child@/. If a child is disabled, it will be
-- ignored when looking for the child fitting the available size best. This
-- allows to programmatically and prematurely hide a child of /@self@/ even if it
-- fits in the available space.
-- 
-- This can be used e.g. to ensure a certain child is hidden below a certain
-- window width, or any other constraint you find suitable.
squeezerSetChildEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Squeezer.Squeezer'
    -> b
    -- ^ /@child@/: a child of /@self@/
    -> Bool
    -- ^ /@enabled@/: 'P.True' to enable the child, 'P.False' to disable it
    -> m ()
squeezerSetChildEnabled :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSqueezer a, IsWidget b) =>
a -> b -> Bool -> m ()
squeezerSetChildEnabled a
self b
child Bool
enabled = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
enabled
    Ptr Squeezer -> Ptr Widget -> CInt -> IO ()
hdy_squeezer_set_child_enabled Ptr Squeezer
self' Ptr Widget
child' CInt
enabled'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetChildEnabledMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsSqueezer a, Gtk.Widget.IsWidget b) => O.OverloadedMethod SqueezerSetChildEnabledMethodInfo a signature where
    overloadedMethod = squeezerSetChildEnabled

instance O.OverloadedMethodInfo SqueezerSetChildEnabledMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerSetChildEnabled",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerSetChildEnabled"
        })


#endif

-- method Squeezer::set_homogeneous
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdySqueezer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "homogeneous"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to make @self homogeneous"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_squeezer_set_homogeneous" hdy_squeezer_set_homogeneous :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    CInt ->                                 -- homogeneous : TBasicType TBoolean
    IO ()

-- | Sets /@self@/ to be homogeneous or not. If it is homogeneous, /@self@/ will request
-- the same size for all its children for its opposite orientation, e.g. if
-- /@self@/ is oriented horizontally and is homogeneous, it will request the same
-- height for all its children. If it isn\'t, /@self@/ may change size when a
-- different child becomes visible.
-- 
-- /Since: 0.0.10/
squeezerSetHomogeneous ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Squeezer.Squeezer'
    -> Bool
    -- ^ /@homogeneous@/: 'P.True' to make /@self@/ homogeneous
    -> m ()
squeezerSetHomogeneous :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> Bool -> m ()
squeezerSetHomogeneous a
self Bool
homogeneous = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let homogeneous' :: CInt
homogeneous' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
homogeneous
    Ptr Squeezer -> CInt -> IO ()
hdy_squeezer_set_homogeneous Ptr Squeezer
self' CInt
homogeneous'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetHomogeneousMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerSetHomogeneousMethodInfo a signature where
    overloadedMethod = squeezerSetHomogeneous

instance O.OverloadedMethodInfo SqueezerSetHomogeneousMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerSetHomogeneous",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerSetHomogeneous"
        })


#endif

-- method Squeezer::set_interpolate_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #HdySqueezer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "interpolate_size"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to interpolate the size"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_squeezer_set_interpolate_size" hdy_squeezer_set_interpolate_size :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    CInt ->                                 -- interpolate_size : TBasicType TBoolean
    IO ()

-- | Sets whether or not /@self@/ will interpolate the size of its opposing
-- orientation when changing the visible child. If 'P.True', /@self@/ will interpolate
-- its size between the one of the previous visible child and the one of the new
-- visible child, according to the set transition duration and the orientation,
-- e.g. if /@self@/ is horizontal, it will interpolate the its height.
-- 
-- /Since: 0.0.10/
squeezerSetInterpolateSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: A t'GI.Handy.Objects.Squeezer.Squeezer'
    -> Bool
    -- ^ /@interpolateSize@/: 'P.True' to interpolate the size
    -> m ()
squeezerSetInterpolateSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> Bool -> m ()
squeezerSetInterpolateSize a
self Bool
interpolateSize = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let interpolateSize' :: CInt
interpolateSize' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
interpolateSize
    Ptr Squeezer -> CInt -> IO ()
hdy_squeezer_set_interpolate_size Ptr Squeezer
self' CInt
interpolateSize'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetInterpolateSizeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerSetInterpolateSizeMethodInfo a signature where
    overloadedMethod = squeezerSetInterpolateSize

instance O.OverloadedMethodInfo SqueezerSetInterpolateSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerSetInterpolateSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerSetInterpolateSize"
        })


#endif

-- method Squeezer::set_transition_duration
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdySqueezer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "duration"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new duration, in milliseconds"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_squeezer_set_transition_duration" hdy_squeezer_set_transition_duration :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    Word32 ->                               -- duration : TBasicType TUInt
    IO ()

-- | Sets the duration that transitions between children in /@self@/ will take.
squeezerSetTransitionDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Squeezer.Squeezer'
    -> Word32
    -- ^ /@duration@/: the new duration, in milliseconds
    -> m ()
squeezerSetTransitionDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> Word32 -> m ()
squeezerSetTransitionDuration a
self Word32
duration = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Squeezer -> Word32 -> IO ()
hdy_squeezer_set_transition_duration Ptr Squeezer
self' Word32
duration
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetTransitionDurationMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerSetTransitionDurationMethodInfo a signature where
    overloadedMethod = squeezerSetTransitionDuration

instance O.OverloadedMethodInfo SqueezerSetTransitionDurationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerSetTransitionDuration",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerSetTransitionDuration"
        })


#endif

-- method Squeezer::set_transition_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdySqueezer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "transition"
--           , argType =
--               TInterface
--                 Name { namespace = "Handy" , name = "SqueezerTransitionType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new transition type"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_squeezer_set_transition_type" hdy_squeezer_set_transition_type :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    CUInt ->                                -- transition : TInterface (Name {namespace = "Handy", name = "SqueezerTransitionType"})
    IO ()

-- | Sets the type of animation that will be used for transitions between children
-- in /@self@/. Available types include various kinds of fades and slides.
-- 
-- The transition type can be changed without problems at runtime, so it is
-- possible to change the animation based on the child that is about to become
-- current.
squeezerSetTransitionType ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Squeezer.Squeezer'
    -> Handy.Enums.SqueezerTransitionType
    -- ^ /@transition@/: the new transition type
    -> m ()
squeezerSetTransitionType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> SqueezerTransitionType -> m ()
squeezerSetTransitionType a
self SqueezerTransitionType
transition = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let transition' :: CUInt
transition' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (SqueezerTransitionType -> Int)
-> SqueezerTransitionType
-> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqueezerTransitionType -> Int
forall a. Enum a => a -> Int
fromEnum) SqueezerTransitionType
transition
    Ptr Squeezer -> CUInt -> IO ()
hdy_squeezer_set_transition_type Ptr Squeezer
self' CUInt
transition'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetTransitionTypeMethodInfo
instance (signature ~ (Handy.Enums.SqueezerTransitionType -> m ()), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerSetTransitionTypeMethodInfo a signature where
    overloadedMethod = squeezerSetTransitionType

instance O.OverloadedMethodInfo SqueezerSetTransitionTypeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerSetTransitionType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerSetTransitionType"
        })


#endif

-- method Squeezer::set_xalign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdySqueezer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xalign"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new xalign value, between 0 and 1"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_squeezer_set_xalign" hdy_squeezer_set_xalign :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    CFloat ->                               -- xalign : TBasicType TFloat
    IO ()

-- | Sets the t'GI.Handy.Objects.Squeezer.Squeezer':@/xalign/@ property for /@self@/.
-- 
-- /Since: 1.0/
squeezerSetXalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Squeezer.Squeezer'
    -> Float
    -- ^ /@xalign@/: the new xalign value, between 0 and 1
    -> m ()
squeezerSetXalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> Float -> m ()
squeezerSetXalign a
self Float
xalign = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let xalign' :: CFloat
xalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
xalign
    Ptr Squeezer -> CFloat -> IO ()
hdy_squeezer_set_xalign Ptr Squeezer
self' CFloat
xalign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetXalignMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerSetXalignMethodInfo a signature where
    overloadedMethod = squeezerSetXalign

instance O.OverloadedMethodInfo SqueezerSetXalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerSetXalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerSetXalign"
        })


#endif

-- method Squeezer::set_yalign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Squeezer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdySqueezer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "yalign"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new yalign value, between 0 and 1"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_squeezer_set_yalign" hdy_squeezer_set_yalign :: 
    Ptr Squeezer ->                         -- self : TInterface (Name {namespace = "Handy", name = "Squeezer"})
    CFloat ->                               -- yalign : TBasicType TFloat
    IO ()

-- | Sets the t'GI.Handy.Objects.Squeezer.Squeezer':@/yalign/@ property for /@self@/.
-- 
-- /Since: 1.0/
squeezerSetYalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsSqueezer a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Squeezer.Squeezer'
    -> Float
    -- ^ /@yalign@/: the new yalign value, between 0 and 1
    -> m ()
squeezerSetYalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSqueezer a) =>
a -> Float -> m ()
squeezerSetYalign a
self Float
yalign = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Squeezer
self' <- a -> IO (Ptr Squeezer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let yalign' :: CFloat
yalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
yalign
    Ptr Squeezer -> CFloat -> IO ()
hdy_squeezer_set_yalign Ptr Squeezer
self' CFloat
yalign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SqueezerSetYalignMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsSqueezer a) => O.OverloadedMethod SqueezerSetYalignMethodInfo a signature where
    overloadedMethod = squeezerSetYalign

instance O.OverloadedMethodInfo SqueezerSetYalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Squeezer.squeezerSetYalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Squeezer.html#v:squeezerSetYalign"
        })


#endif