    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A range of pages to print.
    --
    -- See also 'GI.Gtk.Objects.PrintSettings.printSettingsSetPageRanges'.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gtk.Structs.PageRange
        (

    -- * Exported types
        PageRange(..)                           ,
        newZeroPageRange                        ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolvePageRangeMethod                  ,
    #endif

     -- * Properties

    -- ** end #attr:end#
    -- | end of page range.

        getPageRangeEnd                         ,
    #if defined(ENABLE_OVERLOADING)
        pageRange_end                           ,
    #endif
        setPageRangeEnd                         ,

    -- ** start #attr:start#
    -- | start of page range.

        getPageRangeStart                       ,
    #if defined(ENABLE_OVERLOADING)
        pageRange_start                         ,
    #endif
        setPageRangeStart                       ,

        ) 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)

    #else

    #endif

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

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

    instance BoxedPtr PageRange where
        boxedPtrCopy :: PageRange -> IO PageRange
    boxedPtrCopy = \PageRange
    p -> PageRange -> (Ptr PageRange -> IO PageRange) -> IO PageRange
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr PageRange
    p (Int -> Ptr PageRange -> IO (Ptr PageRange)
    forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
    copyBytes Int
    8 (Ptr PageRange -> IO (Ptr PageRange))
    -> (Ptr PageRange -> IO PageRange) -> Ptr PageRange -> IO PageRange
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> (ManagedPtr PageRange -> PageRange)
    -> Ptr PageRange -> IO PageRange
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.wrapPtr ManagedPtr PageRange -> PageRange
    PageRange)
        boxedPtrFree :: PageRange -> IO ()
    boxedPtrFree = \PageRange
    x -> PageRange -> (Ptr PageRange -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    SP.withManagedPtr PageRange
    x Ptr PageRange -> IO ()
    forall a. Ptr a -> IO ()
    SP.freeMem
    instance CallocPtr PageRange where
        boxedPtrCalloc :: IO (Ptr PageRange)
    boxedPtrCalloc = Int -> IO (Ptr PageRange)
    forall a. Int -> IO (Ptr a)
    callocBytes Int
    8

    -- | Construct a t'PageRange' struct initialized to zero.
    newZeroPageRange :: MonadIO m => m PageRange
    newZeroPageRange :: forall (m :: * -> *). MonadIO m => m PageRange
    newZeroPageRange = IO PageRange -> m PageRange
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO PageRange -> m PageRange) -> IO PageRange -> m PageRange
    forall a b. (a -> b) -> a -> b
    $ IO (Ptr PageRange)
    forall a. CallocPtr a => IO (Ptr a)
    boxedPtrCalloc IO (Ptr PageRange)
    -> (Ptr PageRange -> IO PageRange) -> IO PageRange
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr PageRange -> PageRange)
    -> Ptr PageRange -> IO PageRange
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr PageRange -> PageRange
    PageRange

    instance tag ~ 'AttrSet => Constructible PageRange tag where
        new :: forall (m :: * -> *).
    MonadIO m =>
    (ManagedPtr PageRange -> PageRange)
    -> [AttrOp PageRange tag] -> m PageRange
    new ManagedPtr PageRange -> PageRange
    _ [AttrOp PageRange tag]
    attrs = do
            o <- m PageRange
    forall (m :: * -> *). MonadIO m => m PageRange
    newZeroPageRange
            GI.Attributes.set o attrs
            return o

    -- | Get the value of the “@start@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' pageRange #start
    -- @
    getPageRangeStart :: MonadIO m => PageRange -> m Int32
    getPageRangeStart :: forall (m :: * -> *). MonadIO m => PageRange -> m Int32
    getPageRangeStart PageRange
    s = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ PageRange -> (Ptr PageRange -> IO Int32) -> IO Int32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr PageRange
    s ((Ptr PageRange -> IO Int32) -> IO Int32)
    -> (Ptr PageRange -> IO Int32) -> IO Int32
    forall a b. (a -> b) -> a -> b
    $ \Ptr PageRange
    ptr -> do
        val <- Ptr Int32 -> IO Int32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr PageRange
    ptr Ptr PageRange -> Int -> Ptr Int32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) :: IO Int32
        return val

    -- | Set the value of the “@start@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' pageRange [ #start 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setPageRangeStart :: MonadIO m => PageRange -> Int32 -> m ()
    setPageRangeStart :: forall (m :: * -> *). MonadIO m => PageRange -> Int32 -> m ()
    setPageRangeStart PageRange
    s Int32
    val = 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
    $ PageRange -> (Ptr PageRange -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr PageRange
    s ((Ptr PageRange -> IO ()) -> IO ())
    -> (Ptr PageRange -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr PageRange
    ptr -> do
        Ptr Int32 -> Int32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr PageRange
    ptr Ptr PageRange -> Int -> Ptr Int32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Int32
    val :: Int32)

    #if defined(ENABLE_OVERLOADING)
    data PageRangeStartFieldInfo
    instance AttrInfo PageRangeStartFieldInfo where
        type AttrBaseTypeConstraint PageRangeStartFieldInfo = (~) PageRange
        type AttrAllowedOps PageRangeStartFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint PageRangeStartFieldInfo = (~) Int32
        type AttrTransferTypeConstraint PageRangeStartFieldInfo = (~)Int32
        type AttrTransferType PageRangeStartFieldInfo = Int32
        type AttrGetType PageRangeStartFieldInfo = Int32
        type AttrLabel PageRangeStartFieldInfo = "start"
        type AttrOrigin PageRangeStartFieldInfo = PageRange
        attrGet = getPageRangeStart
        attrSet = setPageRangeStart
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.PageRange.start"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-PageRange.html#g:attr:start"
            })

    pageRange_start :: AttrLabelProxy "start"
    pageRange_start = AttrLabelProxy

    #endif

    -- | Get the value of the “@end@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' pageRange #end
    -- @
    getPageRangeEnd :: MonadIO m => PageRange -> m Int32
    getPageRangeEnd :: forall (m :: * -> *). MonadIO m => PageRange -> m Int32
    getPageRangeEnd PageRange
    s = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ PageRange -> (Ptr PageRange -> IO Int32) -> IO Int32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr PageRange
    s ((Ptr PageRange -> IO Int32) -> IO Int32)
    -> (Ptr PageRange -> IO Int32) -> IO Int32
    forall a b. (a -> b) -> a -> b
    $ \Ptr PageRange
    ptr -> do
        val <- Ptr Int32 -> IO Int32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr PageRange
    ptr Ptr PageRange -> Int -> Ptr Int32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    4) :: IO Int32
        return val

    -- | Set the value of the “@end@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' pageRange [ #end 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setPageRangeEnd :: MonadIO m => PageRange -> Int32 -> m ()
    setPageRangeEnd :: forall (m :: * -> *). MonadIO m => PageRange -> Int32 -> m ()
    setPageRangeEnd PageRange
    s Int32
    val = 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
    $ PageRange -> (Ptr PageRange -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr PageRange
    s ((Ptr PageRange -> IO ()) -> IO ())
    -> (Ptr PageRange -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr PageRange
    ptr -> do
        Ptr Int32 -> Int32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr PageRange
    ptr Ptr PageRange -> Int -> Ptr Int32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    4) (Int32
    val :: Int32)

    #if defined(ENABLE_OVERLOADING)
    data PageRangeEndFieldInfo
    instance AttrInfo PageRangeEndFieldInfo where
        type AttrBaseTypeConstraint PageRangeEndFieldInfo = (~) PageRange
        type AttrAllowedOps PageRangeEndFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint PageRangeEndFieldInfo = (~) Int32
        type AttrTransferTypeConstraint PageRangeEndFieldInfo = (~)Int32
        type AttrTransferType PageRangeEndFieldInfo = Int32
        type AttrGetType PageRangeEndFieldInfo = Int32
        type AttrLabel PageRangeEndFieldInfo = "end"
        type AttrOrigin PageRangeEndFieldInfo = PageRange
        attrGet = getPageRangeEnd
        attrSet = setPageRangeEnd
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.PageRange.end"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Structs-PageRange.html#g:attr:end"
            })

    pageRange_end :: AttrLabelProxy "end"
    pageRange_end = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList PageRange
    type instance O.AttributeList PageRange = PageRangeAttributeList
    type PageRangeAttributeList = ('[ '("start", PageRangeStartFieldInfo), '("end", PageRangeEndFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolvePageRangeMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolvePageRangeMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif