{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Poppler.Objects.StructureElement
    ( 
#if defined(ENABLE_OVERLOADING)
    StructureElementGetBorderColorMethodInfo,
#endif

-- * Exported types
    StructureElement(..)                    ,
    IsStructureElement                      ,
    toStructureElement                      ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [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"), [isBlock]("GI.Poppler.Objects.StructureElement#g:method:isBlock"), [isContent]("GI.Poppler.Objects.StructureElement#g:method:isContent"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isGrouping]("GI.Poppler.Objects.StructureElement#g:method:isGrouping"), [isInline]("GI.Poppler.Objects.StructureElement#g:method:isInline"), [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
-- [getAbbreviation]("GI.Poppler.Objects.StructureElement#g:method:getAbbreviation"), [getActualText]("GI.Poppler.Objects.StructureElement#g:method:getActualText"), [getAltText]("GI.Poppler.Objects.StructureElement#g:method:getAltText"), [getBackgroundColor]("GI.Poppler.Objects.StructureElement#g:method:getBackgroundColor"), [getBaselineShift]("GI.Poppler.Objects.StructureElement#g:method:getBaselineShift"), [getBlockAlign]("GI.Poppler.Objects.StructureElement#g:method:getBlockAlign"), [getBorderColor]("GI.Poppler.Objects.StructureElement#g:method:getBorderColor"), [getBorderStyle]("GI.Poppler.Objects.StructureElement#g:method:getBorderStyle"), [getBorderThickness]("GI.Poppler.Objects.StructureElement#g:method:getBorderThickness"), [getBoundingBox]("GI.Poppler.Objects.StructureElement#g:method:getBoundingBox"), [getColor]("GI.Poppler.Objects.StructureElement#g:method:getColor"), [getColumnCount]("GI.Poppler.Objects.StructureElement#g:method:getColumnCount"), [getColumnGaps]("GI.Poppler.Objects.StructureElement#g:method:getColumnGaps"), [getColumnWidths]("GI.Poppler.Objects.StructureElement#g:method:getColumnWidths"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getEndIndent]("GI.Poppler.Objects.StructureElement#g:method:getEndIndent"), [getFormDescription]("GI.Poppler.Objects.StructureElement#g:method:getFormDescription"), [getFormRole]("GI.Poppler.Objects.StructureElement#g:method:getFormRole"), [getFormState]("GI.Poppler.Objects.StructureElement#g:method:getFormState"), [getGlyphOrientation]("GI.Poppler.Objects.StructureElement#g:method:getGlyphOrientation"), [getHeight]("GI.Poppler.Objects.StructureElement#g:method:getHeight"), [getId]("GI.Poppler.Objects.StructureElement#g:method:getId"), [getInlineAlign]("GI.Poppler.Objects.StructureElement#g:method:getInlineAlign"), [getKind]("GI.Poppler.Objects.StructureElement#g:method:getKind"), [getLanguage]("GI.Poppler.Objects.StructureElement#g:method:getLanguage"), [getLineHeight]("GI.Poppler.Objects.StructureElement#g:method:getLineHeight"), [getListNumbering]("GI.Poppler.Objects.StructureElement#g:method:getListNumbering"), [getPadding]("GI.Poppler.Objects.StructureElement#g:method:getPadding"), [getPage]("GI.Poppler.Objects.StructureElement#g:method:getPage"), [getPlacement]("GI.Poppler.Objects.StructureElement#g:method:getPlacement"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRubyAlign]("GI.Poppler.Objects.StructureElement#g:method:getRubyAlign"), [getRubyPosition]("GI.Poppler.Objects.StructureElement#g:method:getRubyPosition"), [getSpaceAfter]("GI.Poppler.Objects.StructureElement#g:method:getSpaceAfter"), [getSpaceBefore]("GI.Poppler.Objects.StructureElement#g:method:getSpaceBefore"), [getStartIndent]("GI.Poppler.Objects.StructureElement#g:method:getStartIndent"), [getTableBorderStyle]("GI.Poppler.Objects.StructureElement#g:method:getTableBorderStyle"), [getTableColumnSpan]("GI.Poppler.Objects.StructureElement#g:method:getTableColumnSpan"), [getTableHeaders]("GI.Poppler.Objects.StructureElement#g:method:getTableHeaders"), [getTablePadding]("GI.Poppler.Objects.StructureElement#g:method:getTablePadding"), [getTableRowSpan]("GI.Poppler.Objects.StructureElement#g:method:getTableRowSpan"), [getTableScope]("GI.Poppler.Objects.StructureElement#g:method:getTableScope"), [getTableSummary]("GI.Poppler.Objects.StructureElement#g:method:getTableSummary"), [getText]("GI.Poppler.Objects.StructureElement#g:method:getText"), [getTextAlign]("GI.Poppler.Objects.StructureElement#g:method:getTextAlign"), [getTextDecorationColor]("GI.Poppler.Objects.StructureElement#g:method:getTextDecorationColor"), [getTextDecorationThickness]("GI.Poppler.Objects.StructureElement#g:method:getTextDecorationThickness"), [getTextDecorationType]("GI.Poppler.Objects.StructureElement#g:method:getTextDecorationType"), [getTextIndent]("GI.Poppler.Objects.StructureElement#g:method:getTextIndent"), [getTextSpans]("GI.Poppler.Objects.StructureElement#g:method:getTextSpans"), [getTitle]("GI.Poppler.Objects.StructureElement#g:method:getTitle"), [getWidth]("GI.Poppler.Objects.StructureElement#g:method:getWidth"), [getWritingMode]("GI.Poppler.Objects.StructureElement#g:method:getWritingMode").
-- 
-- ==== Setters
-- [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)
    ResolveStructureElementMethod           ,
#endif

-- ** getAbbreviation #method:getAbbreviation#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetAbbreviationMethodInfo,
#endif
    structureElementGetAbbreviation         ,


-- ** getActualText #method:getActualText#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetActualTextMethodInfo ,
#endif
    structureElementGetActualText           ,


-- ** getAltText #method:getAltText#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetAltTextMethodInfo    ,
#endif
    structureElementGetAltText              ,


-- ** getBackgroundColor #method:getBackgroundColor#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetBackgroundColorMethodInfo,
#endif
    structureElementGetBackgroundColor      ,


-- ** getBaselineShift #method:getBaselineShift#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetBaselineShiftMethodInfo,
#endif
    structureElementGetBaselineShift        ,


-- ** getBlockAlign #method:getBlockAlign#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetBlockAlignMethodInfo ,
#endif
    structureElementGetBlockAlign           ,


-- ** getBorderStyle #method:getBorderStyle#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetBorderStyleMethodInfo,
#endif
    structureElementGetBorderStyle          ,


-- ** getBorderThickness #method:getBorderThickness#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetBorderThicknessMethodInfo,
#endif
    structureElementGetBorderThickness      ,


-- ** getBoundingBox #method:getBoundingBox#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetBoundingBoxMethodInfo,
#endif
    structureElementGetBoundingBox          ,


-- ** getColor #method:getColor#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetColorMethodInfo      ,
#endif
    structureElementGetColor                ,


-- ** getColumnCount #method:getColumnCount#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetColumnCountMethodInfo,
#endif
    structureElementGetColumnCount          ,


-- ** getColumnGaps #method:getColumnGaps#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetColumnGapsMethodInfo ,
#endif
    structureElementGetColumnGaps           ,


-- ** getColumnWidths #method:getColumnWidths#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetColumnWidthsMethodInfo,
#endif
    structureElementGetColumnWidths         ,


-- ** getEndIndent #method:getEndIndent#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetEndIndentMethodInfo  ,
#endif
    structureElementGetEndIndent            ,


-- ** getFormDescription #method:getFormDescription#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetFormDescriptionMethodInfo,
#endif
    structureElementGetFormDescription      ,


-- ** getFormRole #method:getFormRole#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetFormRoleMethodInfo   ,
#endif
    structureElementGetFormRole             ,


-- ** getFormState #method:getFormState#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetFormStateMethodInfo  ,
#endif
    structureElementGetFormState            ,


-- ** getGlyphOrientation #method:getGlyphOrientation#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetGlyphOrientationMethodInfo,
#endif
    structureElementGetGlyphOrientation     ,


-- ** getHeight #method:getHeight#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetHeightMethodInfo     ,
#endif
    structureElementGetHeight               ,


-- ** getId #method:getId#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetIdMethodInfo         ,
#endif
    structureElementGetId                   ,


-- ** getInlineAlign #method:getInlineAlign#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetInlineAlignMethodInfo,
#endif
    structureElementGetInlineAlign          ,


-- ** getKind #method:getKind#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetKindMethodInfo       ,
#endif
    structureElementGetKind                 ,


-- ** getLanguage #method:getLanguage#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetLanguageMethodInfo   ,
#endif
    structureElementGetLanguage             ,


-- ** getLineHeight #method:getLineHeight#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetLineHeightMethodInfo ,
#endif
    structureElementGetLineHeight           ,


-- ** getListNumbering #method:getListNumbering#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetListNumberingMethodInfo,
#endif
    structureElementGetListNumbering        ,


-- ** getPadding #method:getPadding#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetPaddingMethodInfo    ,
#endif
    structureElementGetPadding              ,


-- ** getPage #method:getPage#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetPageMethodInfo       ,
#endif
    structureElementGetPage                 ,


-- ** getPlacement #method:getPlacement#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetPlacementMethodInfo  ,
#endif
    structureElementGetPlacement            ,


-- ** getRubyAlign #method:getRubyAlign#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetRubyAlignMethodInfo  ,
#endif
    structureElementGetRubyAlign            ,


-- ** getRubyPosition #method:getRubyPosition#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetRubyPositionMethodInfo,
#endif
    structureElementGetRubyPosition         ,


-- ** getSpaceAfter #method:getSpaceAfter#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetSpaceAfterMethodInfo ,
#endif
    structureElementGetSpaceAfter           ,


-- ** getSpaceBefore #method:getSpaceBefore#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetSpaceBeforeMethodInfo,
#endif
    structureElementGetSpaceBefore          ,


-- ** getStartIndent #method:getStartIndent#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetStartIndentMethodInfo,
#endif
    structureElementGetStartIndent          ,


-- ** getTableBorderStyle #method:getTableBorderStyle#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTableBorderStyleMethodInfo,
#endif
    structureElementGetTableBorderStyle     ,


-- ** getTableColumnSpan #method:getTableColumnSpan#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTableColumnSpanMethodInfo,
#endif
    structureElementGetTableColumnSpan      ,


-- ** getTableHeaders #method:getTableHeaders#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTableHeadersMethodInfo,
#endif
    structureElementGetTableHeaders         ,


-- ** getTablePadding #method:getTablePadding#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTablePaddingMethodInfo,
#endif
    structureElementGetTablePadding         ,


-- ** getTableRowSpan #method:getTableRowSpan#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTableRowSpanMethodInfo,
#endif
    structureElementGetTableRowSpan         ,


-- ** getTableScope #method:getTableScope#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTableScopeMethodInfo ,
#endif
    structureElementGetTableScope           ,


-- ** getTableSummary #method:getTableSummary#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTableSummaryMethodInfo,
#endif
    structureElementGetTableSummary         ,


-- ** getText #method:getText#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTextMethodInfo       ,
#endif
    structureElementGetText                 ,


-- ** getTextAlign #method:getTextAlign#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTextAlignMethodInfo  ,
#endif
    structureElementGetTextAlign            ,


-- ** getTextDecorationColor #method:getTextDecorationColor#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTextDecorationColorMethodInfo,
#endif
    structureElementGetTextDecorationColor  ,


-- ** getTextDecorationThickness #method:getTextDecorationThickness#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTextDecorationThicknessMethodInfo,
#endif
    structureElementGetTextDecorationThickness,


-- ** getTextDecorationType #method:getTextDecorationType#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTextDecorationTypeMethodInfo,
#endif
    structureElementGetTextDecorationType   ,


-- ** getTextIndent #method:getTextIndent#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTextIndentMethodInfo ,
#endif
    structureElementGetTextIndent           ,


-- ** getTextSpans #method:getTextSpans#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTextSpansMethodInfo  ,
#endif
    structureElementGetTextSpans            ,


-- ** getTitle #method:getTitle#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetTitleMethodInfo      ,
#endif
    structureElementGetTitle                ,


-- ** getWidth #method:getWidth#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetWidthMethodInfo      ,
#endif
    structureElementGetWidth                ,


-- ** getWritingMode #method:getWritingMode#

#if defined(ENABLE_OVERLOADING)
    StructureElementGetWritingModeMethodInfo,
#endif
    structureElementGetWritingMode          ,


-- ** isBlock #method:isBlock#

#if defined(ENABLE_OVERLOADING)
    StructureElementIsBlockMethodInfo       ,
#endif
    structureElementIsBlock                 ,


-- ** isContent #method:isContent#

#if defined(ENABLE_OVERLOADING)
    StructureElementIsContentMethodInfo     ,
#endif
    structureElementIsContent               ,


-- ** isGrouping #method:isGrouping#

#if defined(ENABLE_OVERLOADING)
    StructureElementIsGroupingMethodInfo    ,
#endif
    structureElementIsGrouping              ,


-- ** isInline #method:isInline#

#if defined(ENABLE_OVERLOADING)
    StructureElementIsInlineMethodInfo      ,
#endif
    structureElementIsInline                ,




    ) 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.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.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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums
import {-# SOURCE #-} qualified GI.Poppler.Flags as Poppler.Flags
import {-# SOURCE #-} qualified GI.Poppler.Structs.Color as Poppler.Color
import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle
import {-# SOURCE #-} qualified GI.Poppler.Structs.TextSpan as Poppler.TextSpan

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

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

foreign import ccall "poppler_structure_element_get_type"
    c_poppler_structure_element_get_type :: IO B.Types.GType

instance B.Types.TypedObject StructureElement where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_element_get_type

instance B.Types.GObject StructureElement

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

instance O.HasParentTypes StructureElement
type instance O.ParentTypes StructureElement = '[GObject.Object.Object]

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

-- | Convert 'StructureElement' 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 StructureElement) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_poppler_structure_element_get_type
    gvalueSet_ :: Ptr GValue -> Maybe StructureElement -> IO ()
gvalueSet_ Ptr GValue
gv Maybe StructureElement
P.Nothing = Ptr GValue -> Ptr StructureElement -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr StructureElement
forall a. Ptr a
FP.nullPtr :: FP.Ptr StructureElement)
    gvalueSet_ Ptr GValue
gv (P.Just StructureElement
obj) = StructureElement -> (Ptr StructureElement -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr StructureElement
obj (Ptr GValue -> Ptr StructureElement -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe StructureElement)
gvalueGet_ Ptr GValue
gv = do
        Ptr StructureElement
ptr <- Ptr GValue -> IO (Ptr StructureElement)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr StructureElement)
        if Ptr StructureElement
ptr Ptr StructureElement -> Ptr StructureElement -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr StructureElement
forall a. Ptr a
FP.nullPtr
        then StructureElement -> Maybe StructureElement
forall a. a -> Maybe a
P.Just (StructureElement -> Maybe StructureElement)
-> IO StructureElement -> IO (Maybe StructureElement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr StructureElement -> StructureElement)
-> Ptr StructureElement -> IO StructureElement
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr StructureElement -> StructureElement
StructureElement Ptr StructureElement
ptr
        else Maybe StructureElement -> IO (Maybe StructureElement)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StructureElement
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveStructureElementMethod (t :: Symbol) (o :: *) :: * where
    ResolveStructureElementMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveStructureElementMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveStructureElementMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveStructureElementMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveStructureElementMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveStructureElementMethod "isBlock" o = StructureElementIsBlockMethodInfo
    ResolveStructureElementMethod "isContent" o = StructureElementIsContentMethodInfo
    ResolveStructureElementMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveStructureElementMethod "isGrouping" o = StructureElementIsGroupingMethodInfo
    ResolveStructureElementMethod "isInline" o = StructureElementIsInlineMethodInfo
    ResolveStructureElementMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveStructureElementMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveStructureElementMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveStructureElementMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveStructureElementMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveStructureElementMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveStructureElementMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveStructureElementMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveStructureElementMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveStructureElementMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveStructureElementMethod "getAbbreviation" o = StructureElementGetAbbreviationMethodInfo
    ResolveStructureElementMethod "getActualText" o = StructureElementGetActualTextMethodInfo
    ResolveStructureElementMethod "getAltText" o = StructureElementGetAltTextMethodInfo
    ResolveStructureElementMethod "getBackgroundColor" o = StructureElementGetBackgroundColorMethodInfo
    ResolveStructureElementMethod "getBaselineShift" o = StructureElementGetBaselineShiftMethodInfo
    ResolveStructureElementMethod "getBlockAlign" o = StructureElementGetBlockAlignMethodInfo
    ResolveStructureElementMethod "getBorderColor" o = StructureElementGetBorderColorMethodInfo
    ResolveStructureElementMethod "getBorderStyle" o = StructureElementGetBorderStyleMethodInfo
    ResolveStructureElementMethod "getBorderThickness" o = StructureElementGetBorderThicknessMethodInfo
    ResolveStructureElementMethod "getBoundingBox" o = StructureElementGetBoundingBoxMethodInfo
    ResolveStructureElementMethod "getColor" o = StructureElementGetColorMethodInfo
    ResolveStructureElementMethod "getColumnCount" o = StructureElementGetColumnCountMethodInfo
    ResolveStructureElementMethod "getColumnGaps" o = StructureElementGetColumnGapsMethodInfo
    ResolveStructureElementMethod "getColumnWidths" o = StructureElementGetColumnWidthsMethodInfo
    ResolveStructureElementMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveStructureElementMethod "getEndIndent" o = StructureElementGetEndIndentMethodInfo
    ResolveStructureElementMethod "getFormDescription" o = StructureElementGetFormDescriptionMethodInfo
    ResolveStructureElementMethod "getFormRole" o = StructureElementGetFormRoleMethodInfo
    ResolveStructureElementMethod "getFormState" o = StructureElementGetFormStateMethodInfo
    ResolveStructureElementMethod "getGlyphOrientation" o = StructureElementGetGlyphOrientationMethodInfo
    ResolveStructureElementMethod "getHeight" o = StructureElementGetHeightMethodInfo
    ResolveStructureElementMethod "getId" o = StructureElementGetIdMethodInfo
    ResolveStructureElementMethod "getInlineAlign" o = StructureElementGetInlineAlignMethodInfo
    ResolveStructureElementMethod "getKind" o = StructureElementGetKindMethodInfo
    ResolveStructureElementMethod "getLanguage" o = StructureElementGetLanguageMethodInfo
    ResolveStructureElementMethod "getLineHeight" o = StructureElementGetLineHeightMethodInfo
    ResolveStructureElementMethod "getListNumbering" o = StructureElementGetListNumberingMethodInfo
    ResolveStructureElementMethod "getPadding" o = StructureElementGetPaddingMethodInfo
    ResolveStructureElementMethod "getPage" o = StructureElementGetPageMethodInfo
    ResolveStructureElementMethod "getPlacement" o = StructureElementGetPlacementMethodInfo
    ResolveStructureElementMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveStructureElementMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveStructureElementMethod "getRubyAlign" o = StructureElementGetRubyAlignMethodInfo
    ResolveStructureElementMethod "getRubyPosition" o = StructureElementGetRubyPositionMethodInfo
    ResolveStructureElementMethod "getSpaceAfter" o = StructureElementGetSpaceAfterMethodInfo
    ResolveStructureElementMethod "getSpaceBefore" o = StructureElementGetSpaceBeforeMethodInfo
    ResolveStructureElementMethod "getStartIndent" o = StructureElementGetStartIndentMethodInfo
    ResolveStructureElementMethod "getTableBorderStyle" o = StructureElementGetTableBorderStyleMethodInfo
    ResolveStructureElementMethod "getTableColumnSpan" o = StructureElementGetTableColumnSpanMethodInfo
    ResolveStructureElementMethod "getTableHeaders" o = StructureElementGetTableHeadersMethodInfo
    ResolveStructureElementMethod "getTablePadding" o = StructureElementGetTablePaddingMethodInfo
    ResolveStructureElementMethod "getTableRowSpan" o = StructureElementGetTableRowSpanMethodInfo
    ResolveStructureElementMethod "getTableScope" o = StructureElementGetTableScopeMethodInfo
    ResolveStructureElementMethod "getTableSummary" o = StructureElementGetTableSummaryMethodInfo
    ResolveStructureElementMethod "getText" o = StructureElementGetTextMethodInfo
    ResolveStructureElementMethod "getTextAlign" o = StructureElementGetTextAlignMethodInfo
    ResolveStructureElementMethod "getTextDecorationColor" o = StructureElementGetTextDecorationColorMethodInfo
    ResolveStructureElementMethod "getTextDecorationThickness" o = StructureElementGetTextDecorationThicknessMethodInfo
    ResolveStructureElementMethod "getTextDecorationType" o = StructureElementGetTextDecorationTypeMethodInfo
    ResolveStructureElementMethod "getTextIndent" o = StructureElementGetTextIndentMethodInfo
    ResolveStructureElementMethod "getTextSpans" o = StructureElementGetTextSpansMethodInfo
    ResolveStructureElementMethod "getTitle" o = StructureElementGetTitleMethodInfo
    ResolveStructureElementMethod "getWidth" o = StructureElementGetWidthMethodInfo
    ResolveStructureElementMethod "getWritingMode" o = StructureElementGetWritingModeMethodInfo
    ResolveStructureElementMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveStructureElementMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveStructureElementMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveStructureElementMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList StructureElement
type instance O.AttributeList StructureElement = StructureElementAttributeList
type StructureElementAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList StructureElement = StructureElementSignalList
type StructureElementSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method StructureElement::get_abbreviation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_abbreviation" poppler_structure_element_get_abbreviation :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CString

-- | Acronyms and abbreviations contained in elements of type
-- @/POPPLER_STRUCTURE_ELEMENT_SPAN/@ may have an associated expanded
-- text form, which can be retrieved using this function.
-- 
-- /Since: 0.26/
structureElementGetAbbreviation ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m T.Text
    -- ^ __Returns:__ Text of the expanded abbreviation if the
    --    element text is an abbreviation or acrony, 'P.Nothing' if not.
structureElementGetAbbreviation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Text
structureElementGetAbbreviation a
popplerStructureElement = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CString
result <- Ptr StructureElement -> IO CString
poppler_structure_element_get_abbreviation Ptr StructureElement
popplerStructureElement'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementGetAbbreviation" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetAbbreviationMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetAbbreviationMethodInfo a signature where
    overloadedMethod = structureElementGetAbbreviation

instance O.OverloadedMethodInfo StructureElementGetAbbreviationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetAbbreviation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetAbbreviation"
        })


#endif

-- method StructureElement::get_actual_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_actual_text" poppler_structure_element_get_actual_text :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CString

-- | Obtains the actual text enclosed by the element (and its child elements).
-- The actual text is mostly used for non-text elements like images and
-- figures which \<emphasis>do\<\/emphasis> have the graphical appearance of text, like
-- a logo. For those the actual text is the equivalent text to those
-- graphical elements which look like text when rendered.
-- 
-- Note that for elements containing proper text, the function
-- 'GI.Poppler.Objects.StructureElement.structureElementGetText' must be used instead.
-- 
-- /Since: 0.26/
structureElementGetActualText ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m T.Text
    -- ^ __Returns:__ The actual text for the element, or 'P.Nothing'
    --    if not defined.
structureElementGetActualText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Text
structureElementGetActualText a
popplerStructureElement = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CString
result <- Ptr StructureElement -> IO CString
poppler_structure_element_get_actual_text Ptr StructureElement
popplerStructureElement'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementGetActualText" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetActualTextMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetActualTextMethodInfo a signature where
    overloadedMethod = structureElementGetActualText

instance O.OverloadedMethodInfo StructureElementGetActualTextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetActualText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetActualText"
        })


#endif

-- method StructureElement::get_alt_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_alt_text" poppler_structure_element_get_alt_text :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CString

-- | Obtains the “alternate” text representation of the element (and its child
-- elements). This is mostly used for non-text elements like images and
-- figures, to specify a textual description of the element.
-- 
-- Note that for elements containing proper text, the function
-- 'GI.Poppler.Objects.StructureElement.structureElementGetText' must be used instead.
-- 
-- /Since: 0.26/
structureElementGetAltText ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m T.Text
    -- ^ __Returns:__ The alternate text representation for the
    --    element, or 'P.Nothing' if not defined.
structureElementGetAltText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Text
structureElementGetAltText a
popplerStructureElement = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CString
result <- Ptr StructureElement -> IO CString
poppler_structure_element_get_alt_text Ptr StructureElement
popplerStructureElement'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementGetAltText" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetAltTextMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetAltTextMethodInfo a signature where
    overloadedMethod = structureElementGetAltText

instance O.OverloadedMethodInfo StructureElementGetAltTextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetAltText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetAltText"
        })


#endif

-- method StructureElement::get_background_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType =
--               TInterface Name { namespace = "Poppler" , name = "Color" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerColor." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_background_color" poppler_structure_element_get_background_color :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    Ptr Poppler.Color.Color ->              -- color : TInterface (Name {namespace = "Poppler", name = "Color"})
    IO CInt

-- | Obtains the background color of the element. If this attribute is
-- not specified, the element shall be treated as if it were transparent.
-- 
-- /Since: 0.26/
structureElementGetBackgroundColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m ((Bool, Poppler.Color.Color))
    -- ^ __Returns:__ 'P.True' if a color is defined for the element,
    --    'P.False' otherwise.
structureElementGetBackgroundColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m (Bool, Color)
structureElementGetBackgroundColor a
popplerStructureElement = IO (Bool, Color) -> m (Bool, Color)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Color) -> m (Bool, Color))
-> IO (Bool, Color) -> m (Bool, Color)
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Ptr Color
color <- Int -> IO (Ptr Color)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
6 :: IO (Ptr Poppler.Color.Color)
    CInt
result <- Ptr StructureElement -> Ptr Color -> IO CInt
poppler_structure_element_get_background_color Ptr StructureElement
popplerStructureElement' Ptr Color
color
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Color
color' <- ((ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Color -> Color
Poppler.Color.Color) Ptr Color
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    (Bool, Color) -> IO (Bool, Color)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Color
color')

#if defined(ENABLE_OVERLOADING)
data StructureElementGetBackgroundColorMethodInfo
instance (signature ~ (m ((Bool, Poppler.Color.Color))), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetBackgroundColorMethodInfo a signature where
    overloadedMethod = structureElementGetBackgroundColor

instance O.OverloadedMethodInfo StructureElementGetBackgroundColorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetBackgroundColor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetBackgroundColor"
        })


#endif

-- method StructureElement::get_baseline_shift
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_baseline_shift" poppler_structure_element_get_baseline_shift :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CDouble

-- | Obtains how much the text contained in the inline-level structure element should be shifted,
-- measuring from the baseline of the glyphs.
-- 
-- /Since: 0.26/
structureElementGetBaselineShift ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Double
    -- ^ __Returns:__ A numeric value.
structureElementGetBaselineShift :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Double
structureElementGetBaselineShift a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CDouble
result <- Ptr StructureElement -> IO CDouble
poppler_structure_element_get_baseline_shift Ptr StructureElement
popplerStructureElement'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetBaselineShiftMethodInfo
instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetBaselineShiftMethodInfo a signature where
    overloadedMethod = structureElementGetBaselineShift

instance O.OverloadedMethodInfo StructureElementGetBaselineShiftMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetBaselineShift",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetBaselineShift"
        })


#endif

-- method StructureElement::get_block_align
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureBlockAlign" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_block_align" poppler_structure_element_get_block_align :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CUInt

-- | Obtains the block-alignment mode of the block-level structure element.
-- 
-- /Since: 0.26/
structureElementGetBlockAlign ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Poppler.Enums.StructureBlockAlign
    -- ^ __Returns:__ A t'GI.Poppler.Enums.StructureBlockAlign' value.
structureElementGetBlockAlign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m StructureBlockAlign
structureElementGetBlockAlign a
popplerStructureElement = IO StructureBlockAlign -> m StructureBlockAlign
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureBlockAlign -> m StructureBlockAlign)
-> IO StructureBlockAlign -> m StructureBlockAlign
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CUInt
result <- Ptr StructureElement -> IO CUInt
poppler_structure_element_get_block_align Ptr StructureElement
popplerStructureElement'
    let result' :: StructureBlockAlign
result' = (Int -> StructureBlockAlign
forall a. Enum a => Int -> a
toEnum (Int -> StructureBlockAlign)
-> (CUInt -> Int) -> CUInt -> StructureBlockAlign
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    StructureBlockAlign -> IO StructureBlockAlign
forall (m :: * -> *) a. Monad m => a -> m a
return StructureBlockAlign
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetBlockAlignMethodInfo
instance (signature ~ (m Poppler.Enums.StructureBlockAlign), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetBlockAlignMethodInfo a signature where
    overloadedMethod = structureElementGetBlockAlign

instance O.OverloadedMethodInfo StructureElementGetBlockAlignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetBlockAlign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetBlockAlign"
        })


#endif

-- XXX Could not generate method StructureElement::get_border_color
-- Not implemented: Don't know how to allocate "colors" of type TCArray False 4 (-1) (TInterface (Name {namespace = "Poppler", name = "Color"}))
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data StructureElementGetBorderColorMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "getBorderColor" StructureElement) => O.OverloadedMethod StructureElementGetBorderColorMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "getBorderColor" StructureElement) => O.OverloadedMethodInfo StructureElementGetBorderColorMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- method StructureElement::get_border_style
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "border_styles"
--           , argType =
--               TCArray
--                 False
--                 4
--                 (-1)
--                 (TInterface
--                    Name { namespace = "Poppler" , name = "StructureBorderStyle" })
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "\n   An array of four #PopplerStructureBorderStyle elements."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_border_style" poppler_structure_element_get_border_style :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    Ptr (Ptr CUInt) ->                      -- border_styles : TCArray False 4 (-1) (TInterface (Name {namespace = "Poppler", name = "StructureBorderStyle"}))
    IO ()

-- | Obtains the border style of a structure element. The result values
-- are in before-after-start-end ordering. For example, using Western
-- left-to-right writing, that is top-bottom-left-right.
-- 
-- /Since: 0.26/
structureElementGetBorderStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m ([Poppler.Enums.StructureBorderStyle])
structureElementGetBorderStyle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m [StructureBorderStyle]
structureElementGetBorderStyle a
popplerStructureElement = IO [StructureBorderStyle] -> m [StructureBorderStyle]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [StructureBorderStyle] -> m [StructureBorderStyle])
-> IO [StructureBorderStyle] -> m [StructureBorderStyle]
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Ptr (Ptr CUInt)
borderStyles <- IO (Ptr (Ptr CUInt))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr CUInt))
    Ptr StructureElement -> Ptr (Ptr CUInt) -> IO ()
poppler_structure_element_get_border_style Ptr StructureElement
popplerStructureElement' Ptr (Ptr CUInt)
borderStyles
    Ptr CUInt
borderStyles' <- Ptr (Ptr CUInt) -> IO (Ptr CUInt)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr CUInt)
borderStyles
    [CUInt]
borderStyles'' <- (Integer -> Ptr CUInt -> IO [CUInt]
forall a b. (Integral a, Storable b) => a -> Ptr b -> IO [b]
unpackStorableArrayWithLength Integer
4) Ptr CUInt
borderStyles'
    let borderStyles''' :: [StructureBorderStyle]
borderStyles''' = (CUInt -> StructureBorderStyle)
-> [CUInt] -> [StructureBorderStyle]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> StructureBorderStyle
forall a. Enum a => Int -> a
toEnum (Int -> StructureBorderStyle)
-> (CUInt -> Int) -> CUInt -> StructureBorderStyle
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) [CUInt]
borderStyles''
    Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
borderStyles'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Ptr (Ptr CUInt) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CUInt)
borderStyles
    [StructureBorderStyle] -> IO [StructureBorderStyle]
forall (m :: * -> *) a. Monad m => a -> m a
return [StructureBorderStyle]
borderStyles'''

#if defined(ENABLE_OVERLOADING)
data StructureElementGetBorderStyleMethodInfo
instance (signature ~ (m ([Poppler.Enums.StructureBorderStyle])), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetBorderStyleMethodInfo a signature where
    overloadedMethod = structureElementGetBorderStyle

instance O.OverloadedMethodInfo StructureElementGetBorderStyleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetBorderStyle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetBorderStyle"
        })


#endif

-- method StructureElement::get_border_thickness
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "border_thicknesses"
--           , argType = TCArray False 4 (-1) (TBasicType TDouble)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "\n   Array with the four values of border thicknesses."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_border_thickness" poppler_structure_element_get_border_thickness :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    Ptr (Ptr CDouble) ->                    -- border_thicknesses : TCArray False 4 (-1) (TBasicType TDouble)
    IO CInt

-- | Obtains the thickness of the border of an element. The result values
-- are in before-after-start-end ordering (for the typical Western
-- left-to-right writing, that is top-bottom-left-right).
-- A value of 0 indicates that the border shall not be drawn.
-- 
-- /Since: 0.26/
structureElementGetBorderThickness ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m ((Bool, [Double]))
    -- ^ __Returns:__ 'P.True' if the border thickness attribute is defined for
    --    the element, 'P.False' otherwise.
structureElementGetBorderThickness :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m (Bool, [Double])
structureElementGetBorderThickness a
popplerStructureElement = IO (Bool, [Double]) -> m (Bool, [Double])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, [Double]) -> m (Bool, [Double]))
-> IO (Bool, [Double]) -> m (Bool, [Double])
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Ptr (Ptr CDouble)
borderThicknesses <- IO (Ptr (Ptr CDouble))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr CDouble))
    CInt
result <- Ptr StructureElement -> Ptr (Ptr CDouble) -> IO CInt
poppler_structure_element_get_border_thickness Ptr StructureElement
popplerStructureElement' Ptr (Ptr CDouble)
borderThicknesses
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Ptr CDouble
borderThicknesses' <- Ptr (Ptr CDouble) -> IO (Ptr CDouble)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr CDouble)
borderThicknesses
    [Double]
borderThicknesses'' <- ((CDouble -> Double) -> Integer -> Ptr CDouble -> IO [Double]
forall a b c.
(Integral a, Storable b) =>
(b -> c) -> a -> Ptr b -> IO [c]
unpackMapStorableArrayWithLength CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac Integer
4) Ptr CDouble
borderThicknesses'
    Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
borderThicknesses'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Ptr (Ptr CDouble) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CDouble)
borderThicknesses
    (Bool, [Double]) -> IO (Bool, [Double])
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', [Double]
borderThicknesses'')

#if defined(ENABLE_OVERLOADING)
data StructureElementGetBorderThicknessMethodInfo
instance (signature ~ (m ((Bool, [Double]))), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetBorderThicknessMethodInfo a signature where
    overloadedMethod = structureElementGetBorderThickness

instance O.OverloadedMethodInfo StructureElementGetBorderThicknessMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetBorderThickness",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetBorderThickness"
        })


#endif

-- method StructureElement::get_bounding_box
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bounding_box"
--           , argType =
--               TInterface Name { namespace = "Poppler" , name = "Rectangle" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerRectangle."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_bounding_box" poppler_structure_element_get_bounding_box :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    Ptr Poppler.Rectangle.Rectangle ->      -- bounding_box : TInterface (Name {namespace = "Poppler", name = "Rectangle"})
    IO CInt

-- | Obtains the size of the bounding box of a block-level structure element.
-- 
-- /Since: 0.26/
structureElementGetBoundingBox ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m ((Bool, Poppler.Rectangle.Rectangle))
    -- ^ __Returns:__ 'P.True' if a bounding box is defined for the element,
    --    'P.False' otherwise.
structureElementGetBoundingBox :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m (Bool, Rectangle)
structureElementGetBoundingBox a
popplerStructureElement = IO (Bool, Rectangle) -> m (Bool, Rectangle)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Rectangle) -> m (Bool, Rectangle))
-> IO (Bool, Rectangle) -> m (Bool, Rectangle)
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Ptr Rectangle
boundingBox <- Int -> IO (Ptr Rectangle)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Poppler.Rectangle.Rectangle)
    CInt
result <- Ptr StructureElement -> Ptr Rectangle -> IO CInt
poppler_structure_element_get_bounding_box Ptr StructureElement
popplerStructureElement' Ptr Rectangle
boundingBox
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Rectangle
boundingBox' <- ((ManagedPtr Rectangle -> Rectangle)
-> Ptr Rectangle -> IO Rectangle
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rectangle -> Rectangle
Poppler.Rectangle.Rectangle) Ptr Rectangle
boundingBox
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    (Bool, Rectangle) -> IO (Bool, Rectangle)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Rectangle
boundingBox')

#if defined(ENABLE_OVERLOADING)
data StructureElementGetBoundingBoxMethodInfo
instance (signature ~ (m ((Bool, Poppler.Rectangle.Rectangle))), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetBoundingBoxMethodInfo a signature where
    overloadedMethod = structureElementGetBoundingBox

instance O.OverloadedMethodInfo StructureElementGetBoundingBoxMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetBoundingBox",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetBoundingBox"
        })


#endif

-- method StructureElement::get_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType =
--               TInterface Name { namespace = "Poppler" , name = "Color" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerColor." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_color" poppler_structure_element_get_color :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    Ptr Poppler.Color.Color ->              -- color : TInterface (Name {namespace = "Poppler", name = "Color"})
    IO CInt

-- | Obtains the color of the content contained in the element.
-- If this attribute is not specified, the color for this element shall
-- be the current text fill color in effect at the start of its associated content.
-- 
-- /Since: 0.26/
structureElementGetColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m ((Bool, Poppler.Color.Color))
    -- ^ __Returns:__ 'P.True' if a color is defined for the element,
    --    'P.False' otherwise.
structureElementGetColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m (Bool, Color)
structureElementGetColor a
popplerStructureElement = IO (Bool, Color) -> m (Bool, Color)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Color) -> m (Bool, Color))
-> IO (Bool, Color) -> m (Bool, Color)
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Ptr Color
color <- Int -> IO (Ptr Color)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
6 :: IO (Ptr Poppler.Color.Color)
    CInt
result <- Ptr StructureElement -> Ptr Color -> IO CInt
poppler_structure_element_get_color Ptr StructureElement
popplerStructureElement' Ptr Color
color
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Color
color' <- ((ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Color -> Color
Poppler.Color.Color) Ptr Color
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    (Bool, Color) -> IO (Bool, Color)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Color
color')

#if defined(ENABLE_OVERLOADING)
data StructureElementGetColorMethodInfo
instance (signature ~ (m ((Bool, Poppler.Color.Color))), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetColorMethodInfo a signature where
    overloadedMethod = structureElementGetColor

instance O.OverloadedMethodInfo StructureElementGetColorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetColor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetColor"
        })


#endif

-- method StructureElement::get_column_count
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_column_count" poppler_structure_element_get_column_count :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO Word32

-- | Obtains the number of columns used to lay out the content contained
-- in the grouping element.
-- 
-- /Since: 0.26/
structureElementGetColumnCount ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Word32
    -- ^ __Returns:__ Number of columns.
structureElementGetColumnCount :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Word32
structureElementGetColumnCount a
popplerStructureElement = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Word32
result <- Ptr StructureElement -> IO Word32
poppler_structure_element_get_column_count Ptr StructureElement
popplerStructureElement'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data StructureElementGetColumnCountMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetColumnCountMethodInfo a signature where
    overloadedMethod = structureElementGetColumnCount

instance O.OverloadedMethodInfo StructureElementGetColumnCountMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetColumnCount",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetColumnCount"
        })


#endif

-- method StructureElement::get_column_gaps
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_values"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Size of the returned array."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_values"
--              , argType = TBasicType TUInt
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "Size of the returned array."
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Just (TCArray False (-1) 1 (TBasicType TDouble))
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_column_gaps" poppler_structure_element_get_column_gaps :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    Ptr Word32 ->                           -- n_values : TBasicType TUInt
    IO (Ptr CDouble)

-- | Obtains the size of the gaps in between adjacent columns. Returns an
-- array of elements: the first one is the size of the gap in between
-- columns 1 and 2, second is the size between columns 2 and 3, and so on.
-- 
-- For elements which use a single column, 'P.Nothing' is returned and /@nValues@/
-- is set to zero.
-- 
-- If the attribute is undefined, 'P.Nothing' is returned and /@nValues@/ is set
-- to a non-zero value.
-- 
-- The array with the results is allocated by the function. When it is
-- not needed anymore, be sure to call 'GI.GLib.Functions.free' on it.
-- 
-- /Since: 0.26/
structureElementGetColumnGaps ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m [Double]
    -- ^ __Returns:__ 
    --    Array containing the values for the column gaps, or 'P.Nothing' if the
    --    array is empty or the attribute is not defined.
structureElementGetColumnGaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m [Double]
structureElementGetColumnGaps a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Ptr Word32
nValues <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
    Ptr CDouble
result <- Ptr StructureElement -> Ptr Word32 -> IO (Ptr CDouble)
poppler_structure_element_get_column_gaps Ptr StructureElement
popplerStructureElement' Ptr Word32
nValues
    Word32
nValues' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
nValues
    Text -> Ptr CDouble -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementGetColumnGaps" Ptr CDouble
result
    [Double]
result' <- ((CDouble -> Double) -> Word32 -> Ptr CDouble -> IO [Double]
forall a b c.
(Integral a, Storable b) =>
(b -> c) -> a -> Ptr b -> IO [c]
unpackMapStorableArrayWithLength CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac Word32
nValues') Ptr CDouble
result
    Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
nValues
    [Double] -> IO [Double]
forall (m :: * -> *) a. Monad m => a -> m a
return [Double]
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetColumnGapsMethodInfo
instance (signature ~ (m [Double]), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetColumnGapsMethodInfo a signature where
    overloadedMethod = structureElementGetColumnGaps

instance O.OverloadedMethodInfo StructureElementGetColumnGapsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetColumnGaps",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetColumnGaps"
        })


#endif

-- method StructureElement::get_column_widths
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_values"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Size of the returned array."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_values"
--              , argType = TBasicType TUInt
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "Size of the returned array."
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Just (TCArray False (-1) 1 (TBasicType TDouble))
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_column_widths" poppler_structure_element_get_column_widths :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    Ptr Word32 ->                           -- n_values : TBasicType TUInt
    IO (Ptr CDouble)

-- | Obtains an array with the widths of the columns.
-- 
-- The array with the results is allocated by the function. When it is
-- not needed anymore, be sure to call 'GI.GLib.Functions.free' on it.
-- 
-- /Since: 0.26/
structureElementGetColumnWidths ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m [Double]
    -- ^ __Returns:__ 
    --    Array containing widths of the columns, or 'P.Nothing' if the attribute
    --    is not defined.
structureElementGetColumnWidths :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m [Double]
structureElementGetColumnWidths a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Ptr Word32
nValues <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
    Ptr CDouble
result <- Ptr StructureElement -> Ptr Word32 -> IO (Ptr CDouble)
poppler_structure_element_get_column_widths Ptr StructureElement
popplerStructureElement' Ptr Word32
nValues
    Word32
nValues' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
nValues
    Text -> Ptr CDouble -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementGetColumnWidths" Ptr CDouble
result
    [Double]
result' <- ((CDouble -> Double) -> Word32 -> Ptr CDouble -> IO [Double]
forall a b c.
(Integral a, Storable b) =>
(b -> c) -> a -> Ptr b -> IO [c]
unpackMapStorableArrayWithLength CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac Word32
nValues') Ptr CDouble
result
    Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
nValues
    [Double] -> IO [Double]
forall (m :: * -> *) a. Monad m => a -> m a
return [Double]
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetColumnWidthsMethodInfo
instance (signature ~ (m [Double]), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetColumnWidthsMethodInfo a signature where
    overloadedMethod = structureElementGetColumnWidths

instance O.OverloadedMethodInfo StructureElementGetColumnWidthsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetColumnWidths",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetColumnWidths"
        })


#endif

-- method StructureElement::get_end_indent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_end_indent" poppler_structure_element_get_end_indent :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CDouble

-- | Obtains the amount of indentation at the end of the block-level structure element.
-- 
-- /Since: 0.26/
structureElementGetEndIndent ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Double
    -- ^ __Returns:__ A numeric value.
structureElementGetEndIndent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Double
structureElementGetEndIndent a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CDouble
result <- Ptr StructureElement -> IO CDouble
poppler_structure_element_get_end_indent Ptr StructureElement
popplerStructureElement'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetEndIndentMethodInfo
instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetEndIndentMethodInfo a signature where
    overloadedMethod = structureElementGetEndIndent

instance O.OverloadedMethodInfo StructureElementGetEndIndentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetEndIndent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetEndIndent"
        })


#endif

-- method StructureElement::get_form_description
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_form_description" poppler_structure_element_get_form_description :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CString

-- | Obtains the textual description of the form element. Note that the
-- description is for informative purposes, and it is not intended
-- to be rendered. For example, assistive technologies may use the
-- description field to provide an alternate way of presenting an
-- element to the user.
-- 
-- The returned string is allocated by the function. When it is
-- not needed anymore, be sure to call 'GI.GLib.Functions.free' on it.
-- 
-- /Since: 0.26/
structureElementGetFormDescription ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m T.Text
    -- ^ __Returns:__ A string, or 'P.Nothing' if the attribute
    --    is not defined.
structureElementGetFormDescription :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Text
structureElementGetFormDescription a
popplerStructureElement = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CString
result <- Ptr StructureElement -> IO CString
poppler_structure_element_get_form_description Ptr StructureElement
popplerStructureElement'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementGetFormDescription" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetFormDescriptionMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetFormDescriptionMethodInfo a signature where
    overloadedMethod = structureElementGetFormDescription

instance O.OverloadedMethodInfo StructureElementGetFormDescriptionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetFormDescription",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetFormDescription"
        })


#endif

-- method StructureElement::get_form_role
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureFormRole" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_form_role" poppler_structure_element_get_form_role :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CUInt

-- | Obtains the role of a form structure element that is part of a form, or is
-- a form field. This hints how the control for the element is intended
-- to be rendered.
-- 
-- /Since: 0.26/
structureElementGetFormRole ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Poppler.Enums.StructureFormRole
    -- ^ __Returns:__ A t'GI.Poppler.Enums.StructureFormRole' value.
structureElementGetFormRole :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m StructureFormRole
structureElementGetFormRole a
popplerStructureElement = IO StructureFormRole -> m StructureFormRole
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureFormRole -> m StructureFormRole)
-> IO StructureFormRole -> m StructureFormRole
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CUInt
result <- Ptr StructureElement -> IO CUInt
poppler_structure_element_get_form_role Ptr StructureElement
popplerStructureElement'
    let result' :: StructureFormRole
result' = (Int -> StructureFormRole
forall a. Enum a => Int -> a
toEnum (Int -> StructureFormRole)
-> (CUInt -> Int) -> CUInt -> StructureFormRole
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    StructureFormRole -> IO StructureFormRole
forall (m :: * -> *) a. Monad m => a -> m a
return StructureFormRole
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetFormRoleMethodInfo
instance (signature ~ (m Poppler.Enums.StructureFormRole), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetFormRoleMethodInfo a signature where
    overloadedMethod = structureElementGetFormRole

instance O.OverloadedMethodInfo StructureElementGetFormRoleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetFormRole",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetFormRole"
        })


#endif

-- method StructureElement::get_form_state
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureFormState" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_form_state" poppler_structure_element_get_form_state :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CUInt

-- | For a structure element that is a form field, obtains in which state
-- the associated control is expected to be rendered.
-- 
-- /Since: 0.26/
structureElementGetFormState ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Poppler.Enums.StructureFormState
    -- ^ __Returns:__ A t'GI.Poppler.Enums.StructureFormState' value.
structureElementGetFormState :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m StructureFormState
structureElementGetFormState a
popplerStructureElement = IO StructureFormState -> m StructureFormState
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureFormState -> m StructureFormState)
-> IO StructureFormState -> m StructureFormState
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CUInt
result <- Ptr StructureElement -> IO CUInt
poppler_structure_element_get_form_state Ptr StructureElement
popplerStructureElement'
    let result' :: StructureFormState
result' = (Int -> StructureFormState
forall a. Enum a => Int -> a
toEnum (Int -> StructureFormState)
-> (CUInt -> Int) -> CUInt -> StructureFormState
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    StructureFormState -> IO StructureFormState
forall (m :: * -> *) a. Monad m => a -> m a
return StructureFormState
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetFormStateMethodInfo
instance (signature ~ (m Poppler.Enums.StructureFormState), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetFormStateMethodInfo a signature where
    overloadedMethod = structureElementGetFormState

instance O.OverloadedMethodInfo StructureElementGetFormStateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetFormState",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetFormState"
        })


#endif

-- method StructureElement::get_glyph_orientation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name
--                    { namespace = "Poppler" , name = "StructureGlyphOrientation" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_glyph_orientation" poppler_structure_element_get_glyph_orientation :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CUInt

-- | Obtains the glyph orientation for the text contained in a
-- inline-level structure element.
-- 
-- /Since: 0.26/
structureElementGetGlyphOrientation ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Poppler.Enums.StructureGlyphOrientation
    -- ^ __Returns:__ A t'GI.Poppler.Enums.StructureGlyphOrientation' value.
structureElementGetGlyphOrientation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m StructureGlyphOrientation
structureElementGetGlyphOrientation a
popplerStructureElement = IO StructureGlyphOrientation -> m StructureGlyphOrientation
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureGlyphOrientation -> m StructureGlyphOrientation)
-> IO StructureGlyphOrientation -> m StructureGlyphOrientation
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CUInt
result <- Ptr StructureElement -> IO CUInt
poppler_structure_element_get_glyph_orientation Ptr StructureElement
popplerStructureElement'
    let result' :: StructureGlyphOrientation
result' = (Int -> StructureGlyphOrientation
forall a. Enum a => Int -> a
toEnum (Int -> StructureGlyphOrientation)
-> (CUInt -> Int) -> CUInt -> StructureGlyphOrientation
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    StructureGlyphOrientation -> IO StructureGlyphOrientation
forall (m :: * -> *) a. Monad m => a -> m a
return StructureGlyphOrientation
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetGlyphOrientationMethodInfo
instance (signature ~ (m Poppler.Enums.StructureGlyphOrientation), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetGlyphOrientationMethodInfo a signature where
    overloadedMethod = structureElementGetGlyphOrientation

instance O.OverloadedMethodInfo StructureElementGetGlyphOrientationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetGlyphOrientation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetGlyphOrientation"
        })


#endif

-- method StructureElement::get_height
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_height" poppler_structure_element_get_height :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CDouble

-- | Obtains the height of the block-level structure element. Note that for elements which do
-- not specify a height, it has to be calculated, and in this case -1 is returned.
-- 
-- /Since: 0.26/
structureElementGetHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Double
    -- ^ __Returns:__ A positive value if a width is defined, or -1
    --    if the height is to be calculated automatically.
structureElementGetHeight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Double
structureElementGetHeight a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CDouble
result <- Ptr StructureElement -> IO CDouble
poppler_structure_element_get_height Ptr StructureElement
popplerStructureElement'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetHeightMethodInfo
instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetHeightMethodInfo a signature where
    overloadedMethod = structureElementGetHeight

instance O.OverloadedMethodInfo StructureElementGetHeightMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetHeight",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetHeight"
        })


#endif

-- method StructureElement::get_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_id" poppler_structure_element_get_id :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CString

-- | Obtains the identifier of an element.
-- 
-- /Since: 0.26/
structureElementGetId ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m T.Text
    -- ^ __Returns:__ The identifier of the element (if
    --    defined), or 'P.Nothing'.
structureElementGetId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Text
structureElementGetId a
popplerStructureElement = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CString
result <- Ptr StructureElement -> IO CString
poppler_structure_element_get_id Ptr StructureElement
popplerStructureElement'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementGetId" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetIdMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetIdMethodInfo a signature where
    overloadedMethod = structureElementGetId

instance O.OverloadedMethodInfo StructureElementGetIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetId",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetId"
        })


#endif

-- method StructureElement::get_inline_align
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureInlineAlign" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_inline_align" poppler_structure_element_get_inline_align :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CUInt

-- | Obtains the inline-alignment mode of the block-level structure element.
-- 
-- /Since: 0.26/
structureElementGetInlineAlign ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Poppler.Enums.StructureInlineAlign
    -- ^ __Returns:__ A t'GI.Poppler.Enums.StructureInlineAlign' value.
structureElementGetInlineAlign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m StructureInlineAlign
structureElementGetInlineAlign a
popplerStructureElement = IO StructureInlineAlign -> m StructureInlineAlign
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureInlineAlign -> m StructureInlineAlign)
-> IO StructureInlineAlign -> m StructureInlineAlign
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CUInt
result <- Ptr StructureElement -> IO CUInt
poppler_structure_element_get_inline_align Ptr StructureElement
popplerStructureElement'
    let result' :: StructureInlineAlign
result' = (Int -> StructureInlineAlign
forall a. Enum a => Int -> a
toEnum (Int -> StructureInlineAlign)
-> (CUInt -> Int) -> CUInt -> StructureInlineAlign
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    StructureInlineAlign -> IO StructureInlineAlign
forall (m :: * -> *) a. Monad m => a -> m a
return StructureInlineAlign
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetInlineAlignMethodInfo
instance (signature ~ (m Poppler.Enums.StructureInlineAlign), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetInlineAlignMethodInfo a signature where
    overloadedMethod = structureElementGetInlineAlign

instance O.OverloadedMethodInfo StructureElementGetInlineAlignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetInlineAlign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetInlineAlign"
        })


#endif

-- method StructureElement::get_kind
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureElementKind" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_kind" poppler_structure_element_get_kind :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CUInt

-- | /No description available in the introspection data./
-- 
-- /Since: 0.26/
structureElementGetKind ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Poppler.Enums.StructureElementKind
    -- ^ __Returns:__ A t'GI.Poppler.Enums.StructureElementKind' value.
structureElementGetKind :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m StructureElementKind
structureElementGetKind a
popplerStructureElement = IO StructureElementKind -> m StructureElementKind
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureElementKind -> m StructureElementKind)
-> IO StructureElementKind -> m StructureElementKind
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CUInt
result <- Ptr StructureElement -> IO CUInt
poppler_structure_element_get_kind Ptr StructureElement
popplerStructureElement'
    let result' :: StructureElementKind
result' = (Int -> StructureElementKind
forall a. Enum a => Int -> a
toEnum (Int -> StructureElementKind)
-> (CUInt -> Int) -> CUInt -> StructureElementKind
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    StructureElementKind -> IO StructureElementKind
forall (m :: * -> *) a. Monad m => a -> m a
return StructureElementKind
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetKindMethodInfo
instance (signature ~ (m Poppler.Enums.StructureElementKind), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetKindMethodInfo a signature where
    overloadedMethod = structureElementGetKind

instance O.OverloadedMethodInfo StructureElementGetKindMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetKind",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetKind"
        })


#endif

-- method StructureElement::get_language
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_language" poppler_structure_element_get_language :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CString

-- | Obtains the language and country code for the content in an element,
-- in two-letter ISO format, e.g. \<code>en_ES\<\/code>, or 'P.Nothing' if not
-- defined.
-- 
-- /Since: 0.26/
structureElementGetLanguage ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m T.Text
    -- ^ __Returns:__ language and country code, or 'P.Nothing'.
structureElementGetLanguage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Text
structureElementGetLanguage a
popplerStructureElement = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CString
result <- Ptr StructureElement -> IO CString
poppler_structure_element_get_language Ptr StructureElement
popplerStructureElement'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementGetLanguage" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetLanguageMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetLanguageMethodInfo a signature where
    overloadedMethod = structureElementGetLanguage

instance O.OverloadedMethodInfo StructureElementGetLanguageMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetLanguage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetLanguage"
        })


#endif

-- method StructureElement::get_line_height
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_line_height" poppler_structure_element_get_line_height :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CDouble

-- | Obtains the line height for the text contained in the inline-level structure element.
-- Note that for elements which do not specify a line height, it has to be calculated,
-- and in this case -1 is returned.
-- 
-- /Since: 0.26/
structureElementGetLineHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Double
    -- ^ __Returns:__ A positive value if a line height is defined, or -1
    --    if the height is to be calculated automatically.
structureElementGetLineHeight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Double
structureElementGetLineHeight a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CDouble
result <- Ptr StructureElement -> IO CDouble
poppler_structure_element_get_line_height Ptr StructureElement
popplerStructureElement'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetLineHeightMethodInfo
instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetLineHeightMethodInfo a signature where
    overloadedMethod = structureElementGetLineHeight

instance O.OverloadedMethodInfo StructureElementGetLineHeightMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetLineHeight",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetLineHeight"
        })


#endif

-- method StructureElement::get_list_numbering
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureListNumbering" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_list_numbering" poppler_structure_element_get_list_numbering :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CUInt

-- | Obtains the list numbering style for list items.
-- 
-- /Since: 0.26/
structureElementGetListNumbering ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Poppler.Enums.StructureListNumbering
    -- ^ __Returns:__ A t'GI.Poppler.Enums.StructureListNumbering' value.
structureElementGetListNumbering :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m StructureListNumbering
structureElementGetListNumbering a
popplerStructureElement = IO StructureListNumbering -> m StructureListNumbering
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureListNumbering -> m StructureListNumbering)
-> IO StructureListNumbering -> m StructureListNumbering
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CUInt
result <- Ptr StructureElement -> IO CUInt
poppler_structure_element_get_list_numbering Ptr StructureElement
popplerStructureElement'
    let result' :: StructureListNumbering
result' = (Int -> StructureListNumbering
forall a. Enum a => Int -> a
toEnum (Int -> StructureListNumbering)
-> (CUInt -> Int) -> CUInt -> StructureListNumbering
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    StructureListNumbering -> IO StructureListNumbering
forall (m :: * -> *) a. Monad m => a -> m a
return StructureListNumbering
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetListNumberingMethodInfo
instance (signature ~ (m Poppler.Enums.StructureListNumbering), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetListNumberingMethodInfo a signature where
    overloadedMethod = structureElementGetListNumbering

instance O.OverloadedMethodInfo StructureElementGetListNumberingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetListNumbering",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetListNumbering"
        })


#endif

-- method StructureElement::get_padding
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "paddings"
--           , argType = TCArray False 4 (-1) (TBasicType TDouble)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "\n   Padding for the four sides of the element."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_padding" poppler_structure_element_get_padding :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    Ptr (Ptr CDouble) ->                    -- paddings : TCArray False 4 (-1) (TBasicType TDouble)
    IO ()

-- | Obtains the padding of an element (space around it). The result
-- values are in before-after-start-end ordering. For example using
-- Western left-to-right writing, that is top-bottom-left-right.
-- 
-- /Since: 0.26/
structureElementGetPadding ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m ([Double])
structureElementGetPadding :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m [Double]
structureElementGetPadding a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Ptr (Ptr CDouble)
paddings <- IO (Ptr (Ptr CDouble))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr CDouble))
    Ptr StructureElement -> Ptr (Ptr CDouble) -> IO ()
poppler_structure_element_get_padding Ptr StructureElement
popplerStructureElement' Ptr (Ptr CDouble)
paddings
    Ptr CDouble
paddings' <- Ptr (Ptr CDouble) -> IO (Ptr CDouble)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr CDouble)
paddings
    [Double]
paddings'' <- ((CDouble -> Double) -> Integer -> Ptr CDouble -> IO [Double]
forall a b c.
(Integral a, Storable b) =>
(b -> c) -> a -> Ptr b -> IO [c]
unpackMapStorableArrayWithLength CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac Integer
4) Ptr CDouble
paddings'
    Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
paddings'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Ptr (Ptr CDouble) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CDouble)
paddings
    [Double] -> IO [Double]
forall (m :: * -> *) a. Monad m => a -> m a
return [Double]
paddings''

#if defined(ENABLE_OVERLOADING)
data StructureElementGetPaddingMethodInfo
instance (signature ~ (m ([Double])), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetPaddingMethodInfo a signature where
    overloadedMethod = structureElementGetPadding

instance O.OverloadedMethodInfo StructureElementGetPaddingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetPadding",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetPadding"
        })


#endif

-- method StructureElement::get_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_page" poppler_structure_element_get_page :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO Int32

-- | Obtains the page number in which the element is contained.
-- 
-- /Since: 0.26/
structureElementGetPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Int32
    -- ^ __Returns:__ Number of the page that contains the element, of
    --    \<code>-1\<\/code> if not defined.
structureElementGetPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Int32
structureElementGetPage a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Int32
result <- Ptr StructureElement -> IO Int32
poppler_structure_element_get_page Ptr StructureElement
popplerStructureElement'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data StructureElementGetPageMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetPageMethodInfo a signature where
    overloadedMethod = structureElementGetPage

instance O.OverloadedMethodInfo StructureElementGetPageMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetPage"
        })


#endif

-- method StructureElement::get_placement
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructurePlacement" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_placement" poppler_structure_element_get_placement :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CUInt

-- | Obtains the placement type of the structure element.
-- 
-- /Since: 0.26/
structureElementGetPlacement ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Poppler.Enums.StructurePlacement
    -- ^ __Returns:__ A t'GI.Poppler.Enums.StructurePlacement' value.
structureElementGetPlacement :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m StructurePlacement
structureElementGetPlacement a
popplerStructureElement = IO StructurePlacement -> m StructurePlacement
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructurePlacement -> m StructurePlacement)
-> IO StructurePlacement -> m StructurePlacement
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CUInt
result <- Ptr StructureElement -> IO CUInt
poppler_structure_element_get_placement Ptr StructureElement
popplerStructureElement'
    let result' :: StructurePlacement
result' = (Int -> StructurePlacement
forall a. Enum a => Int -> a
toEnum (Int -> StructurePlacement)
-> (CUInt -> Int) -> CUInt -> StructurePlacement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    StructurePlacement -> IO StructurePlacement
forall (m :: * -> *) a. Monad m => a -> m a
return StructurePlacement
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetPlacementMethodInfo
instance (signature ~ (m Poppler.Enums.StructurePlacement), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetPlacementMethodInfo a signature where
    overloadedMethod = structureElementGetPlacement

instance O.OverloadedMethodInfo StructureElementGetPlacementMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetPlacement",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetPlacement"
        })


#endif

-- method StructureElement::get_ruby_align
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureRubyAlign" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_ruby_align" poppler_structure_element_get_ruby_align :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CUInt

-- | Obtains the alignment for the ruby text contained in a
-- inline-level structure element.
-- 
-- /Since: 0.26/
structureElementGetRubyAlign ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Poppler.Enums.StructureRubyAlign
    -- ^ __Returns:__ A t'GI.Poppler.Enums.StructureRubyAlign' value.
structureElementGetRubyAlign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m StructureRubyAlign
structureElementGetRubyAlign a
popplerStructureElement = IO StructureRubyAlign -> m StructureRubyAlign
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureRubyAlign -> m StructureRubyAlign)
-> IO StructureRubyAlign -> m StructureRubyAlign
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CUInt
result <- Ptr StructureElement -> IO CUInt
poppler_structure_element_get_ruby_align Ptr StructureElement
popplerStructureElement'
    let result' :: StructureRubyAlign
result' = (Int -> StructureRubyAlign
forall a. Enum a => Int -> a
toEnum (Int -> StructureRubyAlign)
-> (CUInt -> Int) -> CUInt -> StructureRubyAlign
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    StructureRubyAlign -> IO StructureRubyAlign
forall (m :: * -> *) a. Monad m => a -> m a
return StructureRubyAlign
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetRubyAlignMethodInfo
instance (signature ~ (m Poppler.Enums.StructureRubyAlign), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetRubyAlignMethodInfo a signature where
    overloadedMethod = structureElementGetRubyAlign

instance O.OverloadedMethodInfo StructureElementGetRubyAlignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetRubyAlign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetRubyAlign"
        })


#endif

-- method StructureElement::get_ruby_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureRubyPosition" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_ruby_position" poppler_structure_element_get_ruby_position :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CUInt

-- | Obtains the position for the ruby text contained in a
-- inline-level structure element.
-- 
-- /Since: 0.26/
structureElementGetRubyPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Poppler.Enums.StructureRubyPosition
    -- ^ __Returns:__ A t'GI.Poppler.Enums.StructureRubyPosition' value.
structureElementGetRubyPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m StructureRubyPosition
structureElementGetRubyPosition a
popplerStructureElement = IO StructureRubyPosition -> m StructureRubyPosition
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureRubyPosition -> m StructureRubyPosition)
-> IO StructureRubyPosition -> m StructureRubyPosition
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CUInt
result <- Ptr StructureElement -> IO CUInt
poppler_structure_element_get_ruby_position Ptr StructureElement
popplerStructureElement'
    let result' :: StructureRubyPosition
result' = (Int -> StructureRubyPosition
forall a. Enum a => Int -> a
toEnum (Int -> StructureRubyPosition)
-> (CUInt -> Int) -> CUInt -> StructureRubyPosition
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    StructureRubyPosition -> IO StructureRubyPosition
forall (m :: * -> *) a. Monad m => a -> m a
return StructureRubyPosition
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetRubyPositionMethodInfo
instance (signature ~ (m Poppler.Enums.StructureRubyPosition), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetRubyPositionMethodInfo a signature where
    overloadedMethod = structureElementGetRubyPosition

instance O.OverloadedMethodInfo StructureElementGetRubyPositionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetRubyPosition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetRubyPosition"
        })


#endif

-- method StructureElement::get_space_after
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_space_after" poppler_structure_element_get_space_after :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CDouble

-- | Obtains the amount of empty space after the block-level structure element.
-- 
-- /Since: 0.26/
structureElementGetSpaceAfter ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Double
    -- ^ __Returns:__ A positive value.
structureElementGetSpaceAfter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Double
structureElementGetSpaceAfter a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CDouble
result <- Ptr StructureElement -> IO CDouble
poppler_structure_element_get_space_after Ptr StructureElement
popplerStructureElement'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetSpaceAfterMethodInfo
instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetSpaceAfterMethodInfo a signature where
    overloadedMethod = structureElementGetSpaceAfter

instance O.OverloadedMethodInfo StructureElementGetSpaceAfterMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetSpaceAfter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetSpaceAfter"
        })


#endif

-- method StructureElement::get_space_before
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_space_before" poppler_structure_element_get_space_before :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CDouble

-- | Obtains the amount of empty space before the block-level structure element.
-- 
-- /Since: 0.26/
structureElementGetSpaceBefore ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Double
    -- ^ __Returns:__ A positive value.
structureElementGetSpaceBefore :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Double
structureElementGetSpaceBefore a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CDouble
result <- Ptr StructureElement -> IO CDouble
poppler_structure_element_get_space_before Ptr StructureElement
popplerStructureElement'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetSpaceBeforeMethodInfo
instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetSpaceBeforeMethodInfo a signature where
    overloadedMethod = structureElementGetSpaceBefore

instance O.OverloadedMethodInfo StructureElementGetSpaceBeforeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetSpaceBefore",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetSpaceBefore"
        })


#endif

-- method StructureElement::get_start_indent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_start_indent" poppler_structure_element_get_start_indent :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CDouble

-- | Obtains the amount of indentation at the beginning of the block-level structure element.
-- 
-- /Since: 0.26/
structureElementGetStartIndent ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Double
    -- ^ __Returns:__ A numeric value.
structureElementGetStartIndent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Double
structureElementGetStartIndent a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CDouble
result <- Ptr StructureElement -> IO CDouble
poppler_structure_element_get_start_indent Ptr StructureElement
popplerStructureElement'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetStartIndentMethodInfo
instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetStartIndentMethodInfo a signature where
    overloadedMethod = structureElementGetStartIndent

instance O.OverloadedMethodInfo StructureElementGetStartIndentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetStartIndent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetStartIndent"
        })


#endif

-- method StructureElement::get_table_border_style
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "border_styles"
--           , argType =
--               TCArray
--                 False
--                 4
--                 (-1)
--                 (TInterface
--                    Name { namespace = "Poppler" , name = "StructureBorderStyle" })
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "\n   An array of four #PopplerStructureBorderStyle elements."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_table_border_style" poppler_structure_element_get_table_border_style :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    Ptr (Ptr CUInt) ->                      -- border_styles : TCArray False 4 (-1) (TInterface (Name {namespace = "Poppler", name = "StructureBorderStyle"}))
    IO ()

-- | Obtains the table cell border style of a block-level structure element. The result values
-- are in before-after-start-end ordering. For example, using Western
-- left-to-right writing, that is top-bottom-left-right.
-- 
-- /Since: 0.26/
structureElementGetTableBorderStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m ([Poppler.Enums.StructureBorderStyle])
structureElementGetTableBorderStyle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m [StructureBorderStyle]
structureElementGetTableBorderStyle a
popplerStructureElement = IO [StructureBorderStyle] -> m [StructureBorderStyle]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [StructureBorderStyle] -> m [StructureBorderStyle])
-> IO [StructureBorderStyle] -> m [StructureBorderStyle]
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Ptr (Ptr CUInt)
borderStyles <- IO (Ptr (Ptr CUInt))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr CUInt))
    Ptr StructureElement -> Ptr (Ptr CUInt) -> IO ()
poppler_structure_element_get_table_border_style Ptr StructureElement
popplerStructureElement' Ptr (Ptr CUInt)
borderStyles
    Ptr CUInt
borderStyles' <- Ptr (Ptr CUInt) -> IO (Ptr CUInt)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr CUInt)
borderStyles
    [CUInt]
borderStyles'' <- (Integer -> Ptr CUInt -> IO [CUInt]
forall a b. (Integral a, Storable b) => a -> Ptr b -> IO [b]
unpackStorableArrayWithLength Integer
4) Ptr CUInt
borderStyles'
    let borderStyles''' :: [StructureBorderStyle]
borderStyles''' = (CUInt -> StructureBorderStyle)
-> [CUInt] -> [StructureBorderStyle]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> StructureBorderStyle
forall a. Enum a => Int -> a
toEnum (Int -> StructureBorderStyle)
-> (CUInt -> Int) -> CUInt -> StructureBorderStyle
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) [CUInt]
borderStyles''
    Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
borderStyles'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Ptr (Ptr CUInt) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CUInt)
borderStyles
    [StructureBorderStyle] -> IO [StructureBorderStyle]
forall (m :: * -> *) a. Monad m => a -> m a
return [StructureBorderStyle]
borderStyles'''

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTableBorderStyleMethodInfo
instance (signature ~ (m ([Poppler.Enums.StructureBorderStyle])), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTableBorderStyleMethodInfo a signature where
    overloadedMethod = structureElementGetTableBorderStyle

instance O.OverloadedMethodInfo StructureElementGetTableBorderStyleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetTableBorderStyle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetTableBorderStyle"
        })


#endif

-- method StructureElement::get_table_column_span
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_table_column_span" poppler_structure_element_get_table_column_span :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO Word32

-- | Obtains the number of columns the table element spans to.
-- 
-- /Since: 0.26/
structureElementGetTableColumnSpan ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Word32
    -- ^ __Returns:__ A positive, non-zero value.
structureElementGetTableColumnSpan :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Word32
structureElementGetTableColumnSpan a
popplerStructureElement = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Word32
result <- Ptr StructureElement -> IO Word32
poppler_structure_element_get_table_column_span Ptr StructureElement
popplerStructureElement'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTableColumnSpanMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTableColumnSpanMethodInfo a signature where
    overloadedMethod = structureElementGetTableColumnSpan

instance O.OverloadedMethodInfo StructureElementGetTableColumnSpanMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetTableColumnSpan",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetTableColumnSpan"
        })


#endif

-- method StructureElement::get_table_headers
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_table_headers" poppler_structure_element_get_table_headers :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO (Ptr CString)

-- | Obtains an array with the names of the table column headers. This is only
-- useful for table header row elements.
-- 
-- The array with the results is allocated by the function. The number
-- of items in the returned array can be obtained with 'GI.GLib.Functions.strvLength'.
-- The returned value must be freed using 'GI.GLib.Functions.strfreev'.
-- 
-- /Since: 0.26/
structureElementGetTableHeaders ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m [T.Text]
    -- ^ __Returns:__ 
    --    Zero-terminated array of strings with the table header names,
    --    or 'P.Nothing' if the attribute is not defined.
structureElementGetTableHeaders :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m [Text]
structureElementGetTableHeaders a
popplerStructureElement = IO [Text] -> m [Text]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Ptr CString
result <- Ptr StructureElement -> IO (Ptr CString)
poppler_structure_element_get_table_headers Ptr StructureElement
popplerStructureElement'
    Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementGetTableHeaders" Ptr CString
result
    [Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
    (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    [Text] -> IO [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTableHeadersMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTableHeadersMethodInfo a signature where
    overloadedMethod = structureElementGetTableHeaders

instance O.OverloadedMethodInfo StructureElementGetTableHeadersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetTableHeaders",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetTableHeaders"
        })


#endif

-- method StructureElement::get_table_padding
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "paddings"
--           , argType = TCArray False 4 (-1) (TBasicType TDouble)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "\n   Padding for the four sides of the element."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_table_padding" poppler_structure_element_get_table_padding :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    Ptr (Ptr CDouble) ->                    -- paddings : TCArray False 4 (-1) (TBasicType TDouble)
    IO ()

-- | Obtains the padding between the table cell’s content rectangle and the
-- surrounding border of a block-level structure element. The result
-- values are in before-after-start-end ordering (for the typical
-- Western left-to-right writing, that is top-bottom-left-right).
-- 
-- /Since: 0.26/
structureElementGetTablePadding ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m ([Double])
structureElementGetTablePadding :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m [Double]
structureElementGetTablePadding a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Ptr (Ptr CDouble)
paddings <- IO (Ptr (Ptr CDouble))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr CDouble))
    Ptr StructureElement -> Ptr (Ptr CDouble) -> IO ()
poppler_structure_element_get_table_padding Ptr StructureElement
popplerStructureElement' Ptr (Ptr CDouble)
paddings
    Ptr CDouble
paddings' <- Ptr (Ptr CDouble) -> IO (Ptr CDouble)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr CDouble)
paddings
    [Double]
paddings'' <- ((CDouble -> Double) -> Integer -> Ptr CDouble -> IO [Double]
forall a b c.
(Integral a, Storable b) =>
(b -> c) -> a -> Ptr b -> IO [c]
unpackMapStorableArrayWithLength CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac Integer
4) Ptr CDouble
paddings'
    Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
paddings'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Ptr (Ptr CDouble) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CDouble)
paddings
    [Double] -> IO [Double]
forall (m :: * -> *) a. Monad m => a -> m a
return [Double]
paddings''

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTablePaddingMethodInfo
instance (signature ~ (m ([Double])), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTablePaddingMethodInfo a signature where
    overloadedMethod = structureElementGetTablePadding

instance O.OverloadedMethodInfo StructureElementGetTablePaddingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetTablePadding",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetTablePadding"
        })


#endif

-- method StructureElement::get_table_row_span
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_table_row_span" poppler_structure_element_get_table_row_span :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO Word32

-- | Obtains the number of rows the table element spans to.
-- 
-- /Since: 0.26/
structureElementGetTableRowSpan ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Word32
    -- ^ __Returns:__ A positive, non-zero value.
structureElementGetTableRowSpan :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Word32
structureElementGetTableRowSpan a
popplerStructureElement = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Word32
result <- Ptr StructureElement -> IO Word32
poppler_structure_element_get_table_row_span Ptr StructureElement
popplerStructureElement'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTableRowSpanMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTableRowSpanMethodInfo a signature where
    overloadedMethod = structureElementGetTableRowSpan

instance O.OverloadedMethodInfo StructureElementGetTableRowSpanMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetTableRowSpan",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetTableRowSpan"
        })


#endif

-- method StructureElement::get_table_scope
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureTableScope" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_table_scope" poppler_structure_element_get_table_scope :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CUInt

-- | Obtains the scope of a table structure element.
-- 
-- /Since: 0.26/
structureElementGetTableScope ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Poppler.Enums.StructureTableScope
    -- ^ __Returns:__ A t'GI.Poppler.Enums.StructureTableScope' value.
structureElementGetTableScope :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m StructureTableScope
structureElementGetTableScope a
popplerStructureElement = IO StructureTableScope -> m StructureTableScope
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureTableScope -> m StructureTableScope)
-> IO StructureTableScope -> m StructureTableScope
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CUInt
result <- Ptr StructureElement -> IO CUInt
poppler_structure_element_get_table_scope Ptr StructureElement
popplerStructureElement'
    let result' :: StructureTableScope
result' = (Int -> StructureTableScope
forall a. Enum a => Int -> a
toEnum (Int -> StructureTableScope)
-> (CUInt -> Int) -> CUInt -> StructureTableScope
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    StructureTableScope -> IO StructureTableScope
forall (m :: * -> *) a. Monad m => a -> m a
return StructureTableScope
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTableScopeMethodInfo
instance (signature ~ (m Poppler.Enums.StructureTableScope), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTableScopeMethodInfo a signature where
    overloadedMethod = structureElementGetTableScope

instance O.OverloadedMethodInfo StructureElementGetTableScopeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetTableScope",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetTableScope"
        })


#endif

-- method StructureElement::get_table_summary
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_table_summary" poppler_structure_element_get_table_summary :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CString

-- | Obtains the textual summary of the contents of the table element. Note that
-- the summary is meant for informative purposes, and it is not intended
-- to be rendered. For example, assistive technologies may use the
-- description field to provide an alternate way of presenting an element
-- to the user, or a document indexer may want to scan it for additional
-- keywords.
-- 
-- The returned string is allocated by the function. When it is
-- not needed anymore, be sure to call 'GI.GLib.Functions.free' on it.
-- 
-- /Since: 0.26/
structureElementGetTableSummary ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m T.Text
    -- ^ __Returns:__ A string, or 'P.Nothing' if the attribute
    --    is not defined.
structureElementGetTableSummary :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Text
structureElementGetTableSummary a
popplerStructureElement = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CString
result <- Ptr StructureElement -> IO CString
poppler_structure_element_get_table_summary Ptr StructureElement
popplerStructureElement'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementGetTableSummary" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTableSummaryMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTableSummaryMethodInfo a signature where
    overloadedMethod = structureElementGetTableSummary

instance O.OverloadedMethodInfo StructureElementGetTableSummaryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetTableSummary",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetTableSummary"
        })


#endif

-- method StructureElement::get_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureGetTextFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A #PopplerStructureGetTextFlags value, or\n   %POPPLER_STRUCTURE_GET_TEXT_NONE to disable all the flags."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_text" poppler_structure_element_get_text :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Poppler", name = "StructureGetTextFlags"})
    IO CString

-- | Obtains the text enclosed by an element, or the text enclosed by the
-- elements in the subtree (including the element itself).
-- 
-- /Since: 0.26/
structureElementGetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> [Poppler.Flags.StructureGetTextFlags]
    -- ^ /@flags@/: A t'GI.Poppler.Flags.StructureGetTextFlags' value, or
    --    'GI.Poppler.Flags.StructureGetTextFlagsNone' to disable all the flags.
    -> m T.Text
    -- ^ __Returns:__ A string.
structureElementGetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> [StructureGetTextFlags] -> m Text
structureElementGetText a
popplerStructureElement [StructureGetTextFlags]
flags = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    let flags' :: CUInt
flags' = [StructureGetTextFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StructureGetTextFlags]
flags
    CString
result <- Ptr StructureElement -> CUInt -> IO CString
poppler_structure_element_get_text Ptr StructureElement
popplerStructureElement' CUInt
flags'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementGetText" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTextMethodInfo
instance (signature ~ ([Poppler.Flags.StructureGetTextFlags] -> m T.Text), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTextMethodInfo a signature where
    overloadedMethod = structureElementGetText

instance O.OverloadedMethodInfo StructureElementGetTextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetText"
        })


#endif

-- method StructureElement::get_text_align
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureTextAlign" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_text_align" poppler_structure_element_get_text_align :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CUInt

-- | Obtains the text alignment mode of the text contained into a
-- block-level structure element.
-- 
-- /Since: 0.26/
structureElementGetTextAlign ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Poppler.Enums.StructureTextAlign
    -- ^ __Returns:__ A t'GI.Poppler.Enums.StructureTextAlign' value.
structureElementGetTextAlign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m StructureTextAlign
structureElementGetTextAlign a
popplerStructureElement = IO StructureTextAlign -> m StructureTextAlign
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureTextAlign -> m StructureTextAlign)
-> IO StructureTextAlign -> m StructureTextAlign
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CUInt
result <- Ptr StructureElement -> IO CUInt
poppler_structure_element_get_text_align Ptr StructureElement
popplerStructureElement'
    let result' :: StructureTextAlign
result' = (Int -> StructureTextAlign
forall a. Enum a => Int -> a
toEnum (Int -> StructureTextAlign)
-> (CUInt -> Int) -> CUInt -> StructureTextAlign
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    StructureTextAlign -> IO StructureTextAlign
forall (m :: * -> *) a. Monad m => a -> m a
return StructureTextAlign
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTextAlignMethodInfo
instance (signature ~ (m Poppler.Enums.StructureTextAlign), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTextAlignMethodInfo a signature where
    overloadedMethod = structureElementGetTextAlign

instance O.OverloadedMethodInfo StructureElementGetTextAlignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetTextAlign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetTextAlign"
        })


#endif

-- method StructureElement::get_text_decoration_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType =
--               TInterface Name { namespace = "Poppler" , name = "Color" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerColor." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_text_decoration_color" poppler_structure_element_get_text_decoration_color :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    Ptr Poppler.Color.Color ->              -- color : TInterface (Name {namespace = "Poppler", name = "Color"})
    IO CInt

-- | Obtains the color of the text decoration for the text contained
-- in the inline-level structure element.
-- If this attribute is not specified, the color for this element shall be the current fill
-- color in effect at the start of its associated content.
-- 
-- /Since: 0.26/
structureElementGetTextDecorationColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m ((Bool, Poppler.Color.Color))
    -- ^ __Returns:__ 'P.True' if a color is defined for the element,
    --    'P.False' otherwise.
structureElementGetTextDecorationColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m (Bool, Color)
structureElementGetTextDecorationColor a
popplerStructureElement = IO (Bool, Color) -> m (Bool, Color)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Color) -> m (Bool, Color))
-> IO (Bool, Color) -> m (Bool, Color)
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Ptr Color
color <- Int -> IO (Ptr Color)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
6 :: IO (Ptr Poppler.Color.Color)
    CInt
result <- Ptr StructureElement -> Ptr Color -> IO CInt
poppler_structure_element_get_text_decoration_color Ptr StructureElement
popplerStructureElement' Ptr Color
color
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Color
color' <- ((ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Color -> Color
Poppler.Color.Color) Ptr Color
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    (Bool, Color) -> IO (Bool, Color)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Color
color')

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTextDecorationColorMethodInfo
instance (signature ~ (m ((Bool, Poppler.Color.Color))), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTextDecorationColorMethodInfo a signature where
    overloadedMethod = structureElementGetTextDecorationColor

instance O.OverloadedMethodInfo StructureElementGetTextDecorationColorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetTextDecorationColor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetTextDecorationColor"
        })


#endif

-- method StructureElement::get_text_decoration_thickness
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_text_decoration_thickness" poppler_structure_element_get_text_decoration_thickness :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CDouble

-- | Obtains the thickness of the text decoration for the text contained
-- in the inline-level structure element.
-- If this attribute is not specified, it shall be derived from the current
-- stroke thickness in effect at the start of the element’s associated content.
-- 
-- /Since: 0.26/
structureElementGetTextDecorationThickness ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Double
    -- ^ __Returns:__ Thickness of the text decoration, or NAN if not defined.
structureElementGetTextDecorationThickness :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Double
structureElementGetTextDecorationThickness a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CDouble
result <- Ptr StructureElement -> IO CDouble
poppler_structure_element_get_text_decoration_thickness Ptr StructureElement
popplerStructureElement'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTextDecorationThicknessMethodInfo
instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTextDecorationThicknessMethodInfo a signature where
    overloadedMethod = structureElementGetTextDecorationThickness

instance O.OverloadedMethodInfo StructureElementGetTextDecorationThicknessMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetTextDecorationThickness",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetTextDecorationThickness"
        })


#endif

-- method StructureElement::get_text_decoration_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureTextDecoration" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_text_decoration_type" poppler_structure_element_get_text_decoration_type :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CUInt

-- | Obtains the text decoration type of the text contained in the
-- inline-level structure element.
-- 
-- /Since: 0.26/
structureElementGetTextDecorationType ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Poppler.Enums.StructureTextDecoration
    -- ^ __Returns:__ A t'GI.Poppler.Enums.StructureTextDecoration' value.
structureElementGetTextDecorationType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m StructureTextDecoration
structureElementGetTextDecorationType a
popplerStructureElement = IO StructureTextDecoration -> m StructureTextDecoration
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureTextDecoration -> m StructureTextDecoration)
-> IO StructureTextDecoration -> m StructureTextDecoration
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CUInt
result <- Ptr StructureElement -> IO CUInt
poppler_structure_element_get_text_decoration_type Ptr StructureElement
popplerStructureElement'
    let result' :: StructureTextDecoration
result' = (Int -> StructureTextDecoration
forall a. Enum a => Int -> a
toEnum (Int -> StructureTextDecoration)
-> (CUInt -> Int) -> CUInt -> StructureTextDecoration
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    StructureTextDecoration -> IO StructureTextDecoration
forall (m :: * -> *) a. Monad m => a -> m a
return StructureTextDecoration
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTextDecorationTypeMethodInfo
instance (signature ~ (m Poppler.Enums.StructureTextDecoration), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTextDecorationTypeMethodInfo a signature where
    overloadedMethod = structureElementGetTextDecorationType

instance O.OverloadedMethodInfo StructureElementGetTextDecorationTypeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetTextDecorationType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetTextDecorationType"
        })


#endif

-- method StructureElement::get_text_indent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_text_indent" poppler_structure_element_get_text_indent :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CDouble

-- | Obtains the amount of indentation of the text contained in the block-level structure element.
-- 
-- /Since: 0.26/
structureElementGetTextIndent ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Double
    -- ^ __Returns:__ A numeric value.
structureElementGetTextIndent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Double
structureElementGetTextIndent a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CDouble
result <- Ptr StructureElement -> IO CDouble
poppler_structure_element_get_text_indent Ptr StructureElement
popplerStructureElement'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTextIndentMethodInfo
instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTextIndentMethodInfo a signature where
    overloadedMethod = structureElementGetTextIndent

instance O.OverloadedMethodInfo StructureElementGetTextIndentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetTextIndent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetTextIndent"
        })


#endif

-- method StructureElement::get_text_spans
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_text_spans"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A pointer to the location where the number of elements in\n   the returned array will be stored."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_text_spans"
--              , argType = TBasicType TUInt
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText =
--                        Just
--                          "A pointer to the location where the number of elements in\n   the returned array will be stored."
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Just
--               (TCArray
--                  False
--                  (-1)
--                  1
--                  (TInterface Name { namespace = "Poppler" , name = "TextSpan" }))
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_text_spans" poppler_structure_element_get_text_spans :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    Ptr Word32 ->                           -- n_text_spans : TBasicType TUInt
    IO (Ptr (Ptr Poppler.TextSpan.TextSpan))

-- | Obtains the text enclosed by an element, as an array of t'GI.Poppler.Structs.TextSpan.TextSpan'
-- structures. Each item in the list is a piece of text which share the same
-- attributes, plus its attributes. The following example shows how to
-- obtain and free the text spans of an element:
-- 
-- \<informalexample>\<programlisting>
-- guint i, n_spans;
-- PopplerTextSpan **text_spans =
--    poppler_structure_element_get_text_spans (element, &n_spans);
-- \/\<!-- -->* Use the text spans *\<!-- -->\/
-- for (i = 0; i \< n_spans; i++)
--    poppler_text_span_free (text_spans[i]);
-- g_free (text_spans);
-- \<\/programlisting>\<\/informalexample>
-- 
-- /Since: 0.26/
structureElementGetTextSpans ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m [Poppler.TextSpan.TextSpan]
    -- ^ __Returns:__ 
    --    An array of t'GI.Poppler.Structs.TextSpan.TextSpan' elements.
structureElementGetTextSpans :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m [TextSpan]
structureElementGetTextSpans a
popplerStructureElement = IO [TextSpan] -> m [TextSpan]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [TextSpan] -> m [TextSpan]) -> IO [TextSpan] -> m [TextSpan]
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    Ptr Word32
nTextSpans <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
    Ptr (Ptr TextSpan)
result <- Ptr StructureElement -> Ptr Word32 -> IO (Ptr (Ptr TextSpan))
poppler_structure_element_get_text_spans Ptr StructureElement
popplerStructureElement' Ptr Word32
nTextSpans
    Word32
nTextSpans' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
nTextSpans
    Text -> Ptr (Ptr TextSpan) -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementGetTextSpans" Ptr (Ptr TextSpan)
result
    [Ptr TextSpan]
result' <- (Word32 -> Ptr (Ptr TextSpan) -> IO [Ptr TextSpan]
forall a b. Integral a => a -> Ptr (Ptr b) -> IO [Ptr b]
unpackPtrArrayWithLength Word32
nTextSpans') Ptr (Ptr TextSpan)
result
    [TextSpan]
result'' <- (Ptr TextSpan -> IO TextSpan) -> [Ptr TextSpan] -> IO [TextSpan]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr TextSpan -> TextSpan) -> Ptr TextSpan -> IO TextSpan
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TextSpan -> TextSpan
Poppler.TextSpan.TextSpan) [Ptr TextSpan]
result'
    Ptr (Ptr TextSpan) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr TextSpan)
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
nTextSpans
    [TextSpan] -> IO [TextSpan]
forall (m :: * -> *) a. Monad m => a -> m a
return [TextSpan]
result''

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTextSpansMethodInfo
instance (signature ~ (m [Poppler.TextSpan.TextSpan]), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTextSpansMethodInfo a signature where
    overloadedMethod = structureElementGetTextSpans

instance O.OverloadedMethodInfo StructureElementGetTextSpansMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetTextSpans",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetTextSpans"
        })


#endif

-- method StructureElement::get_title
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_title" poppler_structure_element_get_title :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CString

-- | Obtains the title of an element.
-- 
-- /Since: 0.26/
structureElementGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m T.Text
    -- ^ __Returns:__ The title of the element, or 'P.Nothing'.
structureElementGetTitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Text
structureElementGetTitle a
popplerStructureElement = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CString
result <- Ptr StructureElement -> IO CString
poppler_structure_element_get_title Ptr StructureElement
popplerStructureElement'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementGetTitle" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetTitleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetTitleMethodInfo a signature where
    overloadedMethod = structureElementGetTitle

instance O.OverloadedMethodInfo StructureElementGetTitleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetTitle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetTitle"
        })


#endif

-- method StructureElement::get_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_width" poppler_structure_element_get_width :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CDouble

-- | Obtains the width of the block-level structure element. Note that for elements which do
-- not specify a width, it has to be calculated, and in this case -1 is returned.
-- 
-- /Since: 0.26/
structureElementGetWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Double
    -- ^ __Returns:__ A positive value if a width is defined, or -1
    --    if the width is to be calculated automatically.
structureElementGetWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Double
structureElementGetWidth a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CDouble
result <- Ptr StructureElement -> IO CDouble
poppler_structure_element_get_width Ptr StructureElement
popplerStructureElement'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetWidthMethodInfo
instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetWidthMethodInfo a signature where
    overloadedMethod = structureElementGetWidth

instance O.OverloadedMethodInfo StructureElementGetWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetWidth"
        })


#endif

-- method StructureElement::get_writing_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureWritingMode" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_get_writing_mode" poppler_structure_element_get_writing_mode :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CUInt

-- | Obtains the writing mode (writing direction) of the content associated
-- with a structure element.
-- 
-- /Since: 0.26/
structureElementGetWritingMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Poppler.Enums.StructureWritingMode
    -- ^ __Returns:__ A t'GI.Poppler.Enums.StructureWritingMode' value.
structureElementGetWritingMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m StructureWritingMode
structureElementGetWritingMode a
popplerStructureElement = IO StructureWritingMode -> m StructureWritingMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureWritingMode -> m StructureWritingMode)
-> IO StructureWritingMode -> m StructureWritingMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CUInt
result <- Ptr StructureElement -> IO CUInt
poppler_structure_element_get_writing_mode Ptr StructureElement
popplerStructureElement'
    let result' :: StructureWritingMode
result' = (Int -> StructureWritingMode
forall a. Enum a => Int -> a
toEnum (Int -> StructureWritingMode)
-> (CUInt -> Int) -> CUInt -> StructureWritingMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    StructureWritingMode -> IO StructureWritingMode
forall (m :: * -> *) a. Monad m => a -> m a
return StructureWritingMode
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementGetWritingModeMethodInfo
instance (signature ~ (m Poppler.Enums.StructureWritingMode), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementGetWritingModeMethodInfo a signature where
    overloadedMethod = structureElementGetWritingMode

instance O.OverloadedMethodInfo StructureElementGetWritingModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementGetWritingMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementGetWritingMode"
        })


#endif

-- method StructureElement::is_block
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_is_block" poppler_structure_element_is_block :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CInt

-- | Checks whether an element is a block element.
-- 
-- /Since: 0.26/
structureElementIsBlock ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if  the element is a block element, or 'P.False' otherwise.
structureElementIsBlock :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Bool
structureElementIsBlock a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CInt
result <- Ptr StructureElement -> IO CInt
poppler_structure_element_is_block Ptr StructureElement
popplerStructureElement'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementIsBlockMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementIsBlockMethodInfo a signature where
    overloadedMethod = structureElementIsBlock

instance O.OverloadedMethodInfo StructureElementIsBlockMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementIsBlock",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementIsBlock"
        })


#endif

-- method StructureElement::is_content
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_is_content" poppler_structure_element_is_content :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CInt

-- | Checks whether an element is actual document content.
-- 
-- /Since: 0.26/
structureElementIsContent ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the element is content, or 'P.False' otherwise.
structureElementIsContent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Bool
structureElementIsContent a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CInt
result <- Ptr StructureElement -> IO CInt
poppler_structure_element_is_content Ptr StructureElement
popplerStructureElement'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementIsContentMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementIsContentMethodInfo a signature where
    overloadedMethod = structureElementIsContent

instance O.OverloadedMethodInfo StructureElementIsContentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementIsContent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementIsContent"
        })


#endif

-- method StructureElement::is_grouping
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_is_grouping" poppler_structure_element_is_grouping :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CInt

-- | Checks whether an element is a grouping element.
-- 
-- /Since: 0.26/
structureElementIsGrouping ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the element is a grouping element, 'P.False'
    --    otherwise.
structureElementIsGrouping :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Bool
structureElementIsGrouping a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CInt
result <- Ptr StructureElement -> IO CInt
poppler_structure_element_is_grouping Ptr StructureElement
popplerStructureElement'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementIsGroupingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementIsGroupingMethodInfo a signature where
    overloadedMethod = structureElementIsGrouping

instance O.OverloadedMethodInfo StructureElementIsGroupingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementIsGrouping",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementIsGrouping"
        })


#endif

-- method StructureElement::is_inline
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "poppler_structure_element"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PopplerStructureElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_is_inline" poppler_structure_element_is_inline :: 
    Ptr StructureElement ->                 -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"})
    IO CInt

-- | Checks whether an element is an inline element.
-- 
-- /Since: 0.26/
structureElementIsInline ::
    (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) =>
    a
    -- ^ /@popplerStructureElement@/: A t'GI.Poppler.Objects.StructureElement.StructureElement'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the element is an inline element, or 'P.False' otherwise.
structureElementIsInline :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStructureElement a) =>
a -> m Bool
structureElementIsInline a
popplerStructureElement = 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
$ do
    Ptr StructureElement
popplerStructureElement' <- a -> IO (Ptr StructureElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerStructureElement
    CInt
result <- Ptr StructureElement -> IO CInt
poppler_structure_element_is_inline Ptr StructureElement
popplerStructureElement'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerStructureElement
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementIsInlineMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStructureElement a) => O.OverloadedMethod StructureElementIsInlineMethodInfo a signature where
    overloadedMethod = structureElementIsInline

instance O.OverloadedMethodInfo StructureElementIsInlineMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.StructureElement.structureElementIsInline",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Objects-StructureElement.html#v:structureElementIsInline"
        })


#endif