{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.ListItem
(
ListItem(..) ,
IsListItem ,
toListItem ,
#if defined(ENABLE_OVERLOADING)
ResolveListItemMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ListItemGetAccessibleDescriptionMethodInfo,
#endif
listItemGetAccessibleDescription ,
#if defined(ENABLE_OVERLOADING)
ListItemGetAccessibleLabelMethodInfo ,
#endif
listItemGetAccessibleLabel ,
#if defined(ENABLE_OVERLOADING)
ListItemGetActivatableMethodInfo ,
#endif
listItemGetActivatable ,
#if defined(ENABLE_OVERLOADING)
ListItemGetChildMethodInfo ,
#endif
listItemGetChild ,
#if defined(ENABLE_OVERLOADING)
ListItemGetFocusableMethodInfo ,
#endif
listItemGetFocusable ,
#if defined(ENABLE_OVERLOADING)
ListItemGetItemMethodInfo ,
#endif
listItemGetItem ,
#if defined(ENABLE_OVERLOADING)
ListItemGetPositionMethodInfo ,
#endif
listItemGetPosition ,
#if defined(ENABLE_OVERLOADING)
ListItemGetSelectableMethodInfo ,
#endif
listItemGetSelectable ,
#if defined(ENABLE_OVERLOADING)
ListItemGetSelectedMethodInfo ,
#endif
listItemGetSelected ,
#if defined(ENABLE_OVERLOADING)
ListItemSetAccessibleDescriptionMethodInfo,
#endif
listItemSetAccessibleDescription ,
#if defined(ENABLE_OVERLOADING)
ListItemSetAccessibleLabelMethodInfo ,
#endif
listItemSetAccessibleLabel ,
#if defined(ENABLE_OVERLOADING)
ListItemSetActivatableMethodInfo ,
#endif
listItemSetActivatable ,
#if defined(ENABLE_OVERLOADING)
ListItemSetChildMethodInfo ,
#endif
listItemSetChild ,
#if defined(ENABLE_OVERLOADING)
ListItemSetFocusableMethodInfo ,
#endif
listItemSetFocusable ,
#if defined(ENABLE_OVERLOADING)
ListItemSetSelectableMethodInfo ,
#endif
listItemSetSelectable ,
#if defined(ENABLE_OVERLOADING)
ListItemAccessibleDescriptionPropertyInfo,
#endif
constructListItemAccessibleDescription ,
getListItemAccessibleDescription ,
#if defined(ENABLE_OVERLOADING)
listItemAccessibleDescription ,
#endif
setListItemAccessibleDescription ,
#if defined(ENABLE_OVERLOADING)
ListItemAccessibleLabelPropertyInfo ,
#endif
constructListItemAccessibleLabel ,
getListItemAccessibleLabel ,
#if defined(ENABLE_OVERLOADING)
listItemAccessibleLabel ,
#endif
setListItemAccessibleLabel ,
#if defined(ENABLE_OVERLOADING)
ListItemActivatablePropertyInfo ,
#endif
constructListItemActivatable ,
getListItemActivatable ,
#if defined(ENABLE_OVERLOADING)
listItemActivatable ,
#endif
setListItemActivatable ,
#if defined(ENABLE_OVERLOADING)
ListItemChildPropertyInfo ,
#endif
clearListItemChild ,
constructListItemChild ,
getListItemChild ,
#if defined(ENABLE_OVERLOADING)
listItemChild ,
#endif
setListItemChild ,
#if defined(ENABLE_OVERLOADING)
ListItemFocusablePropertyInfo ,
#endif
constructListItemFocusable ,
getListItemFocusable ,
#if defined(ENABLE_OVERLOADING)
listItemFocusable ,
#endif
setListItemFocusable ,
#if defined(ENABLE_OVERLOADING)
ListItemItemPropertyInfo ,
#endif
getListItemItem ,
#if defined(ENABLE_OVERLOADING)
listItemItem ,
#endif
#if defined(ENABLE_OVERLOADING)
ListItemPositionPropertyInfo ,
#endif
getListItemPosition ,
#if defined(ENABLE_OVERLOADING)
listItemPosition ,
#endif
#if defined(ENABLE_OVERLOADING)
ListItemSelectablePropertyInfo ,
#endif
constructListItemSelectable ,
getListItemSelectable ,
#if defined(ENABLE_OVERLOADING)
listItemSelectable ,
#endif
setListItemSelectable ,
#if defined(ENABLE_OVERLOADING)
ListItemSelectedPropertyInfo ,
#endif
getListItemSelected ,
#if defined(ENABLE_OVERLOADING)
listItemSelected ,
#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.GHashTable as B.GHT
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.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.Cairo.Structs.Context as Cairo.Context
import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Flags as Gdk.Flags
import qualified GI.Gdk.Interfaces.Paintable as Gdk.Paintable
import qualified GI.Gdk.Objects.Clipboard as Gdk.Clipboard
import qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
import qualified GI.Gdk.Objects.Device as Gdk.Device
import qualified GI.Gdk.Objects.Display as Gdk.Display
import qualified GI.Gdk.Objects.Event as Gdk.Event
import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
import qualified GI.Gdk.Objects.Snapshot as Gdk.Snapshot
import qualified GI.Gdk.Objects.Surface as Gdk.Surface
import qualified GI.Gdk.Objects.Texture as Gdk.Texture
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
import qualified GI.Graphene.Structs.Point as Graphene.Point
import qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
import qualified GI.Graphene.Structs.Rect as Graphene.Rect
import qualified GI.Graphene.Structs.Size as Graphene.Size
import qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
import qualified GI.Graphene.Structs.Vec4 as Graphene.Vec4
import qualified GI.Gsk.Enums as Gsk.Enums
import qualified GI.Gsk.Objects.GLShader as Gsk.GLShader
import qualified GI.Gsk.Objects.RenderNode as Gsk.RenderNode
import qualified GI.Gsk.Objects.Renderer as Gsk.Renderer
import qualified GI.Gsk.Structs.ColorStop as Gsk.ColorStop
import qualified GI.Gsk.Structs.Path as Gsk.Path
import qualified GI.Gsk.Structs.RoundedRect as Gsk.RoundedRect
import qualified GI.Gsk.Structs.Shadow as Gsk.Shadow
import qualified GI.Gsk.Structs.Stroke as Gsk.Stroke
import qualified GI.Gsk.Structs.Transform as Gsk.Transform
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Native as Gtk.Native
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Root as Gtk.Root
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.StyleProvider as Gtk.StyleProvider
import {-# SOURCE #-} qualified GI.Gtk.Objects.ATContext as Gtk.ATContext
import {-# SOURCE #-} qualified GI.Gtk.Objects.EventController as Gtk.EventController
import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutChild as Gtk.LayoutChild
import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutManager as Gtk.LayoutManager
import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings
import {-# SOURCE #-} qualified GI.Gtk.Objects.Snapshot as Gtk.Snapshot
import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleContext as Gtk.StyleContext
import {-# SOURCE #-} qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import {-# SOURCE #-} qualified GI.Gtk.Structs.Border as Gtk.Border
import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition
import qualified GI.Pango.Enums as Pango.Enums
import qualified GI.Pango.Objects.Context as Pango.Context
import qualified GI.Pango.Objects.FontMap as Pango.FontMap
import qualified GI.Pango.Objects.Layout as Pango.Layout
#else
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
#endif
newtype ListItem = ListItem (SP.ManagedPtr ListItem)
deriving (ListItem -> ListItem -> Bool
(ListItem -> ListItem -> Bool)
-> (ListItem -> ListItem -> Bool) -> Eq ListItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListItem -> ListItem -> Bool
== :: ListItem -> ListItem -> Bool
$c/= :: ListItem -> ListItem -> Bool
/= :: ListItem -> ListItem -> Bool
Eq)
instance SP.ManagedPtrNewtype ListItem where
toManagedPtr :: ListItem -> ManagedPtr ListItem
toManagedPtr (ListItem ManagedPtr ListItem
p) = ManagedPtr ListItem
p
foreign import ccall "gtk_list_item_get_type"
c_gtk_list_item_get_type :: IO B.Types.GType
instance B.Types.TypedObject ListItem where
glibType :: IO GType
glibType = IO GType
c_gtk_list_item_get_type
instance B.Types.GObject ListItem
class (SP.GObject o, O.IsDescendantOf ListItem o) => IsListItem o
instance (SP.GObject o, O.IsDescendantOf ListItem o) => IsListItem o
instance O.HasParentTypes ListItem
type instance O.ParentTypes ListItem = '[GObject.Object.Object]
toListItem :: (MIO.MonadIO m, IsListItem o) => o -> m ListItem
toListItem :: forall (m :: * -> *) o.
(MonadIO m, IsListItem o) =>
o -> m ListItem
toListItem = IO ListItem -> m ListItem
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ListItem -> m ListItem)
-> (o -> IO ListItem) -> o -> m ListItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ListItem -> ListItem) -> o -> IO ListItem
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ListItem -> ListItem
ListItem
instance B.GValue.IsGValue (Maybe ListItem) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_list_item_get_type
gvalueSet_ :: Ptr GValue -> Maybe ListItem -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ListItem
P.Nothing = Ptr GValue -> Ptr ListItem -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr ListItem
forall a. Ptr a
FP.nullPtr :: FP.Ptr ListItem)
gvalueSet_ Ptr GValue
gv (P.Just ListItem
obj) = ListItem -> (Ptr ListItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ListItem
obj (Ptr GValue -> Ptr ListItem -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe ListItem)
gvalueGet_ Ptr GValue
gv = do
Ptr ListItem
ptr <- Ptr GValue -> IO (Ptr ListItem)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr ListItem)
if Ptr ListItem
ptr Ptr ListItem -> Ptr ListItem -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ListItem
forall a. Ptr a
FP.nullPtr
then ListItem -> Maybe ListItem
forall a. a -> Maybe a
P.Just (ListItem -> Maybe ListItem) -> IO ListItem -> IO (Maybe ListItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr ListItem -> ListItem) -> Ptr ListItem -> IO ListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ListItem -> ListItem
ListItem Ptr ListItem
ptr
else Maybe ListItem -> IO (Maybe ListItem)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ListItem
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveListItemMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveListItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveListItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveListItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveListItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveListItemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveListItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveListItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveListItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveListItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveListItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveListItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveListItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveListItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveListItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveListItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveListItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveListItemMethod "getAccessibleDescription" o = ListItemGetAccessibleDescriptionMethodInfo
ResolveListItemMethod "getAccessibleLabel" o = ListItemGetAccessibleLabelMethodInfo
ResolveListItemMethod "getActivatable" o = ListItemGetActivatableMethodInfo
ResolveListItemMethod "getChild" o = ListItemGetChildMethodInfo
ResolveListItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveListItemMethod "getFocusable" o = ListItemGetFocusableMethodInfo
ResolveListItemMethod "getItem" o = ListItemGetItemMethodInfo
ResolveListItemMethod "getPosition" o = ListItemGetPositionMethodInfo
ResolveListItemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveListItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveListItemMethod "getSelectable" o = ListItemGetSelectableMethodInfo
ResolveListItemMethod "getSelected" o = ListItemGetSelectedMethodInfo
ResolveListItemMethod "setAccessibleDescription" o = ListItemSetAccessibleDescriptionMethodInfo
ResolveListItemMethod "setAccessibleLabel" o = ListItemSetAccessibleLabelMethodInfo
ResolveListItemMethod "setActivatable" o = ListItemSetActivatableMethodInfo
ResolveListItemMethod "setChild" o = ListItemSetChildMethodInfo
ResolveListItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveListItemMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveListItemMethod "setFocusable" o = ListItemSetFocusableMethodInfo
ResolveListItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveListItemMethod "setSelectable" o = ListItemSetSelectableMethodInfo
ResolveListItemMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveListItemMethod t ListItem, O.OverloadedMethod info ListItem p) => OL.IsLabel t (ListItem -> 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 ~ ResolveListItemMethod t ListItem, O.OverloadedMethod info ListItem p, R.HasField t ListItem p) => R.HasField t ListItem p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveListItemMethod t ListItem, O.OverloadedMethodInfo info ListItem) => OL.IsLabel t (O.MethodProxy info ListItem) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getListItemAccessibleDescription :: (MonadIO m, IsListItem o) => o -> m T.Text
getListItemAccessibleDescription :: forall (m :: * -> *) o. (MonadIO m, IsListItem o) => o -> m Text
getListItemAccessibleDescription o
obj = IO Text -> m Text
forall a. IO a -> m a
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
"getListItemAccessibleDescription" (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
"accessible-description"
setListItemAccessibleDescription :: (MonadIO m, IsListItem o) => o -> T.Text -> m ()
setListItemAccessibleDescription :: forall (m :: * -> *) o.
(MonadIO m, IsListItem o) =>
o -> Text -> m ()
setListItemAccessibleDescription o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-description" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)
constructListItemAccessibleDescription :: (IsListItem o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructListItemAccessibleDescription :: forall o (m :: * -> *).
(IsListItem o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructListItemAccessibleDescription Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"accessible-description" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)
#if defined(ENABLE_OVERLOADING)
data ListItemAccessibleDescriptionPropertyInfo
instance AttrInfo ListItemAccessibleDescriptionPropertyInfo where
type AttrAllowedOps ListItemAccessibleDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint ListItemAccessibleDescriptionPropertyInfo = IsListItem
type AttrSetTypeConstraint ListItemAccessibleDescriptionPropertyInfo = (~) T.Text
type AttrTransferTypeConstraint ListItemAccessibleDescriptionPropertyInfo = (~) T.Text
type AttrTransferType ListItemAccessibleDescriptionPropertyInfo = T.Text
type AttrGetType ListItemAccessibleDescriptionPropertyInfo = T.Text
type AttrLabel ListItemAccessibleDescriptionPropertyInfo = "accessible-description"
type AttrOrigin ListItemAccessibleDescriptionPropertyInfo = ListItem
attrGet = getListItemAccessibleDescription
attrSet = setListItemAccessibleDescription
attrTransfer _ v = do
return v
attrConstruct = constructListItemAccessibleDescription
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.accessibleDescription"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#g:attr:accessibleDescription"
})
#endif
getListItemAccessibleLabel :: (MonadIO m, IsListItem o) => o -> m T.Text
getListItemAccessibleLabel :: forall (m :: * -> *) o. (MonadIO m, IsListItem o) => o -> m Text
getListItemAccessibleLabel o
obj = IO Text -> m Text
forall a. IO a -> m a
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
"getListItemAccessibleLabel" (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
"accessible-label"
setListItemAccessibleLabel :: (MonadIO m, IsListItem o) => o -> T.Text -> m ()
setListItemAccessibleLabel :: forall (m :: * -> *) o.
(MonadIO m, IsListItem o) =>
o -> Text -> m ()
setListItemAccessibleLabel o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-label" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)
constructListItemAccessibleLabel :: (IsListItem o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructListItemAccessibleLabel :: forall o (m :: * -> *).
(IsListItem o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructListItemAccessibleLabel Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"accessible-label" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)
#if defined(ENABLE_OVERLOADING)
data ListItemAccessibleLabelPropertyInfo
instance AttrInfo ListItemAccessibleLabelPropertyInfo where
type AttrAllowedOps ListItemAccessibleLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint ListItemAccessibleLabelPropertyInfo = IsListItem
type AttrSetTypeConstraint ListItemAccessibleLabelPropertyInfo = (~) T.Text
type AttrTransferTypeConstraint ListItemAccessibleLabelPropertyInfo = (~) T.Text
type AttrTransferType ListItemAccessibleLabelPropertyInfo = T.Text
type AttrGetType ListItemAccessibleLabelPropertyInfo = T.Text
type AttrLabel ListItemAccessibleLabelPropertyInfo = "accessible-label"
type AttrOrigin ListItemAccessibleLabelPropertyInfo = ListItem
attrGet = getListItemAccessibleLabel
attrSet = setListItemAccessibleLabel
attrTransfer _ v = do
return v
attrConstruct = constructListItemAccessibleLabel
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.accessibleLabel"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#g:attr:accessibleLabel"
})
#endif
getListItemActivatable :: (MonadIO m, IsListItem o) => o -> m Bool
getListItemActivatable :: forall (m :: * -> *) o. (MonadIO m, IsListItem o) => o -> m Bool
getListItemActivatable o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"activatable"
setListItemActivatable :: (MonadIO m, IsListItem o) => o -> Bool -> m ()
setListItemActivatable :: forall (m :: * -> *) o.
(MonadIO m, IsListItem o) =>
o -> Bool -> m ()
setListItemActivatable o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"activatable" Bool
val
constructListItemActivatable :: (IsListItem o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructListItemActivatable :: forall o (m :: * -> *).
(IsListItem o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructListItemActivatable Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"activatable" Bool
val
#if defined(ENABLE_OVERLOADING)
data ListItemActivatablePropertyInfo
instance AttrInfo ListItemActivatablePropertyInfo where
type AttrAllowedOps ListItemActivatablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint ListItemActivatablePropertyInfo = IsListItem
type AttrSetTypeConstraint ListItemActivatablePropertyInfo = (~) Bool
type AttrTransferTypeConstraint ListItemActivatablePropertyInfo = (~) Bool
type AttrTransferType ListItemActivatablePropertyInfo = Bool
type AttrGetType ListItemActivatablePropertyInfo = Bool
type AttrLabel ListItemActivatablePropertyInfo = "activatable"
type AttrOrigin ListItemActivatablePropertyInfo = ListItem
attrGet = getListItemActivatable
attrSet = setListItemActivatable
attrTransfer _ v = do
return v
attrConstruct = constructListItemActivatable
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.activatable"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#g:attr:activatable"
})
#endif
getListItemChild :: (MonadIO m, IsListItem o) => o -> m (Maybe Gtk.Widget.Widget)
getListItemChild :: forall (m :: * -> *) o.
(MonadIO m, IsListItem o) =>
o -> m (Maybe Widget)
getListItemChild o
obj = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Widget -> Widget) -> IO (Maybe Widget)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"child" ManagedPtr Widget -> Widget
Gtk.Widget.Widget
setListItemChild :: (MonadIO m, IsListItem o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setListItemChild :: forall (m :: * -> *) o a.
(MonadIO m, IsListItem o, IsWidget a) =>
o -> a -> m ()
setListItemChild o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"child" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)
constructListItemChild :: (IsListItem o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructListItemChild :: forall o (m :: * -> *) a.
(IsListItem o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructListItemChild a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (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
"child" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)
clearListItemChild :: (MonadIO m, IsListItem o) => o -> m ()
clearListItemChild :: forall (m :: * -> *) o. (MonadIO m, IsListItem o) => o -> m ()
clearListItemChild o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"child" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)
#if defined(ENABLE_OVERLOADING)
data ListItemChildPropertyInfo
instance AttrInfo ListItemChildPropertyInfo where
type AttrAllowedOps ListItemChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint ListItemChildPropertyInfo = IsListItem
type AttrSetTypeConstraint ListItemChildPropertyInfo = Gtk.Widget.IsWidget
type AttrTransferTypeConstraint ListItemChildPropertyInfo = Gtk.Widget.IsWidget
type AttrTransferType ListItemChildPropertyInfo = Gtk.Widget.Widget
type AttrGetType ListItemChildPropertyInfo = (Maybe Gtk.Widget.Widget)
type AttrLabel ListItemChildPropertyInfo = "child"
type AttrOrigin ListItemChildPropertyInfo = ListItem
attrGet = getListItemChild
attrSet = setListItemChild
attrTransfer _ v = do
unsafeCastTo Gtk.Widget.Widget v
attrConstruct = constructListItemChild
attrClear = clearListItemChild
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.child"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#g:attr:child"
})
#endif
getListItemFocusable :: (MonadIO m, IsListItem o) => o -> m Bool
getListItemFocusable :: forall (m :: * -> *) o. (MonadIO m, IsListItem o) => o -> m Bool
getListItemFocusable o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"focusable"
setListItemFocusable :: (MonadIO m, IsListItem o) => o -> Bool -> m ()
setListItemFocusable :: forall (m :: * -> *) o.
(MonadIO m, IsListItem o) =>
o -> Bool -> m ()
setListItemFocusable o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"focusable" Bool
val
constructListItemFocusable :: (IsListItem o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructListItemFocusable :: forall o (m :: * -> *).
(IsListItem o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructListItemFocusable Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"focusable" Bool
val
#if defined(ENABLE_OVERLOADING)
data ListItemFocusablePropertyInfo
instance AttrInfo ListItemFocusablePropertyInfo where
type AttrAllowedOps ListItemFocusablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint ListItemFocusablePropertyInfo = IsListItem
type AttrSetTypeConstraint ListItemFocusablePropertyInfo = (~) Bool
type AttrTransferTypeConstraint ListItemFocusablePropertyInfo = (~) Bool
type AttrTransferType ListItemFocusablePropertyInfo = Bool
type AttrGetType ListItemFocusablePropertyInfo = Bool
type AttrLabel ListItemFocusablePropertyInfo = "focusable"
type AttrOrigin ListItemFocusablePropertyInfo = ListItem
attrGet = getListItemFocusable
attrSet = setListItemFocusable
attrTransfer _ v = do
return v
attrConstruct = constructListItemFocusable
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.focusable"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#g:attr:focusable"
})
#endif
getListItemItem :: (MonadIO m, IsListItem o) => o -> m (Maybe GObject.Object.Object)
getListItemItem :: forall (m :: * -> *) o.
(MonadIO m, IsListItem o) =>
o -> m (Maybe Object)
getListItemItem o
obj = IO (Maybe Object) -> m (Maybe Object)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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
"item" ManagedPtr Object -> Object
GObject.Object.Object
#if defined(ENABLE_OVERLOADING)
data ListItemItemPropertyInfo
instance AttrInfo ListItemItemPropertyInfo where
type AttrAllowedOps ListItemItemPropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint ListItemItemPropertyInfo = IsListItem
type AttrSetTypeConstraint ListItemItemPropertyInfo = (~) ()
type AttrTransferTypeConstraint ListItemItemPropertyInfo = (~) ()
type AttrTransferType ListItemItemPropertyInfo = ()
type AttrGetType ListItemItemPropertyInfo = (Maybe GObject.Object.Object)
type AttrLabel ListItemItemPropertyInfo = "item"
type AttrOrigin ListItemItemPropertyInfo = ListItem
attrGet = getListItemItem
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.item"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#g:attr:item"
})
#endif
getListItemPosition :: (MonadIO m, IsListItem o) => o -> m Word32
getListItemPosition :: forall (m :: * -> *) o. (MonadIO m, IsListItem o) => o -> m Word32
getListItemPosition o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"position"
#if defined(ENABLE_OVERLOADING)
data ListItemPositionPropertyInfo
instance AttrInfo ListItemPositionPropertyInfo where
type AttrAllowedOps ListItemPositionPropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint ListItemPositionPropertyInfo = IsListItem
type AttrSetTypeConstraint ListItemPositionPropertyInfo = (~) ()
type AttrTransferTypeConstraint ListItemPositionPropertyInfo = (~) ()
type AttrTransferType ListItemPositionPropertyInfo = ()
type AttrGetType ListItemPositionPropertyInfo = Word32
type AttrLabel ListItemPositionPropertyInfo = "position"
type AttrOrigin ListItemPositionPropertyInfo = ListItem
attrGet = getListItemPosition
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.position"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#g:attr:position"
})
#endif
getListItemSelectable :: (MonadIO m, IsListItem o) => o -> m Bool
getListItemSelectable :: forall (m :: * -> *) o. (MonadIO m, IsListItem o) => o -> m Bool
getListItemSelectable o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"selectable"
setListItemSelectable :: (MonadIO m, IsListItem o) => o -> Bool -> m ()
setListItemSelectable :: forall (m :: * -> *) o.
(MonadIO m, IsListItem o) =>
o -> Bool -> m ()
setListItemSelectable o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"selectable" Bool
val
constructListItemSelectable :: (IsListItem o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructListItemSelectable :: forall o (m :: * -> *).
(IsListItem o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructListItemSelectable Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"selectable" Bool
val
#if defined(ENABLE_OVERLOADING)
data ListItemSelectablePropertyInfo
instance AttrInfo ListItemSelectablePropertyInfo where
type AttrAllowedOps ListItemSelectablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint ListItemSelectablePropertyInfo = IsListItem
type AttrSetTypeConstraint ListItemSelectablePropertyInfo = (~) Bool
type AttrTransferTypeConstraint ListItemSelectablePropertyInfo = (~) Bool
type AttrTransferType ListItemSelectablePropertyInfo = Bool
type AttrGetType ListItemSelectablePropertyInfo = Bool
type AttrLabel ListItemSelectablePropertyInfo = "selectable"
type AttrOrigin ListItemSelectablePropertyInfo = ListItem
attrGet = getListItemSelectable
attrSet = setListItemSelectable
attrTransfer _ v = do
return v
attrConstruct = constructListItemSelectable
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.selectable"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#g:attr:selectable"
})
#endif
getListItemSelected :: (MonadIO m, IsListItem o) => o -> m Bool
getListItemSelected :: forall (m :: * -> *) o. (MonadIO m, IsListItem o) => o -> m Bool
getListItemSelected o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"selected"
#if defined(ENABLE_OVERLOADING)
data ListItemSelectedPropertyInfo
instance AttrInfo ListItemSelectedPropertyInfo where
type AttrAllowedOps ListItemSelectedPropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint ListItemSelectedPropertyInfo = IsListItem
type AttrSetTypeConstraint ListItemSelectedPropertyInfo = (~) ()
type AttrTransferTypeConstraint ListItemSelectedPropertyInfo = (~) ()
type AttrTransferType ListItemSelectedPropertyInfo = ()
type AttrGetType ListItemSelectedPropertyInfo = Bool
type AttrLabel ListItemSelectedPropertyInfo = "selected"
type AttrOrigin ListItemSelectedPropertyInfo = ListItem
attrGet = getListItemSelected
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.selected"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#g:attr:selected"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ListItem
type instance O.AttributeList ListItem = ListItemAttributeList
type ListItemAttributeList = ('[ '("accessibleDescription", ListItemAccessibleDescriptionPropertyInfo), '("accessibleLabel", ListItemAccessibleLabelPropertyInfo), '("activatable", ListItemActivatablePropertyInfo), '("child", ListItemChildPropertyInfo), '("focusable", ListItemFocusablePropertyInfo), '("item", ListItemItemPropertyInfo), '("position", ListItemPositionPropertyInfo), '("selectable", ListItemSelectablePropertyInfo), '("selected", ListItemSelectedPropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
listItemAccessibleDescription :: AttrLabelProxy "accessibleDescription"
listItemAccessibleDescription = AttrLabelProxy
listItemAccessibleLabel :: AttrLabelProxy "accessibleLabel"
listItemAccessibleLabel = AttrLabelProxy
listItemActivatable :: AttrLabelProxy "activatable"
listItemActivatable = AttrLabelProxy
listItemChild :: AttrLabelProxy "child"
listItemChild = AttrLabelProxy
listItemFocusable :: AttrLabelProxy "focusable"
listItemFocusable = AttrLabelProxy
listItemItem :: AttrLabelProxy "item"
listItemItem = AttrLabelProxy
listItemPosition :: AttrLabelProxy "position"
listItemPosition = AttrLabelProxy
listItemSelectable :: AttrLabelProxy "selectable"
listItemSelectable = AttrLabelProxy
listItemSelected :: AttrLabelProxy "selected"
listItemSelected = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ListItem = ListItemSignalList
type ListItemSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "gtk_list_item_get_accessible_description" gtk_list_item_get_accessible_description ::
Ptr ListItem ->
IO CString
listItemGetAccessibleDescription ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a) =>
a
-> m T.Text
listItemGetAccessibleDescription :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListItem a) =>
a -> m Text
listItemGetAccessibleDescription a
self = IO Text -> m Text
forall a. IO a -> m a
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 ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
result <- Ptr ListItem -> IO CString
gtk_list_item_get_accessible_description Ptr ListItem
self'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"listItemGetAccessibleDescription" 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data ListItemGetAccessibleDescriptionMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsListItem a) => O.OverloadedMethod ListItemGetAccessibleDescriptionMethodInfo a signature where
overloadedMethod = listItemGetAccessibleDescription
instance O.OverloadedMethodInfo ListItemGetAccessibleDescriptionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemGetAccessibleDescription",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemGetAccessibleDescription"
})
#endif
foreign import ccall "gtk_list_item_get_accessible_label" gtk_list_item_get_accessible_label ::
Ptr ListItem ->
IO CString
listItemGetAccessibleLabel ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a) =>
a
-> m T.Text
listItemGetAccessibleLabel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListItem a) =>
a -> m Text
listItemGetAccessibleLabel a
self = IO Text -> m Text
forall a. IO a -> m a
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 ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
result <- Ptr ListItem -> IO CString
gtk_list_item_get_accessible_label Ptr ListItem
self'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"listItemGetAccessibleLabel" 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data ListItemGetAccessibleLabelMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsListItem a) => O.OverloadedMethod ListItemGetAccessibleLabelMethodInfo a signature where
overloadedMethod = listItemGetAccessibleLabel
instance O.OverloadedMethodInfo ListItemGetAccessibleLabelMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemGetAccessibleLabel",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemGetAccessibleLabel"
})
#endif
foreign import ccall "gtk_list_item_get_activatable" gtk_list_item_get_activatable ::
Ptr ListItem ->
IO CInt
listItemGetActivatable ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a) =>
a
-> m Bool
listItemGetActivatable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListItem a) =>
a -> m Bool
listItemGetActivatable a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CInt
result <- Ptr ListItem -> IO CInt
gtk_list_item_get_activatable Ptr ListItem
self'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ListItemGetActivatableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsListItem a) => O.OverloadedMethod ListItemGetActivatableMethodInfo a signature where
overloadedMethod = listItemGetActivatable
instance O.OverloadedMethodInfo ListItemGetActivatableMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemGetActivatable",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemGetActivatable"
})
#endif
foreign import ccall "gtk_list_item_get_child" gtk_list_item_get_child ::
Ptr ListItem ->
IO (Ptr Gtk.Widget.Widget)
listItemGetChild ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a) =>
a
-> m (Maybe Gtk.Widget.Widget)
listItemGetChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListItem a) =>
a -> m (Maybe Widget)
listItemGetChild a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
Ptr ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr Widget
result <- Ptr ListItem -> IO (Ptr Widget)
gtk_list_item_get_child Ptr ListItem
self'
Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult
#if defined(ENABLE_OVERLOADING)
data ListItemGetChildMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsListItem a) => O.OverloadedMethod ListItemGetChildMethodInfo a signature where
overloadedMethod = listItemGetChild
instance O.OverloadedMethodInfo ListItemGetChildMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemGetChild",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemGetChild"
})
#endif
foreign import ccall "gtk_list_item_get_focusable" gtk_list_item_get_focusable ::
Ptr ListItem ->
IO CInt
listItemGetFocusable ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a) =>
a
-> m Bool
listItemGetFocusable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListItem a) =>
a -> m Bool
listItemGetFocusable a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CInt
result <- Ptr ListItem -> IO CInt
gtk_list_item_get_focusable Ptr ListItem
self'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ListItemGetFocusableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsListItem a) => O.OverloadedMethod ListItemGetFocusableMethodInfo a signature where
overloadedMethod = listItemGetFocusable
instance O.OverloadedMethodInfo ListItemGetFocusableMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemGetFocusable",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemGetFocusable"
})
#endif
foreign import ccall "gtk_list_item_get_item" gtk_list_item_get_item ::
Ptr ListItem ->
IO (Ptr GObject.Object.Object)
listItemGetItem ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a) =>
a
-> m (Maybe GObject.Object.Object)
listItemGetItem :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListItem a) =>
a -> m (Maybe Object)
listItemGetItem a
self = IO (Maybe Object) -> m (Maybe Object)
forall a. IO a -> m a
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
$ do
Ptr ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr Object
result <- Ptr ListItem -> IO (Ptr Object)
gtk_list_item_get_item Ptr ListItem
self'
Maybe Object
maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
result ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Object
result' -> do
Object
result'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
result'
Object -> IO Object
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Maybe Object -> IO (Maybe Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
maybeResult
#if defined(ENABLE_OVERLOADING)
data ListItemGetItemMethodInfo
instance (signature ~ (m (Maybe GObject.Object.Object)), MonadIO m, IsListItem a) => O.OverloadedMethod ListItemGetItemMethodInfo a signature where
overloadedMethod = listItemGetItem
instance O.OverloadedMethodInfo ListItemGetItemMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemGetItem",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemGetItem"
})
#endif
foreign import ccall "gtk_list_item_get_position" gtk_list_item_get_position ::
Ptr ListItem ->
IO Word32
listItemGetPosition ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a) =>
a
-> m Word32
listItemGetPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListItem a) =>
a -> m Word32
listItemGetPosition a
self = IO Word32 -> m Word32
forall a. IO a -> m a
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
Ptr ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Word32
result <- Ptr ListItem -> IO Word32
gtk_list_item_get_position Ptr ListItem
self'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data ListItemGetPositionMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsListItem a) => O.OverloadedMethod ListItemGetPositionMethodInfo a signature where
overloadedMethod = listItemGetPosition
instance O.OverloadedMethodInfo ListItemGetPositionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemGetPosition",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemGetPosition"
})
#endif
foreign import ccall "gtk_list_item_get_selectable" gtk_list_item_get_selectable ::
Ptr ListItem ->
IO CInt
listItemGetSelectable ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a) =>
a
-> m Bool
listItemGetSelectable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListItem a) =>
a -> m Bool
listItemGetSelectable a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CInt
result <- Ptr ListItem -> IO CInt
gtk_list_item_get_selectable Ptr ListItem
self'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ListItemGetSelectableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsListItem a) => O.OverloadedMethod ListItemGetSelectableMethodInfo a signature where
overloadedMethod = listItemGetSelectable
instance O.OverloadedMethodInfo ListItemGetSelectableMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemGetSelectable",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemGetSelectable"
})
#endif
foreign import ccall "gtk_list_item_get_selected" gtk_list_item_get_selected ::
Ptr ListItem ->
IO CInt
listItemGetSelected ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a) =>
a
-> m Bool
listItemGetSelected :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListItem a) =>
a -> m Bool
listItemGetSelected a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CInt
result <- Ptr ListItem -> IO CInt
gtk_list_item_get_selected Ptr ListItem
self'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ListItemGetSelectedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsListItem a) => O.OverloadedMethod ListItemGetSelectedMethodInfo a signature where
overloadedMethod = listItemGetSelected
instance O.OverloadedMethodInfo ListItemGetSelectedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemGetSelected",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemGetSelected"
})
#endif
foreign import ccall "gtk_list_item_set_accessible_description" gtk_list_item_set_accessible_description ::
Ptr ListItem ->
CString ->
IO ()
listItemSetAccessibleDescription ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a) =>
a
-> T.Text
-> m ()
listItemSetAccessibleDescription :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListItem a) =>
a -> Text -> m ()
listItemSetAccessibleDescription a
self Text
description = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
description' <- Text -> IO CString
textToCString Text
description
Ptr ListItem -> CString -> IO ()
gtk_list_item_set_accessible_description Ptr ListItem
self' CString
description'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
description'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ListItemSetAccessibleDescriptionMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsListItem a) => O.OverloadedMethod ListItemSetAccessibleDescriptionMethodInfo a signature where
overloadedMethod = listItemSetAccessibleDescription
instance O.OverloadedMethodInfo ListItemSetAccessibleDescriptionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemSetAccessibleDescription",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemSetAccessibleDescription"
})
#endif
foreign import ccall "gtk_list_item_set_accessible_label" gtk_list_item_set_accessible_label ::
Ptr ListItem ->
CString ->
IO ()
listItemSetAccessibleLabel ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a) =>
a
-> T.Text
-> m ()
listItemSetAccessibleLabel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListItem a) =>
a -> Text -> m ()
listItemSetAccessibleLabel a
self Text
label = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
label' <- Text -> IO CString
textToCString Text
label
Ptr ListItem -> CString -> IO ()
gtk_list_item_set_accessible_label Ptr ListItem
self' CString
label'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
label'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ListItemSetAccessibleLabelMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsListItem a) => O.OverloadedMethod ListItemSetAccessibleLabelMethodInfo a signature where
overloadedMethod = listItemSetAccessibleLabel
instance O.OverloadedMethodInfo ListItemSetAccessibleLabelMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemSetAccessibleLabel",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemSetAccessibleLabel"
})
#endif
foreign import ccall "gtk_list_item_set_activatable" gtk_list_item_set_activatable ::
Ptr ListItem ->
CInt ->
IO ()
listItemSetActivatable ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a) =>
a
-> Bool
-> m ()
listItemSetActivatable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListItem a) =>
a -> Bool -> m ()
listItemSetActivatable a
self Bool
activatable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
let activatable' :: CInt
activatable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
activatable
Ptr ListItem -> CInt -> IO ()
gtk_list_item_set_activatable Ptr ListItem
self' CInt
activatable'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ListItemSetActivatableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsListItem a) => O.OverloadedMethod ListItemSetActivatableMethodInfo a signature where
overloadedMethod = listItemSetActivatable
instance O.OverloadedMethodInfo ListItemSetActivatableMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemSetActivatable",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemSetActivatable"
})
#endif
foreign import ccall "gtk_list_item_set_child" gtk_list_item_set_child ::
Ptr ListItem ->
Ptr Gtk.Widget.Widget ->
IO ()
listItemSetChild ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a, Gtk.Widget.IsWidget b) =>
a
-> Maybe (b)
-> m ()
listItemSetChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsListItem a, IsWidget b) =>
a -> Maybe b -> m ()
listItemSetChild a
self Maybe b
child = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr Widget
maybeChild <- case Maybe b
child of
Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
Just b
jChild -> do
Ptr Widget
jChild' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jChild
Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jChild'
Ptr ListItem -> Ptr Widget -> IO ()
gtk_list_item_set_child Ptr ListItem
self' Ptr Widget
maybeChild
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
child b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ListItemSetChildMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsListItem a, Gtk.Widget.IsWidget b) => O.OverloadedMethod ListItemSetChildMethodInfo a signature where
overloadedMethod = listItemSetChild
instance O.OverloadedMethodInfo ListItemSetChildMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemSetChild",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemSetChild"
})
#endif
foreign import ccall "gtk_list_item_set_focusable" gtk_list_item_set_focusable ::
Ptr ListItem ->
CInt ->
IO ()
listItemSetFocusable ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a) =>
a
-> Bool
-> m ()
listItemSetFocusable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListItem a) =>
a -> Bool -> m ()
listItemSetFocusable a
self Bool
focusable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
let focusable' :: CInt
focusable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
focusable
Ptr ListItem -> CInt -> IO ()
gtk_list_item_set_focusable Ptr ListItem
self' CInt
focusable'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ListItemSetFocusableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsListItem a) => O.OverloadedMethod ListItemSetFocusableMethodInfo a signature where
overloadedMethod = listItemSetFocusable
instance O.OverloadedMethodInfo ListItemSetFocusableMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemSetFocusable",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemSetFocusable"
})
#endif
foreign import ccall "gtk_list_item_set_selectable" gtk_list_item_set_selectable ::
Ptr ListItem ->
CInt ->
IO ()
listItemSetSelectable ::
(B.CallStack.HasCallStack, MonadIO m, IsListItem a) =>
a
-> Bool
-> m ()
listItemSetSelectable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListItem a) =>
a -> Bool -> m ()
listItemSetSelectable a
self Bool
selectable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr ListItem
self' <- a -> IO (Ptr ListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
let selectable' :: CInt
selectable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
selectable
Ptr ListItem -> CInt -> IO ()
gtk_list_item_set_selectable Ptr ListItem
self' CInt
selectable'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ListItemSetSelectableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsListItem a) => O.OverloadedMethod ListItemSetSelectableMethodInfo a signature where
overloadedMethod = listItemSetSelectable
instance O.OverloadedMethodInfo ListItemSetSelectableMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ListItem.listItemSetSelectable",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.9/docs/GI-Gtk-Objects-ListItem.html#v:listItemSetSelectable"
})
#endif