{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Gtk.Objects.StringObject
    ( 

-- * Exported types
    StringObject(..)                        ,
    IsStringObject                          ,
    toStringObject                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getString]("GI.Gtk.Objects.StringObject#g:method:getString").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveStringObjectMethod               ,
#endif

-- ** getString #method:getString#

#if defined(ENABLE_OVERLOADING)
    StringObjectGetStringMethodInfo         ,
#endif
    stringObjectGetString                   ,


-- ** new #method:new#

    stringObjectNew                         ,




 -- * Properties


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

#if defined(ENABLE_OVERLOADING)
    StringObjectStringPropertyInfo          ,
#endif
    getStringObjectString                   ,
#if defined(ENABLE_OVERLOADING)
    stringObjectString                      ,
#endif




    ) 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.GArray as B.GArray
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 GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "gtk_string_object_get_type"
    c_gtk_string_object_get_type :: IO B.Types.GType

instance B.Types.TypedObject StringObject where
    glibType :: IO GType
glibType = IO GType
c_gtk_string_object_get_type

instance B.Types.GObject StringObject

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

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

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

-- | Convert 'StringObject' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe StringObject) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_string_object_get_type
    gvalueSet_ :: Ptr GValue -> Maybe StringObject -> IO ()
gvalueSet_ Ptr GValue
gv Maybe StringObject
P.Nothing = Ptr GValue -> Ptr StringObject -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr StringObject
forall a. Ptr a
FP.nullPtr :: FP.Ptr StringObject)
    gvalueSet_ Ptr GValue
gv (P.Just StringObject
obj) = StringObject -> (Ptr StringObject -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr StringObject
obj (Ptr GValue -> Ptr StringObject -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe StringObject)
gvalueGet_ Ptr GValue
gv = do
        Ptr StringObject
ptr <- Ptr GValue -> IO (Ptr StringObject)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr StringObject)
        if Ptr StringObject
ptr Ptr StringObject -> Ptr StringObject -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr StringObject
forall a. Ptr a
FP.nullPtr
        then StringObject -> Maybe StringObject
forall a. a -> Maybe a
P.Just (StringObject -> Maybe StringObject)
-> IO StringObject -> IO (Maybe StringObject)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr StringObject -> StringObject)
-> Ptr StringObject -> IO StringObject
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr StringObject -> StringObject
StringObject Ptr StringObject
ptr
        else Maybe StringObject -> IO (Maybe StringObject)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StringObject
forall a. Maybe a
P.Nothing
        
    

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

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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveStringObjectMethod t StringObject, O.OverloadedMethod info StringObject p, R.HasField t StringObject p) => R.HasField t StringObject p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveStringObjectMethod t StringObject, O.OverloadedMethodInfo info StringObject) => OL.IsLabel t (O.MethodProxy info StringObject) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- VVV Prop "string"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@string@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' stringObject #string
-- @
getStringObjectString :: (MonadIO m, IsStringObject o) => o -> m T.Text
getStringObjectString :: forall (m :: * -> *) o.
(MonadIO m, IsStringObject o) =>
o -> m Text
getStringObjectString o
obj = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getStringObjectString" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"string"

#if defined(ENABLE_OVERLOADING)
data StringObjectStringPropertyInfo
instance AttrInfo StringObjectStringPropertyInfo where
    type AttrAllowedOps StringObjectStringPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint StringObjectStringPropertyInfo = IsStringObject
    type AttrSetTypeConstraint StringObjectStringPropertyInfo = (~) ()
    type AttrTransferTypeConstraint StringObjectStringPropertyInfo = (~) ()
    type AttrTransferType StringObjectStringPropertyInfo = ()
    type AttrGetType StringObjectStringPropertyInfo = T.Text
    type AttrLabel StringObjectStringPropertyInfo = "string"
    type AttrOrigin StringObjectStringPropertyInfo = StringObject
    attrGet = getStringObjectString
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList StringObject
type instance O.AttributeList StringObject = StringObjectAttributeList
type StringObjectAttributeList = ('[ '("string", StringObjectStringPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
stringObjectString :: AttrLabelProxy "string"
stringObjectString = AttrLabelProxy

#endif

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

#endif

-- method StringObject::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "string"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The string to wrap" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "StringObject" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_string_object_new" gtk_string_object_new :: 
    CString ->                              -- string : TBasicType TUTF8
    IO (Ptr StringObject)

-- | Wraps a string in an object for use with t'GI.Gio.Interfaces.ListModel.ListModel'
stringObjectNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@string@/: The string to wrap
    -> m StringObject
    -- ^ __Returns:__ a new t'GI.Gtk.Objects.StringObject.StringObject'
stringObjectNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m StringObject
stringObjectNew Text
string = IO StringObject -> m StringObject
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StringObject -> m StringObject)
-> IO StringObject -> m StringObject
forall a b. (a -> b) -> a -> b
$ do
    CString
string' <- Text -> IO CString
textToCString Text
string
    Ptr StringObject
result <- CString -> IO (Ptr StringObject)
gtk_string_object_new CString
string'
    Text -> Ptr StringObject -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringObjectNew" Ptr StringObject
result
    StringObject
result' <- ((ManagedPtr StringObject -> StringObject)
-> Ptr StringObject -> IO StringObject
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr StringObject -> StringObject
StringObject) Ptr StringObject
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
string'
    StringObject -> IO StringObject
forall (m :: * -> *) a. Monad m => a -> m a
return StringObject
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method StringObject::get_string
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "StringObject" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkStringObject" , 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 "gtk_string_object_get_string" gtk_string_object_get_string :: 
    Ptr StringObject ->                     -- self : TInterface (Name {namespace = "Gtk", name = "StringObject"})
    IO CString

-- | Returns the string contained in a t'GI.Gtk.Objects.StringObject.StringObject'.
stringObjectGetString ::
    (B.CallStack.HasCallStack, MonadIO m, IsStringObject a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.StringObject.StringObject'
    -> m T.Text
    -- ^ __Returns:__ the string of /@self@/
stringObjectGetString :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStringObject a) =>
a -> m Text
stringObjectGetString a
self = 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 StringObject
self' <- a -> IO (Ptr StringObject)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr StringObject -> IO CString
gtk_string_object_get_string Ptr StringObject
self'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringObjectGetString" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data StringObjectGetStringMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsStringObject a) => O.OverloadedMethod StringObjectGetStringMethodInfo a signature where
    overloadedMethod = stringObjectGetString

instance O.OverloadedMethodInfo StringObjectGetStringMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.StringObject.stringObjectGetString",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-StringObject.html#v:stringObjectGetString"
        }


#endif