{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Describes a breakpoint for [class/@window@/] or [class/@dialog@/].
-- 
-- Breakpoints are used to create adaptive UI, allowing to change the layout
-- depending on available size.
-- 
-- Breakpoint is a size threshold, specified by its condition, as well as one or
-- more setters.
-- 
-- Each setter has a target object, a property and a value. When a breakpoint
-- is applied, each setter sets the target property on their target object to
-- the specified value, and reset it back to the original value when it\'s
-- unapplied.
-- 
-- For more complicated scenarios, [signal/@breakpoint@/[apply](#g:signal:apply)] and
-- [signal/@breakpoint@/[unapply](#g:signal:unapply)] can be used instead.
-- 
-- Breakpoints can be used within [class/@window@/], [class/@applicationWindow@/],
-- [class/@dialog@/] or [class/@breakpointBin@/].
-- 
-- == @AdwBreakpoint@ as @GtkBuildable@:
-- 
-- @AdwBreakpoint@ supports specifying its condition via the @\<condition>@
-- element. The contents of the element must be a string in a format accepted by
-- @/BreakpointCondition.parse/@.
-- 
-- It also supports adding setters via the @\<setter>@ element. Each @\<setter>@
-- element must have the @object@ attribute specifying the target object, and
-- the @property@ attribute specifying the property name. The contents of the
-- element are used as the setter value.
-- 
-- For @G_TYPE_OBJECT@ and @G_TYPE_BOXED@ derived properties, empty contents are
-- treated as @NULL@.
-- 
-- Setter values can be translated with the usual @translatable@, @context@ and
-- @comments@ attributes.
-- 
-- Example of an @AdwBreakpoint@ UI definition:
-- 
-- 
-- === /xml code/
-- ><object class="AdwBreakpoint">
-- >  <condition>max-width: 400px</condition>
-- >  <setter object="button" property="visible">True</setter>
-- >  <setter object="box" property="orientation">vertical</setter>
-- >  <setter object="page" property="title" translatable="yes">Example</setter>
-- ></object>
-- 
-- 
-- /Since: 1.4/

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

module GI.Adw.Objects.Breakpoint
    ( 

-- * Exported types
    Breakpoint(..)                          ,
    IsBreakpoint                            ,
    toBreakpoint                            ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveBreakpointMethod                 ,
#endif

-- ** addSetter #method:addSetter#

#if defined(ENABLE_OVERLOADING)
    BreakpointAddSetterMethodInfo           ,
#endif
    breakpointAddSetter                     ,


-- ** addSetters #method:addSetters#

#if defined(ENABLE_OVERLOADING)
    BreakpointAddSettersMethodInfo          ,
#endif
    breakpointAddSetters                    ,


-- ** getCondition #method:getCondition#

#if defined(ENABLE_OVERLOADING)
    BreakpointGetConditionMethodInfo        ,
#endif
    breakpointGetCondition                  ,


-- ** new #method:new#

    breakpointNew                           ,


-- ** setCondition #method:setCondition#

#if defined(ENABLE_OVERLOADING)
    BreakpointSetConditionMethodInfo        ,
#endif
    breakpointSetCondition                  ,




 -- * Properties


-- ** condition #attr:condition#
-- | The breakpoint\'s condition.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    BreakpointConditionPropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    breakpointCondition                     ,
#endif
    clearBreakpointCondition                ,
    constructBreakpointCondition            ,
    getBreakpointCondition                  ,
    setBreakpointCondition                  ,




 -- * Signals


-- ** apply #signal:apply#

    BreakpointApplyCallback                 ,
#if defined(ENABLE_OVERLOADING)
    BreakpointApplySignalInfo               ,
#endif
    afterBreakpointApply                    ,
    onBreakpointApply                       ,


-- ** unapply #signal:unapply#

    BreakpointUnapplyCallback               ,
#if defined(ENABLE_OVERLOADING)
    BreakpointUnapplySignalInfo             ,
#endif
    afterBreakpointUnapply                  ,
    onBreakpointUnapply                     ,




    ) 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

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.Adw.Enums as Adw.Enums
import {-# SOURCE #-} qualified GI.Adw.Structs.BreakpointCondition as Adw.BreakpointCondition
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable

#else
import {-# SOURCE #-} qualified GI.Adw.Structs.BreakpointCondition as Adw.BreakpointCondition
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable

#endif

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

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

foreign import ccall "adw_breakpoint_get_type"
    c_adw_breakpoint_get_type :: IO B.Types.GType

instance B.Types.TypedObject Breakpoint where
    glibType :: IO GType
glibType = IO GType
c_adw_breakpoint_get_type

instance B.Types.GObject Breakpoint

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

instance O.HasParentTypes Breakpoint
type instance O.ParentTypes Breakpoint = '[GObject.Object.Object, Gtk.Buildable.Buildable]

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveBreakpointMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveBreakpointMethod "addSetter" o = BreakpointAddSetterMethodInfo
    ResolveBreakpointMethod "addSetters" o = BreakpointAddSettersMethodInfo
    ResolveBreakpointMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveBreakpointMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveBreakpointMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveBreakpointMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveBreakpointMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveBreakpointMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveBreakpointMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveBreakpointMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveBreakpointMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveBreakpointMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveBreakpointMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveBreakpointMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveBreakpointMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveBreakpointMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveBreakpointMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveBreakpointMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveBreakpointMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveBreakpointMethod "getCondition" o = BreakpointGetConditionMethodInfo
    ResolveBreakpointMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveBreakpointMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveBreakpointMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveBreakpointMethod "setCondition" o = BreakpointSetConditionMethodInfo
    ResolveBreakpointMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveBreakpointMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveBreakpointMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveBreakpointMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveBreakpointMethod t Breakpoint, O.OverloadedMethod info Breakpoint p) => OL.IsLabel t (Breakpoint -> 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 ~ ResolveBreakpointMethod t Breakpoint, O.OverloadedMethod info Breakpoint p, R.HasField t Breakpoint p) => R.HasField t Breakpoint p where
    getField = O.overloadedMethod @info

#endif

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

#endif

-- signal Breakpoint::apply
-- | Emitted when the breakpoint is applied.
-- 
-- This signal is emitted after the setters have been applied.
-- 
-- /Since: 1.4/
type BreakpointApplyCallback =
    IO ()

type C_BreakpointApplyCallback =
    Ptr Breakpoint ->                       -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_BreakpointApplyCallback`.
foreign import ccall "wrapper"
    mk_BreakpointApplyCallback :: C_BreakpointApplyCallback -> IO (FunPtr C_BreakpointApplyCallback)

wrap_BreakpointApplyCallback :: 
    GObject a => (a -> BreakpointApplyCallback) ->
    C_BreakpointApplyCallback
wrap_BreakpointApplyCallback :: forall a. GObject a => (a -> IO ()) -> C_BreakpointApplyCallback
wrap_BreakpointApplyCallback a -> IO ()
gi'cb Ptr Breakpoint
gi'selfPtr Ptr ()
_ = do
    Ptr Breakpoint -> (Breakpoint -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Breakpoint
gi'selfPtr ((Breakpoint -> IO ()) -> IO ()) -> (Breakpoint -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Breakpoint
gi'self -> a -> IO ()
gi'cb (Breakpoint -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Breakpoint
gi'self) 


-- | Connect a signal handler for the [apply](#signal:apply) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' breakpoint #apply callback
-- @
-- 
-- 
onBreakpointApply :: (IsBreakpoint a, MonadIO m) => a -> ((?self :: a) => BreakpointApplyCallback) -> m SignalHandlerId
onBreakpointApply :: forall a (m :: * -> *).
(IsBreakpoint a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onBreakpointApply a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_BreakpointApplyCallback
wrapped' = (a -> IO ()) -> C_BreakpointApplyCallback
forall a. GObject a => (a -> IO ()) -> C_BreakpointApplyCallback
wrap_BreakpointApplyCallback a -> IO ()
wrapped
    FunPtr C_BreakpointApplyCallback
wrapped'' <- C_BreakpointApplyCallback -> IO (FunPtr C_BreakpointApplyCallback)
mk_BreakpointApplyCallback C_BreakpointApplyCallback
wrapped'
    a
-> Text
-> FunPtr C_BreakpointApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"apply" FunPtr C_BreakpointApplyCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [apply](#signal:apply) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' breakpoint #apply callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterBreakpointApply :: (IsBreakpoint a, MonadIO m) => a -> ((?self :: a) => BreakpointApplyCallback) -> m SignalHandlerId
afterBreakpointApply :: forall a (m :: * -> *).
(IsBreakpoint a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterBreakpointApply a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_BreakpointApplyCallback
wrapped' = (a -> IO ()) -> C_BreakpointApplyCallback
forall a. GObject a => (a -> IO ()) -> C_BreakpointApplyCallback
wrap_BreakpointApplyCallback a -> IO ()
wrapped
    FunPtr C_BreakpointApplyCallback
wrapped'' <- C_BreakpointApplyCallback -> IO (FunPtr C_BreakpointApplyCallback)
mk_BreakpointApplyCallback C_BreakpointApplyCallback
wrapped'
    a
-> Text
-> FunPtr C_BreakpointApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"apply" FunPtr C_BreakpointApplyCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data BreakpointApplySignalInfo
instance SignalInfo BreakpointApplySignalInfo where
    type HaskellCallbackType BreakpointApplySignalInfo = BreakpointApplyCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_BreakpointApplyCallback cb
        cb'' <- mk_BreakpointApplyCallback cb'
        connectSignalFunPtr obj "apply" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Breakpoint::apply"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Breakpoint.html#g:signal:apply"})

#endif

-- signal Breakpoint::unapply
-- | Emitted when the breakpoint is unapplied.
-- 
-- This signal is emitted before resetting the setter values.
-- 
-- /Since: 1.4/
type BreakpointUnapplyCallback =
    IO ()

type C_BreakpointUnapplyCallback =
    Ptr Breakpoint ->                       -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_BreakpointUnapplyCallback`.
foreign import ccall "wrapper"
    mk_BreakpointUnapplyCallback :: C_BreakpointUnapplyCallback -> IO (FunPtr C_BreakpointUnapplyCallback)

wrap_BreakpointUnapplyCallback :: 
    GObject a => (a -> BreakpointUnapplyCallback) ->
    C_BreakpointUnapplyCallback
wrap_BreakpointUnapplyCallback :: forall a. GObject a => (a -> IO ()) -> C_BreakpointApplyCallback
wrap_BreakpointUnapplyCallback a -> IO ()
gi'cb Ptr Breakpoint
gi'selfPtr Ptr ()
_ = do
    Ptr Breakpoint -> (Breakpoint -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Breakpoint
gi'selfPtr ((Breakpoint -> IO ()) -> IO ()) -> (Breakpoint -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Breakpoint
gi'self -> a -> IO ()
gi'cb (Breakpoint -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Breakpoint
gi'self) 


-- | Connect a signal handler for the [unapply](#signal:unapply) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' breakpoint #unapply callback
-- @
-- 
-- 
onBreakpointUnapply :: (IsBreakpoint a, MonadIO m) => a -> ((?self :: a) => BreakpointUnapplyCallback) -> m SignalHandlerId
onBreakpointUnapply :: forall a (m :: * -> *).
(IsBreakpoint a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onBreakpointUnapply a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_BreakpointApplyCallback
wrapped' = (a -> IO ()) -> C_BreakpointApplyCallback
forall a. GObject a => (a -> IO ()) -> C_BreakpointApplyCallback
wrap_BreakpointUnapplyCallback a -> IO ()
wrapped
    FunPtr C_BreakpointApplyCallback
wrapped'' <- C_BreakpointApplyCallback -> IO (FunPtr C_BreakpointApplyCallback)
mk_BreakpointUnapplyCallback C_BreakpointApplyCallback
wrapped'
    a
-> Text
-> FunPtr C_BreakpointApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"unapply" FunPtr C_BreakpointApplyCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [unapply](#signal:unapply) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' breakpoint #unapply callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterBreakpointUnapply :: (IsBreakpoint a, MonadIO m) => a -> ((?self :: a) => BreakpointUnapplyCallback) -> m SignalHandlerId
afterBreakpointUnapply :: forall a (m :: * -> *).
(IsBreakpoint a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterBreakpointUnapply a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_BreakpointApplyCallback
wrapped' = (a -> IO ()) -> C_BreakpointApplyCallback
forall a. GObject a => (a -> IO ()) -> C_BreakpointApplyCallback
wrap_BreakpointUnapplyCallback a -> IO ()
wrapped
    FunPtr C_BreakpointApplyCallback
wrapped'' <- C_BreakpointApplyCallback -> IO (FunPtr C_BreakpointApplyCallback)
mk_BreakpointUnapplyCallback C_BreakpointApplyCallback
wrapped'
    a
-> Text
-> FunPtr C_BreakpointApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"unapply" FunPtr C_BreakpointApplyCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data BreakpointUnapplySignalInfo
instance SignalInfo BreakpointUnapplySignalInfo where
    type HaskellCallbackType BreakpointUnapplySignalInfo = BreakpointUnapplyCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_BreakpointUnapplyCallback cb
        cb'' <- mk_BreakpointUnapplyCallback cb'
        connectSignalFunPtr obj "unapply" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Breakpoint::unapply"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Breakpoint.html#g:signal:unapply"})

#endif

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

-- | Get the value of the “@condition@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' breakpoint #condition
-- @
getBreakpointCondition :: (MonadIO m, IsBreakpoint o) => o -> m (Maybe Adw.BreakpointCondition.BreakpointCondition)
getBreakpointCondition :: forall (m :: * -> *) o.
(MonadIO m, IsBreakpoint o) =>
o -> m (Maybe BreakpointCondition)
getBreakpointCondition o
obj = IO (Maybe BreakpointCondition) -> m (Maybe BreakpointCondition)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe BreakpointCondition) -> m (Maybe BreakpointCondition))
-> IO (Maybe BreakpointCondition) -> m (Maybe BreakpointCondition)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr BreakpointCondition -> BreakpointCondition)
-> IO (Maybe BreakpointCondition)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"condition" ManagedPtr BreakpointCondition -> BreakpointCondition
Adw.BreakpointCondition.BreakpointCondition

-- | Set the value of the “@condition@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' breakpoint [ #condition 'Data.GI.Base.Attributes.:=' value ]
-- @
setBreakpointCondition :: (MonadIO m, IsBreakpoint o) => o -> Adw.BreakpointCondition.BreakpointCondition -> m ()
setBreakpointCondition :: forall (m :: * -> *) o.
(MonadIO m, IsBreakpoint o) =>
o -> BreakpointCondition -> m ()
setBreakpointCondition o
obj BreakpointCondition
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 BreakpointCondition -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"condition" (BreakpointCondition -> Maybe BreakpointCondition
forall a. a -> Maybe a
Just BreakpointCondition
val)

-- | Construct a `GValueConstruct` with valid value for the “@condition@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructBreakpointCondition :: (IsBreakpoint o, MIO.MonadIO m) => Adw.BreakpointCondition.BreakpointCondition -> m (GValueConstruct o)
constructBreakpointCondition :: forall o (m :: * -> *).
(IsBreakpoint o, MonadIO m) =>
BreakpointCondition -> m (GValueConstruct o)
constructBreakpointCondition BreakpointCondition
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 BreakpointCondition -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"condition" (BreakpointCondition -> Maybe BreakpointCondition
forall a. a -> Maybe a
P.Just BreakpointCondition
val)

-- | Set the value of the “@condition@” 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' #condition
-- @
clearBreakpointCondition :: (MonadIO m, IsBreakpoint o) => o -> m ()
clearBreakpointCondition :: forall (m :: * -> *) o. (MonadIO m, IsBreakpoint o) => o -> m ()
clearBreakpointCondition 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 BreakpointCondition -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"condition" (Maybe BreakpointCondition
forall a. Maybe a
Nothing :: Maybe Adw.BreakpointCondition.BreakpointCondition)

#if defined(ENABLE_OVERLOADING)
data BreakpointConditionPropertyInfo
instance AttrInfo BreakpointConditionPropertyInfo where
    type AttrAllowedOps BreakpointConditionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint BreakpointConditionPropertyInfo = IsBreakpoint
    type AttrSetTypeConstraint BreakpointConditionPropertyInfo = (~) Adw.BreakpointCondition.BreakpointCondition
    type AttrTransferTypeConstraint BreakpointConditionPropertyInfo = (~) Adw.BreakpointCondition.BreakpointCondition
    type AttrTransferType BreakpointConditionPropertyInfo = Adw.BreakpointCondition.BreakpointCondition
    type AttrGetType BreakpointConditionPropertyInfo = (Maybe Adw.BreakpointCondition.BreakpointCondition)
    type AttrLabel BreakpointConditionPropertyInfo = "condition"
    type AttrOrigin BreakpointConditionPropertyInfo = Breakpoint
    attrGet = getBreakpointCondition
    attrSet = setBreakpointCondition
    attrTransfer _ v = do
        return v
    attrConstruct = constructBreakpointCondition
    attrClear = clearBreakpointCondition
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Breakpoint.condition"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Breakpoint.html#g:attr:condition"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Breakpoint
type instance O.AttributeList Breakpoint = BreakpointAttributeList
type BreakpointAttributeList = ('[ '("condition", BreakpointConditionPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
breakpointCondition :: AttrLabelProxy "condition"
breakpointCondition = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Breakpoint = BreakpointSignalList
type BreakpointSignalList = ('[ '("apply", BreakpointApplySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("unapply", BreakpointUnapplySignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method Breakpoint::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "condition"
--           , argType =
--               TInterface
--                 Name { namespace = "Adw" , name = "BreakpointCondition" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the condition" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "Breakpoint" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_breakpoint_new" adw_breakpoint_new :: 
    Ptr Adw.BreakpointCondition.BreakpointCondition -> -- condition : TInterface (Name {namespace = "Adw", name = "BreakpointCondition"})
    IO (Ptr Breakpoint)

-- | Creates a new @AdwBreakpoint@ with /@condition@/.
-- 
-- /Since: 1.4/
breakpointNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Adw.BreakpointCondition.BreakpointCondition
    -- ^ /@condition@/: the condition
    -> m Breakpoint
    -- ^ __Returns:__ the newly created @AdwBreakpoint@
breakpointNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BreakpointCondition -> m Breakpoint
breakpointNew BreakpointCondition
condition = IO Breakpoint -> m Breakpoint
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Breakpoint -> m Breakpoint) -> IO Breakpoint -> m Breakpoint
forall a b. (a -> b) -> a -> b
$ do
    Ptr BreakpointCondition
condition' <- BreakpointCondition -> IO (Ptr BreakpointCondition)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed BreakpointCondition
condition
    Ptr Breakpoint
result <- Ptr BreakpointCondition -> IO (Ptr Breakpoint)
adw_breakpoint_new Ptr BreakpointCondition
condition'
    Text -> Ptr Breakpoint -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"breakpointNew" Ptr Breakpoint
result
    Breakpoint
result' <- ((ManagedPtr Breakpoint -> Breakpoint)
-> Ptr Breakpoint -> IO Breakpoint
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Breakpoint -> Breakpoint
Breakpoint) Ptr Breakpoint
result
    BreakpointCondition -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BreakpointCondition
condition
    Breakpoint -> IO Breakpoint
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Breakpoint
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Breakpoint::add_setter
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Breakpoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a breakpoint" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the target object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the target property"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TGValue
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the value to set" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_breakpoint_add_setter" adw_breakpoint_add_setter :: 
    Ptr Breakpoint ->                       -- self : TInterface (Name {namespace = "Adw", name = "Breakpoint"})
    Ptr GObject.Object.Object ->            -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    CString ->                              -- property : TBasicType TUTF8
    Ptr GValue ->                           -- value : TGValue
    IO ()

-- | Adds a setter to /@self@/.
-- 
-- The setter will automatically set /@property@/ on /@object@/ to /@value@/ when
-- applying the breakpoint, and set it back to its original value upon
-- unapplying it.
-- 
-- ::: note
--     Setting properties to their original values does not work for properties
--     that have irreversible side effects. For example, changing
--     [Button:label]("GI.Gtk.Objects.Button#g:attr:label") while [Button:iconName]("GI.Gtk.Objects.Button#g:attr:iconName") is set
--     will reset the icon. However, resetting the label will not set
--     @icon-name@ to its original value.
-- 
-- Use the [signal/@breakpoint@/[apply](#g:signal:apply)] and [signal/@breakpoint@/[unapply](#g:signal:unapply)] signals
-- for those properties instead, as follows:
-- 
-- 
-- === /c code/
-- >static void
-- >breakpoint_apply_cb (MyWidget *self)
-- >{
-- >  gtk_button_set_icon_name (self->button, "go-previous-symbolic");
-- >}
-- >
-- >static void
-- >breakpoint_apply_cb (MyWidget *self)
-- >{
-- >  gtk_button_set_label (self->button, _("_Back"));
-- >}
-- >
-- >// ...
-- >
-- >g_signal_connect_swapped (breakpoint, "apply",
-- >                          G_CALLBACK (breakpoint_apply_cb), self);
-- >g_signal_connect_swapped (breakpoint, "unapply",
-- >                          G_CALLBACK (breakpoint_unapply_cb), self);
-- 
-- 
-- /Since: 1.4/
breakpointAddSetter ::
    (B.CallStack.HasCallStack, MonadIO m, IsBreakpoint a, GObject.Object.IsObject b) =>
    a
    -- ^ /@self@/: a breakpoint
    -> b
    -- ^ /@object@/: the target object
    -> T.Text
    -- ^ /@property@/: the target property
    -> Maybe (GValue)
    -- ^ /@value@/: the value to set
    -> m ()
breakpointAddSetter :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsBreakpoint a, IsObject b) =>
a -> b -> Text -> Maybe GValue -> m ()
breakpointAddSetter a
self b
object Text
property Maybe GValue
value = 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 Breakpoint
self' <- a -> IO (Ptr Breakpoint)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Object
object' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
object
    CString
property' <- Text -> IO CString
textToCString Text
property
    Ptr GValue
maybeValue <- case Maybe GValue
value of
        Maybe GValue
Nothing -> Ptr GValue -> IO (Ptr GValue)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GValue
forall a. Ptr a
nullPtr
        Just GValue
jValue -> do
            Ptr GValue
jValue' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
jValue
            Ptr GValue -> IO (Ptr GValue)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GValue
jValue'
    Ptr Breakpoint -> Ptr Object -> CString -> Ptr GValue -> IO ()
adw_breakpoint_add_setter Ptr Breakpoint
self' Ptr Object
object' CString
property' Ptr GValue
maybeValue
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
object
    Maybe GValue -> (GValue -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GValue
value GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
property'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BreakpointAddSetterMethodInfo
instance (signature ~ (b -> T.Text -> Maybe (GValue) -> m ()), MonadIO m, IsBreakpoint a, GObject.Object.IsObject b) => O.OverloadedMethod BreakpointAddSetterMethodInfo a signature where
    overloadedMethod = breakpointAddSetter

instance O.OverloadedMethodInfo BreakpointAddSetterMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Breakpoint.breakpointAddSetter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Breakpoint.html#v:breakpointAddSetter"
        })


#endif

-- method Breakpoint::add_setters
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Breakpoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a breakpoint" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_setters"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of setters to add"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "objects"
--           , argType =
--               TCArray
--                 False
--                 (-1)
--                 1
--                 (TInterface Name { namespace = "GObject" , name = "Object" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "setter target object"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "names"
--           , argType = TCArray False (-1) 1 (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "setter target properties"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "values"
--           , argType = TCArray False (-1) 1 TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "setter values" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_setters"
--              , argType = TBasicType TInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the number of setters to add"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          , Arg
--              { argCName = "n_setters"
--              , argType = TBasicType TInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the number of setters to add"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          , Arg
--              { argCName = "n_setters"
--              , argType = TBasicType TInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the number of setters to add"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_breakpoint_add_settersv" adw_breakpoint_add_settersv :: 
    Ptr Breakpoint ->                       -- self : TInterface (Name {namespace = "Adw", name = "Breakpoint"})
    Int32 ->                                -- n_setters : TBasicType TInt
    Ptr (Ptr GObject.Object.Object) ->      -- objects : TCArray False (-1) 1 (TInterface (Name {namespace = "GObject", name = "Object"}))
    Ptr CString ->                          -- names : TCArray False (-1) 1 (TBasicType TUTF8)
    Ptr B.GValue.GValue ->                  -- values : TCArray False (-1) 1 TGValue
    IO ()

-- | Adds /@nSetters@/ setters to /@self@/.
-- 
-- This is a convenience function for adding multiple setters at once.
-- 
-- See [method/@breakpoint@/.add_setter].
-- 
-- This function is meant to be used by language bindings.
-- 
-- /Since: 1.4/
breakpointAddSetters ::
    (B.CallStack.HasCallStack, MonadIO m, IsBreakpoint a) =>
    a
    -- ^ /@self@/: a breakpoint
    -> [GObject.Object.Object]
    -- ^ /@objects@/: setter target object
    -> [T.Text]
    -- ^ /@names@/: setter target properties
    -> [GValue]
    -- ^ /@values@/: setter values
    -> m ()
breakpointAddSetters :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBreakpoint a) =>
a -> [Object] -> [Text] -> [GValue] -> m ()
breakpointAddSetters a
self [Object]
objects [Text]
names [GValue]
values = 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
    let nSetters :: Int32
nSetters = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [GValue] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [GValue]
values
    let names_expected_length_ :: Int32
names_expected_length_ = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [Text] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Text]
names
    Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int32
names_expected_length_ Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Int32
nSetters) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
        String -> IO ()
forall a. HasCallStack => String -> a
error String
"Adw.breakpointAddSetters : length of 'names' does not agree with that of 'values'."
    let objects_expected_length_ :: Int32
objects_expected_length_ = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [Object] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Object]
objects
    Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int32
objects_expected_length_ Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Int32
nSetters) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
        String -> IO ()
forall a. HasCallStack => String -> a
error String
"Adw.breakpointAddSetters : length of 'objects' does not agree with that of 'names'."
    Ptr Breakpoint
self' <- a -> IO (Ptr Breakpoint)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    [Ptr Object]
objects' <- (Object -> IO (Ptr Object)) -> [Object] -> IO [Ptr Object]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Object -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [Object]
objects
    Ptr (Ptr Object)
objects'' <- [Ptr Object] -> IO (Ptr (Ptr Object))
forall a. [Ptr a] -> IO (Ptr (Ptr a))
packPtrArray [Ptr Object]
objects'
    Ptr CString
names' <- [Text] -> IO (Ptr CString)
packUTF8CArray [Text]
names
    Ptr GValue
values' <- [GValue] -> IO (Ptr GValue)
B.GValue.packGValueArray [GValue]
values
    Ptr Breakpoint
-> Int32 -> Ptr (Ptr Object) -> Ptr CString -> Ptr GValue -> IO ()
adw_breakpoint_add_settersv Ptr Breakpoint
self' Int32
nSetters Ptr (Ptr Object)
objects'' Ptr CString
names' Ptr GValue
values'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    (Object -> IO ()) -> [Object] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Object -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [Object]
objects
    (GValue -> IO ()) -> [GValue] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [GValue]
values
    Ptr (Ptr Object) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Object)
objects''
    (Int32 -> (CString -> IO ()) -> Ptr CString -> IO ()
forall a b c.
(Storable a, Integral b) =>
b -> (a -> IO c) -> Ptr a -> IO ()
mapCArrayWithLength Int32
nSetters) CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
names'
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
names'
    Ptr GValue -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr GValue
values'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BreakpointAddSettersMethodInfo
instance (signature ~ ([GObject.Object.Object] -> [T.Text] -> [GValue] -> m ()), MonadIO m, IsBreakpoint a) => O.OverloadedMethod BreakpointAddSettersMethodInfo a signature where
    overloadedMethod = breakpointAddSetters

instance O.OverloadedMethodInfo BreakpointAddSettersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Breakpoint.breakpointAddSetters",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Breakpoint.html#v:breakpointAddSetters"
        })


#endif

-- method Breakpoint::get_condition
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Breakpoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a breakpoint" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Adw" , name = "BreakpointCondition" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_breakpoint_get_condition" adw_breakpoint_get_condition :: 
    Ptr Breakpoint ->                       -- self : TInterface (Name {namespace = "Adw", name = "Breakpoint"})
    IO (Ptr Adw.BreakpointCondition.BreakpointCondition)

-- | Gets the condition for /@self@/.
-- 
-- /Since: 1.4/
breakpointGetCondition ::
    (B.CallStack.HasCallStack, MonadIO m, IsBreakpoint a) =>
    a
    -- ^ /@self@/: a breakpoint
    -> m (Maybe Adw.BreakpointCondition.BreakpointCondition)
    -- ^ __Returns:__ the condition
breakpointGetCondition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBreakpoint a) =>
a -> m (Maybe BreakpointCondition)
breakpointGetCondition a
self = IO (Maybe BreakpointCondition) -> m (Maybe BreakpointCondition)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BreakpointCondition) -> m (Maybe BreakpointCondition))
-> IO (Maybe BreakpointCondition) -> m (Maybe BreakpointCondition)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Breakpoint
self' <- a -> IO (Ptr Breakpoint)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr BreakpointCondition
result <- Ptr Breakpoint -> IO (Ptr BreakpointCondition)
adw_breakpoint_get_condition Ptr Breakpoint
self'
    Maybe BreakpointCondition
maybeResult <- Ptr BreakpointCondition
-> (Ptr BreakpointCondition -> IO BreakpointCondition)
-> IO (Maybe BreakpointCondition)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BreakpointCondition
result ((Ptr BreakpointCondition -> IO BreakpointCondition)
 -> IO (Maybe BreakpointCondition))
-> (Ptr BreakpointCondition -> IO BreakpointCondition)
-> IO (Maybe BreakpointCondition)
forall a b. (a -> b) -> a -> b
$ \Ptr BreakpointCondition
result' -> do
        BreakpointCondition
result'' <- ((ManagedPtr BreakpointCondition -> BreakpointCondition)
-> Ptr BreakpointCondition -> IO BreakpointCondition
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr BreakpointCondition -> BreakpointCondition
Adw.BreakpointCondition.BreakpointCondition) Ptr BreakpointCondition
result'
        BreakpointCondition -> IO BreakpointCondition
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BreakpointCondition
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe BreakpointCondition -> IO (Maybe BreakpointCondition)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BreakpointCondition
maybeResult

#if defined(ENABLE_OVERLOADING)
data BreakpointGetConditionMethodInfo
instance (signature ~ (m (Maybe Adw.BreakpointCondition.BreakpointCondition)), MonadIO m, IsBreakpoint a) => O.OverloadedMethod BreakpointGetConditionMethodInfo a signature where
    overloadedMethod = breakpointGetCondition

instance O.OverloadedMethodInfo BreakpointGetConditionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Breakpoint.breakpointGetCondition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Breakpoint.html#v:breakpointGetCondition"
        })


#endif

-- method Breakpoint::set_condition
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Breakpoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a breakpoint" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "condition"
--           , argType =
--               TInterface
--                 Name { namespace = "Adw" , name = "BreakpointCondition" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new condition" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_breakpoint_set_condition" adw_breakpoint_set_condition :: 
    Ptr Breakpoint ->                       -- self : TInterface (Name {namespace = "Adw", name = "Breakpoint"})
    Ptr Adw.BreakpointCondition.BreakpointCondition -> -- condition : TInterface (Name {namespace = "Adw", name = "BreakpointCondition"})
    IO ()

-- | Sets the condition for /@self@/.
-- 
-- /Since: 1.4/
breakpointSetCondition ::
    (B.CallStack.HasCallStack, MonadIO m, IsBreakpoint a) =>
    a
    -- ^ /@self@/: a breakpoint
    -> Maybe (Adw.BreakpointCondition.BreakpointCondition)
    -- ^ /@condition@/: the new condition
    -> m ()
breakpointSetCondition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBreakpoint a) =>
a -> Maybe BreakpointCondition -> m ()
breakpointSetCondition a
self Maybe BreakpointCondition
condition = 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 Breakpoint
self' <- a -> IO (Ptr Breakpoint)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr BreakpointCondition
maybeCondition <- case Maybe BreakpointCondition
condition of
        Maybe BreakpointCondition
Nothing -> Ptr BreakpointCondition -> IO (Ptr BreakpointCondition)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr BreakpointCondition
forall a. Ptr a
nullPtr
        Just BreakpointCondition
jCondition -> do
            Ptr BreakpointCondition
jCondition' <- BreakpointCondition -> IO (Ptr BreakpointCondition)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BreakpointCondition
jCondition
            Ptr BreakpointCondition -> IO (Ptr BreakpointCondition)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr BreakpointCondition
jCondition'
    Ptr Breakpoint -> Ptr BreakpointCondition -> IO ()
adw_breakpoint_set_condition Ptr Breakpoint
self' Ptr BreakpointCondition
maybeCondition
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe BreakpointCondition
-> (BreakpointCondition -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe BreakpointCondition
condition BreakpointCondition -> 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 BreakpointSetConditionMethodInfo
instance (signature ~ (Maybe (Adw.BreakpointCondition.BreakpointCondition) -> m ()), MonadIO m, IsBreakpoint a) => O.OverloadedMethod BreakpointSetConditionMethodInfo a signature where
    overloadedMethod = breakpointSetCondition

instance O.OverloadedMethodInfo BreakpointSetConditionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Breakpoint.breakpointSetCondition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Breakpoint.html#v:breakpointSetCondition"
        })


#endif