{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A t'GI.Poppler.Structs.PageTransition.PageTransition' structures describes a visual transition
-- to use when moving between pages during a presentation

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

module GI.Poppler.Structs.PageTransition
    ( 

-- * Exported types
    PageTransition(..)                      ,
    newZeroPageTransition                   ,
    noPageTransition                        ,


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

#if defined(ENABLE_OVERLOADING)
    ResolvePageTransitionMethod             ,
#endif


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    PageTransitionCopyMethodInfo            ,
#endif
    pageTransitionCopy                      ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    PageTransitionFreeMethodInfo            ,
#endif
    pageTransitionFree                      ,


-- ** new #method:new#

    pageTransitionNew                       ,




 -- * Properties
-- ** alignment #attr:alignment#
-- | the dimension in which the transition effect shall occur.
-- Only for @/POPPLER_PAGE_TRANSITION_SPLIT/@ and @/POPPLER_PAGE_TRANSITION_BLINDS/@ transition types

    getPageTransitionAlignment              ,
#if defined(ENABLE_OVERLOADING)
    pageTransition_alignment                ,
#endif
    setPageTransitionAlignment              ,


-- ** angle #attr:angle#
-- | the direction in which the specified transition effect shall moves,
-- expressed in degrees counterclockwise starting from a left-to-right direction.
-- Only for @/POPPLER_PAGE_TRANSITION_WIPE/@, @/POPPLER_PAGE_TRANSITION_GLITTER/@, @/POPPLER_PAGE_TRANSITION_FLY/@,
-- @/POPPLER_PAGE_TRANSITION_COVER/@, @/POPPLER_PAGE_TRANSITION_UNCOVER/@ and @/POPPLER_PAGE_TRANSITION_PUSH/@
-- transition types

    getPageTransitionAngle                  ,
#if defined(ENABLE_OVERLOADING)
    pageTransition_angle                    ,
#endif
    setPageTransitionAngle                  ,


-- ** direction #attr:direction#
-- | the direction of motion for the transition effect.
-- Only for @/POPPLER_PAGE_TRANSITION_SPLIT/@, @/POPPLER_PAGE_TRANSITION_BOX/@ and @/POPPLER_PAGE_TRANSITION_FLY/@
-- transition types

    getPageTransitionDirection              ,
#if defined(ENABLE_OVERLOADING)
    pageTransition_direction                ,
#endif
    setPageTransitionDirection              ,


-- ** duration #attr:duration#
-- | the duration of the transition effect

    getPageTransitionDuration               ,
#if defined(ENABLE_OVERLOADING)
    pageTransition_duration                 ,
#endif
    setPageTransitionDuration               ,


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

    getPageTransitionDurationReal           ,
#if defined(ENABLE_OVERLOADING)
    pageTransition_durationReal             ,
#endif
    setPageTransitionDurationReal           ,


-- ** rectangular #attr:rectangular#
-- | whether the area that will be flown is rectangular and opaque.
-- Only for @/POPPLER_PAGE_TRANSITION_FLY/@ transition type

    getPageTransitionRectangular            ,
#if defined(ENABLE_OVERLOADING)
    pageTransition_rectangular              ,
#endif
    setPageTransitionRectangular            ,


-- ** scale #attr:scale#
-- | the starting or ending scale at which the changes shall be drawn.
-- Only for @/POPPLER_PAGE_TRANSITION_FLY/@ transition type

    getPageTransitionScale                  ,
#if defined(ENABLE_OVERLOADING)
    pageTransition_scale                    ,
#endif
    setPageTransitionScale                  ,


-- ** type #attr:type#
-- | the type of transtition

    getPageTransitionType                   ,
#if defined(ENABLE_OVERLOADING)
    pageTransition_type                     ,
#endif
    setPageTransitionType                   ,




    ) 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 {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums

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

instance BoxedObject PageTransition where
    boxedType :: PageTransition -> IO GType
boxedType _ = IO GType
c_poppler_page_transition_get_type

-- | Convert 'PageTransition' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue PageTransition where
    toGValue :: PageTransition -> IO GValue
toGValue o :: PageTransition
o = do
        GType
gtype <- IO GType
c_poppler_page_transition_get_type
        PageTransition -> (Ptr PageTransition -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr PageTransition
o (GType
-> (GValue -> Ptr PageTransition -> IO ())
-> Ptr PageTransition
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr PageTransition -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
        
    fromGValue :: GValue -> IO PageTransition
fromGValue gv :: GValue
gv = do
        Ptr PageTransition
ptr <- GValue -> IO (Ptr PageTransition)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr PageTransition)
        (ManagedPtr PageTransition -> PageTransition)
-> Ptr PageTransition -> IO PageTransition
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr PageTransition -> PageTransition
PageTransition Ptr PageTransition
ptr
        
    

-- | Construct a `PageTransition` struct initialized to zero.
newZeroPageTransition :: MonadIO m => m PageTransition
newZeroPageTransition :: m PageTransition
newZeroPageTransition = IO PageTransition -> m PageTransition
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PageTransition -> m PageTransition)
-> IO PageTransition -> m PageTransition
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr PageTransition)
forall a. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 48 IO (Ptr PageTransition)
-> (Ptr PageTransition -> IO PageTransition) -> IO PageTransition
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr PageTransition -> PageTransition)
-> Ptr PageTransition -> IO PageTransition
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr PageTransition -> PageTransition
PageTransition

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


-- | A convenience alias for `Nothing` :: `Maybe` `PageTransition`.
noPageTransition :: Maybe PageTransition
noPageTransition :: Maybe PageTransition
noPageTransition = Maybe PageTransition
forall a. Maybe a
Nothing

-- | Get the value of the “@type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pageTransition #type
-- @
getPageTransitionType :: MonadIO m => PageTransition -> m Poppler.Enums.PageTransitionType
getPageTransitionType :: PageTransition -> m PageTransitionType
getPageTransitionType s :: PageTransition
s = IO PageTransitionType -> m PageTransitionType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PageTransitionType -> m PageTransitionType)
-> IO PageTransitionType -> m PageTransitionType
forall a b. (a -> b) -> a -> b
$ PageTransition
-> (Ptr PageTransition -> IO PageTransitionType)
-> IO PageTransitionType
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PageTransition
s ((Ptr PageTransition -> IO PageTransitionType)
 -> IO PageTransitionType)
-> (Ptr PageTransition -> IO PageTransitionType)
-> IO PageTransitionType
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PageTransition
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr PageTransition
ptr Ptr PageTransition -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO CUInt
    let val' :: PageTransitionType
val' = (Int -> PageTransitionType
forall a. Enum a => Int -> a
toEnum (Int -> PageTransitionType)
-> (CUInt -> Int) -> CUInt -> PageTransitionType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    PageTransitionType -> IO PageTransitionType
forall (m :: * -> *) a. Monad m => a -> m a
return PageTransitionType
val'

-- | Set the value of the “@type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pageTransition [ #type 'Data.GI.Base.Attributes.:=' value ]
-- @
setPageTransitionType :: MonadIO m => PageTransition -> Poppler.Enums.PageTransitionType -> m ()
setPageTransitionType :: PageTransition -> PageTransitionType -> m ()
setPageTransitionType s :: PageTransition
s val :: PageTransitionType
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PageTransition -> (Ptr PageTransition -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PageTransition
s ((Ptr PageTransition -> IO ()) -> IO ())
-> (Ptr PageTransition -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PageTransition
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (PageTransitionType -> Int) -> PageTransitionType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PageTransitionType -> Int
forall a. Enum a => a -> Int
fromEnum) PageTransitionType
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PageTransition
ptr Ptr PageTransition -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data PageTransitionTypeFieldInfo
instance AttrInfo PageTransitionTypeFieldInfo where
    type AttrBaseTypeConstraint PageTransitionTypeFieldInfo = (~) PageTransition
    type AttrAllowedOps PageTransitionTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PageTransitionTypeFieldInfo = (~) Poppler.Enums.PageTransitionType
    type AttrTransferTypeConstraint PageTransitionTypeFieldInfo = (~)Poppler.Enums.PageTransitionType
    type AttrTransferType PageTransitionTypeFieldInfo = Poppler.Enums.PageTransitionType
    type AttrGetType PageTransitionTypeFieldInfo = Poppler.Enums.PageTransitionType
    type AttrLabel PageTransitionTypeFieldInfo = "type"
    type AttrOrigin PageTransitionTypeFieldInfo = PageTransition
    attrGet = getPageTransitionType
    attrSet = setPageTransitionType
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

pageTransition_type :: AttrLabelProxy "type"
pageTransition_type = AttrLabelProxy

#endif


-- | Get the value of the “@alignment@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pageTransition #alignment
-- @
getPageTransitionAlignment :: MonadIO m => PageTransition -> m Poppler.Enums.PageTransitionAlignment
getPageTransitionAlignment :: PageTransition -> m PageTransitionAlignment
getPageTransitionAlignment s :: PageTransition
s = IO PageTransitionAlignment -> m PageTransitionAlignment
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PageTransitionAlignment -> m PageTransitionAlignment)
-> IO PageTransitionAlignment -> m PageTransitionAlignment
forall a b. (a -> b) -> a -> b
$ PageTransition
-> (Ptr PageTransition -> IO PageTransitionAlignment)
-> IO PageTransitionAlignment
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PageTransition
s ((Ptr PageTransition -> IO PageTransitionAlignment)
 -> IO PageTransitionAlignment)
-> (Ptr PageTransition -> IO PageTransitionAlignment)
-> IO PageTransitionAlignment
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PageTransition
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr PageTransition
ptr Ptr PageTransition -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 4) :: IO CUInt
    let val' :: PageTransitionAlignment
val' = (Int -> PageTransitionAlignment
forall a. Enum a => Int -> a
toEnum (Int -> PageTransitionAlignment)
-> (CUInt -> Int) -> CUInt -> PageTransitionAlignment
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    PageTransitionAlignment -> IO PageTransitionAlignment
forall (m :: * -> *) a. Monad m => a -> m a
return PageTransitionAlignment
val'

-- | Set the value of the “@alignment@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pageTransition [ #alignment 'Data.GI.Base.Attributes.:=' value ]
-- @
setPageTransitionAlignment :: MonadIO m => PageTransition -> Poppler.Enums.PageTransitionAlignment -> m ()
setPageTransitionAlignment :: PageTransition -> PageTransitionAlignment -> m ()
setPageTransitionAlignment s :: PageTransition
s val :: PageTransitionAlignment
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PageTransition -> (Ptr PageTransition -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PageTransition
s ((Ptr PageTransition -> IO ()) -> IO ())
-> (Ptr PageTransition -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PageTransition
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (PageTransitionAlignment -> Int)
-> PageTransitionAlignment
-> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PageTransitionAlignment -> Int
forall a. Enum a => a -> Int
fromEnum) PageTransitionAlignment
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PageTransition
ptr Ptr PageTransition -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 4) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data PageTransitionAlignmentFieldInfo
instance AttrInfo PageTransitionAlignmentFieldInfo where
    type AttrBaseTypeConstraint PageTransitionAlignmentFieldInfo = (~) PageTransition
    type AttrAllowedOps PageTransitionAlignmentFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PageTransitionAlignmentFieldInfo = (~) Poppler.Enums.PageTransitionAlignment
    type AttrTransferTypeConstraint PageTransitionAlignmentFieldInfo = (~)Poppler.Enums.PageTransitionAlignment
    type AttrTransferType PageTransitionAlignmentFieldInfo = Poppler.Enums.PageTransitionAlignment
    type AttrGetType PageTransitionAlignmentFieldInfo = Poppler.Enums.PageTransitionAlignment
    type AttrLabel PageTransitionAlignmentFieldInfo = "alignment"
    type AttrOrigin PageTransitionAlignmentFieldInfo = PageTransition
    attrGet = getPageTransitionAlignment
    attrSet = setPageTransitionAlignment
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

pageTransition_alignment :: AttrLabelProxy "alignment"
pageTransition_alignment = AttrLabelProxy

#endif


-- | Get the value of the “@direction@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pageTransition #direction
-- @
getPageTransitionDirection :: MonadIO m => PageTransition -> m Poppler.Enums.PageTransitionDirection
getPageTransitionDirection :: PageTransition -> m PageTransitionDirection
getPageTransitionDirection s :: PageTransition
s = IO PageTransitionDirection -> m PageTransitionDirection
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PageTransitionDirection -> m PageTransitionDirection)
-> IO PageTransitionDirection -> m PageTransitionDirection
forall a b. (a -> b) -> a -> b
$ PageTransition
-> (Ptr PageTransition -> IO PageTransitionDirection)
-> IO PageTransitionDirection
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PageTransition
s ((Ptr PageTransition -> IO PageTransitionDirection)
 -> IO PageTransitionDirection)
-> (Ptr PageTransition -> IO PageTransitionDirection)
-> IO PageTransitionDirection
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PageTransition
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr PageTransition
ptr Ptr PageTransition -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) :: IO CUInt
    let val' :: PageTransitionDirection
val' = (Int -> PageTransitionDirection
forall a. Enum a => Int -> a
toEnum (Int -> PageTransitionDirection)
-> (CUInt -> Int) -> CUInt -> PageTransitionDirection
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    PageTransitionDirection -> IO PageTransitionDirection
forall (m :: * -> *) a. Monad m => a -> m a
return PageTransitionDirection
val'

-- | Set the value of the “@direction@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pageTransition [ #direction 'Data.GI.Base.Attributes.:=' value ]
-- @
setPageTransitionDirection :: MonadIO m => PageTransition -> Poppler.Enums.PageTransitionDirection -> m ()
setPageTransitionDirection :: PageTransition -> PageTransitionDirection -> m ()
setPageTransitionDirection s :: PageTransition
s val :: PageTransitionDirection
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PageTransition -> (Ptr PageTransition -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PageTransition
s ((Ptr PageTransition -> IO ()) -> IO ())
-> (Ptr PageTransition -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PageTransition
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (PageTransitionDirection -> Int)
-> PageTransitionDirection
-> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PageTransitionDirection -> Int
forall a. Enum a => a -> Int
fromEnum) PageTransitionDirection
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PageTransition
ptr Ptr PageTransition -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data PageTransitionDirectionFieldInfo
instance AttrInfo PageTransitionDirectionFieldInfo where
    type AttrBaseTypeConstraint PageTransitionDirectionFieldInfo = (~) PageTransition
    type AttrAllowedOps PageTransitionDirectionFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PageTransitionDirectionFieldInfo = (~) Poppler.Enums.PageTransitionDirection
    type AttrTransferTypeConstraint PageTransitionDirectionFieldInfo = (~)Poppler.Enums.PageTransitionDirection
    type AttrTransferType PageTransitionDirectionFieldInfo = Poppler.Enums.PageTransitionDirection
    type AttrGetType PageTransitionDirectionFieldInfo = Poppler.Enums.PageTransitionDirection
    type AttrLabel PageTransitionDirectionFieldInfo = "direction"
    type AttrOrigin PageTransitionDirectionFieldInfo = PageTransition
    attrGet = getPageTransitionDirection
    attrSet = setPageTransitionDirection
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

pageTransition_direction :: AttrLabelProxy "direction"
pageTransition_direction = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data PageTransitionDurationFieldInfo
instance AttrInfo PageTransitionDurationFieldInfo where
    type AttrBaseTypeConstraint PageTransitionDurationFieldInfo = (~) PageTransition
    type AttrAllowedOps PageTransitionDurationFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PageTransitionDurationFieldInfo = (~) Int32
    type AttrTransferTypeConstraint PageTransitionDurationFieldInfo = (~)Int32
    type AttrTransferType PageTransitionDurationFieldInfo = Int32
    type AttrGetType PageTransitionDurationFieldInfo = Int32
    type AttrLabel PageTransitionDurationFieldInfo = "duration"
    type AttrOrigin PageTransitionDurationFieldInfo = PageTransition
    attrGet = getPageTransitionDuration
    attrSet = setPageTransitionDuration
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

pageTransition_duration :: AttrLabelProxy "duration"
pageTransition_duration = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data PageTransitionAngleFieldInfo
instance AttrInfo PageTransitionAngleFieldInfo where
    type AttrBaseTypeConstraint PageTransitionAngleFieldInfo = (~) PageTransition
    type AttrAllowedOps PageTransitionAngleFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PageTransitionAngleFieldInfo = (~) Int32
    type AttrTransferTypeConstraint PageTransitionAngleFieldInfo = (~)Int32
    type AttrTransferType PageTransitionAngleFieldInfo = Int32
    type AttrGetType PageTransitionAngleFieldInfo = Int32
    type AttrLabel PageTransitionAngleFieldInfo = "angle"
    type AttrOrigin PageTransitionAngleFieldInfo = PageTransition
    attrGet = getPageTransitionAngle
    attrSet = setPageTransitionAngle
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

pageTransition_angle :: AttrLabelProxy "angle"
pageTransition_angle = AttrLabelProxy

#endif


-- | Get the value of the “@scale@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pageTransition #scale
-- @
getPageTransitionScale :: MonadIO m => PageTransition -> m Double
getPageTransitionScale :: PageTransition -> m Double
getPageTransitionScale s :: PageTransition
s = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ PageTransition -> (Ptr PageTransition -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PageTransition
s ((Ptr PageTransition -> IO Double) -> IO Double)
-> (Ptr PageTransition -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PageTransition
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr PageTransition
ptr Ptr PageTransition -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

-- | Set the value of the “@scale@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pageTransition [ #scale 'Data.GI.Base.Attributes.:=' value ]
-- @
setPageTransitionScale :: MonadIO m => PageTransition -> Double -> m ()
setPageTransitionScale :: PageTransition -> Double -> m ()
setPageTransitionScale s :: PageTransition
s val :: Double
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PageTransition -> (Ptr PageTransition -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PageTransition
s ((Ptr PageTransition -> IO ()) -> IO ())
-> (Ptr PageTransition -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PageTransition
ptr -> do
    let val' :: CDouble
val' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
    Ptr CDouble -> CDouble -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PageTransition
ptr Ptr PageTransition -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (CDouble
val' :: CDouble)

#if defined(ENABLE_OVERLOADING)
data PageTransitionScaleFieldInfo
instance AttrInfo PageTransitionScaleFieldInfo where
    type AttrBaseTypeConstraint PageTransitionScaleFieldInfo = (~) PageTransition
    type AttrAllowedOps PageTransitionScaleFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PageTransitionScaleFieldInfo = (~) Double
    type AttrTransferTypeConstraint PageTransitionScaleFieldInfo = (~)Double
    type AttrTransferType PageTransitionScaleFieldInfo = Double
    type AttrGetType PageTransitionScaleFieldInfo = Double
    type AttrLabel PageTransitionScaleFieldInfo = "scale"
    type AttrOrigin PageTransitionScaleFieldInfo = PageTransition
    attrGet = getPageTransitionScale
    attrSet = setPageTransitionScale
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

pageTransition_scale :: AttrLabelProxy "scale"
pageTransition_scale = AttrLabelProxy

#endif


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

-- | Set the value of the “@rectangular@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pageTransition [ #rectangular 'Data.GI.Base.Attributes.:=' value ]
-- @
setPageTransitionRectangular :: MonadIO m => PageTransition -> Bool -> m ()
setPageTransitionRectangular :: PageTransition -> Bool -> m ()
setPageTransitionRectangular s :: PageTransition
s val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PageTransition -> (Ptr PageTransition -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PageTransition
s ((Ptr PageTransition -> IO ()) -> IO ())
-> (Ptr PageTransition -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PageTransition
ptr -> do
    let val' :: CInt
val' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
val
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PageTransition
ptr Ptr PageTransition -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) (CInt
val' :: CInt)

#if defined(ENABLE_OVERLOADING)
data PageTransitionRectangularFieldInfo
instance AttrInfo PageTransitionRectangularFieldInfo where
    type AttrBaseTypeConstraint PageTransitionRectangularFieldInfo = (~) PageTransition
    type AttrAllowedOps PageTransitionRectangularFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PageTransitionRectangularFieldInfo = (~) Bool
    type AttrTransferTypeConstraint PageTransitionRectangularFieldInfo = (~)Bool
    type AttrTransferType PageTransitionRectangularFieldInfo = Bool
    type AttrGetType PageTransitionRectangularFieldInfo = Bool
    type AttrLabel PageTransitionRectangularFieldInfo = "rectangular"
    type AttrOrigin PageTransitionRectangularFieldInfo = PageTransition
    attrGet = getPageTransitionRectangular
    attrSet = setPageTransitionRectangular
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

pageTransition_rectangular :: AttrLabelProxy "rectangular"
pageTransition_rectangular = AttrLabelProxy

#endif


-- | Get the value of the “@duration_real@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pageTransition #durationReal
-- @
getPageTransitionDurationReal :: MonadIO m => PageTransition -> m Double
getPageTransitionDurationReal :: PageTransition -> m Double
getPageTransitionDurationReal s :: PageTransition
s = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ PageTransition -> (Ptr PageTransition -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PageTransition
s ((Ptr PageTransition -> IO Double) -> IO Double)
-> (Ptr PageTransition -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PageTransition
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr PageTransition
ptr Ptr PageTransition -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

-- | Set the value of the “@duration_real@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pageTransition [ #durationReal 'Data.GI.Base.Attributes.:=' value ]
-- @
setPageTransitionDurationReal :: MonadIO m => PageTransition -> Double -> m ()
setPageTransitionDurationReal :: PageTransition -> Double -> m ()
setPageTransitionDurationReal s :: PageTransition
s val :: Double
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PageTransition -> (Ptr PageTransition -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PageTransition
s ((Ptr PageTransition -> IO ()) -> IO ())
-> (Ptr PageTransition -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PageTransition
ptr -> do
    let val' :: CDouble
val' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
    Ptr CDouble -> CDouble -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PageTransition
ptr Ptr PageTransition -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) (CDouble
val' :: CDouble)

#if defined(ENABLE_OVERLOADING)
data PageTransitionDurationRealFieldInfo
instance AttrInfo PageTransitionDurationRealFieldInfo where
    type AttrBaseTypeConstraint PageTransitionDurationRealFieldInfo = (~) PageTransition
    type AttrAllowedOps PageTransitionDurationRealFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PageTransitionDurationRealFieldInfo = (~) Double
    type AttrTransferTypeConstraint PageTransitionDurationRealFieldInfo = (~)Double
    type AttrTransferType PageTransitionDurationRealFieldInfo = Double
    type AttrGetType PageTransitionDurationRealFieldInfo = Double
    type AttrLabel PageTransitionDurationRealFieldInfo = "duration_real"
    type AttrOrigin PageTransitionDurationRealFieldInfo = PageTransition
    attrGet = getPageTransitionDurationReal
    attrSet = setPageTransitionDurationReal
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

pageTransition_durationReal :: AttrLabelProxy "durationReal"
pageTransition_durationReal = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList PageTransition
type instance O.AttributeList PageTransition = PageTransitionAttributeList
type PageTransitionAttributeList = ('[ '("type", PageTransitionTypeFieldInfo), '("alignment", PageTransitionAlignmentFieldInfo), '("direction", PageTransitionDirectionFieldInfo), '("duration", PageTransitionDurationFieldInfo), '("angle", PageTransitionAngleFieldInfo), '("scale", PageTransitionScaleFieldInfo), '("rectangular", PageTransitionRectangularFieldInfo), '("durationReal", PageTransitionDurationRealFieldInfo)] :: [(Symbol, *)])
#endif

-- method PageTransition::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "PageTransition" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_page_transition_new" poppler_page_transition_new :: 
    IO (Ptr PageTransition)

-- | Creates a new t'GI.Poppler.Structs.PageTransition.PageTransition'
pageTransitionNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m PageTransition
    -- ^ __Returns:__ a new t'GI.Poppler.Structs.PageTransition.PageTransition', use 'GI.Poppler.Structs.PageTransition.pageTransitionFree' to free it
pageTransitionNew :: m PageTransition
pageTransitionNew  = IO PageTransition -> m PageTransition
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PageTransition -> m PageTransition)
-> IO PageTransition -> m PageTransition
forall a b. (a -> b) -> a -> b
$ do
    Ptr PageTransition
result <- IO (Ptr PageTransition)
poppler_page_transition_new
    Text -> Ptr PageTransition -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "pageTransitionNew" Ptr PageTransition
result
    PageTransition
result' <- ((ManagedPtr PageTransition -> PageTransition)
-> Ptr PageTransition -> IO PageTransition
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr PageTransition -> PageTransition
PageTransition) Ptr PageTransition
result
    PageTransition -> IO PageTransition
forall (m :: * -> *) a. Monad m => a -> m a
return PageTransition
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method PageTransition::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "transition"
--           , argType =
--               TInterface Name { namespace = "Poppler" , name = "PageTransition" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PopplerPageTransition to copy"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "PageTransition" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_page_transition_copy" poppler_page_transition_copy :: 
    Ptr PageTransition ->                   -- transition : TInterface (Name {namespace = "Poppler", name = "PageTransition"})
    IO (Ptr PageTransition)

-- | Creates a copy of /@transition@/
pageTransitionCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PageTransition
    -- ^ /@transition@/: a t'GI.Poppler.Structs.PageTransition.PageTransition' to copy
    -> m PageTransition
    -- ^ __Returns:__ a new allocated copy of /@transition@/
pageTransitionCopy :: PageTransition -> m PageTransition
pageTransitionCopy transition :: PageTransition
transition = IO PageTransition -> m PageTransition
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PageTransition -> m PageTransition)
-> IO PageTransition -> m PageTransition
forall a b. (a -> b) -> a -> b
$ do
    Ptr PageTransition
transition' <- PageTransition -> IO (Ptr PageTransition)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PageTransition
transition
    Ptr PageTransition
result <- Ptr PageTransition -> IO (Ptr PageTransition)
poppler_page_transition_copy Ptr PageTransition
transition'
    Text -> Ptr PageTransition -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "pageTransitionCopy" Ptr PageTransition
result
    PageTransition
result' <- ((ManagedPtr PageTransition -> PageTransition)
-> Ptr PageTransition -> IO PageTransition
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr PageTransition -> PageTransition
PageTransition) Ptr PageTransition
result
    PageTransition -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr PageTransition
transition
    PageTransition -> IO PageTransition
forall (m :: * -> *) a. Monad m => a -> m a
return PageTransition
result'

#if defined(ENABLE_OVERLOADING)
data PageTransitionCopyMethodInfo
instance (signature ~ (m PageTransition), MonadIO m) => O.MethodInfo PageTransitionCopyMethodInfo PageTransition signature where
    overloadedMethod = pageTransitionCopy

#endif

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

foreign import ccall "poppler_page_transition_free" poppler_page_transition_free :: 
    Ptr PageTransition ->                   -- transition : TInterface (Name {namespace = "Poppler", name = "PageTransition"})
    IO ()

-- | Frees the given t'GI.Poppler.Structs.PageTransition.PageTransition'
pageTransitionFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PageTransition
    -- ^ /@transition@/: a t'GI.Poppler.Structs.PageTransition.PageTransition'
    -> m ()
pageTransitionFree :: PageTransition -> m ()
pageTransitionFree transition :: PageTransition
transition = 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 PageTransition
transition' <- PageTransition -> IO (Ptr PageTransition)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PageTransition
transition
    Ptr PageTransition -> IO ()
poppler_page_transition_free Ptr PageTransition
transition'
    PageTransition -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr PageTransition
transition
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PageTransitionFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo PageTransitionFreeMethodInfo PageTransition signature where
    overloadedMethod = pageTransitionFree

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolvePageTransitionMethod (t :: Symbol) (o :: *) :: * where
    ResolvePageTransitionMethod "copy" o = PageTransitionCopyMethodInfo
    ResolvePageTransitionMethod "free" o = PageTransitionFreeMethodInfo
    ResolvePageTransitionMethod l o = O.MethodResolutionFailed l o

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

#endif