{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Wnck.Objects.Application.Application' struct contains only private fields and should not be
-- directly accessed.

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

module GI.Wnck.Objects.Application
    ( 

-- * Exported types
    Application(..)                         ,
    IsApplication                           ,
    toApplication                           ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveApplicationMethod                ,
#endif


-- ** get #method:get#

    applicationGet                          ,


-- ** getIcon #method:getIcon#

#if defined(ENABLE_OVERLOADING)
    ApplicationGetIconMethodInfo            ,
#endif
    applicationGetIcon                      ,


-- ** getIconIsFallback #method:getIconIsFallback#

#if defined(ENABLE_OVERLOADING)
    ApplicationGetIconIsFallbackMethodInfo  ,
#endif
    applicationGetIconIsFallback            ,


-- ** getIconName #method:getIconName#

#if defined(ENABLE_OVERLOADING)
    ApplicationGetIconNameMethodInfo        ,
#endif
    applicationGetIconName                  ,


-- ** getMiniIcon #method:getMiniIcon#

#if defined(ENABLE_OVERLOADING)
    ApplicationGetMiniIconMethodInfo        ,
#endif
    applicationGetMiniIcon                  ,


-- ** getNWindows #method:getNWindows#

#if defined(ENABLE_OVERLOADING)
    ApplicationGetNWindowsMethodInfo        ,
#endif
    applicationGetNWindows                  ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    ApplicationGetNameMethodInfo            ,
#endif
    applicationGetName                      ,


-- ** getPid #method:getPid#

#if defined(ENABLE_OVERLOADING)
    ApplicationGetPidMethodInfo             ,
#endif
    applicationGetPid                       ,


-- ** getStartupId #method:getStartupId#

#if defined(ENABLE_OVERLOADING)
    ApplicationGetStartupIdMethodInfo       ,
#endif
    applicationGetStartupId                 ,


-- ** getWindows #method:getWindows#

#if defined(ENABLE_OVERLOADING)
    ApplicationGetWindowsMethodInfo         ,
#endif
    applicationGetWindows                   ,


-- ** getXid #method:getXid#

#if defined(ENABLE_OVERLOADING)
    ApplicationGetXidMethodInfo             ,
#endif
    applicationGetXid                       ,




 -- * Signals
-- ** iconChanged #signal:iconChanged#

    ApplicationIconChangedCallback          ,
#if defined(ENABLE_OVERLOADING)
    ApplicationIconChangedSignalInfo        ,
#endif
    C_ApplicationIconChangedCallback        ,
    afterApplicationIconChanged             ,
    genClosure_ApplicationIconChanged       ,
    mk_ApplicationIconChangedCallback       ,
    noApplicationIconChangedCallback        ,
    onApplicationIconChanged                ,
    wrap_ApplicationIconChangedCallback     ,


-- ** nameChanged #signal:nameChanged#

    ApplicationNameChangedCallback          ,
#if defined(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.BasicTypes as B.Types
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
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 (SP.ManagedPtr Application)
    deriving (Application -> Application -> Bool
(Application -> Application -> Bool)
-> (Application -> Application -> Bool) -> Eq Application
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Application -> Application -> Bool
$c/= :: Application -> Application -> Bool
== :: Application -> Application -> Bool
$c== :: Application -> Application -> Bool
Eq)

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

foreign import ccall "wnck_application_get_type"
    c_wnck_application_get_type :: IO B.Types.GType

instance B.Types.TypedObject Application where
    glibType :: IO GType
glibType = IO GType
c_wnck_application_get_type

instance B.Types.GObject Application

-- | Convert 'Application' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue Application where
    toGValue :: Application -> IO GValue
toGValue Application
o = do
        GType
gtype <- IO GType
c_wnck_application_get_type
        Application -> (Ptr Application -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Application
o (GType
-> (GValue -> Ptr Application -> IO ())
-> Ptr Application
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Application -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO Application
fromGValue GValue
gv = do
        Ptr Application
ptr <- GValue -> IO (Ptr Application)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Application)
        (ManagedPtr Application -> Application)
-> Ptr Application -> IO Application
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Application -> Application
Application Ptr Application
ptr
        
    

-- | Type class for types which can be safely cast to `Application`, for instance with `toApplication`.
class (SP.GObject o, O.IsDescendantOf Application o) => IsApplication o
instance (SP.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 :: o -> m Application
toApplication = IO Application -> m Application
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Application -> m Application)
-> (o -> IO Application) -> o -> m Application
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Application -> Application) -> o -> IO Application
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Application -> Application
Application

#if defined(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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    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 @info
#else
    fromLabel _ = O.overloadedMethod @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 :: Maybe (IO ())
noApplicationIconChangedCallback = Maybe (IO ())
forall a. Maybe a
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 :: IO () -> m (GClosure C_ApplicationIconChangedCallback)
genClosure_ApplicationIconChanged IO ()
cb = IO (GClosure C_ApplicationIconChangedCallback)
-> m (GClosure C_ApplicationIconChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ApplicationIconChangedCallback)
 -> m (GClosure C_ApplicationIconChangedCallback))
-> IO (GClosure C_ApplicationIconChangedCallback)
-> m (GClosure C_ApplicationIconChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ApplicationIconChangedCallback
cb' = IO () -> C_ApplicationIconChangedCallback
wrap_ApplicationIconChangedCallback IO ()
cb
    C_ApplicationIconChangedCallback
-> IO (FunPtr C_ApplicationIconChangedCallback)
mk_ApplicationIconChangedCallback C_ApplicationIconChangedCallback
cb' IO (FunPtr C_ApplicationIconChangedCallback)
-> (FunPtr C_ApplicationIconChangedCallback
    -> IO (GClosure C_ApplicationIconChangedCallback))
-> IO (GClosure C_ApplicationIconChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ApplicationIconChangedCallback
-> IO (GClosure C_ApplicationIconChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ApplicationIconChangedCallback` into a `C_ApplicationIconChangedCallback`.
wrap_ApplicationIconChangedCallback ::
    ApplicationIconChangedCallback ->
    C_ApplicationIconChangedCallback
wrap_ApplicationIconChangedCallback :: IO () -> C_ApplicationIconChangedCallback
wrap_ApplicationIconChangedCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [iconChanged](#signal:iconChanged) 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 :: a -> IO () -> m SignalHandlerId
onApplicationIconChanged a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ApplicationIconChangedCallback
cb' = IO () -> C_ApplicationIconChangedCallback
wrap_ApplicationIconChangedCallback IO ()
cb
    FunPtr C_ApplicationIconChangedCallback
cb'' <- C_ApplicationIconChangedCallback
-> IO (FunPtr C_ApplicationIconChangedCallback)
mk_ApplicationIconChangedCallback C_ApplicationIconChangedCallback
cb'
    a
-> Text
-> FunPtr C_ApplicationIconChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"icon-changed" FunPtr C_ApplicationIconChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [iconChanged](#signal:iconChanged) 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 :: a -> IO () -> m SignalHandlerId
afterApplicationIconChanged a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ApplicationIconChangedCallback
cb' = IO () -> C_ApplicationIconChangedCallback
wrap_ApplicationIconChangedCallback IO ()
cb
    FunPtr C_ApplicationIconChangedCallback
cb'' <- C_ApplicationIconChangedCallback
-> IO (FunPtr C_ApplicationIconChangedCallback)
mk_ApplicationIconChangedCallback C_ApplicationIconChangedCallback
cb'
    a
-> Text
-> FunPtr C_ApplicationIconChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"icon-changed" FunPtr C_ApplicationIconChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ApplicationIconChangedSignalInfo
instance SignalInfo ApplicationIconChangedSignalInfo where
    type HaskellCallbackType ApplicationIconChangedSignalInfo = ApplicationIconChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ApplicationIconChangedCallback cb
        cb'' <- mk_ApplicationIconChangedCallback cb'
        connectSignalFunPtr obj "icon-changed" cb'' connectMode detail

#endif

-- 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 :: Maybe (IO ())
noApplicationNameChangedCallback = Maybe (IO ())
forall a. Maybe a
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 :: IO () -> m (GClosure C_ApplicationIconChangedCallback)
genClosure_ApplicationNameChanged IO ()
cb = IO (GClosure C_ApplicationIconChangedCallback)
-> m (GClosure C_ApplicationIconChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ApplicationIconChangedCallback)
 -> m (GClosure C_ApplicationIconChangedCallback))
-> IO (GClosure C_ApplicationIconChangedCallback)
-> m (GClosure C_ApplicationIconChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ApplicationIconChangedCallback
cb' = IO () -> C_ApplicationIconChangedCallback
wrap_ApplicationNameChangedCallback IO ()
cb
    C_ApplicationIconChangedCallback
-> IO (FunPtr C_ApplicationIconChangedCallback)
mk_ApplicationNameChangedCallback C_ApplicationIconChangedCallback
cb' IO (FunPtr C_ApplicationIconChangedCallback)
-> (FunPtr C_ApplicationIconChangedCallback
    -> IO (GClosure C_ApplicationIconChangedCallback))
-> IO (GClosure C_ApplicationIconChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ApplicationIconChangedCallback
-> IO (GClosure C_ApplicationIconChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ApplicationNameChangedCallback` into a `C_ApplicationNameChangedCallback`.
wrap_ApplicationNameChangedCallback ::
    ApplicationNameChangedCallback ->
    C_ApplicationNameChangedCallback
wrap_ApplicationNameChangedCallback :: IO () -> C_ApplicationIconChangedCallback
wrap_ApplicationNameChangedCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [nameChanged](#signal:nameChanged) 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 :: a -> IO () -> m SignalHandlerId
onApplicationNameChanged a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ApplicationIconChangedCallback
cb' = IO () -> C_ApplicationIconChangedCallback
wrap_ApplicationNameChangedCallback IO ()
cb
    FunPtr C_ApplicationIconChangedCallback
cb'' <- C_ApplicationIconChangedCallback
-> IO (FunPtr C_ApplicationIconChangedCallback)
mk_ApplicationNameChangedCallback C_ApplicationIconChangedCallback
cb'
    a
-> Text
-> FunPtr C_ApplicationIconChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"name-changed" FunPtr C_ApplicationIconChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [nameChanged](#signal:nameChanged) 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 :: a -> IO () -> m SignalHandlerId
afterApplicationNameChanged a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ApplicationIconChangedCallback
cb' = IO () -> C_ApplicationIconChangedCallback
wrap_ApplicationNameChangedCallback IO ()
cb
    FunPtr C_ApplicationIconChangedCallback
cb'' <- C_ApplicationIconChangedCallback
-> IO (FunPtr C_ApplicationIconChangedCallback)
mk_ApplicationNameChangedCallback C_ApplicationIconChangedCallback
cb'
    a
-> Text
-> FunPtr C_ApplicationIconChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"name-changed" FunPtr C_ApplicationIconChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ApplicationNameChangedSignalInfo
instance SignalInfo ApplicationNameChangedSignalInfo where
    type HaskellCallbackType ApplicationNameChangedSignalInfo = ApplicationNameChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ApplicationNameChangedCallback cb
        cb'' <- mk_ApplicationNameChangedCallback cb'
        connectSignalFunPtr obj "name-changed" cb'' connectMode detail

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
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 t'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 :: a -> m Pixbuf
applicationGetIcon a
app = IO Pixbuf -> m Pixbuf
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Pixbuf -> m Pixbuf) -> IO Pixbuf -> m Pixbuf
forall a b. (a -> b) -> a -> b
$ do
    Ptr Application
app' <- a -> IO (Ptr Application)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
app
    Ptr Pixbuf
result <- Ptr Application -> IO (Ptr Pixbuf)
wnck_application_get_icon Ptr Application
app'
    Text -> Ptr Pixbuf -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"applicationGetIcon" Ptr Pixbuf
result
    Pixbuf
result' <- ((ManagedPtr Pixbuf -> Pixbuf) -> Ptr Pixbuf -> IO Pixbuf
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Pixbuf -> Pixbuf
GdkPixbuf.Pixbuf.Pixbuf) Ptr Pixbuf
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
app
    Pixbuf -> IO Pixbuf
forall (m :: * -> *) a. Monad m => a -> m a
return Pixbuf
result'

#if defined(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 t'GI.Wnck.Objects.Application.Application'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the icon for /@app@/ is a fallback, 'P.False' otherwise.
applicationGetIconIsFallback :: a -> m Bool
applicationGetIconIsFallback a
app = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Application
app' <- a -> IO (Ptr Application)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
app
    CInt
result <- Ptr Application -> IO CInt
wnck_application_get_icon_is_fallback Ptr Application
app'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
app
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(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 t'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 :: a -> m Text
applicationGetIconName a
app = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Application
app' <- a -> IO (Ptr Application)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
app
    CString
result <- Ptr Application -> IO CString
wnck_application_get_icon_name Ptr Application
app'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"applicationGetIconName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
app
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(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 t'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 :: a -> m Pixbuf
applicationGetMiniIcon a
app = IO Pixbuf -> m Pixbuf
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Pixbuf -> m Pixbuf) -> IO Pixbuf -> m Pixbuf
forall a b. (a -> b) -> a -> b
$ do
    Ptr Application
app' <- a -> IO (Ptr Application)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
app
    Ptr Pixbuf
result <- Ptr Application -> IO (Ptr Pixbuf)
wnck_application_get_mini_icon Ptr Application
app'
    Text -> Ptr Pixbuf -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"applicationGetMiniIcon" Ptr Pixbuf
result
    Pixbuf
result' <- ((ManagedPtr Pixbuf -> Pixbuf) -> Ptr Pixbuf -> IO Pixbuf
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Pixbuf -> Pixbuf
GdkPixbuf.Pixbuf.Pixbuf) Ptr Pixbuf
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
app
    Pixbuf -> IO Pixbuf
forall (m :: * -> *) a. Monad m => a -> m a
return Pixbuf
result'

#if defined(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 t'GI.Wnck.Objects.Window.Window' belonging to /@app@/.
applicationGetNWindows ::
    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>
    a
    -- ^ /@app@/: a t'GI.Wnck.Objects.Application.Application'.
    -> m Int32
    -- ^ __Returns:__ the number of t'GI.Wnck.Objects.Window.Window' belonging to /@app@/.
applicationGetNWindows :: a -> m Int32
applicationGetNWindows a
app = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Application
app' <- a -> IO (Ptr Application)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
app
    Int32
result <- Ptr Application -> IO Int32
wnck_application_get_n_windows Ptr Application
app'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
app
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(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 t'GI.Wnck.Objects.Application.Application'.
    -> m T.Text
    -- ^ __Returns:__ the name of /@app@/, or a fallback name if no name is available.
applicationGetName :: a -> m Text
applicationGetName a
app = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Application
app' <- a -> IO (Ptr Application)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
app
    CString
result <- Ptr Application -> IO CString
wnck_application_get_name Ptr Application
app'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"applicationGetName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
app
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(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 t'GI.Wnck.Objects.Application.Application'.
    -> m Int32
    -- ^ __Returns:__ the process ID of /@app@/, or 0 if none is available.
applicationGetPid :: a -> m Int32
applicationGetPid a
app = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Application
app' <- a -> IO (Ptr Application)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
app
    Int32
result <- Ptr Application -> IO Int32
wnck_application_get_pid Ptr Application
app'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
app
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(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 t'GI.Wnck.Objects.Application.Application'.
    -> m T.Text
    -- ^ __Returns:__ the startup sequence ID used for startup notification of /@app@/,
    -- or 'P.Nothing' if none is available.
applicationGetStartupId :: a -> m Text
applicationGetStartupId a
app = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Application
app' <- a -> IO (Ptr Application)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
app
    CString
result <- Ptr Application -> IO CString
wnck_application_get_startup_id Ptr Application
app'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"applicationGetStartupId" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
app
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(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 t'GI.Wnck.Objects.Window.Window' belonging to /@app@/.
applicationGetWindows ::
    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>
    a
    -- ^ /@app@/: a t'GI.Wnck.Objects.Application.Application'.
    -> m [Wnck.Window.Window]
    -- ^ __Returns:__ the list of
    -- t'GI.Wnck.Objects.Window.Window' belonging to /@app@/, or 'P.Nothing' if the application contains no
    -- window. The list should not be modified nor freed, as it is owned by /@app@/.
applicationGetWindows :: a -> m [Window]
applicationGetWindows a
app = IO [Window] -> m [Window]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Window] -> m [Window]) -> IO [Window] -> m [Window]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Application
app' <- a -> IO (Ptr Application)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
app
    Ptr (GList (Ptr Window))
result <- Ptr Application -> IO (Ptr (GList (Ptr Window)))
wnck_application_get_windows Ptr Application
app'
    [Ptr Window]
result' <- Ptr (GList (Ptr Window)) -> IO [Ptr Window]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Window))
result
    [Window]
result'' <- (Ptr Window -> IO Window) -> [Ptr Window] -> IO [Window]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr Window -> Window) -> Ptr Window -> IO Window
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Window -> Window
Wnck.Window.Window) [Ptr Window]
result'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
app
    [Window] -> IO [Window]
forall (m :: * -> *) a. Monad m => a -> m a
return [Window]
result''

#if defined(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 t'GI.Wnck.Objects.Application.Application'.
    -> m CULong
    -- ^ __Returns:__ the X window ID of the group leader window for /@app@/.
applicationGetXid :: a -> m SignalHandlerId
applicationGetXid a
app = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    Ptr Application
app' <- a -> IO (Ptr Application)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
app
    SignalHandlerId
result <- Ptr Application -> IO SignalHandlerId
wnck_application_get_xid Ptr Application
app'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
app
    SignalHandlerId -> IO SignalHandlerId
forall (m :: * -> *) a. Monad m => a -> m a
return SignalHandlerId
result

#if defined(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 t'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 t'GI.Wnck.Objects.Application.Application' corresponding to
    -- /@xwindow@/, or 'P.Nothing' if there no such t'GI.Wnck.Objects.Application.Application' could be found. The
    -- returned t'GI.Wnck.Objects.Application.Application' is owned by libwnck and must not be referenced or
    -- unreferenced.
applicationGet :: SignalHandlerId -> m Application
applicationGet SignalHandlerId
xwindow = IO Application -> m Application
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Application -> m Application)
-> IO Application -> m Application
forall a b. (a -> b) -> a -> b
$ do
    Ptr Application
result <- SignalHandlerId -> IO (Ptr Application)
wnck_application_get SignalHandlerId
xwindow
    Text -> Ptr Application -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"applicationGet" Ptr Application
result
    Application
result' <- ((ManagedPtr Application -> Application)
-> Ptr Application -> IO Application
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Application -> Application
Application) Ptr Application
result
    Application -> IO Application
forall (m :: * -> *) a. Monad m => a -> m a
return Application
result'

#if defined(ENABLE_OVERLOADING)
#endif