{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) A 'GI.Gtk.Structs.TargetEntry.TargetEntry' represents a single type of data than can be supplied for by a widget for a selection or for supplied or received during drag-and-drop. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gtk.Structs.TargetEntry ( -- * Exported types TargetEntry(..) , newZeroTargetEntry , noTargetEntry , -- * Methods -- ** copy #method:copy# #if ENABLE_OVERLOADING TargetEntryCopyMethodInfo , #endif targetEntryCopy , -- ** free #method:free# #if ENABLE_OVERLOADING TargetEntryFreeMethodInfo , #endif targetEntryFree , -- ** new #method:new# targetEntryNew , -- * Properties -- ** flags #attr:flags# {- | 'GI.Gtk.Flags.TargetFlags' for DND -} getTargetEntryFlags , setTargetEntryFlags , #if ENABLE_OVERLOADING targetEntry_flags , #endif -- ** info #attr:info# {- | an application-assigned integer ID which will get passed as a parameter to e.g the 'GI.Gtk.Objects.Widget.Widget'::@/selection-get/@ signal. It allows the application to identify the target type without extensive string compares. -} getTargetEntryInfo , setTargetEntryInfo , #if ENABLE_OVERLOADING targetEntry_info , #endif -- ** target #attr:target# {- | a string representation of the target type -} clearTargetEntryTarget , getTargetEntryTarget , setTargetEntryTarget , #if ENABLE_OVERLOADING targetEntry_target , #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.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.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 -- | Memory-managed wrapper type. newtype TargetEntry = TargetEntry (ManagedPtr TargetEntry) foreign import ccall "gtk_target_entry_get_type" c_gtk_target_entry_get_type :: IO GType instance BoxedObject TargetEntry where boxedType _ = c_gtk_target_entry_get_type -- | Construct a `TargetEntry` struct initialized to zero. newZeroTargetEntry :: MonadIO m => m TargetEntry newZeroTargetEntry = liftIO $ callocBoxedBytes 16 >>= wrapBoxed TargetEntry instance tag ~ 'AttrSet => Constructible TargetEntry tag where new _ attrs = do o <- newZeroTargetEntry GI.Attributes.set o attrs return o -- | A convenience alias for `Nothing` :: `Maybe` `TargetEntry`. noTargetEntry :: Maybe TargetEntry noTargetEntry = Nothing {- | Get the value of the “@target@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' targetEntry #target @ -} getTargetEntryTarget :: MonadIO m => TargetEntry -> m (Maybe T.Text) getTargetEntryTarget s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO CString result <- SP.convertIfNonNull val $ \val' -> do val'' <- cstringToText val' return val'' return result {- | Set the value of the “@target@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' targetEntry [ #target 'Data.GI.Base.Attributes.:=' value ] @ -} setTargetEntryTarget :: MonadIO m => TargetEntry -> CString -> m () setTargetEntryTarget s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (val :: CString) {- | Set the value of the “@target@” field to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #target @ -} clearTargetEntryTarget :: MonadIO m => TargetEntry -> m () clearTargetEntryTarget s = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (FP.nullPtr :: CString) #if ENABLE_OVERLOADING data TargetEntryTargetFieldInfo instance AttrInfo TargetEntryTargetFieldInfo where type AttrAllowedOps TargetEntryTargetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint TargetEntryTargetFieldInfo = (~) CString type AttrBaseTypeConstraint TargetEntryTargetFieldInfo = (~) TargetEntry type AttrGetType TargetEntryTargetFieldInfo = Maybe T.Text type AttrLabel TargetEntryTargetFieldInfo = "target" type AttrOrigin TargetEntryTargetFieldInfo = TargetEntry attrGet _ = getTargetEntryTarget attrSet _ = setTargetEntryTarget attrConstruct = undefined attrClear _ = clearTargetEntryTarget targetEntry_target :: AttrLabelProxy "target" targetEntry_target = AttrLabelProxy #endif {- | Get the value of the “@flags@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' targetEntry #flags @ -} getTargetEntryFlags :: MonadIO m => TargetEntry -> m Word32 getTargetEntryFlags s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 8) :: IO Word32 return val {- | Set the value of the “@flags@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' targetEntry [ #flags 'Data.GI.Base.Attributes.:=' value ] @ -} setTargetEntryFlags :: MonadIO m => TargetEntry -> Word32 -> m () setTargetEntryFlags s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 8) (val :: Word32) #if ENABLE_OVERLOADING data TargetEntryFlagsFieldInfo instance AttrInfo TargetEntryFlagsFieldInfo where type AttrAllowedOps TargetEntryFlagsFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint TargetEntryFlagsFieldInfo = (~) Word32 type AttrBaseTypeConstraint TargetEntryFlagsFieldInfo = (~) TargetEntry type AttrGetType TargetEntryFlagsFieldInfo = Word32 type AttrLabel TargetEntryFlagsFieldInfo = "flags" type AttrOrigin TargetEntryFlagsFieldInfo = TargetEntry attrGet _ = getTargetEntryFlags attrSet _ = setTargetEntryFlags attrConstruct = undefined attrClear _ = undefined targetEntry_flags :: AttrLabelProxy "flags" targetEntry_flags = AttrLabelProxy #endif {- | Get the value of the “@info@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' targetEntry #info @ -} getTargetEntryInfo :: MonadIO m => TargetEntry -> m Word32 getTargetEntryInfo s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 12) :: IO Word32 return val {- | Set the value of the “@info@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' targetEntry [ #info 'Data.GI.Base.Attributes.:=' value ] @ -} setTargetEntryInfo :: MonadIO m => TargetEntry -> Word32 -> m () setTargetEntryInfo s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 12) (val :: Word32) #if ENABLE_OVERLOADING data TargetEntryInfoFieldInfo instance AttrInfo TargetEntryInfoFieldInfo where type AttrAllowedOps TargetEntryInfoFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint TargetEntryInfoFieldInfo = (~) Word32 type AttrBaseTypeConstraint TargetEntryInfoFieldInfo = (~) TargetEntry type AttrGetType TargetEntryInfoFieldInfo = Word32 type AttrLabel TargetEntryInfoFieldInfo = "info" type AttrOrigin TargetEntryInfoFieldInfo = TargetEntry attrGet _ = getTargetEntryInfo attrSet _ = setTargetEntryInfo attrConstruct = undefined attrClear _ = undefined targetEntry_info :: AttrLabelProxy "info" targetEntry_info = AttrLabelProxy #endif #if ENABLE_OVERLOADING instance O.HasAttributeList TargetEntry type instance O.AttributeList TargetEntry = TargetEntryAttributeList type TargetEntryAttributeList = ('[ '("target", TargetEntryTargetFieldInfo), '("flags", TargetEntryFlagsFieldInfo), '("info", TargetEntryInfoFieldInfo)] :: [(Symbol, *)]) #endif -- method TargetEntry::new -- method type : Constructor -- Args : [Arg {argCName = "target", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "String identifier for target", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Set of flags, see #GtkTargetFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an ID that will be passed back to the application", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TargetEntry"})) -- throws : False -- Skip return : False foreign import ccall "gtk_target_entry_new" gtk_target_entry_new :: CString -> -- target : TBasicType TUTF8 Word32 -> -- flags : TBasicType TUInt Word32 -> -- info : TBasicType TUInt IO (Ptr TargetEntry) {- | Makes a new 'GI.Gtk.Structs.TargetEntry.TargetEntry'. -} targetEntryNew :: (B.CallStack.HasCallStack, MonadIO m) => T.Text {- ^ /@target@/: String identifier for target -} -> Word32 {- ^ /@flags@/: Set of flags, see 'GI.Gtk.Flags.TargetFlags' -} -> Word32 {- ^ /@info@/: an ID that will be passed back to the application -} -> m TargetEntry {- ^ __Returns:__ a pointer to a new 'GI.Gtk.Structs.TargetEntry.TargetEntry'. Free with 'GI.Gtk.Structs.TargetEntry.targetEntryFree' -} targetEntryNew target flags info = liftIO $ do target' <- textToCString target result <- gtk_target_entry_new target' flags info checkUnexpectedReturnNULL "targetEntryNew" result result' <- (wrapBoxed TargetEntry) result freeMem target' return result' #if ENABLE_OVERLOADING #endif -- method TargetEntry::copy -- method type : OrdinaryMethod -- Args : [Arg {argCName = "data", argType = TInterface (Name {namespace = "Gtk", name = "TargetEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GtkTargetEntry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TargetEntry"})) -- throws : False -- Skip return : False foreign import ccall "gtk_target_entry_copy" gtk_target_entry_copy :: Ptr TargetEntry -> -- data : TInterface (Name {namespace = "Gtk", name = "TargetEntry"}) IO (Ptr TargetEntry) {- | Makes a copy of a 'GI.Gtk.Structs.TargetEntry.TargetEntry' and its data. -} targetEntryCopy :: (B.CallStack.HasCallStack, MonadIO m) => TargetEntry {- ^ /@data@/: a pointer to a 'GI.Gtk.Structs.TargetEntry.TargetEntry' -} -> m TargetEntry {- ^ __Returns:__ a pointer to a copy of /@data@/. Free with 'GI.Gtk.Structs.TargetEntry.targetEntryFree' -} targetEntryCopy data_ = liftIO $ do data_' <- unsafeManagedPtrGetPtr data_ result <- gtk_target_entry_copy data_' checkUnexpectedReturnNULL "targetEntryCopy" result result' <- (wrapBoxed TargetEntry) result touchManagedPtr data_ return result' #if ENABLE_OVERLOADING data TargetEntryCopyMethodInfo instance (signature ~ (m TargetEntry), MonadIO m) => O.MethodInfo TargetEntryCopyMethodInfo TargetEntry signature where overloadedMethod _ = targetEntryCopy #endif -- method TargetEntry::free -- method type : OrdinaryMethod -- Args : [Arg {argCName = "data", argType = TInterface (Name {namespace = "Gtk", name = "TargetEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GtkTargetEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_target_entry_free" gtk_target_entry_free :: Ptr TargetEntry -> -- data : TInterface (Name {namespace = "Gtk", name = "TargetEntry"}) IO () {- | Frees a 'GI.Gtk.Structs.TargetEntry.TargetEntry' returned from 'GI.Gtk.Structs.TargetEntry.targetEntryNew' or 'GI.Gtk.Structs.TargetEntry.targetEntryCopy'. -} targetEntryFree :: (B.CallStack.HasCallStack, MonadIO m) => TargetEntry {- ^ /@data@/: a pointer to a 'GI.Gtk.Structs.TargetEntry.TargetEntry'. -} -> m () targetEntryFree data_ = liftIO $ do data_' <- unsafeManagedPtrGetPtr data_ gtk_target_entry_free data_' touchManagedPtr data_ return () #if ENABLE_OVERLOADING data TargetEntryFreeMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo TargetEntryFreeMethodInfo TargetEntry signature where overloadedMethod _ = targetEntryFree #endif #if ENABLE_OVERLOADING type family ResolveTargetEntryMethod (t :: Symbol) (o :: *) :: * where ResolveTargetEntryMethod "copy" o = TargetEntryCopyMethodInfo ResolveTargetEntryMethod "free" o = TargetEntryFreeMethodInfo ResolveTargetEntryMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveTargetEntryMethod t TargetEntry, O.MethodInfo info TargetEntry p) => OL.IsLabel t (TargetEntry -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif