{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.StringObject
(
StringObject(..) ,
IsStringObject ,
toStringObject ,
#if defined(ENABLE_OVERLOADING)
ResolveStringObjectMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
StringObjectGetStringMethodInfo ,
#endif
stringObjectGetString ,
stringObjectNew ,
#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
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
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]
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
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
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
foreign import ccall "gtk_string_object_new" gtk_string_object_new ::
CString ->
IO (Ptr StringObject)
stringObjectNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m 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
foreign import ccall "gtk_string_object_get_string" gtk_string_object_get_string ::
Ptr StringObject ->
IO CString
stringObjectGetString ::
(B.CallStack.HasCallStack, MonadIO m, IsStringObject a) =>
a
-> m T.Text
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