{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Gio.Objects.Emblem.Emblem' is an implementation of t'GI.Gio.Interfaces.Icon.Icon' that supports
-- having an emblem, which is an icon with additional properties.
-- It can than be added to a t'GI.Gio.Objects.EmblemedIcon.EmblemedIcon'.
-- 
-- Currently, only metainformation about the emblem\'s origin is
-- supported. More may be added in the future.

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

module GI.Gio.Objects.Emblem
    ( 

-- * Exported types
    Emblem(..)                              ,
    IsEmblem                                ,
    toEmblem                                ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveEmblemMethod                     ,
#endif


-- ** getIcon #method:getIcon#

#if defined(ENABLE_OVERLOADING)
    EmblemGetIconMethodInfo                 ,
#endif
    emblemGetIcon                           ,


-- ** getOrigin #method:getOrigin#

#if defined(ENABLE_OVERLOADING)
    EmblemGetOriginMethodInfo               ,
#endif
    emblemGetOrigin                         ,


-- ** new #method:new#

    emblemNew                               ,


-- ** newWithOrigin #method:newWithOrigin#

    emblemNewWithOrigin                     ,




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

#if defined(ENABLE_OVERLOADING)
    EmblemIconPropertyInfo                  ,
#endif
    constructEmblemIcon                     ,
#if defined(ENABLE_OVERLOADING)
    emblemIcon                              ,
#endif
    getEmblemIcon                           ,


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

#if defined(ENABLE_OVERLOADING)
    EmblemOriginPropertyInfo                ,
#endif
    constructEmblemOrigin                   ,
#if defined(ENABLE_OVERLOADING)
    emblemOrigin                            ,
#endif
    getEmblemOrigin                         ,




    ) 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 {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Icon as Gio.Icon

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

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

foreign import ccall "g_emblem_get_type"
    c_g_emblem_get_type :: IO B.Types.GType

instance B.Types.TypedObject Emblem where
    glibType :: IO GType
glibType = IO GType
c_g_emblem_get_type

instance B.Types.GObject Emblem

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

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

instance O.HasParentTypes Emblem
type instance O.ParentTypes Emblem = '[GObject.Object.Object, Gio.Icon.Icon]

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

#if defined(ENABLE_OVERLOADING)
type family ResolveEmblemMethod (t :: Symbol) (o :: *) :: * where
    ResolveEmblemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveEmblemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveEmblemMethod "equal" o = Gio.Icon.IconEqualMethodInfo
    ResolveEmblemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveEmblemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveEmblemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveEmblemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveEmblemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveEmblemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveEmblemMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveEmblemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveEmblemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveEmblemMethod "serialize" o = Gio.Icon.IconSerializeMethodInfo
    ResolveEmblemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveEmblemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveEmblemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveEmblemMethod "toString" o = Gio.Icon.IconToStringMethodInfo
    ResolveEmblemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveEmblemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveEmblemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveEmblemMethod "getIcon" o = EmblemGetIconMethodInfo
    ResolveEmblemMethod "getOrigin" o = EmblemGetOriginMethodInfo
    ResolveEmblemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveEmblemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveEmblemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveEmblemMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveEmblemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveEmblemMethod l o = O.MethodResolutionFailed l o

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

#endif

-- VVV Prop "icon"
   -- Type: TInterface (Name {namespace = "GObject", name = "Object"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

-- | Construct a `GValueConstruct` with valid value for the “@icon@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructEmblemIcon :: (IsEmblem o, MIO.MonadIO m, GObject.Object.IsObject a) => a -> m (GValueConstruct o)
constructEmblemIcon :: a -> m (GValueConstruct o)
constructEmblemIcon a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"icon" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data EmblemIconPropertyInfo
instance AttrInfo EmblemIconPropertyInfo where
    type AttrAllowedOps EmblemIconPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint EmblemIconPropertyInfo = IsEmblem
    type AttrSetTypeConstraint EmblemIconPropertyInfo = GObject.Object.IsObject
    type AttrTransferTypeConstraint EmblemIconPropertyInfo = GObject.Object.IsObject
    type AttrTransferType EmblemIconPropertyInfo = GObject.Object.Object
    type AttrGetType EmblemIconPropertyInfo = (Maybe GObject.Object.Object)
    type AttrLabel EmblemIconPropertyInfo = "icon"
    type AttrOrigin EmblemIconPropertyInfo = Emblem
    attrGet = getEmblemIcon
    attrSet = undefined
    attrTransfer _ v = do
        unsafeCastTo GObject.Object.Object v
    attrConstruct = constructEmblemIcon
    attrClear = undefined
#endif

-- VVV Prop "origin"
   -- Type: TInterface (Name {namespace = "Gio", name = "EmblemOrigin"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@origin@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' emblem #origin
-- @
getEmblemOrigin :: (MonadIO m, IsEmblem o) => o -> m Gio.Enums.EmblemOrigin
getEmblemOrigin :: o -> m EmblemOrigin
getEmblemOrigin o
obj = IO EmblemOrigin -> m EmblemOrigin
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EmblemOrigin -> m EmblemOrigin)
-> IO EmblemOrigin -> m EmblemOrigin
forall a b. (a -> b) -> a -> b
$ o -> String -> IO EmblemOrigin
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"origin"

-- | Construct a `GValueConstruct` with valid value for the “@origin@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructEmblemOrigin :: (IsEmblem o, MIO.MonadIO m) => Gio.Enums.EmblemOrigin -> m (GValueConstruct o)
constructEmblemOrigin :: EmblemOrigin -> m (GValueConstruct o)
constructEmblemOrigin EmblemOrigin
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> EmblemOrigin -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"origin" EmblemOrigin
val

#if defined(ENABLE_OVERLOADING)
data EmblemOriginPropertyInfo
instance AttrInfo EmblemOriginPropertyInfo where
    type AttrAllowedOps EmblemOriginPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint EmblemOriginPropertyInfo = IsEmblem
    type AttrSetTypeConstraint EmblemOriginPropertyInfo = (~) Gio.Enums.EmblemOrigin
    type AttrTransferTypeConstraint EmblemOriginPropertyInfo = (~) Gio.Enums.EmblemOrigin
    type AttrTransferType EmblemOriginPropertyInfo = Gio.Enums.EmblemOrigin
    type AttrGetType EmblemOriginPropertyInfo = Gio.Enums.EmblemOrigin
    type AttrLabel EmblemOriginPropertyInfo = "origin"
    type AttrOrigin EmblemOriginPropertyInfo = Emblem
    attrGet = getEmblemOrigin
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructEmblemOrigin
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Emblem
type instance O.AttributeList Emblem = EmblemAttributeList
type EmblemAttributeList = ('[ '("icon", EmblemIconPropertyInfo), '("origin", EmblemOriginPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
emblemIcon :: AttrLabelProxy "icon"
emblemIcon = AttrLabelProxy

emblemOrigin :: AttrLabelProxy "origin"
emblemOrigin = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Emblem = EmblemSignalList
type EmblemSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Emblem::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "icon"
--           , argType = TInterface Name { namespace = "Gio" , name = "Icon" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a GIcon containing the icon."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "Emblem" })
-- throws : False
-- Skip return : False

foreign import ccall "g_emblem_new" g_emblem_new :: 
    Ptr Gio.Icon.Icon ->                    -- icon : TInterface (Name {namespace = "Gio", name = "Icon"})
    IO (Ptr Emblem)

-- | Creates a new emblem for /@icon@/.
-- 
-- /Since: 2.18/
emblemNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Icon.IsIcon a) =>
    a
    -- ^ /@icon@/: a GIcon containing the icon.
    -> m Emblem
    -- ^ __Returns:__ a new t'GI.Gio.Objects.Emblem.Emblem'.
emblemNew :: a -> m Emblem
emblemNew a
icon = IO Emblem -> m Emblem
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Emblem -> m Emblem) -> IO Emblem -> m Emblem
forall a b. (a -> b) -> a -> b
$ do
    Ptr Icon
icon' <- a -> IO (Ptr Icon)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
icon
    Ptr Emblem
result <- Ptr Icon -> IO (Ptr Emblem)
g_emblem_new Ptr Icon
icon'
    Text -> Ptr Emblem -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"emblemNew" Ptr Emblem
result
    Emblem
result' <- ((ManagedPtr Emblem -> Emblem) -> Ptr Emblem -> IO Emblem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Emblem -> Emblem
Emblem) Ptr Emblem
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
icon
    Emblem -> IO Emblem
forall (m :: * -> *) a. Monad m => a -> m a
return Emblem
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Emblem::new_with_origin
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "icon"
--           , argType = TInterface Name { namespace = "Gio" , name = "Icon" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a GIcon containing the icon."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "origin"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "EmblemOrigin" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a GEmblemOrigin enum defining the emblem's origin"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "Emblem" })
-- throws : False
-- Skip return : False

foreign import ccall "g_emblem_new_with_origin" g_emblem_new_with_origin :: 
    Ptr Gio.Icon.Icon ->                    -- icon : TInterface (Name {namespace = "Gio", name = "Icon"})
    CUInt ->                                -- origin : TInterface (Name {namespace = "Gio", name = "EmblemOrigin"})
    IO (Ptr Emblem)

-- | Creates a new emblem for /@icon@/.
-- 
-- /Since: 2.18/
emblemNewWithOrigin ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Icon.IsIcon a) =>
    a
    -- ^ /@icon@/: a GIcon containing the icon.
    -> Gio.Enums.EmblemOrigin
    -- ^ /@origin@/: a GEmblemOrigin enum defining the emblem\'s origin
    -> m Emblem
    -- ^ __Returns:__ a new t'GI.Gio.Objects.Emblem.Emblem'.
emblemNewWithOrigin :: a -> EmblemOrigin -> m Emblem
emblemNewWithOrigin a
icon EmblemOrigin
origin = IO Emblem -> m Emblem
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Emblem -> m Emblem) -> IO Emblem -> m Emblem
forall a b. (a -> b) -> a -> b
$ do
    Ptr Icon
icon' <- a -> IO (Ptr Icon)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
icon
    let origin' :: CUInt
origin' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (EmblemOrigin -> Int) -> EmblemOrigin -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EmblemOrigin -> Int
forall a. Enum a => a -> Int
fromEnum) EmblemOrigin
origin
    Ptr Emblem
result <- Ptr Icon -> CUInt -> IO (Ptr Emblem)
g_emblem_new_with_origin Ptr Icon
icon' CUInt
origin'
    Text -> Ptr Emblem -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"emblemNewWithOrigin" Ptr Emblem
result
    Emblem
result' <- ((ManagedPtr Emblem -> Emblem) -> Ptr Emblem -> IO Emblem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Emblem -> Emblem
Emblem) Ptr Emblem
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
icon
    Emblem -> IO Emblem
forall (m :: * -> *) a. Monad m => a -> m a
return Emblem
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Emblem::get_icon
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "emblem"
--           , argType = TInterface Name { namespace = "Gio" , name = "Emblem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GEmblem from which the icon should be extracted."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "Icon" })
-- throws : False
-- Skip return : False

foreign import ccall "g_emblem_get_icon" g_emblem_get_icon :: 
    Ptr Emblem ->                           -- emblem : TInterface (Name {namespace = "Gio", name = "Emblem"})
    IO (Ptr Gio.Icon.Icon)

-- | Gives back the icon from /@emblem@/.
-- 
-- /Since: 2.18/
emblemGetIcon ::
    (B.CallStack.HasCallStack, MonadIO m, IsEmblem a) =>
    a
    -- ^ /@emblem@/: a t'GI.Gio.Objects.Emblem.Emblem' from which the icon should be extracted.
    -> m Gio.Icon.Icon
    -- ^ __Returns:__ a t'GI.Gio.Interfaces.Icon.Icon'. The returned object belongs to
    --          the emblem and should not be modified or freed.
emblemGetIcon :: a -> m Icon
emblemGetIcon a
emblem = IO Icon -> m Icon
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Icon -> m Icon) -> IO Icon -> m Icon
forall a b. (a -> b) -> a -> b
$ do
    Ptr Emblem
emblem' <- a -> IO (Ptr Emblem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
emblem
    Ptr Icon
result <- Ptr Emblem -> IO (Ptr Icon)
g_emblem_get_icon Ptr Emblem
emblem'
    Text -> Ptr Icon -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"emblemGetIcon" Ptr Icon
result
    Icon
result' <- ((ManagedPtr Icon -> Icon) -> Ptr Icon -> IO Icon
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Icon -> Icon
Gio.Icon.Icon) Ptr Icon
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
emblem
    Icon -> IO Icon
forall (m :: * -> *) a. Monad m => a -> m a
return Icon
result'

#if defined(ENABLE_OVERLOADING)
data EmblemGetIconMethodInfo
instance (signature ~ (m Gio.Icon.Icon), MonadIO m, IsEmblem a) => O.MethodInfo EmblemGetIconMethodInfo a signature where
    overloadedMethod = emblemGetIcon

#endif

-- method Emblem::get_origin
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "emblem"
--           , argType = TInterface Name { namespace = "Gio" , name = "Emblem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GEmblem" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gio" , name = "EmblemOrigin" })
-- throws : False
-- Skip return : False

foreign import ccall "g_emblem_get_origin" g_emblem_get_origin :: 
    Ptr Emblem ->                           -- emblem : TInterface (Name {namespace = "Gio", name = "Emblem"})
    IO CUInt

-- | Gets the origin of the emblem.
-- 
-- /Since: 2.18/
emblemGetOrigin ::
    (B.CallStack.HasCallStack, MonadIO m, IsEmblem a) =>
    a
    -- ^ /@emblem@/: a t'GI.Gio.Objects.Emblem.Emblem'
    -> m Gio.Enums.EmblemOrigin
    -- ^ __Returns:__ the origin of the emblem
emblemGetOrigin :: a -> m EmblemOrigin
emblemGetOrigin a
emblem = IO EmblemOrigin -> m EmblemOrigin
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EmblemOrigin -> m EmblemOrigin)
-> IO EmblemOrigin -> m EmblemOrigin
forall a b. (a -> b) -> a -> b
$ do
    Ptr Emblem
emblem' <- a -> IO (Ptr Emblem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
emblem
    CUInt
result <- Ptr Emblem -> IO CUInt
g_emblem_get_origin Ptr Emblem
emblem'
    let result' :: EmblemOrigin
result' = (Int -> EmblemOrigin
forall a. Enum a => Int -> a
toEnum (Int -> EmblemOrigin) -> (CUInt -> Int) -> CUInt -> EmblemOrigin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
emblem
    EmblemOrigin -> IO EmblemOrigin
forall (m :: * -> *) a. Monad m => a -> m a
return EmblemOrigin
result'

#if defined(ENABLE_OVERLOADING)
data EmblemGetOriginMethodInfo
instance (signature ~ (m Gio.Enums.EmblemOrigin), MonadIO m, IsEmblem a) => O.MethodInfo EmblemGetOriginMethodInfo a signature where
    overloadedMethod = emblemGetOrigin

#endif