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


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

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

module GI.Dazzle.Objects.Tree
    ( 

-- * Exported types
    Tree(..)                                ,
    IsTree                                  ,
    toTree                                  ,


 -- * 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"), [addBuilder]("GI.Dazzle.Objects.Tree#g:method:addBuilder"), [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"), [appendColumn]("GI.Gtk.Objects.TreeView#g:method:appendColumn"), [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"), [collapseAll]("GI.Gtk.Objects.TreeView#g:method:collapseAll"), [collapseRow]("GI.Gtk.Objects.TreeView#g:method:collapseRow"), [columnsAutosize]("GI.Gtk.Objects.TreeView#g:method:columnsAutosize"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [constructChild]("GI.Gtk.Interfaces.Buildable#g:method:constructChild"), [convertBinWindowToTreeCoords]("GI.Gtk.Objects.TreeView#g:method:convertBinWindowToTreeCoords"), [convertBinWindowToWidgetCoords]("GI.Gtk.Objects.TreeView#g:method:convertBinWindowToWidgetCoords"), [convertTreeToBinWindowCoords]("GI.Gtk.Objects.TreeView#g:method:convertTreeToBinWindowCoords"), [convertTreeToWidgetCoords]("GI.Gtk.Objects.TreeView#g:method:convertTreeToWidgetCoords"), [convertWidgetToBinWindowCoords]("GI.Gtk.Objects.TreeView#g:method:convertWidgetToBinWindowCoords"), [convertWidgetToTreeCoords]("GI.Gtk.Objects.TreeView#g:method:convertWidgetToTreeCoords"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [createRowDragIcon]("GI.Gtk.Objects.TreeView#g:method:createRowDragIcon"), [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"), [enableModelDragDest]("GI.Gtk.Objects.TreeView#g:method:enableModelDragDest"), [enableModelDragSource]("GI.Gtk.Objects.TreeView#g:method:enableModelDragSource"), [ensureStyle]("GI.Gtk.Objects.Widget#g:method:ensureStyle"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [event]("GI.Gtk.Objects.Widget#g:method:event"), [expandAll]("GI.Gtk.Objects.TreeView#g:method:expandAll"), [expandRow]("GI.Gtk.Objects.TreeView#g:method:expandRow"), [expandToNode]("GI.Dazzle.Objects.Tree#g:method:expandToNode"), [expandToPath]("GI.Gtk.Objects.TreeView#g:method:expandToPath"), [findChildNode]("GI.Dazzle.Objects.Tree#g:method:findChildNode"), [findCustom]("GI.Dazzle.Objects.Tree#g:method:findCustom"), [findItem]("GI.Dazzle.Objects.Tree#g:method:findItem"), [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"), [insertColumn]("GI.Gtk.Objects.TreeView#g:method:insertColumn"), [insertColumnWithDataFunc]("GI.Gtk.Objects.TreeView#g:method:insertColumnWithDataFunc"), [intersect]("GI.Gtk.Objects.Widget#g:method:intersect"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isBlankAtPos]("GI.Gtk.Objects.TreeView#g:method:isBlankAtPos"), [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"), [isRubberBandingActive]("GI.Gtk.Objects.TreeView#g:method:isRubberBandingActive"), [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"), [mapExpandedRows]("GI.Gtk.Objects.TreeView#g:method:mapExpandedRows"), [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"), [moveColumnAfter]("GI.Gtk.Objects.TreeView#g:method:moveColumnAfter"), [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"), [rebuild]("GI.Dazzle.Objects.Tree#g:method:rebuild"), [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"), [removeBuilder]("GI.Dazzle.Objects.Tree#g:method:removeBuilder"), [removeColumn]("GI.Gtk.Objects.TreeView#g:method:removeColumn"), [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"), [rowActivated]("GI.Gtk.Objects.TreeView#g:method:rowActivated"), [rowExpanded]("GI.Gtk.Objects.TreeView#g:method:rowExpanded"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [scrollToCell]("GI.Gtk.Objects.TreeView#g:method:scrollToCell"), [scrollToNode]("GI.Dazzle.Objects.Tree#g:method:scrollToNode"), [scrollToPoint]("GI.Gtk.Objects.TreeView#g:method:scrollToPoint"), [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"), [unselectAll]("GI.Dazzle.Objects.Tree#g:method:unselectAll"), [unsetFocusChain]("GI.Gtk.Objects.Container#g:method:unsetFocusChain"), [unsetRowsDragDest]("GI.Gtk.Objects.TreeView#g:method:unsetRowsDragDest"), [unsetRowsDragSource]("GI.Gtk.Objects.TreeView#g:method:unsetRowsDragSource"), [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"), [getActivateOnSingleClick]("GI.Gtk.Objects.TreeView#g:method:getActivateOnSingleClick"), [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"), [getBackgroundArea]("GI.Gtk.Objects.TreeView#g:method:getBackgroundArea"), [getBinWindow]("GI.Gtk.Objects.TreeView#g:method:getBinWindow"), [getBorder]("GI.Gtk.Interfaces.Scrollable#g:method:getBorder"), [getBorderWidth]("GI.Gtk.Objects.Container#g:method:getBorderWidth"), [getCanDefault]("GI.Gtk.Objects.Widget#g:method:getCanDefault"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCellArea]("GI.Gtk.Objects.TreeView#g:method:getCellArea"), [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"), [getColumn]("GI.Gtk.Objects.TreeView#g:method:getColumn"), [getColumns]("GI.Gtk.Objects.TreeView#g:method:getColumns"), [getCompositeName]("GI.Gtk.Objects.Widget#g:method:getCompositeName"), [getContextMenu]("GI.Dazzle.Objects.Tree#g:method:getContextMenu"), [getCursor]("GI.Gtk.Objects.TreeView#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDestRowAtPos]("GI.Gtk.Objects.TreeView#g:method:getDestRowAtPos"), [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"), [getDragDestRow]("GI.Gtk.Objects.TreeView#g:method:getDragDestRow"), [getEnableSearch]("GI.Gtk.Objects.TreeView#g:method:getEnableSearch"), [getEnableTreeLines]("GI.Gtk.Objects.TreeView#g:method:getEnableTreeLines"), [getEvents]("GI.Gtk.Objects.Widget#g:method:getEvents"), [getExpanderColumn]("GI.Gtk.Objects.TreeView#g:method:getExpanderColumn"), [getFixedHeightMode]("GI.Gtk.Objects.TreeView#g:method:getFixedHeightMode"), [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"), [getGridLines]("GI.Gtk.Objects.TreeView#g:method:getGridLines"), [getHadjustment]("GI.Gtk.Objects.TreeView#g:method:getHadjustment"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHasWindow]("GI.Gtk.Objects.Widget#g:method:getHasWindow"), [getHeadersClickable]("GI.Gtk.Objects.TreeView#g:method:getHeadersClickable"), [getHeadersVisible]("GI.Gtk.Objects.TreeView#g:method:getHeadersVisible"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getHoverExpand]("GI.Gtk.Objects.TreeView#g:method:getHoverExpand"), [getHoverSelection]("GI.Gtk.Objects.TreeView#g:method:getHoverSelection"), [getHscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getHscrollPolicy"), [getInternalChild]("GI.Gtk.Interfaces.Buildable#g:method:getInternalChild"), [getLevelIndentation]("GI.Gtk.Objects.TreeView#g:method:getLevelIndentation"), [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"), [getModel]("GI.Gtk.Objects.TreeView#g:method:getModel"), [getModifierMask]("GI.Gtk.Objects.Widget#g:method:getModifierMask"), [getModifierStyle]("GI.Gtk.Objects.Widget#g:method:getModifierStyle"), [getNColumns]("GI.Gtk.Objects.TreeView#g:method:getNColumns"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNoShowAll]("GI.Gtk.Objects.Widget#g:method:getNoShowAll"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getParentWindow]("GI.Gtk.Objects.Widget#g:method:getParentWindow"), [getPath]("GI.Gtk.Objects.Widget#g:method:getPath"), [getPathAtPos]("GI.Gtk.Objects.TreeView#g:method:getPathAtPos"), [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"), [getReorderable]("GI.Gtk.Objects.TreeView#g:method:getReorderable"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRequisition]("GI.Gtk.Objects.Widget#g:method:getRequisition"), [getResizeMode]("GI.Gtk.Objects.Container#g:method:getResizeMode"), [getRoot]("GI.Dazzle.Objects.Tree#g:method:getRoot"), [getRootWindow]("GI.Gtk.Objects.Widget#g:method:getRootWindow"), [getRubberBanding]("GI.Gtk.Objects.TreeView#g:method:getRubberBanding"), [getRulesHint]("GI.Gtk.Objects.TreeView#g:method:getRulesHint"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getScreen]("GI.Gtk.Objects.Widget#g:method:getScreen"), [getSearchColumn]("GI.Gtk.Objects.TreeView#g:method:getSearchColumn"), [getSearchEntry]("GI.Gtk.Objects.TreeView#g:method:getSearchEntry"), [getSelected]("GI.Dazzle.Objects.Tree#g:method:getSelected"), [getSelection]("GI.Gtk.Objects.TreeView#g:method:getSelection"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getShowExpanders]("GI.Gtk.Objects.TreeView#g:method:getShowExpanders"), [getShowIcons]("GI.Dazzle.Objects.Tree#g:method:getShowIcons"), [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"), [getTooltipColumn]("GI.Gtk.Objects.TreeView#g:method:getTooltipColumn"), [getTooltipContext]("GI.Gtk.Objects.TreeView#g:method:getTooltipContext"), [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"), [getVadjustment]("GI.Gtk.Objects.TreeView#g:method:getVadjustment"), [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"), [getVisibleRange]("GI.Gtk.Objects.TreeView#g:method:getVisibleRange"), [getVisibleRect]("GI.Gtk.Objects.TreeView#g:method:getVisibleRect"), [getVisual]("GI.Gtk.Objects.Widget#g:method:getVisual"), [getVscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getVscrollPolicy"), [getWindow]("GI.Gtk.Objects.Widget#g:method:getWindow").
-- 
-- ==== Setters
-- [setAccelPath]("GI.Gtk.Objects.Widget#g:method:setAccelPath"), [setActivateOnSingleClick]("GI.Gtk.Objects.TreeView#g:method:setActivateOnSingleClick"), [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"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setClip]("GI.Gtk.Objects.Widget#g:method:setClip"), [setColumnDragFunction]("GI.Gtk.Objects.TreeView#g:method:setColumnDragFunction"), [setCompositeName]("GI.Gtk.Objects.Widget#g:method:setCompositeName"), [setContextMenu]("GI.Dazzle.Objects.Tree#g:method:setContextMenu"), [setCursor]("GI.Gtk.Objects.TreeView#g:method:setCursor"), [setCursorOnCell]("GI.Gtk.Objects.TreeView#g:method:setCursorOnCell"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDestroyCountFunc]("GI.Gtk.Objects.TreeView#g:method:setDestroyCountFunc"), [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"), [setDragDestRow]("GI.Gtk.Objects.TreeView#g:method:setDragDestRow"), [setEnableSearch]("GI.Gtk.Objects.TreeView#g:method:setEnableSearch"), [setEnableTreeLines]("GI.Gtk.Objects.TreeView#g:method:setEnableTreeLines"), [setEvents]("GI.Gtk.Objects.Widget#g:method:setEvents"), [setExpanderColumn]("GI.Gtk.Objects.TreeView#g:method:setExpanderColumn"), [setFilter]("GI.Dazzle.Objects.Tree#g:method:setFilter"), [setFixedHeightMode]("GI.Gtk.Objects.TreeView#g:method:setFixedHeightMode"), [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"), [setGridLines]("GI.Gtk.Objects.TreeView#g:method:setGridLines"), [setHadjustment]("GI.Gtk.Objects.TreeView#g:method:setHadjustment"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHasWindow]("GI.Gtk.Objects.Widget#g:method:setHasWindow"), [setHeadersClickable]("GI.Gtk.Objects.TreeView#g:method:setHeadersClickable"), [setHeadersVisible]("GI.Gtk.Objects.TreeView#g:method:setHeadersVisible"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setHoverExpand]("GI.Gtk.Objects.TreeView#g:method:setHoverExpand"), [setHoverSelection]("GI.Gtk.Objects.TreeView#g:method:setHoverSelection"), [setHscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:setHscrollPolicy"), [setLevelIndentation]("GI.Gtk.Objects.TreeView#g:method:setLevelIndentation"), [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"), [setModel]("GI.Gtk.Objects.TreeView#g:method:setModel"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setNoShowAll]("GI.Gtk.Objects.Widget#g:method:setNoShowAll"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setParentWindow]("GI.Gtk.Objects.Widget#g:method:setParentWindow"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRealized]("GI.Gtk.Objects.Widget#g:method:setRealized"), [setReallocateRedraws]("GI.Gtk.Objects.Container#g:method:setReallocateRedraws"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setRedrawOnAllocate]("GI.Gtk.Objects.Widget#g:method:setRedrawOnAllocate"), [setReorderable]("GI.Gtk.Objects.TreeView#g:method:setReorderable"), [setResizeMode]("GI.Gtk.Objects.Container#g:method:setResizeMode"), [setRoot]("GI.Dazzle.Objects.Tree#g:method:setRoot"), [setRowSeparatorFunc]("GI.Gtk.Objects.TreeView#g:method:setRowSeparatorFunc"), [setRubberBanding]("GI.Gtk.Objects.TreeView#g:method:setRubberBanding"), [setRulesHint]("GI.Gtk.Objects.TreeView#g:method:setRulesHint"), [setSearchColumn]("GI.Gtk.Objects.TreeView#g:method:setSearchColumn"), [setSearchEntry]("GI.Gtk.Objects.TreeView#g:method:setSearchEntry"), [setSearchEqualFunc]("GI.Gtk.Objects.TreeView#g:method:setSearchEqualFunc"), [setSearchPositionFunc]("GI.Gtk.Objects.TreeView#g:method:setSearchPositionFunc"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setShowExpanders]("GI.Gtk.Objects.TreeView#g:method:setShowExpanders"), [setShowIcons]("GI.Dazzle.Objects.Tree#g:method:setShowIcons"), [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"), [setTooltipCell]("GI.Gtk.Objects.TreeView#g:method:setTooltipCell"), [setTooltipColumn]("GI.Gtk.Objects.TreeView#g:method:setTooltipColumn"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipRow]("GI.Gtk.Objects.TreeView#g:method:setTooltipRow"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTooltipWindow]("GI.Gtk.Objects.Widget#g:method:setTooltipWindow"), [setVadjustment]("GI.Gtk.Objects.TreeView#g:method:setVadjustment"), [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"), [setVscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:setVscrollPolicy"), [setWindow]("GI.Gtk.Objects.Widget#g:method:setWindow").

#if defined(ENABLE_OVERLOADING)
    ResolveTreeMethod                       ,
#endif

-- ** addBuilder #method:addBuilder#

#if defined(ENABLE_OVERLOADING)
    TreeAddBuilderMethodInfo                ,
#endif
    treeAddBuilder                          ,


-- ** expandToNode #method:expandToNode#

#if defined(ENABLE_OVERLOADING)
    TreeExpandToNodeMethodInfo              ,
#endif
    treeExpandToNode                        ,


-- ** findChildNode #method:findChildNode#

#if defined(ENABLE_OVERLOADING)
    TreeFindChildNodeMethodInfo             ,
#endif
    treeFindChildNode                       ,


-- ** findCustom #method:findCustom#

#if defined(ENABLE_OVERLOADING)
    TreeFindCustomMethodInfo                ,
#endif
    treeFindCustom                          ,


-- ** findItem #method:findItem#

#if defined(ENABLE_OVERLOADING)
    TreeFindItemMethodInfo                  ,
#endif
    treeFindItem                            ,


-- ** getContextMenu #method:getContextMenu#

#if defined(ENABLE_OVERLOADING)
    TreeGetContextMenuMethodInfo            ,
#endif
    treeGetContextMenu                      ,


-- ** getRoot #method:getRoot#

#if defined(ENABLE_OVERLOADING)
    TreeGetRootMethodInfo                   ,
#endif
    treeGetRoot                             ,


-- ** getSelected #method:getSelected#

#if defined(ENABLE_OVERLOADING)
    TreeGetSelectedMethodInfo               ,
#endif
    treeGetSelected                         ,


-- ** getShowIcons #method:getShowIcons#

#if defined(ENABLE_OVERLOADING)
    TreeGetShowIconsMethodInfo              ,
#endif
    treeGetShowIcons                        ,


-- ** rebuild #method:rebuild#

#if defined(ENABLE_OVERLOADING)
    TreeRebuildMethodInfo                   ,
#endif
    treeRebuild                             ,


-- ** removeBuilder #method:removeBuilder#

#if defined(ENABLE_OVERLOADING)
    TreeRemoveBuilderMethodInfo             ,
#endif
    treeRemoveBuilder                       ,


-- ** scrollToNode #method:scrollToNode#

#if defined(ENABLE_OVERLOADING)
    TreeScrollToNodeMethodInfo              ,
#endif
    treeScrollToNode                        ,


-- ** setContextMenu #method:setContextMenu#

#if defined(ENABLE_OVERLOADING)
    TreeSetContextMenuMethodInfo            ,
#endif
    treeSetContextMenu                      ,


-- ** setFilter #method:setFilter#

#if defined(ENABLE_OVERLOADING)
    TreeSetFilterMethodInfo                 ,
#endif
    treeSetFilter                           ,


-- ** setRoot #method:setRoot#

#if defined(ENABLE_OVERLOADING)
    TreeSetRootMethodInfo                   ,
#endif
    treeSetRoot                             ,


-- ** setShowIcons #method:setShowIcons#

#if defined(ENABLE_OVERLOADING)
    TreeSetShowIconsMethodInfo              ,
#endif
    treeSetShowIcons                        ,


-- ** unselectAll #method:unselectAll#

#if defined(ENABLE_OVERLOADING)
    TreeUnselectAllMethodInfo               ,
#endif
    treeUnselectAll                         ,




 -- * Properties


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

#if defined(ENABLE_OVERLOADING)
    TreeAlwaysExpandPropertyInfo            ,
#endif
    constructTreeAlwaysExpand               ,
    getTreeAlwaysExpand                     ,
#if defined(ENABLE_OVERLOADING)
    treeAlwaysExpand                        ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TreeContextMenuPropertyInfo             ,
#endif
    constructTreeContextMenu                ,
    getTreeContextMenu                      ,
    setTreeContextMenu                      ,
#if defined(ENABLE_OVERLOADING)
    treeContextMenu                         ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TreeRootPropertyInfo                    ,
#endif
    constructTreeRoot                       ,
    getTreeRoot                             ,
    setTreeRoot                             ,
#if defined(ENABLE_OVERLOADING)
    treeRoot                                ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TreeSelectionPropertyInfo               ,
#endif
    clearTreeSelection                      ,
    constructTreeSelection                  ,
    getTreeSelection                        ,
    setTreeSelection                        ,
#if defined(ENABLE_OVERLOADING)
    treeSelection                           ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TreeShowIconsPropertyInfo               ,
#endif
    constructTreeShowIcons                  ,
    getTreeShowIcons                        ,
    setTreeShowIcons                        ,
#if defined(ENABLE_OVERLOADING)
    treeShowIcons                           ,
#endif




 -- * Signals


-- ** action #signal:action#

    TreeActionCallback                      ,
#if defined(ENABLE_OVERLOADING)
    TreeActionSignalInfo                    ,
#endif
    afterTreeAction                         ,
    onTreeAction                            ,


-- ** populatePopup #signal:populatePopup#

    TreePopulatePopupCallback               ,
#if defined(ENABLE_OVERLOADING)
    TreePopulatePopupSignalInfo             ,
#endif
    afterTreePopulatePopup                  ,
    onTreePopulatePopup                     ,




    ) where

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

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

import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Dazzle.Callbacks as Dazzle.Callbacks
import {-# SOURCE #-} qualified GI.Dazzle.Objects.TreeBuilder as Dazzle.TreeBuilder
import {-# SOURCE #-} qualified GI.Dazzle.Objects.TreeNode as Dazzle.TreeNode
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.Scrollable as Gtk.Scrollable
import qualified GI.Gtk.Objects.Container as Gtk.Container
import qualified GI.Gtk.Objects.TreeView as Gtk.TreeView
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

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

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

foreign import ccall "dzl_tree_get_type"
    c_dzl_tree_get_type :: IO B.Types.GType

instance B.Types.TypedObject Tree where
    glibType :: IO GType
glibType = IO GType
c_dzl_tree_get_type

instance B.Types.GObject Tree

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

instance O.HasParentTypes Tree
type instance O.ParentTypes Tree = '[Gtk.TreeView.TreeView, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable, Gtk.Scrollable.Scrollable]

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveTreeMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveTreeMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveTreeMethod "add" o = Gtk.Container.ContainerAddMethodInfo
    ResolveTreeMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
    ResolveTreeMethod "addBuilder" o = TreeAddBuilderMethodInfo
    ResolveTreeMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveTreeMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
    ResolveTreeMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
    ResolveTreeMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveTreeMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveTreeMethod "appendColumn" o = Gtk.TreeView.TreeViewAppendColumnMethodInfo
    ResolveTreeMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTreeMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTreeMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
    ResolveTreeMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo
    ResolveTreeMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveTreeMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo
    ResolveTreeMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo
    ResolveTreeMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo
    ResolveTreeMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo
    ResolveTreeMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo
    ResolveTreeMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
    ResolveTreeMethod "collapseAll" o = Gtk.TreeView.TreeViewCollapseAllMethodInfo
    ResolveTreeMethod "collapseRow" o = Gtk.TreeView.TreeViewCollapseRowMethodInfo
    ResolveTreeMethod "columnsAutosize" o = Gtk.TreeView.TreeViewColumnsAutosizeMethodInfo
    ResolveTreeMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveTreeMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveTreeMethod "convertBinWindowToTreeCoords" o = Gtk.TreeView.TreeViewConvertBinWindowToTreeCoordsMethodInfo
    ResolveTreeMethod "convertBinWindowToWidgetCoords" o = Gtk.TreeView.TreeViewConvertBinWindowToWidgetCoordsMethodInfo
    ResolveTreeMethod "convertTreeToBinWindowCoords" o = Gtk.TreeView.TreeViewConvertTreeToBinWindowCoordsMethodInfo
    ResolveTreeMethod "convertTreeToWidgetCoords" o = Gtk.TreeView.TreeViewConvertTreeToWidgetCoordsMethodInfo
    ResolveTreeMethod "convertWidgetToBinWindowCoords" o = Gtk.TreeView.TreeViewConvertWidgetToBinWindowCoordsMethodInfo
    ResolveTreeMethod "convertWidgetToTreeCoords" o = Gtk.TreeView.TreeViewConvertWidgetToTreeCoordsMethodInfo
    ResolveTreeMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveTreeMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveTreeMethod "createRowDragIcon" o = Gtk.TreeView.TreeViewCreateRowDragIconMethodInfo
    ResolveTreeMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveTreeMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveTreeMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveTreeMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
    ResolveTreeMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
    ResolveTreeMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
    ResolveTreeMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
    ResolveTreeMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
    ResolveTreeMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveTreeMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
    ResolveTreeMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
    ResolveTreeMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
    ResolveTreeMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
    ResolveTreeMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
    ResolveTreeMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
    ResolveTreeMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
    ResolveTreeMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
    ResolveTreeMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
    ResolveTreeMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
    ResolveTreeMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
    ResolveTreeMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
    ResolveTreeMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
    ResolveTreeMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
    ResolveTreeMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
    ResolveTreeMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
    ResolveTreeMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
    ResolveTreeMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
    ResolveTreeMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
    ResolveTreeMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
    ResolveTreeMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
    ResolveTreeMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
    ResolveTreeMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
    ResolveTreeMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
    ResolveTreeMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
    ResolveTreeMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
    ResolveTreeMethod "enableModelDragDest" o = Gtk.TreeView.TreeViewEnableModelDragDestMethodInfo
    ResolveTreeMethod "enableModelDragSource" o = Gtk.TreeView.TreeViewEnableModelDragSourceMethodInfo
    ResolveTreeMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
    ResolveTreeMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveTreeMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
    ResolveTreeMethod "expandAll" o = Gtk.TreeView.TreeViewExpandAllMethodInfo
    ResolveTreeMethod "expandRow" o = Gtk.TreeView.TreeViewExpandRowMethodInfo
    ResolveTreeMethod "expandToNode" o = TreeExpandToNodeMethodInfo
    ResolveTreeMethod "expandToPath" o = Gtk.TreeView.TreeViewExpandToPathMethodInfo
    ResolveTreeMethod "findChildNode" o = TreeFindChildNodeMethodInfo
    ResolveTreeMethod "findCustom" o = TreeFindCustomMethodInfo
    ResolveTreeMethod "findItem" o = TreeFindItemMethodInfo
    ResolveTreeMethod "forall" o = Gtk.Container.ContainerForallMethodInfo
    ResolveTreeMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTreeMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo
    ResolveTreeMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
    ResolveTreeMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTreeMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTreeMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
    ResolveTreeMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
    ResolveTreeMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveTreeMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
    ResolveTreeMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveTreeMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveTreeMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
    ResolveTreeMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
    ResolveTreeMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
    ResolveTreeMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveTreeMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveTreeMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
    ResolveTreeMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveTreeMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveTreeMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
    ResolveTreeMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveTreeMethod "insertColumn" o = Gtk.TreeView.TreeViewInsertColumnMethodInfo
    ResolveTreeMethod "insertColumnWithDataFunc" o = Gtk.TreeView.TreeViewInsertColumnWithDataFuncMethodInfo
    ResolveTreeMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
    ResolveTreeMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveTreeMethod "isBlankAtPos" o = Gtk.TreeView.TreeViewIsBlankAtPosMethodInfo
    ResolveTreeMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
    ResolveTreeMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveTreeMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTreeMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveTreeMethod "isRubberBandingActive" o = Gtk.TreeView.TreeViewIsRubberBandingActiveMethodInfo
    ResolveTreeMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveTreeMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
    ResolveTreeMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveTreeMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveTreeMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
    ResolveTreeMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
    ResolveTreeMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveTreeMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveTreeMethod "mapExpandedRows" o = Gtk.TreeView.TreeViewMapExpandedRowsMethodInfo
    ResolveTreeMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveTreeMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
    ResolveTreeMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
    ResolveTreeMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
    ResolveTreeMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
    ResolveTreeMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
    ResolveTreeMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
    ResolveTreeMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
    ResolveTreeMethod "moveColumnAfter" o = Gtk.TreeView.TreeViewMoveColumnAfterMethodInfo
    ResolveTreeMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTreeMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTreeMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
    ResolveTreeMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
    ResolveTreeMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
    ResolveTreeMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
    ResolveTreeMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
    ResolveTreeMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveTreeMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
    ResolveTreeMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo
    ResolveTreeMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveTreeMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
    ResolveTreeMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveTreeMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
    ResolveTreeMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
    ResolveTreeMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveTreeMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
    ResolveTreeMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveTreeMethod "rebuild" o = TreeRebuildMethodInfo
    ResolveTreeMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTreeMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTreeMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
    ResolveTreeMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
    ResolveTreeMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo
    ResolveTreeMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
    ResolveTreeMethod "removeBuilder" o = TreeRemoveBuilderMethodInfo
    ResolveTreeMethod "removeColumn" o = Gtk.TreeView.TreeViewRemoveColumnMethodInfo
    ResolveTreeMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveTreeMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveTreeMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
    ResolveTreeMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
    ResolveTreeMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
    ResolveTreeMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
    ResolveTreeMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
    ResolveTreeMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo
    ResolveTreeMethod "rowActivated" o = Gtk.TreeView.TreeViewRowActivatedMethodInfo
    ResolveTreeMethod "rowExpanded" o = Gtk.TreeView.TreeViewRowExpandedMethodInfo
    ResolveTreeMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTreeMethod "scrollToCell" o = Gtk.TreeView.TreeViewScrollToCellMethodInfo
    ResolveTreeMethod "scrollToNode" o = TreeScrollToNodeMethodInfo
    ResolveTreeMethod "scrollToPoint" o = Gtk.TreeView.TreeViewScrollToPointMethodInfo
    ResolveTreeMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
    ResolveTreeMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
    ResolveTreeMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
    ResolveTreeMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveTreeMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
    ResolveTreeMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
    ResolveTreeMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveTreeMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
    ResolveTreeMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
    ResolveTreeMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTreeMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTreeMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
    ResolveTreeMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
    ResolveTreeMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
    ResolveTreeMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTreeMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveTreeMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveTreeMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveTreeMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveTreeMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveTreeMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTreeMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
    ResolveTreeMethod "unselectAll" o = TreeUnselectAllMethodInfo
    ResolveTreeMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo
    ResolveTreeMethod "unsetRowsDragDest" o = Gtk.TreeView.TreeViewUnsetRowsDragDestMethodInfo
    ResolveTreeMethod "unsetRowsDragSource" o = Gtk.TreeView.TreeViewUnsetRowsDragSourceMethodInfo
    ResolveTreeMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveTreeMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTreeMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
    ResolveTreeMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
    ResolveTreeMethod "getActivateOnSingleClick" o = Gtk.TreeView.TreeViewGetActivateOnSingleClickMethodInfo
    ResolveTreeMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveTreeMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveTreeMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
    ResolveTreeMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveTreeMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveTreeMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveTreeMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
    ResolveTreeMethod "getBackgroundArea" o = Gtk.TreeView.TreeViewGetBackgroundAreaMethodInfo
    ResolveTreeMethod "getBinWindow" o = Gtk.TreeView.TreeViewGetBinWindowMethodInfo
    ResolveTreeMethod "getBorder" o = Gtk.Scrollable.ScrollableGetBorderMethodInfo
    ResolveTreeMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo
    ResolveTreeMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
    ResolveTreeMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveTreeMethod "getCellArea" o = Gtk.TreeView.TreeViewGetCellAreaMethodInfo
    ResolveTreeMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
    ResolveTreeMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveTreeMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo
    ResolveTreeMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
    ResolveTreeMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveTreeMethod "getColumn" o = Gtk.TreeView.TreeViewGetColumnMethodInfo
    ResolveTreeMethod "getColumns" o = Gtk.TreeView.TreeViewGetColumnsMethodInfo
    ResolveTreeMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
    ResolveTreeMethod "getContextMenu" o = TreeGetContextMenuMethodInfo
    ResolveTreeMethod "getCursor" o = Gtk.TreeView.TreeViewGetCursorMethodInfo
    ResolveTreeMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTreeMethod "getDestRowAtPos" o = Gtk.TreeView.TreeViewGetDestRowAtPosMethodInfo
    ResolveTreeMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
    ResolveTreeMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
    ResolveTreeMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveTreeMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveTreeMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
    ResolveTreeMethod "getDragDestRow" o = Gtk.TreeView.TreeViewGetDragDestRowMethodInfo
    ResolveTreeMethod "getEnableSearch" o = Gtk.TreeView.TreeViewGetEnableSearchMethodInfo
    ResolveTreeMethod "getEnableTreeLines" o = Gtk.TreeView.TreeViewGetEnableTreeLinesMethodInfo
    ResolveTreeMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
    ResolveTreeMethod "getExpanderColumn" o = Gtk.TreeView.TreeViewGetExpanderColumnMethodInfo
    ResolveTreeMethod "getFixedHeightMode" o = Gtk.TreeView.TreeViewGetFixedHeightModeMethodInfo
    ResolveTreeMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo
    ResolveTreeMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo
    ResolveTreeMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo
    ResolveTreeMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveTreeMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo
    ResolveTreeMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveTreeMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveTreeMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveTreeMethod "getGridLines" o = Gtk.TreeView.TreeViewGetGridLinesMethodInfo
    ResolveTreeMethod "getHadjustment" o = Gtk.TreeView.TreeViewGetHadjustmentMethodInfo
    ResolveTreeMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveTreeMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveTreeMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
    ResolveTreeMethod "getHeadersClickable" o = Gtk.TreeView.TreeViewGetHeadersClickableMethodInfo
    ResolveTreeMethod "getHeadersVisible" o = Gtk.TreeView.TreeViewGetHeadersVisibleMethodInfo
    ResolveTreeMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveTreeMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveTreeMethod "getHoverExpand" o = Gtk.TreeView.TreeViewGetHoverExpandMethodInfo
    ResolveTreeMethod "getHoverSelection" o = Gtk.TreeView.TreeViewGetHoverSelectionMethodInfo
    ResolveTreeMethod "getHscrollPolicy" o = Gtk.Scrollable.ScrollableGetHscrollPolicyMethodInfo
    ResolveTreeMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveTreeMethod "getLevelIndentation" o = Gtk.TreeView.TreeViewGetLevelIndentationMethodInfo
    ResolveTreeMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveTreeMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveTreeMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveTreeMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
    ResolveTreeMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
    ResolveTreeMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveTreeMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveTreeMethod "getModel" o = Gtk.TreeView.TreeViewGetModelMethodInfo
    ResolveTreeMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
    ResolveTreeMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
    ResolveTreeMethod "getNColumns" o = Gtk.TreeView.TreeViewGetNColumnsMethodInfo
    ResolveTreeMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveTreeMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
    ResolveTreeMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveTreeMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveTreeMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveTreeMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
    ResolveTreeMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
    ResolveTreeMethod "getPathAtPos" o = Gtk.TreeView.TreeViewGetPathAtPosMethodInfo
    ResolveTreeMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo
    ResolveTreeMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
    ResolveTreeMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
    ResolveTreeMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
    ResolveTreeMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
    ResolveTreeMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveTreeMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
    ResolveTreeMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
    ResolveTreeMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTreeMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTreeMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveTreeMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveTreeMethod "getReorderable" o = Gtk.TreeView.TreeViewGetReorderableMethodInfo
    ResolveTreeMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveTreeMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
    ResolveTreeMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo
    ResolveTreeMethod "getRoot" o = TreeGetRootMethodInfo
    ResolveTreeMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
    ResolveTreeMethod "getRubberBanding" o = Gtk.TreeView.TreeViewGetRubberBandingMethodInfo
    ResolveTreeMethod "getRulesHint" o = Gtk.TreeView.TreeViewGetRulesHintMethodInfo
    ResolveTreeMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveTreeMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
    ResolveTreeMethod "getSearchColumn" o = Gtk.TreeView.TreeViewGetSearchColumnMethodInfo
    ResolveTreeMethod "getSearchEntry" o = Gtk.TreeView.TreeViewGetSearchEntryMethodInfo
    ResolveTreeMethod "getSelected" o = TreeGetSelectedMethodInfo
    ResolveTreeMethod "getSelection" o = Gtk.TreeView.TreeViewGetSelectionMethodInfo
    ResolveTreeMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveTreeMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveTreeMethod "getShowExpanders" o = Gtk.TreeView.TreeViewGetShowExpandersMethodInfo
    ResolveTreeMethod "getShowIcons" o = TreeGetShowIconsMethodInfo
    ResolveTreeMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveTreeMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
    ResolveTreeMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveTreeMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
    ResolveTreeMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveTreeMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
    ResolveTreeMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveTreeMethod "getTooltipColumn" o = Gtk.TreeView.TreeViewGetTooltipColumnMethodInfo
    ResolveTreeMethod "getTooltipContext" o = Gtk.TreeView.TreeViewGetTooltipContextMethodInfo
    ResolveTreeMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveTreeMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveTreeMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
    ResolveTreeMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
    ResolveTreeMethod "getVadjustment" o = Gtk.TreeView.TreeViewGetVadjustmentMethodInfo
    ResolveTreeMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveTreeMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
    ResolveTreeMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveTreeMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveTreeMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveTreeMethod "getVisibleRange" o = Gtk.TreeView.TreeViewGetVisibleRangeMethodInfo
    ResolveTreeMethod "getVisibleRect" o = Gtk.TreeView.TreeViewGetVisibleRectMethodInfo
    ResolveTreeMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
    ResolveTreeMethod "getVscrollPolicy" o = Gtk.Scrollable.ScrollableGetVscrollPolicyMethodInfo
    ResolveTreeMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
    ResolveTreeMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
    ResolveTreeMethod "setActivateOnSingleClick" o = Gtk.TreeView.TreeViewSetActivateOnSingleClickMethodInfo
    ResolveTreeMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
    ResolveTreeMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
    ResolveTreeMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo
    ResolveTreeMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveTreeMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
    ResolveTreeMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveTreeMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveTreeMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
    ResolveTreeMethod "setColumnDragFunction" o = Gtk.TreeView.TreeViewSetColumnDragFunctionMethodInfo
    ResolveTreeMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
    ResolveTreeMethod "setContextMenu" o = TreeSetContextMenuMethodInfo
    ResolveTreeMethod "setCursor" o = Gtk.TreeView.TreeViewSetCursorMethodInfo
    ResolveTreeMethod "setCursorOnCell" o = Gtk.TreeView.TreeViewSetCursorOnCellMethodInfo
    ResolveTreeMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTreeMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTreeMethod "setDestroyCountFunc" o = Gtk.TreeView.TreeViewSetDestroyCountFuncMethodInfo
    ResolveTreeMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
    ResolveTreeMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
    ResolveTreeMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveTreeMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
    ResolveTreeMethod "setDragDestRow" o = Gtk.TreeView.TreeViewSetDragDestRowMethodInfo
    ResolveTreeMethod "setEnableSearch" o = Gtk.TreeView.TreeViewSetEnableSearchMethodInfo
    ResolveTreeMethod "setEnableTreeLines" o = Gtk.TreeView.TreeViewSetEnableTreeLinesMethodInfo
    ResolveTreeMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
    ResolveTreeMethod "setExpanderColumn" o = Gtk.TreeView.TreeViewSetExpanderColumnMethodInfo
    ResolveTreeMethod "setFilter" o = TreeSetFilterMethodInfo
    ResolveTreeMethod "setFixedHeightMode" o = Gtk.TreeView.TreeViewSetFixedHeightModeMethodInfo
    ResolveTreeMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo
    ResolveTreeMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo
    ResolveTreeMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo
    ResolveTreeMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveTreeMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo
    ResolveTreeMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveTreeMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveTreeMethod "setGridLines" o = Gtk.TreeView.TreeViewSetGridLinesMethodInfo
    ResolveTreeMethod "setHadjustment" o = Gtk.TreeView.TreeViewSetHadjustmentMethodInfo
    ResolveTreeMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveTreeMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveTreeMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
    ResolveTreeMethod "setHeadersClickable" o = Gtk.TreeView.TreeViewSetHeadersClickableMethodInfo
    ResolveTreeMethod "setHeadersVisible" o = Gtk.TreeView.TreeViewSetHeadersVisibleMethodInfo
    ResolveTreeMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveTreeMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveTreeMethod "setHoverExpand" o = Gtk.TreeView.TreeViewSetHoverExpandMethodInfo
    ResolveTreeMethod "setHoverSelection" o = Gtk.TreeView.TreeViewSetHoverSelectionMethodInfo
    ResolveTreeMethod "setHscrollPolicy" o = Gtk.Scrollable.ScrollableSetHscrollPolicyMethodInfo
    ResolveTreeMethod "setLevelIndentation" o = Gtk.TreeView.TreeViewSetLevelIndentationMethodInfo
    ResolveTreeMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
    ResolveTreeMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveTreeMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveTreeMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
    ResolveTreeMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
    ResolveTreeMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveTreeMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveTreeMethod "setModel" o = Gtk.TreeView.TreeViewSetModelMethodInfo
    ResolveTreeMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveTreeMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
    ResolveTreeMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveTreeMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveTreeMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
    ResolveTreeMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTreeMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
    ResolveTreeMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo
    ResolveTreeMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveTreeMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
    ResolveTreeMethod "setReorderable" o = Gtk.TreeView.TreeViewSetReorderableMethodInfo
    ResolveTreeMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo
    ResolveTreeMethod "setRoot" o = TreeSetRootMethodInfo
    ResolveTreeMethod "setRowSeparatorFunc" o = Gtk.TreeView.TreeViewSetRowSeparatorFuncMethodInfo
    ResolveTreeMethod "setRubberBanding" o = Gtk.TreeView.TreeViewSetRubberBandingMethodInfo
    ResolveTreeMethod "setRulesHint" o = Gtk.TreeView.TreeViewSetRulesHintMethodInfo
    ResolveTreeMethod "setSearchColumn" o = Gtk.TreeView.TreeViewSetSearchColumnMethodInfo
    ResolveTreeMethod "setSearchEntry" o = Gtk.TreeView.TreeViewSetSearchEntryMethodInfo
    ResolveTreeMethod "setSearchEqualFunc" o = Gtk.TreeView.TreeViewSetSearchEqualFuncMethodInfo
    ResolveTreeMethod "setSearchPositionFunc" o = Gtk.TreeView.TreeViewSetSearchPositionFuncMethodInfo
    ResolveTreeMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveTreeMethod "setShowExpanders" o = Gtk.TreeView.TreeViewSetShowExpandersMethodInfo
    ResolveTreeMethod "setShowIcons" o = TreeSetShowIconsMethodInfo
    ResolveTreeMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveTreeMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
    ResolveTreeMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveTreeMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
    ResolveTreeMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
    ResolveTreeMethod "setTooltipCell" o = Gtk.TreeView.TreeViewSetTooltipCellMethodInfo
    ResolveTreeMethod "setTooltipColumn" o = Gtk.TreeView.TreeViewSetTooltipColumnMethodInfo
    ResolveTreeMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveTreeMethod "setTooltipRow" o = Gtk.TreeView.TreeViewSetTooltipRowMethodInfo
    ResolveTreeMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveTreeMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
    ResolveTreeMethod "setVadjustment" o = Gtk.TreeView.TreeViewSetVadjustmentMethodInfo
    ResolveTreeMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveTreeMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveTreeMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveTreeMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveTreeMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
    ResolveTreeMethod "setVscrollPolicy" o = Gtk.Scrollable.ScrollableSetVscrollPolicyMethodInfo
    ResolveTreeMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
    ResolveTreeMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal Tree::action
-- | /No description available in the introspection data./
type TreeActionCallback =
    T.Text
    -> T.Text
    -> T.Text
    -> IO ()

type C_TreeActionCallback =
    Ptr Tree ->                             -- object
    CString ->
    CString ->
    CString ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TreeActionCallback :: 
    GObject a => (a -> TreeActionCallback) ->
    C_TreeActionCallback
wrap_TreeActionCallback :: forall a.
GObject a =>
(a -> TreeActionCallback) -> C_TreeActionCallback
wrap_TreeActionCallback a -> TreeActionCallback
gi'cb Ptr Tree
gi'selfPtr CString
object CString
p0 CString
p1 Ptr ()
_ = do
    Text
object' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
object
    Text
p0' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
p0
    Text
p1' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
p1
    Ptr Tree -> (Tree -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Tree
gi'selfPtr ((Tree -> IO ()) -> IO ()) -> (Tree -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Tree
gi'self -> a -> TreeActionCallback
gi'cb (Tree -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Tree
gi'self)  Text
object' Text
p0' Text
p1'


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

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


#if defined(ENABLE_OVERLOADING)
data TreeActionSignalInfo
instance SignalInfo TreeActionSignalInfo where
    type HaskellCallbackType TreeActionSignalInfo = TreeActionCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreeActionCallback cb
        cb'' <- mk_TreeActionCallback cb'
        connectSignalFunPtr obj "action" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree::action"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#g:signal:action"})

#endif

-- signal Tree::populate-popup
-- | /No description available in the introspection data./
type TreePopulatePopupCallback =
    Gtk.Widget.Widget
    -> IO ()

type C_TreePopulatePopupCallback =
    Ptr Tree ->                             -- object
    Ptr Gtk.Widget.Widget ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TreePopulatePopupCallback :: 
    GObject a => (a -> TreePopulatePopupCallback) ->
    C_TreePopulatePopupCallback
wrap_TreePopulatePopupCallback :: forall a.
GObject a =>
(a -> TreePopulatePopupCallback) -> C_TreePopulatePopupCallback
wrap_TreePopulatePopupCallback a -> TreePopulatePopupCallback
gi'cb Ptr Tree
gi'selfPtr Ptr Widget
object Ptr ()
_ = do
    Widget
object' <- ((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
object
    Ptr Tree -> (Tree -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Tree
gi'selfPtr ((Tree -> IO ()) -> IO ()) -> (Tree -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Tree
gi'self -> a -> TreePopulatePopupCallback
gi'cb (Tree -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Tree
gi'self)  Widget
object'


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

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


#if defined(ENABLE_OVERLOADING)
data TreePopulatePopupSignalInfo
instance SignalInfo TreePopulatePopupSignalInfo where
    type HaskellCallbackType TreePopulatePopupSignalInfo = TreePopulatePopupCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TreePopulatePopupCallback cb
        cb'' <- mk_TreePopulatePopupCallback cb'
        connectSignalFunPtr obj "populate-popup" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree::populate-popup"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#g:signal:populatePopup"})

#endif

-- VVV Prop "always-expand"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@always-expand@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' tree #alwaysExpand
-- @
getTreeAlwaysExpand :: (MonadIO m, IsTree o) => o -> m Bool
getTreeAlwaysExpand :: forall (m :: * -> *) o. (MonadIO m, IsTree o) => o -> m Bool
getTreeAlwaysExpand o
obj = IO Bool -> m Bool
forall a. IO a -> m a
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
"always-expand"

-- | Construct a `GValueConstruct` with valid value for the “@always-expand@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTreeAlwaysExpand :: (IsTree o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTreeAlwaysExpand :: forall o (m :: * -> *).
(IsTree o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTreeAlwaysExpand Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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
"always-expand" Bool
val

#if defined(ENABLE_OVERLOADING)
data TreeAlwaysExpandPropertyInfo
instance AttrInfo TreeAlwaysExpandPropertyInfo where
    type AttrAllowedOps TreeAlwaysExpandPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeAlwaysExpandPropertyInfo = IsTree
    type AttrSetTypeConstraint TreeAlwaysExpandPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TreeAlwaysExpandPropertyInfo = (~) Bool
    type AttrTransferType TreeAlwaysExpandPropertyInfo = Bool
    type AttrGetType TreeAlwaysExpandPropertyInfo = Bool
    type AttrLabel TreeAlwaysExpandPropertyInfo = "always-expand"
    type AttrOrigin TreeAlwaysExpandPropertyInfo = Tree
    attrGet = getTreeAlwaysExpand
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructTreeAlwaysExpand
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.alwaysExpand"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#g:attr:alwaysExpand"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TreeContextMenuPropertyInfo
instance AttrInfo TreeContextMenuPropertyInfo where
    type AttrAllowedOps TreeContextMenuPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeContextMenuPropertyInfo = IsTree
    type AttrSetTypeConstraint TreeContextMenuPropertyInfo = Gio.MenuModel.IsMenuModel
    type AttrTransferTypeConstraint TreeContextMenuPropertyInfo = Gio.MenuModel.IsMenuModel
    type AttrTransferType TreeContextMenuPropertyInfo = Gio.MenuModel.MenuModel
    type AttrGetType TreeContextMenuPropertyInfo = (Maybe Gio.MenuModel.MenuModel)
    type AttrLabel TreeContextMenuPropertyInfo = "context-menu"
    type AttrOrigin TreeContextMenuPropertyInfo = Tree
    attrGet = getTreeContextMenu
    attrSet = setTreeContextMenu
    attrTransfer _ v = do
        unsafeCastTo Gio.MenuModel.MenuModel v
    attrConstruct = constructTreeContextMenu
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.contextMenu"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#g:attr:contextMenu"
        })
#endif

-- VVV Prop "root"
   -- Type: TInterface (Name {namespace = "Dazzle", name = "TreeNode"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just False)

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

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

-- | Construct a `GValueConstruct` with valid value for the “@root@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTreeRoot :: (IsTree o, MIO.MonadIO m, Dazzle.TreeNode.IsTreeNode a) => a -> m (GValueConstruct o)
constructTreeRoot :: forall o (m :: * -> *) a.
(IsTree o, MonadIO m, IsTreeNode a) =>
a -> m (GValueConstruct o)
constructTreeRoot a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"root" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data TreeRootPropertyInfo
instance AttrInfo TreeRootPropertyInfo where
    type AttrAllowedOps TreeRootPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeRootPropertyInfo = IsTree
    type AttrSetTypeConstraint TreeRootPropertyInfo = Dazzle.TreeNode.IsTreeNode
    type AttrTransferTypeConstraint TreeRootPropertyInfo = Dazzle.TreeNode.IsTreeNode
    type AttrTransferType TreeRootPropertyInfo = Dazzle.TreeNode.TreeNode
    type AttrGetType TreeRootPropertyInfo = (Maybe Dazzle.TreeNode.TreeNode)
    type AttrLabel TreeRootPropertyInfo = "root"
    type AttrOrigin TreeRootPropertyInfo = Tree
    attrGet = getTreeRoot
    attrSet = setTreeRoot
    attrTransfer _ v = do
        unsafeCastTo Dazzle.TreeNode.TreeNode v
    attrConstruct = constructTreeRoot
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.root"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#g:attr:root"
        })
#endif

-- VVV Prop "selection"
   -- Type: TInterface (Name {namespace = "Dazzle", name = "TreeNode"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

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

-- | Construct a `GValueConstruct` with valid value for the “@selection@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTreeSelection :: (IsTree o, MIO.MonadIO m, Dazzle.TreeNode.IsTreeNode a) => a -> m (GValueConstruct o)
constructTreeSelection :: forall o (m :: * -> *) a.
(IsTree o, MonadIO m, IsTreeNode a) =>
a -> m (GValueConstruct o)
constructTreeSelection a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"selection" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

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

#if defined(ENABLE_OVERLOADING)
data TreeSelectionPropertyInfo
instance AttrInfo TreeSelectionPropertyInfo where
    type AttrAllowedOps TreeSelectionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TreeSelectionPropertyInfo = IsTree
    type AttrSetTypeConstraint TreeSelectionPropertyInfo = Dazzle.TreeNode.IsTreeNode
    type AttrTransferTypeConstraint TreeSelectionPropertyInfo = Dazzle.TreeNode.IsTreeNode
    type AttrTransferType TreeSelectionPropertyInfo = Dazzle.TreeNode.TreeNode
    type AttrGetType TreeSelectionPropertyInfo = (Maybe Dazzle.TreeNode.TreeNode)
    type AttrLabel TreeSelectionPropertyInfo = "selection"
    type AttrOrigin TreeSelectionPropertyInfo = Tree
    attrGet = getTreeSelection
    attrSet = setTreeSelection
    attrTransfer _ v = do
        unsafeCastTo Dazzle.TreeNode.TreeNode v
    attrConstruct = constructTreeSelection
    attrClear = clearTreeSelection
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.selection"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#g:attr:selection"
        })
#endif

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

-- | Get the value of the “@show-icons@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' tree #showIcons
-- @
getTreeShowIcons :: (MonadIO m, IsTree o) => o -> m Bool
getTreeShowIcons :: forall (m :: * -> *) o. (MonadIO m, IsTree o) => o -> m Bool
getTreeShowIcons o
obj = IO Bool -> m Bool
forall a. IO a -> m a
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
"show-icons"

-- | Set the value of the “@show-icons@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' tree [ #showIcons 'Data.GI.Base.Attributes.:=' value ]
-- @
setTreeShowIcons :: (MonadIO m, IsTree o) => o -> Bool -> m ()
setTreeShowIcons :: forall (m :: * -> *) o. (MonadIO m, IsTree o) => o -> Bool -> m ()
setTreeShowIcons o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
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
"show-icons" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@show-icons@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTreeShowIcons :: (IsTree o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTreeShowIcons :: forall o (m :: * -> *).
(IsTree o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTreeShowIcons Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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
"show-icons" Bool
val

#if defined(ENABLE_OVERLOADING)
data TreeShowIconsPropertyInfo
instance AttrInfo TreeShowIconsPropertyInfo where
    type AttrAllowedOps TreeShowIconsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TreeShowIconsPropertyInfo = IsTree
    type AttrSetTypeConstraint TreeShowIconsPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TreeShowIconsPropertyInfo = (~) Bool
    type AttrTransferType TreeShowIconsPropertyInfo = Bool
    type AttrGetType TreeShowIconsPropertyInfo = Bool
    type AttrLabel TreeShowIconsPropertyInfo = "show-icons"
    type AttrOrigin TreeShowIconsPropertyInfo = Tree
    attrGet = getTreeShowIcons
    attrSet = setTreeShowIcons
    attrTransfer _ v = do
        return v
    attrConstruct = constructTreeShowIcons
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.showIcons"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#g:attr:showIcons"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Tree
type instance O.AttributeList Tree = TreeAttributeList
type TreeAttributeList = ('[ '("activateOnSingleClick", Gtk.TreeView.TreeViewActivateOnSingleClickPropertyInfo), '("alwaysExpand", TreeAlwaysExpandPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("contextMenu", TreeContextMenuPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("enableGridLines", Gtk.TreeView.TreeViewEnableGridLinesPropertyInfo), '("enableSearch", Gtk.TreeView.TreeViewEnableSearchPropertyInfo), '("enableTreeLines", Gtk.TreeView.TreeViewEnableTreeLinesPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("expanderColumn", Gtk.TreeView.TreeViewExpanderColumnPropertyInfo), '("fixedHeightMode", Gtk.TreeView.TreeViewFixedHeightModePropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("hadjustment", Gtk.Scrollable.ScrollableHadjustmentPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("headersClickable", Gtk.TreeView.TreeViewHeadersClickablePropertyInfo), '("headersVisible", Gtk.TreeView.TreeViewHeadersVisiblePropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hoverExpand", Gtk.TreeView.TreeViewHoverExpandPropertyInfo), '("hoverSelection", Gtk.TreeView.TreeViewHoverSelectionPropertyInfo), '("hscrollPolicy", Gtk.Scrollable.ScrollableHscrollPolicyPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("levelIndentation", Gtk.TreeView.TreeViewLevelIndentationPropertyInfo), '("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), '("model", Gtk.TreeView.TreeViewModelPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("reorderable", Gtk.TreeView.TreeViewReorderablePropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("root", TreeRootPropertyInfo), '("rubberBanding", Gtk.TreeView.TreeViewRubberBandingPropertyInfo), '("rulesHint", Gtk.TreeView.TreeViewRulesHintPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("searchColumn", Gtk.TreeView.TreeViewSearchColumnPropertyInfo), '("selection", TreeSelectionPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showExpanders", Gtk.TreeView.TreeViewShowExpandersPropertyInfo), '("showIcons", TreeShowIconsPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipColumn", Gtk.TreeView.TreeViewTooltipColumnPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("vadjustment", Gtk.Scrollable.ScrollableVadjustmentPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("vscrollPolicy", Gtk.Scrollable.ScrollableVscrollPolicyPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
treeAlwaysExpand :: AttrLabelProxy "alwaysExpand"
treeAlwaysExpand = AttrLabelProxy

treeContextMenu :: AttrLabelProxy "contextMenu"
treeContextMenu = AttrLabelProxy

treeRoot :: AttrLabelProxy "root"
treeRoot = AttrLabelProxy

treeSelection :: AttrLabelProxy "selection"
treeSelection = AttrLabelProxy

treeShowIcons :: AttrLabelProxy "showIcons"
treeShowIcons = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Tree = TreeSignalList
type TreeSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("action", TreeActionSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("columnsChanged", Gtk.TreeView.TreeViewColumnsChangedSignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("cursorChanged", Gtk.TreeView.TreeViewCursorChangedSignalInfo), '("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), '("expandCollapseCursorRow", Gtk.TreeView.TreeViewExpandCollapseCursorRowSignalInfo), '("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), '("moveCursor", Gtk.TreeView.TreeViewMoveCursorSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("populatePopup", TreePopulatePopupSignalInfo), '("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), '("rowActivated", Gtk.TreeView.TreeViewRowActivatedSignalInfo), '("rowCollapsed", Gtk.TreeView.TreeViewRowCollapsedSignalInfo), '("rowExpanded", Gtk.TreeView.TreeViewRowExpandedSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectAll", Gtk.TreeView.TreeViewSelectAllSignalInfo), '("selectCursorParent", Gtk.TreeView.TreeViewSelectCursorParentSignalInfo), '("selectCursorRow", Gtk.TreeView.TreeViewSelectCursorRowSignalInfo), '("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), '("startInteractiveSearch", Gtk.TreeView.TreeViewStartInteractiveSearchSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("testCollapseRow", Gtk.TreeView.TreeViewTestCollapseRowSignalInfo), '("testExpandRow", Gtk.TreeView.TreeViewTestExpandRowSignalInfo), '("toggleCursorRow", Gtk.TreeView.TreeViewToggleCursorRowSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("unselectAll", Gtk.TreeView.TreeViewUnselectAllSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, DK.Type)])

#endif

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

foreign import ccall "dzl_tree_add_builder" dzl_tree_add_builder :: 
    Ptr Tree ->                             -- self : TInterface (Name {namespace = "Dazzle", name = "Tree"})
    Ptr Dazzle.TreeBuilder.TreeBuilder ->   -- builder : TInterface (Name {namespace = "Dazzle", name = "TreeBuilder"})
    IO ()

-- | Add a builder to the tree.
treeAddBuilder ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a, Dazzle.TreeBuilder.IsTreeBuilder b) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Objects.Tree.Tree'.
    -> b
    -- ^ /@builder@/: A t'GI.Dazzle.Objects.TreeBuilder.TreeBuilder' to add.
    -> m ()
treeAddBuilder :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTree a, IsTreeBuilder b) =>
a -> b -> m ()
treeAddBuilder a
self b
builder = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TreeBuilder
builder' <- b -> IO (Ptr TreeBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
builder
    Ptr Tree -> Ptr TreeBuilder -> IO ()
dzl_tree_add_builder Ptr Tree
self' Ptr TreeBuilder
builder'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
builder
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TreeAddBuilderMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTree a, Dazzle.TreeBuilder.IsTreeBuilder b) => O.OverloadedMethod TreeAddBuilderMethodInfo a signature where
    overloadedMethod = treeAddBuilder

instance O.OverloadedMethodInfo TreeAddBuilderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeAddBuilder",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeAddBuilder"
        })


#endif

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

foreign import ccall "dzl_tree_expand_to_node" dzl_tree_expand_to_node :: 
    Ptr Tree ->                             -- self : TInterface (Name {namespace = "Dazzle", name = "Tree"})
    Ptr Dazzle.TreeNode.TreeNode ->         -- node : TInterface (Name {namespace = "Dazzle", name = "TreeNode"})
    IO ()

-- | /No description available in the introspection data./
treeExpandToNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a, Dazzle.TreeNode.IsTreeNode b) =>
    a
    -> b
    -> m ()
treeExpandToNode :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTree a, IsTreeNode b) =>
a -> b -> m ()
treeExpandToNode a
self b
node = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TreeNode
node' <- b -> IO (Ptr TreeNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
node
    Ptr Tree -> Ptr TreeNode -> IO ()
dzl_tree_expand_to_node Ptr Tree
self' Ptr TreeNode
node'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
node
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TreeExpandToNodeMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTree a, Dazzle.TreeNode.IsTreeNode b) => O.OverloadedMethod TreeExpandToNodeMethodInfo a signature where
    overloadedMethod = treeExpandToNode

instance O.OverloadedMethodInfo TreeExpandToNodeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeExpandToNode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeExpandToNode"
        })


#endif

-- method Tree::find_child_node
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "Tree" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlTree" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "TreeNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlTreeNode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "find_func"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "TreeFindFunc" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A callback to locate the child"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = 3
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data for @find_func"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Dazzle" , name = "TreeNode" })
-- throws : False
-- Skip return : False

foreign import ccall "dzl_tree_find_child_node" dzl_tree_find_child_node :: 
    Ptr Tree ->                             -- self : TInterface (Name {namespace = "Dazzle", name = "Tree"})
    Ptr Dazzle.TreeNode.TreeNode ->         -- node : TInterface (Name {namespace = "Dazzle", name = "TreeNode"})
    FunPtr Dazzle.Callbacks.C_TreeFindFunc -> -- find_func : TInterface (Name {namespace = "Dazzle", name = "TreeFindFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO (Ptr Dazzle.TreeNode.TreeNode)

-- | Searches through the direct children of /@node@/ for a matching child.
-- /@findFunc@/ should return 'P.True' if the child matches, otherwise 'P.False'.
treeFindChildNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a, Dazzle.TreeNode.IsTreeNode b) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Objects.Tree.Tree'
    -> b
    -- ^ /@node@/: A t'GI.Dazzle.Objects.TreeNode.TreeNode'
    -> Dazzle.Callbacks.TreeFindFunc
    -- ^ /@findFunc@/: A callback to locate the child
    -> m (Maybe Dazzle.TreeNode.TreeNode)
    -- ^ __Returns:__ A t'GI.Dazzle.Objects.TreeNode.TreeNode' or 'P.Nothing'.
treeFindChildNode :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTree a, IsTreeNode b) =>
a -> b -> TreeFindFunc -> m (Maybe TreeNode)
treeFindChildNode a
self b
node TreeFindFunc
findFunc = IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeNode) -> m (Maybe TreeNode))
-> IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TreeNode
node' <- b -> IO (Ptr TreeNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
node
    FunPtr C_TreeFindFunc
findFunc' <- C_TreeFindFunc -> IO (FunPtr C_TreeFindFunc)
Dazzle.Callbacks.mk_TreeFindFunc (Maybe (Ptr (FunPtr C_TreeFindFunc))
-> TreeFindFunc_WithClosures -> C_TreeFindFunc
Dazzle.Callbacks.wrap_TreeFindFunc Maybe (Ptr (FunPtr C_TreeFindFunc))
forall a. Maybe a
Nothing (TreeFindFunc -> TreeFindFunc_WithClosures
Dazzle.Callbacks.drop_closures_TreeFindFunc TreeFindFunc
findFunc))
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr TreeNode
result <- Ptr Tree
-> Ptr TreeNode
-> FunPtr C_TreeFindFunc
-> Ptr ()
-> IO (Ptr TreeNode)
dzl_tree_find_child_node Ptr Tree
self' Ptr TreeNode
node' FunPtr C_TreeFindFunc
findFunc' Ptr ()
forall a. Ptr a
userData
    Maybe TreeNode
maybeResult <- Ptr TreeNode
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreeNode
result ((Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode))
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ \Ptr TreeNode
result' -> do
        TreeNode
result'' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
result'
        TreeNode -> IO TreeNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TreeNode
result''
    Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_TreeFindFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_TreeFindFunc
findFunc'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
node
    Maybe TreeNode -> IO (Maybe TreeNode)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeNode
maybeResult

#if defined(ENABLE_OVERLOADING)
data TreeFindChildNodeMethodInfo
instance (signature ~ (b -> Dazzle.Callbacks.TreeFindFunc -> m (Maybe Dazzle.TreeNode.TreeNode)), MonadIO m, IsTree a, Dazzle.TreeNode.IsTreeNode b) => O.OverloadedMethod TreeFindChildNodeMethodInfo a signature where
    overloadedMethod = treeFindChildNode

instance O.OverloadedMethodInfo TreeFindChildNodeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeFindChildNode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeFindChildNode"
        })


#endif

-- method Tree::find_custom
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "Tree" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlTree" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "equal_func"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "EqualFunc" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GEqualFunc" , sinceVersion = Nothing }
--           , argScope = ScopeTypeCall
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the key for @equal_func"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Dazzle" , name = "TreeNode" })
-- throws : False
-- Skip return : False

foreign import ccall "dzl_tree_find_custom" dzl_tree_find_custom :: 
    Ptr Tree ->                             -- self : TInterface (Name {namespace = "Dazzle", name = "Tree"})
    FunPtr GLib.Callbacks.C_EqualFunc ->    -- equal_func : TInterface (Name {namespace = "GLib", name = "EqualFunc"})
    Ptr () ->                               -- key : TBasicType TPtr
    IO (Ptr Dazzle.TreeNode.TreeNode)

-- | Walks the entire tree looking for the first item that matches given
-- /@equalFunc@/ and /@key@/.
-- 
-- The first parameter to /@equalFunc@/ will always be /@key@/.
-- The second parameter will be the nodes [TreeNode:item]("GI.Dazzle.Objects.TreeNode#g:attr:item") property.
treeFindCustom ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Objects.Tree.Tree'
    -> GLib.Callbacks.EqualFunc
    -- ^ /@equalFunc@/: A t'GI.GLib.Callbacks.EqualFunc'
    -> Ptr ()
    -- ^ /@key@/: the key for /@equalFunc@/
    -> m (Maybe Dazzle.TreeNode.TreeNode)
    -- ^ __Returns:__ A t'GI.Dazzle.Objects.TreeNode.TreeNode' or 'P.Nothing'.
treeFindCustom :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTree a) =>
a -> EqualFunc -> Ptr () -> m (Maybe TreeNode)
treeFindCustom a
self EqualFunc
equalFunc Ptr ()
key = IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeNode) -> m (Maybe TreeNode))
-> IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    FunPtr C_EqualFunc
equalFunc' <- C_EqualFunc -> IO (FunPtr C_EqualFunc)
GLib.Callbacks.mk_EqualFunc (Maybe (Ptr (FunPtr C_EqualFunc))
-> EqualFunc_WithClosures -> C_EqualFunc
GLib.Callbacks.wrap_EqualFunc Maybe (Ptr (FunPtr C_EqualFunc))
forall a. Maybe a
Nothing (EqualFunc -> EqualFunc_WithClosures
GLib.Callbacks.drop_closures_EqualFunc EqualFunc
equalFunc))
    Ptr TreeNode
result <- Ptr Tree -> FunPtr C_EqualFunc -> Ptr () -> IO (Ptr TreeNode)
dzl_tree_find_custom Ptr Tree
self' FunPtr C_EqualFunc
equalFunc' Ptr ()
key
    Maybe TreeNode
maybeResult <- Ptr TreeNode
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreeNode
result ((Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode))
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ \Ptr TreeNode
result' -> do
        TreeNode
result'' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
result'
        TreeNode -> IO TreeNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TreeNode
result''
    Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_EqualFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_EqualFunc
equalFunc'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe TreeNode -> IO (Maybe TreeNode)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeNode
maybeResult

#if defined(ENABLE_OVERLOADING)
data TreeFindCustomMethodInfo
instance (signature ~ (GLib.Callbacks.EqualFunc -> Ptr () -> m (Maybe Dazzle.TreeNode.TreeNode)), MonadIO m, IsTree a) => O.OverloadedMethod TreeFindCustomMethodInfo a signature where
    overloadedMethod = treeFindCustom

instance O.OverloadedMethodInfo TreeFindCustomMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeFindCustom",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeFindCustom"
        })


#endif

-- method Tree::find_item
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "Tree" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlTree." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "item"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GObject or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Dazzle" , name = "TreeNode" })
-- throws : False
-- Skip return : False

foreign import ccall "dzl_tree_find_item" dzl_tree_find_item :: 
    Ptr Tree ->                             -- self : TInterface (Name {namespace = "Dazzle", name = "Tree"})
    Ptr GObject.Object.Object ->            -- item : TInterface (Name {namespace = "GObject", name = "Object"})
    IO (Ptr Dazzle.TreeNode.TreeNode)

-- | Finds a t'GI.Dazzle.Objects.TreeNode.TreeNode' with an item property matching /@item@/.
treeFindItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a, GObject.Object.IsObject b) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Objects.Tree.Tree'.
    -> Maybe (b)
    -- ^ /@item@/: A t'GI.GObject.Objects.Object.Object' or 'P.Nothing'.
    -> m (Maybe Dazzle.TreeNode.TreeNode)
    -- ^ __Returns:__ A t'GI.Dazzle.Objects.TreeNode.TreeNode' or 'P.Nothing'.
treeFindItem :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTree a, IsObject b) =>
a -> Maybe b -> m (Maybe TreeNode)
treeFindItem a
self Maybe b
item = IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeNode) -> m (Maybe TreeNode))
-> IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Object
maybeItem <- case Maybe b
item of
        Maybe b
Nothing -> Ptr Object -> IO (Ptr Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
        Just b
jItem -> do
            Ptr Object
jItem' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jItem
            Ptr Object -> IO (Ptr Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jItem'
    Ptr TreeNode
result <- Ptr Tree -> Ptr Object -> IO (Ptr TreeNode)
dzl_tree_find_item Ptr Tree
self' Ptr Object
maybeItem
    Maybe TreeNode
maybeResult <- Ptr TreeNode
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreeNode
result ((Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode))
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ \Ptr TreeNode
result' -> do
        TreeNode
result'' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
result'
        TreeNode -> IO TreeNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TreeNode
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
item b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Maybe TreeNode -> IO (Maybe TreeNode)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeNode
maybeResult

#if defined(ENABLE_OVERLOADING)
data TreeFindItemMethodInfo
instance (signature ~ (Maybe (b) -> m (Maybe Dazzle.TreeNode.TreeNode)), MonadIO m, IsTree a, GObject.Object.IsObject b) => O.OverloadedMethod TreeFindItemMethodInfo a signature where
    overloadedMethod = treeFindItem

instance O.OverloadedMethodInfo TreeFindItemMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeFindItem",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeFindItem"
        })


#endif

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

foreign import ccall "dzl_tree_get_context_menu" dzl_tree_get_context_menu :: 
    Ptr Tree ->                             -- self : TInterface (Name {namespace = "Dazzle", name = "Tree"})
    IO (Ptr Gio.MenuModel.MenuModel)

-- | /No description available in the introspection data./
treeGetContextMenu ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
    a
    -> m (Maybe Gio.MenuModel.MenuModel)
    -- ^ __Returns:__ A t'GI.Gio.Objects.MenuModel.MenuModel' or 'P.Nothing'.
treeGetContextMenu :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTree a) =>
a -> m (Maybe MenuModel)
treeGetContextMenu a
self = IO (Maybe MenuModel) -> m (Maybe MenuModel)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe MenuModel) -> m (Maybe MenuModel))
-> IO (Maybe MenuModel) -> m (Maybe MenuModel)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr MenuModel
result <- Ptr Tree -> IO (Ptr MenuModel)
dzl_tree_get_context_menu Ptr Tree
self'
    Maybe MenuModel
maybeResult <- Ptr MenuModel
-> (Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr MenuModel
result ((Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel))
-> (Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel)
forall a b. (a -> b) -> a -> b
$ \Ptr MenuModel
result' -> do
        MenuModel
result'' <- ((ManagedPtr MenuModel -> MenuModel)
-> Ptr MenuModel -> IO MenuModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr MenuModel -> MenuModel
Gio.MenuModel.MenuModel) Ptr MenuModel
result'
        MenuModel -> IO MenuModel
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MenuModel
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe MenuModel -> IO (Maybe MenuModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MenuModel
maybeResult

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

instance O.OverloadedMethodInfo TreeGetContextMenuMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeGetContextMenu",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeGetContextMenu"
        })


#endif

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

foreign import ccall "dzl_tree_get_root" dzl_tree_get_root :: 
    Ptr Tree ->                             -- self : TInterface (Name {namespace = "Dazzle", name = "Tree"})
    IO (Ptr Dazzle.TreeNode.TreeNode)

-- | Retrieves the root node of the tree. The root node is not a visible node
-- in the self, but a placeholder for all other builders to build upon.
treeGetRoot ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
    a
    -> m (Maybe Dazzle.TreeNode.TreeNode)
    -- ^ __Returns:__ A t'GI.Dazzle.Objects.TreeNode.TreeNode' or 'P.Nothing'.
treeGetRoot :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTree a) =>
a -> m (Maybe TreeNode)
treeGetRoot a
self = IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeNode) -> m (Maybe TreeNode))
-> IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TreeNode
result <- Ptr Tree -> IO (Ptr TreeNode)
dzl_tree_get_root Ptr Tree
self'
    Maybe TreeNode
maybeResult <- Ptr TreeNode
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreeNode
result ((Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode))
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ \Ptr TreeNode
result' -> do
        TreeNode
result'' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
result'
        TreeNode -> IO TreeNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TreeNode
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe TreeNode -> IO (Maybe TreeNode)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeNode
maybeResult

#if defined(ENABLE_OVERLOADING)
data TreeGetRootMethodInfo
instance (signature ~ (m (Maybe Dazzle.TreeNode.TreeNode)), MonadIO m, IsTree a) => O.OverloadedMethod TreeGetRootMethodInfo a signature where
    overloadedMethod = treeGetRoot

instance O.OverloadedMethodInfo TreeGetRootMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeGetRoot",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeGetRoot"
        })


#endif

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

foreign import ccall "dzl_tree_get_selected" dzl_tree_get_selected :: 
    Ptr Tree ->                             -- self : TInterface (Name {namespace = "Dazzle", name = "Tree"})
    IO (Ptr Dazzle.TreeNode.TreeNode)

-- | Gets the currently selected node in the tree.
treeGetSelected ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Objects.Tree.Tree'.
    -> m Dazzle.TreeNode.TreeNode
    -- ^ __Returns:__ A t'GI.Dazzle.Objects.TreeNode.TreeNode'.
treeGetSelected :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTree a) =>
a -> m TreeNode
treeGetSelected a
self = IO TreeNode -> m TreeNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TreeNode -> m TreeNode) -> IO TreeNode -> m TreeNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TreeNode
result <- Ptr Tree -> IO (Ptr TreeNode)
dzl_tree_get_selected Ptr Tree
self'
    Text -> Ptr TreeNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"treeGetSelected" Ptr TreeNode
result
    TreeNode
result' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeNode -> TreeNode
Dazzle.TreeNode.TreeNode) Ptr TreeNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    TreeNode -> IO TreeNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TreeNode
result'

#if defined(ENABLE_OVERLOADING)
data TreeGetSelectedMethodInfo
instance (signature ~ (m Dazzle.TreeNode.TreeNode), MonadIO m, IsTree a) => O.OverloadedMethod TreeGetSelectedMethodInfo a signature where
    overloadedMethod = treeGetSelected

instance O.OverloadedMethodInfo TreeGetSelectedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeGetSelected",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeGetSelected"
        })


#endif

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

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

-- | /No description available in the introspection data./
treeGetShowIcons ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
    a
    -> m Bool
treeGetShowIcons :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTree a) =>
a -> m Bool
treeGetShowIcons a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Tree -> IO CInt
dzl_tree_get_show_icons Ptr Tree
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TreeGetShowIconsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTree a) => O.OverloadedMethod TreeGetShowIconsMethodInfo a signature where
    overloadedMethod = treeGetShowIcons

instance O.OverloadedMethodInfo TreeGetShowIconsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeGetShowIcons",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeGetShowIcons"
        })


#endif

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

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

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

#if defined(ENABLE_OVERLOADING)
data TreeRebuildMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTree a) => O.OverloadedMethod TreeRebuildMethodInfo a signature where
    overloadedMethod = treeRebuild

instance O.OverloadedMethodInfo TreeRebuildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeRebuild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeRebuild"
        })


#endif

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

foreign import ccall "dzl_tree_remove_builder" dzl_tree_remove_builder :: 
    Ptr Tree ->                             -- self : TInterface (Name {namespace = "Dazzle", name = "Tree"})
    Ptr Dazzle.TreeBuilder.TreeBuilder ->   -- builder : TInterface (Name {namespace = "Dazzle", name = "TreeBuilder"})
    IO ()

-- | Removes a builder from the tree.
treeRemoveBuilder ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a, Dazzle.TreeBuilder.IsTreeBuilder b) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Objects.Tree.Tree'.
    -> b
    -- ^ /@builder@/: A t'GI.Dazzle.Objects.TreeBuilder.TreeBuilder' to remove.
    -> m ()
treeRemoveBuilder :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTree a, IsTreeBuilder b) =>
a -> b -> m ()
treeRemoveBuilder a
self b
builder = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TreeBuilder
builder' <- b -> IO (Ptr TreeBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
builder
    Ptr Tree -> Ptr TreeBuilder -> IO ()
dzl_tree_remove_builder Ptr Tree
self' Ptr TreeBuilder
builder'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
builder
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TreeRemoveBuilderMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTree a, Dazzle.TreeBuilder.IsTreeBuilder b) => O.OverloadedMethod TreeRemoveBuilderMethodInfo a signature where
    overloadedMethod = treeRemoveBuilder

instance O.OverloadedMethodInfo TreeRemoveBuilderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeRemoveBuilder",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeRemoveBuilder"
        })


#endif

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

foreign import ccall "dzl_tree_scroll_to_node" dzl_tree_scroll_to_node :: 
    Ptr Tree ->                             -- self : TInterface (Name {namespace = "Dazzle", name = "Tree"})
    Ptr Dazzle.TreeNode.TreeNode ->         -- node : TInterface (Name {namespace = "Dazzle", name = "TreeNode"})
    IO ()

-- | /No description available in the introspection data./
treeScrollToNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a, Dazzle.TreeNode.IsTreeNode b) =>
    a
    -> b
    -> m ()
treeScrollToNode :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTree a, IsTreeNode b) =>
a -> b -> m ()
treeScrollToNode a
self b
node = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TreeNode
node' <- b -> IO (Ptr TreeNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
node
    Ptr Tree -> Ptr TreeNode -> IO ()
dzl_tree_scroll_to_node Ptr Tree
self' Ptr TreeNode
node'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
node
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TreeScrollToNodeMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTree a, Dazzle.TreeNode.IsTreeNode b) => O.OverloadedMethod TreeScrollToNodeMethodInfo a signature where
    overloadedMethod = treeScrollToNode

instance O.OverloadedMethodInfo TreeScrollToNodeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeScrollToNode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeScrollToNode"
        })


#endif

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

foreign import ccall "dzl_tree_set_context_menu" dzl_tree_set_context_menu :: 
    Ptr Tree ->                             -- self : TInterface (Name {namespace = "Dazzle", name = "Tree"})
    Ptr Gio.MenuModel.MenuModel ->          -- context_menu : TInterface (Name {namespace = "Gio", name = "MenuModel"})
    IO ()

-- | /No description available in the introspection data./
treeSetContextMenu ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a, Gio.MenuModel.IsMenuModel b) =>
    a
    -> b
    -> m ()
treeSetContextMenu :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTree a, IsMenuModel b) =>
a -> b -> m ()
treeSetContextMenu a
self b
contextMenu = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr MenuModel
contextMenu' <- b -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
contextMenu
    Ptr Tree -> Ptr MenuModel -> IO ()
dzl_tree_set_context_menu Ptr Tree
self' Ptr MenuModel
contextMenu'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
contextMenu
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TreeSetContextMenuMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTree a, Gio.MenuModel.IsMenuModel b) => O.OverloadedMethod TreeSetContextMenuMethodInfo a signature where
    overloadedMethod = treeSetContextMenu

instance O.OverloadedMethodInfo TreeSetContextMenuMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeSetContextMenu",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeSetContextMenu"
        })


#endif

-- method Tree::set_filter
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "Tree" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlTree" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filter_func"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "TreeFilterFunc" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A callback to determien visibility."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = 2
--           , argDestroy = 3
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filter_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "User data for @filter_func."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filter_data_destroy"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Destroy notify for @filter_data."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_tree_set_filter" dzl_tree_set_filter :: 
    Ptr Tree ->                             -- self : TInterface (Name {namespace = "Dazzle", name = "Tree"})
    FunPtr Dazzle.Callbacks.C_TreeFilterFunc -> -- filter_func : TInterface (Name {namespace = "Dazzle", name = "TreeFilterFunc"})
    Ptr () ->                               -- filter_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- filter_data_destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

-- | Sets the filter function to be used to determine visability of a tree node.
treeSetFilter ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Objects.Tree.Tree'
    -> Dazzle.Callbacks.TreeFilterFunc
    -- ^ /@filterFunc@/: A callback to determien visibility.
    -> m ()
treeSetFilter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTree a) =>
a -> TreeFilterFunc -> m ()
treeSetFilter a
self TreeFilterFunc
filterFunc = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    FunPtr C_TreeFilterFunc
filterFunc' <- C_TreeFilterFunc -> IO (FunPtr C_TreeFilterFunc)
Dazzle.Callbacks.mk_TreeFilterFunc (Maybe (Ptr (FunPtr C_TreeFilterFunc))
-> TreeFilterFunc_WithClosures -> C_TreeFilterFunc
Dazzle.Callbacks.wrap_TreeFilterFunc Maybe (Ptr (FunPtr C_TreeFilterFunc))
forall a. Maybe a
Nothing (TreeFilterFunc -> TreeFilterFunc_WithClosures
Dazzle.Callbacks.drop_closures_TreeFilterFunc TreeFilterFunc
filterFunc))
    let filterData :: Ptr ()
filterData = FunPtr C_TreeFilterFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_TreeFilterFunc
filterFunc'
    let filterDataDestroy :: FunPtr (Ptr a -> IO ())
filterDataDestroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
    Ptr Tree
-> FunPtr C_TreeFilterFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
dzl_tree_set_filter Ptr Tree
self' FunPtr C_TreeFilterFunc
filterFunc' Ptr ()
filterData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
filterDataDestroy
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TreeSetFilterMethodInfo
instance (signature ~ (Dazzle.Callbacks.TreeFilterFunc -> m ()), MonadIO m, IsTree a) => O.OverloadedMethod TreeSetFilterMethodInfo a signature where
    overloadedMethod = treeSetFilter

instance O.OverloadedMethodInfo TreeSetFilterMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeSetFilter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeSetFilter"
        })


#endif

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

foreign import ccall "dzl_tree_set_root" dzl_tree_set_root :: 
    Ptr Tree ->                             -- self : TInterface (Name {namespace = "Dazzle", name = "Tree"})
    Ptr Dazzle.TreeNode.TreeNode ->         -- node : TInterface (Name {namespace = "Dazzle", name = "TreeNode"})
    IO ()

-- | Sets the root node of the t'GI.Dazzle.Objects.Tree.Tree' widget. This is used to build
-- the items within the treeview. The item itself will not be added
-- to the self, but the direct children will be.
treeSetRoot ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a, Dazzle.TreeNode.IsTreeNode b) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Objects.Tree.Tree'.
    -> b
    -- ^ /@node@/: A t'GI.Dazzle.Objects.TreeNode.TreeNode'.
    -> m ()
treeSetRoot :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTree a, IsTreeNode b) =>
a -> b -> m ()
treeSetRoot a
self b
node = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TreeNode
node' <- b -> IO (Ptr TreeNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
node
    Ptr Tree -> Ptr TreeNode -> IO ()
dzl_tree_set_root Ptr Tree
self' Ptr TreeNode
node'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
node
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TreeSetRootMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTree a, Dazzle.TreeNode.IsTreeNode b) => O.OverloadedMethod TreeSetRootMethodInfo a signature where
    overloadedMethod = treeSetRoot

instance O.OverloadedMethodInfo TreeSetRootMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeSetRoot",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeSetRoot"
        })


#endif

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

foreign import ccall "dzl_tree_set_show_icons" dzl_tree_set_show_icons :: 
    Ptr Tree ->                             -- self : TInterface (Name {namespace = "Dazzle", name = "Tree"})
    CInt ->                                 -- show_icons : TBasicType TBoolean
    IO ()

-- | /No description available in the introspection data./
treeSetShowIcons ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
    a
    -> Bool
    -> m ()
treeSetShowIcons :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTree a) =>
a -> Bool -> m ()
treeSetShowIcons a
self Bool
showIcons = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let showIcons' :: CInt
showIcons' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
showIcons
    Ptr Tree -> CInt -> IO ()
dzl_tree_set_show_icons Ptr Tree
self' CInt
showIcons'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TreeSetShowIconsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTree a) => O.OverloadedMethod TreeSetShowIconsMethodInfo a signature where
    overloadedMethod = treeSetShowIcons

instance O.OverloadedMethodInfo TreeSetShowIconsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeSetShowIcons",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeSetShowIcons"
        })


#endif

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

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

-- | Unselects the currently selected node in the tree.
treeUnselectAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Objects.Tree.Tree'.
    -> m ()
treeUnselectAll :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTree a) =>
a -> m ()
treeUnselectAll a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Tree
self' <- a -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Tree -> IO ()
dzl_tree_unselect_all Ptr Tree
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TreeUnselectAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTree a) => O.OverloadedMethod TreeUnselectAllMethodInfo a signature where
    overloadedMethod = treeUnselectAll

instance O.OverloadedMethodInfo TreeUnselectAllMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.Tree.treeUnselectAll",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.1/docs/GI-Dazzle-Objects-Tree.html#v:treeUnselectAll"
        })


#endif