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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A @GtkWindow@ is a toplevel window which can contain other widgets.
-- 
-- <<https://docs.gtk.org/gtk4/window.png An example GtkWindow>>
-- 
-- Windows normally have decorations that are under the control
-- of the windowing system and allow the user to manipulate the window
-- (resize it, move it, close it,...).
-- 
-- = GtkWindow as GtkBuildable
-- 
-- The @GtkWindow@ implementation of the t'GI.Gtk.Interfaces.Buildable.Buildable' interface supports
-- setting a child as the titlebar by specifying “titlebar” as the “type”
-- attribute of a \<child> element.
-- 
-- = CSS nodes
-- 
-- >window.background [.csd / .solid-csd / .ssd] [.maximized / .fullscreen / .tiled]
-- >├── <child>
-- >╰── <titlebar child>.titlebar [.default-decoration]
-- 
-- 
-- @GtkWindow@ has a main CSS node with name window and style class .background.
-- 
-- Style classes that are typically used with the main CSS node are .csd (when
-- client-side decorations are in use), .solid-csd (for client-side decorations
-- without invisible borders), .ssd (used by mutter when rendering server-side
-- decorations). GtkWindow also represents window states with the following
-- style classes on the main node: .maximized, .fullscreen, .tiled (when supported,
-- also .tiled-top, .tiled-left, .tiled-right, .tiled-bottom).
-- 
-- @GtkWindow@ subclasses often add their own discriminating style classes,
-- such as .dialog, .popup or .tooltip.
-- 
-- Generally, some CSS properties don\'t make sense on the toplevel window node,
-- such as margins or padding. When client-side decorations without invisible
-- borders are in use (i.e. the .solid-csd style class is added to the
-- main window node), the CSS border of the toplevel window is used for
-- resize drags. In the .csd case, the shadow area outside of the window
-- can be used to resize it.
-- 
-- @GtkWindow@ adds the .titlebar and .default-decoration style classes to the
-- widget that is added as a titlebar child.
-- 
-- = Accessibility
-- 
-- @GtkWindow@ uses the 'GI.Gtk.Enums.AccessibleRoleWindow' role.
-- 
-- = Actions
-- 
-- @GtkWindow@ defines a set of built-in actions:
-- 
-- * @default.activate@: Activate the default widget.
-- * @window.minimize@: Minimize the window.
-- * @window.toggle-maximized@: Maximize or restore the window.
-- * @window.close@: Close the window.
-- 

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

module GI.Gtk.Objects.Window
    ( 

-- * Exported types
    Window(..)                              ,
    IsWindow                                ,
    toWindow                                ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [close]("GI.Gtk.Objects.Window#g:method:close"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [destroy]("GI.Gtk.Objects.Window#g:method:destroy"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [fullscreen]("GI.Gtk.Objects.Window#g:method:fullscreen"), [fullscreenOnMonitor]("GI.Gtk.Objects.Window#g:method:fullscreenOnMonitor"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasGroup]("GI.Gtk.Objects.Window#g:method:hasGroup"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isActive]("GI.Gtk.Objects.Window#g:method:isActive"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isFullscreen]("GI.Gtk.Objects.Window#g:method:isFullscreen"), [isMaximized]("GI.Gtk.Objects.Window#g:method:isMaximized"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [maximize]("GI.Gtk.Objects.Window#g:method:maximize"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [minimize]("GI.Gtk.Objects.Window#g:method:minimize"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [present]("GI.Gtk.Objects.Window#g:method:present"), [presentWithTime]("GI.Gtk.Objects.Window#g:method:presentWithTime"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unfullscreen]("GI.Gtk.Objects.Window#g:method:unfullscreen"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unmaximize]("GI.Gtk.Objects.Window#g:method:unmaximize"), [unminimize]("GI.Gtk.Objects.Window#g:method:unminimize"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getApplication]("GI.Gtk.Objects.Window#g:method:getApplication"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChild]("GI.Gtk.Objects.Window#g:method:getChild"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDecorated]("GI.Gtk.Objects.Window#g:method:getDecorated"), [getDefaultSize]("GI.Gtk.Objects.Window#g:method:getDefaultSize"), [getDefaultWidget]("GI.Gtk.Objects.Window#g:method:getDefaultWidget"), [getDeletable]("GI.Gtk.Objects.Window#g:method:getDeletable"), [getDestroyWithParent]("GI.Gtk.Objects.Window#g:method:getDestroyWithParent"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocus]("GI.Gtk.Objects.Window#g:method:getFocus"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusVisible]("GI.Gtk.Objects.Window#g:method:getFocusVisible"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getGroup]("GI.Gtk.Objects.Window#g:method:getGroup"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHandleMenubarAccel]("GI.Gtk.Objects.Window#g:method:getHandleMenubarAccel"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getHideOnClose]("GI.Gtk.Objects.Window#g:method:getHideOnClose"), [getIconName]("GI.Gtk.Objects.Window#g:method:getIconName"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getMnemonicsVisible]("GI.Gtk.Objects.Window#g:method:getMnemonicsVisible"), [getModal]("GI.Gtk.Objects.Window#g:method:getModal"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRenderer]("GI.Gtk.Interfaces.Native#g:method:getRenderer"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getResizable]("GI.Gtk.Objects.Window#g:method:getResizable"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getSurface]("GI.Gtk.Interfaces.Native#g:method:getSurface"), [getSurfaceTransform]("GI.Gtk.Interfaces.Native#g:method:getSurfaceTransform"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTitle]("GI.Gtk.Objects.Window#g:method:getTitle"), [getTitlebar]("GI.Gtk.Objects.Window#g:method:getTitlebar"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTransientFor]("GI.Gtk.Objects.Window#g:method:getTransientFor"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
-- 
-- ==== Setters
-- [setApplication]("GI.Gtk.Objects.Window#g:method:setApplication"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChild]("GI.Gtk.Objects.Window#g:method:setChild"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDecorated]("GI.Gtk.Objects.Window#g:method:setDecorated"), [setDefaultSize]("GI.Gtk.Objects.Window#g:method:setDefaultSize"), [setDefaultWidget]("GI.Gtk.Objects.Window#g:method:setDefaultWidget"), [setDeletable]("GI.Gtk.Objects.Window#g:method:setDeletable"), [setDestroyWithParent]("GI.Gtk.Objects.Window#g:method:setDestroyWithParent"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setDisplay]("GI.Gtk.Objects.Window#g:method:setDisplay"), [setFocus]("GI.Gtk.Objects.Window#g:method:setFocus"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusVisible]("GI.Gtk.Objects.Window#g:method:setFocusVisible"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHandleMenubarAccel]("GI.Gtk.Objects.Window#g:method:setHandleMenubarAccel"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setHideOnClose]("GI.Gtk.Objects.Window#g:method:setHideOnClose"), [setIconName]("GI.Gtk.Objects.Window#g:method:setIconName"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setMnemonicsVisible]("GI.Gtk.Objects.Window#g:method:setMnemonicsVisible"), [setModal]("GI.Gtk.Objects.Window#g:method:setModal"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setResizable]("GI.Gtk.Objects.Window#g:method:setResizable"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStartupId]("GI.Gtk.Objects.Window#g:method:setStartupId"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTitle]("GI.Gtk.Objects.Window#g:method:setTitle"), [setTitlebar]("GI.Gtk.Objects.Window#g:method:setTitlebar"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTransientFor]("GI.Gtk.Objects.Window#g:method:setTransientFor"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible").

#if defined(ENABLE_OVERLOADING)
    ResolveWindowMethod                     ,
#endif

-- ** close #method:close#

#if defined(ENABLE_OVERLOADING)
    WindowCloseMethodInfo                   ,
#endif
    windowClose                             ,


-- ** destroy #method:destroy#

#if defined(ENABLE_OVERLOADING)
    WindowDestroyMethodInfo                 ,
#endif
    windowDestroy                           ,


-- ** fullscreen #method:fullscreen#

#if defined(ENABLE_OVERLOADING)
    WindowFullscreenMethodInfo              ,
#endif
    windowFullscreen                        ,


-- ** fullscreenOnMonitor #method:fullscreenOnMonitor#

#if defined(ENABLE_OVERLOADING)
    WindowFullscreenOnMonitorMethodInfo     ,
#endif
    windowFullscreenOnMonitor               ,


-- ** getApplication #method:getApplication#

#if defined(ENABLE_OVERLOADING)
    WindowGetApplicationMethodInfo          ,
#endif
    windowGetApplication                    ,


-- ** getChild #method:getChild#

#if defined(ENABLE_OVERLOADING)
    WindowGetChildMethodInfo                ,
#endif
    windowGetChild                          ,


-- ** getDecorated #method:getDecorated#

#if defined(ENABLE_OVERLOADING)
    WindowGetDecoratedMethodInfo            ,
#endif
    windowGetDecorated                      ,


-- ** getDefaultIconName #method:getDefaultIconName#

    windowGetDefaultIconName                ,


-- ** getDefaultSize #method:getDefaultSize#

#if defined(ENABLE_OVERLOADING)
    WindowGetDefaultSizeMethodInfo          ,
#endif
    windowGetDefaultSize                    ,


-- ** getDefaultWidget #method:getDefaultWidget#

#if defined(ENABLE_OVERLOADING)
    WindowGetDefaultWidgetMethodInfo        ,
#endif
    windowGetDefaultWidget                  ,


-- ** getDeletable #method:getDeletable#

#if defined(ENABLE_OVERLOADING)
    WindowGetDeletableMethodInfo            ,
#endif
    windowGetDeletable                      ,


-- ** getDestroyWithParent #method:getDestroyWithParent#

#if defined(ENABLE_OVERLOADING)
    WindowGetDestroyWithParentMethodInfo    ,
#endif
    windowGetDestroyWithParent              ,


-- ** getFocus #method:getFocus#

#if defined(ENABLE_OVERLOADING)
    WindowGetFocusMethodInfo                ,
#endif
    windowGetFocus                          ,


-- ** getFocusVisible #method:getFocusVisible#

#if defined(ENABLE_OVERLOADING)
    WindowGetFocusVisibleMethodInfo         ,
#endif
    windowGetFocusVisible                   ,


-- ** getGroup #method:getGroup#

#if defined(ENABLE_OVERLOADING)
    WindowGetGroupMethodInfo                ,
#endif
    windowGetGroup                          ,


-- ** getHandleMenubarAccel #method:getHandleMenubarAccel#

#if defined(ENABLE_OVERLOADING)
    WindowGetHandleMenubarAccelMethodInfo   ,
#endif
    windowGetHandleMenubarAccel             ,


-- ** getHideOnClose #method:getHideOnClose#

#if defined(ENABLE_OVERLOADING)
    WindowGetHideOnCloseMethodInfo          ,
#endif
    windowGetHideOnClose                    ,


-- ** getIconName #method:getIconName#

#if defined(ENABLE_OVERLOADING)
    WindowGetIconNameMethodInfo             ,
#endif
    windowGetIconName                       ,


-- ** getMnemonicsVisible #method:getMnemonicsVisible#

#if defined(ENABLE_OVERLOADING)
    WindowGetMnemonicsVisibleMethodInfo     ,
#endif
    windowGetMnemonicsVisible               ,


-- ** getModal #method:getModal#

#if defined(ENABLE_OVERLOADING)
    WindowGetModalMethodInfo                ,
#endif
    windowGetModal                          ,


-- ** getResizable #method:getResizable#

#if defined(ENABLE_OVERLOADING)
    WindowGetResizableMethodInfo            ,
#endif
    windowGetResizable                      ,


-- ** getTitle #method:getTitle#

#if defined(ENABLE_OVERLOADING)
    WindowGetTitleMethodInfo                ,
#endif
    windowGetTitle                          ,


-- ** getTitlebar #method:getTitlebar#

#if defined(ENABLE_OVERLOADING)
    WindowGetTitlebarMethodInfo             ,
#endif
    windowGetTitlebar                       ,


-- ** getToplevels #method:getToplevels#

    windowGetToplevels                      ,


-- ** getTransientFor #method:getTransientFor#

#if defined(ENABLE_OVERLOADING)
    WindowGetTransientForMethodInfo         ,
#endif
    windowGetTransientFor                   ,


-- ** hasGroup #method:hasGroup#

#if defined(ENABLE_OVERLOADING)
    WindowHasGroupMethodInfo                ,
#endif
    windowHasGroup                          ,


-- ** isActive #method:isActive#

#if defined(ENABLE_OVERLOADING)
    WindowIsActiveMethodInfo                ,
#endif
    windowIsActive                          ,


-- ** isFullscreen #method:isFullscreen#

#if defined(ENABLE_OVERLOADING)
    WindowIsFullscreenMethodInfo            ,
#endif
    windowIsFullscreen                      ,


-- ** isMaximized #method:isMaximized#

#if defined(ENABLE_OVERLOADING)
    WindowIsMaximizedMethodInfo             ,
#endif
    windowIsMaximized                       ,


-- ** listToplevels #method:listToplevels#

    windowListToplevels                     ,


-- ** maximize #method:maximize#

#if defined(ENABLE_OVERLOADING)
    WindowMaximizeMethodInfo                ,
#endif
    windowMaximize                          ,


-- ** minimize #method:minimize#

#if defined(ENABLE_OVERLOADING)
    WindowMinimizeMethodInfo                ,
#endif
    windowMinimize                          ,


-- ** new #method:new#

    windowNew                               ,


-- ** present #method:present#

#if defined(ENABLE_OVERLOADING)
    WindowPresentMethodInfo                 ,
#endif
    windowPresent                           ,


-- ** presentWithTime #method:presentWithTime#

#if defined(ENABLE_OVERLOADING)
    WindowPresentWithTimeMethodInfo         ,
#endif
    windowPresentWithTime                   ,


-- ** setApplication #method:setApplication#

#if defined(ENABLE_OVERLOADING)
    WindowSetApplicationMethodInfo          ,
#endif
    windowSetApplication                    ,


-- ** setAutoStartupNotification #method:setAutoStartupNotification#

    windowSetAutoStartupNotification        ,


-- ** setChild #method:setChild#

#if defined(ENABLE_OVERLOADING)
    WindowSetChildMethodInfo                ,
#endif
    windowSetChild                          ,


-- ** setDecorated #method:setDecorated#

#if defined(ENABLE_OVERLOADING)
    WindowSetDecoratedMethodInfo            ,
#endif
    windowSetDecorated                      ,


-- ** setDefaultIconName #method:setDefaultIconName#

    windowSetDefaultIconName                ,


-- ** setDefaultSize #method:setDefaultSize#

#if defined(ENABLE_OVERLOADING)
    WindowSetDefaultSizeMethodInfo          ,
#endif
    windowSetDefaultSize                    ,


-- ** setDefaultWidget #method:setDefaultWidget#

#if defined(ENABLE_OVERLOADING)
    WindowSetDefaultWidgetMethodInfo        ,
#endif
    windowSetDefaultWidget                  ,


-- ** setDeletable #method:setDeletable#

#if defined(ENABLE_OVERLOADING)
    WindowSetDeletableMethodInfo            ,
#endif
    windowSetDeletable                      ,


-- ** setDestroyWithParent #method:setDestroyWithParent#

#if defined(ENABLE_OVERLOADING)
    WindowSetDestroyWithParentMethodInfo    ,
#endif
    windowSetDestroyWithParent              ,


-- ** setDisplay #method:setDisplay#

#if defined(ENABLE_OVERLOADING)
    WindowSetDisplayMethodInfo              ,
#endif
    windowSetDisplay                        ,


-- ** setFocus #method:setFocus#

#if defined(ENABLE_OVERLOADING)
    WindowSetFocusMethodInfo                ,
#endif
    windowSetFocus                          ,


-- ** setFocusVisible #method:setFocusVisible#

#if defined(ENABLE_OVERLOADING)
    WindowSetFocusVisibleMethodInfo         ,
#endif
    windowSetFocusVisible                   ,


-- ** setHandleMenubarAccel #method:setHandleMenubarAccel#

#if defined(ENABLE_OVERLOADING)
    WindowSetHandleMenubarAccelMethodInfo   ,
#endif
    windowSetHandleMenubarAccel             ,


-- ** setHideOnClose #method:setHideOnClose#

#if defined(ENABLE_OVERLOADING)
    WindowSetHideOnCloseMethodInfo          ,
#endif
    windowSetHideOnClose                    ,


-- ** setIconName #method:setIconName#

#if defined(ENABLE_OVERLOADING)
    WindowSetIconNameMethodInfo             ,
#endif
    windowSetIconName                       ,


-- ** setInteractiveDebugging #method:setInteractiveDebugging#

    windowSetInteractiveDebugging           ,


-- ** setMnemonicsVisible #method:setMnemonicsVisible#

#if defined(ENABLE_OVERLOADING)
    WindowSetMnemonicsVisibleMethodInfo     ,
#endif
    windowSetMnemonicsVisible               ,


-- ** setModal #method:setModal#

#if defined(ENABLE_OVERLOADING)
    WindowSetModalMethodInfo                ,
#endif
    windowSetModal                          ,


-- ** setResizable #method:setResizable#

#if defined(ENABLE_OVERLOADING)
    WindowSetResizableMethodInfo            ,
#endif
    windowSetResizable                      ,


-- ** setStartupId #method:setStartupId#

#if defined(ENABLE_OVERLOADING)
    WindowSetStartupIdMethodInfo            ,
#endif
    windowSetStartupId                      ,


-- ** setTitle #method:setTitle#

#if defined(ENABLE_OVERLOADING)
    WindowSetTitleMethodInfo                ,
#endif
    windowSetTitle                          ,


-- ** setTitlebar #method:setTitlebar#

#if defined(ENABLE_OVERLOADING)
    WindowSetTitlebarMethodInfo             ,
#endif
    windowSetTitlebar                       ,


-- ** setTransientFor #method:setTransientFor#

#if defined(ENABLE_OVERLOADING)
    WindowSetTransientForMethodInfo         ,
#endif
    windowSetTransientFor                   ,


-- ** unfullscreen #method:unfullscreen#

#if defined(ENABLE_OVERLOADING)
    WindowUnfullscreenMethodInfo            ,
#endif
    windowUnfullscreen                      ,


-- ** unmaximize #method:unmaximize#

#if defined(ENABLE_OVERLOADING)
    WindowUnmaximizeMethodInfo              ,
#endif
    windowUnmaximize                        ,


-- ** unminimize #method:unminimize#

#if defined(ENABLE_OVERLOADING)
    WindowUnminimizeMethodInfo              ,
#endif
    windowUnminimize                        ,




 -- * Properties


-- ** application #attr:application#
-- | The @GtkApplication@ associated with the window.
-- 
-- The application will be kept alive for at least as long as it
-- has any windows associated with it (see 'GI.Gio.Objects.Application.applicationHold'
-- for a way to keep it alive without windows).
-- 
-- Normally, the connection between the application and the window
-- will remain until the window is destroyed, but you can explicitly
-- remove it by setting the :application property to 'P.Nothing'.

#if defined(ENABLE_OVERLOADING)
    WindowApplicationPropertyInfo           ,
#endif
    clearWindowApplication                  ,
    constructWindowApplication              ,
    getWindowApplication                    ,
    setWindowApplication                    ,
#if defined(ENABLE_OVERLOADING)
    windowApplication                       ,
#endif


-- ** child #attr:child#
-- | The child widget.

#if defined(ENABLE_OVERLOADING)
    WindowChildPropertyInfo                 ,
#endif
    clearWindowChild                        ,
    constructWindowChild                    ,
    getWindowChild                          ,
    setWindowChild                          ,
#if defined(ENABLE_OVERLOADING)
    windowChild                             ,
#endif


-- ** decorated #attr:decorated#
-- | Whether the window should have a frame (also known as *decorations*).

#if defined(ENABLE_OVERLOADING)
    WindowDecoratedPropertyInfo             ,
#endif
    constructWindowDecorated                ,
    getWindowDecorated                      ,
    setWindowDecorated                      ,
#if defined(ENABLE_OVERLOADING)
    windowDecorated                         ,
#endif


-- ** defaultHeight #attr:defaultHeight#
-- | The default height of the window.

#if defined(ENABLE_OVERLOADING)
    WindowDefaultHeightPropertyInfo         ,
#endif
    constructWindowDefaultHeight            ,
    getWindowDefaultHeight                  ,
    setWindowDefaultHeight                  ,
#if defined(ENABLE_OVERLOADING)
    windowDefaultHeight                     ,
#endif


-- ** defaultWidget #attr:defaultWidget#
-- | The default widget.

#if defined(ENABLE_OVERLOADING)
    WindowDefaultWidgetPropertyInfo         ,
#endif
    clearWindowDefaultWidget                ,
    constructWindowDefaultWidget            ,
    getWindowDefaultWidget                  ,
    setWindowDefaultWidget                  ,
#if defined(ENABLE_OVERLOADING)
    windowDefaultWidget                     ,
#endif


-- ** defaultWidth #attr:defaultWidth#
-- | The default width of the window.

#if defined(ENABLE_OVERLOADING)
    WindowDefaultWidthPropertyInfo          ,
#endif
    constructWindowDefaultWidth             ,
    getWindowDefaultWidth                   ,
    setWindowDefaultWidth                   ,
#if defined(ENABLE_OVERLOADING)
    windowDefaultWidth                      ,
#endif


-- ** deletable #attr:deletable#
-- | Whether the window frame should have a close button.

#if defined(ENABLE_OVERLOADING)
    WindowDeletablePropertyInfo             ,
#endif
    constructWindowDeletable                ,
    getWindowDeletable                      ,
    setWindowDeletable                      ,
#if defined(ENABLE_OVERLOADING)
    windowDeletable                         ,
#endif


-- ** destroyWithParent #attr:destroyWithParent#
-- | If this window should be destroyed when the parent is destroyed.

#if defined(ENABLE_OVERLOADING)
    WindowDestroyWithParentPropertyInfo     ,
#endif
    constructWindowDestroyWithParent        ,
    getWindowDestroyWithParent              ,
    setWindowDestroyWithParent              ,
#if defined(ENABLE_OVERLOADING)
    windowDestroyWithParent                 ,
#endif


-- ** display #attr:display#
-- | The display that will display this window.

#if defined(ENABLE_OVERLOADING)
    WindowDisplayPropertyInfo               ,
#endif
    constructWindowDisplay                  ,
    getWindowDisplay                        ,
    setWindowDisplay                        ,
#if defined(ENABLE_OVERLOADING)
    windowDisplay                           ,
#endif


-- ** focusVisible #attr:focusVisible#
-- | Whether \'focus rectangles\' are currently visible in this window.
-- 
-- This property is maintained by GTK based on user input
-- and should not be set by applications.

#if defined(ENABLE_OVERLOADING)
    WindowFocusVisiblePropertyInfo          ,
#endif
    constructWindowFocusVisible             ,
    getWindowFocusVisible                   ,
    setWindowFocusVisible                   ,
#if defined(ENABLE_OVERLOADING)
    windowFocusVisible                      ,
#endif


-- ** focusWidget #attr:focusWidget#
-- | The focus widget.

#if defined(ENABLE_OVERLOADING)
    WindowFocusWidgetPropertyInfo           ,
#endif
    clearWindowFocusWidget                  ,
    constructWindowFocusWidget              ,
    getWindowFocusWidget                    ,
    setWindowFocusWidget                    ,
#if defined(ENABLE_OVERLOADING)
    windowFocusWidget                       ,
#endif


-- ** fullscreened #attr:fullscreened#
-- | Whether the window is fullscreen.
-- 
-- Setting this property is the equivalent of calling
-- 'GI.Gtk.Objects.Window.windowFullscreen' or 'GI.Gtk.Objects.Window.windowUnfullscreen';
-- either operation is asynchronous, which means you will need to
-- connect to the [notify](#g:signal:notify) signal in order to know whether the
-- operation was successful.

#if defined(ENABLE_OVERLOADING)
    WindowFullscreenedPropertyInfo          ,
#endif
    constructWindowFullscreened             ,
    getWindowFullscreened                   ,
    setWindowFullscreened                   ,
#if defined(ENABLE_OVERLOADING)
    windowFullscreened                      ,
#endif


-- ** handleMenubarAccel #attr:handleMenubarAccel#
-- | Whether the window frame should handle F10 for activating
-- menubars.
-- 
-- /Since: 4.2/

#if defined(ENABLE_OVERLOADING)
    WindowHandleMenubarAccelPropertyInfo    ,
#endif
    constructWindowHandleMenubarAccel       ,
    getWindowHandleMenubarAccel             ,
    setWindowHandleMenubarAccel             ,
#if defined(ENABLE_OVERLOADING)
    windowHandleMenubarAccel                ,
#endif


-- ** hideOnClose #attr:hideOnClose#
-- | If this window should be hidden when the users clicks the close button.

#if defined(ENABLE_OVERLOADING)
    WindowHideOnClosePropertyInfo           ,
#endif
    constructWindowHideOnClose              ,
    getWindowHideOnClose                    ,
    setWindowHideOnClose                    ,
#if defined(ENABLE_OVERLOADING)
    windowHideOnClose                       ,
#endif


-- ** iconName #attr:iconName#
-- | Specifies the name of the themed icon to use as the window icon.
-- 
-- See t'GI.Gtk.Objects.IconTheme.IconTheme' for more details.

#if defined(ENABLE_OVERLOADING)
    WindowIconNamePropertyInfo              ,
#endif
    clearWindowIconName                     ,
    constructWindowIconName                 ,
    getWindowIconName                       ,
    setWindowIconName                       ,
#if defined(ENABLE_OVERLOADING)
    windowIconName                          ,
#endif


-- ** isActive #attr:isActive#
-- | Whether the toplevel is the currently active window.

#if defined(ENABLE_OVERLOADING)
    WindowIsActivePropertyInfo              ,
#endif
    getWindowIsActive                       ,


-- ** maximized #attr:maximized#
-- | Whether the window is maximized.
-- 
-- Setting this property is the equivalent of calling
-- 'GI.Gtk.Objects.Window.windowMaximize' or 'GI.Gtk.Objects.Window.windowUnmaximize';
-- either operation is asynchronous, which means you will need to
-- connect to the [notify](#g:signal:notify) signal in order to know whether the
-- operation was successful.

#if defined(ENABLE_OVERLOADING)
    WindowMaximizedPropertyInfo             ,
#endif
    constructWindowMaximized                ,
    getWindowMaximized                      ,
    setWindowMaximized                      ,
#if defined(ENABLE_OVERLOADING)
    windowMaximized                         ,
#endif


-- ** mnemonicsVisible #attr:mnemonicsVisible#
-- | Whether mnemonics are currently visible in this window.
-- 
-- This property is maintained by GTK based on user input,
-- and should not be set by applications.

#if defined(ENABLE_OVERLOADING)
    WindowMnemonicsVisiblePropertyInfo      ,
#endif
    constructWindowMnemonicsVisible         ,
    getWindowMnemonicsVisible               ,
    setWindowMnemonicsVisible               ,
#if defined(ENABLE_OVERLOADING)
    windowMnemonicsVisible                  ,
#endif


-- ** modal #attr:modal#
-- | If 'P.True', the window is modal.

#if defined(ENABLE_OVERLOADING)
    WindowModalPropertyInfo                 ,
#endif
    constructWindowModal                    ,
    getWindowModal                          ,
    setWindowModal                          ,
#if defined(ENABLE_OVERLOADING)
    windowModal                             ,
#endif


-- ** resizable #attr:resizable#
-- | If 'P.True', users can resize the window.

#if defined(ENABLE_OVERLOADING)
    WindowResizablePropertyInfo             ,
#endif
    constructWindowResizable                ,
    getWindowResizable                      ,
    setWindowResizable                      ,
#if defined(ENABLE_OVERLOADING)
    windowResizable                         ,
#endif


-- ** startupId #attr:startupId#
-- | A write-only property for setting window\'s startup notification identifier.

#if defined(ENABLE_OVERLOADING)
    WindowStartupIdPropertyInfo             ,
#endif
    constructWindowStartupId                ,
    setWindowStartupId                      ,
#if defined(ENABLE_OVERLOADING)
    windowStartupId                         ,
#endif


-- ** title #attr:title#
-- | The title of the window.

#if defined(ENABLE_OVERLOADING)
    WindowTitlePropertyInfo                 ,
#endif
    clearWindowTitle                        ,
    constructWindowTitle                    ,
    getWindowTitle                          ,
    setWindowTitle                          ,
#if defined(ENABLE_OVERLOADING)
    windowTitle                             ,
#endif


-- ** titlebar #attr:titlebar#
-- | The titlebar widget.
-- 
-- /Since: 4.6/

#if defined(ENABLE_OVERLOADING)
    WindowTitlebarPropertyInfo              ,
#endif
    clearWindowTitlebar                     ,
    constructWindowTitlebar                 ,
    getWindowTitlebar                       ,
    setWindowTitlebar                       ,
#if defined(ENABLE_OVERLOADING)
    windowTitlebar                          ,
#endif


-- ** transientFor #attr:transientFor#
-- | The transient parent of the window.

#if defined(ENABLE_OVERLOADING)
    WindowTransientForPropertyInfo          ,
#endif
    clearWindowTransientFor                 ,
    constructWindowTransientFor             ,
    getWindowTransientFor                   ,
    setWindowTransientFor                   ,
#if defined(ENABLE_OVERLOADING)
    windowTransientFor                      ,
#endif




 -- * Signals


-- ** activateDefault #signal:activateDefault#

    WindowActivateDefaultCallback           ,
#if defined(ENABLE_OVERLOADING)
    WindowActivateDefaultSignalInfo         ,
#endif
    afterWindowActivateDefault              ,
    onWindowActivateDefault                 ,


-- ** activateFocus #signal:activateFocus#

    WindowActivateFocusCallback             ,
#if defined(ENABLE_OVERLOADING)
    WindowActivateFocusSignalInfo           ,
#endif
    afterWindowActivateFocus                ,
    onWindowActivateFocus                   ,


-- ** closeRequest #signal:closeRequest#

    WindowCloseRequestCallback              ,
#if defined(ENABLE_OVERLOADING)
    WindowCloseRequestSignalInfo            ,
#endif
    afterWindowCloseRequest                 ,
    onWindowCloseRequest                    ,


-- ** enableDebugging #signal:enableDebugging#

    WindowEnableDebuggingCallback           ,
#if defined(ENABLE_OVERLOADING)
    WindowEnableDebuggingSignalInfo         ,
#endif
    afterWindowEnableDebugging              ,
    onWindowEnableDebugging                 ,


-- ** keysChanged #signal:keysChanged#

    WindowKeysChangedCallback               ,
#if defined(ENABLE_OVERLOADING)
    WindowKeysChangedSignalInfo             ,
#endif
    afterWindowKeysChanged                  ,
    onWindowKeysChanged                     ,




    ) 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.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Objects.Display as Gdk.Display
import qualified GI.Gdk.Objects.Monitor as Gdk.Monitor
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Native as Gtk.Native
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Root as Gtk.Root
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ShortcutManager as Gtk.ShortcutManager
import {-# SOURCE #-} qualified GI.Gtk.Objects.Application as Gtk.Application
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import {-# SOURCE #-} qualified GI.Gtk.Objects.WindowGroup as Gtk.WindowGroup

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

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

foreign import ccall "gtk_window_get_type"
    c_gtk_window_get_type :: IO B.Types.GType

instance B.Types.TypedObject Window where
    glibType :: IO GType
glibType = IO GType
c_gtk_window_get_type

instance B.Types.GObject Window

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

instance O.HasParentTypes Window
type instance O.ParentTypes Window = '[Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget, Gtk.Native.Native, Gtk.Root.Root, Gtk.ShortcutManager.ShortcutManager]

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveWindowMethod (t :: Symbol) (o :: *) :: * where
    ResolveWindowMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveWindowMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveWindowMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveWindowMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveWindowMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveWindowMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveWindowMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveWindowMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveWindowMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveWindowMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveWindowMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveWindowMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveWindowMethod "close" o = WindowCloseMethodInfo
    ResolveWindowMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveWindowMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveWindowMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveWindowMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveWindowMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveWindowMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveWindowMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveWindowMethod "destroy" o = WindowDestroyMethodInfo
    ResolveWindowMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
    ResolveWindowMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveWindowMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveWindowMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveWindowMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveWindowMethod "fullscreen" o = WindowFullscreenMethodInfo
    ResolveWindowMethod "fullscreenOnMonitor" o = WindowFullscreenOnMonitorMethodInfo
    ResolveWindowMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveWindowMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveWindowMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveWindowMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveWindowMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveWindowMethod "hasGroup" o = WindowHasGroupMethodInfo
    ResolveWindowMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveWindowMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveWindowMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveWindowMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveWindowMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveWindowMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveWindowMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveWindowMethod "isActive" o = WindowIsActiveMethodInfo
    ResolveWindowMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveWindowMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveWindowMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveWindowMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveWindowMethod "isFullscreen" o = WindowIsFullscreenMethodInfo
    ResolveWindowMethod "isMaximized" o = WindowIsMaximizedMethodInfo
    ResolveWindowMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveWindowMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveWindowMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveWindowMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveWindowMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveWindowMethod "maximize" o = WindowMaximizeMethodInfo
    ResolveWindowMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveWindowMethod "minimize" o = WindowMinimizeMethodInfo
    ResolveWindowMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveWindowMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveWindowMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveWindowMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveWindowMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveWindowMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveWindowMethod "present" o = WindowPresentMethodInfo
    ResolveWindowMethod "presentWithTime" o = WindowPresentWithTimeMethodInfo
    ResolveWindowMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveWindowMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveWindowMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveWindowMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveWindowMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveWindowMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveWindowMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveWindowMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveWindowMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveWindowMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveWindowMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveWindowMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveWindowMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveWindowMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveWindowMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveWindowMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveWindowMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveWindowMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveWindowMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveWindowMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveWindowMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveWindowMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveWindowMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveWindowMethod "unfullscreen" o = WindowUnfullscreenMethodInfo
    ResolveWindowMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveWindowMethod "unmaximize" o = WindowUnmaximizeMethodInfo
    ResolveWindowMethod "unminimize" o = WindowUnminimizeMethodInfo
    ResolveWindowMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveWindowMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveWindowMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveWindowMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveWindowMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveWindowMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveWindowMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveWindowMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveWindowMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveWindowMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveWindowMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveWindowMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveWindowMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveWindowMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveWindowMethod "getApplication" o = WindowGetApplicationMethodInfo
    ResolveWindowMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveWindowMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveWindowMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveWindowMethod "getChild" o = WindowGetChildMethodInfo
    ResolveWindowMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveWindowMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveWindowMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveWindowMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveWindowMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveWindowMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveWindowMethod "getDecorated" o = WindowGetDecoratedMethodInfo
    ResolveWindowMethod "getDefaultSize" o = WindowGetDefaultSizeMethodInfo
    ResolveWindowMethod "getDefaultWidget" o = WindowGetDefaultWidgetMethodInfo
    ResolveWindowMethod "getDeletable" o = WindowGetDeletableMethodInfo
    ResolveWindowMethod "getDestroyWithParent" o = WindowGetDestroyWithParentMethodInfo
    ResolveWindowMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveWindowMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveWindowMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveWindowMethod "getFocus" o = WindowGetFocusMethodInfo
    ResolveWindowMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveWindowMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveWindowMethod "getFocusVisible" o = WindowGetFocusVisibleMethodInfo
    ResolveWindowMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveWindowMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveWindowMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveWindowMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveWindowMethod "getGroup" o = WindowGetGroupMethodInfo
    ResolveWindowMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveWindowMethod "getHandleMenubarAccel" o = WindowGetHandleMenubarAccelMethodInfo
    ResolveWindowMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveWindowMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveWindowMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveWindowMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveWindowMethod "getHideOnClose" o = WindowGetHideOnCloseMethodInfo
    ResolveWindowMethod "getIconName" o = WindowGetIconNameMethodInfo
    ResolveWindowMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveWindowMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveWindowMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveWindowMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveWindowMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveWindowMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveWindowMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveWindowMethod "getMnemonicsVisible" o = WindowGetMnemonicsVisibleMethodInfo
    ResolveWindowMethod "getModal" o = WindowGetModalMethodInfo
    ResolveWindowMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveWindowMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveWindowMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveWindowMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveWindowMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveWindowMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveWindowMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveWindowMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveWindowMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveWindowMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveWindowMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveWindowMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveWindowMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveWindowMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveWindowMethod "getRenderer" o = Gtk.Native.NativeGetRendererMethodInfo
    ResolveWindowMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveWindowMethod "getResizable" o = WindowGetResizableMethodInfo
    ResolveWindowMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveWindowMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveWindowMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveWindowMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveWindowMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveWindowMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveWindowMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveWindowMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveWindowMethod "getSurface" o = Gtk.Native.NativeGetSurfaceMethodInfo
    ResolveWindowMethod "getSurfaceTransform" o = Gtk.Native.NativeGetSurfaceTransformMethodInfo
    ResolveWindowMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveWindowMethod "getTitle" o = WindowGetTitleMethodInfo
    ResolveWindowMethod "getTitlebar" o = WindowGetTitlebarMethodInfo
    ResolveWindowMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveWindowMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveWindowMethod "getTransientFor" o = WindowGetTransientForMethodInfo
    ResolveWindowMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveWindowMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveWindowMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveWindowMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveWindowMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveWindowMethod "setApplication" o = WindowSetApplicationMethodInfo
    ResolveWindowMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveWindowMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveWindowMethod "setChild" o = WindowSetChildMethodInfo
    ResolveWindowMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveWindowMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveWindowMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveWindowMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveWindowMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveWindowMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveWindowMethod "setDecorated" o = WindowSetDecoratedMethodInfo
    ResolveWindowMethod "setDefaultSize" o = WindowSetDefaultSizeMethodInfo
    ResolveWindowMethod "setDefaultWidget" o = WindowSetDefaultWidgetMethodInfo
    ResolveWindowMethod "setDeletable" o = WindowSetDeletableMethodInfo
    ResolveWindowMethod "setDestroyWithParent" o = WindowSetDestroyWithParentMethodInfo
    ResolveWindowMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveWindowMethod "setDisplay" o = WindowSetDisplayMethodInfo
    ResolveWindowMethod "setFocus" o = WindowSetFocusMethodInfo
    ResolveWindowMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveWindowMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveWindowMethod "setFocusVisible" o = WindowSetFocusVisibleMethodInfo
    ResolveWindowMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveWindowMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveWindowMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveWindowMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveWindowMethod "setHandleMenubarAccel" o = WindowSetHandleMenubarAccelMethodInfo
    ResolveWindowMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveWindowMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveWindowMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveWindowMethod "setHideOnClose" o = WindowSetHideOnCloseMethodInfo
    ResolveWindowMethod "setIconName" o = WindowSetIconNameMethodInfo
    ResolveWindowMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveWindowMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveWindowMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveWindowMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveWindowMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveWindowMethod "setMnemonicsVisible" o = WindowSetMnemonicsVisibleMethodInfo
    ResolveWindowMethod "setModal" o = WindowSetModalMethodInfo
    ResolveWindowMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveWindowMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveWindowMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveWindowMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveWindowMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWindowMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveWindowMethod "setResizable" o = WindowSetResizableMethodInfo
    ResolveWindowMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveWindowMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveWindowMethod "setStartupId" o = WindowSetStartupIdMethodInfo
    ResolveWindowMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveWindowMethod "setTitle" o = WindowSetTitleMethodInfo
    ResolveWindowMethod "setTitlebar" o = WindowSetTitlebarMethodInfo
    ResolveWindowMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveWindowMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveWindowMethod "setTransientFor" o = WindowSetTransientForMethodInfo
    ResolveWindowMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveWindowMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveWindowMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveWindowMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveWindowMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal Window::activate-default
-- | Emitted when the user activates the default widget
-- of /@window@/.
-- 
-- This is a <https://docs.gtk.org/gtk4/class.SignalAction.html keybinding signal>.
type WindowActivateDefaultCallback =
    IO ()

type C_WindowActivateDefaultCallback =
    Ptr Window ->                           -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_WindowActivateDefaultCallback :: 
    GObject a => (a -> WindowActivateDefaultCallback) ->
    C_WindowActivateDefaultCallback
wrap_WindowActivateDefaultCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_WindowActivateDefaultCallback
wrap_WindowActivateDefaultCallback a -> IO ()
gi'cb Ptr Window
gi'selfPtr Ptr ()
_ = do
    Ptr Window -> (Window -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Window
gi'selfPtr ((Window -> IO ()) -> IO ()) -> (Window -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Window
gi'self -> a -> IO ()
gi'cb (Window -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Window
gi'self) 


-- | Connect a signal handler for the [activateDefault](#signal:activateDefault) 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' window #activateDefault callback
-- @
-- 
-- 
onWindowActivateDefault :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateDefaultCallback) -> m SignalHandlerId
onWindowActivateDefault :: forall a (m :: * -> *).
(IsWindow a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onWindowActivateDefault a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_WindowActivateDefaultCallback
wrapped' = (a -> IO ()) -> C_WindowActivateDefaultCallback
forall a.
GObject a =>
(a -> IO ()) -> C_WindowActivateDefaultCallback
wrap_WindowActivateDefaultCallback a -> IO ()
wrapped
    FunPtr C_WindowActivateDefaultCallback
wrapped'' <- C_WindowActivateDefaultCallback
-> IO (FunPtr C_WindowActivateDefaultCallback)
mk_WindowActivateDefaultCallback C_WindowActivateDefaultCallback
wrapped'
    a
-> Text
-> FunPtr C_WindowActivateDefaultCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate-default" FunPtr C_WindowActivateDefaultCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [activateDefault](#signal:activateDefault) 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' window #activateDefault 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.
-- 
afterWindowActivateDefault :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateDefaultCallback) -> m SignalHandlerId
afterWindowActivateDefault :: forall a (m :: * -> *).
(IsWindow a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterWindowActivateDefault a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_WindowActivateDefaultCallback
wrapped' = (a -> IO ()) -> C_WindowActivateDefaultCallback
forall a.
GObject a =>
(a -> IO ()) -> C_WindowActivateDefaultCallback
wrap_WindowActivateDefaultCallback a -> IO ()
wrapped
    FunPtr C_WindowActivateDefaultCallback
wrapped'' <- C_WindowActivateDefaultCallback
-> IO (FunPtr C_WindowActivateDefaultCallback)
mk_WindowActivateDefaultCallback C_WindowActivateDefaultCallback
wrapped'
    a
-> Text
-> FunPtr C_WindowActivateDefaultCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate-default" FunPtr C_WindowActivateDefaultCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WindowActivateDefaultSignalInfo
instance SignalInfo WindowActivateDefaultSignalInfo where
    type HaskellCallbackType WindowActivateDefaultSignalInfo = WindowActivateDefaultCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WindowActivateDefaultCallback cb
        cb'' <- mk_WindowActivateDefaultCallback cb'
        connectSignalFunPtr obj "activate-default" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window::activate-default"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:signal:activateDefault"})

#endif

-- signal Window::activate-focus
-- | Emitted when the user activates the currently focused
-- widget of /@window@/.
-- 
-- This is a <https://docs.gtk.org/gtk4/class.SignalAction.html keybinding signal>.
type WindowActivateFocusCallback =
    IO ()

type C_WindowActivateFocusCallback =
    Ptr Window ->                           -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_WindowActivateFocusCallback :: 
    GObject a => (a -> WindowActivateFocusCallback) ->
    C_WindowActivateFocusCallback
wrap_WindowActivateFocusCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_WindowActivateDefaultCallback
wrap_WindowActivateFocusCallback a -> IO ()
gi'cb Ptr Window
gi'selfPtr Ptr ()
_ = do
    Ptr Window -> (Window -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Window
gi'selfPtr ((Window -> IO ()) -> IO ()) -> (Window -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Window
gi'self -> a -> IO ()
gi'cb (Window -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Window
gi'self) 


-- | Connect a signal handler for the [activateFocus](#signal:activateFocus) 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' window #activateFocus callback
-- @
-- 
-- 
onWindowActivateFocus :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateFocusCallback) -> m SignalHandlerId
onWindowActivateFocus :: forall a (m :: * -> *).
(IsWindow a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onWindowActivateFocus a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_WindowActivateDefaultCallback
wrapped' = (a -> IO ()) -> C_WindowActivateDefaultCallback
forall a.
GObject a =>
(a -> IO ()) -> C_WindowActivateDefaultCallback
wrap_WindowActivateFocusCallback a -> IO ()
wrapped
    FunPtr C_WindowActivateDefaultCallback
wrapped'' <- C_WindowActivateDefaultCallback
-> IO (FunPtr C_WindowActivateDefaultCallback)
mk_WindowActivateFocusCallback C_WindowActivateDefaultCallback
wrapped'
    a
-> Text
-> FunPtr C_WindowActivateDefaultCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate-focus" FunPtr C_WindowActivateDefaultCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [activateFocus](#signal:activateFocus) 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' window #activateFocus 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.
-- 
afterWindowActivateFocus :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateFocusCallback) -> m SignalHandlerId
afterWindowActivateFocus :: forall a (m :: * -> *).
(IsWindow a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterWindowActivateFocus a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_WindowActivateDefaultCallback
wrapped' = (a -> IO ()) -> C_WindowActivateDefaultCallback
forall a.
GObject a =>
(a -> IO ()) -> C_WindowActivateDefaultCallback
wrap_WindowActivateFocusCallback a -> IO ()
wrapped
    FunPtr C_WindowActivateDefaultCallback
wrapped'' <- C_WindowActivateDefaultCallback
-> IO (FunPtr C_WindowActivateDefaultCallback)
mk_WindowActivateFocusCallback C_WindowActivateDefaultCallback
wrapped'
    a
-> Text
-> FunPtr C_WindowActivateDefaultCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate-focus" FunPtr C_WindowActivateDefaultCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WindowActivateFocusSignalInfo
instance SignalInfo WindowActivateFocusSignalInfo where
    type HaskellCallbackType WindowActivateFocusSignalInfo = WindowActivateFocusCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WindowActivateFocusCallback cb
        cb'' <- mk_WindowActivateFocusCallback cb'
        connectSignalFunPtr obj "activate-focus" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window::activate-focus"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:signal:activateFocus"})

#endif

-- signal Window::close-request
-- | Emitted when the user clicks on the close button of the window.
type WindowCloseRequestCallback =
    IO Bool
    -- ^ __Returns:__ 'P.True' to stop other handlers from being invoked for the signal

type C_WindowCloseRequestCallback =
    Ptr Window ->                           -- object
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_WindowCloseRequestCallback :: 
    GObject a => (a -> WindowCloseRequestCallback) ->
    C_WindowCloseRequestCallback
wrap_WindowCloseRequestCallback :: forall a.
GObject a =>
(a -> WindowCloseRequestCallback) -> C_WindowCloseRequestCallback
wrap_WindowCloseRequestCallback a -> WindowCloseRequestCallback
gi'cb Ptr Window
gi'selfPtr Ptr ()
_ = do
    Bool
result <- Ptr Window
-> (Window -> WindowCloseRequestCallback)
-> WindowCloseRequestCallback
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Window
gi'selfPtr ((Window -> WindowCloseRequestCallback)
 -> WindowCloseRequestCallback)
-> (Window -> WindowCloseRequestCallback)
-> WindowCloseRequestCallback
forall a b. (a -> b) -> a -> b
$ \Window
gi'self -> a -> WindowCloseRequestCallback
gi'cb (Window -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Window
gi'self) 
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [closeRequest](#signal:closeRequest) 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' window #closeRequest callback
-- @
-- 
-- 
onWindowCloseRequest :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowCloseRequestCallback) -> m SignalHandlerId
onWindowCloseRequest :: forall a (m :: * -> *).
(IsWindow a, MonadIO m) =>
a
-> ((?self::a) => WindowCloseRequestCallback) -> m SignalHandlerId
onWindowCloseRequest a
obj (?self::a) => WindowCloseRequestCallback
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 -> WindowCloseRequestCallback
wrapped a
self = let ?self = a
?self::a
self in WindowCloseRequestCallback
(?self::a) => WindowCloseRequestCallback
cb
    let wrapped' :: C_WindowCloseRequestCallback
wrapped' = (a -> WindowCloseRequestCallback) -> C_WindowCloseRequestCallback
forall a.
GObject a =>
(a -> WindowCloseRequestCallback) -> C_WindowCloseRequestCallback
wrap_WindowCloseRequestCallback a -> WindowCloseRequestCallback
wrapped
    FunPtr C_WindowCloseRequestCallback
wrapped'' <- C_WindowCloseRequestCallback
-> IO (FunPtr C_WindowCloseRequestCallback)
mk_WindowCloseRequestCallback C_WindowCloseRequestCallback
wrapped'
    a
-> Text
-> FunPtr C_WindowCloseRequestCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"close-request" FunPtr C_WindowCloseRequestCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [closeRequest](#signal:closeRequest) 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' window #closeRequest 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.
-- 
afterWindowCloseRequest :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowCloseRequestCallback) -> m SignalHandlerId
afterWindowCloseRequest :: forall a (m :: * -> *).
(IsWindow a, MonadIO m) =>
a
-> ((?self::a) => WindowCloseRequestCallback) -> m SignalHandlerId
afterWindowCloseRequest a
obj (?self::a) => WindowCloseRequestCallback
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 -> WindowCloseRequestCallback
wrapped a
self = let ?self = a
?self::a
self in WindowCloseRequestCallback
(?self::a) => WindowCloseRequestCallback
cb
    let wrapped' :: C_WindowCloseRequestCallback
wrapped' = (a -> WindowCloseRequestCallback) -> C_WindowCloseRequestCallback
forall a.
GObject a =>
(a -> WindowCloseRequestCallback) -> C_WindowCloseRequestCallback
wrap_WindowCloseRequestCallback a -> WindowCloseRequestCallback
wrapped
    FunPtr C_WindowCloseRequestCallback
wrapped'' <- C_WindowCloseRequestCallback
-> IO (FunPtr C_WindowCloseRequestCallback)
mk_WindowCloseRequestCallback C_WindowCloseRequestCallback
wrapped'
    a
-> Text
-> FunPtr C_WindowCloseRequestCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"close-request" FunPtr C_WindowCloseRequestCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WindowCloseRequestSignalInfo
instance SignalInfo WindowCloseRequestSignalInfo where
    type HaskellCallbackType WindowCloseRequestSignalInfo = WindowCloseRequestCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WindowCloseRequestCallback cb
        cb'' <- mk_WindowCloseRequestCallback cb'
        connectSignalFunPtr obj "close-request" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window::close-request"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:signal:closeRequest"})

#endif

-- signal Window::enable-debugging
-- | Emitted when the user enables or disables interactive debugging.
-- 
-- When /@toggle@/ is 'P.True', interactive debugging is toggled on or off,
-- when it is 'P.False', the debugger will be pointed at the widget
-- under the pointer.
-- 
-- This is a <https://docs.gtk.org/gtk4/class.SignalAction.html keybinding signal>.
-- 
-- The default bindings for this signal are Ctrl-Shift-I
-- and Ctrl-Shift-D.
type WindowEnableDebuggingCallback =
    Bool
    -- ^ /@toggle@/: toggle the debugger
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the key binding was handled

type C_WindowEnableDebuggingCallback =
    Ptr Window ->                           -- object
    CInt ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_WindowEnableDebuggingCallback :: 
    GObject a => (a -> WindowEnableDebuggingCallback) ->
    C_WindowEnableDebuggingCallback
wrap_WindowEnableDebuggingCallback :: forall a.
GObject a =>
(a -> WindowEnableDebuggingCallback)
-> C_WindowEnableDebuggingCallback
wrap_WindowEnableDebuggingCallback a -> WindowEnableDebuggingCallback
gi'cb Ptr Window
gi'selfPtr CInt
toggle Ptr ()
_ = do
    let toggle' :: Bool
toggle' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
toggle
    Bool
result <- Ptr Window
-> (Window -> WindowCloseRequestCallback)
-> WindowCloseRequestCallback
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Window
gi'selfPtr ((Window -> WindowCloseRequestCallback)
 -> WindowCloseRequestCallback)
-> (Window -> WindowCloseRequestCallback)
-> WindowCloseRequestCallback
forall a b. (a -> b) -> a -> b
$ \Window
gi'self -> a -> WindowEnableDebuggingCallback
gi'cb (Window -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Window
gi'self)  Bool
toggle'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [enableDebugging](#signal:enableDebugging) 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' window #enableDebugging callback
-- @
-- 
-- 
onWindowEnableDebugging :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowEnableDebuggingCallback) -> m SignalHandlerId
onWindowEnableDebugging :: forall a (m :: * -> *).
(IsWindow a, MonadIO m) =>
a
-> ((?self::a) => WindowEnableDebuggingCallback)
-> m SignalHandlerId
onWindowEnableDebugging a
obj (?self::a) => WindowEnableDebuggingCallback
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 -> WindowEnableDebuggingCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => WindowEnableDebuggingCallback
WindowEnableDebuggingCallback
cb
    let wrapped' :: C_WindowEnableDebuggingCallback
wrapped' = (a -> WindowEnableDebuggingCallback)
-> C_WindowEnableDebuggingCallback
forall a.
GObject a =>
(a -> WindowEnableDebuggingCallback)
-> C_WindowEnableDebuggingCallback
wrap_WindowEnableDebuggingCallback a -> WindowEnableDebuggingCallback
wrapped
    FunPtr C_WindowEnableDebuggingCallback
wrapped'' <- C_WindowEnableDebuggingCallback
-> IO (FunPtr C_WindowEnableDebuggingCallback)
mk_WindowEnableDebuggingCallback C_WindowEnableDebuggingCallback
wrapped'
    a
-> Text
-> FunPtr C_WindowEnableDebuggingCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"enable-debugging" FunPtr C_WindowEnableDebuggingCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [enableDebugging](#signal:enableDebugging) 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' window #enableDebugging 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.
-- 
afterWindowEnableDebugging :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowEnableDebuggingCallback) -> m SignalHandlerId
afterWindowEnableDebugging :: forall a (m :: * -> *).
(IsWindow a, MonadIO m) =>
a
-> ((?self::a) => WindowEnableDebuggingCallback)
-> m SignalHandlerId
afterWindowEnableDebugging a
obj (?self::a) => WindowEnableDebuggingCallback
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 -> WindowEnableDebuggingCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => WindowEnableDebuggingCallback
WindowEnableDebuggingCallback
cb
    let wrapped' :: C_WindowEnableDebuggingCallback
wrapped' = (a -> WindowEnableDebuggingCallback)
-> C_WindowEnableDebuggingCallback
forall a.
GObject a =>
(a -> WindowEnableDebuggingCallback)
-> C_WindowEnableDebuggingCallback
wrap_WindowEnableDebuggingCallback a -> WindowEnableDebuggingCallback
wrapped
    FunPtr C_WindowEnableDebuggingCallback
wrapped'' <- C_WindowEnableDebuggingCallback
-> IO (FunPtr C_WindowEnableDebuggingCallback)
mk_WindowEnableDebuggingCallback C_WindowEnableDebuggingCallback
wrapped'
    a
-> Text
-> FunPtr C_WindowEnableDebuggingCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"enable-debugging" FunPtr C_WindowEnableDebuggingCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WindowEnableDebuggingSignalInfo
instance SignalInfo WindowEnableDebuggingSignalInfo where
    type HaskellCallbackType WindowEnableDebuggingSignalInfo = WindowEnableDebuggingCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WindowEnableDebuggingCallback cb
        cb'' <- mk_WindowEnableDebuggingCallback cb'
        connectSignalFunPtr obj "enable-debugging" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window::enable-debugging"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:signal:enableDebugging"})

#endif

-- signal Window::keys-changed
-- | emitted when the set of accelerators or mnemonics that
-- are associated with /@window@/ changes.
type WindowKeysChangedCallback =
    IO ()

type C_WindowKeysChangedCallback =
    Ptr Window ->                           -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_WindowKeysChangedCallback :: 
    GObject a => (a -> WindowKeysChangedCallback) ->
    C_WindowKeysChangedCallback
wrap_WindowKeysChangedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_WindowActivateDefaultCallback
wrap_WindowKeysChangedCallback a -> IO ()
gi'cb Ptr Window
gi'selfPtr Ptr ()
_ = do
    Ptr Window -> (Window -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Window
gi'selfPtr ((Window -> IO ()) -> IO ()) -> (Window -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Window
gi'self -> a -> IO ()
gi'cb (Window -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Window
gi'self) 


-- | Connect a signal handler for the [keysChanged](#signal:keysChanged) 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' window #keysChanged callback
-- @
-- 
-- 
onWindowKeysChanged :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowKeysChangedCallback) -> m SignalHandlerId
onWindowKeysChanged :: forall a (m :: * -> *).
(IsWindow a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onWindowKeysChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_WindowActivateDefaultCallback
wrapped' = (a -> IO ()) -> C_WindowActivateDefaultCallback
forall a.
GObject a =>
(a -> IO ()) -> C_WindowActivateDefaultCallback
wrap_WindowKeysChangedCallback a -> IO ()
wrapped
    FunPtr C_WindowActivateDefaultCallback
wrapped'' <- C_WindowActivateDefaultCallback
-> IO (FunPtr C_WindowActivateDefaultCallback)
mk_WindowKeysChangedCallback C_WindowActivateDefaultCallback
wrapped'
    a
-> Text
-> FunPtr C_WindowActivateDefaultCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"keys-changed" FunPtr C_WindowActivateDefaultCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [keysChanged](#signal:keysChanged) 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' window #keysChanged 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.
-- 
afterWindowKeysChanged :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowKeysChangedCallback) -> m SignalHandlerId
afterWindowKeysChanged :: forall a (m :: * -> *).
(IsWindow a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterWindowKeysChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_WindowActivateDefaultCallback
wrapped' = (a -> IO ()) -> C_WindowActivateDefaultCallback
forall a.
GObject a =>
(a -> IO ()) -> C_WindowActivateDefaultCallback
wrap_WindowKeysChangedCallback a -> IO ()
wrapped
    FunPtr C_WindowActivateDefaultCallback
wrapped'' <- C_WindowActivateDefaultCallback
-> IO (FunPtr C_WindowActivateDefaultCallback)
mk_WindowKeysChangedCallback C_WindowActivateDefaultCallback
wrapped'
    a
-> Text
-> FunPtr C_WindowActivateDefaultCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"keys-changed" FunPtr C_WindowActivateDefaultCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WindowKeysChangedSignalInfo
instance SignalInfo WindowKeysChangedSignalInfo where
    type HaskellCallbackType WindowKeysChangedSignalInfo = WindowKeysChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WindowKeysChangedCallback cb
        cb'' <- mk_WindowKeysChangedCallback cb'
        connectSignalFunPtr obj "keys-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window::keys-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:signal:keysChanged"})

#endif

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

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

-- | Set the value of the “@application@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #application 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowApplication :: (MonadIO m, IsWindow o, Gtk.Application.IsApplication a) => o -> a -> m ()
setWindowApplication :: forall (m :: * -> *) o a.
(MonadIO m, IsWindow o, IsApplication a) =>
o -> a -> m ()
setWindowApplication 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
"application" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@application@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructWindowApplication :: (IsWindow o, MIO.MonadIO m, Gtk.Application.IsApplication a) => a -> m (GValueConstruct o)
constructWindowApplication :: forall o (m :: * -> *) a.
(IsWindow o, MonadIO m, IsApplication a) =>
a -> m (GValueConstruct o)
constructWindowApplication 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
"application" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@application@” 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' #application
-- @
clearWindowApplication :: (MonadIO m, IsWindow o) => o -> m ()
clearWindowApplication :: forall (m :: * -> *) o. (MonadIO m, IsWindow o) => o -> m ()
clearWindowApplication 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 Application -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"application" (Maybe Application
forall a. Maybe a
Nothing :: Maybe Gtk.Application.Application)

#if defined(ENABLE_OVERLOADING)
data WindowApplicationPropertyInfo
instance AttrInfo WindowApplicationPropertyInfo where
    type AttrAllowedOps WindowApplicationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WindowApplicationPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowApplicationPropertyInfo = Gtk.Application.IsApplication
    type AttrTransferTypeConstraint WindowApplicationPropertyInfo = Gtk.Application.IsApplication
    type AttrTransferType WindowApplicationPropertyInfo = Gtk.Application.Application
    type AttrGetType WindowApplicationPropertyInfo = (Maybe Gtk.Application.Application)
    type AttrLabel WindowApplicationPropertyInfo = "application"
    type AttrOrigin WindowApplicationPropertyInfo = Window
    attrGet = getWindowApplication
    attrSet = setWindowApplication
    attrTransfer _ v = do
        unsafeCastTo Gtk.Application.Application v
    attrConstruct = constructWindowApplication
    attrClear = clearWindowApplication
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.application"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:application"
        })
#endif

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

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

-- | Set the value of the “@child@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #child 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowChild :: (MonadIO m, IsWindow o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setWindowChild :: forall (m :: * -> *) o a.
(MonadIO m, IsWindow o, IsWidget a) =>
o -> a -> m ()
setWindowChild 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
"child" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@child@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructWindowChild :: (IsWindow o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructWindowChild :: forall o (m :: * -> *) a.
(IsWindow o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructWindowChild 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
"child" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

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

#if defined(ENABLE_OVERLOADING)
data WindowChildPropertyInfo
instance AttrInfo WindowChildPropertyInfo where
    type AttrAllowedOps WindowChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WindowChildPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint WindowChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType WindowChildPropertyInfo = Gtk.Widget.Widget
    type AttrGetType WindowChildPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel WindowChildPropertyInfo = "child"
    type AttrOrigin WindowChildPropertyInfo = Window
    attrGet = getWindowChild
    attrSet = setWindowChild
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructWindowChild
    attrClear = clearWindowChild
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.child"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:child"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data WindowDecoratedPropertyInfo
instance AttrInfo WindowDecoratedPropertyInfo where
    type AttrAllowedOps WindowDecoratedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WindowDecoratedPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowDecoratedPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint WindowDecoratedPropertyInfo = (~) Bool
    type AttrTransferType WindowDecoratedPropertyInfo = Bool
    type AttrGetType WindowDecoratedPropertyInfo = Bool
    type AttrLabel WindowDecoratedPropertyInfo = "decorated"
    type AttrOrigin WindowDecoratedPropertyInfo = Window
    attrGet = getWindowDecorated
    attrSet = setWindowDecorated
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowDecorated
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.decorated"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:decorated"
        })
#endif

-- VVV Prop "default-height"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

-- | Set the value of the “@default-height@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #defaultHeight 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowDefaultHeight :: (MonadIO m, IsWindow o) => o -> Int32 -> m ()
setWindowDefaultHeight :: forall (m :: * -> *) o.
(MonadIO m, IsWindow o) =>
o -> Int32 -> m ()
setWindowDefaultHeight o
obj Int32
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 -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"default-height" Int32
val

-- | Construct a `GValueConstruct` with valid value for the “@default-height@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructWindowDefaultHeight :: (IsWindow o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructWindowDefaultHeight :: forall o (m :: * -> *).
(IsWindow o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructWindowDefaultHeight Int32
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 -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"default-height" Int32
val

#if defined(ENABLE_OVERLOADING)
data WindowDefaultHeightPropertyInfo
instance AttrInfo WindowDefaultHeightPropertyInfo where
    type AttrAllowedOps WindowDefaultHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WindowDefaultHeightPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowDefaultHeightPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint WindowDefaultHeightPropertyInfo = (~) Int32
    type AttrTransferType WindowDefaultHeightPropertyInfo = Int32
    type AttrGetType WindowDefaultHeightPropertyInfo = Int32
    type AttrLabel WindowDefaultHeightPropertyInfo = "default-height"
    type AttrOrigin WindowDefaultHeightPropertyInfo = Window
    attrGet = getWindowDefaultHeight
    attrSet = setWindowDefaultHeight
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowDefaultHeight
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.defaultHeight"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:defaultHeight"
        })
#endif

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

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

-- | Set the value of the “@default-widget@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #defaultWidget 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowDefaultWidget :: (MonadIO m, IsWindow o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setWindowDefaultWidget :: forall (m :: * -> *) o a.
(MonadIO m, IsWindow o, IsWidget a) =>
o -> a -> m ()
setWindowDefaultWidget 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
"default-widget" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@default-widget@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructWindowDefaultWidget :: (IsWindow o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructWindowDefaultWidget :: forall o (m :: * -> *) a.
(IsWindow o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructWindowDefaultWidget 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
"default-widget" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@default-widget@” 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' #defaultWidget
-- @
clearWindowDefaultWidget :: (MonadIO m, IsWindow o) => o -> m ()
clearWindowDefaultWidget :: forall (m :: * -> *) o. (MonadIO m, IsWindow o) => o -> m ()
clearWindowDefaultWidget 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 Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"default-widget" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data WindowDefaultWidgetPropertyInfo
instance AttrInfo WindowDefaultWidgetPropertyInfo where
    type AttrAllowedOps WindowDefaultWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WindowDefaultWidgetPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowDefaultWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint WindowDefaultWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType WindowDefaultWidgetPropertyInfo = Gtk.Widget.Widget
    type AttrGetType WindowDefaultWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel WindowDefaultWidgetPropertyInfo = "default-widget"
    type AttrOrigin WindowDefaultWidgetPropertyInfo = Window
    attrGet = getWindowDefaultWidget
    attrSet = setWindowDefaultWidget
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructWindowDefaultWidget
    attrClear = clearWindowDefaultWidget
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.defaultWidget"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:defaultWidget"
        })
#endif

-- VVV Prop "default-width"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

-- | Set the value of the “@default-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #defaultWidth 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowDefaultWidth :: (MonadIO m, IsWindow o) => o -> Int32 -> m ()
setWindowDefaultWidth :: forall (m :: * -> *) o.
(MonadIO m, IsWindow o) =>
o -> Int32 -> m ()
setWindowDefaultWidth o
obj Int32
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 -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"default-width" Int32
val

-- | Construct a `GValueConstruct` with valid value for the “@default-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructWindowDefaultWidth :: (IsWindow o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructWindowDefaultWidth :: forall o (m :: * -> *).
(IsWindow o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructWindowDefaultWidth Int32
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 -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"default-width" Int32
val

#if defined(ENABLE_OVERLOADING)
data WindowDefaultWidthPropertyInfo
instance AttrInfo WindowDefaultWidthPropertyInfo where
    type AttrAllowedOps WindowDefaultWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WindowDefaultWidthPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowDefaultWidthPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint WindowDefaultWidthPropertyInfo = (~) Int32
    type AttrTransferType WindowDefaultWidthPropertyInfo = Int32
    type AttrGetType WindowDefaultWidthPropertyInfo = Int32
    type AttrLabel WindowDefaultWidthPropertyInfo = "default-width"
    type AttrOrigin WindowDefaultWidthPropertyInfo = Window
    attrGet = getWindowDefaultWidth
    attrSet = setWindowDefaultWidth
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowDefaultWidth
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.defaultWidth"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:defaultWidth"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data WindowDeletablePropertyInfo
instance AttrInfo WindowDeletablePropertyInfo where
    type AttrAllowedOps WindowDeletablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WindowDeletablePropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowDeletablePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint WindowDeletablePropertyInfo = (~) Bool
    type AttrTransferType WindowDeletablePropertyInfo = Bool
    type AttrGetType WindowDeletablePropertyInfo = Bool
    type AttrLabel WindowDeletablePropertyInfo = "deletable"
    type AttrOrigin WindowDeletablePropertyInfo = Window
    attrGet = getWindowDeletable
    attrSet = setWindowDeletable
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowDeletable
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.deletable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:deletable"
        })
#endif

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

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

-- | Set the value of the “@destroy-with-parent@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #destroyWithParent 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowDestroyWithParent :: (MonadIO m, IsWindow o) => o -> Bool -> m ()
setWindowDestroyWithParent :: forall (m :: * -> *) o.
(MonadIO m, IsWindow o) =>
o -> Bool -> m ()
setWindowDestroyWithParent 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
"destroy-with-parent" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data WindowDestroyWithParentPropertyInfo
instance AttrInfo WindowDestroyWithParentPropertyInfo where
    type AttrAllowedOps WindowDestroyWithParentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WindowDestroyWithParentPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowDestroyWithParentPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint WindowDestroyWithParentPropertyInfo = (~) Bool
    type AttrTransferType WindowDestroyWithParentPropertyInfo = Bool
    type AttrGetType WindowDestroyWithParentPropertyInfo = Bool
    type AttrLabel WindowDestroyWithParentPropertyInfo = "destroy-with-parent"
    type AttrOrigin WindowDestroyWithParentPropertyInfo = Window
    attrGet = getWindowDestroyWithParent
    attrSet = setWindowDestroyWithParent
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowDestroyWithParent
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.destroyWithParent"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:destroyWithParent"
        })
#endif

-- VVV Prop "display"
   -- Type: TInterface (Name {namespace = "Gdk", name = "Display"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

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

-- | Set the value of the “@display@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #display 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowDisplay :: (MonadIO m, IsWindow o, Gdk.Display.IsDisplay a) => o -> a -> m ()
setWindowDisplay :: forall (m :: * -> *) o a.
(MonadIO m, IsWindow o, IsDisplay a) =>
o -> a -> m ()
setWindowDisplay 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
"display" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@display@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructWindowDisplay :: (IsWindow o, MIO.MonadIO m, Gdk.Display.IsDisplay a) => a -> m (GValueConstruct o)
constructWindowDisplay :: forall o (m :: * -> *) a.
(IsWindow o, MonadIO m, IsDisplay a) =>
a -> m (GValueConstruct o)
constructWindowDisplay 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
"display" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data WindowDisplayPropertyInfo
instance AttrInfo WindowDisplayPropertyInfo where
    type AttrAllowedOps WindowDisplayPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WindowDisplayPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowDisplayPropertyInfo = Gdk.Display.IsDisplay
    type AttrTransferTypeConstraint WindowDisplayPropertyInfo = Gdk.Display.IsDisplay
    type AttrTransferType WindowDisplayPropertyInfo = Gdk.Display.Display
    type AttrGetType WindowDisplayPropertyInfo = (Maybe Gdk.Display.Display)
    type AttrLabel WindowDisplayPropertyInfo = "display"
    type AttrOrigin WindowDisplayPropertyInfo = Window
    attrGet = getWindowDisplay
    attrSet = setWindowDisplay
    attrTransfer _ v = do
        unsafeCastTo Gdk.Display.Display v
    attrConstruct = constructWindowDisplay
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.display"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:display"
        })
#endif

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

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

-- | Set the value of the “@focus-visible@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #focusVisible 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowFocusVisible :: (MonadIO m, IsWindow o) => o -> Bool -> m ()
setWindowFocusVisible :: forall (m :: * -> *) o.
(MonadIO m, IsWindow o) =>
o -> Bool -> m ()
setWindowFocusVisible 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
"focus-visible" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data WindowFocusVisiblePropertyInfo
instance AttrInfo WindowFocusVisiblePropertyInfo where
    type AttrAllowedOps WindowFocusVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WindowFocusVisiblePropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowFocusVisiblePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint WindowFocusVisiblePropertyInfo = (~) Bool
    type AttrTransferType WindowFocusVisiblePropertyInfo = Bool
    type AttrGetType WindowFocusVisiblePropertyInfo = Bool
    type AttrLabel WindowFocusVisiblePropertyInfo = "focus-visible"
    type AttrOrigin WindowFocusVisiblePropertyInfo = Window
    attrGet = getWindowFocusVisible
    attrSet = setWindowFocusVisible
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowFocusVisible
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.focusVisible"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:focusVisible"
        })
#endif

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

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

-- | Set the value of the “@focus-widget@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #focusWidget 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowFocusWidget :: (MonadIO m, IsWindow o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setWindowFocusWidget :: forall (m :: * -> *) o a.
(MonadIO m, IsWindow o, IsWidget a) =>
o -> a -> m ()
setWindowFocusWidget 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
"focus-widget" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@focus-widget@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructWindowFocusWidget :: (IsWindow o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructWindowFocusWidget :: forall o (m :: * -> *) a.
(IsWindow o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructWindowFocusWidget 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
"focus-widget" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@focus-widget@” 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' #focusWidget
-- @
clearWindowFocusWidget :: (MonadIO m, IsWindow o) => o -> m ()
clearWindowFocusWidget :: forall (m :: * -> *) o. (MonadIO m, IsWindow o) => o -> m ()
clearWindowFocusWidget 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 Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"focus-widget" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data WindowFocusWidgetPropertyInfo
instance AttrInfo WindowFocusWidgetPropertyInfo where
    type AttrAllowedOps WindowFocusWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WindowFocusWidgetPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowFocusWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint WindowFocusWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType WindowFocusWidgetPropertyInfo = Gtk.Widget.Widget
    type AttrGetType WindowFocusWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel WindowFocusWidgetPropertyInfo = "focus-widget"
    type AttrOrigin WindowFocusWidgetPropertyInfo = Window
    attrGet = getWindowFocusWidget
    attrSet = setWindowFocusWidget
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructWindowFocusWidget
    attrClear = clearWindowFocusWidget
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.focusWidget"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:focusWidget"
        })
#endif

-- VVV Prop "fullscreened"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

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

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

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

#if defined(ENABLE_OVERLOADING)
data WindowFullscreenedPropertyInfo
instance AttrInfo WindowFullscreenedPropertyInfo where
    type AttrAllowedOps WindowFullscreenedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WindowFullscreenedPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowFullscreenedPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint WindowFullscreenedPropertyInfo = (~) Bool
    type AttrTransferType WindowFullscreenedPropertyInfo = Bool
    type AttrGetType WindowFullscreenedPropertyInfo = Bool
    type AttrLabel WindowFullscreenedPropertyInfo = "fullscreened"
    type AttrOrigin WindowFullscreenedPropertyInfo = Window
    attrGet = getWindowFullscreened
    attrSet = setWindowFullscreened
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowFullscreened
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.fullscreened"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:fullscreened"
        })
#endif

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

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

-- | Set the value of the “@handle-menubar-accel@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #handleMenubarAccel 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowHandleMenubarAccel :: (MonadIO m, IsWindow o) => o -> Bool -> m ()
setWindowHandleMenubarAccel :: forall (m :: * -> *) o.
(MonadIO m, IsWindow o) =>
o -> Bool -> m ()
setWindowHandleMenubarAccel 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
"handle-menubar-accel" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data WindowHandleMenubarAccelPropertyInfo
instance AttrInfo WindowHandleMenubarAccelPropertyInfo where
    type AttrAllowedOps WindowHandleMenubarAccelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WindowHandleMenubarAccelPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowHandleMenubarAccelPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint WindowHandleMenubarAccelPropertyInfo = (~) Bool
    type AttrTransferType WindowHandleMenubarAccelPropertyInfo = Bool
    type AttrGetType WindowHandleMenubarAccelPropertyInfo = Bool
    type AttrLabel WindowHandleMenubarAccelPropertyInfo = "handle-menubar-accel"
    type AttrOrigin WindowHandleMenubarAccelPropertyInfo = Window
    attrGet = getWindowHandleMenubarAccel
    attrSet = setWindowHandleMenubarAccel
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowHandleMenubarAccel
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.handleMenubarAccel"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:handleMenubarAccel"
        })
#endif

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

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

-- | Set the value of the “@hide-on-close@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #hideOnClose 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowHideOnClose :: (MonadIO m, IsWindow o) => o -> Bool -> m ()
setWindowHideOnClose :: forall (m :: * -> *) o.
(MonadIO m, IsWindow o) =>
o -> Bool -> m ()
setWindowHideOnClose 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
"hide-on-close" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data WindowHideOnClosePropertyInfo
instance AttrInfo WindowHideOnClosePropertyInfo where
    type AttrAllowedOps WindowHideOnClosePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WindowHideOnClosePropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowHideOnClosePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint WindowHideOnClosePropertyInfo = (~) Bool
    type AttrTransferType WindowHideOnClosePropertyInfo = Bool
    type AttrGetType WindowHideOnClosePropertyInfo = Bool
    type AttrLabel WindowHideOnClosePropertyInfo = "hide-on-close"
    type AttrOrigin WindowHideOnClosePropertyInfo = Window
    attrGet = getWindowHideOnClose
    attrSet = setWindowHideOnClose
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowHideOnClose
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.hideOnClose"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:hideOnClose"
        })
#endif

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

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

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

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

-- | Set the value of the “@icon-name@” 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' #iconName
-- @
clearWindowIconName :: (MonadIO m, IsWindow o) => o -> m ()
clearWindowIconName :: forall (m :: * -> *) o. (MonadIO m, IsWindow o) => o -> m ()
clearWindowIconName 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 Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"icon-name" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data WindowIconNamePropertyInfo
instance AttrInfo WindowIconNamePropertyInfo where
    type AttrAllowedOps WindowIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WindowIconNamePropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowIconNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint WindowIconNamePropertyInfo = (~) T.Text
    type AttrTransferType WindowIconNamePropertyInfo = T.Text
    type AttrGetType WindowIconNamePropertyInfo = (Maybe T.Text)
    type AttrLabel WindowIconNamePropertyInfo = "icon-name"
    type AttrOrigin WindowIconNamePropertyInfo = Window
    attrGet = getWindowIconName
    attrSet = setWindowIconName
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowIconName
    attrClear = clearWindowIconName
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.iconName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:iconName"
        })
#endif

-- VVV Prop "is-active"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data WindowIsActivePropertyInfo
instance AttrInfo WindowIsActivePropertyInfo where
    type AttrAllowedOps WindowIsActivePropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint WindowIsActivePropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowIsActivePropertyInfo = (~) ()
    type AttrTransferTypeConstraint WindowIsActivePropertyInfo = (~) ()
    type AttrTransferType WindowIsActivePropertyInfo = ()
    type AttrGetType WindowIsActivePropertyInfo = Bool
    type AttrLabel WindowIsActivePropertyInfo = "is-active"
    type AttrOrigin WindowIsActivePropertyInfo = Window
    attrGet = getWindowIsActive
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.isActive"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:isActive"
        })
#endif

-- VVV Prop "maximized"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

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

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

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

#if defined(ENABLE_OVERLOADING)
data WindowMaximizedPropertyInfo
instance AttrInfo WindowMaximizedPropertyInfo where
    type AttrAllowedOps WindowMaximizedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WindowMaximizedPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowMaximizedPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint WindowMaximizedPropertyInfo = (~) Bool
    type AttrTransferType WindowMaximizedPropertyInfo = Bool
    type AttrGetType WindowMaximizedPropertyInfo = Bool
    type AttrLabel WindowMaximizedPropertyInfo = "maximized"
    type AttrOrigin WindowMaximizedPropertyInfo = Window
    attrGet = getWindowMaximized
    attrSet = setWindowMaximized
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowMaximized
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.maximized"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:maximized"
        })
#endif

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

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

-- | Set the value of the “@mnemonics-visible@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #mnemonicsVisible 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowMnemonicsVisible :: (MonadIO m, IsWindow o) => o -> Bool -> m ()
setWindowMnemonicsVisible :: forall (m :: * -> *) o.
(MonadIO m, IsWindow o) =>
o -> Bool -> m ()
setWindowMnemonicsVisible 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
"mnemonics-visible" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data WindowMnemonicsVisiblePropertyInfo
instance AttrInfo WindowMnemonicsVisiblePropertyInfo where
    type AttrAllowedOps WindowMnemonicsVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WindowMnemonicsVisiblePropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowMnemonicsVisiblePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint WindowMnemonicsVisiblePropertyInfo = (~) Bool
    type AttrTransferType WindowMnemonicsVisiblePropertyInfo = Bool
    type AttrGetType WindowMnemonicsVisiblePropertyInfo = Bool
    type AttrLabel WindowMnemonicsVisiblePropertyInfo = "mnemonics-visible"
    type AttrOrigin WindowMnemonicsVisiblePropertyInfo = Window
    attrGet = getWindowMnemonicsVisible
    attrSet = setWindowMnemonicsVisible
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowMnemonicsVisible
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.mnemonicsVisible"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:mnemonicsVisible"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data WindowModalPropertyInfo
instance AttrInfo WindowModalPropertyInfo where
    type AttrAllowedOps WindowModalPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WindowModalPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowModalPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint WindowModalPropertyInfo = (~) Bool
    type AttrTransferType WindowModalPropertyInfo = Bool
    type AttrGetType WindowModalPropertyInfo = Bool
    type AttrLabel WindowModalPropertyInfo = "modal"
    type AttrOrigin WindowModalPropertyInfo = Window
    attrGet = getWindowModal
    attrSet = setWindowModal
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowModal
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.modal"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:modal"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data WindowResizablePropertyInfo
instance AttrInfo WindowResizablePropertyInfo where
    type AttrAllowedOps WindowResizablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint WindowResizablePropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowResizablePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint WindowResizablePropertyInfo = (~) Bool
    type AttrTransferType WindowResizablePropertyInfo = Bool
    type AttrGetType WindowResizablePropertyInfo = Bool
    type AttrLabel WindowResizablePropertyInfo = "resizable"
    type AttrOrigin WindowResizablePropertyInfo = Window
    attrGet = getWindowResizable
    attrSet = setWindowResizable
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowResizable
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.resizable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:resizable"
        })
#endif

-- VVV Prop "startup-id"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyWritable]
   -- Nullable: (Nothing,Just False)

-- | Set the value of the “@startup-id@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #startupId 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowStartupId :: (MonadIO m, IsWindow o) => o -> T.Text -> m ()
setWindowStartupId :: forall (m :: * -> *) o.
(MonadIO m, IsWindow o) =>
o -> Text -> m ()
setWindowStartupId o
obj Text
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 Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"startup-id" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@startup-id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructWindowStartupId :: (IsWindow o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructWindowStartupId :: forall o (m :: * -> *).
(IsWindow o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructWindowStartupId Text
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 Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"startup-id" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data WindowStartupIdPropertyInfo
instance AttrInfo WindowStartupIdPropertyInfo where
    type AttrAllowedOps WindowStartupIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct]
    type AttrBaseTypeConstraint WindowStartupIdPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowStartupIdPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint WindowStartupIdPropertyInfo = (~) T.Text
    type AttrTransferType WindowStartupIdPropertyInfo = T.Text
    type AttrGetType WindowStartupIdPropertyInfo = ()
    type AttrLabel WindowStartupIdPropertyInfo = "startup-id"
    type AttrOrigin WindowStartupIdPropertyInfo = Window
    attrGet = undefined
    attrSet = setWindowStartupId
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowStartupId
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.startupId"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:startupId"
        })
#endif

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

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

-- | Set the value of the “@title@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #title 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowTitle :: (MonadIO m, IsWindow o) => o -> T.Text -> m ()
setWindowTitle :: forall (m :: * -> *) o.
(MonadIO m, IsWindow o) =>
o -> Text -> m ()
setWindowTitle o
obj Text
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 Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"title" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@title@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructWindowTitle :: (IsWindow o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructWindowTitle :: forall o (m :: * -> *).
(IsWindow o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructWindowTitle Text
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 Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"title" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@title@” 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' #title
-- @
clearWindowTitle :: (MonadIO m, IsWindow o) => o -> m ()
clearWindowTitle :: forall (m :: * -> *) o. (MonadIO m, IsWindow o) => o -> m ()
clearWindowTitle 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 Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"title" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data WindowTitlePropertyInfo
instance AttrInfo WindowTitlePropertyInfo where
    type AttrAllowedOps WindowTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WindowTitlePropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowTitlePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint WindowTitlePropertyInfo = (~) T.Text
    type AttrTransferType WindowTitlePropertyInfo = T.Text
    type AttrGetType WindowTitlePropertyInfo = (Maybe T.Text)
    type AttrLabel WindowTitlePropertyInfo = "title"
    type AttrOrigin WindowTitlePropertyInfo = Window
    attrGet = getWindowTitle
    attrSet = setWindowTitle
    attrTransfer _ v = do
        return v
    attrConstruct = constructWindowTitle
    attrClear = clearWindowTitle
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.title"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:title"
        })
#endif

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

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

-- | Set the value of the “@titlebar@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #titlebar 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowTitlebar :: (MonadIO m, IsWindow o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setWindowTitlebar :: forall (m :: * -> *) o a.
(MonadIO m, IsWindow o, IsWidget a) =>
o -> a -> m ()
setWindowTitlebar 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
"titlebar" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@titlebar@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructWindowTitlebar :: (IsWindow o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructWindowTitlebar :: forall o (m :: * -> *) a.
(IsWindow o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructWindowTitlebar 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
"titlebar" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@titlebar@” 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' #titlebar
-- @
clearWindowTitlebar :: (MonadIO m, IsWindow o) => o -> m ()
clearWindowTitlebar :: forall (m :: * -> *) o. (MonadIO m, IsWindow o) => o -> m ()
clearWindowTitlebar 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 Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"titlebar" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data WindowTitlebarPropertyInfo
instance AttrInfo WindowTitlebarPropertyInfo where
    type AttrAllowedOps WindowTitlebarPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WindowTitlebarPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowTitlebarPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint WindowTitlebarPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType WindowTitlebarPropertyInfo = Gtk.Widget.Widget
    type AttrGetType WindowTitlebarPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel WindowTitlebarPropertyInfo = "titlebar"
    type AttrOrigin WindowTitlebarPropertyInfo = Window
    attrGet = getWindowTitlebar
    attrSet = setWindowTitlebar
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructWindowTitlebar
    attrClear = clearWindowTitlebar
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.titlebar"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:titlebar"
        })
#endif

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

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

-- | Set the value of the “@transient-for@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' window [ #transientFor 'Data.GI.Base.Attributes.:=' value ]
-- @
setWindowTransientFor :: (MonadIO m, IsWindow o, IsWindow a) => o -> a -> m ()
setWindowTransientFor :: forall (m :: * -> *) o a.
(MonadIO m, IsWindow o, IsWindow a) =>
o -> a -> m ()
setWindowTransientFor 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
"transient-for" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

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

-- | Set the value of the “@transient-for@” 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' #transientFor
-- @
clearWindowTransientFor :: (MonadIO m, IsWindow o) => o -> m ()
clearWindowTransientFor :: forall (m :: * -> *) o. (MonadIO m, IsWindow o) => o -> m ()
clearWindowTransientFor 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 Window -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"transient-for" (Maybe Window
forall a. Maybe a
Nothing :: Maybe Window)

#if defined(ENABLE_OVERLOADING)
data WindowTransientForPropertyInfo
instance AttrInfo WindowTransientForPropertyInfo where
    type AttrAllowedOps WindowTransientForPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WindowTransientForPropertyInfo = IsWindow
    type AttrSetTypeConstraint WindowTransientForPropertyInfo = IsWindow
    type AttrTransferTypeConstraint WindowTransientForPropertyInfo = IsWindow
    type AttrTransferType WindowTransientForPropertyInfo = Window
    type AttrGetType WindowTransientForPropertyInfo = (Maybe Window)
    type AttrLabel WindowTransientForPropertyInfo = "transient-for"
    type AttrOrigin WindowTransientForPropertyInfo = Window
    attrGet = getWindowTransientFor
    attrSet = setWindowTransientFor
    attrTransfer _ v = do
        unsafeCastTo Window v
    attrConstruct = constructWindowTransientFor
    attrClear = clearWindowTransientFor
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.transientFor"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#g:attr:transientFor"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Window
type instance O.AttributeList Window = WindowAttributeList
type WindowAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("application", WindowApplicationPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", WindowChildPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("defaultHeight", WindowDefaultHeightPropertyInfo), '("defaultWidget", WindowDefaultWidgetPropertyInfo), '("defaultWidth", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroyWithParent", WindowDestroyWithParentPropertyInfo), '("display", WindowDisplayPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusVisible", WindowFocusVisiblePropertyInfo), '("focusWidget", WindowFocusWidgetPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("fullscreened", WindowFullscreenedPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("handleMenubarAccel", WindowHandleMenubarAccelPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hideOnClose", WindowHideOnClosePropertyInfo), '("iconName", WindowIconNamePropertyInfo), '("isActive", WindowIsActivePropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("maximized", WindowMaximizedPropertyInfo), '("mnemonicsVisible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("startupId", WindowStartupIdPropertyInfo), '("title", WindowTitlePropertyInfo), '("titlebar", WindowTitlebarPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("transientFor", WindowTransientForPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
windowApplication :: AttrLabelProxy "application"
windowApplication = AttrLabelProxy

windowChild :: AttrLabelProxy "child"
windowChild = AttrLabelProxy

windowDecorated :: AttrLabelProxy "decorated"
windowDecorated = AttrLabelProxy

windowDefaultHeight :: AttrLabelProxy "defaultHeight"
windowDefaultHeight = AttrLabelProxy

windowDefaultWidget :: AttrLabelProxy "defaultWidget"
windowDefaultWidget = AttrLabelProxy

windowDefaultWidth :: AttrLabelProxy "defaultWidth"
windowDefaultWidth = AttrLabelProxy

windowDeletable :: AttrLabelProxy "deletable"
windowDeletable = AttrLabelProxy

windowDestroyWithParent :: AttrLabelProxy "destroyWithParent"
windowDestroyWithParent = AttrLabelProxy

windowDisplay :: AttrLabelProxy "display"
windowDisplay = AttrLabelProxy

windowFocusVisible :: AttrLabelProxy "focusVisible"
windowFocusVisible = AttrLabelProxy

windowFocusWidget :: AttrLabelProxy "focusWidget"
windowFocusWidget = AttrLabelProxy

windowFullscreened :: AttrLabelProxy "fullscreened"
windowFullscreened = AttrLabelProxy

windowHandleMenubarAccel :: AttrLabelProxy "handleMenubarAccel"
windowHandleMenubarAccel = AttrLabelProxy

windowHideOnClose :: AttrLabelProxy "hideOnClose"
windowHideOnClose = AttrLabelProxy

windowIconName :: AttrLabelProxy "iconName"
windowIconName = AttrLabelProxy

windowMaximized :: AttrLabelProxy "maximized"
windowMaximized = AttrLabelProxy

windowMnemonicsVisible :: AttrLabelProxy "mnemonicsVisible"
windowMnemonicsVisible = AttrLabelProxy

windowModal :: AttrLabelProxy "modal"
windowModal = AttrLabelProxy

windowResizable :: AttrLabelProxy "resizable"
windowResizable = AttrLabelProxy

windowStartupId :: AttrLabelProxy "startupId"
windowStartupId = AttrLabelProxy

windowTitle :: AttrLabelProxy "title"
windowTitle = AttrLabelProxy

windowTitlebar :: AttrLabelProxy "titlebar"
windowTitlebar = AttrLabelProxy

windowTransientFor :: AttrLabelProxy "transientFor"
windowTransientFor = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Window = WindowSignalList
type WindowSignalList = ('[ '("activateDefault", WindowActivateDefaultSignalInfo), '("activateFocus", WindowActivateFocusSignalInfo), '("closeRequest", WindowCloseRequestSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("enableDebugging", WindowEnableDebuggingSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("keysChanged", WindowKeysChangedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "gtk_window_new" gtk_window_new :: 
    IO (Ptr Window)

-- | Creates a new @GtkWindow@.
-- 
-- To get an undecorated window (no window borders), use
-- 'GI.Gtk.Objects.Window.windowSetDecorated'.
-- 
-- All top-level windows created by 'GI.Gtk.Objects.Window.windowNew' are stored
-- in an internal top-level window list. This list can be obtained
-- from [func/@gtk@/.Window.list_toplevels]. Due to GTK keeping a
-- reference to the window internally, 'GI.Gtk.Objects.Window.windowNew' does not
-- return a reference to the caller.
-- 
-- To delete a @GtkWindow@, call 'GI.Gtk.Objects.Window.windowDestroy'.
windowNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Window
    -- ^ __Returns:__ a new @GtkWindow@.
windowNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Window
windowNew  = IO Window -> m Window
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Window -> m Window) -> IO Window -> m Window
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
result <- IO (Ptr Window)
gtk_window_new
    Text -> Ptr Window -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"windowNew" Ptr Window
result
    Window
result' <- ((ManagedPtr Window -> Window) -> Ptr Window -> IO Window
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Window -> Window
Window) Ptr Window
result
    Window -> IO Window
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Window
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "gtk_window_close" gtk_window_close :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO ()

-- | Requests that the window is closed.
-- 
-- This is similar to what happens when a window manager
-- close button is clicked.
-- 
-- This function can be used with close buttons in custom
-- titlebars.
windowClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m ()
windowClose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m ()
windowClose a
window = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Window -> IO ()
gtk_window_close Ptr Window
window'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowCloseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowCloseMethodInfo a signature where
    overloadedMethod = windowClose

instance O.OverloadedMethodInfo WindowCloseMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowClose",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowClose"
        })


#endif

-- method Window::destroy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The window to destroy"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_destroy" gtk_window_destroy :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO ()

-- | Drop the internal reference GTK holds on toplevel windows.
windowDestroy ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: The window to destroy
    -> m ()
windowDestroy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m ()
windowDestroy a
window = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Window -> IO ()
gtk_window_destroy Ptr Window
window'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowDestroyMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowDestroyMethodInfo a signature where
    overloadedMethod = windowDestroy

instance O.OverloadedMethodInfo WindowDestroyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowDestroy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowDestroy"
        })


#endif

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

foreign import ccall "gtk_window_fullscreen" gtk_window_fullscreen :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO ()

-- | Asks to place /@window@/ in the fullscreen state.
-- 
-- Note that you shouldn’t assume the window is definitely fullscreen
-- afterward, because other entities (e.g. the user or window manager
-- unfullscreen it again, and not all window managers honor requests
-- to fullscreen windows.
-- 
-- You can track the result of this operation via the
-- t'GI.Gdk.Interfaces.Toplevel.Toplevel':@/state/@ property, or by listening to
-- notifications of the [Window:fullscreened]("GI.Gtk.Objects.Window#g:attr:fullscreened") property.
windowFullscreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m ()
windowFullscreen :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m ()
windowFullscreen a
window = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Window -> IO ()
gtk_window_fullscreen Ptr Window
window'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowFullscreenMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowFullscreenMethodInfo a signature where
    overloadedMethod = windowFullscreen

instance O.OverloadedMethodInfo WindowFullscreenMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowFullscreen",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowFullscreen"
        })


#endif

-- method Window::fullscreen_on_monitor
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "monitor"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Monitor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "which monitor to go fullscreen on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_fullscreen_on_monitor" gtk_window_fullscreen_on_monitor :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    Ptr Gdk.Monitor.Monitor ->              -- monitor : TInterface (Name {namespace = "Gdk", name = "Monitor"})
    IO ()

-- | Asks to place /@window@/ in the fullscreen state on the given /@monitor@/.
-- 
-- Note that you shouldn\'t assume the window is definitely fullscreen
-- afterward, or that the windowing system allows fullscreen windows on
-- any given monitor.
-- 
-- You can track the result of this operation via the
-- t'GI.Gdk.Interfaces.Toplevel.Toplevel':@/state/@ property, or by listening to
-- notifications of the [Window:fullscreened]("GI.Gtk.Objects.Window#g:attr:fullscreened") property.
windowFullscreenOnMonitor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Gdk.Monitor.IsMonitor b) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> b
    -- ^ /@monitor@/: which monitor to go fullscreen on
    -> m ()
windowFullscreenOnMonitor :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWindow a, IsMonitor b) =>
a -> b -> m ()
windowFullscreenOnMonitor a
window b
monitor = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Monitor
monitor' <- b -> IO (Ptr Monitor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
monitor
    Ptr Window -> Ptr Monitor -> IO ()
gtk_window_fullscreen_on_monitor Ptr Window
window' Ptr Monitor
monitor'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
monitor
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowFullscreenOnMonitorMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWindow a, Gdk.Monitor.IsMonitor b) => O.OverloadedMethod WindowFullscreenOnMonitorMethodInfo a signature where
    overloadedMethod = windowFullscreenOnMonitor

instance O.OverloadedMethodInfo WindowFullscreenOnMonitorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowFullscreenOnMonitor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowFullscreenOnMonitor"
        })


#endif

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

foreign import ccall "gtk_window_get_application" gtk_window_get_application :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO (Ptr Gtk.Application.Application)

-- | Gets the @GtkApplication@ associated with the window.
windowGetApplication ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m (Maybe Gtk.Application.Application)
    -- ^ __Returns:__ a @GtkApplication@
windowGetApplication :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m (Maybe Application)
windowGetApplication a
window = IO (Maybe Application) -> m (Maybe Application)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Application) -> m (Maybe Application))
-> IO (Maybe Application) -> m (Maybe Application)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Application
result <- Ptr Window -> IO (Ptr Application)
gtk_window_get_application Ptr Window
window'
    Maybe Application
maybeResult <- Ptr Application
-> (Ptr Application -> IO Application) -> IO (Maybe Application)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Application
result ((Ptr Application -> IO Application) -> IO (Maybe Application))
-> (Ptr Application -> IO Application) -> IO (Maybe Application)
forall a b. (a -> b) -> a -> b
$ \Ptr Application
result' -> do
        Application
result'' <- ((ManagedPtr Application -> Application)
-> Ptr Application -> IO Application
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Application -> Application
Gtk.Application.Application) Ptr Application
result'
        Application -> IO Application
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Application
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Maybe Application -> IO (Maybe Application)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Application
maybeResult

#if defined(ENABLE_OVERLOADING)
data WindowGetApplicationMethodInfo
instance (signature ~ (m (Maybe Gtk.Application.Application)), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetApplicationMethodInfo a signature where
    overloadedMethod = windowGetApplication

instance O.OverloadedMethodInfo WindowGetApplicationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetApplication",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetApplication"
        })


#endif

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

foreign import ccall "gtk_window_get_child" gtk_window_get_child :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO (Ptr Gtk.Widget.Widget)

-- | Gets the child widget of /@window@/.
windowGetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the child widget of /@window@/
windowGetChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m (Maybe Widget)
windowGetChild a
window = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Widget
result <- Ptr Window -> IO (Ptr Widget)
gtk_window_get_child Ptr Window
window'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

instance O.OverloadedMethodInfo WindowGetChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetChild"
        })


#endif

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

foreign import ccall "gtk_window_get_decorated" gtk_window_get_decorated :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CInt

-- | Returns whether the window has been set to have decorations.
windowGetDecorated ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the window has been set to have decorations
windowGetDecorated :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m Bool
windowGetDecorated a
window = WindowCloseRequestCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WindowCloseRequestCallback -> m Bool)
-> WindowCloseRequestCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CInt
result <- Ptr Window -> IO CInt
gtk_window_get_decorated Ptr Window
window'
    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
window
    WindowEnableDebuggingCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WindowGetDecoratedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetDecoratedMethodInfo a signature where
    overloadedMethod = windowGetDecorated

instance O.OverloadedMethodInfo WindowGetDecoratedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetDecorated",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetDecorated"
        })


#endif

-- method Window::get_default_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location to store the default width"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location to store the default height"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_get_default_size" gtk_window_get_default_size :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    Ptr Int32 ->                            -- width : TBasicType TInt
    Ptr Int32 ->                            -- height : TBasicType TInt
    IO ()

-- | Gets the default size of the window.
-- 
-- A value of 0 for the width or height indicates that a default
-- size has not been explicitly set for that dimension, so the
-- “natural” size of the window will be used.
windowGetDefaultSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m ((Int32, Int32))
windowGetDefaultSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m (Int32, Int32)
windowGetDefaultSize a
window = IO (Int32, Int32) -> m (Int32, Int32)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Int32
width <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
height <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Window -> Ptr Int32 -> Ptr Int32 -> IO ()
gtk_window_get_default_size Ptr Window
window' Ptr Int32
width Ptr Int32
height
    Int32
width' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
width
    Int32
height' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
height
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
width
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
height
    (Int32, Int32) -> IO (Int32, Int32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
width', Int32
height')

#if defined(ENABLE_OVERLOADING)
data WindowGetDefaultSizeMethodInfo
instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetDefaultSizeMethodInfo a signature where
    overloadedMethod = windowGetDefaultSize

instance O.OverloadedMethodInfo WindowGetDefaultSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetDefaultSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetDefaultSize"
        })


#endif

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

foreign import ccall "gtk_window_get_default_widget" gtk_window_get_default_widget :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO (Ptr Gtk.Widget.Widget)

-- | Returns the default widget for /@window@/.
windowGetDefaultWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the default widget
windowGetDefaultWidget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m (Maybe Widget)
windowGetDefaultWidget a
window = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Widget
result <- Ptr Window -> IO (Ptr Widget)
gtk_window_get_default_widget Ptr Window
window'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

instance O.OverloadedMethodInfo WindowGetDefaultWidgetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetDefaultWidget",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetDefaultWidget"
        })


#endif

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

foreign import ccall "gtk_window_get_deletable" gtk_window_get_deletable :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CInt

-- | Returns whether the window has been set to have a close button.
windowGetDeletable ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the window has been set to have a close button
windowGetDeletable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m Bool
windowGetDeletable a
window = WindowCloseRequestCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WindowCloseRequestCallback -> m Bool)
-> WindowCloseRequestCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CInt
result <- Ptr Window -> IO CInt
gtk_window_get_deletable Ptr Window
window'
    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
window
    WindowEnableDebuggingCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WindowGetDeletableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetDeletableMethodInfo a signature where
    overloadedMethod = windowGetDeletable

instance O.OverloadedMethodInfo WindowGetDeletableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetDeletable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetDeletable"
        })


#endif

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

foreign import ccall "gtk_window_get_destroy_with_parent" gtk_window_get_destroy_with_parent :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CInt

-- | Returns whether the window will be destroyed with its transient parent.
windowGetDestroyWithParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the window will be destroyed with its transient parent.
windowGetDestroyWithParent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m Bool
windowGetDestroyWithParent a
window = WindowCloseRequestCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WindowCloseRequestCallback -> m Bool)
-> WindowCloseRequestCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CInt
result <- Ptr Window -> IO CInt
gtk_window_get_destroy_with_parent Ptr Window
window'
    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
window
    WindowEnableDebuggingCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WindowGetDestroyWithParentMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetDestroyWithParentMethodInfo a signature where
    overloadedMethod = windowGetDestroyWithParent

instance O.OverloadedMethodInfo WindowGetDestroyWithParentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetDestroyWithParent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetDestroyWithParent"
        })


#endif

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

foreign import ccall "gtk_window_get_focus" gtk_window_get_focus :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO (Ptr Gtk.Widget.Widget)

-- | Retrieves the current focused widget within the window.
-- 
-- Note that this is the widget that would have the focus
-- if the toplevel window focused; if the toplevel window
-- is not focused then @gtk_widget_has_focus (widget)@ will
-- not be 'P.True' for the widget.
windowGetFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the currently focused widget
windowGetFocus :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m (Maybe Widget)
windowGetFocus a
window = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Widget
result <- Ptr Window -> IO (Ptr Widget)
gtk_window_get_focus Ptr Window
window'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

instance O.OverloadedMethodInfo WindowGetFocusMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetFocus",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetFocus"
        })


#endif

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

foreign import ccall "gtk_window_get_focus_visible" gtk_window_get_focus_visible :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CInt

-- | Gets whether “focus rectangles” are supposed to be visible.
windowGetFocusVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if “focus rectangles” are supposed to be visible
    --   in this window.
windowGetFocusVisible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m Bool
windowGetFocusVisible a
window = WindowCloseRequestCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WindowCloseRequestCallback -> m Bool)
-> WindowCloseRequestCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CInt
result <- Ptr Window -> IO CInt
gtk_window_get_focus_visible Ptr Window
window'
    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
window
    WindowEnableDebuggingCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WindowGetFocusVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetFocusVisibleMethodInfo a signature where
    overloadedMethod = windowGetFocusVisible

instance O.OverloadedMethodInfo WindowGetFocusVisibleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetFocusVisible",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetFocusVisible"
        })


#endif

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

foreign import ccall "gtk_window_get_group" gtk_window_get_group :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO (Ptr Gtk.WindowGroup.WindowGroup)

-- | Returns the group for /@window@/.
-- 
-- If the window has no group, then the default group is returned.
windowGetGroup ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m Gtk.WindowGroup.WindowGroup
    -- ^ __Returns:__ the @GtkWindowGroup@ for a window
    --   or the default group
windowGetGroup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m WindowGroup
windowGetGroup a
window = IO WindowGroup -> m WindowGroup
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WindowGroup -> m WindowGroup)
-> IO WindowGroup -> m WindowGroup
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr WindowGroup
result <- Ptr Window -> IO (Ptr WindowGroup)
gtk_window_get_group Ptr Window
window'
    Text -> Ptr WindowGroup -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"windowGetGroup" Ptr WindowGroup
result
    WindowGroup
result' <- ((ManagedPtr WindowGroup -> WindowGroup)
-> Ptr WindowGroup -> IO WindowGroup
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr WindowGroup -> WindowGroup
Gtk.WindowGroup.WindowGroup) Ptr WindowGroup
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    WindowGroup -> IO WindowGroup
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WindowGroup
result'

#if defined(ENABLE_OVERLOADING)
data WindowGetGroupMethodInfo
instance (signature ~ (m Gtk.WindowGroup.WindowGroup), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetGroupMethodInfo a signature where
    overloadedMethod = windowGetGroup

instance O.OverloadedMethodInfo WindowGetGroupMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetGroup",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetGroup"
        })


#endif

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

foreign import ccall "gtk_window_get_handle_menubar_accel" gtk_window_get_handle_menubar_accel :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CInt

-- | Returns whether this window reacts to F10 key presses by
-- activating a menubar it contains.
-- 
-- /Since: 4.2/
windowGetHandleMenubarAccel ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the window handles F10
windowGetHandleMenubarAccel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m Bool
windowGetHandleMenubarAccel a
window = WindowCloseRequestCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WindowCloseRequestCallback -> m Bool)
-> WindowCloseRequestCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CInt
result <- Ptr Window -> IO CInt
gtk_window_get_handle_menubar_accel Ptr Window
window'
    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
window
    WindowEnableDebuggingCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WindowGetHandleMenubarAccelMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetHandleMenubarAccelMethodInfo a signature where
    overloadedMethod = windowGetHandleMenubarAccel

instance O.OverloadedMethodInfo WindowGetHandleMenubarAccelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetHandleMenubarAccel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetHandleMenubarAccel"
        })


#endif

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

foreign import ccall "gtk_window_get_hide_on_close" gtk_window_get_hide_on_close :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CInt

-- | Returns whether the window will be hidden when the close button is clicked.
windowGetHideOnClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the window will be hidden
windowGetHideOnClose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m Bool
windowGetHideOnClose a
window = WindowCloseRequestCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WindowCloseRequestCallback -> m Bool)
-> WindowCloseRequestCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CInt
result <- Ptr Window -> IO CInt
gtk_window_get_hide_on_close Ptr Window
window'
    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
window
    WindowEnableDebuggingCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WindowGetHideOnCloseMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetHideOnCloseMethodInfo a signature where
    overloadedMethod = windowGetHideOnClose

instance O.OverloadedMethodInfo WindowGetHideOnCloseMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetHideOnClose",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetHideOnClose"
        })


#endif

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

foreign import ccall "gtk_window_get_icon_name" gtk_window_get_icon_name :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CString

-- | Returns the name of the themed icon for the window.
windowGetIconName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the icon name
windowGetIconName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m (Maybe Text)
windowGetIconName a
window = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CString
result <- Ptr Window -> IO CString
gtk_window_get_icon_name Ptr Window
window'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo WindowGetIconNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetIconName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetIconName"
        })


#endif

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

foreign import ccall "gtk_window_get_mnemonics_visible" gtk_window_get_mnemonics_visible :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CInt

-- | Gets whether mnemonics are supposed to be visible.
windowGetMnemonicsVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if mnemonics are supposed to be visible
    --   in this window.
windowGetMnemonicsVisible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m Bool
windowGetMnemonicsVisible a
window = WindowCloseRequestCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WindowCloseRequestCallback -> m Bool)
-> WindowCloseRequestCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CInt
result <- Ptr Window -> IO CInt
gtk_window_get_mnemonics_visible Ptr Window
window'
    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
window
    WindowEnableDebuggingCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WindowGetMnemonicsVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetMnemonicsVisibleMethodInfo a signature where
    overloadedMethod = windowGetMnemonicsVisible

instance O.OverloadedMethodInfo WindowGetMnemonicsVisibleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetMnemonicsVisible",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetMnemonicsVisible"
        })


#endif

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

foreign import ccall "gtk_window_get_modal" gtk_window_get_modal :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CInt

-- | Returns whether the window is modal.
windowGetModal ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the window is set to be modal and
    --   establishes a grab when shown
windowGetModal :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m Bool
windowGetModal a
window = WindowCloseRequestCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WindowCloseRequestCallback -> m Bool)
-> WindowCloseRequestCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CInt
result <- Ptr Window -> IO CInt
gtk_window_get_modal Ptr Window
window'
    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
window
    WindowEnableDebuggingCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WindowGetModalMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetModalMethodInfo a signature where
    overloadedMethod = windowGetModal

instance O.OverloadedMethodInfo WindowGetModalMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetModal",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetModal"
        })


#endif

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

foreign import ccall "gtk_window_get_resizable" gtk_window_get_resizable :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CInt

-- | Gets the value set by 'GI.Gtk.Objects.Window.windowSetResizable'.
windowGetResizable ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the user can resize the window
windowGetResizable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m Bool
windowGetResizable a
window = WindowCloseRequestCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WindowCloseRequestCallback -> m Bool)
-> WindowCloseRequestCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CInt
result <- Ptr Window -> IO CInt
gtk_window_get_resizable Ptr Window
window'
    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
window
    WindowEnableDebuggingCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WindowGetResizableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetResizableMethodInfo a signature where
    overloadedMethod = windowGetResizable

instance O.OverloadedMethodInfo WindowGetResizableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetResizable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetResizable"
        })


#endif

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

foreign import ccall "gtk_window_get_title" gtk_window_get_title :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CString

-- | Retrieves the title of the window.
windowGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the title of the window
windowGetTitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m (Maybe Text)
windowGetTitle a
window = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CString
result <- Ptr Window -> IO CString
gtk_window_get_title Ptr Window
window'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

instance O.OverloadedMethodInfo WindowGetTitleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetTitle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetTitle"
        })


#endif

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

foreign import ccall "gtk_window_get_titlebar" gtk_window_get_titlebar :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO (Ptr Gtk.Widget.Widget)

-- | Returns the custom titlebar that has been set with
-- 'GI.Gtk.Objects.Window.windowSetTitlebar'.
windowGetTitlebar ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the custom titlebar
windowGetTitlebar :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m (Maybe Widget)
windowGetTitlebar a
window = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Widget
result <- Ptr Window -> IO (Ptr Widget)
gtk_window_get_titlebar Ptr Window
window'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

instance O.OverloadedMethodInfo WindowGetTitlebarMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetTitlebar",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetTitlebar"
        })


#endif

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

foreign import ccall "gtk_window_get_transient_for" gtk_window_get_transient_for :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO (Ptr Window)

-- | Fetches the transient parent for this window.
windowGetTransientFor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m (Maybe Window)
    -- ^ __Returns:__ the transient parent for this window
windowGetTransientFor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m (Maybe Window)
windowGetTransientFor a
window = IO (Maybe Window) -> m (Maybe Window)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Window) -> m (Maybe Window))
-> IO (Maybe Window) -> m (Maybe Window)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Window
result <- Ptr Window -> IO (Ptr Window)
gtk_window_get_transient_for Ptr Window
window'
    Maybe Window
maybeResult <- Ptr Window -> (Ptr Window -> IO Window) -> IO (Maybe Window)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Window
result ((Ptr Window -> IO Window) -> IO (Maybe Window))
-> (Ptr Window -> IO Window) -> IO (Maybe Window)
forall a b. (a -> b) -> a -> b
$ \Ptr Window
result' -> do
        Window
result'' <- ((ManagedPtr Window -> Window) -> Ptr Window -> IO Window
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Window -> Window
Window) Ptr Window
result'
        Window -> IO Window
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Window
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Maybe Window -> IO (Maybe Window)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Window
maybeResult

#if defined(ENABLE_OVERLOADING)
data WindowGetTransientForMethodInfo
instance (signature ~ (m (Maybe Window)), MonadIO m, IsWindow a) => O.OverloadedMethod WindowGetTransientForMethodInfo a signature where
    overloadedMethod = windowGetTransientFor

instance O.OverloadedMethodInfo WindowGetTransientForMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowGetTransientFor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowGetTransientFor"
        })


#endif

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

foreign import ccall "gtk_window_has_group" gtk_window_has_group :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CInt

-- | Returns whether /@window@/ has an explicit window group.
windowHasGroup ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@window@/ has an explicit window group.
windowHasGroup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m Bool
windowHasGroup a
window = WindowCloseRequestCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WindowCloseRequestCallback -> m Bool)
-> WindowCloseRequestCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CInt
result <- Ptr Window -> IO CInt
gtk_window_has_group Ptr Window
window'
    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
window
    WindowEnableDebuggingCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WindowHasGroupMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowHasGroupMethodInfo a signature where
    overloadedMethod = windowHasGroup

instance O.OverloadedMethodInfo WindowHasGroupMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowHasGroup",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowHasGroup"
        })


#endif

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

foreign import ccall "gtk_window_is_active" gtk_window_is_active :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CInt

-- | Returns whether the window is part of the current active toplevel.
-- 
-- The active toplevel is the window receiving keystrokes.
-- 
-- The return value is 'P.True' if the window is active toplevel itself.
-- You might use this function if you wanted to draw a widget
-- differently in an active window from a widget in an inactive window.
windowIsActive ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the window part of the current active window.
windowIsActive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m Bool
windowIsActive a
window = WindowCloseRequestCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WindowCloseRequestCallback -> m Bool)
-> WindowCloseRequestCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CInt
result <- Ptr Window -> IO CInt
gtk_window_is_active Ptr Window
window'
    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
window
    WindowEnableDebuggingCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WindowIsActiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowIsActiveMethodInfo a signature where
    overloadedMethod = windowIsActive

instance O.OverloadedMethodInfo WindowIsActiveMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowIsActive",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowIsActive"
        })


#endif

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

foreign import ccall "gtk_window_is_fullscreen" gtk_window_is_fullscreen :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CInt

-- | Retrieves the current fullscreen state of /@window@/.
-- 
-- Note that since fullscreening is ultimately handled by the window
-- manager and happens asynchronously to an application request, you
-- shouldn’t assume the return value of this function changing
-- immediately (or at all), as an effect of calling
-- 'GI.Gtk.Objects.Window.windowFullscreen' or 'GI.Gtk.Objects.Window.windowUnfullscreen'.
-- 
-- If the window isn\'t yet mapped, the value returned will whether the
-- initial requested state is fullscreen.
windowIsFullscreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m Bool
    -- ^ __Returns:__ whether the window has a fullscreen state.
windowIsFullscreen :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m Bool
windowIsFullscreen a
window = WindowCloseRequestCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WindowCloseRequestCallback -> m Bool)
-> WindowCloseRequestCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CInt
result <- Ptr Window -> IO CInt
gtk_window_is_fullscreen Ptr Window
window'
    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
window
    WindowEnableDebuggingCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WindowIsFullscreenMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowIsFullscreenMethodInfo a signature where
    overloadedMethod = windowIsFullscreen

instance O.OverloadedMethodInfo WindowIsFullscreenMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowIsFullscreen",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowIsFullscreen"
        })


#endif

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

foreign import ccall "gtk_window_is_maximized" gtk_window_is_maximized :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO CInt

-- | Retrieves the current maximized state of /@window@/.
-- 
-- Note that since maximization is ultimately handled by the window
-- manager and happens asynchronously to an application request, you
-- shouldn’t assume the return value of this function changing
-- immediately (or at all), as an effect of calling
-- 'GI.Gtk.Objects.Window.windowMaximize' or 'GI.Gtk.Objects.Window.windowUnmaximize'.
-- 
-- If the window isn\'t yet mapped, the value returned will whether the
-- initial requested state is maximized.
windowIsMaximized ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m Bool
    -- ^ __Returns:__ whether the window has a maximized state.
windowIsMaximized :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m Bool
windowIsMaximized a
window = WindowCloseRequestCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (WindowCloseRequestCallback -> m Bool)
-> WindowCloseRequestCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CInt
result <- Ptr Window -> IO CInt
gtk_window_is_maximized Ptr Window
window'
    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
window
    WindowEnableDebuggingCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data WindowIsMaximizedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.OverloadedMethod WindowIsMaximizedMethodInfo a signature where
    overloadedMethod = windowIsMaximized

instance O.OverloadedMethodInfo WindowIsMaximizedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowIsMaximized",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowIsMaximized"
        })


#endif

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

foreign import ccall "gtk_window_maximize" gtk_window_maximize :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO ()

-- | Asks to maximize /@window@/, so that it fills the screen.
-- 
-- Note that you shouldn’t assume the window is definitely maximized
-- afterward, because other entities (e.g. the user or window manager
-- could unmaximize it again, and not all window managers support
-- maximization.
-- 
-- It’s permitted to call this function before showing a window,
-- in which case the window will be maximized when it appears onscreen
-- initially.
-- 
-- You can track the result of this operation via the
-- t'GI.Gdk.Interfaces.Toplevel.Toplevel':@/state/@ property, or by listening to
-- notifications on the [Window:maximized]("GI.Gtk.Objects.Window#g:attr:maximized")
-- property.
windowMaximize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m ()
windowMaximize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m ()
windowMaximize a
window = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Window -> IO ()
gtk_window_maximize Ptr Window
window'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowMaximizeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowMaximizeMethodInfo a signature where
    overloadedMethod = windowMaximize

instance O.OverloadedMethodInfo WindowMaximizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowMaximize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowMaximize"
        })


#endif

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

foreign import ccall "gtk_window_minimize" gtk_window_minimize :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO ()

-- | Asks to minimize the specified /@window@/.
-- 
-- Note that you shouldn’t assume the window is definitely minimized
-- afterward, because the windowing system might not support this
-- functionality; other entities (e.g. the user or the window manager
-- could unminimize it again, or there may not be a window manager in
-- which case minimization isn’t possible, etc.
-- 
-- It’s permitted to call this function before showing a window,
-- in which case the window will be minimized before it ever appears
-- onscreen.
-- 
-- You can track result of this operation via the
-- t'GI.Gdk.Interfaces.Toplevel.Toplevel':@/state/@ property.
windowMinimize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m ()
windowMinimize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m ()
windowMinimize a
window = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Window -> IO ()
gtk_window_minimize Ptr Window
window'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowMinimizeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowMinimizeMethodInfo a signature where
    overloadedMethod = windowMinimize

instance O.OverloadedMethodInfo WindowMinimizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowMinimize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowMinimize"
        })


#endif

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

foreign import ccall "gtk_window_present" gtk_window_present :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO ()

-- | Presents a window to the user.
-- 
-- This function should not be used as when it is called,
-- it is too late to gather a valid timestamp to allow focus
-- stealing prevention to work correctly.
windowPresent ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m ()
windowPresent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m ()
windowPresent a
window = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Window -> IO ()
gtk_window_present Ptr Window
window'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowPresentMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowPresentMethodInfo a signature where
    overloadedMethod = windowPresent

instance O.OverloadedMethodInfo WindowPresentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowPresent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowPresent"
        })


#endif

-- method Window::present_with_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "timestamp"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the timestamp of the user interaction (typically a\n  button or key press event) which triggered this call"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_present_with_time" gtk_window_present_with_time :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    Word32 ->                               -- timestamp : TBasicType TUInt32
    IO ()

-- | Presents a window to the user.
-- 
-- This may mean raising the window in the stacking order,
-- unminimizing it, moving it to the current desktop, and\/or
-- giving it the keyboard focus, possibly dependent on the user’s
-- platform, window manager, and preferences.
-- 
-- If /@window@/ is hidden, this function calls 'GI.Gtk.Objects.Widget.widgetShow'
-- as well.
-- 
-- This function should be used when the user tries to open a window
-- that’s already open. Say for example the preferences dialog is
-- currently open, and the user chooses Preferences from the menu
-- a second time; use 'GI.Gtk.Objects.Window.windowPresent' to move the
-- already-open dialog where the user can see it.
-- 
-- Presents a window to the user in response to a user interaction.
-- The timestamp should be gathered when the window was requested
-- to be shown (when clicking a link for example), rather than once
-- the window is ready to be shown.
windowPresentWithTime ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Word32
    -- ^ /@timestamp@/: the timestamp of the user interaction (typically a
    --   button or key press event) which triggered this call
    -> m ()
windowPresentWithTime :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> Word32 -> m ()
windowPresentWithTime a
window Word32
timestamp = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Window -> Word32 -> IO ()
gtk_window_present_with_time Ptr Window
window' Word32
timestamp
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowPresentWithTimeMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowPresentWithTimeMethodInfo a signature where
    overloadedMethod = windowPresentWithTime

instance O.OverloadedMethodInfo WindowPresentWithTimeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowPresentWithTime",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowPresentWithTime"
        })


#endif

-- method Window::set_application
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "application"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Application" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkApplication`, or %NULL to unset"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_application" gtk_window_set_application :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    Ptr Gtk.Application.Application ->      -- application : TInterface (Name {namespace = "Gtk", name = "Application"})
    IO ()

-- | Sets or unsets the @GtkApplication@ associated with the window.
-- 
-- The application will be kept alive for at least as long as it has
-- any windows associated with it (see 'GI.Gio.Objects.Application.applicationHold' for a way
-- to keep it alive without windows).
-- 
-- Normally, the connection between the application and the window will
-- remain until the window is destroyed, but you can explicitly remove
-- it by setting the /@application@/ to 'P.Nothing'.
-- 
-- This is equivalent to calling 'GI.Gtk.Objects.Application.applicationRemoveWindow'
-- and\/or 'GI.Gtk.Objects.Application.applicationAddWindow' on the old\/new applications
-- as relevant.
windowSetApplication ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Gtk.Application.IsApplication b) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Maybe (b)
    -- ^ /@application@/: a @GtkApplication@, or 'P.Nothing' to unset
    -> m ()
windowSetApplication :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWindow a, IsApplication b) =>
a -> Maybe b -> m ()
windowSetApplication a
window Maybe b
application = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Application
maybeApplication <- case Maybe b
application of
        Maybe b
Nothing -> Ptr Application -> IO (Ptr Application)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Application
forall a. Ptr a
nullPtr
        Just b
jApplication -> do
            Ptr Application
jApplication' <- b -> IO (Ptr Application)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jApplication
            Ptr Application -> IO (Ptr Application)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Application
jApplication'
    Ptr Window -> Ptr Application -> IO ()
gtk_window_set_application Ptr Window
window' Ptr Application
maybeApplication
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
application b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetApplicationMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsWindow a, Gtk.Application.IsApplication b) => O.OverloadedMethod WindowSetApplicationMethodInfo a signature where
    overloadedMethod = windowSetApplication

instance O.OverloadedMethodInfo WindowSetApplicationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetApplication",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetApplication"
        })


#endif

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

foreign import ccall "gtk_window_set_child" gtk_window_set_child :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the child widget of /@window@/.
windowSetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Maybe (b)
    -- ^ /@child@/: the child widget
    -> m ()
windowSetChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWindow a, IsWidget b) =>
a -> Maybe b -> m ()
windowSetChild a
window Maybe b
child = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Widget
maybeChild <- case Maybe b
child of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jChild -> do
            Ptr Widget
jChild' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jChild
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jChild'
    Ptr Window -> Ptr Widget -> IO ()
gtk_window_set_child Ptr Window
window' Ptr Widget
maybeChild
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
child b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo WindowSetChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetChild"
        })


#endif

-- method Window::set_decorated
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "setting"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to decorate the window"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_decorated" gtk_window_set_decorated :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

-- | Sets whether the window should be decorated.
-- 
-- By default, windows are decorated with a title bar, resize
-- controls, etc. Some window managers allow GTK to disable these
-- decorations, creating a borderless window. If you set the decorated
-- property to 'P.False' using this function, GTK will do its best to
-- convince the window manager not to decorate the window. Depending on
-- the system, this function may not have any effect when called on a
-- window that is already visible, so you should call it before calling
-- 'GI.Gtk.Objects.Widget.widgetShow'.
-- 
-- On Windows, this function always works, since there’s no window manager
-- policy involved.
windowSetDecorated ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Bool
    -- ^ /@setting@/: 'P.True' to decorate the window
    -> m ()
windowSetDecorated :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> Bool -> m ()
windowSetDecorated a
window Bool
setting = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    let setting' :: CInt
setting' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
setting
    Ptr Window -> CInt -> IO ()
gtk_window_set_decorated Ptr Window
window' CInt
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetDecoratedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetDecoratedMethodInfo a signature where
    overloadedMethod = windowSetDecorated

instance O.OverloadedMethodInfo WindowSetDecoratedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetDecorated",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetDecorated"
        })


#endif

-- method Window::set_default_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "width in pixels, or -1 to unset the default width"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "height in pixels, or -1 to unset the default height"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_default_size" gtk_window_set_default_size :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    Int32 ->                                -- width : TBasicType TInt
    Int32 ->                                -- height : TBasicType TInt
    IO ()

-- | Sets the default size of a window.
-- 
-- If the window’s “natural” size (its size request) is larger than
-- the default, the default will be ignored.
-- 
-- Unlike 'GI.Gtk.Objects.Widget.widgetSetSizeRequest', which sets a size
-- request for a widget and thus would keep users from shrinking
-- the window, this function only sets the initial size, just as
-- if the user had resized the window themselves. Users can still
-- shrink the window again as they normally would. Setting a default
-- size of -1 means to use the “natural” default size (the size request
-- of the window).
-- 
-- The default size of a window only affects the first time a window is
-- shown; if a window is hidden and re-shown, it will remember the size
-- it had prior to hiding, rather than using the default size.
-- 
-- Windows can’t actually be 0x0 in size, they must be at least 1x1, but
-- passing 0 for /@width@/ and /@height@/ is OK, resulting in a 1x1 default size.
-- 
-- If you use this function to reestablish a previously saved window size,
-- note that the appropriate size to save is the one returned by
-- 'GI.Gtk.Objects.Window.windowGetDefaultSize'. Using the window allocation
-- directly will not work in all circumstances and can lead to growing
-- or shrinking windows.
windowSetDefaultSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Int32
    -- ^ /@width@/: width in pixels, or -1 to unset the default width
    -> Int32
    -- ^ /@height@/: height in pixels, or -1 to unset the default height
    -> m ()
windowSetDefaultSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> Int32 -> Int32 -> m ()
windowSetDefaultSize a
window Int32
width Int32
height = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Window -> Int32 -> Int32 -> IO ()
gtk_window_set_default_size Ptr Window
window' Int32
width Int32
height
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetDefaultSizeMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetDefaultSizeMethodInfo a signature where
    overloadedMethod = windowSetDefaultSize

instance O.OverloadedMethodInfo WindowSetDefaultSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetDefaultSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetDefaultSize"
        })


#endif

-- method Window::set_default_widget
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "default_widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "widget to be the default\n  to unset the default widget for the toplevel"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_default_widget" gtk_window_set_default_widget :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    Ptr Gtk.Widget.Widget ->                -- default_widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the default widget.
-- 
-- The default widget is the widget that is activated when the user
-- presses Enter in a dialog (for example).
windowSetDefaultWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Maybe (b)
    -- ^ /@defaultWidget@/: widget to be the default
    --   to unset the default widget for the toplevel
    -> m ()
windowSetDefaultWidget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWindow a, IsWidget b) =>
a -> Maybe b -> m ()
windowSetDefaultWidget a
window Maybe b
defaultWidget = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Widget
maybeDefaultWidget <- case Maybe b
defaultWidget of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jDefaultWidget -> do
            Ptr Widget
jDefaultWidget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jDefaultWidget
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jDefaultWidget'
    Ptr Window -> Ptr Widget -> IO ()
gtk_window_set_default_widget Ptr Window
window' Ptr Widget
maybeDefaultWidget
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
defaultWidget b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo WindowSetDefaultWidgetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetDefaultWidget",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetDefaultWidget"
        })


#endif

-- method Window::set_deletable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "setting"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to decorate the window as deletable"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_deletable" gtk_window_set_deletable :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

-- | Sets whether the window should be deletable.
-- 
-- By default, windows have a close button in the window frame.
-- Some  window managers allow GTK to disable this button. If you
-- set the deletable property to 'P.False' using this function, GTK
-- will do its best to convince the window manager not to show a
-- close button. Depending on the system, this function may not
-- have any effect when called on a window that is already visible,
-- so you should call it before calling 'GI.Gtk.Objects.Widget.widgetShow'.
-- 
-- On Windows, this function always works, since there’s no window
-- manager policy involved.
windowSetDeletable ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Bool
    -- ^ /@setting@/: 'P.True' to decorate the window as deletable
    -> m ()
windowSetDeletable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> Bool -> m ()
windowSetDeletable a
window Bool
setting = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    let setting' :: CInt
setting' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
setting
    Ptr Window -> CInt -> IO ()
gtk_window_set_deletable Ptr Window
window' CInt
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetDeletableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetDeletableMethodInfo a signature where
    overloadedMethod = windowSetDeletable

instance O.OverloadedMethodInfo WindowSetDeletableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetDeletable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetDeletable"
        })


#endif

-- method Window::set_destroy_with_parent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "setting"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether to destroy @window with its transient parent"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_destroy_with_parent" gtk_window_set_destroy_with_parent :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

-- | If /@setting@/ is 'P.True', then destroying the transient parent of /@window@/
-- will also destroy /@window@/ itself.
-- 
-- This is useful for dialogs that shouldn’t persist beyond the lifetime
-- of the main window they are associated with, for example.
windowSetDestroyWithParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Bool
    -- ^ /@setting@/: whether to destroy /@window@/ with its transient parent
    -> m ()
windowSetDestroyWithParent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> Bool -> m ()
windowSetDestroyWithParent a
window Bool
setting = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    let setting' :: CInt
setting' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
setting
    Ptr Window -> CInt -> IO ()
gtk_window_set_destroy_with_parent Ptr Window
window' CInt
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetDestroyWithParentMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetDestroyWithParentMethodInfo a signature where
    overloadedMethod = windowSetDestroyWithParent

instance O.OverloadedMethodInfo WindowSetDestroyWithParentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetDestroyWithParent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetDestroyWithParent"
        })


#endif

-- method Window::set_display
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "display"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Display" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GdkDisplay`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_display" gtk_window_set_display :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    Ptr Gdk.Display.Display ->              -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    IO ()

-- | Sets the @GdkDisplay@ where the /@window@/ is displayed.
-- 
-- If the window is already mapped, it will be unmapped,
-- and then remapped on the new display.
windowSetDisplay ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Gdk.Display.IsDisplay b) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> b
    -- ^ /@display@/: a @GdkDisplay@
    -> m ()
windowSetDisplay :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWindow a, IsDisplay b) =>
a -> b -> m ()
windowSetDisplay a
window b
display = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Display
display' <- b -> IO (Ptr Display)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
display
    Ptr Window -> Ptr Display -> IO ()
gtk_window_set_display Ptr Window
window' Ptr Display
display'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
display
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetDisplayMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWindow a, Gdk.Display.IsDisplay b) => O.OverloadedMethod WindowSetDisplayMethodInfo a signature where
    overloadedMethod = windowSetDisplay

instance O.OverloadedMethodInfo WindowSetDisplayMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetDisplay",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetDisplay"
        })


#endif

-- method Window::set_focus
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "focus"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "widget to be the new focus widget, or %NULL to unset\n  any focus widget for the toplevel window."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_focus" gtk_window_set_focus :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    Ptr Gtk.Widget.Widget ->                -- focus : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the focus widget.
-- 
-- If /@focus@/ is not the current focus widget, and is focusable,
-- sets it as the focus widget for the window. If /@focus@/ is 'P.Nothing',
-- unsets the focus widget for this window. To set the focus to a
-- particular widget in the toplevel, it is usually more convenient
-- to use 'GI.Gtk.Objects.Widget.widgetGrabFocus' instead of this function.
windowSetFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Maybe (b)
    -- ^ /@focus@/: widget to be the new focus widget, or 'P.Nothing' to unset
    --   any focus widget for the toplevel window.
    -> m ()
windowSetFocus :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWindow a, IsWidget b) =>
a -> Maybe b -> m ()
windowSetFocus a
window Maybe b
focus = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Widget
maybeFocus <- case Maybe b
focus of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jFocus -> do
            Ptr Widget
jFocus' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jFocus
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jFocus'
    Ptr Window -> Ptr Widget -> IO ()
gtk_window_set_focus Ptr Window
window' Ptr Widget
maybeFocus
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
focus b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo WindowSetFocusMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetFocus",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetFocus"
        })


#endif

-- method Window::set_focus_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "setting"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_focus_visible" gtk_window_set_focus_visible :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

-- | Sets whether “focus rectangles” are supposed to be visible.
windowSetFocusVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Bool
    -- ^ /@setting@/: the new value
    -> m ()
windowSetFocusVisible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> Bool -> m ()
windowSetFocusVisible a
window Bool
setting = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    let setting' :: CInt
setting' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
setting
    Ptr Window -> CInt -> IO ()
gtk_window_set_focus_visible Ptr Window
window' CInt
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetFocusVisibleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetFocusVisibleMethodInfo a signature where
    overloadedMethod = windowSetFocusVisible

instance O.OverloadedMethodInfo WindowSetFocusVisibleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetFocusVisible",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetFocusVisible"
        })


#endif

-- method Window::set_handle_menubar_accel
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "handle_menubar_accel"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to make @window handle F10"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_handle_menubar_accel" gtk_window_set_handle_menubar_accel :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    CInt ->                                 -- handle_menubar_accel : TBasicType TBoolean
    IO ()

-- | Sets whether this window should react to F10 key presses
-- by activating a menubar it contains.
-- 
-- /Since: 4.2/
windowSetHandleMenubarAccel ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Bool
    -- ^ /@handleMenubarAccel@/: 'P.True' to make /@window@/ handle F10
    -> m ()
windowSetHandleMenubarAccel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> Bool -> m ()
windowSetHandleMenubarAccel a
window Bool
handleMenubarAccel = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    let handleMenubarAccel' :: CInt
handleMenubarAccel' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
handleMenubarAccel
    Ptr Window -> CInt -> IO ()
gtk_window_set_handle_menubar_accel Ptr Window
window' CInt
handleMenubarAccel'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetHandleMenubarAccelMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetHandleMenubarAccelMethodInfo a signature where
    overloadedMethod = windowSetHandleMenubarAccel

instance O.OverloadedMethodInfo WindowSetHandleMenubarAccelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetHandleMenubarAccel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetHandleMenubarAccel"
        })


#endif

-- method Window::set_hide_on_close
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "setting"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to hide the window when it is closed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_hide_on_close" gtk_window_set_hide_on_close :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

-- | If /@setting@/ is 'P.True', then clicking the close button on the window
-- will not destroy it, but only hide it.
windowSetHideOnClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Bool
    -- ^ /@setting@/: whether to hide the window when it is closed
    -> m ()
windowSetHideOnClose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> Bool -> m ()
windowSetHideOnClose a
window Bool
setting = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    let setting' :: CInt
setting' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
setting
    Ptr Window -> CInt -> IO ()
gtk_window_set_hide_on_close Ptr Window
window' CInt
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetHideOnCloseMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetHideOnCloseMethodInfo a signature where
    overloadedMethod = windowSetHideOnClose

instance O.OverloadedMethodInfo WindowSetHideOnCloseMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetHideOnClose",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetHideOnClose"
        })


#endif

-- method Window::set_icon_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the themed icon"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_icon_name" gtk_window_set_icon_name :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Sets the icon for the window from a named themed icon.
-- 
-- See the docs for t'GI.Gtk.Objects.IconTheme.IconTheme' for more details.
-- On some platforms, the window icon is not used at all.
-- 
-- Note that this has nothing to do with the WM_ICON_NAME
-- property which is mentioned in the ICCCM.
windowSetIconName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Maybe (T.Text)
    -- ^ /@name@/: the name of the themed icon
    -> m ()
windowSetIconName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> Maybe Text -> m ()
windowSetIconName a
window Maybe Text
name = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CString
maybeName <- case Maybe Text
name of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jName -> do
            CString
jName' <- Text -> IO CString
textToCString Text
jName
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jName'
    Ptr Window -> CString -> IO ()
gtk_window_set_icon_name Ptr Window
window' CString
maybeName
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeName
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetIconNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetIconNameMethodInfo a signature where
    overloadedMethod = windowSetIconName

instance O.OverloadedMethodInfo WindowSetIconNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetIconName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetIconName"
        })


#endif

-- method Window::set_mnemonics_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "setting"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_mnemonics_visible" gtk_window_set_mnemonics_visible :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

-- | Sets whether mnemonics are supposed to be visible.
windowSetMnemonicsVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Bool
    -- ^ /@setting@/: the new value
    -> m ()
windowSetMnemonicsVisible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> Bool -> m ()
windowSetMnemonicsVisible a
window Bool
setting = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    let setting' :: CInt
setting' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
setting
    Ptr Window -> CInt -> IO ()
gtk_window_set_mnemonics_visible Ptr Window
window' CInt
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetMnemonicsVisibleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetMnemonicsVisibleMethodInfo a signature where
    overloadedMethod = windowSetMnemonicsVisible

instance O.OverloadedMethodInfo WindowSetMnemonicsVisibleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetMnemonicsVisible",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetMnemonicsVisible"
        })


#endif

-- method Window::set_modal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modal"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the window is modal"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_modal" gtk_window_set_modal :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    CInt ->                                 -- modal : TBasicType TBoolean
    IO ()

-- | Sets a window modal or non-modal.
-- 
-- Modal windows prevent interaction with other windows in the same
-- application. To keep modal dialogs on top of main application windows,
-- use 'GI.Gtk.Objects.Window.windowSetTransientFor' to make the dialog transient
-- for the parent; most window managers will then disallow lowering the
-- dialog below the parent.
windowSetModal ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Bool
    -- ^ /@modal@/: whether the window is modal
    -> m ()
windowSetModal :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> Bool -> m ()
windowSetModal a
window Bool
modal = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    let modal' :: CInt
modal' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
modal
    Ptr Window -> CInt -> IO ()
gtk_window_set_modal Ptr Window
window' CInt
modal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetModalMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetModalMethodInfo a signature where
    overloadedMethod = windowSetModal

instance O.OverloadedMethodInfo WindowSetModalMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetModal",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetModal"
        })


#endif

-- method Window::set_resizable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "resizable"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if the user can resize this window"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_resizable" gtk_window_set_resizable :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    CInt ->                                 -- resizable : TBasicType TBoolean
    IO ()

-- | Sets whether the user can resize a window.
-- 
-- Windows are user resizable by default.
windowSetResizable ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Bool
    -- ^ /@resizable@/: 'P.True' if the user can resize this window
    -> m ()
windowSetResizable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> Bool -> m ()
windowSetResizable a
window Bool
resizable = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    let resizable' :: CInt
resizable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
resizable
    Ptr Window -> CInt -> IO ()
gtk_window_set_resizable Ptr Window
window' CInt
resizable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetResizableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetResizableMethodInfo a signature where
    overloadedMethod = windowSetResizable

instance O.OverloadedMethodInfo WindowSetResizableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetResizable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetResizable"
        })


#endif

-- method Window::set_startup_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "startup_id"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string with startup-notification identifier"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_startup_id" gtk_window_set_startup_id :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    CString ->                              -- startup_id : TBasicType TUTF8
    IO ()

-- | Sets the startup notification ID.
-- 
-- Startup notification identifiers are used by desktop environment
-- to track application startup, to provide user feedback and other
-- features. This function changes the corresponding property on the
-- underlying @GdkSurface@.
-- 
-- Normally, startup identifier is managed automatically and you should
-- only use this function in special cases like transferring focus from
-- other processes. You should use this function before calling
-- 'GI.Gtk.Objects.Window.windowPresent' or any equivalent function generating
-- a window map event.
-- 
-- This function is only useful on X11, not with other GTK targets.
windowSetStartupId ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> T.Text
    -- ^ /@startupId@/: a string with startup-notification identifier
    -> m ()
windowSetStartupId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> Text -> m ()
windowSetStartupId a
window Text
startupId = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CString
startupId' <- Text -> IO CString
textToCString Text
startupId
    Ptr Window -> CString -> IO ()
gtk_window_set_startup_id Ptr Window
window' CString
startupId'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
startupId'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo WindowSetStartupIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetStartupId",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetStartupId"
        })


#endif

-- method Window::set_title
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "title"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "title of the window"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_title" gtk_window_set_title :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    CString ->                              -- title : TBasicType TUTF8
    IO ()

-- | Sets the title of the @GtkWindow@.
-- 
-- The title of a window will be displayed in its title bar; on the
-- X Window System, the title bar is rendered by the window manager
-- so exactly how the title appears to users may vary according to a
-- user’s exact configuration. The title should help a user distinguish
-- this window from other windows they may have open. A good title might
-- include the application name and current document filename, for example.
-- 
-- Passing 'P.Nothing' does the same as setting the title to an empty string.
windowSetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Maybe (T.Text)
    -- ^ /@title@/: title of the window
    -> m ()
windowSetTitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> Maybe Text -> m ()
windowSetTitle a
window Maybe Text
title = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    CString
maybeTitle <- case Maybe Text
title of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jTitle -> do
            CString
jTitle' <- Text -> IO CString
textToCString Text
jTitle
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jTitle'
    Ptr Window -> CString -> IO ()
gtk_window_set_title Ptr Window
window' CString
maybeTitle
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeTitle
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetTitleMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowSetTitleMethodInfo a signature where
    overloadedMethod = windowSetTitle

instance O.OverloadedMethodInfo WindowSetTitleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetTitle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetTitle"
        })


#endif

-- method Window::set_titlebar
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "titlebar"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the widget to use as titlebar"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_titlebar" gtk_window_set_titlebar :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    Ptr Gtk.Widget.Widget ->                -- titlebar : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets a custom titlebar for /@window@/.
-- 
-- A typical widget used here is t'GI.Gtk.Objects.HeaderBar.HeaderBar', as it
-- provides various features expected of a titlebar while allowing
-- the addition of child widgets to it.
-- 
-- If you set a custom titlebar, GTK will do its best to convince
-- the window manager not to put its own titlebar on the window.
-- Depending on the system, this function may not work for a window
-- that is already visible, so you set the titlebar before calling
-- 'GI.Gtk.Objects.Widget.widgetShow'.
windowSetTitlebar ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Maybe (b)
    -- ^ /@titlebar@/: the widget to use as titlebar
    -> m ()
windowSetTitlebar :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWindow a, IsWidget b) =>
a -> Maybe b -> m ()
windowSetTitlebar a
window Maybe b
titlebar = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Widget
maybeTitlebar <- case Maybe b
titlebar of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jTitlebar -> do
            Ptr Widget
jTitlebar' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jTitlebar
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jTitlebar'
    Ptr Window -> Ptr Widget -> IO ()
gtk_window_set_titlebar Ptr Window
window' Ptr Widget
maybeTitlebar
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
titlebar b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo WindowSetTitlebarMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetTitlebar",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetTitlebar"
        })


#endif

-- method Window::set_transient_for
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "window"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkWindow`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parent"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "parent window" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_transient_for" gtk_window_set_transient_for :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    Ptr Window ->                           -- parent : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO ()

-- | Dialog windows should be set transient for the main application
-- window they were spawned from. This allows window managers to e.g.
-- keep the dialog on top of the main window, or center the dialog
-- over the main window. t'GI.Gtk.Objects.Dialog.Dialog'.@/new_with_buttons/@() and other
-- convenience functions in GTK will sometimes call
-- 'GI.Gtk.Objects.Window.windowSetTransientFor' on your behalf.
-- 
-- Passing 'P.Nothing' for /@parent@/ unsets the current transient window.
-- 
-- On Windows, this function puts the child window on top of the parent,
-- much as the window manager would have done on X.
windowSetTransientFor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, IsWindow b) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> Maybe (b)
    -- ^ /@parent@/: parent window
    -> m ()
windowSetTransientFor :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWindow a, IsWindow b) =>
a -> Maybe b -> m ()
windowSetTransientFor a
window Maybe b
parent = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Window
maybeParent <- case Maybe b
parent of
        Maybe b
Nothing -> Ptr Window -> IO (Ptr Window)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Window
forall a. Ptr a
nullPtr
        Just b
jParent -> do
            Ptr Window
jParent' <- b -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jParent
            Ptr Window -> IO (Ptr Window)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Window
jParent'
    Ptr Window -> Ptr Window -> IO ()
gtk_window_set_transient_for Ptr Window
window' Ptr Window
maybeParent
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
parent b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowSetTransientForMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsWindow a, IsWindow b) => O.OverloadedMethod WindowSetTransientForMethodInfo a signature where
    overloadedMethod = windowSetTransientFor

instance O.OverloadedMethodInfo WindowSetTransientForMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowSetTransientFor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowSetTransientFor"
        })


#endif

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

foreign import ccall "gtk_window_unfullscreen" gtk_window_unfullscreen :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO ()

-- | Asks to remove the fullscreen state for /@window@/, and return to
-- its previous state.
-- 
-- Note that you shouldn’t assume the window is definitely not
-- fullscreen afterward, because other entities (e.g. the user or
-- window manager could fullscreen it again, and not all window
-- managers honor requests to unfullscreen windows; normally the
-- window will end up restored to its normal state. Just don’t
-- write code that crashes if not.
-- 
-- You can track the result of this operation via the
-- t'GI.Gdk.Interfaces.Toplevel.Toplevel':@/state/@ property, or by listening to
-- notifications of the [Window:fullscreened]("GI.Gtk.Objects.Window#g:attr:fullscreened") property.
windowUnfullscreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m ()
windowUnfullscreen :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m ()
windowUnfullscreen a
window = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Window -> IO ()
gtk_window_unfullscreen Ptr Window
window'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowUnfullscreenMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowUnfullscreenMethodInfo a signature where
    overloadedMethod = windowUnfullscreen

instance O.OverloadedMethodInfo WindowUnfullscreenMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowUnfullscreen",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowUnfullscreen"
        })


#endif

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

foreign import ccall "gtk_window_unmaximize" gtk_window_unmaximize :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO ()

-- | Asks to unmaximize /@window@/.
-- 
-- Note that you shouldn’t assume the window is definitely unmaximized
-- afterward, because other entities (e.g. the user or window manager
-- maximize it again, and not all window managers honor requests to
-- unmaximize.
-- 
-- You can track the result of this operation via the
-- t'GI.Gdk.Interfaces.Toplevel.Toplevel':@/state/@ property, or by listening to
-- notifications on the [Window:maximized]("GI.Gtk.Objects.Window#g:attr:maximized") property.
windowUnmaximize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m ()
windowUnmaximize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m ()
windowUnmaximize a
window = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Window -> IO ()
gtk_window_unmaximize Ptr Window
window'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowUnmaximizeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowUnmaximizeMethodInfo a signature where
    overloadedMethod = windowUnmaximize

instance O.OverloadedMethodInfo WindowUnmaximizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowUnmaximize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowUnmaximize"
        })


#endif

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

foreign import ccall "gtk_window_unminimize" gtk_window_unminimize :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO ()

-- | Asks to unminimize the specified /@window@/.
-- 
-- Note that you shouldn’t assume the window is definitely unminimized
-- afterward, because the windowing system might not support this
-- functionality; other entities (e.g. the user or the window manager
-- could minimize it again, or there may not be a window manager in
-- which case minimization isn’t possible, etc.
-- 
-- You can track result of this operation via the
-- t'GI.Gdk.Interfaces.Toplevel.Toplevel':@/state/@ property.
windowUnminimize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    -- ^ /@window@/: a @GtkWindow@
    -> m ()
windowUnminimize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
a -> m ()
windowUnminimize a
window = 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 Window
window' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
    Ptr Window -> IO ()
gtk_window_unminimize Ptr Window
window'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WindowUnminimizeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.OverloadedMethod WindowUnminimizeMethodInfo a signature where
    overloadedMethod = windowUnminimize

instance O.OverloadedMethodInfo WindowUnminimizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Window.windowUnminimize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Window.html#v:windowUnminimize"
        })


#endif

-- method Window::get_default_icon_name
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_get_default_icon_name" gtk_window_get_default_icon_name :: 
    IO CString

-- | Returns the fallback icon name for windows.
-- 
-- The returned string is owned by GTK and should not
-- be modified. It is only valid until the next call to
-- [func/@gtk@/.Window.set_default_icon_name].
windowGetDefaultIconName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m (Maybe T.Text)
    -- ^ __Returns:__ the fallback icon name for windows
windowGetDefaultIconName :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m (Maybe Text)
windowGetDefaultIconName  = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    CString
result <- IO CString
gtk_window_get_default_icon_name
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

-- method Window::get_toplevels
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "ListModel" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_get_toplevels" gtk_window_get_toplevels :: 
    IO (Ptr Gio.ListModel.ListModel)

-- | Returns a list of all existing toplevel windows.
-- 
-- If you want to iterate through the list and perform actions involving
-- callbacks that might destroy the widgets or add new ones, be aware that
-- the list of toplevels will change and emit the \"items-changed\" signal.
windowGetToplevels ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Gio.ListModel.ListModel
    -- ^ __Returns:__ the list
    --   of toplevel widgets
windowGetToplevels :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ListModel
windowGetToplevels  = IO ListModel -> m ListModel
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ListModel -> m ListModel) -> IO ListModel -> m ListModel
forall a b. (a -> b) -> a -> b
$ do
    Ptr ListModel
result <- IO (Ptr ListModel)
gtk_window_get_toplevels
    Text -> Ptr ListModel -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"windowGetToplevels" Ptr ListModel
result
    ListModel
result' <- ((ManagedPtr ListModel -> ListModel)
-> Ptr ListModel -> IO ListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListModel -> ListModel
Gio.ListModel.ListModel) Ptr ListModel
result
    ListModel -> IO ListModel
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ListModel
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Window::list_toplevels
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TGList (TInterface Name { namespace = "Gtk" , name = "Widget" }))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_list_toplevels" gtk_window_list_toplevels :: 
    IO (Ptr (GList (Ptr Gtk.Widget.Widget)))

-- | Returns a list of all existing toplevel windows.
-- 
-- The widgets in the list are not individually referenced.
-- If you want to iterate through the list and perform actions
-- involving callbacks that might destroy the widgets, you must
-- call @g_list_foreach (result, (GFunc)g_object_ref, NULL)@ first,
-- and then unref all the widgets afterwards.
windowListToplevels ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m [Gtk.Widget.Widget]
    -- ^ __Returns:__ list of
    --   toplevel widgets
windowListToplevels :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m [Widget]
windowListToplevels  = IO [Widget] -> m [Widget]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Widget] -> m [Widget]) -> IO [Widget] -> m [Widget]
forall a b. (a -> b) -> a -> b
$ do
    Ptr (GList (Ptr Widget))
result <- IO (Ptr (GList (Ptr Widget)))
gtk_window_list_toplevels
    [Ptr Widget]
result' <- Ptr (GList (Ptr Widget)) -> IO [Ptr Widget]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Widget))
result
    [Widget]
result'' <- (Ptr Widget -> IO Widget) -> [Ptr Widget] -> IO [Widget]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) [Ptr Widget]
result'
    Ptr (GList (Ptr Widget)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Widget))
result
    [Widget] -> IO [Widget]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Widget]
result''

#if defined(ENABLE_OVERLOADING)
#endif

-- method Window::set_auto_startup_notification
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "setting"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE to automatically do startup notification"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_auto_startup_notification" gtk_window_set_auto_startup_notification :: 
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

-- | Sets whether the window should request startup notification.
-- 
-- By default, after showing the first @GtkWindow@, GTK calls
-- 'GI.Gdk.Objects.Display.displayNotifyStartupComplete'. Call this function
-- to disable the automatic startup notification. You might do this
-- if your first window is a splash screen, and you want to delay
-- notification until after your real main window has been shown,
-- for example.
-- 
-- In that example, you would disable startup notification
-- temporarily, show your splash screen, then re-enable it so that
-- showing the main window would automatically result in notification.
windowSetAutoStartupNotification ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Bool
    -- ^ /@setting@/: 'P.True' to automatically do startup notification
    -> m ()
windowSetAutoStartupNotification :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Bool -> m ()
windowSetAutoStartupNotification Bool
setting = 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
    let setting' :: CInt
setting' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
setting
    CInt -> IO ()
gtk_window_set_auto_startup_notification CInt
setting'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
#endif

-- method Window::set_default_icon_name
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the themed icon"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_default_icon_name" gtk_window_set_default_icon_name :: 
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Sets an icon to be used as fallback.
-- 
-- The fallback icon is used for windows that
-- haven\'t had 'GI.Gtk.Objects.Window.windowSetIconName'
-- called on them.
windowSetDefaultIconName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@name@/: the name of the themed icon
    -> m ()
windowSetDefaultIconName :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m ()
windowSetDefaultIconName Text
name = 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
    CString
name' <- Text -> IO CString
textToCString Text
name
    CString -> IO ()
gtk_window_set_default_icon_name CString
name'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
#endif

-- method Window::set_interactive_debugging
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "enable"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to enable interactive debugging"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_window_set_interactive_debugging" gtk_window_set_interactive_debugging :: 
    CInt ->                                 -- enable : TBasicType TBoolean
    IO ()

-- | Opens or closes the <https://docs.gtk.org/gtk4/running.html#interactive-debugging interactive debugger>.
-- 
-- The debugger offers access to the widget hierarchy of the application
-- and to useful debugging tools.
windowSetInteractiveDebugging ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Bool
    -- ^ /@enable@/: 'P.True' to enable interactive debugging
    -> m ()
windowSetInteractiveDebugging :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Bool -> m ()
windowSetInteractiveDebugging Bool
enable = 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
    let enable' :: CInt
enable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
enable
    CInt -> IO ()
gtk_window_set_interactive_debugging CInt
enable'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
#endif