gi-wnck 3.0.1 → 3.0.3

raw patch · 38 files changed

+17001/−9 lines, 38 filesdep ~haskell-gidep ~haskell-gi-basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: haskell-gi, haskell-gi-base

API changes (from Hackage documentation)

Files

• ChangeLog.md +8/−0
• GI/Wnck.hs +56/−0
• GI/Wnck/Constants.hs +75/−0
• GI/Wnck/Enums.hs +500/−0
• GI/Wnck/Enums.hs-boot +46/−0
• GI/Wnck/Flags.hs +364/−0
• GI/Wnck/Flags.hs-boot +36/−0
• GI/Wnck/Functions.hs +290/−0
• GI/Wnck/Objects.hs +59/−0
• GI/Wnck/Objects/ActionMenu.hs +568/−0
• GI/Wnck/Objects/ActionMenu.hs-boot +32/−0
• GI/Wnck/Objects/Application.hs +810/−0
• GI/Wnck/Objects/Application.hs-boot +65/−0
• GI/Wnck/Objects/ClassGroup.hs +653/−0
• GI/Wnck/Objects/ClassGroup.hs-boot +53/−0
• GI/Wnck/Objects/ImageMenuItem.hs +695/−0
• GI/Wnck/Objects/ImageMenuItem.hs-boot +41/−0
• GI/Wnck/Objects/Pager.hs +798/−0
• GI/Wnck/Objects/Pager.hs-boot +50/−0
• GI/Wnck/Objects/Screen.hs +2754/−0
• GI/Wnck/Objects/Screen.hs-boot +140/−0
• GI/Wnck/Objects/Selector.hs +480/−0
• GI/Wnck/Objects/Selector.hs-boot +29/−0
• GI/Wnck/Objects/Tasklist.hs +1141/−0
• GI/Wnck/Objects/Tasklist.hs-boot +65/−0
• GI/Wnck/Objects/Window.hs +4675/−0
• GI/Wnck/Objects/Window.hs-boot +287/−0
• GI/Wnck/Objects/Workspace.hs +836/−0
• GI/Wnck/Objects/Workspace.hs-boot +71/−0
• GI/Wnck/Structs.hs +43/−0
• GI/Wnck/Structs/ResourceUsage.hs +757/−0
• GI/Wnck/Structs/ResourceUsage.hs-boot +26/−0
• GI/Wnck/Structs/WorkspaceLayout.hs +429/−0
• GI/Wnck/Structs/WorkspaceLayout.hs-boot +26/−0
• LICENSE +14/−0
• README.md +1/−1
• gi-wnck.cabal +27/−7
• stack.yaml +1/−1

@@ -1,3 +1,11 @@+### 3.0.3+++ Update to haskell-gi(-base) 0.22++### 3.0.2+++ Update stack version to 12.10+ ### 3.0.1  + Initial release.

@@ -0,0 +1,56 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Wnck+    (     module GI.Wnck.Constants                ,+    module GI.Wnck.Enums                    ,+    module GI.Wnck.Flags                    ,+    module GI.Wnck.Functions                ,+    module GI.Wnck.Objects                  ,+    module GI.Wnck.Structs                  ,++++    module Data.GI.Base                     ,+++    ) where++import GI.Wnck.Constants+import GI.Wnck.Enums+import GI.Wnck.Flags+import GI.Wnck.Functions+import GI.Wnck.Objects+import GI.Wnck.Structs++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 Data.GI.Base+

@@ -0,0 +1,75 @@+{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Wnck.Constants+    ( +    pattern MINOR_VERSION                   ,+    pattern MICRO_VERSION                   ,+    pattern MAJOR_VERSION                   ,+    pattern DEFAULT_MINI_ICON_SIZE          ,+    pattern DEFAULT_ICON_SIZE               ,++    ) 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+++{- |+/No description available in the introspection data./++/Since: 3.0/+-}+pattern MINOR_VERSION = 32 :: Int32++{- |+/No description available in the introspection data./++/Since: 3.0/+-}+pattern MICRO_VERSION = 0 :: Int32++{- |+/No description available in the introspection data./++/Since: 3.0/+-}+pattern MAJOR_VERSION = 3 :: Int32++{- |+/No description available in the introspection data./+-}+pattern DEFAULT_MINI_ICON_SIZE = 16 :: Int32++{- |+/No description available in the introspection data./+-}+pattern DEFAULT_ICON_SIZE = 32 :: Int32++

@@ -0,0 +1,500 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Wnck.Enums+    ( ++ -- * Enumerations+-- ** ClientType #enum:ClientType#++    ClientType(..)                          ,+++-- ** LayoutCorner_ #enum:LayoutCorner_#++    LayoutCorner_(..)                       ,+++-- ** LayoutOrientation_ #enum:LayoutOrientation_#++    LayoutOrientation_(..)                  ,+++-- ** MotionDirection #enum:MotionDirection#++    MotionDirection(..)                     ,+++-- ** PagerDisplayMode #enum:PagerDisplayMode#++    PagerDisplayMode(..)                    ,+++-- ** TasklistGroupingType #enum:TasklistGroupingType#++    TasklistGroupingType(..)                ,+++-- ** WindowGravity #enum:WindowGravity#++    WindowGravity(..)                       ,+++-- ** WindowType #enum:WindowType#++    WindowType(..)                          ,+++++    ) 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+++-- Enum _LayoutOrientation+{- |+/No description available in the introspection data./+-}+data LayoutOrientation_ = +      LayoutOrientationHorizontal_+    {- ^+    /No description available in the introspection data./+    -}+    | LayoutOrientationVertical_+    {- ^+    /No description available in the introspection data./+    -}+    | AnotherLayoutOrientation_ Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum LayoutOrientation_ where+    fromEnum LayoutOrientationHorizontal_ = 0+    fromEnum LayoutOrientationVertical_ = 1+    fromEnum (AnotherLayoutOrientation_ k) = k++    toEnum 0 = LayoutOrientationHorizontal_+    toEnum 1 = LayoutOrientationVertical_+    toEnum k = AnotherLayoutOrientation_ k++instance P.Ord LayoutOrientation_ where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++-- Enum _LayoutCorner+{- |+/No description available in the introspection data./+-}+data LayoutCorner_ = +      LayoutCornerTopleft_+    {- ^+    /No description available in the introspection data./+    -}+    | LayoutCornerTopright_+    {- ^+    /No description available in the introspection data./+    -}+    | LayoutCornerBottomright_+    {- ^+    /No description available in the introspection data./+    -}+    | LayoutCornerBottomleft_+    {- ^+    /No description available in the introspection data./+    -}+    | AnotherLayoutCorner_ Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum LayoutCorner_ where+    fromEnum LayoutCornerTopleft_ = 0+    fromEnum LayoutCornerTopright_ = 1+    fromEnum LayoutCornerBottomright_ = 2+    fromEnum LayoutCornerBottomleft_ = 3+    fromEnum (AnotherLayoutCorner_ k) = k++    toEnum 0 = LayoutCornerTopleft_+    toEnum 1 = LayoutCornerTopright_+    toEnum 2 = LayoutCornerBottomright_+    toEnum 3 = LayoutCornerBottomleft_+    toEnum k = AnotherLayoutCorner_ k++instance P.Ord LayoutCorner_ where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++-- Enum WindowType+{- |+Type describing the semantic type of a 'GI.Wnck.Objects.Window.Window'.+-}+data WindowType = +      WindowTypeNormal+    {- ^+    the window is a normal window.+    -}+    | WindowTypeDesktop+    {- ^+    the window is a desktop.+    -}+    | WindowTypeDock+    {- ^+    the window is a dock or a panel.+    -}+    | WindowTypeDialog+    {- ^+    the window is a dialog window.+    -}+    | WindowTypeToolbar+    {- ^+    the window is a tearoff toolbar.+    -}+    | WindowTypeMenu+    {- ^+    the window is a tearoff menu.+    -}+    | WindowTypeUtility+    {- ^+    the window is a small persistent utility window, such+    as a palette or toolbox.+    -}+    | WindowTypeSplashscreen+    {- ^+    the window is a splash screen displayed as an+    application is starting up.+    -}+    | AnotherWindowType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum WindowType where+    fromEnum WindowTypeNormal = 0+    fromEnum WindowTypeDesktop = 1+    fromEnum WindowTypeDock = 2+    fromEnum WindowTypeDialog = 3+    fromEnum WindowTypeToolbar = 4+    fromEnum WindowTypeMenu = 5+    fromEnum WindowTypeUtility = 6+    fromEnum WindowTypeSplashscreen = 7+    fromEnum (AnotherWindowType k) = k++    toEnum 0 = WindowTypeNormal+    toEnum 1 = WindowTypeDesktop+    toEnum 2 = WindowTypeDock+    toEnum 3 = WindowTypeDialog+    toEnum 4 = WindowTypeToolbar+    toEnum 5 = WindowTypeMenu+    toEnum 6 = WindowTypeUtility+    toEnum 7 = WindowTypeSplashscreen+    toEnum k = AnotherWindowType k++instance P.Ord WindowType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "wnck_window_type_get_type" c_wnck_window_type_get_type :: +    IO GType++instance BoxedEnum WindowType where+    boxedEnumType _ = c_wnck_window_type_get_type++-- Enum WindowGravity+{- |+Flag used when changing the geometry of a 'GI.Wnck.Objects.Window.Window'. This is the gravity+point to use as a reference for the new position.++/Since: 2.16/+-}+data WindowGravity = +      WindowGravityCurrent+    {- ^+    keep the current gravity point.+    -}+    | WindowGravityNorthwest+    {- ^+    use the left top corner of the frame window+    as gravity point.+    -}+    | WindowGravityNorth+    {- ^+    use the center of the frame window\'s top side as+    gravity point.+    -}+    | WindowGravityNortheast+    {- ^+    use the right top corner of the frame window+    as gravity point.+    -}+    | WindowGravityWest+    {- ^+    use the center of the frame window\'s left side as+    gravity point.+    -}+    | WindowGravityCenter+    {- ^+    use the center of the frame window as gravity+    point.+    -}+    | WindowGravityEast+    {- ^+    use the center of the frame window\'s right side+    as gravity point.+    -}+    | WindowGravitySouthwest+    {- ^+    use the left bottom corner of the frame+    window as gravity point.+    -}+    | WindowGravitySouth+    {- ^+    use the center of the frame window\'s bottom side+    as gravity point.+    -}+    | WindowGravitySoutheast+    {- ^+    use the right bottom corner of the frame+    window as gravity point.+    -}+    | WindowGravityStatic+    {- ^+    use the left top corner of the client window as+    gravity point.+    -}+    | AnotherWindowGravity Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum WindowGravity where+    fromEnum WindowGravityCurrent = 0+    fromEnum WindowGravityNorthwest = 1+    fromEnum WindowGravityNorth = 2+    fromEnum WindowGravityNortheast = 3+    fromEnum WindowGravityWest = 4+    fromEnum WindowGravityCenter = 5+    fromEnum WindowGravityEast = 6+    fromEnum WindowGravitySouthwest = 7+    fromEnum WindowGravitySouth = 8+    fromEnum WindowGravitySoutheast = 9+    fromEnum WindowGravityStatic = 10+    fromEnum (AnotherWindowGravity k) = k++    toEnum 0 = WindowGravityCurrent+    toEnum 1 = WindowGravityNorthwest+    toEnum 2 = WindowGravityNorth+    toEnum 3 = WindowGravityNortheast+    toEnum 4 = WindowGravityWest+    toEnum 5 = WindowGravityCenter+    toEnum 6 = WindowGravityEast+    toEnum 7 = WindowGravitySouthwest+    toEnum 8 = WindowGravitySouth+    toEnum 9 = WindowGravitySoutheast+    toEnum 10 = WindowGravityStatic+    toEnum k = AnotherWindowGravity k++instance P.Ord WindowGravity where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "wnck_window_gravity_get_type" c_wnck_window_gravity_get_type :: +    IO GType++instance BoxedEnum WindowGravity where+    boxedEnumType _ = c_wnck_window_gravity_get_type++-- Enum TasklistGroupingType+{- |+Type defining the policy of the 'GI.Wnck.Objects.Tasklist.Tasklist' for grouping multiple+'GI.Wnck.Objects.Window.Window' of the same 'GI.Wnck.Objects.Application.Application'.+-}+data TasklistGroupingType = +      TasklistGroupingTypeNeverGroup+    {- ^+    never group multiple 'GI.Wnck.Objects.Window.Window' of the same+    'GI.Wnck.Objects.Application.Application'.+    -}+    | TasklistGroupingTypeAutoGroup+    {- ^+    group multiple 'GI.Wnck.Objects.Window.Window' of the same+    'GI.Wnck.Objects.Application.Application' for some 'GI.Wnck.Objects.Application.Application', when there is not enough place+    to have a good-looking list of all 'GI.Wnck.Objects.Window.Window'.+    -}+    | TasklistGroupingTypeAlwaysGroup+    {- ^+    always group multiple 'GI.Wnck.Objects.Window.Window' of the same+    'GI.Wnck.Objects.Application.Application', for all 'GI.Wnck.Objects.Application.Application'.+    -}+    | AnotherTasklistGroupingType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum TasklistGroupingType where+    fromEnum TasklistGroupingTypeNeverGroup = 0+    fromEnum TasklistGroupingTypeAutoGroup = 1+    fromEnum TasklistGroupingTypeAlwaysGroup = 2+    fromEnum (AnotherTasklistGroupingType k) = k++    toEnum 0 = TasklistGroupingTypeNeverGroup+    toEnum 1 = TasklistGroupingTypeAutoGroup+    toEnum 2 = TasklistGroupingTypeAlwaysGroup+    toEnum k = AnotherTasklistGroupingType k++instance P.Ord TasklistGroupingType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "wnck_tasklist_grouping_type_get_type" c_wnck_tasklist_grouping_type_get_type :: +    IO GType++instance BoxedEnum TasklistGroupingType where+    boxedEnumType _ = c_wnck_tasklist_grouping_type_get_type++-- Enum PagerDisplayMode+{- |+Mode defining what a 'GI.Wnck.Objects.Pager.Pager' will display.+-}+data PagerDisplayMode = +      PagerDisplayModeName+    {- ^+    the 'GI.Wnck.Objects.Pager.Pager' will only display the names of the+    workspaces.+    -}+    | PagerDisplayModeContent+    {- ^+    the 'GI.Wnck.Objects.Pager.Pager' will display a representation+    for each window in the workspaces.+    -}+    | AnotherPagerDisplayMode Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum PagerDisplayMode where+    fromEnum PagerDisplayModeName = 0+    fromEnum PagerDisplayModeContent = 1+    fromEnum (AnotherPagerDisplayMode k) = k++    toEnum 0 = PagerDisplayModeName+    toEnum 1 = PagerDisplayModeContent+    toEnum k = AnotherPagerDisplayMode k++instance P.Ord PagerDisplayMode where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "wnck_pager_display_mode_get_type" c_wnck_pager_display_mode_get_type :: +    IO GType++instance BoxedEnum PagerDisplayMode where+    boxedEnumType _ = c_wnck_pager_display_mode_get_type++-- Enum MotionDirection+{- |+Type defining a direction in which to search a neighbor 'GI.Wnck.Objects.Workspace.Workspace'.++/Since: 2.14/+-}+data MotionDirection = +      MotionDirectionUp+    {- ^+    search a neighbor 'GI.Wnck.Objects.Workspace.Workspace' above another+    'GI.Wnck.Objects.Workspace.Workspace'.+    -}+    | MotionDirectionDown+    {- ^+    search a neighbor 'GI.Wnck.Objects.Workspace.Workspace' below another+    'GI.Wnck.Objects.Workspace.Workspace'.+    -}+    | MotionDirectionLeft+    {- ^+    search a neighbor 'GI.Wnck.Objects.Workspace.Workspace' at the left of another+    'GI.Wnck.Objects.Workspace.Workspace'.+    -}+    | MotionDirectionRight+    {- ^+    search a neighbor 'GI.Wnck.Objects.Workspace.Workspace' at the right of another+    'GI.Wnck.Objects.Workspace.Workspace'.+    -}+    | AnotherMotionDirection Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum MotionDirection where+    fromEnum MotionDirectionUp = -1+    fromEnum MotionDirectionDown = -2+    fromEnum MotionDirectionLeft = -3+    fromEnum MotionDirectionRight = -4+    fromEnum (AnotherMotionDirection k) = k++    toEnum -1 = MotionDirectionUp+    toEnum -2 = MotionDirectionDown+    toEnum -3 = MotionDirectionLeft+    toEnum -4 = MotionDirectionRight+    toEnum k = AnotherMotionDirection k++instance P.Ord MotionDirection where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "wnck_motion_direction_get_type" c_wnck_motion_direction_get_type :: +    IO GType++instance BoxedEnum MotionDirection where+    boxedEnumType _ = c_wnck_motion_direction_get_type++-- Enum ClientType+{- |+Type describing the role of the libwnck user.++/Since: 2.14/+-}+data ClientType = +      ClientTypeApplication+    {- ^+    the libwnck user is a normal application.+    -}+    | ClientTypePager+    {- ^+    the libwnck user is an utility application dealing+    with window management, like pagers and taskbars.+    -}+    | AnotherClientType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum ClientType where+    fromEnum ClientTypeApplication = 1+    fromEnum ClientTypePager = 2+    fromEnum (AnotherClientType k) = k++    toEnum 1 = ClientTypeApplication+    toEnum 2 = ClientTypePager+    toEnum k = AnotherClientType k++instance P.Ord ClientType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "wnck_client_type_get_type" c_wnck_client_type_get_type :: +    IO GType++instance BoxedEnum ClientType where+    boxedEnumType _ = c_wnck_client_type_get_type++

@@ -0,0 +1,46 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Wnck.Enums 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++data LayoutOrientation_+instance P.Enum LayoutOrientation_ where+data LayoutCorner_+instance P.Enum LayoutCorner_ where+data WindowType+instance P.Enum WindowType where+instance BoxedEnum WindowType where+data WindowGravity+instance P.Enum WindowGravity where+instance BoxedEnum WindowGravity where+data TasklistGroupingType+instance P.Enum TasklistGroupingType where+instance BoxedEnum TasklistGroupingType where+data PagerDisplayMode+instance P.Enum PagerDisplayMode where+instance BoxedEnum PagerDisplayMode where+data MotionDirection+instance P.Enum MotionDirection where+instance BoxedEnum MotionDirection where+data ClientType+instance P.Enum ClientType where+instance BoxedEnum ClientType where

@@ -0,0 +1,364 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Wnck.Flags+    ( ++ -- * Flags+-- ** WindowActions #flag:WindowActions#++    WindowActions(..)                       ,+++-- ** WindowMoveResizeMask #flag:WindowMoveResizeMask#++    WindowMoveResizeMask(..)                ,+++-- ** WindowState #flag:WindowState#++    WindowState(..)                         ,+++++    ) 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+++-- Flags WindowState+{- |+Type used as a bitmask to describe the state of a 'GI.Wnck.Objects.Window.Window'.+-}+data WindowState = +      WindowStateMinimized+    {- ^+    the window is minimized.+    -}+    | WindowStateMaximizedHorizontally+    {- ^+    the window is horizontically+    maximized.+    -}+    | WindowStateMaximizedVertically+    {- ^+    the window is vertically maximized.+    -}+    | WindowStateShaded+    {- ^+    the window is shaded.+    -}+    | WindowStateSkipPager+    {- ^+    the window should not be included on pagers.+    -}+    | WindowStateSkipTasklist+    {- ^+    the window should not be included on+    tasklists.+    -}+    | WindowStateSticky+    {- ^+    the window is sticky (see+    'GI.Wnck.Objects.Window.windowIsSticky').+    -}+    | WindowStateHidden+    {- ^+    the window is not visible on its 'GI.Wnck.Objects.Workspace.Workspace'+    and viewport (when minimized, for example).+    -}+    | WindowStateFullscreen+    {- ^+    the window is fullscreen.+    -}+    | WindowStateDemandsAttention+    {- ^+    the window needs attention (because+    the window requested activation but the window manager refused it, for+    example).+    -}+    | WindowStateUrgent+    {- ^+    the window requires a response from the user.+    -}+    | WindowStateAbove+    {- ^+    the window is above other windows (see+    'GI.Wnck.Objects.Window.windowMakeAbove').+    -}+    | WindowStateBelow+    {- ^+    the window is below other windows (see+    'GI.Wnck.Objects.Window.windowMakeBelow').+    -}+    | AnotherWindowState Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum WindowState where+    fromEnum WindowStateMinimized = 1+    fromEnum WindowStateMaximizedHorizontally = 2+    fromEnum WindowStateMaximizedVertically = 4+    fromEnum WindowStateShaded = 8+    fromEnum WindowStateSkipPager = 16+    fromEnum WindowStateSkipTasklist = 32+    fromEnum WindowStateSticky = 64+    fromEnum WindowStateHidden = 128+    fromEnum WindowStateFullscreen = 256+    fromEnum WindowStateDemandsAttention = 512+    fromEnum WindowStateUrgent = 1024+    fromEnum WindowStateAbove = 2048+    fromEnum WindowStateBelow = 4096+    fromEnum (AnotherWindowState k) = k++    toEnum 1 = WindowStateMinimized+    toEnum 2 = WindowStateMaximizedHorizontally+    toEnum 4 = WindowStateMaximizedVertically+    toEnum 8 = WindowStateShaded+    toEnum 16 = WindowStateSkipPager+    toEnum 32 = WindowStateSkipTasklist+    toEnum 64 = WindowStateSticky+    toEnum 128 = WindowStateHidden+    toEnum 256 = WindowStateFullscreen+    toEnum 512 = WindowStateDemandsAttention+    toEnum 1024 = WindowStateUrgent+    toEnum 2048 = WindowStateAbove+    toEnum 4096 = WindowStateBelow+    toEnum k = AnotherWindowState k++instance P.Ord WindowState where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "wnck_window_state_get_type" c_wnck_window_state_get_type :: +    IO GType++instance BoxedFlags WindowState where+    boxedFlagsType _ = c_wnck_window_state_get_type++instance IsGFlag WindowState++-- Flags WindowMoveResizeMask+{- |+Flag used as a bitmask when changing the geometry of a 'GI.Wnck.Objects.Window.Window'. This+indicates which part of the geometry should be changed.++/Since: 2.16/+-}+data WindowMoveResizeMask = +      WindowMoveResizeMaskX+    {- ^+    X coordinate of the window should be changed.+    -}+    | WindowMoveResizeMaskY+    {- ^+    Y coordinate of the window should be changed.+    -}+    | WindowMoveResizeMaskWidth+    {- ^+    width of the window should be changed.+    -}+    | WindowMoveResizeMaskHeight+    {- ^+    height of the window should be changed.+    -}+    | AnotherWindowMoveResizeMask Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum WindowMoveResizeMask where+    fromEnum WindowMoveResizeMaskX = 1+    fromEnum WindowMoveResizeMaskY = 2+    fromEnum WindowMoveResizeMaskWidth = 4+    fromEnum WindowMoveResizeMaskHeight = 8+    fromEnum (AnotherWindowMoveResizeMask k) = k++    toEnum 1 = WindowMoveResizeMaskX+    toEnum 2 = WindowMoveResizeMaskY+    toEnum 4 = WindowMoveResizeMaskWidth+    toEnum 8 = WindowMoveResizeMaskHeight+    toEnum k = AnotherWindowMoveResizeMask k++instance P.Ord WindowMoveResizeMask where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "wnck_window_move_resize_mask_get_type" c_wnck_window_move_resize_mask_get_type :: +    IO GType++instance BoxedFlags WindowMoveResizeMask where+    boxedFlagsType _ = c_wnck_window_move_resize_mask_get_type++instance IsGFlag WindowMoveResizeMask++-- Flags WindowActions+{- |+Type used as a bitmask to describe the actions that can be done for a+'GI.Wnck.Objects.Window.Window'.+-}+data WindowActions = +      WindowActionsMove+    {- ^+    the window may be moved around the screen.+    -}+    | WindowActionsResize+    {- ^+    the window may be resized.+    -}+    | WindowActionsShade+    {- ^+    the window may be shaded.+    -}+    | WindowActionsStick+    {- ^+    the window may be sticked.+    -}+    | WindowActionsMaximizeHorizontally+    {- ^+    the window may be maximized+    horizontally.+    -}+    | WindowActionsMaximizeVertically+    {- ^+    the window may be maximized+    vertically.+    -}+    | WindowActionsChangeWorkspace+    {- ^+    the window may be moved between+    workspaces, or (un)pinned.+    -}+    | WindowActionsClose+    {- ^+    the window may be closed.+    -}+    | WindowActionsUnmaximizeHorizontally+    {- ^+    the window may be unmaximized+    horizontally.+    -}+    | WindowActionsUnmaximizeVertically+    {- ^+    the window may be maximized+    vertically.+    -}+    | WindowActionsUnshade+    {- ^+    the window may be unshaded.+    -}+    | WindowActionsUnstick+    {- ^+    the window may be unsticked.+    -}+    | WindowActionsMinimize+    {- ^+    the window may be minimized.+    -}+    | WindowActionsUnminimize+    {- ^+    the window may be unminimized.+    -}+    | WindowActionsMaximize+    {- ^+    the window may be maximized.+    -}+    | WindowActionsUnmaximize+    {- ^+    the window may be unmaximized.+    -}+    | WindowActionsFullscreen+    {- ^+    the window may be brought to fullscreen.+    -}+    | WindowActionsAbove+    {- ^+    the window may be made above other windows.+    -}+    | WindowActionsBelow+    {- ^+    the window may be made below other windows.+    -}+    | AnotherWindowActions Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum WindowActions where+    fromEnum WindowActionsMove = 1+    fromEnum WindowActionsResize = 2+    fromEnum WindowActionsShade = 4+    fromEnum WindowActionsStick = 8+    fromEnum WindowActionsMaximizeHorizontally = 16+    fromEnum WindowActionsMaximizeVertically = 32+    fromEnum WindowActionsChangeWorkspace = 64+    fromEnum WindowActionsClose = 128+    fromEnum WindowActionsUnmaximizeHorizontally = 256+    fromEnum WindowActionsUnmaximizeVertically = 512+    fromEnum WindowActionsUnshade = 1024+    fromEnum WindowActionsUnstick = 2048+    fromEnum WindowActionsMinimize = 4096+    fromEnum WindowActionsUnminimize = 8192+    fromEnum WindowActionsMaximize = 16384+    fromEnum WindowActionsUnmaximize = 32768+    fromEnum WindowActionsFullscreen = 65536+    fromEnum WindowActionsAbove = 131072+    fromEnum WindowActionsBelow = 262144+    fromEnum (AnotherWindowActions k) = k++    toEnum 1 = WindowActionsMove+    toEnum 2 = WindowActionsResize+    toEnum 4 = WindowActionsShade+    toEnum 8 = WindowActionsStick+    toEnum 16 = WindowActionsMaximizeHorizontally+    toEnum 32 = WindowActionsMaximizeVertically+    toEnum 64 = WindowActionsChangeWorkspace+    toEnum 128 = WindowActionsClose+    toEnum 256 = WindowActionsUnmaximizeHorizontally+    toEnum 512 = WindowActionsUnmaximizeVertically+    toEnum 1024 = WindowActionsUnshade+    toEnum 2048 = WindowActionsUnstick+    toEnum 4096 = WindowActionsMinimize+    toEnum 8192 = WindowActionsUnminimize+    toEnum 16384 = WindowActionsMaximize+    toEnum 32768 = WindowActionsUnmaximize+    toEnum 65536 = WindowActionsFullscreen+    toEnum 131072 = WindowActionsAbove+    toEnum 262144 = WindowActionsBelow+    toEnum k = AnotherWindowActions k++instance P.Ord WindowActions where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "wnck_window_actions_get_type" c_wnck_window_actions_get_type :: +    IO GType++instance BoxedFlags WindowActions where+    boxedFlagsType _ = c_wnck_window_actions_get_type++instance IsGFlag WindowActions++

@@ -0,0 +1,36 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Wnck.Flags 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++data WindowState+instance P.Enum WindowState where+instance BoxedFlags WindowState where+instance IsGFlag WindowState+data WindowMoveResizeMask+instance P.Enum WindowMoveResizeMask where+instance BoxedFlags WindowMoveResizeMask where+instance IsGFlag WindowMoveResizeMask+data WindowActions+instance P.Enum WindowActions where+instance BoxedFlags WindowActions where+instance IsGFlag WindowActions

@@ -0,0 +1,290 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Wnck.Functions+    ( ++ -- * Methods+-- ** pidReadResourceUsage #method:pidReadResourceUsage#++    pidReadResourceUsage                    ,+++-- ** setClientType #method:setClientType#++    setClientType                           ,+++-- ** setDefaultIconSize #method:setDefaultIconSize#++    setDefaultIconSize                      ,+++-- ** setDefaultMiniIconSize #method:setDefaultMiniIconSize#++    setDefaultMiniIconSize                  ,+++-- ** shutdown #method:shutdown#++    shutdown                                ,+++-- ** xidReadResourceUsage #method:xidReadResourceUsage#++    xidReadResourceUsage                    ,+++++    ) 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.Gdk.Objects.Display as Gdk.Display+import {-# SOURCE #-} qualified GI.Wnck.Enums as Wnck.Enums+import {-# SOURCE #-} qualified GI.Wnck.Structs.ResourceUsage as Wnck.ResourceUsage++-- function wnck_xid_read_resource_usage+-- Args : [Arg {argCName = "gdk_display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a <classname>GdkDisplay</classname>.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xid", 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},Arg {argCName = "usage", argType = TInterface (Name {namespace = "Wnck", name = "ResourceUsage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the X resource usage of the application owning\nthe X window ID @xid.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_xid_read_resource_usage" wnck_xid_read_resource_usage :: +    Ptr Gdk.Display.Display ->              -- gdk_display : TInterface (Name {namespace = "Gdk", name = "Display"})+    CULong ->                               -- xid : TBasicType TULong+    Ptr Wnck.ResourceUsage.ResourceUsage -> -- usage : TInterface (Name {namespace = "Wnck", name = "ResourceUsage"})+    IO ()++{- |+Looks for the X resource usage of the application owning the X window ID+/@xid@/ on display /@gdisplay@/. If no resource usage can be found, then all+fields of /@usage@/ are set to 0.++To properly work, this function requires the XRes extension on the X server.++/Since: 2.6/+-}+xidReadResourceUsage ::+    (B.CallStack.HasCallStack, MonadIO m, Gdk.Display.IsDisplay a) =>+    a+    {- ^ /@gdkDisplay@/: a \<classname>GdkDisplay\<\/classname>. -}+    -> CULong+    {- ^ /@xid@/: an X window ID. -}+    -> Wnck.ResourceUsage.ResourceUsage+    {- ^ /@usage@/: return location for the X resource usage of the application owning+the X window ID /@xid@/. -}+    -> m ()+xidReadResourceUsage gdkDisplay xid usage = liftIO $ do+    gdkDisplay' <- unsafeManagedPtrCastPtr gdkDisplay+    usage' <- unsafeManagedPtrGetPtr usage+    wnck_xid_read_resource_usage gdkDisplay' xid usage'+    touchManagedPtr gdkDisplay+    touchManagedPtr usage+    return ()+++-- function wnck_shutdown+-- Args : []+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_shutdown" wnck_shutdown :: +    IO ()++{- |+Makes libwnck stop listening to events and tear down all resources from+libwnck. This should be done if you are not going to need the state change+notifications for an extended period of time, to avoid wakeups with every+key and focus event.++After this, all pointers to Wnck object you might still hold are invalid.++Due to the fact that \<link+linkend=\"getting-started.pitfalls.memory-management\">Wnck objects are all+owned by libwnck\<\/link>, users of this API through introspection should be+extremely careful: they must explicitly clear variables referencing objects+before this call. Failure to do so might result in crashes.++/Since: 3.4/+-}+shutdown ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m ()+shutdown  = liftIO $ do+    wnck_shutdown+    return ()+++-- function wnck_set_default_mini_icon_size+-- Args : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the default size for windows and application mini icons.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_set_default_mini_icon_size" wnck_set_default_mini_icon_size :: +    Word64 ->                               -- size : TBasicType TUInt64+    IO ()++{- |+The default main icon size is 'GI.Wnck.Constants.DEFAULT_MINI_ICON_SIZE'. This function+allows to change this value.++/Since: 2.4.6/+-}+setDefaultMiniIconSize ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Word64+    {- ^ /@size@/: the default size for windows and application mini icons. -}+    -> m ()+setDefaultMiniIconSize size = liftIO $ do+    wnck_set_default_mini_icon_size size+    return ()+++-- function wnck_set_default_icon_size+-- Args : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the default size for windows and application standard icons.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_set_default_icon_size" wnck_set_default_icon_size :: +    Word64 ->                               -- size : TBasicType TUInt64+    IO ()++{- |+The default main icon size is 'GI.Wnck.Constants.DEFAULT_ICON_SIZE'. This function allows+to change this value.++/Since: 2.4.6/+-}+setDefaultIconSize ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Word64+    {- ^ /@size@/: the default size for windows and application standard icons. -}+    -> m ()+setDefaultIconSize size = liftIO $ do+    wnck_set_default_icon_size size+    return ()+++-- function wnck_set_client_type+-- Args : [Arg {argCName = "ewmh_sourceindication_client_type", argType = TInterface (Name {namespace = "Wnck", name = "ClientType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a role for the client.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_set_client_type" wnck_set_client_type :: +    CUInt ->                                -- ewmh_sourceindication_client_type : TInterface (Name {namespace = "Wnck", name = "ClientType"})+    IO ()++{- |+Sets the role of the libwnck user.++The default role is 'GI.Wnck.Enums.ClientTypeApplication'. Therefore, for+applications providing some window management features, like pagers or+tasklists, it is important to set the role to 'GI.Wnck.Enums.ClientTypePager' for+libwnck to properly work.++This function should only be called once per program. Additional calls+with the same client type will be silently ignored. An attempt to change+the client type to a differnet value after it has already been set will+be ignored and a critical warning will be logged.++/Since: 2.14/+-}+setClientType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Wnck.Enums.ClientType+    {- ^ /@ewmhSourceindicationClientType@/: a role for the client. -}+    -> m ()+setClientType ewmhSourceindicationClientType = liftIO $ do+    let ewmhSourceindicationClientType' = (fromIntegral . fromEnum) ewmhSourceindicationClientType+    wnck_set_client_type ewmhSourceindicationClientType'+    return ()+++-- function wnck_pid_read_resource_usage+-- Args : [Arg {argCName = "gdk_display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a <classname>GdkDisplay</classname>.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pid", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a process ID.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "usage", argType = TInterface (Name {namespace = "Wnck", name = "ResourceUsage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the X resource usage of the application with\nprocess ID @pid.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_pid_read_resource_usage" wnck_pid_read_resource_usage :: +    Ptr Gdk.Display.Display ->              -- gdk_display : TInterface (Name {namespace = "Gdk", name = "Display"})+    CULong ->                               -- pid : TBasicType TULong+    Ptr Wnck.ResourceUsage.ResourceUsage -> -- usage : TInterface (Name {namespace = "Wnck", name = "ResourceUsage"})+    IO ()++{- |+Looks for the X resource usage of the application with process ID /@pid@/ on+display /@gdisplay@/. If no resource usage can be found, then all fields of+/@usage@/ are set to 0.++In order to find the resource usage of an application that does not have an+X window visible to libwnck (panel applets do not have any toplevel windows,+for example), 'GI.Wnck.Functions.pidReadResourceUsage' walks through the whole tree of+X windows. Since this walk is expensive in CPU, a cache is created. This+cache is updated in the background. This means there is a non-null+probability that no resource usage will be found for an application, even if+it is an X client. If this happens, calling 'GI.Wnck.Functions.pidReadResourceUsage'+again after a few seconds should work.++To properly work, this function requires the XRes extension on the X server.++/Since: 2.6/+-}+pidReadResourceUsage ::+    (B.CallStack.HasCallStack, MonadIO m, Gdk.Display.IsDisplay a) =>+    a+    {- ^ /@gdkDisplay@/: a \<classname>GdkDisplay\<\/classname>. -}+    -> CULong+    {- ^ /@pid@/: a process ID. -}+    -> Wnck.ResourceUsage.ResourceUsage+    {- ^ /@usage@/: return location for the X resource usage of the application with+process ID /@pid@/. -}+    -> m ()+pidReadResourceUsage gdkDisplay pid usage = liftIO $ do+    gdkDisplay' <- unsafeManagedPtrCastPtr gdkDisplay+    usage' <- unsafeManagedPtrGetPtr usage+    wnck_pid_read_resource_usage gdkDisplay' pid usage'+    touchManagedPtr gdkDisplay+    touchManagedPtr usage+    return ()+++

@@ -0,0 +1,59 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Wnck.Objects+    (     module GI.Wnck.Objects.ActionMenu       ,+    module GI.Wnck.Objects.Application      ,+    module GI.Wnck.Objects.ClassGroup       ,+    module GI.Wnck.Objects.ImageMenuItem    ,+    module GI.Wnck.Objects.Pager            ,+    module GI.Wnck.Objects.Screen           ,+    module GI.Wnck.Objects.Selector         ,+    module GI.Wnck.Objects.Tasklist         ,+    module GI.Wnck.Objects.Window           ,+    module GI.Wnck.Objects.Workspace        ,+++    ) where++import GI.Wnck.Objects.ActionMenu+import GI.Wnck.Objects.Application+import GI.Wnck.Objects.ClassGroup+import GI.Wnck.Objects.ImageMenuItem+import GI.Wnck.Objects.Pager+import GI.Wnck.Objects.Screen+import GI.Wnck.Objects.Selector+import GI.Wnck.Objects.Tasklist+import GI.Wnck.Objects.Window+import GI.Wnck.Objects.Workspace++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+++

@@ -0,0 +1,568 @@+++{- |+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.ActionMenu.ActionMenu' 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.ActionMenu+    ( ++-- * Exported types+    ActionMenu(..)                          ,+    IsActionMenu                            ,+    toActionMenu                            ,+    noActionMenu                            ,+++ -- * Methods+-- ** new #method:new#++    actionMenuNew                           ,+++++ -- * Properties+-- ** window #attr:window#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    ActionMenuWindowPropertyInfo            ,+#endif+#if ENABLE_OVERLOADING+    actionMenuWindow                        ,+#endif+    constructActionMenuWindow               ,+    getActionMenuWindow                     ,+++++    ) 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.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface+import qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.Container as Gtk.Container+import qualified GI.Gtk.Objects.Menu as Gtk.Menu+import qualified GI.Gtk.Objects.MenuShell as Gtk.MenuShell+import qualified GI.Gtk.Objects.Widget as Gtk.Widget+import {-# SOURCE #-} qualified GI.Wnck.Objects.Window as Wnck.Window++-- | Memory-managed wrapper type.+newtype ActionMenu = ActionMenu (ManagedPtr ActionMenu)+foreign import ccall "wnck_action_menu_get_type"+    c_wnck_action_menu_get_type :: IO GType++instance GObject ActionMenu where+    gobjectType = c_wnck_action_menu_get_type+    ++-- | Type class for types which can be safely cast to `ActionMenu`, for instance with `toActionMenu`.+class (GObject o, O.IsDescendantOf ActionMenu o) => IsActionMenu o+instance (GObject o, O.IsDescendantOf ActionMenu o) => IsActionMenu o++instance O.HasParentTypes ActionMenu+type instance O.ParentTypes ActionMenu = '[Gtk.Menu.Menu, Gtk.MenuShell.MenuShell, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]++-- | Cast to `ActionMenu`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toActionMenu :: (MonadIO m, IsActionMenu o) => o -> m ActionMenu+toActionMenu = liftIO . unsafeCastTo ActionMenu++-- | A convenience alias for `Nothing` :: `Maybe` `ActionMenu`.+noActionMenu :: Maybe ActionMenu+noActionMenu = Nothing++#if ENABLE_OVERLOADING+type family ResolveActionMenuMethod (t :: Symbol) (o :: *) :: * where+    ResolveActionMenuMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo+    ResolveActionMenuMethod "activateItem" o = Gtk.MenuShell.MenuShellActivateItemMethodInfo+    ResolveActionMenuMethod "add" o = Gtk.Container.ContainerAddMethodInfo+    ResolveActionMenuMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveActionMenuMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveActionMenuMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveActionMenuMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveActionMenuMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveActionMenuMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveActionMenuMethod "append" o = Gtk.MenuShell.MenuShellAppendMethodInfo+    ResolveActionMenuMethod "attach" o = Gtk.Menu.MenuAttachMethodInfo+    ResolveActionMenuMethod "attachToWidget" o = Gtk.Menu.MenuAttachToWidgetMethodInfo+    ResolveActionMenuMethod "bindModel" o = Gtk.MenuShell.MenuShellBindModelMethodInfo+    ResolveActionMenuMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveActionMenuMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveActionMenuMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveActionMenuMethod "cancel" o = Gtk.MenuShell.MenuShellCancelMethodInfo+    ResolveActionMenuMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo+    ResolveActionMenuMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveActionMenuMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo+    ResolveActionMenuMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo+    ResolveActionMenuMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo+    ResolveActionMenuMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo+    ResolveActionMenuMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo+    ResolveActionMenuMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveActionMenuMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveActionMenuMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveActionMenuMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveActionMenuMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveActionMenuMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveActionMenuMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveActionMenuMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveActionMenuMethod "deactivate" o = Gtk.MenuShell.MenuShellDeactivateMethodInfo+    ResolveActionMenuMethod "deselect" o = Gtk.MenuShell.MenuShellDeselectMethodInfo+    ResolveActionMenuMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveActionMenuMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveActionMenuMethod "detach" o = Gtk.Menu.MenuDetachMethodInfo+    ResolveActionMenuMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveActionMenuMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveActionMenuMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveActionMenuMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveActionMenuMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveActionMenuMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveActionMenuMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveActionMenuMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveActionMenuMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveActionMenuMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveActionMenuMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveActionMenuMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveActionMenuMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveActionMenuMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveActionMenuMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveActionMenuMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveActionMenuMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveActionMenuMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveActionMenuMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveActionMenuMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveActionMenuMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveActionMenuMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveActionMenuMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveActionMenuMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveActionMenuMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveActionMenuMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveActionMenuMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveActionMenuMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveActionMenuMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveActionMenuMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveActionMenuMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveActionMenuMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveActionMenuMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveActionMenuMethod "forall" o = Gtk.Container.ContainerForallMethodInfo+    ResolveActionMenuMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveActionMenuMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo+    ResolveActionMenuMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveActionMenuMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveActionMenuMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveActionMenuMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveActionMenuMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveActionMenuMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveActionMenuMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveActionMenuMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveActionMenuMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveActionMenuMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveActionMenuMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveActionMenuMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveActionMenuMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveActionMenuMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveActionMenuMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveActionMenuMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveActionMenuMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveActionMenuMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveActionMenuMethod "insert" o = Gtk.MenuShell.MenuShellInsertMethodInfo+    ResolveActionMenuMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveActionMenuMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveActionMenuMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveActionMenuMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveActionMenuMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveActionMenuMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveActionMenuMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveActionMenuMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveActionMenuMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveActionMenuMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveActionMenuMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveActionMenuMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveActionMenuMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveActionMenuMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveActionMenuMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveActionMenuMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveActionMenuMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveActionMenuMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveActionMenuMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveActionMenuMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveActionMenuMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveActionMenuMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveActionMenuMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveActionMenuMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveActionMenuMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveActionMenuMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveActionMenuMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveActionMenuMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveActionMenuMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveActionMenuMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveActionMenuMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveActionMenuMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveActionMenuMethod "placeOnMonitor" o = Gtk.Menu.MenuPlaceOnMonitorMethodInfo+    ResolveActionMenuMethod "popdown" o = Gtk.Menu.MenuPopdownMethodInfo+    ResolveActionMenuMethod "popup" o = Gtk.Menu.MenuPopupMethodInfo+    ResolveActionMenuMethod "popupAtPointer" o = Gtk.Menu.MenuPopupAtPointerMethodInfo+    ResolveActionMenuMethod "popupAtRect" o = Gtk.Menu.MenuPopupAtRectMethodInfo+    ResolveActionMenuMethod "popupAtWidget" o = Gtk.Menu.MenuPopupAtWidgetMethodInfo+    ResolveActionMenuMethod "popupForDevice" o = Gtk.Menu.MenuPopupForDeviceMethodInfo+    ResolveActionMenuMethod "prepend" o = Gtk.MenuShell.MenuShellPrependMethodInfo+    ResolveActionMenuMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo+    ResolveActionMenuMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveActionMenuMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveActionMenuMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveActionMenuMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveActionMenuMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveActionMenuMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveActionMenuMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveActionMenuMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveActionMenuMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveActionMenuMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveActionMenuMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveActionMenuMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveActionMenuMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo+    ResolveActionMenuMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveActionMenuMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveActionMenuMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveActionMenuMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveActionMenuMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveActionMenuMethod "reorderChild" o = Gtk.Menu.MenuReorderChildMethodInfo+    ResolveActionMenuMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveActionMenuMethod "reposition" o = Gtk.Menu.MenuRepositionMethodInfo+    ResolveActionMenuMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveActionMenuMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveActionMenuMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo+    ResolveActionMenuMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveActionMenuMethod "selectFirst" o = Gtk.MenuShell.MenuShellSelectFirstMethodInfo+    ResolveActionMenuMethod "selectItem" o = Gtk.MenuShell.MenuShellSelectItemMethodInfo+    ResolveActionMenuMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveActionMenuMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveActionMenuMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveActionMenuMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveActionMenuMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveActionMenuMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveActionMenuMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveActionMenuMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveActionMenuMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveActionMenuMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveActionMenuMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveActionMenuMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveActionMenuMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveActionMenuMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveActionMenuMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveActionMenuMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveActionMenuMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveActionMenuMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveActionMenuMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveActionMenuMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveActionMenuMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveActionMenuMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveActionMenuMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo+    ResolveActionMenuMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveActionMenuMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveActionMenuMethod "getAccelGroup" o = Gtk.Menu.MenuGetAccelGroupMethodInfo+    ResolveActionMenuMethod "getAccelPath" o = Gtk.Menu.MenuGetAccelPathMethodInfo+    ResolveActionMenuMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveActionMenuMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveActionMenuMethod "getActive" o = Gtk.Menu.MenuGetActiveMethodInfo+    ResolveActionMenuMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveActionMenuMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveActionMenuMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveActionMenuMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveActionMenuMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveActionMenuMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveActionMenuMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveActionMenuMethod "getAttachWidget" o = Gtk.Menu.MenuGetAttachWidgetMethodInfo+    ResolveActionMenuMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo+    ResolveActionMenuMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveActionMenuMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveActionMenuMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveActionMenuMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveActionMenuMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo+    ResolveActionMenuMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveActionMenuMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveActionMenuMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveActionMenuMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveActionMenuMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveActionMenuMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveActionMenuMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveActionMenuMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveActionMenuMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveActionMenuMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveActionMenuMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo+    ResolveActionMenuMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo+    ResolveActionMenuMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo+    ResolveActionMenuMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolveActionMenuMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo+    ResolveActionMenuMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveActionMenuMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveActionMenuMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveActionMenuMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveActionMenuMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveActionMenuMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveActionMenuMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveActionMenuMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveActionMenuMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveActionMenuMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveActionMenuMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveActionMenuMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveActionMenuMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveActionMenuMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveActionMenuMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveActionMenuMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveActionMenuMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveActionMenuMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveActionMenuMethod "getMonitor" o = Gtk.Menu.MenuGetMonitorMethodInfo+    ResolveActionMenuMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveActionMenuMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveActionMenuMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveActionMenuMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveActionMenuMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveActionMenuMethod "getParentShell" o = Gtk.MenuShell.MenuShellGetParentShellMethodInfo+    ResolveActionMenuMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveActionMenuMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveActionMenuMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo+    ResolveActionMenuMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveActionMenuMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveActionMenuMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveActionMenuMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveActionMenuMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveActionMenuMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveActionMenuMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveActionMenuMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveActionMenuMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveActionMenuMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveActionMenuMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveActionMenuMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveActionMenuMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveActionMenuMethod "getReserveToggleSize" o = Gtk.Menu.MenuGetReserveToggleSizeMethodInfo+    ResolveActionMenuMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo+    ResolveActionMenuMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveActionMenuMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveActionMenuMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveActionMenuMethod "getSelectedItem" o = Gtk.MenuShell.MenuShellGetSelectedItemMethodInfo+    ResolveActionMenuMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveActionMenuMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveActionMenuMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveActionMenuMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveActionMenuMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveActionMenuMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveActionMenuMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveActionMenuMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveActionMenuMethod "getTakeFocus" o = Gtk.MenuShell.MenuShellGetTakeFocusMethodInfo+    ResolveActionMenuMethod "getTearoffState" o = Gtk.Menu.MenuGetTearoffStateMethodInfo+    ResolveActionMenuMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveActionMenuMethod "getTitle" o = Gtk.Menu.MenuGetTitleMethodInfo+    ResolveActionMenuMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveActionMenuMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveActionMenuMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveActionMenuMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveActionMenuMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveActionMenuMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveActionMenuMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveActionMenuMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveActionMenuMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveActionMenuMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveActionMenuMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveActionMenuMethod "setAccelGroup" o = Gtk.Menu.MenuSetAccelGroupMethodInfo+    ResolveActionMenuMethod "setAccelPath" o = Gtk.Menu.MenuSetAccelPathMethodInfo+    ResolveActionMenuMethod "setActive" o = Gtk.Menu.MenuSetActiveMethodInfo+    ResolveActionMenuMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveActionMenuMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveActionMenuMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo+    ResolveActionMenuMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveActionMenuMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveActionMenuMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveActionMenuMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveActionMenuMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveActionMenuMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveActionMenuMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveActionMenuMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveActionMenuMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveActionMenuMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveActionMenuMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveActionMenuMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveActionMenuMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo+    ResolveActionMenuMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo+    ResolveActionMenuMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo+    ResolveActionMenuMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolveActionMenuMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo+    ResolveActionMenuMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveActionMenuMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveActionMenuMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveActionMenuMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveActionMenuMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveActionMenuMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveActionMenuMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveActionMenuMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveActionMenuMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveActionMenuMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveActionMenuMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveActionMenuMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveActionMenuMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveActionMenuMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveActionMenuMethod "setMonitor" o = Gtk.Menu.MenuSetMonitorMethodInfo+    ResolveActionMenuMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveActionMenuMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveActionMenuMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveActionMenuMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveActionMenuMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveActionMenuMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveActionMenuMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveActionMenuMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo+    ResolveActionMenuMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveActionMenuMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveActionMenuMethod "setReserveToggleSize" o = Gtk.Menu.MenuSetReserveToggleSizeMethodInfo+    ResolveActionMenuMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo+    ResolveActionMenuMethod "setScreen" o = Gtk.Menu.MenuSetScreenMethodInfo+    ResolveActionMenuMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveActionMenuMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveActionMenuMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveActionMenuMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveActionMenuMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveActionMenuMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveActionMenuMethod "setTakeFocus" o = Gtk.MenuShell.MenuShellSetTakeFocusMethodInfo+    ResolveActionMenuMethod "setTearoffState" o = Gtk.Menu.MenuSetTearoffStateMethodInfo+    ResolveActionMenuMethod "setTitle" o = Gtk.Menu.MenuSetTitleMethodInfo+    ResolveActionMenuMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveActionMenuMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveActionMenuMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveActionMenuMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveActionMenuMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveActionMenuMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveActionMenuMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveActionMenuMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveActionMenuMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveActionMenuMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveActionMenuMethod t ActionMenu, O.MethodInfo info ActionMenu p) => OL.IsLabel t (ActionMenu -> 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++--- XXX Duplicated object with different types:+  --- Name {namespace = "Wnck", name = "ActionMenu"} -> Property {propName = "window", propType = TBasicType TPtr, propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, propDeprecated = Nothing}+  --- Name {namespace = "Gtk", name = "Widget"} -> Property {propName = "window", propType = TInterface (Name {namespace = "Gdk", name = "Window"}), propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The widget's window if it is realized, %NULL otherwise.", sinceVersion = Just "2.14"}, propDeprecated = Nothing}+-- VVV Prop "window"+   -- Type: TBasicType TPtr+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@window@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' actionMenu #window+@+-}+getActionMenuWindow :: (MonadIO m, IsActionMenu o) => o -> m (Ptr ())+getActionMenuWindow obj = liftIO $ B.Properties.getObjectPropertyPtr obj "window"++{- |+Construct a `GValueConstruct` with valid value for the “@window@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructActionMenuWindow :: (IsActionMenu o) => Ptr () -> IO (GValueConstruct o)+constructActionMenuWindow val = B.Properties.constructObjectPropertyPtr "window" val++#if ENABLE_OVERLOADING+data ActionMenuWindowPropertyInfo+instance AttrInfo ActionMenuWindowPropertyInfo where+    type AttrAllowedOps ActionMenuWindowPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionMenuWindowPropertyInfo = (~) (Ptr ())+    type AttrBaseTypeConstraint ActionMenuWindowPropertyInfo = IsActionMenu+    type AttrGetType ActionMenuWindowPropertyInfo = (Ptr ())+    type AttrLabel ActionMenuWindowPropertyInfo = "window"+    type AttrOrigin ActionMenuWindowPropertyInfo = ActionMenu+    attrGet _ = getActionMenuWindow+    attrSet _ = undefined+    attrConstruct _ = constructActionMenuWindow+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList ActionMenu+type instance O.AttributeList ActionMenu = ActionMenuAttributeList+type ActionMenuAttributeList = ('[ '("accelGroup", Gtk.Menu.MenuAccelGroupPropertyInfo), '("accelPath", Gtk.Menu.MenuAccelPathPropertyInfo), '("active", Gtk.Menu.MenuActivePropertyInfo), '("anchorHints", Gtk.Menu.MenuAnchorHintsPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("attachWidget", Gtk.Menu.MenuAttachWidgetPropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("menuTypeHint", Gtk.Menu.MenuMenuTypeHintPropertyInfo), '("monitor", Gtk.Menu.MenuMonitorPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("rectAnchorDx", Gtk.Menu.MenuRectAnchorDxPropertyInfo), '("rectAnchorDy", Gtk.Menu.MenuRectAnchorDyPropertyInfo), '("reserveToggleSize", Gtk.Menu.MenuReserveToggleSizePropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("takeFocus", Gtk.MenuShell.MenuShellTakeFocusPropertyInfo), '("tearoffState", Gtk.Menu.MenuTearoffStatePropertyInfo), '("tearoffTitle", Gtk.Menu.MenuTearoffTitlePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", ActionMenuWindowPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+actionMenuWindow :: AttrLabelProxy "window"+actionMenuWindow = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList ActionMenu = ActionMenuSignalList+type ActionMenuSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activateCurrent", Gtk.MenuShell.MenuShellActivateCurrentSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("cancel", Gtk.MenuShell.MenuShellCancelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("cycleFocus", Gtk.MenuShell.MenuShellCycleFocusSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deactivate", Gtk.MenuShell.MenuShellDeactivateSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("insert", Gtk.MenuShell.MenuShellInsertSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveCurrent", Gtk.MenuShell.MenuShellMoveCurrentSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("moveScroll", Gtk.Menu.MenuMoveScrollSignalInfo), '("moveSelected", Gtk.MenuShell.MenuShellMoveSelectedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("poppedUp", Gtk.Menu.MenuPoppedUpSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionDone", Gtk.MenuShell.MenuShellSelectionDoneSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])++#endif++-- method ActionMenu::new+-- method type : Constructor+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WnckWindow for which a menu will be created.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "ActionMenu"}))+-- throws : False+-- Skip return : False++foreign import ccall "wnck_action_menu_new" wnck_action_menu_new :: +    Ptr Wnck.Window.Window ->               -- window : TInterface (Name {namespace = "Wnck", name = "Window"})+    IO (Ptr ActionMenu)++{- |+Creates a new 'GI.Wnck.Objects.ActionMenu.ActionMenu'. The 'GI.Wnck.Objects.ActionMenu.ActionMenu' will be filled with menu+items for window operations on /@window@/.++/Since: 2.22/+-}+actionMenuNew ::+    (B.CallStack.HasCallStack, MonadIO m, Wnck.Window.IsWindow a) =>+    a+    {- ^ /@window@/: the 'GI.Wnck.Objects.Window.Window' for which a menu will be created. -}+    -> m ActionMenu+    {- ^ __Returns:__ a newly created 'GI.Wnck.Objects.ActionMenu.ActionMenu'. -}+actionMenuNew window = liftIO $ do+    window' <- unsafeManagedPtrCastPtr window+    result <- wnck_action_menu_new window'+    checkUnexpectedReturnNULL "actionMenuNew" result+    result' <- (newObject ActionMenu) result+    touchManagedPtr window+    return result'++#if ENABLE_OVERLOADING+#endif++

@@ -0,0 +1,32 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Wnck.Objects.ActionMenu 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++newtype ActionMenu = ActionMenu (ManagedPtr ActionMenu)+instance GObject ActionMenu where+class (GObject o, O.IsDescendantOf ActionMenu o) => IsActionMenu o+instance (GObject o, O.IsDescendantOf ActionMenu o) => IsActionMenu o+instance O.HasParentTypes ActionMenu+#if ENABLE_OVERLOADING+data ActionMenuWindowPropertyInfo+#endif

@@ -0,0 +1,810 @@+++{- |+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.Application.Application' 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.Application+    ( ++-- * Exported types+    Application(..)                         ,+    IsApplication                           ,+    toApplication                           ,+    noApplication                           ,+++ -- * Methods+-- ** get #method:get#++    applicationGet                          ,+++-- ** getIcon #method:getIcon#++#if ENABLE_OVERLOADING+    ApplicationGetIconMethodInfo            ,+#endif+    applicationGetIcon                      ,+++-- ** getIconIsFallback #method:getIconIsFallback#++#if ENABLE_OVERLOADING+    ApplicationGetIconIsFallbackMethodInfo  ,+#endif+    applicationGetIconIsFallback            ,+++-- ** getIconName #method:getIconName#++#if ENABLE_OVERLOADING+    ApplicationGetIconNameMethodInfo        ,+#endif+    applicationGetIconName                  ,+++-- ** getMiniIcon #method:getMiniIcon#++#if ENABLE_OVERLOADING+    ApplicationGetMiniIconMethodInfo        ,+#endif+    applicationGetMiniIcon                  ,+++-- ** getNWindows #method:getNWindows#++#if ENABLE_OVERLOADING+    ApplicationGetNWindowsMethodInfo        ,+#endif+    applicationGetNWindows                  ,+++-- ** getName #method:getName#++#if ENABLE_OVERLOADING+    ApplicationGetNameMethodInfo            ,+#endif+    applicationGetName                      ,+++-- ** getPid #method:getPid#++#if ENABLE_OVERLOADING+    ApplicationGetPidMethodInfo             ,+#endif+    applicationGetPid                       ,+++-- ** getStartupId #method:getStartupId#++#if ENABLE_OVERLOADING+    ApplicationGetStartupIdMethodInfo       ,+#endif+    applicationGetStartupId                 ,+++-- ** getWindows #method:getWindows#++#if ENABLE_OVERLOADING+    ApplicationGetWindowsMethodInfo         ,+#endif+    applicationGetWindows                   ,+++-- ** getXid #method:getXid#++#if ENABLE_OVERLOADING+    ApplicationGetXidMethodInfo             ,+#endif+    applicationGetXid                       ,+++++ -- * Signals+-- ** iconChanged #signal:iconChanged#++    ApplicationIconChangedCallback          ,+#if ENABLE_OVERLOADING+    ApplicationIconChangedSignalInfo        ,+#endif+    C_ApplicationIconChangedCallback        ,+    afterApplicationIconChanged             ,+    genClosure_ApplicationIconChanged       ,+    mk_ApplicationIconChangedCallback       ,+    noApplicationIconChangedCallback        ,+    onApplicationIconChanged                ,+    wrap_ApplicationIconChangedCallback     ,+++-- ** nameChanged #signal:nameChanged#++    ApplicationNameChangedCallback          ,+#if ENABLE_OVERLOADING+    ApplicationNameChangedSignalInfo        ,+#endif+    C_ApplicationNameChangedCallback        ,+    afterApplicationNameChanged             ,+    genClosure_ApplicationNameChanged       ,+    mk_ApplicationNameChangedCallback       ,+    noApplicationNameChangedCallback        ,+    onApplicationNameChanged                ,+    wrap_ApplicationNameChangedCallback     ,+++++    ) 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.Objects.Window as Wnck.Window++-- | Memory-managed wrapper type.+newtype Application = Application (ManagedPtr Application)+foreign import ccall "wnck_application_get_type"+    c_wnck_application_get_type :: IO GType++instance GObject Application where+    gobjectType = c_wnck_application_get_type+    ++-- | Type class for types which can be safely cast to `Application`, for instance with `toApplication`.+class (GObject o, O.IsDescendantOf Application o) => IsApplication o+instance (GObject o, O.IsDescendantOf Application o) => IsApplication o++instance O.HasParentTypes Application+type instance O.ParentTypes Application = '[GObject.Object.Object]++-- | Cast to `Application`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toApplication :: (MonadIO m, IsApplication o) => o -> m Application+toApplication = liftIO . unsafeCastTo Application++-- | A convenience alias for `Nothing` :: `Maybe` `Application`.+noApplication :: Maybe Application+noApplication = Nothing++#if ENABLE_OVERLOADING+type family ResolveApplicationMethod (t :: Symbol) (o :: *) :: * where+    ResolveApplicationMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveApplicationMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveApplicationMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveApplicationMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveApplicationMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveApplicationMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveApplicationMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveApplicationMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveApplicationMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveApplicationMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveApplicationMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveApplicationMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveApplicationMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveApplicationMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveApplicationMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveApplicationMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveApplicationMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveApplicationMethod "getIcon" o = ApplicationGetIconMethodInfo+    ResolveApplicationMethod "getIconIsFallback" o = ApplicationGetIconIsFallbackMethodInfo+    ResolveApplicationMethod "getIconName" o = ApplicationGetIconNameMethodInfo+    ResolveApplicationMethod "getMiniIcon" o = ApplicationGetMiniIconMethodInfo+    ResolveApplicationMethod "getNWindows" o = ApplicationGetNWindowsMethodInfo+    ResolveApplicationMethod "getName" o = ApplicationGetNameMethodInfo+    ResolveApplicationMethod "getPid" o = ApplicationGetPidMethodInfo+    ResolveApplicationMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveApplicationMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveApplicationMethod "getStartupId" o = ApplicationGetStartupIdMethodInfo+    ResolveApplicationMethod "getWindows" o = ApplicationGetWindowsMethodInfo+    ResolveApplicationMethod "getXid" o = ApplicationGetXidMethodInfo+    ResolveApplicationMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveApplicationMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveApplicationMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveApplicationMethod t Application, O.MethodInfo info Application p) => OL.IsLabel t (Application -> 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 Application::icon-changed+{- |+Emitted when the icon of /@app@/ changes.+-}+type ApplicationIconChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ApplicationIconChangedCallback`@.+noApplicationIconChangedCallback :: Maybe ApplicationIconChangedCallback+noApplicationIconChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ApplicationIconChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ApplicationIconChangedCallback`.+foreign import ccall "wrapper"+    mk_ApplicationIconChangedCallback :: C_ApplicationIconChangedCallback -> IO (FunPtr C_ApplicationIconChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ApplicationIconChanged :: MonadIO m => ApplicationIconChangedCallback -> m (GClosure C_ApplicationIconChangedCallback)+genClosure_ApplicationIconChanged cb = liftIO $ do+    let cb' = wrap_ApplicationIconChangedCallback cb+    mk_ApplicationIconChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ApplicationIconChangedCallback` into a `C_ApplicationIconChangedCallback`.+wrap_ApplicationIconChangedCallback ::+    ApplicationIconChangedCallback ->+    C_ApplicationIconChangedCallback+wrap_ApplicationIconChangedCallback _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' application #iconChanged callback+@+-}+onApplicationIconChanged :: (IsApplication a, MonadIO m) => a -> ApplicationIconChangedCallback -> m SignalHandlerId+onApplicationIconChanged obj cb = liftIO $ do+    let cb' = wrap_ApplicationIconChangedCallback cb+    cb'' <- mk_ApplicationIconChangedCallback 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' application #iconChanged callback+@+-}+afterApplicationIconChanged :: (IsApplication a, MonadIO m) => a -> ApplicationIconChangedCallback -> m SignalHandlerId+afterApplicationIconChanged obj cb = liftIO $ do+    let cb' = wrap_ApplicationIconChangedCallback cb+    cb'' <- mk_ApplicationIconChangedCallback cb'+    connectSignalFunPtr obj "icon-changed" cb'' SignalConnectAfter+++-- signal Application::name-changed+{- |+Emitted when the name of /@app@/ changes.+-}+type ApplicationNameChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ApplicationNameChangedCallback`@.+noApplicationNameChangedCallback :: Maybe ApplicationNameChangedCallback+noApplicationNameChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ApplicationNameChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ApplicationNameChangedCallback`.+foreign import ccall "wrapper"+    mk_ApplicationNameChangedCallback :: C_ApplicationNameChangedCallback -> IO (FunPtr C_ApplicationNameChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ApplicationNameChanged :: MonadIO m => ApplicationNameChangedCallback -> m (GClosure C_ApplicationNameChangedCallback)+genClosure_ApplicationNameChanged cb = liftIO $ do+    let cb' = wrap_ApplicationNameChangedCallback cb+    mk_ApplicationNameChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ApplicationNameChangedCallback` into a `C_ApplicationNameChangedCallback`.+wrap_ApplicationNameChangedCallback ::+    ApplicationNameChangedCallback ->+    C_ApplicationNameChangedCallback+wrap_ApplicationNameChangedCallback _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' application #nameChanged callback+@+-}+onApplicationNameChanged :: (IsApplication a, MonadIO m) => a -> ApplicationNameChangedCallback -> m SignalHandlerId+onApplicationNameChanged obj cb = liftIO $ do+    let cb' = wrap_ApplicationNameChangedCallback cb+    cb'' <- mk_ApplicationNameChangedCallback 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' application #nameChanged callback+@+-}+afterApplicationNameChanged :: (IsApplication a, MonadIO m) => a -> ApplicationNameChangedCallback -> m SignalHandlerId+afterApplicationNameChanged obj cb = liftIO $ do+    let cb' = wrap_ApplicationNameChangedCallback cb+    cb'' <- mk_ApplicationNameChangedCallback cb'+    connectSignalFunPtr obj "name-changed" cb'' SignalConnectAfter+++#if ENABLE_OVERLOADING+instance O.HasAttributeList Application+type instance O.AttributeList Application = ApplicationAttributeList+type ApplicationAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+data ApplicationIconChangedSignalInfo+instance SignalInfo ApplicationIconChangedSignalInfo where+    type HaskellCallbackType ApplicationIconChangedSignalInfo = ApplicationIconChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ApplicationIconChangedCallback cb+        cb'' <- mk_ApplicationIconChangedCallback cb'+        connectSignalFunPtr obj "icon-changed" cb'' connectMode++data ApplicationNameChangedSignalInfo+instance SignalInfo ApplicationNameChangedSignalInfo where+    type HaskellCallbackType ApplicationNameChangedSignalInfo = ApplicationNameChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ApplicationNameChangedCallback cb+        cb'' <- mk_ApplicationNameChangedCallback cb'+        connectSignalFunPtr obj "name-changed" cb'' connectMode++type instance O.SignalList Application = ApplicationSignalList+type ApplicationSignalList = ('[ '("iconChanged", ApplicationIconChangedSignalInfo), '("nameChanged", ApplicationNameChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method Application::get_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", 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_application_get_icon" wnck_application_get_icon :: +    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)++{- |+Gets the icon to be used for /@app@/. If no icon is set for /@app@/, a+suboptimal heuristic is used to find an appropriate icon. If no icon was+found, a fallback icon is used.+-}+applicationGetIcon ::+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>+    a+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}+    -> m GdkPixbuf.Pixbuf.Pixbuf+    {- ^ __Returns:__ the icon for /@app@/. The caller should+reference the returned \<classname>GdkPixbuf\<\/classname> if it needs to keep+the icon around. -}+applicationGetIcon app = liftIO $ do+    app' <- unsafeManagedPtrCastPtr app+    result <- wnck_application_get_icon app'+    checkUnexpectedReturnNULL "applicationGetIcon" result+    result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result+    touchManagedPtr app+    return result'++#if ENABLE_OVERLOADING+data ApplicationGetIconMethodInfo+instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetIconMethodInfo a signature where+    overloadedMethod _ = applicationGetIcon++#endif++-- method Application::get_icon_is_fallback+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication", 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_application_get_icon_is_fallback" wnck_application_get_icon_is_fallback :: +    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})+    IO CInt++{- |+Gets whether a default fallback icon is used for /@app@/ (because none+was set on /@app@/).+-}+applicationGetIconIsFallback ::+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>+    a+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the icon for /@app@/ is a fallback, 'False' otherwise. -}+applicationGetIconIsFallback app = liftIO $ do+    app' <- unsafeManagedPtrCastPtr app+    result <- wnck_application_get_icon_is_fallback app'+    let result' = (/= 0) result+    touchManagedPtr app+    return result'++#if ENABLE_OVERLOADING+data ApplicationGetIconIsFallbackMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetIconIsFallbackMethodInfo a signature where+    overloadedMethod _ = applicationGetIconIsFallback++#endif++-- method Application::get_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication", 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_application_get_icon_name" wnck_application_get_icon_name :: +    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})+    IO CString++{- |+Gets the icon name of /@app@/ (to be used when /@app@/ is minimized). Since+there is no way to properly find this name, various suboptimal heuristics+are used to find it.+-}+applicationGetIconName ::+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>+    a+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application' -}+    -> m T.Text+    {- ^ __Returns:__ the icon name of /@app@/, or a fallback icon name if no icon name+is available. -}+applicationGetIconName app = liftIO $ do+    app' <- unsafeManagedPtrCastPtr app+    result <- wnck_application_get_icon_name app'+    checkUnexpectedReturnNULL "applicationGetIconName" result+    result' <- cstringToText result+    touchManagedPtr app+    return result'++#if ENABLE_OVERLOADING+data ApplicationGetIconNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetIconNameMethodInfo a signature where+    overloadedMethod _ = applicationGetIconName++#endif++-- method Application::get_mini_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", 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_application_get_mini_icon" wnck_application_get_mini_icon :: +    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)++{- |+Gets the mini-icon to be used for /@app@/. If no mini-icon is set for /@app@/,+a suboptimal heuristic is used to find an appropriate icon. If no mini-icon+was found, a fallback mini-icon is used.+-}+applicationGetMiniIcon ::+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>+    a+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}+    -> m GdkPixbuf.Pixbuf.Pixbuf+    {- ^ __Returns:__ the mini-icon for /@app@/. The caller should+reference the returned \<classname>GdkPixbuf\<\/classname> if it needs to keep+the mini-icon around. -}+applicationGetMiniIcon app = liftIO $ do+    app' <- unsafeManagedPtrCastPtr app+    result <- wnck_application_get_mini_icon app'+    checkUnexpectedReturnNULL "applicationGetMiniIcon" result+    result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result+    touchManagedPtr app+    return result'++#if ENABLE_OVERLOADING+data ApplicationGetMiniIconMethodInfo+instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetMiniIconMethodInfo a signature where+    overloadedMethod _ = applicationGetMiniIcon++#endif++-- method Application::get_n_windows+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", 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_application_get_n_windows" wnck_application_get_n_windows :: +    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})+    IO Int32++{- |+Gets the number of 'GI.Wnck.Objects.Window.Window' belonging to /@app@/.+-}+applicationGetNWindows ::+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>+    a+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}+    -> m Int32+    {- ^ __Returns:__ the number of 'GI.Wnck.Objects.Window.Window' belonging to /@app@/. -}+applicationGetNWindows app = liftIO $ do+    app' <- unsafeManagedPtrCastPtr app+    result <- wnck_application_get_n_windows app'+    touchManagedPtr app+    return result++#if ENABLE_OVERLOADING+data ApplicationGetNWindowsMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetNWindowsMethodInfo a signature where+    overloadedMethod _ = applicationGetNWindows++#endif++-- method Application::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", 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_application_get_name" wnck_application_get_name :: +    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})+    IO CString++{- |+Gets the name of /@app@/. Since there is no way to properly find this name,+various suboptimal heuristics are used to find it. GTK+ should probably have+a function to allow applications to set the _NET_WM_NAME property on the+group leader as the application name, and the \<ulink+url=\"http:\/\/standards.freedesktop.org\/wm-spec\/wm-spec-latest.html\">EWMH\<\/ulink>+should say that this is where the application name goes.+-}+applicationGetName ::+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>+    a+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}+    -> m T.Text+    {- ^ __Returns:__ the name of /@app@/, or a fallback name if no name is available. -}+applicationGetName app = liftIO $ do+    app' <- unsafeManagedPtrCastPtr app+    result <- wnck_application_get_name app'+    checkUnexpectedReturnNULL "applicationGetName" result+    result' <- cstringToText result+    touchManagedPtr app+    return result'++#if ENABLE_OVERLOADING+data ApplicationGetNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetNameMethodInfo a signature where+    overloadedMethod _ = applicationGetName++#endif++-- method Application::get_pid+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", 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_application_get_pid" wnck_application_get_pid :: +    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})+    IO Int32++{- |+Gets the process ID of /@app@/.+-}+applicationGetPid ::+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>+    a+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}+    -> m Int32+    {- ^ __Returns:__ the process ID of /@app@/, or 0 if none is available. -}+applicationGetPid app = liftIO $ do+    app' <- unsafeManagedPtrCastPtr app+    result <- wnck_application_get_pid app'+    touchManagedPtr app+    return result++#if ENABLE_OVERLOADING+data ApplicationGetPidMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetPidMethodInfo a signature where+    overloadedMethod _ = applicationGetPid++#endif++-- method Application::get_startup_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", 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_application_get_startup_id" wnck_application_get_startup_id :: +    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})+    IO CString++{- |+Gets the startup sequence ID used for startup notification of /@app@/.++/Since: 2.2/+-}+applicationGetStartupId ::+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>+    a+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}+    -> m T.Text+    {- ^ __Returns:__ the startup sequence ID used for startup notification of /@app@/,+or 'Nothing' if none is available. -}+applicationGetStartupId app = liftIO $ do+    app' <- unsafeManagedPtrCastPtr app+    result <- wnck_application_get_startup_id app'+    checkUnexpectedReturnNULL "applicationGetStartupId" result+    result' <- cstringToText result+    touchManagedPtr app+    return result'++#if ENABLE_OVERLOADING+data ApplicationGetStartupIdMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetStartupIdMethodInfo a signature where+    overloadedMethod _ = applicationGetStartupId++#endif++-- method Application::get_windows+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TGList (TInterface (Name {namespace = "Wnck", name = "Window"})))+-- throws : False+-- Skip return : False++foreign import ccall "wnck_application_get_windows" wnck_application_get_windows :: +    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})+    IO (Ptr (GList (Ptr Wnck.Window.Window)))++{- |+Gets the list of 'GI.Wnck.Objects.Window.Window' belonging to /@app@/.+-}+applicationGetWindows ::+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>+    a+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}+    -> m [Wnck.Window.Window]+    {- ^ __Returns:__ the list of+'GI.Wnck.Objects.Window.Window' belonging to /@app@/, or 'Nothing' if the application contains no+window. The list should not be modified nor freed, as it is owned by /@app@/. -}+applicationGetWindows app = liftIO $ do+    app' <- unsafeManagedPtrCastPtr app+    result <- wnck_application_get_windows app'+    result' <- unpackGList result+    result'' <- mapM (newObject Wnck.Window.Window) result'+    touchManagedPtr app+    return result''++#if ENABLE_OVERLOADING+data ApplicationGetWindowsMethodInfo+instance (signature ~ (m [Wnck.Window.Window]), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetWindowsMethodInfo a signature where+    overloadedMethod _ = applicationGetWindows++#endif++-- method Application::get_xid+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", 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_application_get_xid" wnck_application_get_xid :: +    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})+    IO CULong++{- |+Gets the X window ID of the group leader window for /@app@/.+-}+applicationGetXid ::+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>+    a+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}+    -> m CULong+    {- ^ __Returns:__ the X window ID of the group leader window for /@app@/. -}+applicationGetXid app = liftIO $ do+    app' <- unsafeManagedPtrCastPtr app+    result <- wnck_application_get_xid app'+    touchManagedPtr app+    return result++#if ENABLE_OVERLOADING+data ApplicationGetXidMethodInfo+instance (signature ~ (m CULong), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetXidMethodInfo a signature where+    overloadedMethod _ = applicationGetXid++#endif++-- method Application::get+-- method type : MemberFunction+-- Args : [Arg {argCName = "xwindow", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the X window ID of a group leader.", 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_application_get" wnck_application_get :: +    CULong ->                               -- xwindow : TBasicType TULong+    IO (Ptr Application)++{- |+Gets the 'GI.Wnck.Objects.Application.Application' corresponding to the group leader with /@xwindow@/+as X window ID.+-}+applicationGet ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    CULong+    {- ^ /@xwindow@/: the X window ID of a group leader. -}+    -> m Application+    {- ^ __Returns:__ the 'GI.Wnck.Objects.Application.Application' corresponding to+/@xwindow@/, or 'Nothing' if there no such 'GI.Wnck.Objects.Application.Application' could be found. The+returned 'GI.Wnck.Objects.Application.Application' is owned by libwnck and must not be referenced or+unreferenced. -}+applicationGet xwindow = liftIO $ do+    result <- wnck_application_get xwindow+    checkUnexpectedReturnNULL "applicationGet" result+    result' <- (newObject Application) result+    return result'++#if ENABLE_OVERLOADING+#endif++

@@ -0,0 +1,65 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Wnck.Objects.Application 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++newtype Application = Application (ManagedPtr Application)+instance GObject Application where+class (GObject o, O.IsDescendantOf Application o) => IsApplication o+instance (GObject o, O.IsDescendantOf Application o) => IsApplication o+instance O.HasParentTypes Application+#if ENABLE_OVERLOADING+data ApplicationIconChangedSignalInfo+#endif+#if ENABLE_OVERLOADING+data ApplicationNameChangedSignalInfo+#endif+#if ENABLE_OVERLOADING+data ApplicationGetIconMethodInfo+#endif+#if ENABLE_OVERLOADING+data ApplicationGetIconIsFallbackMethodInfo+#endif+#if ENABLE_OVERLOADING+data ApplicationGetIconNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data ApplicationGetMiniIconMethodInfo+#endif+#if ENABLE_OVERLOADING+data ApplicationGetNWindowsMethodInfo+#endif+#if ENABLE_OVERLOADING+data ApplicationGetNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data ApplicationGetPidMethodInfo+#endif+#if ENABLE_OVERLOADING+data ApplicationGetStartupIdMethodInfo+#endif+#if ENABLE_OVERLOADING+data ApplicationGetWindowsMethodInfo+#endif+#if ENABLE_OVERLOADING+data ApplicationGetXidMethodInfo+#endif

@@ -0,0 +1,653 @@+++{- |+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.ClassGroup.ClassGroup' 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.ClassGroup+    ( ++-- * Exported types+    ClassGroup(..)                          ,+    IsClassGroup                            ,+    toClassGroup                            ,+    noClassGroup                            ,+++ -- * Methods+-- ** get #method:get#++    classGroupGet                           ,+++-- ** getIcon #method:getIcon#++#if ENABLE_OVERLOADING+    ClassGroupGetIconMethodInfo             ,+#endif+    classGroupGetIcon                       ,+++-- ** getId #method:getId#++#if ENABLE_OVERLOADING+    ClassGroupGetIdMethodInfo               ,+#endif+    classGroupGetId                         ,+++-- ** getMiniIcon #method:getMiniIcon#++#if ENABLE_OVERLOADING+    ClassGroupGetMiniIconMethodInfo         ,+#endif+    classGroupGetMiniIcon                   ,+++-- ** getName #method:getName#++#if ENABLE_OVERLOADING+    ClassGroupGetNameMethodInfo             ,+#endif+    classGroupGetName                       ,+++-- ** getResClass #method:getResClass#++#if ENABLE_OVERLOADING+    ClassGroupGetResClassMethodInfo         ,+#endif+    classGroupGetResClass                   ,+++-- ** getWindows #method:getWindows#++#if ENABLE_OVERLOADING+    ClassGroupGetWindowsMethodInfo          ,+#endif+    classGroupGetWindows                    ,+++++ -- * Signals+-- ** iconChanged #signal:iconChanged#++    C_ClassGroupIconChangedCallback         ,+    ClassGroupIconChangedCallback           ,+#if ENABLE_OVERLOADING+    ClassGroupIconChangedSignalInfo         ,+#endif+    afterClassGroupIconChanged              ,+    genClosure_ClassGroupIconChanged        ,+    mk_ClassGroupIconChangedCallback        ,+    noClassGroupIconChangedCallback         ,+    onClassGroupIconChanged                 ,+    wrap_ClassGroupIconChangedCallback      ,+++-- ** nameChanged #signal:nameChanged#++    C_ClassGroupNameChangedCallback         ,+    ClassGroupNameChangedCallback           ,+#if ENABLE_OVERLOADING+    ClassGroupNameChangedSignalInfo         ,+#endif+    afterClassGroupNameChanged              ,+    genClosure_ClassGroupNameChanged        ,+    mk_ClassGroupNameChangedCallback        ,+    noClassGroupNameChangedCallback         ,+    onClassGroupNameChanged                 ,+    wrap_ClassGroupNameChangedCallback      ,+++++    ) 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.Objects.Window as Wnck.Window++-- | Memory-managed wrapper type.+newtype ClassGroup = ClassGroup (ManagedPtr ClassGroup)+foreign import ccall "wnck_class_group_get_type"+    c_wnck_class_group_get_type :: IO GType++instance GObject ClassGroup where+    gobjectType = c_wnck_class_group_get_type+    ++-- | Type class for types which can be safely cast to `ClassGroup`, for instance with `toClassGroup`.+class (GObject o, O.IsDescendantOf ClassGroup o) => IsClassGroup o+instance (GObject o, O.IsDescendantOf ClassGroup o) => IsClassGroup o++instance O.HasParentTypes ClassGroup+type instance O.ParentTypes ClassGroup = '[GObject.Object.Object]++-- | Cast to `ClassGroup`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toClassGroup :: (MonadIO m, IsClassGroup o) => o -> m ClassGroup+toClassGroup = liftIO . unsafeCastTo ClassGroup++-- | A convenience alias for `Nothing` :: `Maybe` `ClassGroup`.+noClassGroup :: Maybe ClassGroup+noClassGroup = Nothing++#if ENABLE_OVERLOADING+type family ResolveClassGroupMethod (t :: Symbol) (o :: *) :: * where+    ResolveClassGroupMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveClassGroupMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveClassGroupMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveClassGroupMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveClassGroupMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveClassGroupMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveClassGroupMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveClassGroupMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveClassGroupMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveClassGroupMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveClassGroupMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveClassGroupMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveClassGroupMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveClassGroupMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveClassGroupMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveClassGroupMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveClassGroupMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveClassGroupMethod "getIcon" o = ClassGroupGetIconMethodInfo+    ResolveClassGroupMethod "getId" o = ClassGroupGetIdMethodInfo+    ResolveClassGroupMethod "getMiniIcon" o = ClassGroupGetMiniIconMethodInfo+    ResolveClassGroupMethod "getName" o = ClassGroupGetNameMethodInfo+    ResolveClassGroupMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveClassGroupMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveClassGroupMethod "getResClass" o = ClassGroupGetResClassMethodInfo+    ResolveClassGroupMethod "getWindows" o = ClassGroupGetWindowsMethodInfo+    ResolveClassGroupMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveClassGroupMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveClassGroupMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveClassGroupMethod t ClassGroup, O.MethodInfo info ClassGroup p) => OL.IsLabel t (ClassGroup -> 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 ClassGroup::icon-changed+{- |+Emitted when the icon of /@classGroup@/ changes.+-}+type ClassGroupIconChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassGroupIconChangedCallback`@.+noClassGroupIconChangedCallback :: Maybe ClassGroupIconChangedCallback+noClassGroupIconChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ClassGroupIconChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ClassGroupIconChangedCallback`.+foreign import ccall "wrapper"+    mk_ClassGroupIconChangedCallback :: C_ClassGroupIconChangedCallback -> IO (FunPtr C_ClassGroupIconChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ClassGroupIconChanged :: MonadIO m => ClassGroupIconChangedCallback -> m (GClosure C_ClassGroupIconChangedCallback)+genClosure_ClassGroupIconChanged cb = liftIO $ do+    let cb' = wrap_ClassGroupIconChangedCallback cb+    mk_ClassGroupIconChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ClassGroupIconChangedCallback` into a `C_ClassGroupIconChangedCallback`.+wrap_ClassGroupIconChangedCallback ::+    ClassGroupIconChangedCallback ->+    C_ClassGroupIconChangedCallback+wrap_ClassGroupIconChangedCallback _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' classGroup #iconChanged callback+@+-}+onClassGroupIconChanged :: (IsClassGroup a, MonadIO m) => a -> ClassGroupIconChangedCallback -> m SignalHandlerId+onClassGroupIconChanged obj cb = liftIO $ do+    let cb' = wrap_ClassGroupIconChangedCallback cb+    cb'' <- mk_ClassGroupIconChangedCallback 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' classGroup #iconChanged callback+@+-}+afterClassGroupIconChanged :: (IsClassGroup a, MonadIO m) => a -> ClassGroupIconChangedCallback -> m SignalHandlerId+afterClassGroupIconChanged obj cb = liftIO $ do+    let cb' = wrap_ClassGroupIconChangedCallback cb+    cb'' <- mk_ClassGroupIconChangedCallback cb'+    connectSignalFunPtr obj "icon-changed" cb'' SignalConnectAfter+++-- signal ClassGroup::name-changed+{- |+Emitted when the name of /@classGroup@/ changes.+-}+type ClassGroupNameChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassGroupNameChangedCallback`@.+noClassGroupNameChangedCallback :: Maybe ClassGroupNameChangedCallback+noClassGroupNameChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ClassGroupNameChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ClassGroupNameChangedCallback`.+foreign import ccall "wrapper"+    mk_ClassGroupNameChangedCallback :: C_ClassGroupNameChangedCallback -> IO (FunPtr C_ClassGroupNameChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ClassGroupNameChanged :: MonadIO m => ClassGroupNameChangedCallback -> m (GClosure C_ClassGroupNameChangedCallback)+genClosure_ClassGroupNameChanged cb = liftIO $ do+    let cb' = wrap_ClassGroupNameChangedCallback cb+    mk_ClassGroupNameChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ClassGroupNameChangedCallback` into a `C_ClassGroupNameChangedCallback`.+wrap_ClassGroupNameChangedCallback ::+    ClassGroupNameChangedCallback ->+    C_ClassGroupNameChangedCallback+wrap_ClassGroupNameChangedCallback _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' classGroup #nameChanged callback+@+-}+onClassGroupNameChanged :: (IsClassGroup a, MonadIO m) => a -> ClassGroupNameChangedCallback -> m SignalHandlerId+onClassGroupNameChanged obj cb = liftIO $ do+    let cb' = wrap_ClassGroupNameChangedCallback cb+    cb'' <- mk_ClassGroupNameChangedCallback 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' classGroup #nameChanged callback+@+-}+afterClassGroupNameChanged :: (IsClassGroup a, MonadIO m) => a -> ClassGroupNameChangedCallback -> m SignalHandlerId+afterClassGroupNameChanged obj cb = liftIO $ do+    let cb' = wrap_ClassGroupNameChangedCallback cb+    cb'' <- mk_ClassGroupNameChangedCallback cb'+    connectSignalFunPtr obj "name-changed" cb'' SignalConnectAfter+++#if ENABLE_OVERLOADING+instance O.HasAttributeList ClassGroup+type instance O.AttributeList ClassGroup = ClassGroupAttributeList+type ClassGroupAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+data ClassGroupIconChangedSignalInfo+instance SignalInfo ClassGroupIconChangedSignalInfo where+    type HaskellCallbackType ClassGroupIconChangedSignalInfo = ClassGroupIconChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ClassGroupIconChangedCallback cb+        cb'' <- mk_ClassGroupIconChangedCallback cb'+        connectSignalFunPtr obj "icon-changed" cb'' connectMode++data ClassGroupNameChangedSignalInfo+instance SignalInfo ClassGroupNameChangedSignalInfo where+    type HaskellCallbackType ClassGroupNameChangedSignalInfo = ClassGroupNameChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ClassGroupNameChangedCallback cb+        cb'' <- mk_ClassGroupNameChangedCallback cb'+        connectSignalFunPtr obj "name-changed" cb'' connectMode++type instance O.SignalList ClassGroup = ClassGroupSignalList+type ClassGroupSignalList = ('[ '("iconChanged", ClassGroupIconChangedSignalInfo), '("nameChanged", ClassGroupNameChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method ClassGroup::get_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "class_group", argType = TInterface (Name {namespace = "Wnck", name = "ClassGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckClassGroup.", 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_class_group_get_icon" wnck_class_group_get_icon :: +    Ptr ClassGroup ->                       -- class_group : TInterface (Name {namespace = "Wnck", name = "ClassGroup"})+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)++{- |+Gets the icon to be used for /@classGroup@/. Since there is no way to+properly find the icon, a suboptimal heuristic is used to find it. The icon+is the first icon found by looking at all the 'GI.Wnck.Objects.Application.Application' for each+'GI.Wnck.Objects.Window.Window' in /@classGroup@/, then at all the 'GI.Wnck.Objects.Window.Window' in /@classGroup@/. If+no icon was found, a fallback icon is used.++/Since: 2.2/+-}+classGroupGetIcon ::+    (B.CallStack.HasCallStack, MonadIO m, IsClassGroup a) =>+    a+    {- ^ /@classGroup@/: a 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}+    -> m GdkPixbuf.Pixbuf.Pixbuf+    {- ^ __Returns:__ the icon for /@classGroup@/. The caller should+reference the returned \<classname>GdkPixbuf\<\/classname> if it needs to keep+the icon around. -}+classGroupGetIcon classGroup = liftIO $ do+    classGroup' <- unsafeManagedPtrCastPtr classGroup+    result <- wnck_class_group_get_icon classGroup'+    checkUnexpectedReturnNULL "classGroupGetIcon" result+    result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result+    touchManagedPtr classGroup+    return result'++#if ENABLE_OVERLOADING+data ClassGroupGetIconMethodInfo+instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsClassGroup a) => O.MethodInfo ClassGroupGetIconMethodInfo a signature where+    overloadedMethod _ = classGroupGetIcon++#endif++-- method ClassGroup::get_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "class_group", argType = TInterface (Name {namespace = "Wnck", name = "ClassGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckClassGroup.", 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_class_group_get_id" wnck_class_group_get_id :: +    Ptr ClassGroup ->                       -- class_group : TInterface (Name {namespace = "Wnck", name = "ClassGroup"})+    IO CString++{- |+Gets the identifier name for /@classGroup@/. This is the resource class for+/@classGroup@/.++/Since: 3.2/+-}+classGroupGetId ::+    (B.CallStack.HasCallStack, MonadIO m, IsClassGroup a) =>+    a+    {- ^ /@classGroup@/: a 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}+    -> m T.Text+    {- ^ __Returns:__ the identifier name of /@classGroup@/, or an+empty string if the group has no identifier name. -}+classGroupGetId classGroup = liftIO $ do+    classGroup' <- unsafeManagedPtrCastPtr classGroup+    result <- wnck_class_group_get_id classGroup'+    checkUnexpectedReturnNULL "classGroupGetId" result+    result' <- cstringToText result+    touchManagedPtr classGroup+    return result'++#if ENABLE_OVERLOADING+data ClassGroupGetIdMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsClassGroup a) => O.MethodInfo ClassGroupGetIdMethodInfo a signature where+    overloadedMethod _ = classGroupGetId++#endif++-- method ClassGroup::get_mini_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "class_group", argType = TInterface (Name {namespace = "Wnck", name = "ClassGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckClassGroup.", 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_class_group_get_mini_icon" wnck_class_group_get_mini_icon :: +    Ptr ClassGroup ->                       -- class_group : TInterface (Name {namespace = "Wnck", name = "ClassGroup"})+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)++{- |+Gets the mini-icon to be used for /@classGroup@/. Since there is no way to+properly find the mini-icon, the same suboptimal heuristic as the one for+'GI.Wnck.Objects.ClassGroup.classGroupGetIcon' is used to find it.++/Since: 2.2/+-}+classGroupGetMiniIcon ::+    (B.CallStack.HasCallStack, MonadIO m, IsClassGroup a) =>+    a+    {- ^ /@classGroup@/: a 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}+    -> m GdkPixbuf.Pixbuf.Pixbuf+    {- ^ __Returns:__ the mini-icon for /@classGroup@/. The caller+should reference the returned \<classname>GdkPixbuf\<\/classname> if it needs+to keep the mini-icon around. -}+classGroupGetMiniIcon classGroup = liftIO $ do+    classGroup' <- unsafeManagedPtrCastPtr classGroup+    result <- wnck_class_group_get_mini_icon classGroup'+    checkUnexpectedReturnNULL "classGroupGetMiniIcon" result+    result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result+    touchManagedPtr classGroup+    return result'++#if ENABLE_OVERLOADING+data ClassGroupGetMiniIconMethodInfo+instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsClassGroup a) => O.MethodInfo ClassGroupGetMiniIconMethodInfo a signature where+    overloadedMethod _ = classGroupGetMiniIcon++#endif++-- method ClassGroup::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "class_group", argType = TInterface (Name {namespace = "Wnck", name = "ClassGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckClassGroup.", 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_class_group_get_name" wnck_class_group_get_name :: +    Ptr ClassGroup ->                       -- class_group : TInterface (Name {namespace = "Wnck", name = "ClassGroup"})+    IO CString++{- |+Gets an human-readable name for /@classGroup@/. Since there is no way to+properly find this name, a suboptimal heuristic is used to find it. The name+is the name of all 'GI.Wnck.Objects.Application.Application' for each 'GI.Wnck.Objects.Window.Window' in /@classGroup@/ if+they all have the same name. If all 'GI.Wnck.Objects.Application.Application' don\'t have the same+name, the name is the name of all 'GI.Wnck.Objects.Window.Window' in /@classGroup@/ if they all+have the same name. If all 'GI.Wnck.Objects.Window.Window' don\'t have the same name, the+resource class name is used.++/Since: 2.2/+-}+classGroupGetName ::+    (B.CallStack.HasCallStack, MonadIO m, IsClassGroup a) =>+    a+    {- ^ /@classGroup@/: a 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}+    -> m T.Text+    {- ^ __Returns:__ an human-readable name for /@classGroup@/. -}+classGroupGetName classGroup = liftIO $ do+    classGroup' <- unsafeManagedPtrCastPtr classGroup+    result <- wnck_class_group_get_name classGroup'+    checkUnexpectedReturnNULL "classGroupGetName" result+    result' <- cstringToText result+    touchManagedPtr classGroup+    return result'++#if ENABLE_OVERLOADING+data ClassGroupGetNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsClassGroup a) => O.MethodInfo ClassGroupGetNameMethodInfo a signature where+    overloadedMethod _ = classGroupGetName++#endif++-- method ClassGroup::get_res_class+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "class_group", argType = TInterface (Name {namespace = "Wnck", name = "ClassGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckClassGroup.", 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_class_group_get_res_class" wnck_class_group_get_res_class :: +    Ptr ClassGroup ->                       -- class_group : TInterface (Name {namespace = "Wnck", name = "ClassGroup"})+    IO CString++{-# DEPRECATED classGroupGetResClass ["(Since version 3.2)","Use 'GI.Wnck.Objects.ClassGroup.classGroupGetId' instead."] #-}+{- |+Gets the resource class name for /@classGroup@/.++/Since: 2.2/+-}+classGroupGetResClass ::+    (B.CallStack.HasCallStack, MonadIO m, IsClassGroup a) =>+    a+    {- ^ /@classGroup@/: a 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}+    -> m T.Text+    {- ^ __Returns:__ the resource class name of /@classGroup@/, or an+empty string if the group has no resource class name. -}+classGroupGetResClass classGroup = liftIO $ do+    classGroup' <- unsafeManagedPtrCastPtr classGroup+    result <- wnck_class_group_get_res_class classGroup'+    checkUnexpectedReturnNULL "classGroupGetResClass" result+    result' <- cstringToText result+    touchManagedPtr classGroup+    return result'++#if ENABLE_OVERLOADING+data ClassGroupGetResClassMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsClassGroup a) => O.MethodInfo ClassGroupGetResClassMethodInfo a signature where+    overloadedMethod _ = classGroupGetResClass++#endif++-- method ClassGroup::get_windows+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "class_group", argType = TInterface (Name {namespace = "Wnck", name = "ClassGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckClassGroup.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TGList (TInterface (Name {namespace = "Wnck", name = "Window"})))+-- throws : False+-- Skip return : False++foreign import ccall "wnck_class_group_get_windows" wnck_class_group_get_windows :: +    Ptr ClassGroup ->                       -- class_group : TInterface (Name {namespace = "Wnck", name = "ClassGroup"})+    IO (Ptr (GList (Ptr Wnck.Window.Window)))++{- |+Gets the list of 'GI.Wnck.Objects.Window.Window' that are grouped in /@classGroup@/.++/Since: 2.2/+-}+classGroupGetWindows ::+    (B.CallStack.HasCallStack, MonadIO m, IsClassGroup a) =>+    a+    {- ^ /@classGroup@/: a 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}+    -> m [Wnck.Window.Window]+    {- ^ __Returns:__ the list of+'GI.Wnck.Objects.Window.Window' grouped in /@classGroup@/, or 'Nothing' if the group contains no+window. The list should not be modified nor freed, as it is owned by+/@classGroup@/. -}+classGroupGetWindows classGroup = liftIO $ do+    classGroup' <- unsafeManagedPtrCastPtr classGroup+    result <- wnck_class_group_get_windows classGroup'+    result' <- unpackGList result+    result'' <- mapM (newObject Wnck.Window.Window) result'+    touchManagedPtr classGroup+    return result''++#if ENABLE_OVERLOADING+data ClassGroupGetWindowsMethodInfo+instance (signature ~ (m [Wnck.Window.Window]), MonadIO m, IsClassGroup a) => O.MethodInfo ClassGroupGetWindowsMethodInfo a signature where+    overloadedMethod _ = classGroupGetWindows++#endif++-- method ClassGroup::get+-- method type : MemberFunction+-- Args : [Arg {argCName = "id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "identifier name of the sought resource class.", 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_class_group_get" wnck_class_group_get :: +    CString ->                              -- id : TBasicType TUTF8+    IO (Ptr ClassGroup)++{- |+Gets the 'GI.Wnck.Objects.ClassGroup.ClassGroup' corresponding to /@id@/.++/Since: 2.2/+-}+classGroupGet ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@id@/: identifier name of the sought resource class. -}+    -> m ClassGroup+    {- ^ __Returns:__ the 'GI.Wnck.Objects.ClassGroup.ClassGroup' corresponding to+/@id@/, or 'Nothing' if there is no 'GI.Wnck.Objects.ClassGroup.ClassGroup' with the specified+/@id@/. The returned 'GI.Wnck.Objects.ClassGroup.ClassGroup' is owned by libwnck and must not be+referenced or unreferenced. -}+classGroupGet id = liftIO $ do+    id' <- textToCString id+    result <- wnck_class_group_get id'+    checkUnexpectedReturnNULL "classGroupGet" result+    result' <- (newObject ClassGroup) result+    freeMem id'+    return result'++#if ENABLE_OVERLOADING+#endif++

@@ -0,0 +1,53 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Wnck.Objects.ClassGroup 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++newtype ClassGroup = ClassGroup (ManagedPtr ClassGroup)+instance GObject ClassGroup where+class (GObject o, O.IsDescendantOf ClassGroup o) => IsClassGroup o+instance (GObject o, O.IsDescendantOf ClassGroup o) => IsClassGroup o+instance O.HasParentTypes ClassGroup+#if ENABLE_OVERLOADING+data ClassGroupIconChangedSignalInfo+#endif+#if ENABLE_OVERLOADING+data ClassGroupNameChangedSignalInfo+#endif+#if ENABLE_OVERLOADING+data ClassGroupGetIconMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClassGroupGetIdMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClassGroupGetMiniIconMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClassGroupGetNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClassGroupGetResClassMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClassGroupGetWindowsMethodInfo+#endif

@@ -0,0 +1,695 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Wnck.Objects.ImageMenuItem+    ( ++-- * Exported types+    ImageMenuItem(..)                       ,+    IsImageMenuItem                         ,+    toImageMenuItem                         ,+    noImageMenuItem                         ,+++ -- * Methods+-- ** makeLabelBold #method:makeLabelBold#++#if ENABLE_OVERLOADING+    ImageMenuItemMakeLabelBoldMethodInfo    ,+#endif+    imageMenuItemMakeLabelBold              ,+++-- ** makeLabelNormal #method:makeLabelNormal#++#if ENABLE_OVERLOADING+    ImageMenuItemMakeLabelNormalMethodInfo  ,+#endif+    imageMenuItemMakeLabelNormal            ,+++-- ** new #method:new#++    imageMenuItemNew                        ,+++-- ** newWithLabel #method:newWithLabel#++    imageMenuItemNewWithLabel               ,+++-- ** setImageFromIconPixbuf #method:setImageFromIconPixbuf#++#if ENABLE_OVERLOADING+    ImageMenuItemSetImageFromIconPixbufMethodInfo,+#endif+    imageMenuItemSetImageFromIconPixbuf     ,+++-- ** setImageFromWindow #method:setImageFromWindow#++#if ENABLE_OVERLOADING+    ImageMenuItemSetImageFromWindowMethodInfo,+#endif+    imageMenuItemSetImageFromWindow         ,+++++    ) 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.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface+import qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf+import qualified GI.Gtk.Interfaces.Actionable as Gtk.Actionable+import qualified GI.Gtk.Interfaces.Activatable as Gtk.Activatable+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.Bin as Gtk.Bin+import qualified GI.Gtk.Objects.Container as Gtk.Container+import qualified GI.Gtk.Objects.MenuItem as Gtk.MenuItem+import qualified GI.Gtk.Objects.Widget as Gtk.Widget+import {-# SOURCE #-} qualified GI.Wnck.Objects.Window as Wnck.Window++-- | Memory-managed wrapper type.+newtype ImageMenuItem = ImageMenuItem (ManagedPtr ImageMenuItem)+foreign import ccall "wnck_image_menu_item_get_type"+    c_wnck_image_menu_item_get_type :: IO GType++instance GObject ImageMenuItem where+    gobjectType = c_wnck_image_menu_item_get_type+    ++-- | Type class for types which can be safely cast to `ImageMenuItem`, for instance with `toImageMenuItem`.+class (GObject o, O.IsDescendantOf ImageMenuItem o) => IsImageMenuItem o+instance (GObject o, O.IsDescendantOf ImageMenuItem o) => IsImageMenuItem o++instance O.HasParentTypes ImageMenuItem+type instance O.ParentTypes ImageMenuItem = '[Gtk.MenuItem.MenuItem, Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Actionable.Actionable, Gtk.Activatable.Activatable, Gtk.Buildable.Buildable]++-- | Cast to `ImageMenuItem`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toImageMenuItem :: (MonadIO m, IsImageMenuItem o) => o -> m ImageMenuItem+toImageMenuItem = liftIO . unsafeCastTo ImageMenuItem++-- | A convenience alias for `Nothing` :: `Maybe` `ImageMenuItem`.+noImageMenuItem :: Maybe ImageMenuItem+noImageMenuItem = Nothing++#if ENABLE_OVERLOADING+type family ResolveImageMenuItemMethod (t :: Symbol) (o :: *) :: * where+    ResolveImageMenuItemMethod "activate" o = Gtk.MenuItem.MenuItemActivateMethodInfo+    ResolveImageMenuItemMethod "add" o = Gtk.Container.ContainerAddMethodInfo+    ResolveImageMenuItemMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolveImageMenuItemMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolveImageMenuItemMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolveImageMenuItemMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolveImageMenuItemMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolveImageMenuItemMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolveImageMenuItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveImageMenuItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveImageMenuItemMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolveImageMenuItemMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo+    ResolveImageMenuItemMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolveImageMenuItemMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo+    ResolveImageMenuItemMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo+    ResolveImageMenuItemMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo+    ResolveImageMenuItemMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo+    ResolveImageMenuItemMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo+    ResolveImageMenuItemMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolveImageMenuItemMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolveImageMenuItemMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolveImageMenuItemMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolveImageMenuItemMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolveImageMenuItemMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolveImageMenuItemMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolveImageMenuItemMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolveImageMenuItemMethod "deselect" o = Gtk.MenuItem.MenuItemDeselectMethodInfo+    ResolveImageMenuItemMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolveImageMenuItemMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolveImageMenuItemMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolveImageMenuItemMethod "doSetRelatedAction" o = Gtk.Activatable.ActivatableDoSetRelatedActionMethodInfo+    ResolveImageMenuItemMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolveImageMenuItemMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolveImageMenuItemMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolveImageMenuItemMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolveImageMenuItemMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolveImageMenuItemMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolveImageMenuItemMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolveImageMenuItemMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolveImageMenuItemMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolveImageMenuItemMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolveImageMenuItemMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolveImageMenuItemMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolveImageMenuItemMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolveImageMenuItemMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolveImageMenuItemMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolveImageMenuItemMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolveImageMenuItemMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolveImageMenuItemMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolveImageMenuItemMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolveImageMenuItemMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolveImageMenuItemMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolveImageMenuItemMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolveImageMenuItemMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolveImageMenuItemMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolveImageMenuItemMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolveImageMenuItemMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolveImageMenuItemMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolveImageMenuItemMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolveImageMenuItemMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolveImageMenuItemMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolveImageMenuItemMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolveImageMenuItemMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolveImageMenuItemMethod "forall" o = Gtk.Container.ContainerForallMethodInfo+    ResolveImageMenuItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveImageMenuItemMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo+    ResolveImageMenuItemMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolveImageMenuItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveImageMenuItemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveImageMenuItemMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolveImageMenuItemMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolveImageMenuItemMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolveImageMenuItemMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolveImageMenuItemMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolveImageMenuItemMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolveImageMenuItemMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolveImageMenuItemMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolveImageMenuItemMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolveImageMenuItemMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolveImageMenuItemMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolveImageMenuItemMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolveImageMenuItemMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolveImageMenuItemMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolveImageMenuItemMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolveImageMenuItemMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolveImageMenuItemMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolveImageMenuItemMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolveImageMenuItemMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolveImageMenuItemMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolveImageMenuItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveImageMenuItemMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolveImageMenuItemMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolveImageMenuItemMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolveImageMenuItemMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolveImageMenuItemMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolveImageMenuItemMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolveImageMenuItemMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolveImageMenuItemMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolveImageMenuItemMethod "makeLabelBold" o = ImageMenuItemMakeLabelBoldMethodInfo+    ResolveImageMenuItemMethod "makeLabelNormal" o = ImageMenuItemMakeLabelNormalMethodInfo+    ResolveImageMenuItemMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolveImageMenuItemMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolveImageMenuItemMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolveImageMenuItemMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolveImageMenuItemMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolveImageMenuItemMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolveImageMenuItemMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolveImageMenuItemMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolveImageMenuItemMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolveImageMenuItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveImageMenuItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveImageMenuItemMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolveImageMenuItemMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolveImageMenuItemMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolveImageMenuItemMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolveImageMenuItemMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolveImageMenuItemMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolveImageMenuItemMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolveImageMenuItemMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo+    ResolveImageMenuItemMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolveImageMenuItemMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolveImageMenuItemMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolveImageMenuItemMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolveImageMenuItemMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolveImageMenuItemMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolveImageMenuItemMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolveImageMenuItemMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolveImageMenuItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveImageMenuItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveImageMenuItemMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolveImageMenuItemMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolveImageMenuItemMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo+    ResolveImageMenuItemMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolveImageMenuItemMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolveImageMenuItemMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolveImageMenuItemMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolveImageMenuItemMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolveImageMenuItemMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolveImageMenuItemMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolveImageMenuItemMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolveImageMenuItemMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo+    ResolveImageMenuItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveImageMenuItemMethod "select" o = Gtk.MenuItem.MenuItemSelectMethodInfo+    ResolveImageMenuItemMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolveImageMenuItemMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolveImageMenuItemMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolveImageMenuItemMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolveImageMenuItemMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolveImageMenuItemMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolveImageMenuItemMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolveImageMenuItemMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolveImageMenuItemMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolveImageMenuItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveImageMenuItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveImageMenuItemMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolveImageMenuItemMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolveImageMenuItemMethod "syncActionProperties" o = Gtk.Activatable.ActivatableSyncActionPropertiesMethodInfo+    ResolveImageMenuItemMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolveImageMenuItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveImageMenuItemMethod "toggleSizeAllocate" o = Gtk.MenuItem.MenuItemToggleSizeAllocateMethodInfo+    ResolveImageMenuItemMethod "toggleSizeRequest" o = Gtk.MenuItem.MenuItemToggleSizeRequestMethodInfo+    ResolveImageMenuItemMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolveImageMenuItemMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolveImageMenuItemMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolveImageMenuItemMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolveImageMenuItemMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolveImageMenuItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveImageMenuItemMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolveImageMenuItemMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo+    ResolveImageMenuItemMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolveImageMenuItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveImageMenuItemMethod "getAccelPath" o = Gtk.MenuItem.MenuItemGetAccelPathMethodInfo+    ResolveImageMenuItemMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolveImageMenuItemMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolveImageMenuItemMethod "getActionName" o = Gtk.Actionable.ActionableGetActionNameMethodInfo+    ResolveImageMenuItemMethod "getActionTargetValue" o = Gtk.Actionable.ActionableGetActionTargetValueMethodInfo+    ResolveImageMenuItemMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolveImageMenuItemMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolveImageMenuItemMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolveImageMenuItemMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolveImageMenuItemMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolveImageMenuItemMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolveImageMenuItemMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolveImageMenuItemMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo+    ResolveImageMenuItemMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolveImageMenuItemMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolveImageMenuItemMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo+    ResolveImageMenuItemMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolveImageMenuItemMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolveImageMenuItemMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo+    ResolveImageMenuItemMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolveImageMenuItemMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolveImageMenuItemMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolveImageMenuItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveImageMenuItemMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolveImageMenuItemMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolveImageMenuItemMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolveImageMenuItemMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolveImageMenuItemMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolveImageMenuItemMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolveImageMenuItemMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo+    ResolveImageMenuItemMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo+    ResolveImageMenuItemMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo+    ResolveImageMenuItemMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolveImageMenuItemMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo+    ResolveImageMenuItemMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolveImageMenuItemMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolveImageMenuItemMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolveImageMenuItemMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolveImageMenuItemMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolveImageMenuItemMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolveImageMenuItemMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolveImageMenuItemMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolveImageMenuItemMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolveImageMenuItemMethod "getLabel" o = Gtk.MenuItem.MenuItemGetLabelMethodInfo+    ResolveImageMenuItemMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolveImageMenuItemMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolveImageMenuItemMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolveImageMenuItemMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolveImageMenuItemMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolveImageMenuItemMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolveImageMenuItemMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolveImageMenuItemMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolveImageMenuItemMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolveImageMenuItemMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolveImageMenuItemMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolveImageMenuItemMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolveImageMenuItemMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolveImageMenuItemMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolveImageMenuItemMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolveImageMenuItemMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolveImageMenuItemMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo+    ResolveImageMenuItemMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolveImageMenuItemMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolveImageMenuItemMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolveImageMenuItemMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolveImageMenuItemMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolveImageMenuItemMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolveImageMenuItemMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolveImageMenuItemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveImageMenuItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveImageMenuItemMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolveImageMenuItemMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolveImageMenuItemMethod "getRelatedAction" o = Gtk.Activatable.ActivatableGetRelatedActionMethodInfo+    ResolveImageMenuItemMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolveImageMenuItemMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolveImageMenuItemMethod "getReserveIndicator" o = Gtk.MenuItem.MenuItemGetReserveIndicatorMethodInfo+    ResolveImageMenuItemMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo+    ResolveImageMenuItemMethod "getRightJustified" o = Gtk.MenuItem.MenuItemGetRightJustifiedMethodInfo+    ResolveImageMenuItemMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolveImageMenuItemMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolveImageMenuItemMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolveImageMenuItemMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolveImageMenuItemMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolveImageMenuItemMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolveImageMenuItemMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolveImageMenuItemMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolveImageMenuItemMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolveImageMenuItemMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolveImageMenuItemMethod "getSubmenu" o = Gtk.MenuItem.MenuItemGetSubmenuMethodInfo+    ResolveImageMenuItemMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolveImageMenuItemMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolveImageMenuItemMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolveImageMenuItemMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolveImageMenuItemMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolveImageMenuItemMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolveImageMenuItemMethod "getUseActionAppearance" o = Gtk.Activatable.ActivatableGetUseActionAppearanceMethodInfo+    ResolveImageMenuItemMethod "getUseUnderline" o = Gtk.MenuItem.MenuItemGetUseUnderlineMethodInfo+    ResolveImageMenuItemMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolveImageMenuItemMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolveImageMenuItemMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolveImageMenuItemMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolveImageMenuItemMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolveImageMenuItemMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolveImageMenuItemMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolveImageMenuItemMethod "setAccelPath" o = Gtk.MenuItem.MenuItemSetAccelPathMethodInfo+    ResolveImageMenuItemMethod "setActionName" o = Gtk.Actionable.ActionableSetActionNameMethodInfo+    ResolveImageMenuItemMethod "setActionTargetValue" o = Gtk.Actionable.ActionableSetActionTargetValueMethodInfo+    ResolveImageMenuItemMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolveImageMenuItemMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolveImageMenuItemMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo+    ResolveImageMenuItemMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolveImageMenuItemMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolveImageMenuItemMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolveImageMenuItemMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolveImageMenuItemMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolveImageMenuItemMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolveImageMenuItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveImageMenuItemMethod "setDetailedActionName" o = Gtk.Actionable.ActionableSetDetailedActionNameMethodInfo+    ResolveImageMenuItemMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolveImageMenuItemMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolveImageMenuItemMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolveImageMenuItemMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolveImageMenuItemMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolveImageMenuItemMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo+    ResolveImageMenuItemMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo+    ResolveImageMenuItemMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo+    ResolveImageMenuItemMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolveImageMenuItemMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo+    ResolveImageMenuItemMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolveImageMenuItemMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolveImageMenuItemMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolveImageMenuItemMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolveImageMenuItemMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolveImageMenuItemMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolveImageMenuItemMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolveImageMenuItemMethod "setImageFromIconPixbuf" o = ImageMenuItemSetImageFromIconPixbufMethodInfo+    ResolveImageMenuItemMethod "setImageFromWindow" o = ImageMenuItemSetImageFromWindowMethodInfo+    ResolveImageMenuItemMethod "setLabel" o = Gtk.MenuItem.MenuItemSetLabelMethodInfo+    ResolveImageMenuItemMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolveImageMenuItemMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolveImageMenuItemMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolveImageMenuItemMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolveImageMenuItemMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolveImageMenuItemMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolveImageMenuItemMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolveImageMenuItemMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolveImageMenuItemMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolveImageMenuItemMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolveImageMenuItemMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolveImageMenuItemMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolveImageMenuItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveImageMenuItemMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolveImageMenuItemMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo+    ResolveImageMenuItemMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolveImageMenuItemMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolveImageMenuItemMethod "setRelatedAction" o = Gtk.Activatable.ActivatableSetRelatedActionMethodInfo+    ResolveImageMenuItemMethod "setReserveIndicator" o = Gtk.MenuItem.MenuItemSetReserveIndicatorMethodInfo+    ResolveImageMenuItemMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo+    ResolveImageMenuItemMethod "setRightJustified" o = Gtk.MenuItem.MenuItemSetRightJustifiedMethodInfo+    ResolveImageMenuItemMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolveImageMenuItemMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolveImageMenuItemMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolveImageMenuItemMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolveImageMenuItemMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolveImageMenuItemMethod "setSubmenu" o = Gtk.MenuItem.MenuItemSetSubmenuMethodInfo+    ResolveImageMenuItemMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolveImageMenuItemMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolveImageMenuItemMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolveImageMenuItemMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolveImageMenuItemMethod "setUseActionAppearance" o = Gtk.Activatable.ActivatableSetUseActionAppearanceMethodInfo+    ResolveImageMenuItemMethod "setUseUnderline" o = Gtk.MenuItem.MenuItemSetUseUnderlineMethodInfo+    ResolveImageMenuItemMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolveImageMenuItemMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolveImageMenuItemMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolveImageMenuItemMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolveImageMenuItemMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolveImageMenuItemMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolveImageMenuItemMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveImageMenuItemMethod t ImageMenuItem, O.MethodInfo info ImageMenuItem p) => OL.IsLabel t (ImageMenuItem -> 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++#if ENABLE_OVERLOADING+instance O.HasAttributeList ImageMenuItem+type instance O.AttributeList ImageMenuItem = ImageMenuItemAttributeList+type ImageMenuItemAttributeList = ('[ '("accelPath", Gtk.MenuItem.MenuItemAccelPathPropertyInfo), '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("label", Gtk.MenuItem.MenuItemLabelPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("relatedAction", Gtk.Activatable.ActivatableRelatedActionPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("rightJustified", Gtk.MenuItem.MenuItemRightJustifiedPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("submenu", Gtk.MenuItem.MenuItemSubmenuPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useActionAppearance", Gtk.Activatable.ActivatableUseActionAppearancePropertyInfo), '("useUnderline", Gtk.MenuItem.MenuItemUseUnderlinePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type instance O.SignalList ImageMenuItem = ImageMenuItemSignalList+type ImageMenuItemSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activate", Gtk.MenuItem.MenuItemActivateSignalInfo), '("activateItem", Gtk.MenuItem.MenuItemActivateItemSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("deselect", Gtk.MenuItem.MenuItemDeselectSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("select", Gtk.MenuItem.MenuItemSelectSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("toggleSizeAllocate", Gtk.MenuItem.MenuItemToggleSizeAllocateSignalInfo), '("toggleSizeRequest", Gtk.MenuItem.MenuItemToggleSizeRequestSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])++#endif++-- method ImageMenuItem::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"}))+-- throws : False+-- Skip return : False++foreign import ccall "wnck_image_menu_item_new" wnck_image_menu_item_new :: +    IO (Ptr ImageMenuItem)++{- |+/No description available in the introspection data./+-}+imageMenuItemNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m ImageMenuItem+imageMenuItemNew  = liftIO $ do+    result <- wnck_image_menu_item_new+    checkUnexpectedReturnNULL "imageMenuItemNew" result+    result' <- (newObject ImageMenuItem) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method ImageMenuItem::new_with_label+-- method type : Constructor+-- Args : [Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"}))+-- throws : False+-- Skip return : False++foreign import ccall "wnck_image_menu_item_new_with_label" wnck_image_menu_item_new_with_label :: +    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr ImageMenuItem)++{- |+/No description available in the introspection data./+-}+imageMenuItemNewWithLabel ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    -> m ImageMenuItem+imageMenuItemNewWithLabel label = liftIO $ do+    label' <- textToCString label+    result <- wnck_image_menu_item_new_with_label label'+    checkUnexpectedReturnNULL "imageMenuItemNewWithLabel" result+    result' <- (newObject ImageMenuItem) result+    freeMem label'+    return result'++#if ENABLE_OVERLOADING+#endif++-- method ImageMenuItem::make_label_bold+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_image_menu_item_make_label_bold" wnck_image_menu_item_make_label_bold :: +    Ptr ImageMenuItem ->                    -- item : TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"})+    IO ()++{- |+/No description available in the introspection data./+-}+imageMenuItemMakeLabelBold ::+    (B.CallStack.HasCallStack, MonadIO m, IsImageMenuItem a) =>+    a+    -> m ()+imageMenuItemMakeLabelBold item = liftIO $ do+    item' <- unsafeManagedPtrCastPtr item+    wnck_image_menu_item_make_label_bold item'+    touchManagedPtr item+    return ()++#if ENABLE_OVERLOADING+data ImageMenuItemMakeLabelBoldMethodInfo+instance (signature ~ (m ()), MonadIO m, IsImageMenuItem a) => O.MethodInfo ImageMenuItemMakeLabelBoldMethodInfo a signature where+    overloadedMethod _ = imageMenuItemMakeLabelBold++#endif++-- method ImageMenuItem::make_label_normal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_image_menu_item_make_label_normal" wnck_image_menu_item_make_label_normal :: +    Ptr ImageMenuItem ->                    -- item : TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"})+    IO ()++{- |+/No description available in the introspection data./+-}+imageMenuItemMakeLabelNormal ::+    (B.CallStack.HasCallStack, MonadIO m, IsImageMenuItem a) =>+    a+    -> m ()+imageMenuItemMakeLabelNormal item = liftIO $ do+    item' <- unsafeManagedPtrCastPtr item+    wnck_image_menu_item_make_label_normal item'+    touchManagedPtr item+    return ()++#if ENABLE_OVERLOADING+data ImageMenuItemMakeLabelNormalMethodInfo+instance (signature ~ (m ()), MonadIO m, IsImageMenuItem a) => O.MethodInfo ImageMenuItemMakeLabelNormalMethodInfo a signature where+    overloadedMethod _ = imageMenuItemMakeLabelNormal++#endif++-- method ImageMenuItem::set_image_from_icon_pixbuf+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_image_menu_item_set_image_from_icon_pixbuf" wnck_image_menu_item_set_image_from_icon_pixbuf :: +    Ptr ImageMenuItem ->                    -- item : TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"})+    Ptr GdkPixbuf.Pixbuf.Pixbuf ->          -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO ()++{- |+/No description available in the introspection data./+-}+imageMenuItemSetImageFromIconPixbuf ::+    (B.CallStack.HasCallStack, MonadIO m, IsImageMenuItem a, GdkPixbuf.Pixbuf.IsPixbuf b) =>+    a+    -> b+    -> m ()+imageMenuItemSetImageFromIconPixbuf item pixbuf = liftIO $ do+    item' <- unsafeManagedPtrCastPtr item+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    wnck_image_menu_item_set_image_from_icon_pixbuf item' pixbuf'+    touchManagedPtr item+    touchManagedPtr pixbuf+    return ()++#if ENABLE_OVERLOADING+data ImageMenuItemSetImageFromIconPixbufMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, IsImageMenuItem a, GdkPixbuf.Pixbuf.IsPixbuf b) => O.MethodInfo ImageMenuItemSetImageFromIconPixbufMethodInfo a signature where+    overloadedMethod _ = imageMenuItemSetImageFromIconPixbuf++#endif++-- method ImageMenuItem::set_image_from_window+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_image_menu_item_set_image_from_window" wnck_image_menu_item_set_image_from_window :: +    Ptr ImageMenuItem ->                    -- item : TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"})+    Ptr Wnck.Window.Window ->               -- window : TInterface (Name {namespace = "Wnck", name = "Window"})+    IO ()++{- |+/No description available in the introspection data./+-}+imageMenuItemSetImageFromWindow ::+    (B.CallStack.HasCallStack, MonadIO m, IsImageMenuItem a, Wnck.Window.IsWindow b) =>+    a+    -> b+    -> m ()+imageMenuItemSetImageFromWindow item window = liftIO $ do+    item' <- unsafeManagedPtrCastPtr item+    window' <- unsafeManagedPtrCastPtr window+    wnck_image_menu_item_set_image_from_window item' window'+    touchManagedPtr item+    touchManagedPtr window+    return ()++#if ENABLE_OVERLOADING+data ImageMenuItemSetImageFromWindowMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, IsImageMenuItem a, Wnck.Window.IsWindow b) => O.MethodInfo ImageMenuItemSetImageFromWindowMethodInfo a signature where+    overloadedMethod _ = imageMenuItemSetImageFromWindow++#endif++

@@ -0,0 +1,41 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Wnck.Objects.ImageMenuItem 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++newtype ImageMenuItem = ImageMenuItem (ManagedPtr ImageMenuItem)+instance GObject ImageMenuItem where+class (GObject o, O.IsDescendantOf ImageMenuItem o) => IsImageMenuItem o+instance (GObject o, O.IsDescendantOf ImageMenuItem o) => IsImageMenuItem o+instance O.HasParentTypes ImageMenuItem+#if ENABLE_OVERLOADING+data ImageMenuItemMakeLabelBoldMethodInfo+#endif+#if ENABLE_OVERLOADING+data ImageMenuItemMakeLabelNormalMethodInfo+#endif+#if ENABLE_OVERLOADING+data ImageMenuItemSetImageFromIconPixbufMethodInfo+#endif+#if ENABLE_OVERLOADING+data ImageMenuItemSetImageFromWindowMethodInfo+#endif

@@ -0,0 +1,798 @@+++{- |+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.Pager.Pager' 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.Pager+    ( ++-- * Exported types+    Pager(..)                               ,+    IsPager                                 ,+    toPager                                 ,+    noPager                                 ,+++ -- * Methods+-- ** getWrapOnScroll #method:getWrapOnScroll#++#if ENABLE_OVERLOADING+    PagerGetWrapOnScrollMethodInfo          ,+#endif+    pagerGetWrapOnScroll                    ,+++-- ** new #method:new#++    pagerNew                                ,+++-- ** setDisplayMode #method:setDisplayMode#++#if ENABLE_OVERLOADING+    PagerSetDisplayModeMethodInfo           ,+#endif+    pagerSetDisplayMode                     ,+++-- ** setNRows #method:setNRows#++#if ENABLE_OVERLOADING+    PagerSetNRowsMethodInfo                 ,+#endif+    pagerSetNRows                           ,+++-- ** setOrientation #method:setOrientation#++#if ENABLE_OVERLOADING+    PagerSetOrientationMethodInfo           ,+#endif+    pagerSetOrientation                     ,+++-- ** setShadowType #method:setShadowType#++#if ENABLE_OVERLOADING+    PagerSetShadowTypeMethodInfo            ,+#endif+    pagerSetShadowType                      ,+++-- ** setShowAll #method:setShowAll#++#if ENABLE_OVERLOADING+    PagerSetShowAllMethodInfo               ,+#endif+    pagerSetShowAll                         ,+++-- ** setWrapOnScroll #method:setWrapOnScroll#++#if ENABLE_OVERLOADING+    PagerSetWrapOnScrollMethodInfo          ,+#endif+    pagerSetWrapOnScroll                    ,+++++    ) 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.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface+import qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.Gtk.Enums as Gtk.Enums+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable+import qualified GI.Gtk.Objects.Widget as Gtk.Widget+import {-# SOURCE #-} qualified GI.Wnck.Enums as Wnck.Enums++-- | Memory-managed wrapper type.+newtype Pager = Pager (ManagedPtr Pager)+foreign import ccall "wnck_pager_get_type"+    c_wnck_pager_get_type :: IO GType++instance GObject Pager where+    gobjectType = c_wnck_pager_get_type+    ++-- | Type class for types which can be safely cast to `Pager`, for instance with `toPager`.+class (GObject o, O.IsDescendantOf Pager o) => IsPager o+instance (GObject o, O.IsDescendantOf Pager o) => IsPager o++instance O.HasParentTypes Pager+type instance O.ParentTypes Pager = '[Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]++-- | Cast to `Pager`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toPager :: (MonadIO m, IsPager o) => o -> m Pager+toPager = liftIO . unsafeCastTo Pager++-- | A convenience alias for `Nothing` :: `Maybe` `Pager`.+noPager :: Maybe Pager+noPager = Nothing++#if ENABLE_OVERLOADING+type family ResolvePagerMethod (t :: Symbol) (o :: *) :: * where+    ResolvePagerMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo+    ResolvePagerMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo+    ResolvePagerMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo+    ResolvePagerMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo+    ResolvePagerMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo+    ResolvePagerMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo+    ResolvePagerMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo+    ResolvePagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolvePagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolvePagerMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo+    ResolvePagerMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo+    ResolvePagerMethod "childNotify" o = Gtk.Widget.WidgetChildNotifyMethodInfo+    ResolvePagerMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo+    ResolvePagerMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo+    ResolvePagerMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo+    ResolvePagerMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo+    ResolvePagerMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo+    ResolvePagerMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo+    ResolvePagerMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo+    ResolvePagerMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo+    ResolvePagerMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo+    ResolvePagerMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo+    ResolvePagerMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo+    ResolvePagerMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo+    ResolvePagerMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo+    ResolvePagerMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo+    ResolvePagerMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo+    ResolvePagerMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo+    ResolvePagerMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo+    ResolvePagerMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo+    ResolvePagerMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo+    ResolvePagerMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo+    ResolvePagerMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo+    ResolvePagerMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo+    ResolvePagerMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo+    ResolvePagerMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo+    ResolvePagerMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo+    ResolvePagerMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo+    ResolvePagerMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo+    ResolvePagerMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo+    ResolvePagerMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo+    ResolvePagerMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo+    ResolvePagerMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo+    ResolvePagerMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo+    ResolvePagerMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo+    ResolvePagerMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo+    ResolvePagerMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo+    ResolvePagerMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo+    ResolvePagerMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo+    ResolvePagerMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo+    ResolvePagerMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo+    ResolvePagerMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo+    ResolvePagerMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo+    ResolvePagerMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo+    ResolvePagerMethod "event" o = Gtk.Widget.WidgetEventMethodInfo+    ResolvePagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolvePagerMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo+    ResolvePagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolvePagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolvePagerMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo+    ResolvePagerMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo+    ResolvePagerMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo+    ResolvePagerMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo+    ResolvePagerMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo+    ResolvePagerMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo+    ResolvePagerMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo+    ResolvePagerMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo+    ResolvePagerMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo+    ResolvePagerMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo+    ResolvePagerMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo+    ResolvePagerMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo+    ResolvePagerMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo+    ResolvePagerMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo+    ResolvePagerMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo+    ResolvePagerMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo+    ResolvePagerMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo+    ResolvePagerMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo+    ResolvePagerMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo+    ResolvePagerMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo+    ResolvePagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolvePagerMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo+    ResolvePagerMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo+    ResolvePagerMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo+    ResolvePagerMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo+    ResolvePagerMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo+    ResolvePagerMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo+    ResolvePagerMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo+    ResolvePagerMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo+    ResolvePagerMethod "map" o = Gtk.Widget.WidgetMapMethodInfo+    ResolvePagerMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo+    ResolvePagerMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo+    ResolvePagerMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo+    ResolvePagerMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo+    ResolvePagerMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo+    ResolvePagerMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo+    ResolvePagerMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo+    ResolvePagerMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo+    ResolvePagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolvePagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolvePagerMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo+    ResolvePagerMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo+    ResolvePagerMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo+    ResolvePagerMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo+    ResolvePagerMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo+    ResolvePagerMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo+    ResolvePagerMethod "path" o = Gtk.Widget.WidgetPathMethodInfo+    ResolvePagerMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo+    ResolvePagerMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo+    ResolvePagerMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo+    ResolvePagerMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo+    ResolvePagerMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo+    ResolvePagerMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo+    ResolvePagerMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo+    ResolvePagerMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo+    ResolvePagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolvePagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolvePagerMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo+    ResolvePagerMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo+    ResolvePagerMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo+    ResolvePagerMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo+    ResolvePagerMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo+    ResolvePagerMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo+    ResolvePagerMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo+    ResolvePagerMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo+    ResolvePagerMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo+    ResolvePagerMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo+    ResolvePagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolvePagerMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo+    ResolvePagerMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo+    ResolvePagerMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo+    ResolvePagerMethod "show" o = Gtk.Widget.WidgetShowMethodInfo+    ResolvePagerMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo+    ResolvePagerMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo+    ResolvePagerMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo+    ResolvePagerMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo+    ResolvePagerMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo+    ResolvePagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolvePagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolvePagerMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo+    ResolvePagerMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo+    ResolvePagerMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo+    ResolvePagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolvePagerMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo+    ResolvePagerMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo+    ResolvePagerMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo+    ResolvePagerMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo+    ResolvePagerMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo+    ResolvePagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolvePagerMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo+    ResolvePagerMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo+    ResolvePagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolvePagerMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo+    ResolvePagerMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo+    ResolvePagerMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo+    ResolvePagerMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo+    ResolvePagerMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo+    ResolvePagerMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo+    ResolvePagerMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo+    ResolvePagerMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo+    ResolvePagerMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo+    ResolvePagerMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo+    ResolvePagerMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo+    ResolvePagerMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo+    ResolvePagerMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo+    ResolvePagerMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo+    ResolvePagerMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo+    ResolvePagerMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo+    ResolvePagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolvePagerMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo+    ResolvePagerMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo+    ResolvePagerMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo+    ResolvePagerMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo+    ResolvePagerMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo+    ResolvePagerMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo+    ResolvePagerMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo+    ResolvePagerMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo+    ResolvePagerMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo+    ResolvePagerMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo+    ResolvePagerMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo+    ResolvePagerMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo+    ResolvePagerMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo+    ResolvePagerMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo+    ResolvePagerMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo+    ResolvePagerMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo+    ResolvePagerMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo+    ResolvePagerMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo+    ResolvePagerMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo+    ResolvePagerMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo+    ResolvePagerMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo+    ResolvePagerMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo+    ResolvePagerMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo+    ResolvePagerMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo+    ResolvePagerMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo+    ResolvePagerMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo+    ResolvePagerMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo+    ResolvePagerMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo+    ResolvePagerMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo+    ResolvePagerMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo+    ResolvePagerMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo+    ResolvePagerMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo+    ResolvePagerMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo+    ResolvePagerMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo+    ResolvePagerMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo+    ResolvePagerMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo+    ResolvePagerMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo+    ResolvePagerMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo+    ResolvePagerMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo+    ResolvePagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolvePagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolvePagerMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo+    ResolvePagerMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo+    ResolvePagerMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo+    ResolvePagerMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo+    ResolvePagerMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo+    ResolvePagerMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo+    ResolvePagerMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo+    ResolvePagerMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo+    ResolvePagerMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo+    ResolvePagerMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo+    ResolvePagerMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo+    ResolvePagerMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo+    ResolvePagerMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo+    ResolvePagerMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo+    ResolvePagerMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo+    ResolvePagerMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo+    ResolvePagerMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo+    ResolvePagerMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo+    ResolvePagerMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo+    ResolvePagerMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo+    ResolvePagerMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo+    ResolvePagerMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo+    ResolvePagerMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo+    ResolvePagerMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo+    ResolvePagerMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo+    ResolvePagerMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo+    ResolvePagerMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo+    ResolvePagerMethod "getWrapOnScroll" o = PagerGetWrapOnScrollMethodInfo+    ResolvePagerMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo+    ResolvePagerMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo+    ResolvePagerMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo+    ResolvePagerMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo+    ResolvePagerMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo+    ResolvePagerMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo+    ResolvePagerMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo+    ResolvePagerMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo+    ResolvePagerMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo+    ResolvePagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolvePagerMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo+    ResolvePagerMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo+    ResolvePagerMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo+    ResolvePagerMethod "setDisplayMode" o = PagerSetDisplayModeMethodInfo+    ResolvePagerMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo+    ResolvePagerMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo+    ResolvePagerMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo+    ResolvePagerMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo+    ResolvePagerMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo+    ResolvePagerMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo+    ResolvePagerMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo+    ResolvePagerMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo+    ResolvePagerMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo+    ResolvePagerMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo+    ResolvePagerMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo+    ResolvePagerMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo+    ResolvePagerMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo+    ResolvePagerMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo+    ResolvePagerMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo+    ResolvePagerMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo+    ResolvePagerMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo+    ResolvePagerMethod "setNRows" o = PagerSetNRowsMethodInfo+    ResolvePagerMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo+    ResolvePagerMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo+    ResolvePagerMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo+    ResolvePagerMethod "setOrientation" o = PagerSetOrientationMethodInfo+    ResolvePagerMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo+    ResolvePagerMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo+    ResolvePagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolvePagerMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo+    ResolvePagerMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo+    ResolvePagerMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo+    ResolvePagerMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo+    ResolvePagerMethod "setShadowType" o = PagerSetShadowTypeMethodInfo+    ResolvePagerMethod "setShowAll" o = PagerSetShowAllMethodInfo+    ResolvePagerMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo+    ResolvePagerMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo+    ResolvePagerMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo+    ResolvePagerMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo+    ResolvePagerMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo+    ResolvePagerMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo+    ResolvePagerMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo+    ResolvePagerMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo+    ResolvePagerMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo+    ResolvePagerMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo+    ResolvePagerMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo+    ResolvePagerMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo+    ResolvePagerMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo+    ResolvePagerMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo+    ResolvePagerMethod "setWrapOnScroll" o = PagerSetWrapOnScrollMethodInfo+    ResolvePagerMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolvePagerMethod t Pager, O.MethodInfo info Pager p) => OL.IsLabel t (Pager -> 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++#if ENABLE_OVERLOADING+instance O.HasAttributeList Pager+type instance O.AttributeList Pager = PagerAttributeList+type PagerAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type instance O.SignalList Pager = PagerSignalList+type PagerSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])++#endif++-- method Pager::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Pager"}))+-- throws : False+-- Skip return : False++foreign import ccall "wnck_pager_new" wnck_pager_new :: +    IO (Ptr Pager)++{- |+Creates a new 'GI.Wnck.Objects.Pager.Pager'. The 'GI.Wnck.Objects.Pager.Pager' will show the 'GI.Wnck.Objects.Workspace.Workspace' of the+'GI.Wnck.Objects.Screen.Screen' it is on.+-}+pagerNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Pager+    {- ^ __Returns:__ a newly created 'GI.Wnck.Objects.Pager.Pager'. -}+pagerNew  = liftIO $ do+    result <- wnck_pager_new+    checkUnexpectedReturnNULL "pagerNew" result+    result' <- (newObject Pager) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Pager::get_wrap_on_scroll+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pager", argType = TInterface (Name {namespace = "Wnck", name = "Pager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckPager.", 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_pager_get_wrap_on_scroll" wnck_pager_get_wrap_on_scroll :: +    Ptr Pager ->                            -- pager : TInterface (Name {namespace = "Wnck", name = "Pager"})+    IO CInt++{- |+/No description available in the introspection data./++/Since: 3.24.0/+-}+pagerGetWrapOnScroll ::+    (B.CallStack.HasCallStack, MonadIO m, IsPager a) =>+    a+    {- ^ /@pager@/: a 'GI.Wnck.Objects.Pager.Pager'. -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the /@pager@/ wraps workspaces on a scroll event that+hits a border, 'False' otherwise. -}+pagerGetWrapOnScroll pager = liftIO $ do+    pager' <- unsafeManagedPtrCastPtr pager+    result <- wnck_pager_get_wrap_on_scroll pager'+    let result' = (/= 0) result+    touchManagedPtr pager+    return result'++#if ENABLE_OVERLOADING+data PagerGetWrapOnScrollMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsPager a) => O.MethodInfo PagerGetWrapOnScrollMethodInfo a signature where+    overloadedMethod _ = pagerGetWrapOnScroll++#endif++-- method Pager::set_display_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pager", argType = TInterface (Name {namespace = "Wnck", name = "Pager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckPager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Wnck", name = "PagerDisplayMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a display mode.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_pager_set_display_mode" wnck_pager_set_display_mode :: +    Ptr Pager ->                            -- pager : TInterface (Name {namespace = "Wnck", name = "Pager"})+    CUInt ->                                -- mode : TInterface (Name {namespace = "Wnck", name = "PagerDisplayMode"})+    IO ()++{- |+Sets the display mode for /@pager@/ to /@mode@/.+-}+pagerSetDisplayMode ::+    (B.CallStack.HasCallStack, MonadIO m, IsPager a) =>+    a+    {- ^ /@pager@/: a 'GI.Wnck.Objects.Pager.Pager'. -}+    -> Wnck.Enums.PagerDisplayMode+    {- ^ /@mode@/: a display mode. -}+    -> m ()+pagerSetDisplayMode pager mode = liftIO $ do+    pager' <- unsafeManagedPtrCastPtr pager+    let mode' = (fromIntegral . fromEnum) mode+    wnck_pager_set_display_mode pager' mode'+    touchManagedPtr pager+    return ()++#if ENABLE_OVERLOADING+data PagerSetDisplayModeMethodInfo+instance (signature ~ (Wnck.Enums.PagerDisplayMode -> m ()), MonadIO m, IsPager a) => O.MethodInfo PagerSetDisplayModeMethodInfo a signature where+    overloadedMethod _ = pagerSetDisplayMode++#endif++-- method Pager::set_n_rows+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pager", argType = TInterface (Name {namespace = "Wnck", name = "Pager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckPager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_rows", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of rows to use for the layout of #WnckWorkspace on the\n#WnckScreen @pager is watching.", 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_pager_set_n_rows" wnck_pager_set_n_rows :: +    Ptr Pager ->                            -- pager : TInterface (Name {namespace = "Wnck", name = "Pager"})+    Int32 ->                                -- n_rows : TBasicType TInt+    IO CInt++{- |+Tries to change the number of rows in the layout of 'GI.Wnck.Objects.Workspace.Workspace' on the+'GI.Wnck.Objects.Screen.Screen' /@pager@/ is watching. Since no more than one application should+set this property of a 'GI.Wnck.Objects.Screen.Screen' at a time, setting the layout is not+guaranteed to work.++If /@pager@/ has not been added to a widget hierarchy, the call will fail+because /@pager@/ can\'t know the screen on which to modify the layout.+-}+pagerSetNRows ::+    (B.CallStack.HasCallStack, MonadIO m, IsPager a) =>+    a+    {- ^ /@pager@/: a 'GI.Wnck.Objects.Pager.Pager'. -}+    -> Int32+    {- ^ /@nRows@/: the number of rows to use for the layout of 'GI.Wnck.Objects.Workspace.Workspace' on the+'GI.Wnck.Objects.Screen.Screen' /@pager@/ is watching. -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the layout of 'GI.Wnck.Objects.Workspace.Workspace' has been successfully+changed or did not need to be changed, 'False' otherwise. -}+pagerSetNRows pager nRows = liftIO $ do+    pager' <- unsafeManagedPtrCastPtr pager+    result <- wnck_pager_set_n_rows pager' nRows+    let result' = (/= 0) result+    touchManagedPtr pager+    return result'++#if ENABLE_OVERLOADING+data PagerSetNRowsMethodInfo+instance (signature ~ (Int32 -> m Bool), MonadIO m, IsPager a) => O.MethodInfo PagerSetNRowsMethodInfo a signature where+    overloadedMethod _ = pagerSetNRows++#endif++-- method Pager::set_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pager", argType = TInterface (Name {namespace = "Wnck", name = "Pager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckPager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "orientation", argType = TInterface (Name {namespace = "Gtk", name = "Orientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "orientation to use for the layout of #WnckWorkspace on the\n#WnckScreen @pager is watching.", 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_pager_set_orientation" wnck_pager_set_orientation :: +    Ptr Pager ->                            -- pager : TInterface (Name {namespace = "Wnck", name = "Pager"})+    CUInt ->                                -- orientation : TInterface (Name {namespace = "Gtk", name = "Orientation"})+    IO CInt++{- |+Tries to change the orientation of the layout of 'GI.Wnck.Objects.Workspace.Workspace' on the+'GI.Wnck.Objects.Screen.Screen' /@pager@/ is watching. Since no more than one application should+set this property of a 'GI.Wnck.Objects.Screen.Screen' at a time, setting the layout is not+guaranteed to work.++If /@orientation@/ is 'GI.Gtk.Enums.OrientationHorizontal', the 'GI.Wnck.Objects.Workspace.Workspace' will be+laid out in rows, with the first 'GI.Wnck.Objects.Workspace.Workspace' in the top left corner.++If /@orientation@/ is 'GI.Gtk.Enums.OrientationVertical', the 'GI.Wnck.Objects.Workspace.Workspace' will be+laid out in columns, with the first 'GI.Wnck.Objects.Workspace.Workspace' in the top left corner.++For example, if the layout contains one row, but the orientation of the+layout is vertical, the 'GI.Wnck.Objects.Pager.Pager' will display a column of 'GI.Wnck.Objects.Workspace.Workspace'.++Note that setting the orientation will have an effect on the geometry+management: if /@orientation@/ is 'GI.Gtk.Enums.OrientationHorizontal',+'GI.Gtk.Enums.SizeRequestModeWidthForHeight' will be used as request mode; if+/@orientation@/ is 'GI.Gtk.Enums.OrientationVertical', GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH+will be used instead.++If /@pager@/ has not been added to a widget hierarchy, the call will fail+because /@pager@/ can\'t know the screen on which to modify the orientation.+-}+pagerSetOrientation ::+    (B.CallStack.HasCallStack, MonadIO m, IsPager a) =>+    a+    {- ^ /@pager@/: a 'GI.Wnck.Objects.Pager.Pager'. -}+    -> Gtk.Enums.Orientation+    {- ^ /@orientation@/: orientation to use for the layout of 'GI.Wnck.Objects.Workspace.Workspace' on the+'GI.Wnck.Objects.Screen.Screen' /@pager@/ is watching. -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the layout of 'GI.Wnck.Objects.Workspace.Workspace' has been successfully+changed or did not need to be changed, 'False' otherwise. -}+pagerSetOrientation pager orientation = liftIO $ do+    pager' <- unsafeManagedPtrCastPtr pager+    let orientation' = (fromIntegral . fromEnum) orientation+    result <- wnck_pager_set_orientation pager' orientation'+    let result' = (/= 0) result+    touchManagedPtr pager+    return result'++#if ENABLE_OVERLOADING+data PagerSetOrientationMethodInfo+instance (signature ~ (Gtk.Enums.Orientation -> m Bool), MonadIO m, IsPager a) => O.MethodInfo PagerSetOrientationMethodInfo a signature where+    overloadedMethod _ = pagerSetOrientation++#endif++-- method Pager::set_shadow_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pager", argType = TInterface (Name {namespace = "Wnck", name = "Pager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckPager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shadow_type", argType = TInterface (Name {namespace = "Gtk", name = "ShadowType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a shadow 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_pager_set_shadow_type" wnck_pager_set_shadow_type :: +    Ptr Pager ->                            -- pager : TInterface (Name {namespace = "Wnck", name = "Pager"})+    CUInt ->                                -- shadow_type : TInterface (Name {namespace = "Gtk", name = "ShadowType"})+    IO ()++{- |+Sets the shadow type for /@pager@/ to /@shadowType@/. The main use of this+function is proper integration of 'GI.Wnck.Objects.Pager.Pager' in panels with non-system+backgrounds.++/Since: 2.2/+-}+pagerSetShadowType ::+    (B.CallStack.HasCallStack, MonadIO m, IsPager a) =>+    a+    {- ^ /@pager@/: a 'GI.Wnck.Objects.Pager.Pager'. -}+    -> Gtk.Enums.ShadowType+    {- ^ /@shadowType@/: a shadow type. -}+    -> m ()+pagerSetShadowType pager shadowType = liftIO $ do+    pager' <- unsafeManagedPtrCastPtr pager+    let shadowType' = (fromIntegral . fromEnum) shadowType+    wnck_pager_set_shadow_type pager' shadowType'+    touchManagedPtr pager+    return ()++#if ENABLE_OVERLOADING+data PagerSetShadowTypeMethodInfo+instance (signature ~ (Gtk.Enums.ShadowType -> m ()), MonadIO m, IsPager a) => O.MethodInfo PagerSetShadowTypeMethodInfo a signature where+    overloadedMethod _ = pagerSetShadowType++#endif++-- method Pager::set_show_all+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pager", argType = TInterface (Name {namespace = "Wnck", name = "Pager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckPager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "show_all_workspaces", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to display all #WnckWorkspace in @pager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_pager_set_show_all" wnck_pager_set_show_all :: +    Ptr Pager ->                            -- pager : TInterface (Name {namespace = "Wnck", name = "Pager"})+    CInt ->                                 -- show_all_workspaces : TBasicType TBoolean+    IO ()++{- |+Sets /@pager@/ to display all 'GI.Wnck.Objects.Workspace.Workspace' or not, according to+/@showAllWorkspaces@/.+-}+pagerSetShowAll ::+    (B.CallStack.HasCallStack, MonadIO m, IsPager a) =>+    a+    {- ^ /@pager@/: a 'GI.Wnck.Objects.Pager.Pager'. -}+    -> Bool+    {- ^ /@showAllWorkspaces@/: whether to display all 'GI.Wnck.Objects.Workspace.Workspace' in /@pager@/. -}+    -> m ()+pagerSetShowAll pager showAllWorkspaces = liftIO $ do+    pager' <- unsafeManagedPtrCastPtr pager+    let showAllWorkspaces' = (fromIntegral . fromEnum) showAllWorkspaces+    wnck_pager_set_show_all pager' showAllWorkspaces'+    touchManagedPtr pager+    return ()++#if ENABLE_OVERLOADING+data PagerSetShowAllMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsPager a) => O.MethodInfo PagerSetShowAllMethodInfo a signature where+    overloadedMethod _ = pagerSetShowAll++#endif++-- method Pager::set_wrap_on_scroll+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pager", argType = TInterface (Name {namespace = "Wnck", name = "Pager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckPager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wrap_on_scroll", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a boolean.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_pager_set_wrap_on_scroll" wnck_pager_set_wrap_on_scroll :: +    Ptr Pager ->                            -- pager : TInterface (Name {namespace = "Wnck", name = "Pager"})+    CInt ->                                 -- wrap_on_scroll : TBasicType TBoolean+    IO ()++{- |+Sets the wrapping behavior of the /@pager@/. Setting it to 'True' will+wrap arround to the start when scrolling over the end and vice+versa. By default it is set to 'False'.++/Since: 3.24.0/+-}+pagerSetWrapOnScroll ::+    (B.CallStack.HasCallStack, MonadIO m, IsPager a) =>+    a+    {- ^ /@pager@/: a 'GI.Wnck.Objects.Pager.Pager'. -}+    -> Bool+    {- ^ /@wrapOnScroll@/: a boolean. -}+    -> m ()+pagerSetWrapOnScroll pager wrapOnScroll = liftIO $ do+    pager' <- unsafeManagedPtrCastPtr pager+    let wrapOnScroll' = (fromIntegral . fromEnum) wrapOnScroll+    wnck_pager_set_wrap_on_scroll pager' wrapOnScroll'+    touchManagedPtr pager+    return ()++#if ENABLE_OVERLOADING+data PagerSetWrapOnScrollMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsPager a) => O.MethodInfo PagerSetWrapOnScrollMethodInfo a signature where+    overloadedMethod _ = pagerSetWrapOnScroll++#endif++

@@ -0,0 +1,50 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Wnck.Objects.Pager 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++newtype Pager = Pager (ManagedPtr Pager)+instance GObject Pager where+class (GObject o, O.IsDescendantOf Pager o) => IsPager o+instance (GObject o, O.IsDescendantOf Pager o) => IsPager o+instance O.HasParentTypes Pager+#if ENABLE_OVERLOADING+data PagerGetWrapOnScrollMethodInfo+#endif+#if ENABLE_OVERLOADING+data PagerSetDisplayModeMethodInfo+#endif+#if ENABLE_OVERLOADING+data PagerSetNRowsMethodInfo+#endif+#if ENABLE_OVERLOADING+data PagerSetOrientationMethodInfo+#endif+#if ENABLE_OVERLOADING+data PagerSetShadowTypeMethodInfo+#endif+#if ENABLE_OVERLOADING+data PagerSetShowAllMethodInfo+#endif+#if ENABLE_OVERLOADING+data PagerSetWrapOnScrollMethodInfo+#endif

@@ -0,0 +1,2754 @@+++{- |+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.Screen.Screen' 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.Screen+    ( ++-- * Exported types+    Screen(..)                              ,+    IsScreen                                ,+    toScreen                                ,+    noScreen                                ,+++ -- * Methods+-- ** calcWorkspaceLayout #method:calcWorkspaceLayout#++#if ENABLE_OVERLOADING+    ScreenCalcWorkspaceLayoutMethodInfo     ,+#endif+    screenCalcWorkspaceLayout               ,+++-- ** changeWorkspaceCount #method:changeWorkspaceCount#++#if ENABLE_OVERLOADING+    ScreenChangeWorkspaceCountMethodInfo    ,+#endif+    screenChangeWorkspaceCount              ,+++-- ** forceUpdate #method:forceUpdate#++#if ENABLE_OVERLOADING+    ScreenForceUpdateMethodInfo             ,+#endif+    screenForceUpdate                       ,+++-- ** freeWorkspaceLayout #method:freeWorkspaceLayout#++    screenFreeWorkspaceLayout               ,+++-- ** get #method:get#++    screenGet                               ,+++-- ** getActiveWindow #method:getActiveWindow#++#if ENABLE_OVERLOADING+    ScreenGetActiveWindowMethodInfo         ,+#endif+    screenGetActiveWindow                   ,+++-- ** getActiveWorkspace #method:getActiveWorkspace#++#if ENABLE_OVERLOADING+    ScreenGetActiveWorkspaceMethodInfo      ,+#endif+    screenGetActiveWorkspace                ,+++-- ** getBackgroundPixmap #method:getBackgroundPixmap#++#if ENABLE_OVERLOADING+    ScreenGetBackgroundPixmapMethodInfo     ,+#endif+    screenGetBackgroundPixmap               ,+++-- ** getDefault #method:getDefault#++    screenGetDefault                        ,+++-- ** getForRoot #method:getForRoot#++    screenGetForRoot                        ,+++-- ** getHeight #method:getHeight#++#if ENABLE_OVERLOADING+    ScreenGetHeightMethodInfo               ,+#endif+    screenGetHeight                         ,+++-- ** getNumber #method:getNumber#++#if ENABLE_OVERLOADING+    ScreenGetNumberMethodInfo               ,+#endif+    screenGetNumber                         ,+++-- ** getPreviouslyActiveWindow #method:getPreviouslyActiveWindow#++#if ENABLE_OVERLOADING+    ScreenGetPreviouslyActiveWindowMethodInfo,+#endif+    screenGetPreviouslyActiveWindow         ,+++-- ** getShowingDesktop #method:getShowingDesktop#++#if ENABLE_OVERLOADING+    ScreenGetShowingDesktopMethodInfo       ,+#endif+    screenGetShowingDesktop                 ,+++-- ** getWidth #method:getWidth#++#if ENABLE_OVERLOADING+    ScreenGetWidthMethodInfo                ,+#endif+    screenGetWidth                          ,+++-- ** getWindowManagerName #method:getWindowManagerName#++#if ENABLE_OVERLOADING+    ScreenGetWindowManagerNameMethodInfo    ,+#endif+    screenGetWindowManagerName              ,+++-- ** getWindows #method:getWindows#++#if ENABLE_OVERLOADING+    ScreenGetWindowsMethodInfo              ,+#endif+    screenGetWindows                        ,+++-- ** getWindowsStacked #method:getWindowsStacked#++#if ENABLE_OVERLOADING+    ScreenGetWindowsStackedMethodInfo       ,+#endif+    screenGetWindowsStacked                 ,+++-- ** getWorkspace #method:getWorkspace#++#if ENABLE_OVERLOADING+    ScreenGetWorkspaceMethodInfo            ,+#endif+    screenGetWorkspace                      ,+++-- ** getWorkspaceCount #method:getWorkspaceCount#++#if ENABLE_OVERLOADING+    ScreenGetWorkspaceCountMethodInfo       ,+#endif+    screenGetWorkspaceCount                 ,+++-- ** getWorkspaces #method:getWorkspaces#++#if ENABLE_OVERLOADING+    ScreenGetWorkspacesMethodInfo           ,+#endif+    screenGetWorkspaces                     ,+++-- ** moveViewport #method:moveViewport#++#if ENABLE_OVERLOADING+    ScreenMoveViewportMethodInfo            ,+#endif+    screenMoveViewport                      ,+++-- ** netWmSupports #method:netWmSupports#++#if ENABLE_OVERLOADING+    ScreenNetWmSupportsMethodInfo           ,+#endif+    screenNetWmSupports                     ,+++-- ** releaseWorkspaceLayout #method:releaseWorkspaceLayout#++#if ENABLE_OVERLOADING+    ScreenReleaseWorkspaceLayoutMethodInfo  ,+#endif+    screenReleaseWorkspaceLayout            ,+++-- ** toggleShowingDesktop #method:toggleShowingDesktop#++#if ENABLE_OVERLOADING+    ScreenToggleShowingDesktopMethodInfo    ,+#endif+    screenToggleShowingDesktop              ,+++-- ** trySetWorkspaceLayout #method:trySetWorkspaceLayout#++#if ENABLE_OVERLOADING+    ScreenTrySetWorkspaceLayoutMethodInfo   ,+#endif+    screenTrySetWorkspaceLayout             ,+++++ -- * Signals+-- ** activeWindowChanged #signal:activeWindowChanged#++    C_ScreenActiveWindowChangedCallback     ,+    ScreenActiveWindowChangedCallback       ,+#if ENABLE_OVERLOADING+    ScreenActiveWindowChangedSignalInfo     ,+#endif+    afterScreenActiveWindowChanged          ,+    genClosure_ScreenActiveWindowChanged    ,+    mk_ScreenActiveWindowChangedCallback    ,+    noScreenActiveWindowChangedCallback     ,+    onScreenActiveWindowChanged             ,+    wrap_ScreenActiveWindowChangedCallback  ,+++-- ** activeWorkspaceChanged #signal:activeWorkspaceChanged#++    C_ScreenActiveWorkspaceChangedCallback  ,+    ScreenActiveWorkspaceChangedCallback    ,+#if ENABLE_OVERLOADING+    ScreenActiveWorkspaceChangedSignalInfo  ,+#endif+    afterScreenActiveWorkspaceChanged       ,+    genClosure_ScreenActiveWorkspaceChanged ,+    mk_ScreenActiveWorkspaceChangedCallback ,+    noScreenActiveWorkspaceChangedCallback  ,+    onScreenActiveWorkspaceChanged          ,+    wrap_ScreenActiveWorkspaceChangedCallback,+++-- ** applicationClosed #signal:applicationClosed#++    C_ScreenApplicationClosedCallback       ,+    ScreenApplicationClosedCallback         ,+#if ENABLE_OVERLOADING+    ScreenApplicationClosedSignalInfo       ,+#endif+    afterScreenApplicationClosed            ,+    genClosure_ScreenApplicationClosed      ,+    mk_ScreenApplicationClosedCallback      ,+    noScreenApplicationClosedCallback       ,+    onScreenApplicationClosed               ,+    wrap_ScreenApplicationClosedCallback    ,+++-- ** applicationOpened #signal:applicationOpened#++    C_ScreenApplicationOpenedCallback       ,+    ScreenApplicationOpenedCallback         ,+#if ENABLE_OVERLOADING+    ScreenApplicationOpenedSignalInfo       ,+#endif+    afterScreenApplicationOpened            ,+    genClosure_ScreenApplicationOpened      ,+    mk_ScreenApplicationOpenedCallback      ,+    noScreenApplicationOpenedCallback       ,+    onScreenApplicationOpened               ,+    wrap_ScreenApplicationOpenedCallback    ,+++-- ** backgroundChanged #signal:backgroundChanged#++    C_ScreenBackgroundChangedCallback       ,+    ScreenBackgroundChangedCallback         ,+#if ENABLE_OVERLOADING+    ScreenBackgroundChangedSignalInfo       ,+#endif+    afterScreenBackgroundChanged            ,+    genClosure_ScreenBackgroundChanged      ,+    mk_ScreenBackgroundChangedCallback      ,+    noScreenBackgroundChangedCallback       ,+    onScreenBackgroundChanged               ,+    wrap_ScreenBackgroundChangedCallback    ,+++-- ** classGroupClosed #signal:classGroupClosed#++    C_ScreenClassGroupClosedCallback        ,+    ScreenClassGroupClosedCallback          ,+#if ENABLE_OVERLOADING+    ScreenClassGroupClosedSignalInfo        ,+#endif+    afterScreenClassGroupClosed             ,+    genClosure_ScreenClassGroupClosed       ,+    mk_ScreenClassGroupClosedCallback       ,+    noScreenClassGroupClosedCallback        ,+    onScreenClassGroupClosed                ,+    wrap_ScreenClassGroupClosedCallback     ,+++-- ** classGroupOpened #signal:classGroupOpened#++    C_ScreenClassGroupOpenedCallback        ,+    ScreenClassGroupOpenedCallback          ,+#if ENABLE_OVERLOADING+    ScreenClassGroupOpenedSignalInfo        ,+#endif+    afterScreenClassGroupOpened             ,+    genClosure_ScreenClassGroupOpened       ,+    mk_ScreenClassGroupOpenedCallback       ,+    noScreenClassGroupOpenedCallback        ,+    onScreenClassGroupOpened                ,+    wrap_ScreenClassGroupOpenedCallback     ,+++-- ** showingDesktopChanged #signal:showingDesktopChanged#++    C_ScreenShowingDesktopChangedCallback   ,+    ScreenShowingDesktopChangedCallback     ,+#if ENABLE_OVERLOADING+    ScreenShowingDesktopChangedSignalInfo   ,+#endif+    afterScreenShowingDesktopChanged        ,+    genClosure_ScreenShowingDesktopChanged  ,+    mk_ScreenShowingDesktopChangedCallback  ,+    noScreenShowingDesktopChangedCallback   ,+    onScreenShowingDesktopChanged           ,+    wrap_ScreenShowingDesktopChangedCallback,+++-- ** viewportsChanged #signal:viewportsChanged#++    C_ScreenViewportsChangedCallback        ,+    ScreenViewportsChangedCallback          ,+#if ENABLE_OVERLOADING+    ScreenViewportsChangedSignalInfo        ,+#endif+    afterScreenViewportsChanged             ,+    genClosure_ScreenViewportsChanged       ,+    mk_ScreenViewportsChangedCallback       ,+    noScreenViewportsChangedCallback        ,+    onScreenViewportsChanged                ,+    wrap_ScreenViewportsChangedCallback     ,+++-- ** windowClosed #signal:windowClosed#++    C_ScreenWindowClosedCallback            ,+    ScreenWindowClosedCallback              ,+#if ENABLE_OVERLOADING+    ScreenWindowClosedSignalInfo            ,+#endif+    afterScreenWindowClosed                 ,+    genClosure_ScreenWindowClosed           ,+    mk_ScreenWindowClosedCallback           ,+    noScreenWindowClosedCallback            ,+    onScreenWindowClosed                    ,+    wrap_ScreenWindowClosedCallback         ,+++-- ** windowManagerChanged #signal:windowManagerChanged#++    C_ScreenWindowManagerChangedCallback    ,+    ScreenWindowManagerChangedCallback      ,+#if ENABLE_OVERLOADING+    ScreenWindowManagerChangedSignalInfo    ,+#endif+    afterScreenWindowManagerChanged         ,+    genClosure_ScreenWindowManagerChanged   ,+    mk_ScreenWindowManagerChangedCallback   ,+    noScreenWindowManagerChangedCallback    ,+    onScreenWindowManagerChanged            ,+    wrap_ScreenWindowManagerChangedCallback ,+++-- ** windowOpened #signal:windowOpened#++    C_ScreenWindowOpenedCallback            ,+    ScreenWindowOpenedCallback              ,+#if ENABLE_OVERLOADING+    ScreenWindowOpenedSignalInfo            ,+#endif+    afterScreenWindowOpened                 ,+    genClosure_ScreenWindowOpened           ,+    mk_ScreenWindowOpenedCallback           ,+    noScreenWindowOpenedCallback            ,+    onScreenWindowOpened                    ,+    wrap_ScreenWindowOpenedCallback         ,+++-- ** windowStackingChanged #signal:windowStackingChanged#++    C_ScreenWindowStackingChangedCallback   ,+    ScreenWindowStackingChangedCallback     ,+#if ENABLE_OVERLOADING+    ScreenWindowStackingChangedSignalInfo   ,+#endif+    afterScreenWindowStackingChanged        ,+    genClosure_ScreenWindowStackingChanged  ,+    mk_ScreenWindowStackingChangedCallback  ,+    noScreenWindowStackingChangedCallback   ,+    onScreenWindowStackingChanged           ,+    wrap_ScreenWindowStackingChangedCallback,+++-- ** workspaceCreated #signal:workspaceCreated#++    C_ScreenWorkspaceCreatedCallback        ,+    ScreenWorkspaceCreatedCallback          ,+#if ENABLE_OVERLOADING+    ScreenWorkspaceCreatedSignalInfo        ,+#endif+    afterScreenWorkspaceCreated             ,+    genClosure_ScreenWorkspaceCreated       ,+    mk_ScreenWorkspaceCreatedCallback       ,+    noScreenWorkspaceCreatedCallback        ,+    onScreenWorkspaceCreated                ,+    wrap_ScreenWorkspaceCreatedCallback     ,+++-- ** workspaceDestroyed #signal:workspaceDestroyed#++    C_ScreenWorkspaceDestroyedCallback      ,+    ScreenWorkspaceDestroyedCallback        ,+#if ENABLE_OVERLOADING+    ScreenWorkspaceDestroyedSignalInfo      ,+#endif+    afterScreenWorkspaceDestroyed           ,+    genClosure_ScreenWorkspaceDestroyed     ,+    mk_ScreenWorkspaceDestroyedCallback     ,+    noScreenWorkspaceDestroyedCallback      ,+    onScreenWorkspaceDestroyed              ,+    wrap_ScreenWorkspaceDestroyedCallback   ,+++++    ) 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 {-# 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.Window as Wnck.Window+import {-# SOURCE #-} qualified GI.Wnck.Objects.Workspace as Wnck.Workspace+import {-# SOURCE #-} qualified GI.Wnck.Structs.WorkspaceLayout as Wnck.WorkspaceLayout++-- | Memory-managed wrapper type.+newtype Screen = Screen (ManagedPtr Screen)+foreign import ccall "wnck_screen_get_type"+    c_wnck_screen_get_type :: IO GType++instance GObject Screen where+    gobjectType = c_wnck_screen_get_type+    ++-- | Type class for types which can be safely cast to `Screen`, for instance with `toScreen`.+class (GObject o, O.IsDescendantOf Screen o) => IsScreen o+instance (GObject o, O.IsDescendantOf Screen o) => IsScreen o++instance O.HasParentTypes Screen+type instance O.ParentTypes Screen = '[GObject.Object.Object]++-- | Cast to `Screen`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toScreen :: (MonadIO m, IsScreen o) => o -> m Screen+toScreen = liftIO . unsafeCastTo Screen++-- | A convenience alias for `Nothing` :: `Maybe` `Screen`.+noScreen :: Maybe Screen+noScreen = Nothing++#if ENABLE_OVERLOADING+type family ResolveScreenMethod (t :: Symbol) (o :: *) :: * where+    ResolveScreenMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveScreenMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveScreenMethod "calcWorkspaceLayout" o = ScreenCalcWorkspaceLayoutMethodInfo+    ResolveScreenMethod "changeWorkspaceCount" o = ScreenChangeWorkspaceCountMethodInfo+    ResolveScreenMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveScreenMethod "forceUpdate" o = ScreenForceUpdateMethodInfo+    ResolveScreenMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveScreenMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveScreenMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveScreenMethod "moveViewport" o = ScreenMoveViewportMethodInfo+    ResolveScreenMethod "netWmSupports" o = ScreenNetWmSupportsMethodInfo+    ResolveScreenMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveScreenMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveScreenMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveScreenMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveScreenMethod "releaseWorkspaceLayout" o = ScreenReleaseWorkspaceLayoutMethodInfo+    ResolveScreenMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveScreenMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveScreenMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveScreenMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveScreenMethod "toggleShowingDesktop" o = ScreenToggleShowingDesktopMethodInfo+    ResolveScreenMethod "trySetWorkspaceLayout" o = ScreenTrySetWorkspaceLayoutMethodInfo+    ResolveScreenMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveScreenMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveScreenMethod "getActiveWindow" o = ScreenGetActiveWindowMethodInfo+    ResolveScreenMethod "getActiveWorkspace" o = ScreenGetActiveWorkspaceMethodInfo+    ResolveScreenMethod "getBackgroundPixmap" o = ScreenGetBackgroundPixmapMethodInfo+    ResolveScreenMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveScreenMethod "getHeight" o = ScreenGetHeightMethodInfo+    ResolveScreenMethod "getNumber" o = ScreenGetNumberMethodInfo+    ResolveScreenMethod "getPreviouslyActiveWindow" o = ScreenGetPreviouslyActiveWindowMethodInfo+    ResolveScreenMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveScreenMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveScreenMethod "getShowingDesktop" o = ScreenGetShowingDesktopMethodInfo+    ResolveScreenMethod "getWidth" o = ScreenGetWidthMethodInfo+    ResolveScreenMethod "getWindowManagerName" o = ScreenGetWindowManagerNameMethodInfo+    ResolveScreenMethod "getWindows" o = ScreenGetWindowsMethodInfo+    ResolveScreenMethod "getWindowsStacked" o = ScreenGetWindowsStackedMethodInfo+    ResolveScreenMethod "getWorkspace" o = ScreenGetWorkspaceMethodInfo+    ResolveScreenMethod "getWorkspaceCount" o = ScreenGetWorkspaceCountMethodInfo+    ResolveScreenMethod "getWorkspaces" o = ScreenGetWorkspacesMethodInfo+    ResolveScreenMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveScreenMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveScreenMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveScreenMethod t Screen, O.MethodInfo info Screen p) => OL.IsLabel t (Screen -> 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 Screen::active-window-changed+{- |+Emitted when the active window on /@screen@/ has changed.+-}+type ScreenActiveWindowChangedCallback =+    Wnck.Window.Window+    {- ^ /@previouslyActiveWindow@/: the previously active 'GI.Wnck.Objects.Window.Window' before this+change. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenActiveWindowChangedCallback`@.+noScreenActiveWindowChangedCallback :: Maybe ScreenActiveWindowChangedCallback+noScreenActiveWindowChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenActiveWindowChangedCallback =+    Ptr () ->                               -- object+    Ptr Wnck.Window.Window ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenActiveWindowChangedCallback`.+foreign import ccall "wrapper"+    mk_ScreenActiveWindowChangedCallback :: C_ScreenActiveWindowChangedCallback -> IO (FunPtr C_ScreenActiveWindowChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenActiveWindowChanged :: MonadIO m => ScreenActiveWindowChangedCallback -> m (GClosure C_ScreenActiveWindowChangedCallback)+genClosure_ScreenActiveWindowChanged cb = liftIO $ do+    let cb' = wrap_ScreenActiveWindowChangedCallback cb+    mk_ScreenActiveWindowChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenActiveWindowChangedCallback` into a `C_ScreenActiveWindowChangedCallback`.+wrap_ScreenActiveWindowChangedCallback ::+    ScreenActiveWindowChangedCallback ->+    C_ScreenActiveWindowChangedCallback+wrap_ScreenActiveWindowChangedCallback _cb _ previouslyActiveWindow _ = do+    previouslyActiveWindow' <- (newObject Wnck.Window.Window) previouslyActiveWindow+    _cb  previouslyActiveWindow'+++{- |+Connect a signal handler for the “@active-window-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' screen #activeWindowChanged callback+@+-}+onScreenActiveWindowChanged :: (IsScreen a, MonadIO m) => a -> ScreenActiveWindowChangedCallback -> m SignalHandlerId+onScreenActiveWindowChanged obj cb = liftIO $ do+    let cb' = wrap_ScreenActiveWindowChangedCallback cb+    cb'' <- mk_ScreenActiveWindowChangedCallback cb'+    connectSignalFunPtr obj "active-window-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@active-window-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' screen #activeWindowChanged callback+@+-}+afterScreenActiveWindowChanged :: (IsScreen a, MonadIO m) => a -> ScreenActiveWindowChangedCallback -> m SignalHandlerId+afterScreenActiveWindowChanged obj cb = liftIO $ do+    let cb' = wrap_ScreenActiveWindowChangedCallback cb+    cb'' <- mk_ScreenActiveWindowChangedCallback cb'+    connectSignalFunPtr obj "active-window-changed" cb'' SignalConnectAfter+++-- signal Screen::active-workspace-changed+{- |+Emitted when the active workspace on /@screen@/ has changed.+-}+type ScreenActiveWorkspaceChangedCallback =+    Wnck.Workspace.Workspace+    {- ^ /@previouslyActiveSpace@/: the previously active 'GI.Wnck.Objects.Workspace.Workspace' before this+change. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenActiveWorkspaceChangedCallback`@.+noScreenActiveWorkspaceChangedCallback :: Maybe ScreenActiveWorkspaceChangedCallback+noScreenActiveWorkspaceChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenActiveWorkspaceChangedCallback =+    Ptr () ->                               -- object+    Ptr Wnck.Workspace.Workspace ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenActiveWorkspaceChangedCallback`.+foreign import ccall "wrapper"+    mk_ScreenActiveWorkspaceChangedCallback :: C_ScreenActiveWorkspaceChangedCallback -> IO (FunPtr C_ScreenActiveWorkspaceChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenActiveWorkspaceChanged :: MonadIO m => ScreenActiveWorkspaceChangedCallback -> m (GClosure C_ScreenActiveWorkspaceChangedCallback)+genClosure_ScreenActiveWorkspaceChanged cb = liftIO $ do+    let cb' = wrap_ScreenActiveWorkspaceChangedCallback cb+    mk_ScreenActiveWorkspaceChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenActiveWorkspaceChangedCallback` into a `C_ScreenActiveWorkspaceChangedCallback`.+wrap_ScreenActiveWorkspaceChangedCallback ::+    ScreenActiveWorkspaceChangedCallback ->+    C_ScreenActiveWorkspaceChangedCallback+wrap_ScreenActiveWorkspaceChangedCallback _cb _ previouslyActiveSpace _ = do+    previouslyActiveSpace' <- (newObject Wnck.Workspace.Workspace) previouslyActiveSpace+    _cb  previouslyActiveSpace'+++{- |+Connect a signal handler for the “@active-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' screen #activeWorkspaceChanged callback+@+-}+onScreenActiveWorkspaceChanged :: (IsScreen a, MonadIO m) => a -> ScreenActiveWorkspaceChangedCallback -> m SignalHandlerId+onScreenActiveWorkspaceChanged obj cb = liftIO $ do+    let cb' = wrap_ScreenActiveWorkspaceChangedCallback cb+    cb'' <- mk_ScreenActiveWorkspaceChangedCallback cb'+    connectSignalFunPtr obj "active-workspace-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@active-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' screen #activeWorkspaceChanged callback+@+-}+afterScreenActiveWorkspaceChanged :: (IsScreen a, MonadIO m) => a -> ScreenActiveWorkspaceChangedCallback -> m SignalHandlerId+afterScreenActiveWorkspaceChanged obj cb = liftIO $ do+    let cb' = wrap_ScreenActiveWorkspaceChangedCallback cb+    cb'' <- mk_ScreenActiveWorkspaceChangedCallback cb'+    connectSignalFunPtr obj "active-workspace-changed" cb'' SignalConnectAfter+++-- signal Screen::application-closed+{- |+Emitted when a 'GI.Wnck.Objects.Application.Application' is closed on /@screen@/.+-}+type ScreenApplicationClosedCallback =+    Wnck.Application.Application+    {- ^ /@app@/: the closed 'GI.Wnck.Objects.Application.Application'. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenApplicationClosedCallback`@.+noScreenApplicationClosedCallback :: Maybe ScreenApplicationClosedCallback+noScreenApplicationClosedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenApplicationClosedCallback =+    Ptr () ->                               -- object+    Ptr Wnck.Application.Application ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenApplicationClosedCallback`.+foreign import ccall "wrapper"+    mk_ScreenApplicationClosedCallback :: C_ScreenApplicationClosedCallback -> IO (FunPtr C_ScreenApplicationClosedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenApplicationClosed :: MonadIO m => ScreenApplicationClosedCallback -> m (GClosure C_ScreenApplicationClosedCallback)+genClosure_ScreenApplicationClosed cb = liftIO $ do+    let cb' = wrap_ScreenApplicationClosedCallback cb+    mk_ScreenApplicationClosedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenApplicationClosedCallback` into a `C_ScreenApplicationClosedCallback`.+wrap_ScreenApplicationClosedCallback ::+    ScreenApplicationClosedCallback ->+    C_ScreenApplicationClosedCallback+wrap_ScreenApplicationClosedCallback _cb _ app _ = do+    app' <- (newObject Wnck.Application.Application) app+    _cb  app'+++{- |+Connect a signal handler for the “@application-closed@” 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' screen #applicationClosed callback+@+-}+onScreenApplicationClosed :: (IsScreen a, MonadIO m) => a -> ScreenApplicationClosedCallback -> m SignalHandlerId+onScreenApplicationClosed obj cb = liftIO $ do+    let cb' = wrap_ScreenApplicationClosedCallback cb+    cb'' <- mk_ScreenApplicationClosedCallback cb'+    connectSignalFunPtr obj "application-closed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@application-closed@” 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' screen #applicationClosed callback+@+-}+afterScreenApplicationClosed :: (IsScreen a, MonadIO m) => a -> ScreenApplicationClosedCallback -> m SignalHandlerId+afterScreenApplicationClosed obj cb = liftIO $ do+    let cb' = wrap_ScreenApplicationClosedCallback cb+    cb'' <- mk_ScreenApplicationClosedCallback cb'+    connectSignalFunPtr obj "application-closed" cb'' SignalConnectAfter+++-- signal Screen::application-opened+{- |+Emitted when a new 'GI.Wnck.Objects.Application.Application' is opened on /@screen@/.+-}+type ScreenApplicationOpenedCallback =+    Wnck.Application.Application+    {- ^ /@app@/: the opened 'GI.Wnck.Objects.Application.Application'. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenApplicationOpenedCallback`@.+noScreenApplicationOpenedCallback :: Maybe ScreenApplicationOpenedCallback+noScreenApplicationOpenedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenApplicationOpenedCallback =+    Ptr () ->                               -- object+    Ptr Wnck.Application.Application ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenApplicationOpenedCallback`.+foreign import ccall "wrapper"+    mk_ScreenApplicationOpenedCallback :: C_ScreenApplicationOpenedCallback -> IO (FunPtr C_ScreenApplicationOpenedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenApplicationOpened :: MonadIO m => ScreenApplicationOpenedCallback -> m (GClosure C_ScreenApplicationOpenedCallback)+genClosure_ScreenApplicationOpened cb = liftIO $ do+    let cb' = wrap_ScreenApplicationOpenedCallback cb+    mk_ScreenApplicationOpenedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenApplicationOpenedCallback` into a `C_ScreenApplicationOpenedCallback`.+wrap_ScreenApplicationOpenedCallback ::+    ScreenApplicationOpenedCallback ->+    C_ScreenApplicationOpenedCallback+wrap_ScreenApplicationOpenedCallback _cb _ app _ = do+    app' <- (newObject Wnck.Application.Application) app+    _cb  app'+++{- |+Connect a signal handler for the “@application-opened@” 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' screen #applicationOpened callback+@+-}+onScreenApplicationOpened :: (IsScreen a, MonadIO m) => a -> ScreenApplicationOpenedCallback -> m SignalHandlerId+onScreenApplicationOpened obj cb = liftIO $ do+    let cb' = wrap_ScreenApplicationOpenedCallback cb+    cb'' <- mk_ScreenApplicationOpenedCallback cb'+    connectSignalFunPtr obj "application-opened" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@application-opened@” 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' screen #applicationOpened callback+@+-}+afterScreenApplicationOpened :: (IsScreen a, MonadIO m) => a -> ScreenApplicationOpenedCallback -> m SignalHandlerId+afterScreenApplicationOpened obj cb = liftIO $ do+    let cb' = wrap_ScreenApplicationOpenedCallback cb+    cb'' <- mk_ScreenApplicationOpenedCallback cb'+    connectSignalFunPtr obj "application-opened" cb'' SignalConnectAfter+++-- signal Screen::background-changed+{- |+Emitted when the background on the root window of /@screen@/ has changed.+-}+type ScreenBackgroundChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenBackgroundChangedCallback`@.+noScreenBackgroundChangedCallback :: Maybe ScreenBackgroundChangedCallback+noScreenBackgroundChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenBackgroundChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenBackgroundChangedCallback`.+foreign import ccall "wrapper"+    mk_ScreenBackgroundChangedCallback :: C_ScreenBackgroundChangedCallback -> IO (FunPtr C_ScreenBackgroundChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenBackgroundChanged :: MonadIO m => ScreenBackgroundChangedCallback -> m (GClosure C_ScreenBackgroundChangedCallback)+genClosure_ScreenBackgroundChanged cb = liftIO $ do+    let cb' = wrap_ScreenBackgroundChangedCallback cb+    mk_ScreenBackgroundChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenBackgroundChangedCallback` into a `C_ScreenBackgroundChangedCallback`.+wrap_ScreenBackgroundChangedCallback ::+    ScreenBackgroundChangedCallback ->+    C_ScreenBackgroundChangedCallback+wrap_ScreenBackgroundChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@background-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' screen #backgroundChanged callback+@+-}+onScreenBackgroundChanged :: (IsScreen a, MonadIO m) => a -> ScreenBackgroundChangedCallback -> m SignalHandlerId+onScreenBackgroundChanged obj cb = liftIO $ do+    let cb' = wrap_ScreenBackgroundChangedCallback cb+    cb'' <- mk_ScreenBackgroundChangedCallback cb'+    connectSignalFunPtr obj "background-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@background-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' screen #backgroundChanged callback+@+-}+afterScreenBackgroundChanged :: (IsScreen a, MonadIO m) => a -> ScreenBackgroundChangedCallback -> m SignalHandlerId+afterScreenBackgroundChanged obj cb = liftIO $ do+    let cb' = wrap_ScreenBackgroundChangedCallback cb+    cb'' <- mk_ScreenBackgroundChangedCallback cb'+    connectSignalFunPtr obj "background-changed" cb'' SignalConnectAfter+++-- signal Screen::class-group-closed+{- |+Emitted when a 'GI.Wnck.Objects.ClassGroup.ClassGroup' is closed on /@screen@/.++/Since: 2.20/+-}+type ScreenClassGroupClosedCallback =+    Wnck.ClassGroup.ClassGroup+    {- ^ /@classGroup@/: the closed 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenClassGroupClosedCallback`@.+noScreenClassGroupClosedCallback :: Maybe ScreenClassGroupClosedCallback+noScreenClassGroupClosedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenClassGroupClosedCallback =+    Ptr () ->                               -- object+    Ptr Wnck.ClassGroup.ClassGroup ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenClassGroupClosedCallback`.+foreign import ccall "wrapper"+    mk_ScreenClassGroupClosedCallback :: C_ScreenClassGroupClosedCallback -> IO (FunPtr C_ScreenClassGroupClosedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenClassGroupClosed :: MonadIO m => ScreenClassGroupClosedCallback -> m (GClosure C_ScreenClassGroupClosedCallback)+genClosure_ScreenClassGroupClosed cb = liftIO $ do+    let cb' = wrap_ScreenClassGroupClosedCallback cb+    mk_ScreenClassGroupClosedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenClassGroupClosedCallback` into a `C_ScreenClassGroupClosedCallback`.+wrap_ScreenClassGroupClosedCallback ::+    ScreenClassGroupClosedCallback ->+    C_ScreenClassGroupClosedCallback+wrap_ScreenClassGroupClosedCallback _cb _ classGroup _ = do+    classGroup' <- (newObject Wnck.ClassGroup.ClassGroup) classGroup+    _cb  classGroup'+++{- |+Connect a signal handler for the “@class-group-closed@” 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' screen #classGroupClosed callback+@+-}+onScreenClassGroupClosed :: (IsScreen a, MonadIO m) => a -> ScreenClassGroupClosedCallback -> m SignalHandlerId+onScreenClassGroupClosed obj cb = liftIO $ do+    let cb' = wrap_ScreenClassGroupClosedCallback cb+    cb'' <- mk_ScreenClassGroupClosedCallback cb'+    connectSignalFunPtr obj "class-group-closed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@class-group-closed@” 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' screen #classGroupClosed callback+@+-}+afterScreenClassGroupClosed :: (IsScreen a, MonadIO m) => a -> ScreenClassGroupClosedCallback -> m SignalHandlerId+afterScreenClassGroupClosed obj cb = liftIO $ do+    let cb' = wrap_ScreenClassGroupClosedCallback cb+    cb'' <- mk_ScreenClassGroupClosedCallback cb'+    connectSignalFunPtr obj "class-group-closed" cb'' SignalConnectAfter+++-- signal Screen::class-group-opened+{- |+Emitted when a new 'GI.Wnck.Objects.ClassGroup.ClassGroup' is opened on /@screen@/.++/Since: 2.20/+-}+type ScreenClassGroupOpenedCallback =+    Wnck.ClassGroup.ClassGroup+    {- ^ /@classGroup@/: the opened 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenClassGroupOpenedCallback`@.+noScreenClassGroupOpenedCallback :: Maybe ScreenClassGroupOpenedCallback+noScreenClassGroupOpenedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenClassGroupOpenedCallback =+    Ptr () ->                               -- object+    Ptr Wnck.ClassGroup.ClassGroup ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenClassGroupOpenedCallback`.+foreign import ccall "wrapper"+    mk_ScreenClassGroupOpenedCallback :: C_ScreenClassGroupOpenedCallback -> IO (FunPtr C_ScreenClassGroupOpenedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenClassGroupOpened :: MonadIO m => ScreenClassGroupOpenedCallback -> m (GClosure C_ScreenClassGroupOpenedCallback)+genClosure_ScreenClassGroupOpened cb = liftIO $ do+    let cb' = wrap_ScreenClassGroupOpenedCallback cb+    mk_ScreenClassGroupOpenedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenClassGroupOpenedCallback` into a `C_ScreenClassGroupOpenedCallback`.+wrap_ScreenClassGroupOpenedCallback ::+    ScreenClassGroupOpenedCallback ->+    C_ScreenClassGroupOpenedCallback+wrap_ScreenClassGroupOpenedCallback _cb _ classGroup _ = do+    classGroup' <- (newObject Wnck.ClassGroup.ClassGroup) classGroup+    _cb  classGroup'+++{- |+Connect a signal handler for the “@class-group-opened@” 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' screen #classGroupOpened callback+@+-}+onScreenClassGroupOpened :: (IsScreen a, MonadIO m) => a -> ScreenClassGroupOpenedCallback -> m SignalHandlerId+onScreenClassGroupOpened obj cb = liftIO $ do+    let cb' = wrap_ScreenClassGroupOpenedCallback cb+    cb'' <- mk_ScreenClassGroupOpenedCallback cb'+    connectSignalFunPtr obj "class-group-opened" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@class-group-opened@” 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' screen #classGroupOpened callback+@+-}+afterScreenClassGroupOpened :: (IsScreen a, MonadIO m) => a -> ScreenClassGroupOpenedCallback -> m SignalHandlerId+afterScreenClassGroupOpened obj cb = liftIO $ do+    let cb' = wrap_ScreenClassGroupOpenedCallback cb+    cb'' <- mk_ScreenClassGroupOpenedCallback cb'+    connectSignalFunPtr obj "class-group-opened" cb'' SignalConnectAfter+++-- signal Screen::showing-desktop-changed+{- |+Emitted when \"showing the desktop\" mode of /@screen@/ is toggled.++/Since: 2.20/+-}+type ScreenShowingDesktopChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenShowingDesktopChangedCallback`@.+noScreenShowingDesktopChangedCallback :: Maybe ScreenShowingDesktopChangedCallback+noScreenShowingDesktopChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenShowingDesktopChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenShowingDesktopChangedCallback`.+foreign import ccall "wrapper"+    mk_ScreenShowingDesktopChangedCallback :: C_ScreenShowingDesktopChangedCallback -> IO (FunPtr C_ScreenShowingDesktopChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenShowingDesktopChanged :: MonadIO m => ScreenShowingDesktopChangedCallback -> m (GClosure C_ScreenShowingDesktopChangedCallback)+genClosure_ScreenShowingDesktopChanged cb = liftIO $ do+    let cb' = wrap_ScreenShowingDesktopChangedCallback cb+    mk_ScreenShowingDesktopChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenShowingDesktopChangedCallback` into a `C_ScreenShowingDesktopChangedCallback`.+wrap_ScreenShowingDesktopChangedCallback ::+    ScreenShowingDesktopChangedCallback ->+    C_ScreenShowingDesktopChangedCallback+wrap_ScreenShowingDesktopChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@showing-desktop-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' screen #showingDesktopChanged callback+@+-}+onScreenShowingDesktopChanged :: (IsScreen a, MonadIO m) => a -> ScreenShowingDesktopChangedCallback -> m SignalHandlerId+onScreenShowingDesktopChanged obj cb = liftIO $ do+    let cb' = wrap_ScreenShowingDesktopChangedCallback cb+    cb'' <- mk_ScreenShowingDesktopChangedCallback cb'+    connectSignalFunPtr obj "showing-desktop-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@showing-desktop-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' screen #showingDesktopChanged callback+@+-}+afterScreenShowingDesktopChanged :: (IsScreen a, MonadIO m) => a -> ScreenShowingDesktopChangedCallback -> m SignalHandlerId+afterScreenShowingDesktopChanged obj cb = liftIO $ do+    let cb' = wrap_ScreenShowingDesktopChangedCallback cb+    cb'' <- mk_ScreenShowingDesktopChangedCallback cb'+    connectSignalFunPtr obj "showing-desktop-changed" cb'' SignalConnectAfter+++-- signal Screen::viewports-changed+{- |+Emitted when a viewport position has changed in a 'GI.Wnck.Objects.Workspace.Workspace' of+/@screen@/ or when a 'GI.Wnck.Objects.Workspace.Workspace' of /@screen@/ gets or loses its viewport.++/Since: 2.20/+-}+type ScreenViewportsChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenViewportsChangedCallback`@.+noScreenViewportsChangedCallback :: Maybe ScreenViewportsChangedCallback+noScreenViewportsChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenViewportsChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenViewportsChangedCallback`.+foreign import ccall "wrapper"+    mk_ScreenViewportsChangedCallback :: C_ScreenViewportsChangedCallback -> IO (FunPtr C_ScreenViewportsChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenViewportsChanged :: MonadIO m => ScreenViewportsChangedCallback -> m (GClosure C_ScreenViewportsChangedCallback)+genClosure_ScreenViewportsChanged cb = liftIO $ do+    let cb' = wrap_ScreenViewportsChangedCallback cb+    mk_ScreenViewportsChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenViewportsChangedCallback` into a `C_ScreenViewportsChangedCallback`.+wrap_ScreenViewportsChangedCallback ::+    ScreenViewportsChangedCallback ->+    C_ScreenViewportsChangedCallback+wrap_ScreenViewportsChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@viewports-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' screen #viewportsChanged callback+@+-}+onScreenViewportsChanged :: (IsScreen a, MonadIO m) => a -> ScreenViewportsChangedCallback -> m SignalHandlerId+onScreenViewportsChanged obj cb = liftIO $ do+    let cb' = wrap_ScreenViewportsChangedCallback cb+    cb'' <- mk_ScreenViewportsChangedCallback cb'+    connectSignalFunPtr obj "viewports-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@viewports-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' screen #viewportsChanged callback+@+-}+afterScreenViewportsChanged :: (IsScreen a, MonadIO m) => a -> ScreenViewportsChangedCallback -> m SignalHandlerId+afterScreenViewportsChanged obj cb = liftIO $ do+    let cb' = wrap_ScreenViewportsChangedCallback cb+    cb'' <- mk_ScreenViewportsChangedCallback cb'+    connectSignalFunPtr obj "viewports-changed" cb'' SignalConnectAfter+++-- signal Screen::window-closed+{- |+Emitted when a 'GI.Wnck.Objects.Window.Window' is closed on /@screen@/.+-}+type ScreenWindowClosedCallback =+    Wnck.Window.Window+    {- ^ /@window@/: the closed 'GI.Wnck.Objects.Window.Window'. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenWindowClosedCallback`@.+noScreenWindowClosedCallback :: Maybe ScreenWindowClosedCallback+noScreenWindowClosedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenWindowClosedCallback =+    Ptr () ->                               -- object+    Ptr Wnck.Window.Window ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenWindowClosedCallback`.+foreign import ccall "wrapper"+    mk_ScreenWindowClosedCallback :: C_ScreenWindowClosedCallback -> IO (FunPtr C_ScreenWindowClosedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenWindowClosed :: MonadIO m => ScreenWindowClosedCallback -> m (GClosure C_ScreenWindowClosedCallback)+genClosure_ScreenWindowClosed cb = liftIO $ do+    let cb' = wrap_ScreenWindowClosedCallback cb+    mk_ScreenWindowClosedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenWindowClosedCallback` into a `C_ScreenWindowClosedCallback`.+wrap_ScreenWindowClosedCallback ::+    ScreenWindowClosedCallback ->+    C_ScreenWindowClosedCallback+wrap_ScreenWindowClosedCallback _cb _ window _ = do+    window' <- (newObject Wnck.Window.Window) window+    _cb  window'+++{- |+Connect a signal handler for the “@window-closed@” 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' screen #windowClosed callback+@+-}+onScreenWindowClosed :: (IsScreen a, MonadIO m) => a -> ScreenWindowClosedCallback -> m SignalHandlerId+onScreenWindowClosed obj cb = liftIO $ do+    let cb' = wrap_ScreenWindowClosedCallback cb+    cb'' <- mk_ScreenWindowClosedCallback cb'+    connectSignalFunPtr obj "window-closed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@window-closed@” 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' screen #windowClosed callback+@+-}+afterScreenWindowClosed :: (IsScreen a, MonadIO m) => a -> ScreenWindowClosedCallback -> m SignalHandlerId+afterScreenWindowClosed obj cb = liftIO $ do+    let cb' = wrap_ScreenWindowClosedCallback cb+    cb'' <- mk_ScreenWindowClosedCallback cb'+    connectSignalFunPtr obj "window-closed" cb'' SignalConnectAfter+++-- signal Screen::window-manager-changed+{- |+Emitted when the window manager on /@screen@/ has changed.++/Since: 2.20/+-}+type ScreenWindowManagerChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenWindowManagerChangedCallback`@.+noScreenWindowManagerChangedCallback :: Maybe ScreenWindowManagerChangedCallback+noScreenWindowManagerChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenWindowManagerChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenWindowManagerChangedCallback`.+foreign import ccall "wrapper"+    mk_ScreenWindowManagerChangedCallback :: C_ScreenWindowManagerChangedCallback -> IO (FunPtr C_ScreenWindowManagerChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenWindowManagerChanged :: MonadIO m => ScreenWindowManagerChangedCallback -> m (GClosure C_ScreenWindowManagerChangedCallback)+genClosure_ScreenWindowManagerChanged cb = liftIO $ do+    let cb' = wrap_ScreenWindowManagerChangedCallback cb+    mk_ScreenWindowManagerChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenWindowManagerChangedCallback` into a `C_ScreenWindowManagerChangedCallback`.+wrap_ScreenWindowManagerChangedCallback ::+    ScreenWindowManagerChangedCallback ->+    C_ScreenWindowManagerChangedCallback+wrap_ScreenWindowManagerChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@window-manager-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' screen #windowManagerChanged callback+@+-}+onScreenWindowManagerChanged :: (IsScreen a, MonadIO m) => a -> ScreenWindowManagerChangedCallback -> m SignalHandlerId+onScreenWindowManagerChanged obj cb = liftIO $ do+    let cb' = wrap_ScreenWindowManagerChangedCallback cb+    cb'' <- mk_ScreenWindowManagerChangedCallback cb'+    connectSignalFunPtr obj "window-manager-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@window-manager-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' screen #windowManagerChanged callback+@+-}+afterScreenWindowManagerChanged :: (IsScreen a, MonadIO m) => a -> ScreenWindowManagerChangedCallback -> m SignalHandlerId+afterScreenWindowManagerChanged obj cb = liftIO $ do+    let cb' = wrap_ScreenWindowManagerChangedCallback cb+    cb'' <- mk_ScreenWindowManagerChangedCallback cb'+    connectSignalFunPtr obj "window-manager-changed" cb'' SignalConnectAfter+++-- signal Screen::window-opened+{- |+Emitted when a new 'GI.Wnck.Objects.Window.Window' is opened on /@screen@/.+-}+type ScreenWindowOpenedCallback =+    Wnck.Window.Window+    {- ^ /@window@/: the opened 'GI.Wnck.Objects.Window.Window'. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenWindowOpenedCallback`@.+noScreenWindowOpenedCallback :: Maybe ScreenWindowOpenedCallback+noScreenWindowOpenedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenWindowOpenedCallback =+    Ptr () ->                               -- object+    Ptr Wnck.Window.Window ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenWindowOpenedCallback`.+foreign import ccall "wrapper"+    mk_ScreenWindowOpenedCallback :: C_ScreenWindowOpenedCallback -> IO (FunPtr C_ScreenWindowOpenedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenWindowOpened :: MonadIO m => ScreenWindowOpenedCallback -> m (GClosure C_ScreenWindowOpenedCallback)+genClosure_ScreenWindowOpened cb = liftIO $ do+    let cb' = wrap_ScreenWindowOpenedCallback cb+    mk_ScreenWindowOpenedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenWindowOpenedCallback` into a `C_ScreenWindowOpenedCallback`.+wrap_ScreenWindowOpenedCallback ::+    ScreenWindowOpenedCallback ->+    C_ScreenWindowOpenedCallback+wrap_ScreenWindowOpenedCallback _cb _ window _ = do+    window' <- (newObject Wnck.Window.Window) window+    _cb  window'+++{- |+Connect a signal handler for the “@window-opened@” 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' screen #windowOpened callback+@+-}+onScreenWindowOpened :: (IsScreen a, MonadIO m) => a -> ScreenWindowOpenedCallback -> m SignalHandlerId+onScreenWindowOpened obj cb = liftIO $ do+    let cb' = wrap_ScreenWindowOpenedCallback cb+    cb'' <- mk_ScreenWindowOpenedCallback cb'+    connectSignalFunPtr obj "window-opened" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@window-opened@” 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' screen #windowOpened callback+@+-}+afterScreenWindowOpened :: (IsScreen a, MonadIO m) => a -> ScreenWindowOpenedCallback -> m SignalHandlerId+afterScreenWindowOpened obj cb = liftIO $ do+    let cb' = wrap_ScreenWindowOpenedCallback cb+    cb'' <- mk_ScreenWindowOpenedCallback cb'+    connectSignalFunPtr obj "window-opened" cb'' SignalConnectAfter+++-- signal Screen::window-stacking-changed+{- |+Emitted when the stacking order of 'GI.Wnck.Objects.Window.Window' on /@screen@/ has changed.+-}+type ScreenWindowStackingChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenWindowStackingChangedCallback`@.+noScreenWindowStackingChangedCallback :: Maybe ScreenWindowStackingChangedCallback+noScreenWindowStackingChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenWindowStackingChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenWindowStackingChangedCallback`.+foreign import ccall "wrapper"+    mk_ScreenWindowStackingChangedCallback :: C_ScreenWindowStackingChangedCallback -> IO (FunPtr C_ScreenWindowStackingChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenWindowStackingChanged :: MonadIO m => ScreenWindowStackingChangedCallback -> m (GClosure C_ScreenWindowStackingChangedCallback)+genClosure_ScreenWindowStackingChanged cb = liftIO $ do+    let cb' = wrap_ScreenWindowStackingChangedCallback cb+    mk_ScreenWindowStackingChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenWindowStackingChangedCallback` into a `C_ScreenWindowStackingChangedCallback`.+wrap_ScreenWindowStackingChangedCallback ::+    ScreenWindowStackingChangedCallback ->+    C_ScreenWindowStackingChangedCallback+wrap_ScreenWindowStackingChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@window-stacking-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' screen #windowStackingChanged callback+@+-}+onScreenWindowStackingChanged :: (IsScreen a, MonadIO m) => a -> ScreenWindowStackingChangedCallback -> m SignalHandlerId+onScreenWindowStackingChanged obj cb = liftIO $ do+    let cb' = wrap_ScreenWindowStackingChangedCallback cb+    cb'' <- mk_ScreenWindowStackingChangedCallback cb'+    connectSignalFunPtr obj "window-stacking-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@window-stacking-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' screen #windowStackingChanged callback+@+-}+afterScreenWindowStackingChanged :: (IsScreen a, MonadIO m) => a -> ScreenWindowStackingChangedCallback -> m SignalHandlerId+afterScreenWindowStackingChanged obj cb = liftIO $ do+    let cb' = wrap_ScreenWindowStackingChangedCallback cb+    cb'' <- mk_ScreenWindowStackingChangedCallback cb'+    connectSignalFunPtr obj "window-stacking-changed" cb'' SignalConnectAfter+++-- signal Screen::workspace-created+{- |+Emitted when a 'GI.Wnck.Objects.Workspace.Workspace' is created on /@screen@/.+-}+type ScreenWorkspaceCreatedCallback =+    Wnck.Workspace.Workspace+    {- ^ /@space@/: the workspace that has been created. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenWorkspaceCreatedCallback`@.+noScreenWorkspaceCreatedCallback :: Maybe ScreenWorkspaceCreatedCallback+noScreenWorkspaceCreatedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenWorkspaceCreatedCallback =+    Ptr () ->                               -- object+    Ptr Wnck.Workspace.Workspace ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenWorkspaceCreatedCallback`.+foreign import ccall "wrapper"+    mk_ScreenWorkspaceCreatedCallback :: C_ScreenWorkspaceCreatedCallback -> IO (FunPtr C_ScreenWorkspaceCreatedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenWorkspaceCreated :: MonadIO m => ScreenWorkspaceCreatedCallback -> m (GClosure C_ScreenWorkspaceCreatedCallback)+genClosure_ScreenWorkspaceCreated cb = liftIO $ do+    let cb' = wrap_ScreenWorkspaceCreatedCallback cb+    mk_ScreenWorkspaceCreatedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenWorkspaceCreatedCallback` into a `C_ScreenWorkspaceCreatedCallback`.+wrap_ScreenWorkspaceCreatedCallback ::+    ScreenWorkspaceCreatedCallback ->+    C_ScreenWorkspaceCreatedCallback+wrap_ScreenWorkspaceCreatedCallback _cb _ space _ = do+    space' <- (newObject Wnck.Workspace.Workspace) space+    _cb  space'+++{- |+Connect a signal handler for the “@workspace-created@” 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' screen #workspaceCreated callback+@+-}+onScreenWorkspaceCreated :: (IsScreen a, MonadIO m) => a -> ScreenWorkspaceCreatedCallback -> m SignalHandlerId+onScreenWorkspaceCreated obj cb = liftIO $ do+    let cb' = wrap_ScreenWorkspaceCreatedCallback cb+    cb'' <- mk_ScreenWorkspaceCreatedCallback cb'+    connectSignalFunPtr obj "workspace-created" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@workspace-created@” 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' screen #workspaceCreated callback+@+-}+afterScreenWorkspaceCreated :: (IsScreen a, MonadIO m) => a -> ScreenWorkspaceCreatedCallback -> m SignalHandlerId+afterScreenWorkspaceCreated obj cb = liftIO $ do+    let cb' = wrap_ScreenWorkspaceCreatedCallback cb+    cb'' <- mk_ScreenWorkspaceCreatedCallback cb'+    connectSignalFunPtr obj "workspace-created" cb'' SignalConnectAfter+++-- signal Screen::workspace-destroyed+{- |+Emitted when a 'GI.Wnck.Objects.Workspace.Workspace' is destroyed on /@screen@/.+-}+type ScreenWorkspaceDestroyedCallback =+    Wnck.Workspace.Workspace+    {- ^ /@space@/: the workspace that has been destroyed. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenWorkspaceDestroyedCallback`@.+noScreenWorkspaceDestroyedCallback :: Maybe ScreenWorkspaceDestroyedCallback+noScreenWorkspaceDestroyedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ScreenWorkspaceDestroyedCallback =+    Ptr () ->                               -- object+    Ptr Wnck.Workspace.Workspace ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ScreenWorkspaceDestroyedCallback`.+foreign import ccall "wrapper"+    mk_ScreenWorkspaceDestroyedCallback :: C_ScreenWorkspaceDestroyedCallback -> IO (FunPtr C_ScreenWorkspaceDestroyedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ScreenWorkspaceDestroyed :: MonadIO m => ScreenWorkspaceDestroyedCallback -> m (GClosure C_ScreenWorkspaceDestroyedCallback)+genClosure_ScreenWorkspaceDestroyed cb = liftIO $ do+    let cb' = wrap_ScreenWorkspaceDestroyedCallback cb+    mk_ScreenWorkspaceDestroyedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ScreenWorkspaceDestroyedCallback` into a `C_ScreenWorkspaceDestroyedCallback`.+wrap_ScreenWorkspaceDestroyedCallback ::+    ScreenWorkspaceDestroyedCallback ->+    C_ScreenWorkspaceDestroyedCallback+wrap_ScreenWorkspaceDestroyedCallback _cb _ space _ = do+    space' <- (newObject Wnck.Workspace.Workspace) space+    _cb  space'+++{- |+Connect a signal handler for the “@workspace-destroyed@” 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' screen #workspaceDestroyed callback+@+-}+onScreenWorkspaceDestroyed :: (IsScreen a, MonadIO m) => a -> ScreenWorkspaceDestroyedCallback -> m SignalHandlerId+onScreenWorkspaceDestroyed obj cb = liftIO $ do+    let cb' = wrap_ScreenWorkspaceDestroyedCallback cb+    cb'' <- mk_ScreenWorkspaceDestroyedCallback cb'+    connectSignalFunPtr obj "workspace-destroyed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@workspace-destroyed@” 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' screen #workspaceDestroyed callback+@+-}+afterScreenWorkspaceDestroyed :: (IsScreen a, MonadIO m) => a -> ScreenWorkspaceDestroyedCallback -> m SignalHandlerId+afterScreenWorkspaceDestroyed obj cb = liftIO $ do+    let cb' = wrap_ScreenWorkspaceDestroyedCallback cb+    cb'' <- mk_ScreenWorkspaceDestroyedCallback cb'+    connectSignalFunPtr obj "workspace-destroyed" cb'' SignalConnectAfter+++#if ENABLE_OVERLOADING+instance O.HasAttributeList Screen+type instance O.AttributeList Screen = ScreenAttributeList+type ScreenAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+data ScreenActiveWindowChangedSignalInfo+instance SignalInfo ScreenActiveWindowChangedSignalInfo where+    type HaskellCallbackType ScreenActiveWindowChangedSignalInfo = ScreenActiveWindowChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenActiveWindowChangedCallback cb+        cb'' <- mk_ScreenActiveWindowChangedCallback cb'+        connectSignalFunPtr obj "active-window-changed" cb'' connectMode++data ScreenActiveWorkspaceChangedSignalInfo+instance SignalInfo ScreenActiveWorkspaceChangedSignalInfo where+    type HaskellCallbackType ScreenActiveWorkspaceChangedSignalInfo = ScreenActiveWorkspaceChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenActiveWorkspaceChangedCallback cb+        cb'' <- mk_ScreenActiveWorkspaceChangedCallback cb'+        connectSignalFunPtr obj "active-workspace-changed" cb'' connectMode++data ScreenApplicationClosedSignalInfo+instance SignalInfo ScreenApplicationClosedSignalInfo where+    type HaskellCallbackType ScreenApplicationClosedSignalInfo = ScreenApplicationClosedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenApplicationClosedCallback cb+        cb'' <- mk_ScreenApplicationClosedCallback cb'+        connectSignalFunPtr obj "application-closed" cb'' connectMode++data ScreenApplicationOpenedSignalInfo+instance SignalInfo ScreenApplicationOpenedSignalInfo where+    type HaskellCallbackType ScreenApplicationOpenedSignalInfo = ScreenApplicationOpenedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenApplicationOpenedCallback cb+        cb'' <- mk_ScreenApplicationOpenedCallback cb'+        connectSignalFunPtr obj "application-opened" cb'' connectMode++data ScreenBackgroundChangedSignalInfo+instance SignalInfo ScreenBackgroundChangedSignalInfo where+    type HaskellCallbackType ScreenBackgroundChangedSignalInfo = ScreenBackgroundChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenBackgroundChangedCallback cb+        cb'' <- mk_ScreenBackgroundChangedCallback cb'+        connectSignalFunPtr obj "background-changed" cb'' connectMode++data ScreenClassGroupClosedSignalInfo+instance SignalInfo ScreenClassGroupClosedSignalInfo where+    type HaskellCallbackType ScreenClassGroupClosedSignalInfo = ScreenClassGroupClosedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenClassGroupClosedCallback cb+        cb'' <- mk_ScreenClassGroupClosedCallback cb'+        connectSignalFunPtr obj "class-group-closed" cb'' connectMode++data ScreenClassGroupOpenedSignalInfo+instance SignalInfo ScreenClassGroupOpenedSignalInfo where+    type HaskellCallbackType ScreenClassGroupOpenedSignalInfo = ScreenClassGroupOpenedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenClassGroupOpenedCallback cb+        cb'' <- mk_ScreenClassGroupOpenedCallback cb'+        connectSignalFunPtr obj "class-group-opened" cb'' connectMode++data ScreenShowingDesktopChangedSignalInfo+instance SignalInfo ScreenShowingDesktopChangedSignalInfo where+    type HaskellCallbackType ScreenShowingDesktopChangedSignalInfo = ScreenShowingDesktopChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenShowingDesktopChangedCallback cb+        cb'' <- mk_ScreenShowingDesktopChangedCallback cb'+        connectSignalFunPtr obj "showing-desktop-changed" cb'' connectMode++data ScreenViewportsChangedSignalInfo+instance SignalInfo ScreenViewportsChangedSignalInfo where+    type HaskellCallbackType ScreenViewportsChangedSignalInfo = ScreenViewportsChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenViewportsChangedCallback cb+        cb'' <- mk_ScreenViewportsChangedCallback cb'+        connectSignalFunPtr obj "viewports-changed" cb'' connectMode++data ScreenWindowClosedSignalInfo+instance SignalInfo ScreenWindowClosedSignalInfo where+    type HaskellCallbackType ScreenWindowClosedSignalInfo = ScreenWindowClosedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenWindowClosedCallback cb+        cb'' <- mk_ScreenWindowClosedCallback cb'+        connectSignalFunPtr obj "window-closed" cb'' connectMode++data ScreenWindowManagerChangedSignalInfo+instance SignalInfo ScreenWindowManagerChangedSignalInfo where+    type HaskellCallbackType ScreenWindowManagerChangedSignalInfo = ScreenWindowManagerChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenWindowManagerChangedCallback cb+        cb'' <- mk_ScreenWindowManagerChangedCallback cb'+        connectSignalFunPtr obj "window-manager-changed" cb'' connectMode++data ScreenWindowOpenedSignalInfo+instance SignalInfo ScreenWindowOpenedSignalInfo where+    type HaskellCallbackType ScreenWindowOpenedSignalInfo = ScreenWindowOpenedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenWindowOpenedCallback cb+        cb'' <- mk_ScreenWindowOpenedCallback cb'+        connectSignalFunPtr obj "window-opened" cb'' connectMode++data ScreenWindowStackingChangedSignalInfo+instance SignalInfo ScreenWindowStackingChangedSignalInfo where+    type HaskellCallbackType ScreenWindowStackingChangedSignalInfo = ScreenWindowStackingChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenWindowStackingChangedCallback cb+        cb'' <- mk_ScreenWindowStackingChangedCallback cb'+        connectSignalFunPtr obj "window-stacking-changed" cb'' connectMode++data ScreenWorkspaceCreatedSignalInfo+instance SignalInfo ScreenWorkspaceCreatedSignalInfo where+    type HaskellCallbackType ScreenWorkspaceCreatedSignalInfo = ScreenWorkspaceCreatedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenWorkspaceCreatedCallback cb+        cb'' <- mk_ScreenWorkspaceCreatedCallback cb'+        connectSignalFunPtr obj "workspace-created" cb'' connectMode++data ScreenWorkspaceDestroyedSignalInfo+instance SignalInfo ScreenWorkspaceDestroyedSignalInfo where+    type HaskellCallbackType ScreenWorkspaceDestroyedSignalInfo = ScreenWorkspaceDestroyedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ScreenWorkspaceDestroyedCallback cb+        cb'' <- mk_ScreenWorkspaceDestroyedCallback cb'+        connectSignalFunPtr obj "workspace-destroyed" cb'' connectMode++type instance O.SignalList Screen = ScreenSignalList+type ScreenSignalList = ('[ '("activeWindowChanged", ScreenActiveWindowChangedSignalInfo), '("activeWorkspaceChanged", ScreenActiveWorkspaceChangedSignalInfo), '("applicationClosed", ScreenApplicationClosedSignalInfo), '("applicationOpened", ScreenApplicationOpenedSignalInfo), '("backgroundChanged", ScreenBackgroundChangedSignalInfo), '("classGroupClosed", ScreenClassGroupClosedSignalInfo), '("classGroupOpened", ScreenClassGroupOpenedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("showingDesktopChanged", ScreenShowingDesktopChangedSignalInfo), '("viewportsChanged", ScreenViewportsChangedSignalInfo), '("windowClosed", ScreenWindowClosedSignalInfo), '("windowManagerChanged", ScreenWindowManagerChangedSignalInfo), '("windowOpened", ScreenWindowOpenedSignalInfo), '("windowStackingChanged", ScreenWindowStackingChangedSignalInfo), '("workspaceCreated", ScreenWorkspaceCreatedSignalInfo), '("workspaceDestroyed", ScreenWorkspaceDestroyedSignalInfo)] :: [(Symbol, *)])++#endif++-- method Screen::calc_workspace_layout+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num_workspaces", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of #WnckWorkspace on @screen, or -1 to let\nwnck_screen_calc_workspace_layout() find this number.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "space_index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "layout", argType = TInterface (Name {namespace = "Wnck", name = "WorkspaceLayout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the layout of #WnckWorkspace with additional\ninformation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_screen_calc_workspace_layout" wnck_screen_calc_workspace_layout :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    Int32 ->                                -- num_workspaces : TBasicType TInt+    Int32 ->                                -- space_index : TBasicType TInt+    Ptr Wnck.WorkspaceLayout.WorkspaceLayout -> -- layout : TInterface (Name {namespace = "Wnck", name = "WorkspaceLayout"})+    IO ()++{-# DEPRECATED screenCalcWorkspaceLayout ["(Since version 2.20)"] #-}+{- |+Calculates the layout of 'GI.Wnck.Objects.Workspace.Workspace', with additional information like+the row and column of the 'GI.Wnck.Objects.Workspace.Workspace' with index /@spaceIndex@/.++/Since: 2.12/+-}+screenCalcWorkspaceLayout ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> Int32+    {- ^ /@numWorkspaces@/: the number of 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/, or -1 to let+'GI.Wnck.Objects.Screen.screenCalcWorkspaceLayout' find this number. -}+    -> Int32+    {- ^ /@spaceIndex@/: the index of a 'GI.Wnck.Objects.Workspace.Workspace'. -}+    -> Wnck.WorkspaceLayout.WorkspaceLayout+    {- ^ /@layout@/: return location for the layout of 'GI.Wnck.Objects.Workspace.Workspace' with additional+information. -}+    -> m ()+screenCalcWorkspaceLayout screen numWorkspaces spaceIndex layout = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    layout' <- unsafeManagedPtrGetPtr layout+    wnck_screen_calc_workspace_layout screen' numWorkspaces spaceIndex layout'+    touchManagedPtr screen+    touchManagedPtr layout+    return ()++#if ENABLE_OVERLOADING+data ScreenCalcWorkspaceLayoutMethodInfo+instance (signature ~ (Int32 -> Int32 -> Wnck.WorkspaceLayout.WorkspaceLayout -> m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenCalcWorkspaceLayoutMethodInfo a signature where+    overloadedMethod _ = screenCalcWorkspaceLayout++#endif++-- method Screen::change_workspace_count+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of #WnckWorkspace to request.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_screen_change_workspace_count" wnck_screen_change_workspace_count :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    Int32 ->                                -- count : TBasicType TInt+    IO ()++{- |+Asks the window manager to change the number of 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/.++/Since: 2.2/+-}+screenChangeWorkspaceCount ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> Int32+    {- ^ /@count@/: the number of 'GI.Wnck.Objects.Workspace.Workspace' to request. -}+    -> m ()+screenChangeWorkspaceCount screen count = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    wnck_screen_change_workspace_count screen' count+    touchManagedPtr screen+    return ()++#if ENABLE_OVERLOADING+data ScreenChangeWorkspaceCountMethodInfo+instance (signature ~ (Int32 -> m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenChangeWorkspaceCountMethodInfo a signature where+    overloadedMethod _ = screenChangeWorkspaceCount++#endif++-- method Screen::force_update+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_screen_force_update" wnck_screen_force_update :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    IO ()++{- |+Synchronously and immediately updates the list of 'GI.Wnck.Objects.Window.Window' on /@screen@/.+This bypasses the standard update mechanism, where the list of 'GI.Wnck.Objects.Window.Window'+is updated in the idle loop.++This is usually a bad idea for both performance and correctness reasons (to+get things right, you need to write model-view code that tracks changes, not+get a static list of open windows). However, this function can be useful for+small applications that just do something and then exit.+-}+screenForceUpdate ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> m ()+screenForceUpdate screen = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    wnck_screen_force_update screen'+    touchManagedPtr screen+    return ()++#if ENABLE_OVERLOADING+data ScreenForceUpdateMethodInfo+instance (signature ~ (m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenForceUpdateMethodInfo a signature where+    overloadedMethod _ = screenForceUpdate++#endif++-- method Screen::get_active_window+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", 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_screen_get_active_window" wnck_screen_get_active_window :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    IO (Ptr Wnck.Window.Window)++{- |+Gets the active 'GI.Wnck.Objects.Window.Window' on /@screen@/. May return 'Nothing' sometimes, since+not all window managers guarantee that a window is always active.+-}+screenGetActiveWindow ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> m (Maybe Wnck.Window.Window)+    {- ^ __Returns:__ the active 'GI.Wnck.Objects.Window.Window' on /@screen@/, or 'Nothing'.+The returned 'GI.Wnck.Objects.Window.Window' is owned by libwnck and must not be referenced or+unreferenced. -}+screenGetActiveWindow screen = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_get_active_window screen'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newObject Wnck.Window.Window) result'+        return result''+    touchManagedPtr screen+    return maybeResult++#if ENABLE_OVERLOADING+data ScreenGetActiveWindowMethodInfo+instance (signature ~ (m (Maybe Wnck.Window.Window)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetActiveWindowMethodInfo a signature where+    overloadedMethod _ = screenGetActiveWindow++#endif++-- method Screen::get_active_workspace+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", 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_screen_get_active_workspace" wnck_screen_get_active_workspace :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    IO (Ptr Wnck.Workspace.Workspace)++{- |+Gets the active 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/. May return 'Nothing' sometimes,+if libwnck is in a weird state due to the asynchronous nature of the+interaction with the window manager.+-}+screenGetActiveWorkspace ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> m (Maybe Wnck.Workspace.Workspace)+    {- ^ __Returns:__ the active 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/, or+'Nothing'. The returned 'GI.Wnck.Objects.Workspace.Workspace' is owned by libwnck and must not be+referenced or unreferenced. -}+screenGetActiveWorkspace screen = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_get_active_workspace screen'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newObject Wnck.Workspace.Workspace) result'+        return result''+    touchManagedPtr screen+    return maybeResult++#if ENABLE_OVERLOADING+data ScreenGetActiveWorkspaceMethodInfo+instance (signature ~ (m (Maybe Wnck.Workspace.Workspace)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetActiveWorkspaceMethodInfo a signature where+    overloadedMethod _ = screenGetActiveWorkspace++#endif++-- method Screen::get_background_pixmap+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", 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_screen_get_background_pixmap" wnck_screen_get_background_pixmap :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    IO CULong++{- |+Gets the X window ID of the background pixmap of /@screen@/.+-}+screenGetBackgroundPixmap ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> m CULong+    {- ^ __Returns:__ the X window ID of the background pixmap of /@screen@/. -}+screenGetBackgroundPixmap screen = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_get_background_pixmap screen'+    touchManagedPtr screen+    return result++#if ENABLE_OVERLOADING+data ScreenGetBackgroundPixmapMethodInfo+instance (signature ~ (m CULong), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetBackgroundPixmapMethodInfo a signature where+    overloadedMethod _ = screenGetBackgroundPixmap++#endif++-- method Screen::get_height+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", 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_screen_get_height" wnck_screen_get_height :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    IO Int32++{- |+Gets the height of /@screen@/.+-}+screenGetHeight ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> m Int32+    {- ^ __Returns:__ the height of /@screen@/. -}+screenGetHeight screen = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_get_height screen'+    touchManagedPtr screen+    return result++#if ENABLE_OVERLOADING+data ScreenGetHeightMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetHeightMethodInfo a signature where+    overloadedMethod _ = screenGetHeight++#endif++-- method Screen::get_number+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", 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_screen_get_number" wnck_screen_get_number :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    IO Int32++{- |+Gets the index of /@screen@/ on the display to which it belongs. The first+'GI.Wnck.Objects.Screen.Screen' has an index of 0.++/Since: 2.20/+-}+screenGetNumber ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> m Int32+    {- ^ __Returns:__ the index of /@space@/ on /@screen@/, or -1 on errors. -}+screenGetNumber screen = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_get_number screen'+    touchManagedPtr screen+    return result++#if ENABLE_OVERLOADING+data ScreenGetNumberMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetNumberMethodInfo a signature where+    overloadedMethod _ = screenGetNumber++#endif++-- method Screen::get_previously_active_window+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", 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_screen_get_previously_active_window" wnck_screen_get_previously_active_window :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    IO (Ptr Wnck.Window.Window)++{- |+Gets the previously active 'GI.Wnck.Objects.Window.Window' on /@screen@/. May return 'Nothing'+sometimes, since not all window managers guarantee that a window is always+active.++/Since: 2.8/+-}+screenGetPreviouslyActiveWindow ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> m Wnck.Window.Window+    {- ^ __Returns:__ the previously active 'GI.Wnck.Objects.Window.Window' on /@screen@/,+or 'Nothing'. The returned 'GI.Wnck.Objects.Window.Window' is owned by libwnck and must not be+referenced or unreferenced. -}+screenGetPreviouslyActiveWindow screen = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_get_previously_active_window screen'+    checkUnexpectedReturnNULL "screenGetPreviouslyActiveWindow" result+    result' <- (newObject Wnck.Window.Window) result+    touchManagedPtr screen+    return result'++#if ENABLE_OVERLOADING+data ScreenGetPreviouslyActiveWindowMethodInfo+instance (signature ~ (m Wnck.Window.Window), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetPreviouslyActiveWindowMethodInfo a signature where+    overloadedMethod _ = screenGetPreviouslyActiveWindow++#endif++-- method Screen::get_showing_desktop+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", 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_screen_get_showing_desktop" wnck_screen_get_showing_desktop :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    IO CInt++{- |+Gets whether /@screen@/ is in the \"showing the desktop\" mode. This mode is+changed when a 'GI.Wnck.Objects.Screen.Screen'::@/showing-desktop-changed/@ signal gets emitted.++/Since: 2.2/+-}+screenGetShowingDesktop ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> m Bool+    {- ^ __Returns:__ 'True' if /@window@/ is fullscreen, 'False' otherwise. -}+screenGetShowingDesktop screen = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_get_showing_desktop screen'+    let result' = (/= 0) result+    touchManagedPtr screen+    return result'++#if ENABLE_OVERLOADING+data ScreenGetShowingDesktopMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetShowingDesktopMethodInfo a signature where+    overloadedMethod _ = screenGetShowingDesktop++#endif++-- method Screen::get_width+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", 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_screen_get_width" wnck_screen_get_width :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    IO Int32++{- |+Gets the width of /@screen@/.+-}+screenGetWidth ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> m Int32+    {- ^ __Returns:__ the width of /@screen@/. -}+screenGetWidth screen = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_get_width screen'+    touchManagedPtr screen+    return result++#if ENABLE_OVERLOADING+data ScreenGetWidthMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWidthMethodInfo a signature where+    overloadedMethod _ = screenGetWidth++#endif++-- method Screen::get_window_manager_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", 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_screen_get_window_manager_name" wnck_screen_get_window_manager_name :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    IO CString++{- |+Gets the name of the window manager.++/Since: 2.20/+-}+screenGetWindowManagerName ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> m T.Text+    {- ^ __Returns:__ the name of the window manager, or 'Nothing' if the window manager+does not comply with the \<ulink+url=\"http:\/\/standards.freedesktop.org\/wm-spec\/wm-spec-latest.html\">EWMH\<\/ulink>+specification. -}+screenGetWindowManagerName screen = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_get_window_manager_name screen'+    checkUnexpectedReturnNULL "screenGetWindowManagerName" result+    result' <- cstringToText result+    touchManagedPtr screen+    return result'++#if ENABLE_OVERLOADING+data ScreenGetWindowManagerNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWindowManagerNameMethodInfo a signature where+    overloadedMethod _ = screenGetWindowManagerName++#endif++-- method Screen::get_windows+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TGList (TInterface (Name {namespace = "Wnck", name = "Window"})))+-- throws : False+-- Skip return : False++foreign import ccall "wnck_screen_get_windows" wnck_screen_get_windows :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    IO (Ptr (GList (Ptr Wnck.Window.Window)))++{- |+Gets the list of 'GI.Wnck.Objects.Window.Window' on /@screen@/. The list is not in a defined+order, but should be \"stable\" (windows should not be reordered in it).+However, the stability of the list is established by the window manager, so+don\'t blame libwnck if it breaks down.+-}+screenGetWindows ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> m [Wnck.Window.Window]+    {- ^ __Returns:__ the list of+'GI.Wnck.Objects.Window.Window' on /@screen@/, or 'Nothing' if there is no window on /@screen@/. The list+should not be modified nor freed, as it is owned by /@screen@/. -}+screenGetWindows screen = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_get_windows screen'+    result' <- unpackGList result+    result'' <- mapM (newObject Wnck.Window.Window) result'+    touchManagedPtr screen+    return result''++#if ENABLE_OVERLOADING+data ScreenGetWindowsMethodInfo+instance (signature ~ (m [Wnck.Window.Window]), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWindowsMethodInfo a signature where+    overloadedMethod _ = screenGetWindows++#endif++-- method Screen::get_windows_stacked+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TGList (TInterface (Name {namespace = "Wnck", name = "Window"})))+-- throws : False+-- Skip return : False++foreign import ccall "wnck_screen_get_windows_stacked" wnck_screen_get_windows_stacked :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    IO (Ptr (GList (Ptr Wnck.Window.Window)))++{- |+Gets the list of 'GI.Wnck.Objects.Window.Window' on /@screen@/ in bottom-to-top order.+-}+screenGetWindowsStacked ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> m [Wnck.Window.Window]+    {- ^ __Returns:__ the list of+'GI.Wnck.Objects.Window.Window' in stacking order on /@screen@/, or 'Nothing' if there is no window on+/@screen@/. The list should not be modified nor freed, as it is owned by+/@screen@/. -}+screenGetWindowsStacked screen = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_get_windows_stacked screen'+    result' <- unpackGList result+    result'' <- mapM (newObject Wnck.Window.Window) result'+    touchManagedPtr screen+    return result''++#if ENABLE_OVERLOADING+data ScreenGetWindowsStackedMethodInfo+instance (signature ~ (m [Wnck.Window.Window]), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWindowsStackedMethodInfo a signature where+    overloadedMethod _ = screenGetWindowsStacked++#endif++-- method Screen::get_workspace+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "workspace", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a workspace index, starting from 0.", 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_screen_get_workspace" wnck_screen_get_workspace :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    Int32 ->                                -- workspace : TBasicType TInt+    IO (Ptr Wnck.Workspace.Workspace)++{- |+Gets the 'GI.Wnck.Objects.Workspace.Workspace' numbered /@workspace@/ on /@screen@/.+-}+screenGetWorkspace ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> Int32+    {- ^ /@workspace@/: a workspace index, starting from 0. -}+    -> m Wnck.Workspace.Workspace+    {- ^ __Returns:__ the 'GI.Wnck.Objects.Workspace.Workspace' numbered /@workspace@/ on+/@screen@/, or 'Nothing' if no such workspace exists. The returned 'GI.Wnck.Objects.Workspace.Workspace'+is owned by libwnck and must not be referenced or unreferenced. -}+screenGetWorkspace screen workspace = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_get_workspace screen' workspace+    checkUnexpectedReturnNULL "screenGetWorkspace" result+    result' <- (newObject Wnck.Workspace.Workspace) result+    touchManagedPtr screen+    return result'++#if ENABLE_OVERLOADING+data ScreenGetWorkspaceMethodInfo+instance (signature ~ (Int32 -> m Wnck.Workspace.Workspace), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWorkspaceMethodInfo a signature where+    overloadedMethod _ = screenGetWorkspace++#endif++-- method Screen::get_workspace_count+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", 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_screen_get_workspace_count" wnck_screen_get_workspace_count :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    IO Int32++{- |+Gets the number of 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/.+-}+screenGetWorkspaceCount ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> m Int32+    {- ^ __Returns:__ the number of 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/. -}+screenGetWorkspaceCount screen = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_get_workspace_count screen'+    touchManagedPtr screen+    return result++#if ENABLE_OVERLOADING+data ScreenGetWorkspaceCountMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWorkspaceCountMethodInfo a signature where+    overloadedMethod _ = screenGetWorkspaceCount++#endif++-- method Screen::get_workspaces+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TGList (TInterface (Name {namespace = "Wnck", name = "Workspace"})))+-- throws : False+-- Skip return : False++foreign import ccall "wnck_screen_get_workspaces" wnck_screen_get_workspaces :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    IO (Ptr (GList (Ptr Wnck.Workspace.Workspace)))++{- |+Gets the list of 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/. The list is ordered: the+first element in the list is the first 'GI.Wnck.Objects.Workspace.Workspace', etc..++/Since: 2.20/+-}+screenGetWorkspaces ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> m [Wnck.Workspace.Workspace]+    {- ^ __Returns:__ the list of+'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/. The list should not be modified nor freed, as it+is owned by /@screen@/. -}+screenGetWorkspaces screen = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_get_workspaces screen'+    result' <- unpackGList result+    result'' <- mapM (newObject Wnck.Workspace.Workspace) result'+    touchManagedPtr screen+    return result''++#if ENABLE_OVERLOADING+data ScreenGetWorkspacesMethodInfo+instance (signature ~ (m [Wnck.Workspace.Workspace]), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWorkspacesMethodInfo a signature where+    overloadedMethod _ = screenGetWorkspaces++#endif++-- method Screen::move_viewport+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", 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 offset in pixels of viewport.", 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 offset in pixels of viewport.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_screen_move_viewport" wnck_screen_move_viewport :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    Int32 ->                                -- x : TBasicType TInt+    Int32 ->                                -- y : TBasicType TInt+    IO ()++{- |+Asks the window manager to move the viewport of the current 'GI.Wnck.Objects.Workspace.Workspace'+on /@screen@/.++/Since: 2.4/+-}+screenMoveViewport ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> Int32+    {- ^ /@x@/: X offset in pixels of viewport. -}+    -> Int32+    {- ^ /@y@/: Y offset in pixels of viewport. -}+    -> m ()+screenMoveViewport screen x y = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    wnck_screen_move_viewport screen' x y+    touchManagedPtr screen+    return ()++#if ENABLE_OVERLOADING+data ScreenMoveViewportMethodInfo+instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenMoveViewportMethodInfo a signature where+    overloadedMethod _ = screenMoveViewport++#endif++-- method Screen::net_wm_supports+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "atom", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a property atom.", 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_screen_net_wm_supports" wnck_screen_net_wm_supports :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    CString ->                              -- atom : TBasicType TUTF8+    IO CInt++{- |+Gets whether the window manager for /@screen@/ supports a certain hint from+the \<ulink+url=\"http:\/\/standards.freedesktop.org\/wm-spec\/wm-spec-latest.html\">Extended+Window Manager Hints specification\<\/ulink> (EWMH).++When using this function, keep in mind that the window manager can change+over time; so you should not use this function in a way that impacts+persistent application state. A common bug is that your application can+start up before the window manager does when the user logs in, and before+the window manager starts 'GI.Wnck.Objects.Screen.screenNetWmSupports' will return 'False'+for every property.++See also @/gdk_x11_screen_supports_net_wm_hint()/@ in GDK.+-}+screenNetWmSupports ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> T.Text+    {- ^ /@atom@/: a property atom. -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the window manager for /@screen@/ supports the /@atom@/+hint, 'False' otherwise. -}+screenNetWmSupports screen atom = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    atom' <- textToCString atom+    result <- wnck_screen_net_wm_supports screen' atom'+    let result' = (/= 0) result+    touchManagedPtr screen+    freeMem atom'+    return result'++#if ENABLE_OVERLOADING+data ScreenNetWmSupportsMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m, IsScreen a) => O.MethodInfo ScreenNetWmSupportsMethodInfo a signature where+    overloadedMethod _ = screenNetWmSupports++#endif++-- method Screen::release_workspace_layout+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "current_token", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the token obtained through\nwnck_screen_try_set_workspace_layout().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_screen_release_workspace_layout" wnck_screen_release_workspace_layout :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    Int32 ->                                -- current_token : TBasicType TInt+    IO ()++{- |+Releases the ownership of the layout of 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/.+/@currentToken@/ is used to verify that the caller is the owner of the layout.+If the verification fails, nothing happens.+-}+screenReleaseWorkspaceLayout ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> Int32+    {- ^ /@currentToken@/: the token obtained through+'GI.Wnck.Objects.Screen.screenTrySetWorkspaceLayout'. -}+    -> m ()+screenReleaseWorkspaceLayout screen currentToken = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    wnck_screen_release_workspace_layout screen' currentToken+    touchManagedPtr screen+    return ()++#if ENABLE_OVERLOADING+data ScreenReleaseWorkspaceLayoutMethodInfo+instance (signature ~ (Int32 -> m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenReleaseWorkspaceLayoutMethodInfo a signature where+    overloadedMethod _ = screenReleaseWorkspaceLayout++#endif++-- method Screen::toggle_showing_desktop+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "show", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to activate the \"showing the desktop\" mode on @screen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_screen_toggle_showing_desktop" wnck_screen_toggle_showing_desktop :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    CInt ->                                 -- show : TBasicType TBoolean+    IO ()++{- |+Asks the window manager to set the \"showing the desktop\" mode on /@screen@/+according to /@show@/.++/Since: 2.2/+-}+screenToggleShowingDesktop ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> Bool+    {- ^ /@show@/: whether to activate the \"showing the desktop\" mode on /@screen@/. -}+    -> m ()+screenToggleShowingDesktop screen show_ = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    let show_' = (fromIntegral . fromEnum) show_+    wnck_screen_toggle_showing_desktop screen' show_'+    touchManagedPtr screen+    return ()++#if ENABLE_OVERLOADING+data ScreenToggleShowingDesktopMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenToggleShowingDesktopMethodInfo a signature where+    overloadedMethod _ = screenToggleShowingDesktop++#endif++-- method Screen::try_set_workspace_layout+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "current_token", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a token. Use 0 if you do not called\nwnck_screen_try_set_workspace_layout() before, or if you did not keep the\nold token.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rows", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of rows to use for the #WnckWorkspace layout.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "columns", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of columns to use for the #WnckWorkspace layout.", 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_screen_try_set_workspace_layout" wnck_screen_try_set_workspace_layout :: +    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})+    Int32 ->                                -- current_token : TBasicType TInt+    Int32 ->                                -- rows : TBasicType TInt+    Int32 ->                                -- columns : TBasicType TInt+    IO Int32++{- |+Tries to modify the layout of 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/. To do this, tries+to acquire ownership of the layout. If the current process is the owner of+the layout, /@currentToken@/ is used to determine if the caller is the owner+(there might be more than one part of the same process trying to set the+layout). Since no more than one application should set this property of+/@screen@/ at a time, setting the layout is not guaranteed to work.++If /@rows@/ is 0, the actual number of rows will be determined based on+/@columns@/ and the number of 'GI.Wnck.Objects.Workspace.Workspace'. If /@columns@/ is 0, the actual+number of columns will be determined based on /@rows@/ and the number of+'GI.Wnck.Objects.Workspace.Workspace'. /@rows@/ and /@columns@/ must not be 0 at the same time.++You have to release the ownership of the layout with+'GI.Wnck.Objects.Screen.screenReleaseWorkspaceLayout' when you do not need it anymore.+-}+screenTrySetWorkspaceLayout ::+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>+    a+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}+    -> Int32+    {- ^ /@currentToken@/: a token. Use 0 if you do not called+'GI.Wnck.Objects.Screen.screenTrySetWorkspaceLayout' before, or if you did not keep the+old token. -}+    -> Int32+    {- ^ /@rows@/: the number of rows to use for the 'GI.Wnck.Objects.Workspace.Workspace' layout. -}+    -> Int32+    {- ^ /@columns@/: the number of columns to use for the 'GI.Wnck.Objects.Workspace.Workspace' layout. -}+    -> m Int32+    {- ^ __Returns:__ a token to use for future calls to+'GI.Wnck.Objects.Screen.screenTrySetWorkspaceLayout' and to+'GI.Wnck.Objects.Screen.screenReleaseWorkspaceLayout', or 0 if the layout could not be set. -}+screenTrySetWorkspaceLayout screen currentToken rows columns = liftIO $ do+    screen' <- unsafeManagedPtrCastPtr screen+    result <- wnck_screen_try_set_workspace_layout screen' currentToken rows columns+    touchManagedPtr screen+    return result++#if ENABLE_OVERLOADING+data ScreenTrySetWorkspaceLayoutMethodInfo+instance (signature ~ (Int32 -> Int32 -> Int32 -> m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenTrySetWorkspaceLayoutMethodInfo a signature where+    overloadedMethod _ = screenTrySetWorkspaceLayout++#endif++-- method Screen::free_workspace_layout+-- method type : MemberFunction+-- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Wnck", name = "WorkspaceLayout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspaceLayout.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "wnck_screen_free_workspace_layout" wnck_screen_free_workspace_layout :: +    Ptr Wnck.WorkspaceLayout.WorkspaceLayout -> -- layout : TInterface (Name {namespace = "Wnck", name = "WorkspaceLayout"})+    IO ()++{-# DEPRECATED screenFreeWorkspaceLayout ["(Since version 2.20)"] #-}+{- |+Frees the content of /@layout@/. This does not free /@layout@/ itself, so you+might want to free /@layout@/ yourself after calling this.++/Since: 2.12/+-}+screenFreeWorkspaceLayout ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Wnck.WorkspaceLayout.WorkspaceLayout+    {- ^ /@layout@/: a 'GI.Wnck.Structs.WorkspaceLayout.WorkspaceLayout'. -}+    -> m ()+screenFreeWorkspaceLayout layout = liftIO $ do+    layout' <- unsafeManagedPtrGetPtr layout+    wnck_screen_free_workspace_layout layout'+    touchManagedPtr layout+    return ()++#if ENABLE_OVERLOADING+#endif++-- method Screen::get+-- method type : MemberFunction+-- Args : [Arg {argCName = "index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "screen number, starting from 0.", 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_screen_get" wnck_screen_get :: +    Int32 ->                                -- index : TBasicType TInt+    IO (Ptr Screen)++{- |+Gets the 'GI.Wnck.Objects.Screen.Screen' for a given screen on the default display.+-}+screenGet ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Int32+    {- ^ /@index@/: screen number, starting from 0. -}+    -> m Screen+    {- ^ __Returns:__ the 'GI.Wnck.Objects.Screen.Screen' for screen /@index@/, or 'Nothing'+if no such screen exists. The returned 'GI.Wnck.Objects.Screen.Screen' is owned by libwnck and+must not be referenced or unreferenced. -}+screenGet index = liftIO $ do+    result <- wnck_screen_get index+    checkUnexpectedReturnNULL "screenGet" result+    result' <- (newObject Screen) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Screen::get_default+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Screen"}))+-- throws : False+-- Skip return : False++foreign import ccall "wnck_screen_get_default" wnck_screen_get_default :: +    IO (Ptr Screen)++{- |+Gets the default 'GI.Wnck.Objects.Screen.Screen' on the default display.+-}+screenGetDefault ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m (Maybe Screen)+    {- ^ __Returns:__ the default 'GI.Wnck.Objects.Screen.Screen'. The returned+'GI.Wnck.Objects.Screen.Screen' is owned by libwnck and must not be referenced or unreferenced. This+can return 'Nothing' if not on X11. -}+screenGetDefault  = liftIO $ do+    result <- wnck_screen_get_default+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newObject Screen) result'+        return result''+    return maybeResult++#if ENABLE_OVERLOADING+#endif++-- method Screen::get_for_root+-- method type : MemberFunction+-- Args : [Arg {argCName = "root_window_id", 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 = "Screen"}))+-- throws : False+-- Skip return : False++foreign import ccall "wnck_screen_get_for_root" wnck_screen_get_for_root :: +    CULong ->                               -- root_window_id : TBasicType TULong+    IO (Ptr Screen)++{- |+Gets the 'GI.Wnck.Objects.Screen.Screen' for the root window at /@rootWindowId@/, or+'Nothing' if no 'GI.Wnck.Objects.Screen.Screen' exists for this root window.++This function does not work if 'GI.Wnck.Objects.Screen.screenGet' was not called for the+sought 'GI.Wnck.Objects.Screen.Screen' before, and returns 'Nothing'.+-}+screenGetForRoot ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    CULong+    {- ^ /@rootWindowId@/: an X window ID. -}+    -> m Screen+    {- ^ __Returns:__ the 'GI.Wnck.Objects.Screen.Screen' for the root window at+/@rootWindowId@/, or 'Nothing'. The returned 'GI.Wnck.Objects.Screen.Screen' is owned by libwnck and+must not be referenced or unreferenced. -}+screenGetForRoot rootWindowId = liftIO $ do+    result <- wnck_screen_get_for_root rootWindowId+    checkUnexpectedReturnNULL "screenGetForRoot" result+    result' <- (newObject Screen) result+    return result'++#if ENABLE_OVERLOADING+#endif++