{-# 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.Interfaces.Icon.Icon' is a very minimal interface for icons. It provides functions
-- for checking the equality of two icons, hashing of icons and
-- serializing an icon to and from strings.
-- 
-- t'GI.Gio.Interfaces.Icon.Icon' does not provide the actual pixmap for the icon as this is out
-- of GIO\'s scope, however implementations of t'GI.Gio.Interfaces.Icon.Icon' may contain the name
-- of an icon (see t'GI.Gio.Objects.ThemedIcon.ThemedIcon'), or the path to an icon (see t'GI.Gio.Interfaces.LoadableIcon.LoadableIcon').
-- 
-- To obtain a hash of a t'GI.Gio.Interfaces.Icon.Icon', see 'GI.Gio.Functions.iconHash'.
-- 
-- To check if two @/GIcons/@ are equal, see 'GI.Gio.Interfaces.Icon.iconEqual'.
-- 
-- For serializing a t'GI.Gio.Interfaces.Icon.Icon', use 'GI.Gio.Interfaces.Icon.iconSerialize' and
-- 'GI.Gio.Functions.iconDeserialize'.
-- 
-- If you want to consume t'GI.Gio.Interfaces.Icon.Icon' (for example, in a toolkit) you must
-- be prepared to handle at least the three following cases:
-- t'GI.Gio.Interfaces.LoadableIcon.LoadableIcon', t'GI.Gio.Objects.ThemedIcon.ThemedIcon' and t'GI.Gio.Objects.EmblemedIcon.EmblemedIcon'.  It may also make
-- sense to have fast-paths for other cases (like handling @/GdkPixbuf/@
-- directly, for example) but all compliant t'GI.Gio.Interfaces.Icon.Icon' implementations
-- outside of GIO must implement t'GI.Gio.Interfaces.LoadableIcon.LoadableIcon'.
-- 
-- If your application or library provides one or more t'GI.Gio.Interfaces.Icon.Icon'
-- implementations you need to ensure that your new implementation also
-- implements t'GI.Gio.Interfaces.LoadableIcon.LoadableIcon'.  Additionally, you must provide an
-- implementation of 'GI.Gio.Interfaces.Icon.iconSerialize' that gives a result that is
-- understood by 'GI.Gio.Functions.iconDeserialize', yielding one of the built-in icon
-- types.

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

module GI.Gio.Interfaces.Icon
    ( 

-- * Exported types
    Icon(..)                                ,
    noIcon                                  ,
    IsIcon                                  ,
    toIcon                                  ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveIconMethod                       ,
#endif


-- ** deserialize #method:deserialize#

    iconDeserialize                         ,


-- ** equal #method:equal#

#if defined(ENABLE_OVERLOADING)
    IconEqualMethodInfo                     ,
#endif
    iconEqual                               ,


-- ** hash #method:hash#

    iconHash                                ,


-- ** newForString #method:newForString#

    iconNewForString                        ,


-- ** serialize #method:serialize#

#if defined(ENABLE_OVERLOADING)
    IconSerializeMethodInfo                 ,
#endif
    iconSerialize                           ,


-- ** toString #method:toString#

#if defined(ENABLE_OVERLOADING)
    IconToStringMethodInfo                  ,
#endif
    iconToString                            ,




    ) 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.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

-- interface Icon 
-- | Memory-managed wrapper type.
newtype Icon = Icon (ManagedPtr Icon)
    deriving (Icon -> Icon -> Bool
(Icon -> Icon -> Bool) -> (Icon -> Icon -> Bool) -> Eq Icon
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Icon -> Icon -> Bool
$c/= :: Icon -> Icon -> Bool
== :: Icon -> Icon -> Bool
$c== :: Icon -> Icon -> Bool
Eq)
-- | A convenience alias for `Nothing` :: `Maybe` `Icon`.
noIcon :: Maybe Icon
noIcon :: Maybe Icon
noIcon = Maybe Icon
forall a. Maybe a
Nothing

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

#endif

foreign import ccall "g_icon_get_type"
    c_g_icon_get_type :: IO GType

instance GObject Icon where
    gobjectType :: IO GType
gobjectType = IO GType
c_g_icon_get_type
    

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
#endif

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

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

#endif

-- method Icon::equal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "icon1"
--           , argType = TInterface Name { namespace = "Gio" , name = "Icon" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "pointer to the first #GIcon."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "icon2"
--           , argType = TInterface Name { namespace = "Gio" , name = "Icon" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "pointer to the second #GIcon."
--                 , 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 "g_icon_equal" g_icon_equal :: 
    Ptr Icon ->                             -- icon1 : TInterface (Name {namespace = "Gio", name = "Icon"})
    Ptr Icon ->                             -- icon2 : TInterface (Name {namespace = "Gio", name = "Icon"})
    IO CInt

-- | Checks if two icons are equal.
iconEqual ::
    (B.CallStack.HasCallStack, MonadIO m, IsIcon a, IsIcon b) =>
    a
    -- ^ /@icon1@/: pointer to the first t'GI.Gio.Interfaces.Icon.Icon'.
    -> Maybe (b)
    -- ^ /@icon2@/: pointer to the second t'GI.Gio.Interfaces.Icon.Icon'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@icon1@/ is equal to /@icon2@/. 'P.False' otherwise.
iconEqual :: a -> Maybe b -> m Bool
iconEqual icon1 :: a
icon1 icon2 :: Maybe b
icon2 = 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 Icon
icon1' <- a -> IO (Ptr Icon)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
icon1
    Ptr Icon
maybeIcon2 <- case Maybe b
icon2 of
        Nothing -> Ptr Icon -> IO (Ptr Icon)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Icon
forall a. Ptr a
nullPtr
        Just jIcon2 :: b
jIcon2 -> do
            Ptr Icon
jIcon2' <- b -> IO (Ptr Icon)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jIcon2
            Ptr Icon -> IO (Ptr Icon)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Icon
jIcon2'
    CInt
result <- Ptr Icon -> Ptr Icon -> IO CInt
g_icon_equal Ptr Icon
icon1' Ptr Icon
maybeIcon2
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
icon1
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
icon2 b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data IconEqualMethodInfo
instance (signature ~ (Maybe (b) -> m Bool), MonadIO m, IsIcon a, IsIcon b) => O.MethodInfo IconEqualMethodInfo a signature where
    overloadedMethod = iconEqual

#endif

-- method Icon::serialize
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "icon"
--           , argType = TInterface Name { namespace = "Gio" , name = "Icon" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GIcon" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just TVariant
-- throws : False
-- Skip return : False

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

-- | Serializes a t'GI.Gio.Interfaces.Icon.Icon' into a t'GVariant'. An equivalent t'GI.Gio.Interfaces.Icon.Icon' can be retrieved
-- back by calling 'GI.Gio.Functions.iconDeserialize' on the returned value.
-- As serialization will avoid using raw icon data when possible, it only
-- makes sense to transfer the t'GVariant' between processes on the same machine,
-- (as opposed to over the network), and within the same file system namespace.
-- 
-- /Since: 2.38/
iconSerialize ::
    (B.CallStack.HasCallStack, MonadIO m, IsIcon a) =>
    a
    -- ^ /@icon@/: a t'GI.Gio.Interfaces.Icon.Icon'
    -> m GVariant
    -- ^ __Returns:__ a t'GVariant', or 'P.Nothing' when serialization fails.
iconSerialize :: a -> m GVariant
iconSerialize icon :: a
icon = IO GVariant -> m GVariant
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
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 GVariant
result <- Ptr Icon -> IO (Ptr GVariant)
g_icon_serialize Ptr Icon
icon'
    Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "iconSerialize" Ptr GVariant
result
    GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
icon
    GVariant -> IO GVariant
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'

#if defined(ENABLE_OVERLOADING)
data IconSerializeMethodInfo
instance (signature ~ (m GVariant), MonadIO m, IsIcon a) => O.MethodInfo IconSerializeMethodInfo a signature where
    overloadedMethod = iconSerialize

#endif

-- method Icon::to_string
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "icon"
--           , argType = TInterface Name { namespace = "Gio" , name = "Icon" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GIcon." , 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 "g_icon_to_string" g_icon_to_string :: 
    Ptr Icon ->                             -- icon : TInterface (Name {namespace = "Gio", name = "Icon"})
    IO CString

-- | Generates a textual representation of /@icon@/ that can be used for
-- serialization such as when passing /@icon@/ to a different process or
-- saving it to persistent storage. Use 'GI.Gio.Functions.iconNewForString' to
-- get /@icon@/ back from the returned string.
-- 
-- The encoding of the returned string is proprietary to t'GI.Gio.Interfaces.Icon.Icon' except
-- in the following two cases
-- 
-- * If /@icon@/ is a t'GI.Gio.Objects.FileIcon.FileIcon', the returned string is a native path
-- (such as @\/path\/to\/my icon.png@) without escaping
-- if the t'GI.Gio.Interfaces.File.File' for /@icon@/ is a native file.  If the file is not
-- native, the returned string is the result of 'GI.Gio.Interfaces.File.fileGetUri'
-- (such as @sftp:\/\/path\/to\/my%20icon.png@).
-- * If /@icon@/ is a t'GI.Gio.Objects.ThemedIcon.ThemedIcon' with exactly one name and no fallbacks,
-- the encoding is simply the name (such as @network-server@).
-- 
-- 
-- /Since: 2.20/
iconToString ::
    (B.CallStack.HasCallStack, MonadIO m, IsIcon a) =>
    a
    -- ^ /@icon@/: a t'GI.Gio.Interfaces.Icon.Icon'.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ An allocated NUL-terminated UTF8 string or
    -- 'P.Nothing' if /@icon@/ can\'t be serialized. Use 'GI.GLib.Functions.free' to free.
iconToString :: a -> m (Maybe Text)
iconToString icon :: a
icon = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Icon
icon' <- a -> IO (Ptr Icon)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
icon
    CString
result <- Ptr Icon -> IO CString
g_icon_to_string Ptr Icon
icon'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
icon
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data IconToStringMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsIcon a) => O.MethodInfo IconToStringMethodInfo a signature where
    overloadedMethod = iconToString

#endif

-- method Icon::deserialize
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "value"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GVariant created with g_icon_serialize()"
--                 , 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_icon_deserialize" g_icon_deserialize :: 
    Ptr GVariant ->                         -- value : TVariant
    IO (Ptr Icon)

-- | Deserializes a t'GI.Gio.Interfaces.Icon.Icon' previously serialized using 'GI.Gio.Interfaces.Icon.iconSerialize'.
-- 
-- /Since: 2.38/
iconDeserialize ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GVariant
    -- ^ /@value@/: a t'GVariant' created with 'GI.Gio.Interfaces.Icon.iconSerialize'
    -> m Icon
    -- ^ __Returns:__ a t'GI.Gio.Interfaces.Icon.Icon', or 'P.Nothing' when deserialization fails.
iconDeserialize :: GVariant -> m Icon
iconDeserialize value :: GVariant
value = 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 GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
    Ptr Icon
result <- Ptr GVariant -> IO (Ptr Icon)
g_icon_deserialize Ptr GVariant
value'
    Text -> Ptr Icon -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "iconDeserialize" 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
wrapObject ManagedPtr Icon -> Icon
Icon) Ptr Icon
result
    GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
    Icon -> IO Icon
forall (m :: * -> *) a. Monad m => a -> m a
return Icon
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Icon::hash
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "icon"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#gconstpointer to an icon object."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_icon_hash" g_icon_hash :: 
    Ptr () ->                               -- icon : TBasicType TPtr
    IO Word32

-- | Gets a hash for an icon.
iconHash ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Ptr ()
    -- ^ /@icon@/: @/gconstpointer/@ to an icon object.
    -> m Word32
    -- ^ __Returns:__ a @/guint/@ containing a hash for the /@icon@/, suitable for
    -- use in a t'GI.GLib.Structs.HashTable.HashTable' or similar data structure.
iconHash :: Ptr () -> m Word32
iconHash icon :: Ptr ()
icon = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Word32
result <- Ptr () -> IO Word32
g_icon_hash Ptr ()
icon
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
#endif

-- method Icon::new_for_string
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "str"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A string obtained via g_icon_to_string()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "Icon" })
-- throws : True
-- Skip return : False

foreign import ccall "g_icon_new_for_string" g_icon_new_for_string :: 
    CString ->                              -- str : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Icon)

-- | Generate a t'GI.Gio.Interfaces.Icon.Icon' instance from /@str@/. This function can fail if
-- /@str@/ is not valid - see 'GI.Gio.Interfaces.Icon.iconToString' for discussion.
-- 
-- If your application or library provides one or more t'GI.Gio.Interfaces.Icon.Icon'
-- implementations you need to ensure that each t'GType' is registered
-- with the type system prior to calling 'GI.Gio.Functions.iconNewForString'.
-- 
-- /Since: 2.20/
iconNewForString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@str@/: A string obtained via 'GI.Gio.Interfaces.Icon.iconToString'.
    -> m Icon
    -- ^ __Returns:__ An object implementing the t'GI.Gio.Interfaces.Icon.Icon'
    --          interface or 'P.Nothing' if /@error@/ is set. /(Can throw 'Data.GI.Base.GError.GError')/
iconNewForString :: Text -> m Icon
iconNewForString str :: Text
str = 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
    CString
str' <- Text -> IO CString
textToCString Text
str
    IO Icon -> IO () -> IO Icon
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr Icon
result <- (Ptr (Ptr GError) -> IO (Ptr Icon)) -> IO (Ptr Icon)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Icon)) -> IO (Ptr Icon))
-> (Ptr (Ptr GError) -> IO (Ptr Icon)) -> IO (Ptr Icon)
forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO (Ptr Icon)
g_icon_new_for_string CString
str'
        Text -> Ptr Icon -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "iconNewForString" 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
wrapObject ManagedPtr Icon -> Icon
Icon) Ptr Icon
result
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
        Icon -> IO Icon
forall (m :: * -> *) a. Monad m => a -> m a
return Icon
result'
     ) (do
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
     )

#if defined(ENABLE_OVERLOADING)
#endif