gi-wnck-3.0.3: GI/Wnck/Objects/Window.hs

{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

The 'GI.Wnck.Objects.Window.Window' struct contains only private fields and should not be
directly accessed.
-}

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

module GI.Wnck.Objects.Window
    ( 

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


 -- * Methods
-- ** activate #method:activate#

#if ENABLE_OVERLOADING
    WindowActivateMethodInfo                ,
#endif
    windowActivate                          ,


-- ** activateTransient #method:activateTransient#

#if ENABLE_OVERLOADING
    WindowActivateTransientMethodInfo       ,
#endif
    windowActivateTransient                 ,


-- ** close #method:close#

#if ENABLE_OVERLOADING
    WindowCloseMethodInfo                   ,
#endif
    windowClose                             ,


-- ** get #method:get#

    windowGet                               ,


-- ** getActions #method:getActions#

#if ENABLE_OVERLOADING
    WindowGetActionsMethodInfo              ,
#endif
    windowGetActions                        ,


-- ** getApplication #method:getApplication#

#if ENABLE_OVERLOADING
    WindowGetApplicationMethodInfo          ,
#endif
    windowGetApplication                    ,


-- ** getClassGroup #method:getClassGroup#

#if ENABLE_OVERLOADING
    WindowGetClassGroupMethodInfo           ,
#endif
    windowGetClassGroup                     ,


-- ** getClassGroupName #method:getClassGroupName#

#if ENABLE_OVERLOADING
    WindowGetClassGroupNameMethodInfo       ,
#endif
    windowGetClassGroupName                 ,


-- ** getClassInstanceName #method:getClassInstanceName#

#if ENABLE_OVERLOADING
    WindowGetClassInstanceNameMethodInfo    ,
#endif
    windowGetClassInstanceName              ,


-- ** getClientWindowGeometry #method:getClientWindowGeometry#

#if ENABLE_OVERLOADING
    WindowGetClientWindowGeometryMethodInfo ,
#endif
    windowGetClientWindowGeometry           ,


-- ** getGeometry #method:getGeometry#

#if ENABLE_OVERLOADING
    WindowGetGeometryMethodInfo             ,
#endif
    windowGetGeometry                       ,


-- ** getGroupLeader #method:getGroupLeader#

#if ENABLE_OVERLOADING
    WindowGetGroupLeaderMethodInfo          ,
#endif
    windowGetGroupLeader                    ,


-- ** getIcon #method:getIcon#

#if ENABLE_OVERLOADING
    WindowGetIconMethodInfo                 ,
#endif
    windowGetIcon                           ,


-- ** getIconIsFallback #method:getIconIsFallback#

#if ENABLE_OVERLOADING
    WindowGetIconIsFallbackMethodInfo       ,
#endif
    windowGetIconIsFallback                 ,


-- ** getIconName #method:getIconName#

#if ENABLE_OVERLOADING
    WindowGetIconNameMethodInfo             ,
#endif
    windowGetIconName                       ,


-- ** getMiniIcon #method:getMiniIcon#

#if ENABLE_OVERLOADING
    WindowGetMiniIconMethodInfo             ,
#endif
    windowGetMiniIcon                       ,


-- ** getName #method:getName#

#if ENABLE_OVERLOADING
    WindowGetNameMethodInfo                 ,
#endif
    windowGetName                           ,


-- ** getPid #method:getPid#

#if ENABLE_OVERLOADING
    WindowGetPidMethodInfo                  ,
#endif
    windowGetPid                            ,


-- ** getRole #method:getRole#

#if ENABLE_OVERLOADING
    WindowGetRoleMethodInfo                 ,
#endif
    windowGetRole                           ,


-- ** getScreen #method:getScreen#

#if ENABLE_OVERLOADING
    WindowGetScreenMethodInfo               ,
#endif
    windowGetScreen                         ,


-- ** getSessionId #method:getSessionId#

#if ENABLE_OVERLOADING
    WindowGetSessionIdMethodInfo            ,
#endif
    windowGetSessionId                      ,


-- ** getSessionIdUtf8 #method:getSessionIdUtf8#

#if ENABLE_OVERLOADING
    WindowGetSessionIdUtf8MethodInfo        ,
#endif
    windowGetSessionIdUtf8                  ,


-- ** getSortOrder #method:getSortOrder#

#if ENABLE_OVERLOADING
    WindowGetSortOrderMethodInfo            ,
#endif
    windowGetSortOrder                      ,


-- ** getState #method:getState#

#if ENABLE_OVERLOADING
    WindowGetStateMethodInfo                ,
#endif
    windowGetState                          ,


-- ** getTransient #method:getTransient#

#if ENABLE_OVERLOADING
    WindowGetTransientMethodInfo            ,
#endif
    windowGetTransient                      ,


-- ** getWindowType #method:getWindowType#

#if ENABLE_OVERLOADING
    WindowGetWindowTypeMethodInfo           ,
#endif
    windowGetWindowType                     ,


-- ** getWorkspace #method:getWorkspace#

#if ENABLE_OVERLOADING
    WindowGetWorkspaceMethodInfo            ,
#endif
    windowGetWorkspace                      ,


-- ** getXid #method:getXid#

#if ENABLE_OVERLOADING
    WindowGetXidMethodInfo                  ,
#endif
    windowGetXid                            ,


-- ** hasIconName #method:hasIconName#

#if ENABLE_OVERLOADING
    WindowHasIconNameMethodInfo             ,
#endif
    windowHasIconName                       ,


-- ** hasName #method:hasName#

#if ENABLE_OVERLOADING
    WindowHasNameMethodInfo                 ,
#endif
    windowHasName                           ,


-- ** isAbove #method:isAbove#

#if ENABLE_OVERLOADING
    WindowIsAboveMethodInfo                 ,
#endif
    windowIsAbove                           ,


-- ** isActive #method:isActive#

#if ENABLE_OVERLOADING
    WindowIsActiveMethodInfo                ,
#endif
    windowIsActive                          ,


-- ** isBelow #method:isBelow#

#if ENABLE_OVERLOADING
    WindowIsBelowMethodInfo                 ,
#endif
    windowIsBelow                           ,


-- ** isFullscreen #method:isFullscreen#

#if ENABLE_OVERLOADING
    WindowIsFullscreenMethodInfo            ,
#endif
    windowIsFullscreen                      ,


-- ** isInViewport #method:isInViewport#

#if ENABLE_OVERLOADING
    WindowIsInViewportMethodInfo            ,
#endif
    windowIsInViewport                      ,


-- ** isMaximized #method:isMaximized#

#if ENABLE_OVERLOADING
    WindowIsMaximizedMethodInfo             ,
#endif
    windowIsMaximized                       ,


-- ** isMaximizedHorizontally #method:isMaximizedHorizontally#

#if ENABLE_OVERLOADING
    WindowIsMaximizedHorizontallyMethodInfo ,
#endif
    windowIsMaximizedHorizontally           ,


-- ** isMaximizedVertically #method:isMaximizedVertically#

#if ENABLE_OVERLOADING
    WindowIsMaximizedVerticallyMethodInfo   ,
#endif
    windowIsMaximizedVertically             ,


-- ** isMinimized #method:isMinimized#

#if ENABLE_OVERLOADING
    WindowIsMinimizedMethodInfo             ,
#endif
    windowIsMinimized                       ,


-- ** isMostRecentlyActivated #method:isMostRecentlyActivated#

#if ENABLE_OVERLOADING
    WindowIsMostRecentlyActivatedMethodInfo ,
#endif
    windowIsMostRecentlyActivated           ,


-- ** isOnWorkspace #method:isOnWorkspace#

#if ENABLE_OVERLOADING
    WindowIsOnWorkspaceMethodInfo           ,
#endif
    windowIsOnWorkspace                     ,


-- ** isPinned #method:isPinned#

#if ENABLE_OVERLOADING
    WindowIsPinnedMethodInfo                ,
#endif
    windowIsPinned                          ,


-- ** isShaded #method:isShaded#

#if ENABLE_OVERLOADING
    WindowIsShadedMethodInfo                ,
#endif
    windowIsShaded                          ,


-- ** isSkipPager #method:isSkipPager#

#if ENABLE_OVERLOADING
    WindowIsSkipPagerMethodInfo             ,
#endif
    windowIsSkipPager                       ,


-- ** isSkipTasklist #method:isSkipTasklist#

#if ENABLE_OVERLOADING
    WindowIsSkipTasklistMethodInfo          ,
#endif
    windowIsSkipTasklist                    ,


-- ** isSticky #method:isSticky#

#if ENABLE_OVERLOADING
    WindowIsStickyMethodInfo                ,
#endif
    windowIsSticky                          ,


-- ** isVisibleOnWorkspace #method:isVisibleOnWorkspace#

#if ENABLE_OVERLOADING
    WindowIsVisibleOnWorkspaceMethodInfo    ,
#endif
    windowIsVisibleOnWorkspace              ,


-- ** keyboardMove #method:keyboardMove#

#if ENABLE_OVERLOADING
    WindowKeyboardMoveMethodInfo            ,
#endif
    windowKeyboardMove                      ,


-- ** keyboardSize #method:keyboardSize#

#if ENABLE_OVERLOADING
    WindowKeyboardSizeMethodInfo            ,
#endif
    windowKeyboardSize                      ,


-- ** makeAbove #method:makeAbove#

#if ENABLE_OVERLOADING
    WindowMakeAboveMethodInfo               ,
#endif
    windowMakeAbove                         ,


-- ** makeBelow #method:makeBelow#

#if ENABLE_OVERLOADING
    WindowMakeBelowMethodInfo               ,
#endif
    windowMakeBelow                         ,


-- ** maximize #method:maximize#

#if ENABLE_OVERLOADING
    WindowMaximizeMethodInfo                ,
#endif
    windowMaximize                          ,


-- ** maximizeHorizontally #method:maximizeHorizontally#

#if ENABLE_OVERLOADING
    WindowMaximizeHorizontallyMethodInfo    ,
#endif
    windowMaximizeHorizontally              ,


-- ** maximizeVertically #method:maximizeVertically#

#if ENABLE_OVERLOADING
    WindowMaximizeVerticallyMethodInfo      ,
#endif
    windowMaximizeVertically                ,


-- ** minimize #method:minimize#

#if ENABLE_OVERLOADING
    WindowMinimizeMethodInfo                ,
#endif
    windowMinimize                          ,


-- ** moveToWorkspace #method:moveToWorkspace#

#if ENABLE_OVERLOADING
    WindowMoveToWorkspaceMethodInfo         ,
#endif
    windowMoveToWorkspace                   ,


-- ** needsAttention #method:needsAttention#

#if ENABLE_OVERLOADING
    WindowNeedsAttentionMethodInfo          ,
#endif
    windowNeedsAttention                    ,


-- ** orTransientNeedsAttention #method:orTransientNeedsAttention#

#if ENABLE_OVERLOADING
    WindowOrTransientNeedsAttentionMethodInfo,
#endif
    windowOrTransientNeedsAttention         ,


-- ** pin #method:pin#

#if ENABLE_OVERLOADING
    WindowPinMethodInfo                     ,
#endif
    windowPin                               ,


-- ** setFullscreen #method:setFullscreen#

#if ENABLE_OVERLOADING
    WindowSetFullscreenMethodInfo           ,
#endif
    windowSetFullscreen                     ,


-- ** setGeometry #method:setGeometry#

#if ENABLE_OVERLOADING
    WindowSetGeometryMethodInfo             ,
#endif
    windowSetGeometry                       ,


-- ** setIconGeometry #method:setIconGeometry#

#if ENABLE_OVERLOADING
    WindowSetIconGeometryMethodInfo         ,
#endif
    windowSetIconGeometry                   ,


-- ** setSkipPager #method:setSkipPager#

#if ENABLE_OVERLOADING
    WindowSetSkipPagerMethodInfo            ,
#endif
    windowSetSkipPager                      ,


-- ** setSkipTasklist #method:setSkipTasklist#

#if ENABLE_OVERLOADING
    WindowSetSkipTasklistMethodInfo         ,
#endif
    windowSetSkipTasklist                   ,


-- ** setSortOrder #method:setSortOrder#

#if ENABLE_OVERLOADING
    WindowSetSortOrderMethodInfo            ,
#endif
    windowSetSortOrder                      ,


-- ** setWindowType #method:setWindowType#

#if ENABLE_OVERLOADING
    WindowSetWindowTypeMethodInfo           ,
#endif
    windowSetWindowType                     ,


-- ** shade #method:shade#

#if ENABLE_OVERLOADING
    WindowShadeMethodInfo                   ,
#endif
    windowShade                             ,


-- ** stick #method:stick#

#if ENABLE_OVERLOADING
    WindowStickMethodInfo                   ,
#endif
    windowStick                             ,


-- ** transientIsMostRecentlyActivated #method:transientIsMostRecentlyActivated#

#if ENABLE_OVERLOADING
    WindowTransientIsMostRecentlyActivatedMethodInfo,
#endif
    windowTransientIsMostRecentlyActivated  ,


-- ** unmakeAbove #method:unmakeAbove#

#if ENABLE_OVERLOADING
    WindowUnmakeAboveMethodInfo             ,
#endif
    windowUnmakeAbove                       ,


-- ** unmakeBelow #method:unmakeBelow#

#if ENABLE_OVERLOADING
    WindowUnmakeBelowMethodInfo             ,
#endif
    windowUnmakeBelow                       ,


-- ** unmaximize #method:unmaximize#

#if ENABLE_OVERLOADING
    WindowUnmaximizeMethodInfo              ,
#endif
    windowUnmaximize                        ,


-- ** unmaximizeHorizontally #method:unmaximizeHorizontally#

#if ENABLE_OVERLOADING
    WindowUnmaximizeHorizontallyMethodInfo  ,
#endif
    windowUnmaximizeHorizontally            ,


-- ** unmaximizeVertically #method:unmaximizeVertically#

#if ENABLE_OVERLOADING
    WindowUnmaximizeVerticallyMethodInfo    ,
#endif
    windowUnmaximizeVertically              ,


-- ** unminimize #method:unminimize#

#if ENABLE_OVERLOADING
    WindowUnminimizeMethodInfo              ,
#endif
    windowUnminimize                        ,


-- ** unpin #method:unpin#

#if ENABLE_OVERLOADING
    WindowUnpinMethodInfo                   ,
#endif
    windowUnpin                             ,


-- ** unshade #method:unshade#

#if ENABLE_OVERLOADING
    WindowUnshadeMethodInfo                 ,
#endif
    windowUnshade                           ,


-- ** unstick #method:unstick#

#if ENABLE_OVERLOADING
    WindowUnstickMethodInfo                 ,
#endif
    windowUnstick                           ,




 -- * Signals
-- ** actionsChanged #signal:actionsChanged#

    C_WindowActionsChangedCallback          ,
    WindowActionsChangedCallback            ,
#if ENABLE_OVERLOADING
    WindowActionsChangedSignalInfo          ,
#endif
    afterWindowActionsChanged               ,
    genClosure_WindowActionsChanged         ,
    mk_WindowActionsChangedCallback         ,
    noWindowActionsChangedCallback          ,
    onWindowActionsChanged                  ,
    wrap_WindowActionsChangedCallback       ,


-- ** classChanged #signal:classChanged#

    C_WindowClassChangedCallback            ,
    WindowClassChangedCallback              ,
#if ENABLE_OVERLOADING
    WindowClassChangedSignalInfo            ,
#endif
    afterWindowClassChanged                 ,
    genClosure_WindowClassChanged           ,
    mk_WindowClassChangedCallback           ,
    noWindowClassChangedCallback            ,
    onWindowClassChanged                    ,
    wrap_WindowClassChangedCallback         ,


-- ** geometryChanged #signal:geometryChanged#

    C_WindowGeometryChangedCallback         ,
    WindowGeometryChangedCallback           ,
#if ENABLE_OVERLOADING
    WindowGeometryChangedSignalInfo         ,
#endif
    afterWindowGeometryChanged              ,
    genClosure_WindowGeometryChanged        ,
    mk_WindowGeometryChangedCallback        ,
    noWindowGeometryChangedCallback         ,
    onWindowGeometryChanged                 ,
    wrap_WindowGeometryChangedCallback      ,


-- ** iconChanged #signal:iconChanged#

    C_WindowIconChangedCallback             ,
    WindowIconChangedCallback               ,
#if ENABLE_OVERLOADING
    WindowIconChangedSignalInfo             ,
#endif
    afterWindowIconChanged                  ,
    genClosure_WindowIconChanged            ,
    mk_WindowIconChangedCallback            ,
    noWindowIconChangedCallback             ,
    onWindowIconChanged                     ,
    wrap_WindowIconChangedCallback          ,


-- ** nameChanged #signal:nameChanged#

    C_WindowNameChangedCallback             ,
    WindowNameChangedCallback               ,
#if ENABLE_OVERLOADING
    WindowNameChangedSignalInfo             ,
#endif
    afterWindowNameChanged                  ,
    genClosure_WindowNameChanged            ,
    mk_WindowNameChangedCallback            ,
    noWindowNameChangedCallback             ,
    onWindowNameChanged                     ,
    wrap_WindowNameChangedCallback          ,


-- ** roleChanged #signal:roleChanged#

    C_WindowRoleChangedCallback             ,
    WindowRoleChangedCallback               ,
#if ENABLE_OVERLOADING
    WindowRoleChangedSignalInfo             ,
#endif
    afterWindowRoleChanged                  ,
    genClosure_WindowRoleChanged            ,
    mk_WindowRoleChangedCallback            ,
    noWindowRoleChangedCallback             ,
    onWindowRoleChanged                     ,
    wrap_WindowRoleChangedCallback          ,


-- ** stateChanged #signal:stateChanged#

    C_WindowStateChangedCallback            ,
    WindowStateChangedCallback              ,
#if ENABLE_OVERLOADING
    WindowStateChangedSignalInfo            ,
#endif
    afterWindowStateChanged                 ,
    genClosure_WindowStateChanged           ,
    mk_WindowStateChangedCallback           ,
    noWindowStateChangedCallback            ,
    onWindowStateChanged                    ,
    wrap_WindowStateChangedCallback         ,


-- ** typeChanged #signal:typeChanged#

    C_WindowTypeChangedCallback             ,
    WindowTypeChangedCallback               ,
#if ENABLE_OVERLOADING
    WindowTypeChangedSignalInfo             ,
#endif
    afterWindowTypeChanged                  ,
    genClosure_WindowTypeChanged            ,
    mk_WindowTypeChangedCallback            ,
    noWindowTypeChangedCallback             ,
    onWindowTypeChanged                     ,
    wrap_WindowTypeChangedCallback          ,


-- ** workspaceChanged #signal:workspaceChanged#

    C_WindowWorkspaceChangedCallback        ,
    WindowWorkspaceChangedCallback          ,
#if ENABLE_OVERLOADING
    WindowWorkspaceChangedSignalInfo        ,
#endif
    afterWindowWorkspaceChanged             ,
    genClosure_WindowWorkspaceChanged       ,
    mk_WindowWorkspaceChangedCallback       ,
    noWindowWorkspaceChangedCallback        ,
    onWindowWorkspaceChanged                ,
    wrap_WindowWorkspaceChangedCallback     ,




    ) 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
import {-# SOURCE #-} qualified GI.Wnck.Enums as Wnck.Enums
import {-# SOURCE #-} qualified GI.Wnck.Flags as Wnck.Flags
import {-# SOURCE #-} qualified GI.Wnck.Objects.Application as Wnck.Application
import {-# SOURCE #-} qualified GI.Wnck.Objects.ClassGroup as Wnck.ClassGroup
import {-# SOURCE #-} qualified GI.Wnck.Objects.Screen as Wnck.Screen
import {-# SOURCE #-} qualified GI.Wnck.Objects.Workspace as Wnck.Workspace

-- | Memory-managed wrapper type.
newtype Window = Window (ManagedPtr Window)
foreign import ccall "wnck_window_get_type"
    c_wnck_window_get_type :: IO GType

instance GObject Window where
    gobjectType = c_wnck_window_get_type
    

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

instance O.HasParentTypes Window
type instance O.ParentTypes Window = '[GObject.Object.Object]

-- | Cast to `Window`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toWindow :: (MonadIO m, IsWindow o) => o -> m Window
toWindow = liftIO . unsafeCastTo Window

-- | A convenience alias for `Nothing` :: `Maybe` `Window`.
noWindow :: Maybe Window
noWindow = Nothing

#if ENABLE_OVERLOADING
type family ResolveWindowMethod (t :: Symbol) (o :: *) :: * where
    ResolveWindowMethod "activate" o = WindowActivateMethodInfo
    ResolveWindowMethod "activateTransient" o = WindowActivateTransientMethodInfo
    ResolveWindowMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveWindowMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveWindowMethod "close" o = WindowCloseMethodInfo
    ResolveWindowMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveWindowMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveWindowMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveWindowMethod "hasIconName" o = WindowHasIconNameMethodInfo
    ResolveWindowMethod "hasName" o = WindowHasNameMethodInfo
    ResolveWindowMethod "isAbove" o = WindowIsAboveMethodInfo
    ResolveWindowMethod "isActive" o = WindowIsActiveMethodInfo
    ResolveWindowMethod "isBelow" o = WindowIsBelowMethodInfo
    ResolveWindowMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveWindowMethod "isFullscreen" o = WindowIsFullscreenMethodInfo
    ResolveWindowMethod "isInViewport" o = WindowIsInViewportMethodInfo
    ResolveWindowMethod "isMaximized" o = WindowIsMaximizedMethodInfo
    ResolveWindowMethod "isMaximizedHorizontally" o = WindowIsMaximizedHorizontallyMethodInfo
    ResolveWindowMethod "isMaximizedVertically" o = WindowIsMaximizedVerticallyMethodInfo
    ResolveWindowMethod "isMinimized" o = WindowIsMinimizedMethodInfo
    ResolveWindowMethod "isMostRecentlyActivated" o = WindowIsMostRecentlyActivatedMethodInfo
    ResolveWindowMethod "isOnWorkspace" o = WindowIsOnWorkspaceMethodInfo
    ResolveWindowMethod "isPinned" o = WindowIsPinnedMethodInfo
    ResolveWindowMethod "isShaded" o = WindowIsShadedMethodInfo
    ResolveWindowMethod "isSkipPager" o = WindowIsSkipPagerMethodInfo
    ResolveWindowMethod "isSkipTasklist" o = WindowIsSkipTasklistMethodInfo
    ResolveWindowMethod "isSticky" o = WindowIsStickyMethodInfo
    ResolveWindowMethod "isVisibleOnWorkspace" o = WindowIsVisibleOnWorkspaceMethodInfo
    ResolveWindowMethod "keyboardMove" o = WindowKeyboardMoveMethodInfo
    ResolveWindowMethod "keyboardSize" o = WindowKeyboardSizeMethodInfo
    ResolveWindowMethod "makeAbove" o = WindowMakeAboveMethodInfo
    ResolveWindowMethod "makeBelow" o = WindowMakeBelowMethodInfo
    ResolveWindowMethod "maximize" o = WindowMaximizeMethodInfo
    ResolveWindowMethod "maximizeHorizontally" o = WindowMaximizeHorizontallyMethodInfo
    ResolveWindowMethod "maximizeVertically" o = WindowMaximizeVerticallyMethodInfo
    ResolveWindowMethod "minimize" o = WindowMinimizeMethodInfo
    ResolveWindowMethod "moveToWorkspace" o = WindowMoveToWorkspaceMethodInfo
    ResolveWindowMethod "needsAttention" o = WindowNeedsAttentionMethodInfo
    ResolveWindowMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveWindowMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveWindowMethod "orTransientNeedsAttention" o = WindowOrTransientNeedsAttentionMethodInfo
    ResolveWindowMethod "pin" o = WindowPinMethodInfo
    ResolveWindowMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveWindowMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveWindowMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveWindowMethod "shade" o = WindowShadeMethodInfo
    ResolveWindowMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveWindowMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveWindowMethod "stick" o = WindowStickMethodInfo
    ResolveWindowMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveWindowMethod "transientIsMostRecentlyActivated" o = WindowTransientIsMostRecentlyActivatedMethodInfo
    ResolveWindowMethod "unmakeAbove" o = WindowUnmakeAboveMethodInfo
    ResolveWindowMethod "unmakeBelow" o = WindowUnmakeBelowMethodInfo
    ResolveWindowMethod "unmaximize" o = WindowUnmaximizeMethodInfo
    ResolveWindowMethod "unmaximizeHorizontally" o = WindowUnmaximizeHorizontallyMethodInfo
    ResolveWindowMethod "unmaximizeVertically" o = WindowUnmaximizeVerticallyMethodInfo
    ResolveWindowMethod "unminimize" o = WindowUnminimizeMethodInfo
    ResolveWindowMethod "unpin" o = WindowUnpinMethodInfo
    ResolveWindowMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveWindowMethod "unshade" o = WindowUnshadeMethodInfo
    ResolveWindowMethod "unstick" o = WindowUnstickMethodInfo
    ResolveWindowMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveWindowMethod "getActions" o = WindowGetActionsMethodInfo
    ResolveWindowMethod "getApplication" o = WindowGetApplicationMethodInfo
    ResolveWindowMethod "getClassGroup" o = WindowGetClassGroupMethodInfo
    ResolveWindowMethod "getClassGroupName" o = WindowGetClassGroupNameMethodInfo
    ResolveWindowMethod "getClassInstanceName" o = WindowGetClassInstanceNameMethodInfo
    ResolveWindowMethod "getClientWindowGeometry" o = WindowGetClientWindowGeometryMethodInfo
    ResolveWindowMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveWindowMethod "getGeometry" o = WindowGetGeometryMethodInfo
    ResolveWindowMethod "getGroupLeader" o = WindowGetGroupLeaderMethodInfo
    ResolveWindowMethod "getIcon" o = WindowGetIconMethodInfo
    ResolveWindowMethod "getIconIsFallback" o = WindowGetIconIsFallbackMethodInfo
    ResolveWindowMethod "getIconName" o = WindowGetIconNameMethodInfo
    ResolveWindowMethod "getMiniIcon" o = WindowGetMiniIconMethodInfo
    ResolveWindowMethod "getName" o = WindowGetNameMethodInfo
    ResolveWindowMethod "getPid" o = WindowGetPidMethodInfo
    ResolveWindowMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveWindowMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveWindowMethod "getRole" o = WindowGetRoleMethodInfo
    ResolveWindowMethod "getScreen" o = WindowGetScreenMethodInfo
    ResolveWindowMethod "getSessionId" o = WindowGetSessionIdMethodInfo
    ResolveWindowMethod "getSessionIdUtf8" o = WindowGetSessionIdUtf8MethodInfo
    ResolveWindowMethod "getSortOrder" o = WindowGetSortOrderMethodInfo
    ResolveWindowMethod "getState" o = WindowGetStateMethodInfo
    ResolveWindowMethod "getTransient" o = WindowGetTransientMethodInfo
    ResolveWindowMethod "getWindowType" o = WindowGetWindowTypeMethodInfo
    ResolveWindowMethod "getWorkspace" o = WindowGetWorkspaceMethodInfo
    ResolveWindowMethod "getXid" o = WindowGetXidMethodInfo
    ResolveWindowMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveWindowMethod "setFullscreen" o = WindowSetFullscreenMethodInfo
    ResolveWindowMethod "setGeometry" o = WindowSetGeometryMethodInfo
    ResolveWindowMethod "setIconGeometry" o = WindowSetIconGeometryMethodInfo
    ResolveWindowMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWindowMethod "setSkipPager" o = WindowSetSkipPagerMethodInfo
    ResolveWindowMethod "setSkipTasklist" o = WindowSetSkipTasklistMethodInfo
    ResolveWindowMethod "setSortOrder" o = WindowSetSortOrderMethodInfo
    ResolveWindowMethod "setWindowType" o = WindowSetWindowTypeMethodInfo
    ResolveWindowMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal Window::actions-changed
{- |
Emitted when the actions availabilities for /@window@/ change.
-}
type WindowActionsChangedCallback =
    [Wnck.Flags.WindowActions]
    {- ^ /@changedMask@/: the bitmask containing bits set for all actions
availabilities for /@window@/ that have changed. -}
    -> [Wnck.Flags.WindowActions]
    {- ^ /@newState@/: the new actions availabilities for /@window@/. -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowActionsChangedCallback`@.
noWindowActionsChangedCallback :: Maybe WindowActionsChangedCallback
noWindowActionsChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WindowActionsChangedCallback =
    Ptr () ->                               -- object
    CUInt ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowActionsChanged :: MonadIO m => WindowActionsChangedCallback -> m (GClosure C_WindowActionsChangedCallback)
genClosure_WindowActionsChanged cb = liftIO $ do
    let cb' = wrap_WindowActionsChangedCallback cb
    mk_WindowActionsChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WindowActionsChangedCallback` into a `C_WindowActionsChangedCallback`.
wrap_WindowActionsChangedCallback ::
    WindowActionsChangedCallback ->
    C_WindowActionsChangedCallback
wrap_WindowActionsChangedCallback _cb _ changedMask newState _ = do
    let changedMask' = wordToGFlags changedMask
    let newState' = wordToGFlags newState
    _cb  changedMask' newState'


{- |
Connect a signal handler for the “@actions-changed@” 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 #actionsChanged callback
@
-}
onWindowActionsChanged :: (IsWindow a, MonadIO m) => a -> WindowActionsChangedCallback -> m SignalHandlerId
onWindowActionsChanged obj cb = liftIO $ do
    let cb' = wrap_WindowActionsChangedCallback cb
    cb'' <- mk_WindowActionsChangedCallback cb'
    connectSignalFunPtr obj "actions-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@actions-changed@” 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 #actionsChanged callback
@
-}
afterWindowActionsChanged :: (IsWindow a, MonadIO m) => a -> WindowActionsChangedCallback -> m SignalHandlerId
afterWindowActionsChanged obj cb = liftIO $ do
    let cb' = wrap_WindowActionsChangedCallback cb
    cb'' <- mk_WindowActionsChangedCallback cb'
    connectSignalFunPtr obj "actions-changed" cb'' SignalConnectAfter


-- signal Window::class-changed
{- |
Emitted when the class name or instance name of /@window@/ changes.
-}
type WindowClassChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowClassChangedCallback`@.
noWindowClassChangedCallback :: Maybe WindowClassChangedCallback
noWindowClassChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WindowClassChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowClassChanged :: MonadIO m => WindowClassChangedCallback -> m (GClosure C_WindowClassChangedCallback)
genClosure_WindowClassChanged cb = liftIO $ do
    let cb' = wrap_WindowClassChangedCallback cb
    mk_WindowClassChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WindowClassChangedCallback` into a `C_WindowClassChangedCallback`.
wrap_WindowClassChangedCallback ::
    WindowClassChangedCallback ->
    C_WindowClassChangedCallback
wrap_WindowClassChangedCallback _cb _ _ = do
    _cb 


{- |
Connect a signal handler for the “@class-changed@” 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 #classChanged callback
@
-}
onWindowClassChanged :: (IsWindow a, MonadIO m) => a -> WindowClassChangedCallback -> m SignalHandlerId
onWindowClassChanged obj cb = liftIO $ do
    let cb' = wrap_WindowClassChangedCallback cb
    cb'' <- mk_WindowClassChangedCallback cb'
    connectSignalFunPtr obj "class-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@class-changed@” 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 #classChanged callback
@
-}
afterWindowClassChanged :: (IsWindow a, MonadIO m) => a -> WindowClassChangedCallback -> m SignalHandlerId
afterWindowClassChanged obj cb = liftIO $ do
    let cb' = wrap_WindowClassChangedCallback cb
    cb'' <- mk_WindowClassChangedCallback cb'
    connectSignalFunPtr obj "class-changed" cb'' SignalConnectAfter


-- signal Window::geometry-changed
{- |
Emitted when the geometry of /@window@/ changes.
-}
type WindowGeometryChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowGeometryChangedCallback`@.
noWindowGeometryChangedCallback :: Maybe WindowGeometryChangedCallback
noWindowGeometryChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WindowGeometryChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowGeometryChanged :: MonadIO m => WindowGeometryChangedCallback -> m (GClosure C_WindowGeometryChangedCallback)
genClosure_WindowGeometryChanged cb = liftIO $ do
    let cb' = wrap_WindowGeometryChangedCallback cb
    mk_WindowGeometryChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WindowGeometryChangedCallback` into a `C_WindowGeometryChangedCallback`.
wrap_WindowGeometryChangedCallback ::
    WindowGeometryChangedCallback ->
    C_WindowGeometryChangedCallback
wrap_WindowGeometryChangedCallback _cb _ _ = do
    _cb 


{- |
Connect a signal handler for the “@geometry-changed@” 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 #geometryChanged callback
@
-}
onWindowGeometryChanged :: (IsWindow a, MonadIO m) => a -> WindowGeometryChangedCallback -> m SignalHandlerId
onWindowGeometryChanged obj cb = liftIO $ do
    let cb' = wrap_WindowGeometryChangedCallback cb
    cb'' <- mk_WindowGeometryChangedCallback cb'
    connectSignalFunPtr obj "geometry-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@geometry-changed@” 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 #geometryChanged callback
@
-}
afterWindowGeometryChanged :: (IsWindow a, MonadIO m) => a -> WindowGeometryChangedCallback -> m SignalHandlerId
afterWindowGeometryChanged obj cb = liftIO $ do
    let cb' = wrap_WindowGeometryChangedCallback cb
    cb'' <- mk_WindowGeometryChangedCallback cb'
    connectSignalFunPtr obj "geometry-changed" cb'' SignalConnectAfter


-- signal Window::icon-changed
{- |
Emitted when the icon of /@window@/ changes.
-}
type WindowIconChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowIconChangedCallback`@.
noWindowIconChangedCallback :: Maybe WindowIconChangedCallback
noWindowIconChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WindowIconChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowIconChanged :: MonadIO m => WindowIconChangedCallback -> m (GClosure C_WindowIconChangedCallback)
genClosure_WindowIconChanged cb = liftIO $ do
    let cb' = wrap_WindowIconChangedCallback cb
    mk_WindowIconChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WindowIconChangedCallback` into a `C_WindowIconChangedCallback`.
wrap_WindowIconChangedCallback ::
    WindowIconChangedCallback ->
    C_WindowIconChangedCallback
wrap_WindowIconChangedCallback _cb _ _ = do
    _cb 


{- |
Connect a signal handler for the “@icon-changed@” 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 #iconChanged callback
@
-}
onWindowIconChanged :: (IsWindow a, MonadIO m) => a -> WindowIconChangedCallback -> m SignalHandlerId
onWindowIconChanged obj cb = liftIO $ do
    let cb' = wrap_WindowIconChangedCallback cb
    cb'' <- mk_WindowIconChangedCallback cb'
    connectSignalFunPtr obj "icon-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@icon-changed@” 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 #iconChanged callback
@
-}
afterWindowIconChanged :: (IsWindow a, MonadIO m) => a -> WindowIconChangedCallback -> m SignalHandlerId
afterWindowIconChanged obj cb = liftIO $ do
    let cb' = wrap_WindowIconChangedCallback cb
    cb'' <- mk_WindowIconChangedCallback cb'
    connectSignalFunPtr obj "icon-changed" cb'' SignalConnectAfter


-- signal Window::name-changed
{- |
Emitted when the name of /@window@/ changes.
-}
type WindowNameChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowNameChangedCallback`@.
noWindowNameChangedCallback :: Maybe WindowNameChangedCallback
noWindowNameChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WindowNameChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowNameChanged :: MonadIO m => WindowNameChangedCallback -> m (GClosure C_WindowNameChangedCallback)
genClosure_WindowNameChanged cb = liftIO $ do
    let cb' = wrap_WindowNameChangedCallback cb
    mk_WindowNameChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WindowNameChangedCallback` into a `C_WindowNameChangedCallback`.
wrap_WindowNameChangedCallback ::
    WindowNameChangedCallback ->
    C_WindowNameChangedCallback
wrap_WindowNameChangedCallback _cb _ _ = do
    _cb 


{- |
Connect a signal handler for the “@name-changed@” 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 #nameChanged callback
@
-}
onWindowNameChanged :: (IsWindow a, MonadIO m) => a -> WindowNameChangedCallback -> m SignalHandlerId
onWindowNameChanged obj cb = liftIO $ do
    let cb' = wrap_WindowNameChangedCallback cb
    cb'' <- mk_WindowNameChangedCallback cb'
    connectSignalFunPtr obj "name-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@name-changed@” 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 #nameChanged callback
@
-}
afterWindowNameChanged :: (IsWindow a, MonadIO m) => a -> WindowNameChangedCallback -> m SignalHandlerId
afterWindowNameChanged obj cb = liftIO $ do
    let cb' = wrap_WindowNameChangedCallback cb
    cb'' <- mk_WindowNameChangedCallback cb'
    connectSignalFunPtr obj "name-changed" cb'' SignalConnectAfter


-- signal Window::role-changed
{- |
Emitted when the role of /@window@/ changes.
-}
type WindowRoleChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowRoleChangedCallback`@.
noWindowRoleChangedCallback :: Maybe WindowRoleChangedCallback
noWindowRoleChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WindowRoleChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowRoleChanged :: MonadIO m => WindowRoleChangedCallback -> m (GClosure C_WindowRoleChangedCallback)
genClosure_WindowRoleChanged cb = liftIO $ do
    let cb' = wrap_WindowRoleChangedCallback cb
    mk_WindowRoleChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WindowRoleChangedCallback` into a `C_WindowRoleChangedCallback`.
wrap_WindowRoleChangedCallback ::
    WindowRoleChangedCallback ->
    C_WindowRoleChangedCallback
wrap_WindowRoleChangedCallback _cb _ _ = do
    _cb 


{- |
Connect a signal handler for the “@role-changed@” 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 #roleChanged callback
@
-}
onWindowRoleChanged :: (IsWindow a, MonadIO m) => a -> WindowRoleChangedCallback -> m SignalHandlerId
onWindowRoleChanged obj cb = liftIO $ do
    let cb' = wrap_WindowRoleChangedCallback cb
    cb'' <- mk_WindowRoleChangedCallback cb'
    connectSignalFunPtr obj "role-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@role-changed@” 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 #roleChanged callback
@
-}
afterWindowRoleChanged :: (IsWindow a, MonadIO m) => a -> WindowRoleChangedCallback -> m SignalHandlerId
afterWindowRoleChanged obj cb = liftIO $ do
    let cb' = wrap_WindowRoleChangedCallback cb
    cb'' <- mk_WindowRoleChangedCallback cb'
    connectSignalFunPtr obj "role-changed" cb'' SignalConnectAfter


-- signal Window::state-changed
{- |
Emitted when the state of /@window@/ changes. This can happen when /@window@/ is
(un)minimized, (un)maximized, (un)sticked, (un)shaded, (un)made above,
(un)made below, (un)set fullscreen, when it needs attention, etc. See
'GI.Wnck.Flags.WindowState' for the complete list of states that might have changed.
-}
type WindowStateChangedCallback =
    [Wnck.Flags.WindowState]
    {- ^ /@changedMask@/: the bitmask containing bits set for all states of /@window@/
that have changed. -}
    -> [Wnck.Flags.WindowState]
    {- ^ /@newState@/: the new state of /@window@/. -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowStateChangedCallback`@.
noWindowStateChangedCallback :: Maybe WindowStateChangedCallback
noWindowStateChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WindowStateChangedCallback =
    Ptr () ->                               -- object
    CUInt ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowStateChanged :: MonadIO m => WindowStateChangedCallback -> m (GClosure C_WindowStateChangedCallback)
genClosure_WindowStateChanged cb = liftIO $ do
    let cb' = wrap_WindowStateChangedCallback cb
    mk_WindowStateChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WindowStateChangedCallback` into a `C_WindowStateChangedCallback`.
wrap_WindowStateChangedCallback ::
    WindowStateChangedCallback ->
    C_WindowStateChangedCallback
wrap_WindowStateChangedCallback _cb _ changedMask newState _ = do
    let changedMask' = wordToGFlags changedMask
    let newState' = wordToGFlags newState
    _cb  changedMask' newState'


{- |
Connect a signal handler for the “@state-changed@” 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 #stateChanged callback
@
-}
onWindowStateChanged :: (IsWindow a, MonadIO m) => a -> WindowStateChangedCallback -> m SignalHandlerId
onWindowStateChanged obj cb = liftIO $ do
    let cb' = wrap_WindowStateChangedCallback cb
    cb'' <- mk_WindowStateChangedCallback cb'
    connectSignalFunPtr obj "state-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@state-changed@” 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 #stateChanged callback
@
-}
afterWindowStateChanged :: (IsWindow a, MonadIO m) => a -> WindowStateChangedCallback -> m SignalHandlerId
afterWindowStateChanged obj cb = liftIO $ do
    let cb' = wrap_WindowStateChangedCallback cb
    cb'' <- mk_WindowStateChangedCallback cb'
    connectSignalFunPtr obj "state-changed" cb'' SignalConnectAfter


-- signal Window::type-changed
{- |
Emitted when the EWMH type hint of the window changes.

/Since: 3.20/
-}
type WindowTypeChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowTypeChangedCallback`@.
noWindowTypeChangedCallback :: Maybe WindowTypeChangedCallback
noWindowTypeChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WindowTypeChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowTypeChanged :: MonadIO m => WindowTypeChangedCallback -> m (GClosure C_WindowTypeChangedCallback)
genClosure_WindowTypeChanged cb = liftIO $ do
    let cb' = wrap_WindowTypeChangedCallback cb
    mk_WindowTypeChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WindowTypeChangedCallback` into a `C_WindowTypeChangedCallback`.
wrap_WindowTypeChangedCallback ::
    WindowTypeChangedCallback ->
    C_WindowTypeChangedCallback
wrap_WindowTypeChangedCallback _cb _ _ = do
    _cb 


{- |
Connect a signal handler for the “@type-changed@” 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 #typeChanged callback
@
-}
onWindowTypeChanged :: (IsWindow a, MonadIO m) => a -> WindowTypeChangedCallback -> m SignalHandlerId
onWindowTypeChanged obj cb = liftIO $ do
    let cb' = wrap_WindowTypeChangedCallback cb
    cb'' <- mk_WindowTypeChangedCallback cb'
    connectSignalFunPtr obj "type-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@type-changed@” 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 #typeChanged callback
@
-}
afterWindowTypeChanged :: (IsWindow a, MonadIO m) => a -> WindowTypeChangedCallback -> m SignalHandlerId
afterWindowTypeChanged obj cb = liftIO $ do
    let cb' = wrap_WindowTypeChangedCallback cb
    cb'' <- mk_WindowTypeChangedCallback cb'
    connectSignalFunPtr obj "type-changed" cb'' SignalConnectAfter


-- signal Window::workspace-changed
{- |
Emitted when the current workspace of /@window@/ changes, or if /@window@/ has
been pinned or unpinned.
-}
type WindowWorkspaceChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowWorkspaceChangedCallback`@.
noWindowWorkspaceChangedCallback :: Maybe WindowWorkspaceChangedCallback
noWindowWorkspaceChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WindowWorkspaceChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowWorkspaceChanged :: MonadIO m => WindowWorkspaceChangedCallback -> m (GClosure C_WindowWorkspaceChangedCallback)
genClosure_WindowWorkspaceChanged cb = liftIO $ do
    let cb' = wrap_WindowWorkspaceChangedCallback cb
    mk_WindowWorkspaceChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WindowWorkspaceChangedCallback` into a `C_WindowWorkspaceChangedCallback`.
wrap_WindowWorkspaceChangedCallback ::
    WindowWorkspaceChangedCallback ->
    C_WindowWorkspaceChangedCallback
wrap_WindowWorkspaceChangedCallback _cb _ _ = do
    _cb 


{- |
Connect a signal handler for the “@workspace-changed@” 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 #workspaceChanged callback
@
-}
onWindowWorkspaceChanged :: (IsWindow a, MonadIO m) => a -> WindowWorkspaceChangedCallback -> m SignalHandlerId
onWindowWorkspaceChanged obj cb = liftIO $ do
    let cb' = wrap_WindowWorkspaceChangedCallback cb
    cb'' <- mk_WindowWorkspaceChangedCallback cb'
    connectSignalFunPtr obj "workspace-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@workspace-changed@” 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 #workspaceChanged callback
@
-}
afterWindowWorkspaceChanged :: (IsWindow a, MonadIO m) => a -> WindowWorkspaceChangedCallback -> m SignalHandlerId
afterWindowWorkspaceChanged obj cb = liftIO $ do
    let cb' = wrap_WindowWorkspaceChangedCallback cb
    cb'' <- mk_WindowWorkspaceChangedCallback cb'
    connectSignalFunPtr obj "workspace-changed" cb'' SignalConnectAfter


#if ENABLE_OVERLOADING
instance O.HasAttributeList Window
type instance O.AttributeList Window = WindowAttributeList
type WindowAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
#endif

#if ENABLE_OVERLOADING
data WindowActionsChangedSignalInfo
instance SignalInfo WindowActionsChangedSignalInfo where
    type HaskellCallbackType WindowActionsChangedSignalInfo = WindowActionsChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WindowActionsChangedCallback cb
        cb'' <- mk_WindowActionsChangedCallback cb'
        connectSignalFunPtr obj "actions-changed" cb'' connectMode

data WindowClassChangedSignalInfo
instance SignalInfo WindowClassChangedSignalInfo where
    type HaskellCallbackType WindowClassChangedSignalInfo = WindowClassChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WindowClassChangedCallback cb
        cb'' <- mk_WindowClassChangedCallback cb'
        connectSignalFunPtr obj "class-changed" cb'' connectMode

data WindowGeometryChangedSignalInfo
instance SignalInfo WindowGeometryChangedSignalInfo where
    type HaskellCallbackType WindowGeometryChangedSignalInfo = WindowGeometryChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WindowGeometryChangedCallback cb
        cb'' <- mk_WindowGeometryChangedCallback cb'
        connectSignalFunPtr obj "geometry-changed" cb'' connectMode

data WindowIconChangedSignalInfo
instance SignalInfo WindowIconChangedSignalInfo where
    type HaskellCallbackType WindowIconChangedSignalInfo = WindowIconChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WindowIconChangedCallback cb
        cb'' <- mk_WindowIconChangedCallback cb'
        connectSignalFunPtr obj "icon-changed" cb'' connectMode

data WindowNameChangedSignalInfo
instance SignalInfo WindowNameChangedSignalInfo where
    type HaskellCallbackType WindowNameChangedSignalInfo = WindowNameChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WindowNameChangedCallback cb
        cb'' <- mk_WindowNameChangedCallback cb'
        connectSignalFunPtr obj "name-changed" cb'' connectMode

data WindowRoleChangedSignalInfo
instance SignalInfo WindowRoleChangedSignalInfo where
    type HaskellCallbackType WindowRoleChangedSignalInfo = WindowRoleChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WindowRoleChangedCallback cb
        cb'' <- mk_WindowRoleChangedCallback cb'
        connectSignalFunPtr obj "role-changed" cb'' connectMode

data WindowStateChangedSignalInfo
instance SignalInfo WindowStateChangedSignalInfo where
    type HaskellCallbackType WindowStateChangedSignalInfo = WindowStateChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WindowStateChangedCallback cb
        cb'' <- mk_WindowStateChangedCallback cb'
        connectSignalFunPtr obj "state-changed" cb'' connectMode

data WindowTypeChangedSignalInfo
instance SignalInfo WindowTypeChangedSignalInfo where
    type HaskellCallbackType WindowTypeChangedSignalInfo = WindowTypeChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WindowTypeChangedCallback cb
        cb'' <- mk_WindowTypeChangedCallback cb'
        connectSignalFunPtr obj "type-changed" cb'' connectMode

data WindowWorkspaceChangedSignalInfo
instance SignalInfo WindowWorkspaceChangedSignalInfo where
    type HaskellCallbackType WindowWorkspaceChangedSignalInfo = WindowWorkspaceChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WindowWorkspaceChangedCallback cb
        cb'' <- mk_WindowWorkspaceChangedCallback cb'
        connectSignalFunPtr obj "workspace-changed" cb'' connectMode

type instance O.SignalList Window = WindowSignalList
type WindowSignalList = ('[ '("actionsChanged", WindowActionsChangedSignalInfo), '("classChanged", WindowClassChangedSignalInfo), '("geometryChanged", WindowGeometryChangedSignalInfo), '("iconChanged", WindowIconChangedSignalInfo), '("nameChanged", WindowNameChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("roleChanged", WindowRoleChangedSignalInfo), '("stateChanged", WindowStateChangedSignalInfo), '("typeChanged", WindowTypeChangedSignalInfo), '("workspaceChanged", WindowWorkspaceChangedSignalInfo)] :: [(Symbol, *)])

#endif

-- method Window::activate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 X server timestamp of the user interaction event that caused\nthis call to occur.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{- |
Asks the window manager to make /@window@/ the active window. The
window manager may choose to raise /@window@/ along with focusing it, and may
decide to refuse the request (to not steal the focus if there is a more
recent user activity, for example).

This function existed before 2.10, but the /@timestamp@/ argument was missing
in earlier versions.

/Since: 2.10/
-}
windowActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> Word32
    {- ^ /@timestamp@/: the X server timestamp of the user interaction event that caused
this call to occur. -}
    -> m ()
windowActivate window timestamp = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_activate window' timestamp
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowActivateMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowActivateMethodInfo a signature where
    overloadedMethod _ = windowActivate

#endif

-- method Window::activate_transient
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 X server timestamp of the user interaction event that caused\nthis call to occur.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{- |
If /@window@/ has transients, activates the most likely transient
instead of the window itself. Otherwise activates /@window@/.

FIXME the ideal behavior of this function is probably to activate
the most recently active window among /@window@/ and its transients.
This is probably best implemented on the window manager side.

This function existed before 2.10, but the /@timestamp@/ argument was missing
in earlier versions.

/Since: 2.10/
-}
windowActivateTransient ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> Word32
    {- ^ /@timestamp@/: the X server timestamp of the user interaction event that caused
this call to occur. -}
    -> m ()
windowActivateTransient window timestamp = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_activate_transient window' timestamp
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowActivateTransientMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowActivateTransientMethodInfo a signature where
    overloadedMethod _ = windowActivateTransient

#endif

-- method Window::close
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 X server timestamp of the user interaction event that caused\nthis call to occur.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{- |
Closes /@window@/.

This function existed before 2.6, but the /@timestamp@/ argument was missing
in earlier versions.

/Since: 2.6/
-}
windowClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> Word32
    {- ^ /@timestamp@/: the X server timestamp of the user interaction event that caused
this call to occur. -}
    -> m ()
windowClose window timestamp = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_close window' timestamp
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowCloseMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowCloseMethodInfo a signature where
    overloadedMethod _ = windowClose

#endif

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

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

{- |
Gets the actions that can be done for /@window@/.
-}
windowGetActions ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m [Wnck.Flags.WindowActions]
    {- ^ __Returns:__ bitmask of actions that can be done for /@window@/. -}
windowGetActions window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_actions window'
    let result' = wordToGFlags result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetActionsMethodInfo
instance (signature ~ (m [Wnck.Flags.WindowActions]), MonadIO m, IsWindow a) => O.MethodInfo WindowGetActionsMethodInfo a signature where
    overloadedMethod _ = windowGetActions

#endif

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

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

{- |
Gets the 'GI.Wnck.Objects.Application.Application' to which /@window@/ belongs.
-}
windowGetApplication ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Wnck.Application.Application
    {- ^ __Returns:__ the 'GI.Wnck.Objects.Application.Application' to which /@window@/ belongs.
The returned 'GI.Wnck.Objects.Application.Application' is owned by libwnck and must not be referenced
or unreferenced. -}
windowGetApplication window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_application window'
    checkUnexpectedReturnNULL "windowGetApplication" result
    result' <- (newObject Wnck.Application.Application) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetApplicationMethodInfo
instance (signature ~ (m Wnck.Application.Application), MonadIO m, IsWindow a) => O.MethodInfo WindowGetApplicationMethodInfo a signature where
    overloadedMethod _ = windowGetApplication

#endif

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

foreign import ccall "wnck_window_get_class_group" wnck_window_get_class_group :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO (Ptr Wnck.ClassGroup.ClassGroup)

{- |
Gets the 'GI.Wnck.Objects.ClassGroup.ClassGroup' to which /@window@/ belongs.

/Since: 2.2/
-}
windowGetClassGroup ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Wnck.ClassGroup.ClassGroup
    {- ^ __Returns:__ the 'GI.Wnck.Objects.ClassGroup.ClassGroup' to which /@window@/ belongs.
The returned 'GI.Wnck.Objects.ClassGroup.ClassGroup' is owned by libwnck and must not be referenced
or unreferenced. -}
windowGetClassGroup window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_class_group window'
    checkUnexpectedReturnNULL "windowGetClassGroup" result
    result' <- (newObject Wnck.ClassGroup.ClassGroup) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetClassGroupMethodInfo
instance (signature ~ (m Wnck.ClassGroup.ClassGroup), MonadIO m, IsWindow a) => O.MethodInfo WindowGetClassGroupMethodInfo a signature where
    overloadedMethod _ = windowGetClassGroup

#endif

-- method Window::get_class_group_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_get_class_group_name" wnck_window_get_class_group_name :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CString

{- |
Gets the class group name from the \<ulink
url=\"http:\/\/tronche.com\/gui\/x\/icccm\/sec-4.html&num;WM_CLASS\">WM_CLASS Property\<\/ulink>
for /@window@/.

The class group name is also the identifier name of the 'GI.Wnck.Objects.ClassGroup.ClassGroup' to
which /@window@/ belongs.
-}
windowGetClassGroupName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m T.Text
    {- ^ __Returns:__ the class group name for /@window@/, or 'Nothing' if /@window@/ belongs
to no class group. -}
windowGetClassGroupName window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_class_group_name window'
    checkUnexpectedReturnNULL "windowGetClassGroupName" result
    result' <- cstringToText result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetClassGroupNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWindow a) => O.MethodInfo WindowGetClassGroupNameMethodInfo a signature where
    overloadedMethod _ = windowGetClassGroupName

#endif

-- method Window::get_class_instance_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_get_class_instance_name" wnck_window_get_class_instance_name :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CString

{- |
Gets the class instance name from the \<ulink
url=\"http:\/\/tronche.com\/gui\/x\/icccm\/sec-4.html&num;WM_CLASS\">WM_CLASS Property\<\/ulink>
for /@window@/.

The class instance name allows to differentiate windows belonging to the
same class group, so that they can use different resources.
-}
windowGetClassInstanceName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m T.Text
    {- ^ __Returns:__ the class instance name for /@window@/, or 'Nothing' if /@window@/ has
no class instance. -}
windowGetClassInstanceName window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_class_instance_name window'
    checkUnexpectedReturnNULL "windowGetClassInstanceName" result
    result' <- cstringToText result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetClassInstanceNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWindow a) => O.MethodInfo WindowGetClassInstanceNameMethodInfo a signature where
    overloadedMethod _ = windowGetClassInstanceName

#endif

-- method Window::get_client_window_geometry
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for X coordinate in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "yp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for Y coordinate in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "widthp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for width in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "heightp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for height in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "wnck_window_get_client_window_geometry" wnck_window_get_client_window_geometry :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    Ptr Int32 ->                            -- xp : TBasicType TInt
    Ptr Int32 ->                            -- yp : TBasicType TInt
    Ptr Int32 ->                            -- widthp : TBasicType TInt
    Ptr Int32 ->                            -- heightp : TBasicType TInt
    IO ()

{- |
Gets the size and position of /@window@/, as last received
in a ConfigureNotify event (i.e. this call does not round-trip
to the server, just gets the last size we were notified of).
The X and Y coordinates are relative to the root window.

The window manager usually adds a frame around windows. If
you need to know the size of /@window@/ with the frame, use
'GI.Wnck.Objects.Window.windowGetGeometry'.

/Since: 2.20/
-}
windowGetClientWindowGeometry ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ((Int32, Int32, Int32, Int32))
windowGetClientWindowGeometry window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    xp <- allocMem :: IO (Ptr Int32)
    yp <- allocMem :: IO (Ptr Int32)
    widthp <- allocMem :: IO (Ptr Int32)
    heightp <- allocMem :: IO (Ptr Int32)
    wnck_window_get_client_window_geometry window' xp yp widthp heightp
    xp' <- peek xp
    yp' <- peek yp
    widthp' <- peek widthp
    heightp' <- peek heightp
    touchManagedPtr window
    freeMem xp
    freeMem yp
    freeMem widthp
    freeMem heightp
    return (xp', yp', widthp', heightp')

#if ENABLE_OVERLOADING
data WindowGetClientWindowGeometryMethodInfo
instance (signature ~ (m ((Int32, Int32, Int32, Int32))), MonadIO m, IsWindow a) => O.MethodInfo WindowGetClientWindowGeometryMethodInfo a signature where
    overloadedMethod _ = windowGetClientWindowGeometry

#endif

-- method Window::get_geometry
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for X coordinate in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "yp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for Y coordinate in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "widthp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for width in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "heightp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for height in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "wnck_window_get_geometry" wnck_window_get_geometry :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    Ptr Int32 ->                            -- xp : TBasicType TInt
    Ptr Int32 ->                            -- yp : TBasicType TInt
    Ptr Int32 ->                            -- widthp : TBasicType TInt
    Ptr Int32 ->                            -- heightp : TBasicType TInt
    IO ()

{- |
Gets the size and position of /@window@/, including decorations. This
function uses the information last received in a ConfigureNotify
event and adjusts it according to the size of the frame that is
added by the window manager (this call does not round-trip to the
server, it just gets the last sizes that were notified). The
X and Y coordinates are relative to the root window.

If you need to know the actual size of /@window@/ ignoring the frame
added by the window manager, use 'GI.Wnck.Objects.Window.windowGetClientWindowGeometry'.
-}
windowGetGeometry ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ((Int32, Int32, Int32, Int32))
windowGetGeometry window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    xp <- allocMem :: IO (Ptr Int32)
    yp <- allocMem :: IO (Ptr Int32)
    widthp <- allocMem :: IO (Ptr Int32)
    heightp <- allocMem :: IO (Ptr Int32)
    wnck_window_get_geometry window' xp yp widthp heightp
    xp' <- peek xp
    yp' <- peek yp
    widthp' <- peek widthp
    heightp' <- peek heightp
    touchManagedPtr window
    freeMem xp
    freeMem yp
    freeMem widthp
    freeMem heightp
    return (xp', yp', widthp', heightp')

#if ENABLE_OVERLOADING
data WindowGetGeometryMethodInfo
instance (signature ~ (m ((Int32, Int32, Int32, Int32))), MonadIO m, IsWindow a) => O.MethodInfo WindowGetGeometryMethodInfo a signature where
    overloadedMethod _ = windowGetGeometry

#endif

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

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

{- |
Gets the group leader of the group of windows to which /@window@/ belongs.
-}
windowGetGroupLeader ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m CULong
    {- ^ __Returns:__ the group leader of the group of windows to which /@window@/
belongs, or the X window ID of /@window@/ if /@window@/ does not belong to any
group. -}
windowGetGroupLeader window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_group_leader window'
    touchManagedPtr window
    return result

#if ENABLE_OVERLOADING
data WindowGetGroupLeaderMethodInfo
instance (signature ~ (m CULong), MonadIO m, IsWindow a) => O.MethodInfo WindowGetGroupLeaderMethodInfo a signature where
    overloadedMethod _ = windowGetGroupLeader

#endif

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

foreign import ccall "wnck_window_get_icon" wnck_window_get_icon :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)

{- |
Gets the icon to be used for /@window@/. If no icon was found, a fallback
icon is used. 'GI.Wnck.Objects.Window.windowGetIconIsFallback' can be used to tell if the
icon is the fallback icon.
-}
windowGetIcon ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m GdkPixbuf.Pixbuf.Pixbuf
    {- ^ __Returns:__ the icon for /@window@/. The caller should
reference the returned \<classname>GdkPixbuf\<\/classname> if it needs to keep
the icon around. -}
windowGetIcon window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_icon window'
    checkUnexpectedReturnNULL "windowGetIcon" result
    result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetIconMethodInfo
instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsWindow a) => O.MethodInfo WindowGetIconMethodInfo a signature where
    overloadedMethod _ = windowGetIcon

#endif

-- method Window::get_icon_is_fallback
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_get_icon_is_fallback" wnck_window_get_icon_is_fallback :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether a default fallback icon is used for /@window@/ (because none
was set on /@window@/).
-}
windowGetIconIsFallback ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the icon for /@window@/ is a fallback, 'False' otherwise. -}
windowGetIconIsFallback window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_icon_is_fallback window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetIconIsFallbackMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowGetIconIsFallbackMethodInfo a signature where
    overloadedMethod _ = windowGetIconIsFallback

#endif

-- method Window::get_icon_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow", 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 "wnck_window_get_icon_name" wnck_window_get_icon_name :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CString

{- |
Gets the icon name of /@window@/, as it should be displayed for an icon
(minimized state). Always returns some value, even if /@window@/ has no icon
name set; use 'GI.Wnck.Objects.Window.windowHasIconName' if you need to know whether the
returned icon name is \"real\" or not.

Contrast with 'GI.Wnck.Objects.Window.windowGetName', which returns /@window@/\<!-- -->\'s
title, not its icon title.
-}
windowGetIconName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window' -}
    -> m T.Text
    {- ^ __Returns:__ the icon name of /@window@/, or a fallback icon name if no icon
name is available. -}
windowGetIconName window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_icon_name window'
    checkUnexpectedReturnNULL "windowGetIconName" result
    result' <- cstringToText result
    touchManagedPtr window
    return result'

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

#endif

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

foreign import ccall "wnck_window_get_mini_icon" wnck_window_get_mini_icon :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)

{- |
Gets the mini-icon to be used for /@window@/. If no mini-icon was found, a
fallback mini-icon is used. 'GI.Wnck.Objects.Window.windowGetIconIsFallback' can be used
to tell if the mini-icon is the fallback mini-icon.
-}
windowGetMiniIcon ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m GdkPixbuf.Pixbuf.Pixbuf
    {- ^ __Returns:__ the mini-icon for /@window@/. The caller should
reference the returned \<classname>GdkPixbuf\<\/classname> if it needs to keep
the icon around. -}
windowGetMiniIcon window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_mini_icon window'
    checkUnexpectedReturnNULL "windowGetMiniIcon" result
    result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetMiniIconMethodInfo
instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsWindow a) => O.MethodInfo WindowGetMiniIconMethodInfo a signature where
    overloadedMethod _ = windowGetMiniIcon

#endif

-- method Window::get_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_get_name" wnck_window_get_name :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CString

{- |
Gets the name of /@window@/, as it should be displayed in a pager
or tasklist. Always returns some value, even if /@window@/ has no name
set; use 'GI.Wnck.Objects.Window.windowHasName' if you need to know whether the returned
name is \"real\" or not.

For icons titles, use 'GI.Wnck.Objects.Window.windowGetIconName' instead.
-}
windowGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m T.Text
    {- ^ __Returns:__ the name of /@window@/, or a fallback name if no name is
available. -}
windowGetName window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_name window'
    checkUnexpectedReturnNULL "windowGetName" result
    result' <- cstringToText result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWindow a) => O.MethodInfo WindowGetNameMethodInfo a signature where
    overloadedMethod _ = windowGetName

#endif

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

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

{- |
Gets the process ID of /@window@/.
-}
windowGetPid ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Int32
    {- ^ __Returns:__ the process ID of /@window@/, or 0 if none is available. -}
windowGetPid window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_pid window'
    touchManagedPtr window
    return result

#if ENABLE_OVERLOADING
data WindowGetPidMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsWindow a) => O.MethodInfo WindowGetPidMethodInfo a signature where
    overloadedMethod _ = windowGetPid

#endif

-- method Window::get_role
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_get_role" wnck_window_get_role :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CString

{- |
Gets the role for /@window@/.
The role uniquely identifies a window among all windows that have the same
client leader window.
-}
windowGetRole ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m T.Text
    {- ^ __Returns:__ role for /@window@/, or 'Nothing' if /@window@/ has no role. -}
windowGetRole window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_role window'
    checkUnexpectedReturnNULL "windowGetRole" result
    result' <- cstringToText result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetRoleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWindow a) => O.MethodInfo WindowGetRoleMethodInfo a signature where
    overloadedMethod _ = windowGetRole

#endif

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

foreign import ccall "wnck_window_get_screen" wnck_window_get_screen :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO (Ptr Wnck.Screen.Screen)

{- |
Gets the 'GI.Wnck.Objects.Screen.Screen' /@window@/ is on.
-}
windowGetScreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Wnck.Screen.Screen
    {- ^ __Returns:__ the 'GI.Wnck.Objects.Screen.Screen' /@window@/ is on. The returned
'GI.Wnck.Objects.Screen.Screen' is owned by libwnck and must not be referenced or unreferenced. -}
windowGetScreen window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_screen window'
    checkUnexpectedReturnNULL "windowGetScreen" result
    result' <- (newObject Wnck.Screen.Screen) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetScreenMethodInfo
instance (signature ~ (m Wnck.Screen.Screen), MonadIO m, IsWindow a) => O.MethodInfo WindowGetScreenMethodInfo a signature where
    overloadedMethod _ = windowGetScreen

#endif

-- method Window::get_session_id
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_get_session_id" wnck_window_get_session_id :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CString

{- |
Gets the session ID for /@window@/ in Latin-1 encoding.
NOTE: this is invalid UTF-8. You can\'t display this
string in a GTK+ widget without converting to UTF-8.
See 'GI.Wnck.Objects.Window.windowGetSessionIdUtf8'.
-}
windowGetSessionId ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m T.Text
    {- ^ __Returns:__ the session ID for /@window@/ in Latin-1, or 'Nothing' if /@window@/ has
no session ID. -}
windowGetSessionId window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_session_id window'
    checkUnexpectedReturnNULL "windowGetSessionId" result
    result' <- cstringToText result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetSessionIdMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWindow a) => O.MethodInfo WindowGetSessionIdMethodInfo a signature where
    overloadedMethod _ = windowGetSessionId

#endif

-- method Window::get_session_id_utf8
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_get_session_id_utf8" wnck_window_get_session_id_utf8 :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CString

{- |
Gets the session ID for /@window@/ in UTF-8 encoding.
The session ID should be in Latin-1 encoding, so the conversion should work,
but a broken client could set a session ID that might not be convertable to
UTF-8.
-}
windowGetSessionIdUtf8 ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m T.Text
    {- ^ __Returns:__ the session ID for /@window@/ in UTF-8, or 'Nothing' if /@window@/ has
no session ID. -}
windowGetSessionIdUtf8 window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_session_id_utf8 window'
    checkUnexpectedReturnNULL "windowGetSessionIdUtf8" result
    result' <- cstringToText result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetSessionIdUtf8MethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWindow a) => O.MethodInfo WindowGetSessionIdUtf8MethodInfo a signature where
    overloadedMethod _ = windowGetSessionIdUtf8

#endif

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

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

{- |
Gets the sort order of /@window@/, used for ordering of /@window@/ in
'GI.Wnck.Objects.Selector.Selector' and 'GI.Wnck.Objects.Tasklist.Tasklist'. The sort order is an internal state in
libwnck. The initial value is defined when the window is created.

/Since: 2.10/
-}
windowGetSortOrder ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Int32
    {- ^ __Returns:__ the sort order of /@window@/, or G_MAXINT if none is available. -}
windowGetSortOrder window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_sort_order window'
    touchManagedPtr window
    return result

#if ENABLE_OVERLOADING
data WindowGetSortOrderMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsWindow a) => O.MethodInfo WindowGetSortOrderMethodInfo a signature where
    overloadedMethod _ = windowGetSortOrder

#endif

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

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

{- |
Gets the state of /@window@/.
-}
windowGetState ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m [Wnck.Flags.WindowState]
    {- ^ __Returns:__ bitmask of active states for /@window@/. -}
windowGetState window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_state window'
    let result' = wordToGFlags result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetStateMethodInfo
instance (signature ~ (m [Wnck.Flags.WindowState]), MonadIO m, IsWindow a) => O.MethodInfo WindowGetStateMethodInfo a signature where
    overloadedMethod _ = windowGetState

#endif

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

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

{- |
Gets the 'GI.Wnck.Objects.Window.Window' for which /@window@/ is transient.

/Since: 2.12/
-}
windowGetTransient ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Window
    {- ^ __Returns:__ the 'GI.Wnck.Objects.Window.Window' for which /@window@/ is
transient, or 'Nothing' if /@window@/ is not transient for any 'GI.Wnck.Objects.Window.Window'.
The returned 'GI.Wnck.Objects.Window.Window' is owned by libwnck and must not be referenced or
unreferenced. -}
windowGetTransient window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_transient window'
    checkUnexpectedReturnNULL "windowGetTransient" result
    result' <- (newObject Window) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetTransientMethodInfo
instance (signature ~ (m Window), MonadIO m, IsWindow a) => O.MethodInfo WindowGetTransientMethodInfo a signature where
    overloadedMethod _ = windowGetTransient

#endif

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

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

{- |
Gets the semantic type of /@window@/.
-}
windowGetWindowType ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Wnck.Enums.WindowType
    {- ^ __Returns:__ the semantic type of /@window@/. -}
windowGetWindowType window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_window_type window'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetWindowTypeMethodInfo
instance (signature ~ (m Wnck.Enums.WindowType), MonadIO m, IsWindow a) => O.MethodInfo WindowGetWindowTypeMethodInfo a signature where
    overloadedMethod _ = windowGetWindowType

#endif

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

foreign import ccall "wnck_window_get_workspace" wnck_window_get_workspace :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO (Ptr Wnck.Workspace.Workspace)

{- |
Gets the current workspace /@window@/ is on. If the window is pinned (on all
workspaces), or not on any workspaces, 'Nothing' may be returned.
-}
windowGetWorkspace ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Wnck.Workspace.Workspace
    {- ^ __Returns:__ the single current workspace /@window@/ is on, or
'Nothing'. The returned 'GI.Wnck.Objects.Workspace.Workspace' is owned by libwnck and must not be
referenced or unreferenced. -}
windowGetWorkspace window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_workspace window'
    checkUnexpectedReturnNULL "windowGetWorkspace" result
    result' <- (newObject Wnck.Workspace.Workspace) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowGetWorkspaceMethodInfo
instance (signature ~ (m Wnck.Workspace.Workspace), MonadIO m, IsWindow a) => O.MethodInfo WindowGetWorkspaceMethodInfo a signature where
    overloadedMethod _ = windowGetWorkspace

#endif

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

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

{- |
Gets the X window ID of /@window@/.
-}
windowGetXid ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m CULong
    {- ^ __Returns:__ the X window ID of /@window@/. -}
windowGetXid window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_get_xid window'
    touchManagedPtr window
    return result

#if ENABLE_OVERLOADING
data WindowGetXidMethodInfo
instance (signature ~ (m CULong), MonadIO m, IsWindow a) => O.MethodInfo WindowGetXidMethodInfo a signature where
    overloadedMethod _ = windowGetXid

#endif

-- method Window::has_icon_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow", 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 "wnck_window_has_icon_name" wnck_window_has_icon_name :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Checks whether or not /@window@/ has an icon name.
'GI.Wnck.Objects.Window.windowGetIconName' will always return some value, even if
/@window@/ has no icon name set; 'GI.Wnck.Objects.Window.windowHasIconName' can
be used to tell if that icon name is real or not.

(Note that if 'GI.Wnck.Objects.Window.windowHasIconName' returns 'False', but
'GI.Wnck.Objects.Window.windowHasName' returns 'True', then the name returned by
'GI.Wnck.Objects.Window.windowGetIconName' is /@window@/\<!-- -->\'s name. Only when both
methods return 'False' does 'GI.Wnck.Objects.Window.windowGetIconName' return a
generic fallback name.)

/Since: 2.16/
-}
windowHasIconName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if 'GI.Wnck.Objects.Window.windowGetIconName' returns
/@window@/\<!-- -->\'s icon name, 'False' if it returns a fallback name. -}
windowHasIconName window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_has_icon_name window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowHasIconNameMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowHasIconNameMethodInfo a signature where
    overloadedMethod _ = windowHasIconName

#endif

-- method Window::has_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_has_name" wnck_window_has_name :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Checks whether or not /@window@/ has a name. 'GI.Wnck.Objects.Window.windowGetName'
will always return some value, even if /@window@/ has no name set;
'GI.Wnck.Objects.Window.windowHasName' can be used to tell if that name is
real or not.

For icons titles, use 'GI.Wnck.Objects.Window.windowHasIconName' instead.

/Since: 2.16/
-}
windowHasName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if 'GI.Wnck.Objects.Window.windowGetName' returns /@window@/\<!-- -->\'s
name, 'False' if it returns a fallback name. -}
windowHasName window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_has_name window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowHasNameMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowHasNameMethodInfo a signature where
    overloadedMethod _ = windowHasName

#endif

-- method Window::is_above
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_is_above" wnck_window_is_above :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ is above other windows. This state may change
anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.

See 'GI.Wnck.Objects.Window.windowMakeAbove' for more details on this state.

/Since: 2.14/
-}
windowIsAbove ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ is above other windows, 'False' otherwise. -}
windowIsAbove window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_is_above window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowIsAboveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsAboveMethodInfo a signature where
    overloadedMethod _ = windowIsAbove

#endif

-- method Window::is_active
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_is_active" wnck_window_is_active :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ is the active window on its 'GI.Wnck.Objects.Screen.Screen'.
-}
windowIsActive ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ is the active window on its 'GI.Wnck.Objects.Screen.Screen',
'False' otherwise. -}
windowIsActive window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_is_active window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

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

#endif

-- method Window::is_below
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_is_below" wnck_window_is_below :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ is below other windows. This state may change
anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.

See 'GI.Wnck.Objects.Window.windowMakeBelow' for more details on this state.

/Since: 2.20/
-}
windowIsBelow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ is below other windows, 'False' otherwise. -}
windowIsBelow window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_is_below window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowIsBelowMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsBelowMethodInfo a signature where
    overloadedMethod _ = windowIsBelow

#endif

-- method Window::is_fullscreen
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_is_fullscreen" wnck_window_is_fullscreen :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ is fullscreen. Fullscreen state may change
anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.

/Since: 2.8/
-}
windowIsFullscreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ is fullscreen, 'False' otherwise. -}
windowIsFullscreen window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_is_fullscreen window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

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

#endif

-- method Window::is_in_viewport
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "workspace", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", 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 "wnck_window_is_in_viewport" wnck_window_is_in_viewport :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    Ptr Wnck.Workspace.Workspace ->         -- workspace : TInterface (Name {namespace = "Wnck", name = "Workspace"})
    IO CInt

{- |
Gets 'True' if /@window@/ appears in the current viewport of /@workspace@/.

/Since: 2.4/
-}
windowIsInViewport ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> b
    {- ^ /@workspace@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ appears in current viewport of /@workspace@/,
'False' otherwise. -}
windowIsInViewport window workspace = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    workspace' <- unsafeManagedPtrCastPtr workspace
    result <- wnck_window_is_in_viewport window' workspace'
    let result' = (/= 0) result
    touchManagedPtr window
    touchManagedPtr workspace
    return result'

#if ENABLE_OVERLOADING
data WindowIsInViewportMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) => O.MethodInfo WindowIsInViewportMethodInfo a signature where
    overloadedMethod _ = windowIsInViewport

#endif

-- method Window::is_maximized
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_is_maximized" wnck_window_is_maximized :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ is maximized. Maximization state may change
anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.

As for GDK, \"maximized\" means both vertically and horizontally. If /@window@/
is maximized in only one direction, then /@window@/ is not considered
maximized.
-}
windowIsMaximized ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ is maximized in both directions, 'False'
otherwise. -}
windowIsMaximized window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_is_maximized window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

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

#endif

-- method Window::is_maximized_horizontally
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_is_maximized_horizontally" wnck_window_is_maximized_horizontally :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ is maximized horizontally. Horizontal maximization
state may change anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
-}
windowIsMaximizedHorizontally ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ is maximized horizontally, 'False' otherwise. -}
windowIsMaximizedHorizontally window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_is_maximized_horizontally window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowIsMaximizedHorizontallyMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsMaximizedHorizontallyMethodInfo a signature where
    overloadedMethod _ = windowIsMaximizedHorizontally

#endif

-- method Window::is_maximized_vertically
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_is_maximized_vertically" wnck_window_is_maximized_vertically :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ is maximized vertically. vertiVal maximization
state may change anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
-}
windowIsMaximizedVertically ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ is maximized vertically, 'False' otherwise. -}
windowIsMaximizedVertically window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_is_maximized_vertically window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowIsMaximizedVerticallyMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsMaximizedVerticallyMethodInfo a signature where
    overloadedMethod _ = windowIsMaximizedVertically

#endif

-- method Window::is_minimized
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_is_minimized" wnck_window_is_minimized :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ is minimized. Minimization state may change anytime
a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
-}
windowIsMinimized ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ is minimized, 'False' otherwise. -}
windowIsMinimized window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_is_minimized window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowIsMinimizedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsMinimizedMethodInfo a signature where
    overloadedMethod _ = windowIsMinimized

#endif

-- method Window::is_most_recently_activated
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_is_most_recently_activated" wnck_window_is_most_recently_activated :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ is the most recently activated window on its
'GI.Wnck.Objects.Screen.Screen'.

The most recently activated window is identical to the active
window for click and sloppy focus methods (since a window is always
active in those cases) but differs slightly for mouse focus since
there often is no active window.

/Since: 2.8/
-}
windowIsMostRecentlyActivated ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ was the most recently activated window on its
'GI.Wnck.Objects.Screen.Screen', 'False' otherwise. -}
windowIsMostRecentlyActivated window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_is_most_recently_activated window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowIsMostRecentlyActivatedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsMostRecentlyActivatedMethodInfo a signature where
    overloadedMethod _ = windowIsMostRecentlyActivated

#endif

-- method Window::is_on_workspace
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "workspace", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", 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 "wnck_window_is_on_workspace" wnck_window_is_on_workspace :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    Ptr Wnck.Workspace.Workspace ->         -- workspace : TInterface (Name {namespace = "Wnck", name = "Workspace"})
    IO CInt

{- |
Gets whether /@window@/ appears on /@workspace@/.
-}
windowIsOnWorkspace ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> b
    {- ^ /@workspace@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ appears on /@workspace@/, 'False' otherwise. -}
windowIsOnWorkspace window workspace = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    workspace' <- unsafeManagedPtrCastPtr workspace
    result <- wnck_window_is_on_workspace window' workspace'
    let result' = (/= 0) result
    touchManagedPtr window
    touchManagedPtr workspace
    return result'

#if ENABLE_OVERLOADING
data WindowIsOnWorkspaceMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) => O.MethodInfo WindowIsOnWorkspaceMethodInfo a signature where
    overloadedMethod _ = windowIsOnWorkspace

#endif

-- method Window::is_pinned
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_is_pinned" wnck_window_is_pinned :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ is on all workspace. Pinned state may change
anytime a 'GI.Wnck.Objects.Window.Window'::@/workspace-changed/@ signal gets emitted, but not when
a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ gets emitted.
-}
windowIsPinned ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ is on all workspaces, 'False' otherwise. -}
windowIsPinned window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_is_pinned window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowIsPinnedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsPinnedMethodInfo a signature where
    overloadedMethod _ = windowIsPinned

#endif

-- method Window::is_shaded
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_is_shaded" wnck_window_is_shaded :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ is shaded. Shade state may change anytime
a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
-}
windowIsShaded ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ is shaded, 'False' otherwise. -}
windowIsShaded window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_is_shaded window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowIsShadedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsShadedMethodInfo a signature where
    overloadedMethod _ = windowIsShaded

#endif

-- method Window::is_skip_pager
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_is_skip_pager" wnck_window_is_skip_pager :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ is included on pagers. This state may change
anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
-}
windowIsSkipPager ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ is included on pagers, 'False' otherwise. -}
windowIsSkipPager window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_is_skip_pager window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowIsSkipPagerMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsSkipPagerMethodInfo a signature where
    overloadedMethod _ = windowIsSkipPager

#endif

-- method Window::is_skip_tasklist
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_is_skip_tasklist" wnck_window_is_skip_tasklist :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ is included on tasklists. This state may change
anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
-}
windowIsSkipTasklist ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ is included on tasklists, 'False' otherwise. -}
windowIsSkipTasklist window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_is_skip_tasklist window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowIsSkipTasklistMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsSkipTasklistMethodInfo a signature where
    overloadedMethod _ = windowIsSkipTasklist

#endif

-- method Window::is_sticky
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_is_sticky" wnck_window_is_sticky :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ is sticky. Sticky state may change
anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.

Sticky here means \"stuck to the glass\", i.e. does not scroll with the
viewport. In GDK\/GTK+ (e.g. 'GI.Gdk.Objects.Window.windowStick'\/'GI.Gtk.Objects.Window.windowStick'), sticky
means \"stuck to the glass\" and \<emphasis>also\<\/emphasis> that the window is
on all workspaces. But here it only means the viewport aspect of it.
-}
windowIsSticky ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ is \"stuck to the glass\", 'False' otherwise. -}
windowIsSticky window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_is_sticky window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowIsStickyMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsStickyMethodInfo a signature where
    overloadedMethod _ = windowIsSticky

#endif

-- method Window::is_visible_on_workspace
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "workspace", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", 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 "wnck_window_is_visible_on_workspace" wnck_window_is_visible_on_workspace :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    Ptr Wnck.Workspace.Workspace ->         -- workspace : TInterface (Name {namespace = "Wnck", name = "Workspace"})
    IO CInt

{- |
Like 'GI.Wnck.Objects.Window.windowIsOnWorkspace', but also checks that
the window is in a visible state (i.e. not minimized or shaded).
-}
windowIsVisibleOnWorkspace ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> b
    {- ^ /@workspace@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ appears on /@workspace@/ in normal state, 'False'
otherwise. -}
windowIsVisibleOnWorkspace window workspace = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    workspace' <- unsafeManagedPtrCastPtr workspace
    result <- wnck_window_is_visible_on_workspace window' workspace'
    let result' = (/= 0) result
    touchManagedPtr window
    touchManagedPtr workspace
    return result'

#if ENABLE_OVERLOADING
data WindowIsVisibleOnWorkspaceMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) => O.MethodInfo WindowIsVisibleOnWorkspaceMethodInfo a signature where
    overloadedMethod _ = windowIsVisibleOnWorkspace

#endif

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

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

{- |
Asks the window manager to start moving /@window@/ via the keyboard.
-}
windowKeyboardMove ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowKeyboardMove window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_keyboard_move window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowKeyboardMoveMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowKeyboardMoveMethodInfo a signature where
    overloadedMethod _ = windowKeyboardMove

#endif

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

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

{- |
Asks the window manager to start resizing /@window@/ via the keyboard.
-}
windowKeyboardSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowKeyboardSize window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_keyboard_size window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowKeyboardSizeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowKeyboardSizeMethodInfo a signature where
    overloadedMethod _ = windowKeyboardSize

#endif

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

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

{- |
Asks the window manager to put /@window@/ on top of most windows (/@window@/ will
not be on top of focused fullscreen windows, of other windows with this
setting and of dock windows).

/Since: 2.14/
-}
windowMakeAbove ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowMakeAbove window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_make_above window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowMakeAboveMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowMakeAboveMethodInfo a signature where
    overloadedMethod _ = windowMakeAbove

#endif

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

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

{- |
Asks the window manager to put /@window@/ below most windows.

/Since: 2.20/
-}
windowMakeBelow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowMakeBelow window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_make_below window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowMakeBelowMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowMakeBelowMethodInfo a signature where
    overloadedMethod _ = windowMakeBelow

#endif

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

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

{- |
Asks the window manager to maximize /@window@/.
-}
windowMaximize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowMaximize window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_maximize window'
    touchManagedPtr window
    return ()

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

#endif

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

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

{- |
Asks the window manager to maximize horizontally /@window@/.
-}
windowMaximizeHorizontally ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowMaximizeHorizontally window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_maximize_horizontally window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowMaximizeHorizontallyMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowMaximizeHorizontallyMethodInfo a signature where
    overloadedMethod _ = windowMaximizeHorizontally

#endif

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

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

{- |
Asks the window manager to maximize vertically /@window@/.
-}
windowMaximizeVertically ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowMaximizeVertically window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_maximize_vertically window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowMaximizeVerticallyMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowMaximizeVerticallyMethodInfo a signature where
    overloadedMethod _ = windowMaximizeVertically

#endif

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

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

{- |
Minimizes /@window@/.
-}
windowMinimize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowMinimize window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_minimize window'
    touchManagedPtr window
    return ()

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

#endif

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

foreign import ccall "wnck_window_move_to_workspace" wnck_window_move_to_workspace :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    Ptr Wnck.Workspace.Workspace ->         -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
    IO ()

{- |
Asks the window manager to move /@window@/ to /@space@/. If /@window@/ was pinned, it
will also result in /@window@/ being visible only on /@space@/.
-}
windowMoveToWorkspace ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> b
    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
    -> m ()
windowMoveToWorkspace window space = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    space' <- unsafeManagedPtrCastPtr space
    wnck_window_move_to_workspace window' space'
    touchManagedPtr window
    touchManagedPtr space
    return ()

#if ENABLE_OVERLOADING
data WindowMoveToWorkspaceMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) => O.MethodInfo WindowMoveToWorkspaceMethodInfo a signature where
    overloadedMethod _ = windowMoveToWorkspace

#endif

-- method Window::needs_attention
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_needs_attention" wnck_window_needs_attention :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ needs attention. This state may change anytime
a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.

This state depends on flags such as the demands_attention and is_urgent
hints.

/Since: 2.12/
-}
windowNeedsAttention ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ needs attention, 'False' otherwise. -}
windowNeedsAttention window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_needs_attention window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowNeedsAttentionMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowNeedsAttentionMethodInfo a signature where
    overloadedMethod _ = windowNeedsAttention

#endif

-- method Window::or_transient_needs_attention
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_or_transient_needs_attention" wnck_window_or_transient_needs_attention :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether /@window@/ or one of its transients needs attention. This state
may change anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.

/Since: 2.12/
-}
windowOrTransientNeedsAttention ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@window@/ or one of its transients needs attention,
'False' otherwise. -}
windowOrTransientNeedsAttention window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_or_transient_needs_attention window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowOrTransientNeedsAttentionMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowOrTransientNeedsAttentionMethodInfo a signature where
    overloadedMethod _ = windowOrTransientNeedsAttention

#endif

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

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

{- |
Asks the window manager to put /@window@/ on all workspaces.
-}
windowPin ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowPin window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_pin window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowPinMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowPinMethodInfo a signature where
    overloadedMethod _ = windowPin

#endif

-- method Window::set_fullscreen
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fullscreen", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to make @window fullscreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{- |
Asks the window manager to set the fullscreen state of /@window@/ according to
/@fullscreen@/.

/Since: 2.8/
-}
windowSetFullscreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> Bool
    {- ^ /@fullscreen@/: whether to make /@window@/ fullscreen. -}
    -> m ()
windowSetFullscreen window fullscreen = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    let fullscreen' = (fromIntegral . fromEnum) fullscreen
    wnck_window_set_fullscreen window' fullscreen'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowSetFullscreenMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowSetFullscreenMethodInfo a signature where
    overloadedMethod _ = windowSetFullscreen

#endif

-- method Window::set_geometry
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gravity", argType = TInterface (Name {namespace = "Wnck", name = "WindowGravity"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the gravity point to use as a reference for the new position.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "geometry_mask", argType = TInterface (Name {namespace = "Wnck", name = "WindowMoveResizeMask"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a bitmask containing flags for what should be set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new X coordinate in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new Y coordinate in pixels of @window.", 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 "new width in pixels of @window.", 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 "new height in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "wnck_window_set_geometry" wnck_window_set_geometry :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    CUInt ->                                -- gravity : TInterface (Name {namespace = "Wnck", name = "WindowGravity"})
    CUInt ->                                -- geometry_mask : TInterface (Name {namespace = "Wnck", name = "WindowMoveResizeMask"})
    Int32 ->                                -- x : TBasicType TInt
    Int32 ->                                -- y : TBasicType TInt
    Int32 ->                                -- width : TBasicType TInt
    Int32 ->                                -- height : TBasicType TInt
    IO ()

{- |
Sets the size and position of /@window@/. The X and Y coordinates should be
relative to the root window.

Note that the new size and position apply to /@window@/ with its frame added
by the window manager. Therefore, using 'GI.Wnck.Objects.Window.windowSetGeometry' with
the values returned by 'GI.Wnck.Objects.Window.windowGetGeometry' should be a no-op, while
using 'GI.Wnck.Objects.Window.windowSetGeometry' with the values returned by
'GI.Wnck.Objects.Window.windowGetClientWindowGeometry' should reduce the size of /@window@/
and move it.

/Since: 2.16/
-}
windowSetGeometry ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> Wnck.Enums.WindowGravity
    {- ^ /@gravity@/: the gravity point to use as a reference for the new position. -}
    -> [Wnck.Flags.WindowMoveResizeMask]
    {- ^ /@geometryMask@/: a bitmask containing flags for what should be set. -}
    -> Int32
    {- ^ /@x@/: new X coordinate in pixels of /@window@/. -}
    -> Int32
    {- ^ /@y@/: new Y coordinate in pixels of /@window@/. -}
    -> Int32
    {- ^ /@width@/: new width in pixels of /@window@/. -}
    -> Int32
    {- ^ /@height@/: new height in pixels of /@window@/. -}
    -> m ()
windowSetGeometry window gravity geometryMask x y width height = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    let gravity' = (fromIntegral . fromEnum) gravity
    let geometryMask' = gflagsToWord geometryMask
    wnck_window_set_geometry window' gravity' geometryMask' x y width height
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowSetGeometryMethodInfo
instance (signature ~ (Wnck.Enums.WindowGravity -> [Wnck.Flags.WindowMoveResizeMask] -> Int32 -> Int32 -> Int32 -> Int32 -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowSetGeometryMethodInfo a signature where
    overloadedMethod _ = windowSetGeometry

#endif

-- method Window::set_icon_geometry
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate in pixels.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y coordinate in pixels.", 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.", 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.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{- |
Sets the icon geometry for /@window@/. A typical use case for this is the
destination of the minimization animation of /@window@/.
-}
windowSetIconGeometry ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> Int32
    {- ^ /@x@/: X coordinate in pixels. -}
    -> Int32
    {- ^ /@y@/: Y coordinate in pixels. -}
    -> Int32
    {- ^ /@width@/: width in pixels. -}
    -> Int32
    {- ^ /@height@/: height in pixels. -}
    -> m ()
windowSetIconGeometry window x y width height = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_set_icon_geometry window' x y width height
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowSetIconGeometryMethodInfo
instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowSetIconGeometryMethodInfo a signature where
    overloadedMethod _ = windowSetIconGeometry

#endif

-- method Window::set_skip_pager
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "skip", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether @window should be included on pagers.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{- |
Asks the window manager to make /@window@/ included or not included on pagers.
-}
windowSetSkipPager ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> Bool
    {- ^ /@skip@/: whether /@window@/ should be included on pagers. -}
    -> m ()
windowSetSkipPager window skip = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    let skip' = (fromIntegral . fromEnum) skip
    wnck_window_set_skip_pager window' skip'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowSetSkipPagerMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowSetSkipPagerMethodInfo a signature where
    overloadedMethod _ = windowSetSkipPager

#endif

-- method Window::set_skip_tasklist
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "skip", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether @window should be included on tasklists.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{- |
Asks the window manager to make /@window@/ included or not included on
tasklists.
-}
windowSetSkipTasklist ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> Bool
    {- ^ /@skip@/: whether /@window@/ should be included on tasklists. -}
    -> m ()
windowSetSkipTasklist window skip = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    let skip' = (fromIntegral . fromEnum) skip
    wnck_window_set_skip_tasklist window' skip'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowSetSkipTasklistMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowSetSkipTasklistMethodInfo a signature where
    overloadedMethod _ = windowSetSkipTasklist

#endif

-- method Window::set_sort_order
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "order", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new sort order for @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "wnck_window_set_sort_order" wnck_window_set_sort_order :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    Int32 ->                                -- order : TBasicType TInt
    IO ()

{- |
Sets the sort order of /@window@/. The sort order is used for ordering of
/@window@/ in 'GI.Wnck.Objects.Selector.Selector' and 'GI.Wnck.Objects.Tasklist.Tasklist'.

/Since: 2.20/
-}
windowSetSortOrder ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> Int32
    {- ^ /@order@/: new sort order for /@window@/. -}
    -> m ()
windowSetSortOrder window order = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_set_sort_order window' order
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowSetSortOrderMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowSetSortOrderMethodInfo a signature where
    overloadedMethod _ = windowSetSortOrder

#endif

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

foreign import ccall "wnck_window_set_window_type" wnck_window_set_window_type :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    CUInt ->                                -- wintype : TInterface (Name {namespace = "Wnck", name = "WindowType"})
    IO ()

{- |
Sets the semantic type of /@window@/ to /@wintype@/.

/Since: 2.12/
-}
windowSetWindowType ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> Wnck.Enums.WindowType
    {- ^ /@wintype@/: a semantic type. -}
    -> m ()
windowSetWindowType window wintype = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    let wintype' = (fromIntegral . fromEnum) wintype
    wnck_window_set_window_type window' wintype'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowSetWindowTypeMethodInfo
instance (signature ~ (Wnck.Enums.WindowType -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowSetWindowTypeMethodInfo a signature where
    overloadedMethod _ = windowSetWindowType

#endif

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

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

{- |
Asks the window manager to shade /@window@/.
-}
windowShade ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowShade window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_shade window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowShadeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowShadeMethodInfo a signature where
    overloadedMethod _ = windowShade

#endif

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

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

{- |
Asks the window manager to keep the /@window@/\<!-- -->\'s position fixed on the
screen, even when the workspace or viewport scrolls.
-}
windowStick ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowStick window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_stick window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowStickMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowStickMethodInfo a signature where
    overloadedMethod _ = windowStick

#endif

-- method Window::transient_is_most_recently_activated
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 "wnck_window_transient_is_most_recently_activated" wnck_window_transient_is_most_recently_activated :: 
    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
    IO CInt

{- |
Gets whether one of the transients of /@window@/ is the most
recently activated window. See
'GI.Wnck.Objects.Window.windowIsMostRecentlyActivated' for a more complete
description of what is meant by most recently activated.  This
function is needed because clicking on a 'GI.Wnck.Objects.Tasklist.Tasklist' once will
activate a transient instead of /@window@/ itself
(wnck_window_activate_transient), and clicking again should
minimize /@window@/ and its transients.  (Not doing this can be
especially annoying in the case of modal dialogs that don\'t appear
in the 'GI.Wnck.Objects.Tasklist.Tasklist').

/Since: 2.12/
-}
windowTransientIsMostRecentlyActivated ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if one of the transients of /@window@/ is the most recently
activated window, 'False' otherwise. -}
windowTransientIsMostRecentlyActivated window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    result <- wnck_window_transient_is_most_recently_activated window'
    let result' = (/= 0) result
    touchManagedPtr window
    return result'

#if ENABLE_OVERLOADING
data WindowTransientIsMostRecentlyActivatedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowTransientIsMostRecentlyActivatedMethodInfo a signature where
    overloadedMethod _ = windowTransientIsMostRecentlyActivated

#endif

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

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

{- |
Asks the window manager to not put /@window@/ on top of most windows, and to
put it again in the stack with other windows.

/Since: 2.14/
-}
windowUnmakeAbove ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowUnmakeAbove window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_unmake_above window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowUnmakeAboveMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnmakeAboveMethodInfo a signature where
    overloadedMethod _ = windowUnmakeAbove

#endif

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

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

{- |
Asks the window manager to not put /@window@/ below most windows, and to
put it again in the stack with other windows.

/Since: 2.20/
-}
windowUnmakeBelow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowUnmakeBelow window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_unmake_below window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowUnmakeBelowMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnmakeBelowMethodInfo a signature where
    overloadedMethod _ = windowUnmakeBelow

#endif

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

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

{- |
Asks the window manager to unmaximize /@window@/.
-}
windowUnmaximize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowUnmaximize window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_unmaximize window'
    touchManagedPtr window
    return ()

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

#endif

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

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

{- |
Asks the window manager to unmaximize horizontally /@window@/.
-}
windowUnmaximizeHorizontally ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowUnmaximizeHorizontally window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_unmaximize_horizontally window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowUnmaximizeHorizontallyMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnmaximizeHorizontallyMethodInfo a signature where
    overloadedMethod _ = windowUnmaximizeHorizontally

#endif

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

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

{- |
Asks the window manager to unmaximize vertically /@window@/.
-}
windowUnmaximizeVertically ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowUnmaximizeVertically window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_unmaximize_vertically window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowUnmaximizeVerticallyMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnmaximizeVerticallyMethodInfo a signature where
    overloadedMethod _ = windowUnmaximizeVertically

#endif

-- method Window::unminimize
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", 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 X server timestamp of the user interaction event that caused\nthis call to occur.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{- |
Unminimizes /@window@/ by activating it or one of its transients. See
'GI.Wnck.Objects.Window.windowActivateTransient' for details on how the activation is done.
-}
windowUnminimize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> Word32
    {- ^ /@timestamp@/: the X server timestamp of the user interaction event that caused
this call to occur. -}
    -> m ()
windowUnminimize window timestamp = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_unminimize window' timestamp
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowUnminimizeMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnminimizeMethodInfo a signature where
    overloadedMethod _ = windowUnminimize

#endif

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

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

{- |
Asks the window manager to put /@window@/ only in the currently active
workspace, if /@window@/ was previously pinned. If /@window@/ was not pinned,
does not change /@window@/\<!-- -->\'s workspace. If the active workspace
is not known for some reason (it should not happen much), sets
/@window@/\<!-- -->\'s workspace to the first workspace.
-}
windowUnpin ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowUnpin window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_unpin window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowUnpinMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnpinMethodInfo a signature where
    overloadedMethod _ = windowUnpin

#endif

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

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

{- |
Asks the window manager to unshade /@window@/.
-}
windowUnshade ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowUnshade window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_unshade window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowUnshadeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnshadeMethodInfo a signature where
    overloadedMethod _ = windowUnshade

#endif

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

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

{- |
Asks the window manager to not have /@window@/\<!-- -->\'s position fixed on the
screen when the workspace or viewport scrolls.
-}
windowUnstick ::
    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
    a
    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
    -> m ()
windowUnstick window = liftIO $ do
    window' <- unsafeManagedPtrCastPtr window
    wnck_window_unstick window'
    touchManagedPtr window
    return ()

#if ENABLE_OVERLOADING
data WindowUnstickMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnstickMethodInfo a signature where
    overloadedMethod _ = windowUnstick

#endif

-- method Window::get
-- method type : MemberFunction
-- Args : [Arg {argCName = "xwindow", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an X window ID.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Window"}))
-- throws : False
-- Skip return : False

foreign import ccall "wnck_window_get" wnck_window_get :: 
    CULong ->                               -- xwindow : TBasicType TULong
    IO (Ptr Window)

{- |
Gets a preexisting 'GI.Wnck.Objects.Window.Window' for the X window /@xwindow@/. This will not
create a 'GI.Wnck.Objects.Window.Window' if none exists. The function is robust against bogus
window IDs.
-}
windowGet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CULong
    {- ^ /@xwindow@/: an X window ID. -}
    -> m Window
    {- ^ __Returns:__ the 'GI.Wnck.Objects.Window.Window' for /@xwindow@/. The returned
'GI.Wnck.Objects.Window.Window' is owned by libwnck and must not be referenced or unreferenced. -}
windowGet xwindow = liftIO $ do
    result <- wnck_window_get xwindow
    checkUnexpectedReturnNULL "windowGet" result
    result' <- (newObject Window) result
    return result'

#if ENABLE_OVERLOADING
#endif