{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Gtk.Objects.Accessible.Accessible' class is the base class for accessible
-- implementations for t'GI.Gtk.Objects.Widget.Widget' subclasses. It is a thin
-- wrapper around t'GI.Atk.Objects.Object.Object', which adds facilities for associating
-- a widget with its accessible object.
-- 
-- An accessible implementation for a third-party widget should
-- derive from t'GI.Gtk.Objects.Accessible.Accessible' and implement the suitable interfaces
-- from ATK, such as t'GI.Atk.Interfaces.Text.Text' or t'GI.Atk.Interfaces.Selection.Selection'. To establish
-- the connection between the widget class and its corresponding
-- acccessible implementation, override the get_accessible vfunc
-- in t'GI.Gtk.Structs.WidgetClass.WidgetClass'.

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

module GI.Gtk.Objects.Accessible
    ( 

-- * Exported types
    Accessible(..)                          ,
    IsAccessible                            ,
    toAccessible                            ,
    noAccessible                            ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveAccessibleMethod                 ,
#endif


-- ** connectWidgetDestroyed #method:connectWidgetDestroyed#

#if defined(ENABLE_OVERLOADING)
    AccessibleConnectWidgetDestroyedMethodInfo,
#endif
    accessibleConnectWidgetDestroyed        ,


-- ** getWidget #method:getWidget#

#if defined(ENABLE_OVERLOADING)
    AccessibleGetWidgetMethodInfo           ,
#endif
    accessibleGetWidget                     ,


-- ** setWidget #method:setWidget#

#if defined(ENABLE_OVERLOADING)
    AccessibleSetWidgetMethodInfo           ,
#endif
    accessibleSetWidget                     ,




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

#if defined(ENABLE_OVERLOADING)
    AccessibleWidgetPropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    accessibleWidget                        ,
#endif
    clearAccessibleWidget                   ,
    constructAccessibleWidget               ,
    getAccessibleWidget                     ,
    setAccessibleWidget                     ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.Atk.Objects.Object as Atk.Object
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

-- | Memory-managed wrapper type.
newtype Accessible = Accessible (ManagedPtr Accessible)
    deriving (Accessible -> Accessible -> Bool
(Accessible -> Accessible -> Bool)
-> (Accessible -> Accessible -> Bool) -> Eq Accessible
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Accessible -> Accessible -> Bool
$c/= :: Accessible -> Accessible -> Bool
== :: Accessible -> Accessible -> Bool
$c== :: Accessible -> Accessible -> Bool
Eq)
foreign import ccall "gtk_accessible_get_type"
    c_gtk_accessible_get_type :: IO GType

instance GObject Accessible where
    gobjectType :: IO GType
gobjectType = IO GType
c_gtk_accessible_get_type
    

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

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

instance O.HasParentTypes Accessible
type instance O.ParentTypes Accessible = '[Atk.Object.Object, GObject.Object.Object]

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

-- | A convenience alias for `Nothing` :: `Maybe` `Accessible`.
noAccessible :: Maybe Accessible
noAccessible :: Maybe Accessible
noAccessible = Maybe Accessible
forall a. Maybe a
Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolveAccessibleMethod (t :: Symbol) (o :: *) :: * where
    ResolveAccessibleMethod "addRelationship" o = Atk.Object.ObjectAddRelationshipMethodInfo
    ResolveAccessibleMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveAccessibleMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveAccessibleMethod "connectWidgetDestroyed" o = AccessibleConnectWidgetDestroyedMethodInfo
    ResolveAccessibleMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveAccessibleMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveAccessibleMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveAccessibleMethod "initialize" o = Atk.Object.ObjectInitializeMethodInfo
    ResolveAccessibleMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveAccessibleMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveAccessibleMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveAccessibleMethod "notifyStateChange" o = Atk.Object.ObjectNotifyStateChangeMethodInfo
    ResolveAccessibleMethod "peekParent" o = Atk.Object.ObjectPeekParentMethodInfo
    ResolveAccessibleMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveAccessibleMethod "refAccessibleChild" o = Atk.Object.ObjectRefAccessibleChildMethodInfo
    ResolveAccessibleMethod "refRelationSet" o = Atk.Object.ObjectRefRelationSetMethodInfo
    ResolveAccessibleMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveAccessibleMethod "refStateSet" o = Atk.Object.ObjectRefStateSetMethodInfo
    ResolveAccessibleMethod "removePropertyChangeHandler" o = Atk.Object.ObjectRemovePropertyChangeHandlerMethodInfo
    ResolveAccessibleMethod "removeRelationship" o = Atk.Object.ObjectRemoveRelationshipMethodInfo
    ResolveAccessibleMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveAccessibleMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveAccessibleMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveAccessibleMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveAccessibleMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveAccessibleMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveAccessibleMethod "getAttributes" o = Atk.Object.ObjectGetAttributesMethodInfo
    ResolveAccessibleMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveAccessibleMethod "getDescription" o = Atk.Object.ObjectGetDescriptionMethodInfo
    ResolveAccessibleMethod "getIndexInParent" o = Atk.Object.ObjectGetIndexInParentMethodInfo
    ResolveAccessibleMethod "getLayer" o = Atk.Object.ObjectGetLayerMethodInfo
    ResolveAccessibleMethod "getMdiZorder" o = Atk.Object.ObjectGetMdiZorderMethodInfo
    ResolveAccessibleMethod "getNAccessibleChildren" o = Atk.Object.ObjectGetNAccessibleChildrenMethodInfo
    ResolveAccessibleMethod "getName" o = Atk.Object.ObjectGetNameMethodInfo
    ResolveAccessibleMethod "getObjectLocale" o = Atk.Object.ObjectGetObjectLocaleMethodInfo
    ResolveAccessibleMethod "getParent" o = Atk.Object.ObjectGetParentMethodInfo
    ResolveAccessibleMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveAccessibleMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveAccessibleMethod "getRole" o = Atk.Object.ObjectGetRoleMethodInfo
    ResolveAccessibleMethod "getWidget" o = AccessibleGetWidgetMethodInfo
    ResolveAccessibleMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveAccessibleMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveAccessibleMethod "setDescription" o = Atk.Object.ObjectSetDescriptionMethodInfo
    ResolveAccessibleMethod "setName" o = Atk.Object.ObjectSetNameMethodInfo
    ResolveAccessibleMethod "setParent" o = Atk.Object.ObjectSetParentMethodInfo
    ResolveAccessibleMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveAccessibleMethod "setRole" o = Atk.Object.ObjectSetRoleMethodInfo
    ResolveAccessibleMethod "setWidget" o = AccessibleSetWidgetMethodInfo
    ResolveAccessibleMethod l o = O.MethodResolutionFailed l o

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

#endif

-- VVV Prop "widget"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@widget@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' accessible #widget
-- @
getAccessibleWidget :: (MonadIO m, IsAccessible o) => o -> m (Maybe Gtk.Widget.Widget)
getAccessibleWidget :: o -> m (Maybe Widget)
getAccessibleWidget obj :: o
obj = IO (Maybe Widget) -> m (Maybe Widget)
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
$ 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 "widget" ManagedPtr Widget -> Widget
Gtk.Widget.Widget

-- | Set the value of the “@widget@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' accessible [ #widget 'Data.GI.Base.Attributes.:=' value ]
-- @
setAccessibleWidget :: (MonadIO m, IsAccessible o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setAccessibleWidget :: o -> a -> m ()
setAccessibleWidget obj :: o
obj val :: a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj "widget" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@widget@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructAccessibleWidget :: (IsAccessible o, Gtk.Widget.IsWidget a) => a -> IO (GValueConstruct o)
constructAccessibleWidget :: a -> IO (GValueConstruct o)
constructAccessibleWidget val :: a
val = String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject "widget" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Set the value of the “@widget@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #widget
-- @
clearAccessibleWidget :: (MonadIO m, IsAccessible o) => o -> m ()
clearAccessibleWidget :: o -> m ()
clearAccessibleWidget obj :: o
obj = IO () -> m ()
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 "widget" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data AccessibleWidgetPropertyInfo
instance AttrInfo AccessibleWidgetPropertyInfo where
    type AttrAllowedOps AccessibleWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint AccessibleWidgetPropertyInfo = IsAccessible
    type AttrSetTypeConstraint AccessibleWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint AccessibleWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType AccessibleWidgetPropertyInfo = Gtk.Widget.Widget
    type AttrGetType AccessibleWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel AccessibleWidgetPropertyInfo = "widget"
    type AttrOrigin AccessibleWidgetPropertyInfo = Accessible
    attrGet = getAccessibleWidget
    attrSet = setAccessibleWidget
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructAccessibleWidget
    attrClear = clearAccessibleWidget
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Accessible
type instance O.AttributeList Accessible = AccessibleAttributeList
type AccessibleAttributeList = ('[ '("accessibleComponentLayer", Atk.Object.ObjectAccessibleComponentLayerPropertyInfo), '("accessibleComponentMdiZorder", Atk.Object.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessibleDescription", Atk.Object.ObjectAccessibleDescriptionPropertyInfo), '("accessibleHypertextNlinks", Atk.Object.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessibleName", Atk.Object.ObjectAccessibleNamePropertyInfo), '("accessibleParent", Atk.Object.ObjectAccessibleParentPropertyInfo), '("accessibleRole", Atk.Object.ObjectAccessibleRolePropertyInfo), '("accessibleTableCaption", Atk.Object.ObjectAccessibleTableCaptionPropertyInfo), '("accessibleTableCaptionObject", Atk.Object.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessibleTableColumnDescription", Atk.Object.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessibleTableColumnHeader", Atk.Object.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessibleTableRowDescription", Atk.Object.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessibleTableRowHeader", Atk.Object.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessibleTableSummary", Atk.Object.ObjectAccessibleTableSummaryPropertyInfo), '("accessibleValue", Atk.Object.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
accessibleWidget :: AttrLabelProxy "widget"
accessibleWidget = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Accessible = AccessibleSignalList
type AccessibleSignalList = ('[ '("activeDescendantChanged", Atk.Object.ObjectActiveDescendantChangedSignalInfo), '("childrenChanged", Atk.Object.ObjectChildrenChangedSignalInfo), '("focusEvent", Atk.Object.ObjectFocusEventSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("propertyChange", Atk.Object.ObjectPropertyChangeSignalInfo), '("stateChange", Atk.Object.ObjectStateChangeSignalInfo), '("visibleDataChanged", Atk.Object.ObjectVisibleDataChangedSignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "gtk_accessible_connect_widget_destroyed" gtk_accessible_connect_widget_destroyed :: 
    Ptr Accessible ->                       -- accessible : TInterface (Name {namespace = "Gtk", name = "Accessible"})
    IO ()

{-# DEPRECATED accessibleConnectWidgetDestroyed ["(Since version 3.4)","Use 'GI.Gtk.Objects.Accessible.accessibleSetWidget' and its vfuncs."] #-}
-- | This function specifies the callback function to be called
-- when the widget corresponding to a GtkAccessible is destroyed.
accessibleConnectWidgetDestroyed ::
    (B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
    a
    -- ^ /@accessible@/: a t'GI.Gtk.Objects.Accessible.Accessible'
    -> m ()
accessibleConnectWidgetDestroyed :: a -> m ()
accessibleConnectWidgetDestroyed accessible :: a
accessible = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Accessible
accessible' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    Ptr Accessible -> IO ()
gtk_accessible_connect_widget_destroyed Ptr Accessible
accessible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
accessible
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data AccessibleConnectWidgetDestroyedMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAccessible a) => O.MethodInfo AccessibleConnectWidgetDestroyedMethodInfo a signature where
    overloadedMethod = accessibleConnectWidgetDestroyed

#endif

-- method Accessible::get_widget
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Accessible" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkAccessible" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Widget" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_accessible_get_widget" gtk_accessible_get_widget :: 
    Ptr Accessible ->                       -- accessible : TInterface (Name {namespace = "Gtk", name = "Accessible"})
    IO (Ptr Gtk.Widget.Widget)

-- | Gets the t'GI.Gtk.Objects.Widget.Widget' corresponding to the t'GI.Gtk.Objects.Accessible.Accessible'.
-- The returned widget does not have a reference added, so
-- you do not need to unref it.
-- 
-- /Since: 2.22/
accessibleGetWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
    a
    -- ^ /@accessible@/: a t'GI.Gtk.Objects.Accessible.Accessible'
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ pointer to the t'GI.Gtk.Objects.Widget.Widget'
    --     corresponding to the t'GI.Gtk.Objects.Accessible.Accessible', or 'P.Nothing'.
accessibleGetWidget :: a -> m (Maybe Widget)
accessibleGetWidget accessible :: a
accessible = IO (Maybe Widget) -> m (Maybe Widget)
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 Accessible
accessible' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    Ptr Widget
result <- Ptr Accessible -> IO (Ptr Widget)
gtk_accessible_get_widget Ptr Accessible
accessible'
    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
$ \result' :: 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 (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
accessible
    Maybe Widget -> IO (Maybe Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

#if defined(ENABLE_OVERLOADING)
data AccessibleGetWidgetMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsAccessible a) => O.MethodInfo AccessibleGetWidgetMethodInfo a signature where
    overloadedMethod = accessibleGetWidget

#endif

-- method Accessible::set_widget
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Accessible" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkAccessible" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWidget or %NULL to unset"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_accessible_set_widget" gtk_accessible_set_widget :: 
    Ptr Accessible ->                       -- accessible : TInterface (Name {namespace = "Gtk", name = "Accessible"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the t'GI.Gtk.Objects.Widget.Widget' corresponding to the t'GI.Gtk.Objects.Accessible.Accessible'.
-- 
-- /@accessible@/ will not hold a reference to /@widget@/.
-- It is the caller’s responsibility to ensure that when /@widget@/
-- is destroyed, the widget is unset by calling this function
-- again with /@widget@/ set to 'P.Nothing'.
-- 
-- /Since: 2.22/
accessibleSetWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsAccessible a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@accessible@/: a t'GI.Gtk.Objects.Accessible.Accessible'
    -> Maybe (b)
    -- ^ /@widget@/: a t'GI.Gtk.Objects.Widget.Widget' or 'P.Nothing' to unset
    -> m ()
accessibleSetWidget :: a -> Maybe b -> m ()
accessibleSetWidget accessible :: a
accessible widget :: Maybe b
widget = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Accessible
accessible' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    Ptr Widget
maybeWidget <- case Maybe b
widget of
        Nothing -> Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just jWidget :: b
jWidget -> do
            Ptr Widget
jWidget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jWidget
            Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jWidget'
    Ptr Accessible -> Ptr Widget -> IO ()
gtk_accessible_set_widget Ptr Accessible
accessible' Ptr Widget
maybeWidget
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
accessible
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
widget b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data AccessibleSetWidgetMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsAccessible a, Gtk.Widget.IsWidget b) => O.MethodInfo AccessibleSetWidgetMethodInfo a signature where
    overloadedMethod = accessibleSetWidget

#endif