{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Compose a [class/@buffer@/] for printing.
-- 
-- The @GtkSourcePrintCompositor@ object is used to compose a [class/@buffer@/]
-- for printing. You can set various configuration options to customize the
-- printed output. @GtkSourcePrintCompositor@ is designed to be used with the
-- high-level printing API of gtk+, i.e. t'GI.Gtk.Objects.PrintOperation.PrintOperation'.
-- 
-- The margins specified in this object are the layout margins: they define the
-- blank space bordering the printed area of the pages. They must not be
-- confused with the \"print margins\", i.e. the parts of the page that the
-- printer cannot print on, defined in the t'GI.Gtk.Objects.PageSetup.PageSetup' objects. If the
-- specified layout margins are smaller than the \"print margins\", the latter
-- ones are used as a fallback by the @GtkSourcePrintCompositor@ object, so that
-- the printed area is not clipped.

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

module GI.GtkSource.Objects.PrintCompositor
    ( 

-- * Exported types
    PrintCompositor(..)                     ,
    IsPrintCompositor                       ,
    toPrintCompositor                       ,


 -- * 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"), [drawPage]("GI.GtkSource.Objects.PrintCompositor#g:method:drawPage"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [ignoreTag]("GI.GtkSource.Objects.PrintCompositor#g:method:ignoreTag"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [paginate]("GI.GtkSource.Objects.PrintCompositor#g:method:paginate"), [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
-- [getBodyFontName]("GI.GtkSource.Objects.PrintCompositor#g:method:getBodyFontName"), [getBottomMargin]("GI.GtkSource.Objects.PrintCompositor#g:method:getBottomMargin"), [getBuffer]("GI.GtkSource.Objects.PrintCompositor#g:method:getBuffer"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getFooterFontName]("GI.GtkSource.Objects.PrintCompositor#g:method:getFooterFontName"), [getHeaderFontName]("GI.GtkSource.Objects.PrintCompositor#g:method:getHeaderFontName"), [getHighlightSyntax]("GI.GtkSource.Objects.PrintCompositor#g:method:getHighlightSyntax"), [getLeftMargin]("GI.GtkSource.Objects.PrintCompositor#g:method:getLeftMargin"), [getLineNumbersFontName]("GI.GtkSource.Objects.PrintCompositor#g:method:getLineNumbersFontName"), [getNPages]("GI.GtkSource.Objects.PrintCompositor#g:method:getNPages"), [getPaginationProgress]("GI.GtkSource.Objects.PrintCompositor#g:method:getPaginationProgress"), [getPrintFooter]("GI.GtkSource.Objects.PrintCompositor#g:method:getPrintFooter"), [getPrintHeader]("GI.GtkSource.Objects.PrintCompositor#g:method:getPrintHeader"), [getPrintLineNumbers]("GI.GtkSource.Objects.PrintCompositor#g:method:getPrintLineNumbers"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRightMargin]("GI.GtkSource.Objects.PrintCompositor#g:method:getRightMargin"), [getTabWidth]("GI.GtkSource.Objects.PrintCompositor#g:method:getTabWidth"), [getTopMargin]("GI.GtkSource.Objects.PrintCompositor#g:method:getTopMargin"), [getWrapMode]("GI.GtkSource.Objects.PrintCompositor#g:method:getWrapMode").
-- 
-- ==== Setters
-- [setBodyFontName]("GI.GtkSource.Objects.PrintCompositor#g:method:setBodyFontName"), [setBottomMargin]("GI.GtkSource.Objects.PrintCompositor#g:method:setBottomMargin"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setFooterFontName]("GI.GtkSource.Objects.PrintCompositor#g:method:setFooterFontName"), [setFooterFormat]("GI.GtkSource.Objects.PrintCompositor#g:method:setFooterFormat"), [setHeaderFontName]("GI.GtkSource.Objects.PrintCompositor#g:method:setHeaderFontName"), [setHeaderFormat]("GI.GtkSource.Objects.PrintCompositor#g:method:setHeaderFormat"), [setHighlightSyntax]("GI.GtkSource.Objects.PrintCompositor#g:method:setHighlightSyntax"), [setLeftMargin]("GI.GtkSource.Objects.PrintCompositor#g:method:setLeftMargin"), [setLineNumbersFontName]("GI.GtkSource.Objects.PrintCompositor#g:method:setLineNumbersFontName"), [setPrintFooter]("GI.GtkSource.Objects.PrintCompositor#g:method:setPrintFooter"), [setPrintHeader]("GI.GtkSource.Objects.PrintCompositor#g:method:setPrintHeader"), [setPrintLineNumbers]("GI.GtkSource.Objects.PrintCompositor#g:method:setPrintLineNumbers"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRightMargin]("GI.GtkSource.Objects.PrintCompositor#g:method:setRightMargin"), [setTabWidth]("GI.GtkSource.Objects.PrintCompositor#g:method:setTabWidth"), [setTopMargin]("GI.GtkSource.Objects.PrintCompositor#g:method:setTopMargin"), [setWrapMode]("GI.GtkSource.Objects.PrintCompositor#g:method:setWrapMode").

#if defined(ENABLE_OVERLOADING)
    ResolvePrintCompositorMethod            ,
#endif

-- ** drawPage #method:drawPage#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorDrawPageMethodInfo       ,
#endif
    printCompositorDrawPage                 ,


-- ** getBodyFontName #method:getBodyFontName#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetBodyFontNameMethodInfo,
#endif
    printCompositorGetBodyFontName          ,


-- ** getBottomMargin #method:getBottomMargin#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetBottomMarginMethodInfo,
#endif
    printCompositorGetBottomMargin          ,


-- ** getBuffer #method:getBuffer#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetBufferMethodInfo      ,
#endif
    printCompositorGetBuffer                ,


-- ** getFooterFontName #method:getFooterFontName#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetFooterFontNameMethodInfo,
#endif
    printCompositorGetFooterFontName        ,


-- ** getHeaderFontName #method:getHeaderFontName#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetHeaderFontNameMethodInfo,
#endif
    printCompositorGetHeaderFontName        ,


-- ** getHighlightSyntax #method:getHighlightSyntax#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetHighlightSyntaxMethodInfo,
#endif
    printCompositorGetHighlightSyntax       ,


-- ** getLeftMargin #method:getLeftMargin#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetLeftMarginMethodInfo  ,
#endif
    printCompositorGetLeftMargin            ,


-- ** getLineNumbersFontName #method:getLineNumbersFontName#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetLineNumbersFontNameMethodInfo,
#endif
    printCompositorGetLineNumbersFontName   ,


-- ** getNPages #method:getNPages#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetNPagesMethodInfo      ,
#endif
    printCompositorGetNPages                ,


-- ** getPaginationProgress #method:getPaginationProgress#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetPaginationProgressMethodInfo,
#endif
    printCompositorGetPaginationProgress    ,


-- ** getPrintFooter #method:getPrintFooter#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetPrintFooterMethodInfo ,
#endif
    printCompositorGetPrintFooter           ,


-- ** getPrintHeader #method:getPrintHeader#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetPrintHeaderMethodInfo ,
#endif
    printCompositorGetPrintHeader           ,


-- ** getPrintLineNumbers #method:getPrintLineNumbers#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetPrintLineNumbersMethodInfo,
#endif
    printCompositorGetPrintLineNumbers      ,


-- ** getRightMargin #method:getRightMargin#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetRightMarginMethodInfo ,
#endif
    printCompositorGetRightMargin           ,


-- ** getTabWidth #method:getTabWidth#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetTabWidthMethodInfo    ,
#endif
    printCompositorGetTabWidth              ,


-- ** getTopMargin #method:getTopMargin#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetTopMarginMethodInfo   ,
#endif
    printCompositorGetTopMargin             ,


-- ** getWrapMode #method:getWrapMode#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorGetWrapModeMethodInfo    ,
#endif
    printCompositorGetWrapMode              ,


-- ** ignoreTag #method:ignoreTag#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorIgnoreTagMethodInfo      ,
#endif
    printCompositorIgnoreTag                ,


-- ** new #method:new#

    printCompositorNew                      ,


-- ** newFromView #method:newFromView#

    printCompositorNewFromView              ,


-- ** paginate #method:paginate#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorPaginateMethodInfo       ,
#endif
    printCompositorPaginate                 ,


-- ** setBodyFontName #method:setBodyFontName#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetBodyFontNameMethodInfo,
#endif
    printCompositorSetBodyFontName          ,


-- ** setBottomMargin #method:setBottomMargin#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetBottomMarginMethodInfo,
#endif
    printCompositorSetBottomMargin          ,


-- ** setFooterFontName #method:setFooterFontName#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetFooterFontNameMethodInfo,
#endif
    printCompositorSetFooterFontName        ,


-- ** setFooterFormat #method:setFooterFormat#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetFooterFormatMethodInfo,
#endif
    printCompositorSetFooterFormat          ,


-- ** setHeaderFontName #method:setHeaderFontName#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetHeaderFontNameMethodInfo,
#endif
    printCompositorSetHeaderFontName        ,


-- ** setHeaderFormat #method:setHeaderFormat#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetHeaderFormatMethodInfo,
#endif
    printCompositorSetHeaderFormat          ,


-- ** setHighlightSyntax #method:setHighlightSyntax#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetHighlightSyntaxMethodInfo,
#endif
    printCompositorSetHighlightSyntax       ,


-- ** setLeftMargin #method:setLeftMargin#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetLeftMarginMethodInfo  ,
#endif
    printCompositorSetLeftMargin            ,


-- ** setLineNumbersFontName #method:setLineNumbersFontName#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetLineNumbersFontNameMethodInfo,
#endif
    printCompositorSetLineNumbersFontName   ,


-- ** setPrintFooter #method:setPrintFooter#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetPrintFooterMethodInfo ,
#endif
    printCompositorSetPrintFooter           ,


-- ** setPrintHeader #method:setPrintHeader#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetPrintHeaderMethodInfo ,
#endif
    printCompositorSetPrintHeader           ,


-- ** setPrintLineNumbers #method:setPrintLineNumbers#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetPrintLineNumbersMethodInfo,
#endif
    printCompositorSetPrintLineNumbers      ,


-- ** setRightMargin #method:setRightMargin#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetRightMarginMethodInfo ,
#endif
    printCompositorSetRightMargin           ,


-- ** setTabWidth #method:setTabWidth#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetTabWidthMethodInfo    ,
#endif
    printCompositorSetTabWidth              ,


-- ** setTopMargin #method:setTopMargin#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetTopMarginMethodInfo   ,
#endif
    printCompositorSetTopMargin             ,


-- ** setWrapMode #method:setWrapMode#

#if defined(ENABLE_OVERLOADING)
    PrintCompositorSetWrapModeMethodInfo    ,
#endif
    printCompositorSetWrapMode              ,




 -- * Properties


-- ** bodyFontName #attr:bodyFontName#
-- | Name of the font used for the text body.
-- 
-- Accepted values are strings representing a font description Pango can understand.
-- (e.g. "Monospace 10"). See [func/@pango@/.FontDescription.from_string]
-- for a description of the format of the string representation.
-- 
-- The value of this property cannot be changed anymore after the first
-- call to the [method/@printCompositor@/.paginate] function.

#if defined(ENABLE_OVERLOADING)
    PrintCompositorBodyFontNamePropertyInfo ,
#endif
    constructPrintCompositorBodyFontName    ,
    getPrintCompositorBodyFontName          ,
#if defined(ENABLE_OVERLOADING)
    printCompositorBodyFontName             ,
#endif
    setPrintCompositorBodyFontName          ,


-- ** buffer #attr:buffer#
-- | The [class/@buffer@/] object to print.

#if defined(ENABLE_OVERLOADING)
    PrintCompositorBufferPropertyInfo       ,
#endif
    constructPrintCompositorBuffer          ,
    getPrintCompositorBuffer                ,
#if defined(ENABLE_OVERLOADING)
    printCompositorBuffer                   ,
#endif


-- ** footerFontName #attr:footerFontName#
-- | Name of the font used to print page footer.
-- If this property is unspecified, the text body font is used.
-- 
-- Accepted values are strings representing a font description Pango can understand.
-- (e.g. "Monospace 10"). See [func/@pango@/.FontDescription.from_string]
-- for a description of the format of the string representation.
-- 
-- The value of this property cannot be changed anymore after the first
-- call to the [method/@printCompositor@/.paginate] function.

#if defined(ENABLE_OVERLOADING)
    PrintCompositorFooterFontNamePropertyInfo,
#endif
    clearPrintCompositorFooterFontName      ,
    constructPrintCompositorFooterFontName  ,
    getPrintCompositorFooterFontName        ,
#if defined(ENABLE_OVERLOADING)
    printCompositorFooterFontName           ,
#endif
    setPrintCompositorFooterFontName        ,


-- ** headerFontName #attr:headerFontName#
-- | Name of the font used to print page header.
-- If this property is unspecified, the text body font is used.
-- 
-- Accepted values are strings representing a font description Pango can understand.
-- (e.g. "Monospace 10"). See [func/@pango@/.FontDescription.from_string]
-- for a description of the format of the string representation.
-- 
-- The value of this property cannot be changed anymore after the first
-- call to the [method/@printCompositor@/.paginate] function.

#if defined(ENABLE_OVERLOADING)
    PrintCompositorHeaderFontNamePropertyInfo,
#endif
    clearPrintCompositorHeaderFontName      ,
    constructPrintCompositorHeaderFontName  ,
    getPrintCompositorHeaderFontName        ,
#if defined(ENABLE_OVERLOADING)
    printCompositorHeaderFontName           ,
#endif
    setPrintCompositorHeaderFontName        ,


-- ** highlightSyntax #attr:highlightSyntax#
-- | Whether to print the document with highlighted syntax.
-- 
-- The value of this property cannot be changed anymore after the first
-- call to the [method/@printCompositor@/.paginate] function.

#if defined(ENABLE_OVERLOADING)
    PrintCompositorHighlightSyntaxPropertyInfo,
#endif
    constructPrintCompositorHighlightSyntax ,
    getPrintCompositorHighlightSyntax       ,
#if defined(ENABLE_OVERLOADING)
    printCompositorHighlightSyntax          ,
#endif
    setPrintCompositorHighlightSyntax       ,


-- ** lineNumbersFontName #attr:lineNumbersFontName#
-- | Name of the font used to print line numbers on the left margin.
-- If this property is unspecified, the text body font is used.
-- 
-- Accepted values are strings representing a font description Pango can understand.
-- (e.g. "Monospace 10"). See [func/@pango@/.FontDescription.from_string]
-- for a description of the format of the string representation.
-- 
-- The value of this property cannot be changed anymore after the first
-- call to the [method/@printCompositor@/.paginate] function.

#if defined(ENABLE_OVERLOADING)
    PrintCompositorLineNumbersFontNamePropertyInfo,
#endif
    clearPrintCompositorLineNumbersFontName ,
    constructPrintCompositorLineNumbersFontName,
    getPrintCompositorLineNumbersFontName   ,
#if defined(ENABLE_OVERLOADING)
    printCompositorLineNumbersFontName      ,
#endif
    setPrintCompositorLineNumbersFontName   ,


-- ** nPages #attr:nPages#
-- | The number of pages in the document or \<code>-1\<\/code> if the
-- document has not been completely paginated.

#if defined(ENABLE_OVERLOADING)
    PrintCompositorNPagesPropertyInfo       ,
#endif
    getPrintCompositorNPages                ,
#if defined(ENABLE_OVERLOADING)
    printCompositorNPages                   ,
#endif


-- ** printFooter #attr:printFooter#
-- | Whether to print a footer in each page.
-- 
-- Note that by default the footer format is unspecified, and if it is
-- unspecified the footer will not be printed, regardless of the value of
-- this property.
-- 
-- The value of this property cannot be changed anymore after the first
-- call to the [method/@printCompositor@/.paginate] function.

#if defined(ENABLE_OVERLOADING)
    PrintCompositorPrintFooterPropertyInfo  ,
#endif
    constructPrintCompositorPrintFooter     ,
    getPrintCompositorPrintFooter           ,
#if defined(ENABLE_OVERLOADING)
    printCompositorPrintFooter              ,
#endif
    setPrintCompositorPrintFooter           ,


-- ** printHeader #attr:printHeader#
-- | Whether to print a header in each page.
-- 
-- Note that by default the header format is unspecified, and if it is
-- unspecified the header will not be printed, regardless of the value of
-- this property.
-- 
-- The value of this property cannot be changed anymore after the first
-- call to the [method/@printCompositor@/.paginate] function.

#if defined(ENABLE_OVERLOADING)
    PrintCompositorPrintHeaderPropertyInfo  ,
#endif
    constructPrintCompositorPrintHeader     ,
    getPrintCompositorPrintHeader           ,
#if defined(ENABLE_OVERLOADING)
    printCompositorPrintHeader              ,
#endif
    setPrintCompositorPrintHeader           ,


-- ** printLineNumbers #attr:printLineNumbers#
-- | Interval of printed line numbers.
-- 
-- If this property is set to 0 no numbers will be printed.
-- If greater than 0, a number will be printed every \"print-line-numbers\"
-- lines (i.e. 1 will print all line numbers).
-- 
-- The value of this property cannot be changed anymore after the first
-- call to the [method/@printCompositor@/.paginate] function.

#if defined(ENABLE_OVERLOADING)
    PrintCompositorPrintLineNumbersPropertyInfo,
#endif
    constructPrintCompositorPrintLineNumbers,
    getPrintCompositorPrintLineNumbers      ,
#if defined(ENABLE_OVERLOADING)
    printCompositorPrintLineNumbers         ,
#endif
    setPrintCompositorPrintLineNumbers      ,


-- ** tabWidth #attr:tabWidth#
-- | Width of a tab character expressed in spaces.
-- 
-- The value of this property cannot be changed anymore after the first
-- call to the [method/@printCompositor@/.paginate] function.

#if defined(ENABLE_OVERLOADING)
    PrintCompositorTabWidthPropertyInfo     ,
#endif
    constructPrintCompositorTabWidth        ,
    getPrintCompositorTabWidth              ,
#if defined(ENABLE_OVERLOADING)
    printCompositorTabWidth                 ,
#endif
    setPrintCompositorTabWidth              ,


-- ** wrapMode #attr:wrapMode#
-- | Whether to wrap lines never, at word boundaries, or at character boundaries.
-- 
-- The value of this property cannot be changed anymore after the first
-- call to the [method/@printCompositor@/.paginate] function.

#if defined(ENABLE_OVERLOADING)
    PrintCompositorWrapModePropertyInfo     ,
#endif
    constructPrintCompositorWrapMode        ,
    getPrintCompositorWrapMode              ,
#if defined(ENABLE_OVERLOADING)
    printCompositorWrapMode                 ,
#endif
    setPrintCompositorWrapMode              ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Enums as Gtk.Enums
import qualified GI.Gtk.Objects.PrintContext as Gtk.PrintContext
import qualified GI.Gtk.Objects.TextTag as Gtk.TextTag
import {-# SOURCE #-} qualified GI.GtkSource.Objects.Buffer as GtkSource.Buffer
import {-# SOURCE #-} qualified GI.GtkSource.Objects.View as GtkSource.View

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

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

foreign import ccall "gtk_source_print_compositor_get_type"
    c_gtk_source_print_compositor_get_type :: IO B.Types.GType

instance B.Types.TypedObject PrintCompositor where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_print_compositor_get_type

instance B.Types.GObject PrintCompositor

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

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

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolvePrintCompositorMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolvePrintCompositorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolvePrintCompositorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolvePrintCompositorMethod "drawPage" o = PrintCompositorDrawPageMethodInfo
    ResolvePrintCompositorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolvePrintCompositorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolvePrintCompositorMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolvePrintCompositorMethod "ignoreTag" o = PrintCompositorIgnoreTagMethodInfo
    ResolvePrintCompositorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolvePrintCompositorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolvePrintCompositorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolvePrintCompositorMethod "paginate" o = PrintCompositorPaginateMethodInfo
    ResolvePrintCompositorMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolvePrintCompositorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolvePrintCompositorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolvePrintCompositorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolvePrintCompositorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolvePrintCompositorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolvePrintCompositorMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolvePrintCompositorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolvePrintCompositorMethod "getBodyFontName" o = PrintCompositorGetBodyFontNameMethodInfo
    ResolvePrintCompositorMethod "getBottomMargin" o = PrintCompositorGetBottomMarginMethodInfo
    ResolvePrintCompositorMethod "getBuffer" o = PrintCompositorGetBufferMethodInfo
    ResolvePrintCompositorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolvePrintCompositorMethod "getFooterFontName" o = PrintCompositorGetFooterFontNameMethodInfo
    ResolvePrintCompositorMethod "getHeaderFontName" o = PrintCompositorGetHeaderFontNameMethodInfo
    ResolvePrintCompositorMethod "getHighlightSyntax" o = PrintCompositorGetHighlightSyntaxMethodInfo
    ResolvePrintCompositorMethod "getLeftMargin" o = PrintCompositorGetLeftMarginMethodInfo
    ResolvePrintCompositorMethod "getLineNumbersFontName" o = PrintCompositorGetLineNumbersFontNameMethodInfo
    ResolvePrintCompositorMethod "getNPages" o = PrintCompositorGetNPagesMethodInfo
    ResolvePrintCompositorMethod "getPaginationProgress" o = PrintCompositorGetPaginationProgressMethodInfo
    ResolvePrintCompositorMethod "getPrintFooter" o = PrintCompositorGetPrintFooterMethodInfo
    ResolvePrintCompositorMethod "getPrintHeader" o = PrintCompositorGetPrintHeaderMethodInfo
    ResolvePrintCompositorMethod "getPrintLineNumbers" o = PrintCompositorGetPrintLineNumbersMethodInfo
    ResolvePrintCompositorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolvePrintCompositorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolvePrintCompositorMethod "getRightMargin" o = PrintCompositorGetRightMarginMethodInfo
    ResolvePrintCompositorMethod "getTabWidth" o = PrintCompositorGetTabWidthMethodInfo
    ResolvePrintCompositorMethod "getTopMargin" o = PrintCompositorGetTopMarginMethodInfo
    ResolvePrintCompositorMethod "getWrapMode" o = PrintCompositorGetWrapModeMethodInfo
    ResolvePrintCompositorMethod "setBodyFontName" o = PrintCompositorSetBodyFontNameMethodInfo
    ResolvePrintCompositorMethod "setBottomMargin" o = PrintCompositorSetBottomMarginMethodInfo
    ResolvePrintCompositorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolvePrintCompositorMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolvePrintCompositorMethod "setFooterFontName" o = PrintCompositorSetFooterFontNameMethodInfo
    ResolvePrintCompositorMethod "setFooterFormat" o = PrintCompositorSetFooterFormatMethodInfo
    ResolvePrintCompositorMethod "setHeaderFontName" o = PrintCompositorSetHeaderFontNameMethodInfo
    ResolvePrintCompositorMethod "setHeaderFormat" o = PrintCompositorSetHeaderFormatMethodInfo
    ResolvePrintCompositorMethod "setHighlightSyntax" o = PrintCompositorSetHighlightSyntaxMethodInfo
    ResolvePrintCompositorMethod "setLeftMargin" o = PrintCompositorSetLeftMarginMethodInfo
    ResolvePrintCompositorMethod "setLineNumbersFontName" o = PrintCompositorSetLineNumbersFontNameMethodInfo
    ResolvePrintCompositorMethod "setPrintFooter" o = PrintCompositorSetPrintFooterMethodInfo
    ResolvePrintCompositorMethod "setPrintHeader" o = PrintCompositorSetPrintHeaderMethodInfo
    ResolvePrintCompositorMethod "setPrintLineNumbers" o = PrintCompositorSetPrintLineNumbersMethodInfo
    ResolvePrintCompositorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolvePrintCompositorMethod "setRightMargin" o = PrintCompositorSetRightMarginMethodInfo
    ResolvePrintCompositorMethod "setTabWidth" o = PrintCompositorSetTabWidthMethodInfo
    ResolvePrintCompositorMethod "setTopMargin" o = PrintCompositorSetTopMarginMethodInfo
    ResolvePrintCompositorMethod "setWrapMode" o = PrintCompositorSetWrapModeMethodInfo
    ResolvePrintCompositorMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- VVV Prop "body-font-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

-- | Get the value of the “@body-font-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' printCompositor #bodyFontName
-- @
getPrintCompositorBodyFontName :: (MonadIO m, IsPrintCompositor o) => o -> m (Maybe T.Text)
getPrintCompositorBodyFontName :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m (Maybe Text)
getPrintCompositorBodyFontName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"body-font-name"

-- | Set the value of the “@body-font-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' printCompositor [ #bodyFontName 'Data.GI.Base.Attributes.:=' value ]
-- @
setPrintCompositorBodyFontName :: (MonadIO m, IsPrintCompositor o) => o -> T.Text -> m ()
setPrintCompositorBodyFontName :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> Text -> m ()
setPrintCompositorBodyFontName o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"body-font-name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@body-font-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPrintCompositorBodyFontName :: (IsPrintCompositor o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructPrintCompositorBodyFontName :: forall o (m :: * -> *).
(IsPrintCompositor o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructPrintCompositorBodyFontName Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"body-font-name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data PrintCompositorBodyFontNamePropertyInfo
instance AttrInfo PrintCompositorBodyFontNamePropertyInfo where
    type AttrAllowedOps PrintCompositorBodyFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PrintCompositorBodyFontNamePropertyInfo = IsPrintCompositor
    type AttrSetTypeConstraint PrintCompositorBodyFontNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint PrintCompositorBodyFontNamePropertyInfo = (~) T.Text
    type AttrTransferType PrintCompositorBodyFontNamePropertyInfo = T.Text
    type AttrGetType PrintCompositorBodyFontNamePropertyInfo = (Maybe T.Text)
    type AttrLabel PrintCompositorBodyFontNamePropertyInfo = "body-font-name"
    type AttrOrigin PrintCompositorBodyFontNamePropertyInfo = PrintCompositor
    attrGet = getPrintCompositorBodyFontName
    attrSet = setPrintCompositorBodyFontName
    attrTransfer _ v = do
        return v
    attrConstruct = constructPrintCompositorBodyFontName
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.bodyFontName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#g:attr:bodyFontName"
        })
#endif

-- VVV Prop "buffer"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "Buffer"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@buffer@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' printCompositor #buffer
-- @
getPrintCompositorBuffer :: (MonadIO m, IsPrintCompositor o) => o -> m GtkSource.Buffer.Buffer
getPrintCompositorBuffer :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m Buffer
getPrintCompositorBuffer o
obj = IO Buffer -> m Buffer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Buffer) -> IO Buffer
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getPrintCompositorBuffer" (IO (Maybe Buffer) -> IO Buffer) -> IO (Maybe Buffer) -> IO Buffer
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Buffer -> Buffer) -> IO (Maybe Buffer)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"buffer" ManagedPtr Buffer -> Buffer
GtkSource.Buffer.Buffer

-- | Construct a `GValueConstruct` with valid value for the “@buffer@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPrintCompositorBuffer :: (IsPrintCompositor o, MIO.MonadIO m, GtkSource.Buffer.IsBuffer a) => a -> m (GValueConstruct o)
constructPrintCompositorBuffer :: forall o (m :: * -> *) a.
(IsPrintCompositor o, MonadIO m, IsBuffer a) =>
a -> m (GValueConstruct o)
constructPrintCompositorBuffer a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"buffer" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data PrintCompositorBufferPropertyInfo
instance AttrInfo PrintCompositorBufferPropertyInfo where
    type AttrAllowedOps PrintCompositorBufferPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint PrintCompositorBufferPropertyInfo = IsPrintCompositor
    type AttrSetTypeConstraint PrintCompositorBufferPropertyInfo = GtkSource.Buffer.IsBuffer
    type AttrTransferTypeConstraint PrintCompositorBufferPropertyInfo = GtkSource.Buffer.IsBuffer
    type AttrTransferType PrintCompositorBufferPropertyInfo = GtkSource.Buffer.Buffer
    type AttrGetType PrintCompositorBufferPropertyInfo = GtkSource.Buffer.Buffer
    type AttrLabel PrintCompositorBufferPropertyInfo = "buffer"
    type AttrOrigin PrintCompositorBufferPropertyInfo = PrintCompositor
    attrGet = getPrintCompositorBuffer
    attrSet = undefined
    attrTransfer _ v = do
        unsafeCastTo GtkSource.Buffer.Buffer v
    attrConstruct = constructPrintCompositorBuffer
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.buffer"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#g:attr:buffer"
        })
#endif

-- VVV Prop "footer-font-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just True)

-- | Get the value of the “@footer-font-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' printCompositor #footerFontName
-- @
getPrintCompositorFooterFontName :: (MonadIO m, IsPrintCompositor o) => o -> m (Maybe T.Text)
getPrintCompositorFooterFontName :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m (Maybe Text)
getPrintCompositorFooterFontName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"footer-font-name"

-- | Set the value of the “@footer-font-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' printCompositor [ #footerFontName 'Data.GI.Base.Attributes.:=' value ]
-- @
setPrintCompositorFooterFontName :: (MonadIO m, IsPrintCompositor o) => o -> T.Text -> m ()
setPrintCompositorFooterFontName :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> Text -> m ()
setPrintCompositorFooterFontName o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"footer-font-name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@footer-font-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPrintCompositorFooterFontName :: (IsPrintCompositor o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructPrintCompositorFooterFontName :: forall o (m :: * -> *).
(IsPrintCompositor o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructPrintCompositorFooterFontName Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"footer-font-name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@footer-font-name@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #footerFontName
-- @
clearPrintCompositorFooterFontName :: (MonadIO m, IsPrintCompositor o) => o -> m ()
clearPrintCompositorFooterFontName :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m ()
clearPrintCompositorFooterFontName o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"footer-font-name" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data PrintCompositorFooterFontNamePropertyInfo
instance AttrInfo PrintCompositorFooterFontNamePropertyInfo where
    type AttrAllowedOps PrintCompositorFooterFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint PrintCompositorFooterFontNamePropertyInfo = IsPrintCompositor
    type AttrSetTypeConstraint PrintCompositorFooterFontNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint PrintCompositorFooterFontNamePropertyInfo = (~) T.Text
    type AttrTransferType PrintCompositorFooterFontNamePropertyInfo = T.Text
    type AttrGetType PrintCompositorFooterFontNamePropertyInfo = (Maybe T.Text)
    type AttrLabel PrintCompositorFooterFontNamePropertyInfo = "footer-font-name"
    type AttrOrigin PrintCompositorFooterFontNamePropertyInfo = PrintCompositor
    attrGet = getPrintCompositorFooterFontName
    attrSet = setPrintCompositorFooterFontName
    attrTransfer _ v = do
        return v
    attrConstruct = constructPrintCompositorFooterFontName
    attrClear = clearPrintCompositorFooterFontName
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.footerFontName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#g:attr:footerFontName"
        })
#endif

-- VVV Prop "header-font-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just True)

-- | Get the value of the “@header-font-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' printCompositor #headerFontName
-- @
getPrintCompositorHeaderFontName :: (MonadIO m, IsPrintCompositor o) => o -> m (Maybe T.Text)
getPrintCompositorHeaderFontName :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m (Maybe Text)
getPrintCompositorHeaderFontName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"header-font-name"

-- | Set the value of the “@header-font-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' printCompositor [ #headerFontName 'Data.GI.Base.Attributes.:=' value ]
-- @
setPrintCompositorHeaderFontName :: (MonadIO m, IsPrintCompositor o) => o -> T.Text -> m ()
setPrintCompositorHeaderFontName :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> Text -> m ()
setPrintCompositorHeaderFontName o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"header-font-name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@header-font-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPrintCompositorHeaderFontName :: (IsPrintCompositor o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructPrintCompositorHeaderFontName :: forall o (m :: * -> *).
(IsPrintCompositor o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructPrintCompositorHeaderFontName Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"header-font-name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@header-font-name@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #headerFontName
-- @
clearPrintCompositorHeaderFontName :: (MonadIO m, IsPrintCompositor o) => o -> m ()
clearPrintCompositorHeaderFontName :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m ()
clearPrintCompositorHeaderFontName o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"header-font-name" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data PrintCompositorHeaderFontNamePropertyInfo
instance AttrInfo PrintCompositorHeaderFontNamePropertyInfo where
    type AttrAllowedOps PrintCompositorHeaderFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint PrintCompositorHeaderFontNamePropertyInfo = IsPrintCompositor
    type AttrSetTypeConstraint PrintCompositorHeaderFontNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint PrintCompositorHeaderFontNamePropertyInfo = (~) T.Text
    type AttrTransferType PrintCompositorHeaderFontNamePropertyInfo = T.Text
    type AttrGetType PrintCompositorHeaderFontNamePropertyInfo = (Maybe T.Text)
    type AttrLabel PrintCompositorHeaderFontNamePropertyInfo = "header-font-name"
    type AttrOrigin PrintCompositorHeaderFontNamePropertyInfo = PrintCompositor
    attrGet = getPrintCompositorHeaderFontName
    attrSet = setPrintCompositorHeaderFontName
    attrTransfer _ v = do
        return v
    attrConstruct = constructPrintCompositorHeaderFontName
    attrClear = clearPrintCompositorHeaderFontName
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.headerFontName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#g:attr:headerFontName"
        })
#endif

-- VVV Prop "highlight-syntax"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@highlight-syntax@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' printCompositor #highlightSyntax
-- @
getPrintCompositorHighlightSyntax :: (MonadIO m, IsPrintCompositor o) => o -> m Bool
getPrintCompositorHighlightSyntax :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m Bool
getPrintCompositorHighlightSyntax o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"highlight-syntax"

-- | Set the value of the “@highlight-syntax@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' printCompositor [ #highlightSyntax 'Data.GI.Base.Attributes.:=' value ]
-- @
setPrintCompositorHighlightSyntax :: (MonadIO m, IsPrintCompositor o) => o -> Bool -> m ()
setPrintCompositorHighlightSyntax :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> Bool -> m ()
setPrintCompositorHighlightSyntax o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"highlight-syntax" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@highlight-syntax@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPrintCompositorHighlightSyntax :: (IsPrintCompositor o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructPrintCompositorHighlightSyntax :: forall o (m :: * -> *).
(IsPrintCompositor o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructPrintCompositorHighlightSyntax Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"highlight-syntax" Bool
val

#if defined(ENABLE_OVERLOADING)
data PrintCompositorHighlightSyntaxPropertyInfo
instance AttrInfo PrintCompositorHighlightSyntaxPropertyInfo where
    type AttrAllowedOps PrintCompositorHighlightSyntaxPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PrintCompositorHighlightSyntaxPropertyInfo = IsPrintCompositor
    type AttrSetTypeConstraint PrintCompositorHighlightSyntaxPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint PrintCompositorHighlightSyntaxPropertyInfo = (~) Bool
    type AttrTransferType PrintCompositorHighlightSyntaxPropertyInfo = Bool
    type AttrGetType PrintCompositorHighlightSyntaxPropertyInfo = Bool
    type AttrLabel PrintCompositorHighlightSyntaxPropertyInfo = "highlight-syntax"
    type AttrOrigin PrintCompositorHighlightSyntaxPropertyInfo = PrintCompositor
    attrGet = getPrintCompositorHighlightSyntax
    attrSet = setPrintCompositorHighlightSyntax
    attrTransfer _ v = do
        return v
    attrConstruct = constructPrintCompositorHighlightSyntax
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.highlightSyntax"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#g:attr:highlightSyntax"
        })
#endif

-- VVV Prop "line-numbers-font-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just True)

-- | Get the value of the “@line-numbers-font-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' printCompositor #lineNumbersFontName
-- @
getPrintCompositorLineNumbersFontName :: (MonadIO m, IsPrintCompositor o) => o -> m (Maybe T.Text)
getPrintCompositorLineNumbersFontName :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m (Maybe Text)
getPrintCompositorLineNumbersFontName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"line-numbers-font-name"

-- | Set the value of the “@line-numbers-font-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' printCompositor [ #lineNumbersFontName 'Data.GI.Base.Attributes.:=' value ]
-- @
setPrintCompositorLineNumbersFontName :: (MonadIO m, IsPrintCompositor o) => o -> T.Text -> m ()
setPrintCompositorLineNumbersFontName :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> Text -> m ()
setPrintCompositorLineNumbersFontName o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"line-numbers-font-name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@line-numbers-font-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPrintCompositorLineNumbersFontName :: (IsPrintCompositor o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructPrintCompositorLineNumbersFontName :: forall o (m :: * -> *).
(IsPrintCompositor o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructPrintCompositorLineNumbersFontName Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"line-numbers-font-name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@line-numbers-font-name@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #lineNumbersFontName
-- @
clearPrintCompositorLineNumbersFontName :: (MonadIO m, IsPrintCompositor o) => o -> m ()
clearPrintCompositorLineNumbersFontName :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m ()
clearPrintCompositorLineNumbersFontName o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"line-numbers-font-name" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data PrintCompositorLineNumbersFontNamePropertyInfo
instance AttrInfo PrintCompositorLineNumbersFontNamePropertyInfo where
    type AttrAllowedOps PrintCompositorLineNumbersFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint PrintCompositorLineNumbersFontNamePropertyInfo = IsPrintCompositor
    type AttrSetTypeConstraint PrintCompositorLineNumbersFontNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint PrintCompositorLineNumbersFontNamePropertyInfo = (~) T.Text
    type AttrTransferType PrintCompositorLineNumbersFontNamePropertyInfo = T.Text
    type AttrGetType PrintCompositorLineNumbersFontNamePropertyInfo = (Maybe T.Text)
    type AttrLabel PrintCompositorLineNumbersFontNamePropertyInfo = "line-numbers-font-name"
    type AttrOrigin PrintCompositorLineNumbersFontNamePropertyInfo = PrintCompositor
    attrGet = getPrintCompositorLineNumbersFontName
    attrSet = setPrintCompositorLineNumbersFontName
    attrTransfer _ v = do
        return v
    attrConstruct = constructPrintCompositorLineNumbersFontName
    attrClear = clearPrintCompositorLineNumbersFontName
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.lineNumbersFontName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#g:attr:lineNumbersFontName"
        })
#endif

-- VVV Prop "n-pages"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@n-pages@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' printCompositor #nPages
-- @
getPrintCompositorNPages :: (MonadIO m, IsPrintCompositor o) => o -> m Int32
getPrintCompositorNPages :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m Int32
getPrintCompositorNPages o
obj = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"n-pages"

#if defined(ENABLE_OVERLOADING)
data PrintCompositorNPagesPropertyInfo
instance AttrInfo PrintCompositorNPagesPropertyInfo where
    type AttrAllowedOps PrintCompositorNPagesPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint PrintCompositorNPagesPropertyInfo = IsPrintCompositor
    type AttrSetTypeConstraint PrintCompositorNPagesPropertyInfo = (~) ()
    type AttrTransferTypeConstraint PrintCompositorNPagesPropertyInfo = (~) ()
    type AttrTransferType PrintCompositorNPagesPropertyInfo = ()
    type AttrGetType PrintCompositorNPagesPropertyInfo = Int32
    type AttrLabel PrintCompositorNPagesPropertyInfo = "n-pages"
    type AttrOrigin PrintCompositorNPagesPropertyInfo = PrintCompositor
    attrGet = getPrintCompositorNPages
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.nPages"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#g:attr:nPages"
        })
#endif

-- VVV Prop "print-footer"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@print-footer@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' printCompositor #printFooter
-- @
getPrintCompositorPrintFooter :: (MonadIO m, IsPrintCompositor o) => o -> m Bool
getPrintCompositorPrintFooter :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m Bool
getPrintCompositorPrintFooter o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"print-footer"

-- | Set the value of the “@print-footer@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' printCompositor [ #printFooter 'Data.GI.Base.Attributes.:=' value ]
-- @
setPrintCompositorPrintFooter :: (MonadIO m, IsPrintCompositor o) => o -> Bool -> m ()
setPrintCompositorPrintFooter :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> Bool -> m ()
setPrintCompositorPrintFooter o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"print-footer" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@print-footer@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPrintCompositorPrintFooter :: (IsPrintCompositor o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructPrintCompositorPrintFooter :: forall o (m :: * -> *).
(IsPrintCompositor o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructPrintCompositorPrintFooter Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"print-footer" Bool
val

#if defined(ENABLE_OVERLOADING)
data PrintCompositorPrintFooterPropertyInfo
instance AttrInfo PrintCompositorPrintFooterPropertyInfo where
    type AttrAllowedOps PrintCompositorPrintFooterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PrintCompositorPrintFooterPropertyInfo = IsPrintCompositor
    type AttrSetTypeConstraint PrintCompositorPrintFooterPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint PrintCompositorPrintFooterPropertyInfo = (~) Bool
    type AttrTransferType PrintCompositorPrintFooterPropertyInfo = Bool
    type AttrGetType PrintCompositorPrintFooterPropertyInfo = Bool
    type AttrLabel PrintCompositorPrintFooterPropertyInfo = "print-footer"
    type AttrOrigin PrintCompositorPrintFooterPropertyInfo = PrintCompositor
    attrGet = getPrintCompositorPrintFooter
    attrSet = setPrintCompositorPrintFooter
    attrTransfer _ v = do
        return v
    attrConstruct = constructPrintCompositorPrintFooter
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printFooter"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#g:attr:printFooter"
        })
#endif

-- VVV Prop "print-header"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@print-header@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' printCompositor #printHeader
-- @
getPrintCompositorPrintHeader :: (MonadIO m, IsPrintCompositor o) => o -> m Bool
getPrintCompositorPrintHeader :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m Bool
getPrintCompositorPrintHeader o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"print-header"

-- | Set the value of the “@print-header@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' printCompositor [ #printHeader 'Data.GI.Base.Attributes.:=' value ]
-- @
setPrintCompositorPrintHeader :: (MonadIO m, IsPrintCompositor o) => o -> Bool -> m ()
setPrintCompositorPrintHeader :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> Bool -> m ()
setPrintCompositorPrintHeader o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"print-header" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@print-header@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPrintCompositorPrintHeader :: (IsPrintCompositor o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructPrintCompositorPrintHeader :: forall o (m :: * -> *).
(IsPrintCompositor o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructPrintCompositorPrintHeader Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"print-header" Bool
val

#if defined(ENABLE_OVERLOADING)
data PrintCompositorPrintHeaderPropertyInfo
instance AttrInfo PrintCompositorPrintHeaderPropertyInfo where
    type AttrAllowedOps PrintCompositorPrintHeaderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PrintCompositorPrintHeaderPropertyInfo = IsPrintCompositor
    type AttrSetTypeConstraint PrintCompositorPrintHeaderPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint PrintCompositorPrintHeaderPropertyInfo = (~) Bool
    type AttrTransferType PrintCompositorPrintHeaderPropertyInfo = Bool
    type AttrGetType PrintCompositorPrintHeaderPropertyInfo = Bool
    type AttrLabel PrintCompositorPrintHeaderPropertyInfo = "print-header"
    type AttrOrigin PrintCompositorPrintHeaderPropertyInfo = PrintCompositor
    attrGet = getPrintCompositorPrintHeader
    attrSet = setPrintCompositorPrintHeader
    attrTransfer _ v = do
        return v
    attrConstruct = constructPrintCompositorPrintHeader
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printHeader"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#g:attr:printHeader"
        })
#endif

-- VVV Prop "print-line-numbers"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@print-line-numbers@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' printCompositor #printLineNumbers
-- @
getPrintCompositorPrintLineNumbers :: (MonadIO m, IsPrintCompositor o) => o -> m Word32
getPrintCompositorPrintLineNumbers :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m Word32
getPrintCompositorPrintLineNumbers o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"print-line-numbers"

-- | Set the value of the “@print-line-numbers@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' printCompositor [ #printLineNumbers 'Data.GI.Base.Attributes.:=' value ]
-- @
setPrintCompositorPrintLineNumbers :: (MonadIO m, IsPrintCompositor o) => o -> Word32 -> m ()
setPrintCompositorPrintLineNumbers :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> Word32 -> m ()
setPrintCompositorPrintLineNumbers o
obj Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"print-line-numbers" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@print-line-numbers@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPrintCompositorPrintLineNumbers :: (IsPrintCompositor o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructPrintCompositorPrintLineNumbers :: forall o (m :: * -> *).
(IsPrintCompositor o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructPrintCompositorPrintLineNumbers Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"print-line-numbers" Word32
val

#if defined(ENABLE_OVERLOADING)
data PrintCompositorPrintLineNumbersPropertyInfo
instance AttrInfo PrintCompositorPrintLineNumbersPropertyInfo where
    type AttrAllowedOps PrintCompositorPrintLineNumbersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PrintCompositorPrintLineNumbersPropertyInfo = IsPrintCompositor
    type AttrSetTypeConstraint PrintCompositorPrintLineNumbersPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint PrintCompositorPrintLineNumbersPropertyInfo = (~) Word32
    type AttrTransferType PrintCompositorPrintLineNumbersPropertyInfo = Word32
    type AttrGetType PrintCompositorPrintLineNumbersPropertyInfo = Word32
    type AttrLabel PrintCompositorPrintLineNumbersPropertyInfo = "print-line-numbers"
    type AttrOrigin PrintCompositorPrintLineNumbersPropertyInfo = PrintCompositor
    attrGet = getPrintCompositorPrintLineNumbers
    attrSet = setPrintCompositorPrintLineNumbers
    attrTransfer _ v = do
        return v
    attrConstruct = constructPrintCompositorPrintLineNumbers
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printLineNumbers"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#g:attr:printLineNumbers"
        })
#endif

-- VVV Prop "tab-width"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@tab-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' printCompositor #tabWidth
-- @
getPrintCompositorTabWidth :: (MonadIO m, IsPrintCompositor o) => o -> m Word32
getPrintCompositorTabWidth :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m Word32
getPrintCompositorTabWidth o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"tab-width"

-- | Set the value of the “@tab-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' printCompositor [ #tabWidth 'Data.GI.Base.Attributes.:=' value ]
-- @
setPrintCompositorTabWidth :: (MonadIO m, IsPrintCompositor o) => o -> Word32 -> m ()
setPrintCompositorTabWidth :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> Word32 -> m ()
setPrintCompositorTabWidth o
obj Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"tab-width" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@tab-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPrintCompositorTabWidth :: (IsPrintCompositor o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructPrintCompositorTabWidth :: forall o (m :: * -> *).
(IsPrintCompositor o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructPrintCompositorTabWidth Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"tab-width" Word32
val

#if defined(ENABLE_OVERLOADING)
data PrintCompositorTabWidthPropertyInfo
instance AttrInfo PrintCompositorTabWidthPropertyInfo where
    type AttrAllowedOps PrintCompositorTabWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PrintCompositorTabWidthPropertyInfo = IsPrintCompositor
    type AttrSetTypeConstraint PrintCompositorTabWidthPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint PrintCompositorTabWidthPropertyInfo = (~) Word32
    type AttrTransferType PrintCompositorTabWidthPropertyInfo = Word32
    type AttrGetType PrintCompositorTabWidthPropertyInfo = Word32
    type AttrLabel PrintCompositorTabWidthPropertyInfo = "tab-width"
    type AttrOrigin PrintCompositorTabWidthPropertyInfo = PrintCompositor
    attrGet = getPrintCompositorTabWidth
    attrSet = setPrintCompositorTabWidth
    attrTransfer _ v = do
        return v
    attrConstruct = constructPrintCompositorTabWidth
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.tabWidth"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#g:attr:tabWidth"
        })
#endif

-- VVV Prop "wrap-mode"
   -- Type: TInterface (Name {namespace = "Gtk", name = "WrapMode"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@wrap-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' printCompositor #wrapMode
-- @
getPrintCompositorWrapMode :: (MonadIO m, IsPrintCompositor o) => o -> m Gtk.Enums.WrapMode
getPrintCompositorWrapMode :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> m WrapMode
getPrintCompositorWrapMode o
obj = IO WrapMode -> m WrapMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO WrapMode -> m WrapMode) -> IO WrapMode -> m WrapMode
forall a b. (a -> b) -> a -> b
$ o -> String -> IO WrapMode
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"wrap-mode"

-- | Set the value of the “@wrap-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' printCompositor [ #wrapMode 'Data.GI.Base.Attributes.:=' value ]
-- @
setPrintCompositorWrapMode :: (MonadIO m, IsPrintCompositor o) => o -> Gtk.Enums.WrapMode -> m ()
setPrintCompositorWrapMode :: forall (m :: * -> *) o.
(MonadIO m, IsPrintCompositor o) =>
o -> WrapMode -> m ()
setPrintCompositorWrapMode o
obj WrapMode
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> WrapMode -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"wrap-mode" WrapMode
val

-- | Construct a `GValueConstruct` with valid value for the “@wrap-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPrintCompositorWrapMode :: (IsPrintCompositor o, MIO.MonadIO m) => Gtk.Enums.WrapMode -> m (GValueConstruct o)
constructPrintCompositorWrapMode :: forall o (m :: * -> *).
(IsPrintCompositor o, MonadIO m) =>
WrapMode -> m (GValueConstruct o)
constructPrintCompositorWrapMode WrapMode
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> WrapMode -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"wrap-mode" WrapMode
val

#if defined(ENABLE_OVERLOADING)
data PrintCompositorWrapModePropertyInfo
instance AttrInfo PrintCompositorWrapModePropertyInfo where
    type AttrAllowedOps PrintCompositorWrapModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PrintCompositorWrapModePropertyInfo = IsPrintCompositor
    type AttrSetTypeConstraint PrintCompositorWrapModePropertyInfo = (~) Gtk.Enums.WrapMode
    type AttrTransferTypeConstraint PrintCompositorWrapModePropertyInfo = (~) Gtk.Enums.WrapMode
    type AttrTransferType PrintCompositorWrapModePropertyInfo = Gtk.Enums.WrapMode
    type AttrGetType PrintCompositorWrapModePropertyInfo = Gtk.Enums.WrapMode
    type AttrLabel PrintCompositorWrapModePropertyInfo = "wrap-mode"
    type AttrOrigin PrintCompositorWrapModePropertyInfo = PrintCompositor
    attrGet = getPrintCompositorWrapMode
    attrSet = setPrintCompositorWrapMode
    attrTransfer _ v = do
        return v
    attrConstruct = constructPrintCompositorWrapMode
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.wrapMode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#g:attr:wrapMode"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList PrintCompositor
type instance O.AttributeList PrintCompositor = PrintCompositorAttributeList
type PrintCompositorAttributeList = ('[ '("bodyFontName", PrintCompositorBodyFontNamePropertyInfo), '("buffer", PrintCompositorBufferPropertyInfo), '("footerFontName", PrintCompositorFooterFontNamePropertyInfo), '("headerFontName", PrintCompositorHeaderFontNamePropertyInfo), '("highlightSyntax", PrintCompositorHighlightSyntaxPropertyInfo), '("lineNumbersFontName", PrintCompositorLineNumbersFontNamePropertyInfo), '("nPages", PrintCompositorNPagesPropertyInfo), '("printFooter", PrintCompositorPrintFooterPropertyInfo), '("printHeader", PrintCompositorPrintHeaderPropertyInfo), '("printLineNumbers", PrintCompositorPrintLineNumbersPropertyInfo), '("tabWidth", PrintCompositorTabWidthPropertyInfo), '("wrapMode", PrintCompositorWrapModePropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
printCompositorBodyFontName :: AttrLabelProxy "bodyFontName"
printCompositorBodyFontName = AttrLabelProxy

printCompositorBuffer :: AttrLabelProxy "buffer"
printCompositorBuffer = AttrLabelProxy

printCompositorFooterFontName :: AttrLabelProxy "footerFontName"
printCompositorFooterFontName = AttrLabelProxy

printCompositorHeaderFontName :: AttrLabelProxy "headerFontName"
printCompositorHeaderFontName = AttrLabelProxy

printCompositorHighlightSyntax :: AttrLabelProxy "highlightSyntax"
printCompositorHighlightSyntax = AttrLabelProxy

printCompositorLineNumbersFontName :: AttrLabelProxy "lineNumbersFontName"
printCompositorLineNumbersFontName = AttrLabelProxy

printCompositorNPages :: AttrLabelProxy "nPages"
printCompositorNPages = AttrLabelProxy

printCompositorPrintFooter :: AttrLabelProxy "printFooter"
printCompositorPrintFooter = AttrLabelProxy

printCompositorPrintHeader :: AttrLabelProxy "printHeader"
printCompositorPrintHeader = AttrLabelProxy

printCompositorPrintLineNumbers :: AttrLabelProxy "printLineNumbers"
printCompositorPrintLineNumbers = AttrLabelProxy

printCompositorTabWidth :: AttrLabelProxy "tabWidth"
printCompositorTabWidth = AttrLabelProxy

printCompositorWrapMode :: AttrLabelProxy "wrapMode"
printCompositorWrapMode = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList PrintCompositor = PrintCompositorSignalList
type PrintCompositorSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method PrintCompositor::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GtkSourceBuffer to print."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GtkSource" , name = "PrintCompositor" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_new" gtk_source_print_compositor_new :: 
    Ptr GtkSource.Buffer.Buffer ->          -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO (Ptr PrintCompositor)

-- | Creates a new print compositor that can be used to print /@buffer@/.
printCompositorNew ::
    (B.CallStack.HasCallStack, MonadIO m, GtkSource.Buffer.IsBuffer a) =>
    a
    -- ^ /@buffer@/: the t'GI.GtkSource.Objects.Buffer.Buffer' to print.
    -> m PrintCompositor
    -- ^ __Returns:__ a new print compositor object.
printCompositorNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuffer a) =>
a -> m PrintCompositor
printCompositorNew a
buffer = IO PrintCompositor -> m PrintCompositor
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PrintCompositor -> m PrintCompositor)
-> IO PrintCompositor -> m PrintCompositor
forall a b. (a -> b) -> a -> b
$ do
    Ptr Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr PrintCompositor
result <- Ptr Buffer -> IO (Ptr PrintCompositor)
gtk_source_print_compositor_new Ptr Buffer
buffer'
    Text -> Ptr PrintCompositor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"printCompositorNew" Ptr PrintCompositor
result
    PrintCompositor
result' <- ((ManagedPtr PrintCompositor -> PrintCompositor)
-> Ptr PrintCompositor -> IO PrintCompositor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PrintCompositor -> PrintCompositor
PrintCompositor) Ptr PrintCompositor
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    PrintCompositor -> IO PrintCompositor
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PrintCompositor
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method PrintCompositor::new_from_view
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView to get configuration from."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GtkSource" , name = "PrintCompositor" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_new_from_view" gtk_source_print_compositor_new_from_view :: 
    Ptr GtkSource.View.View ->              -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO (Ptr PrintCompositor)

-- | Creates a new print compositor that can be used to print the buffer
-- associated with /@view@/.
-- 
-- This constructor sets some configuration properties to make the
-- printed output match /@view@/ as much as possible.  The properties set are
-- [property/@printCompositor@/:tab-width], [property/@printCompositor@/:highlight-syntax],
-- [property/@printCompositor@/:wrap-mode], [property/@printCompositor@/:body-font-name] and
-- [property/@printCompositor@/:print-line-numbers].
printCompositorNewFromView ::
    (B.CallStack.HasCallStack, MonadIO m, GtkSource.View.IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View' to get configuration from.
    -> m PrintCompositor
    -- ^ __Returns:__ a new print compositor object.
printCompositorNewFromView :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m PrintCompositor
printCompositorNewFromView a
view = IO PrintCompositor -> m PrintCompositor
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PrintCompositor -> m PrintCompositor)
-> IO PrintCompositor -> m PrintCompositor
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Ptr PrintCompositor
result <- Ptr View -> IO (Ptr PrintCompositor)
gtk_source_print_compositor_new_from_view Ptr View
view'
    Text -> Ptr PrintCompositor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"printCompositorNewFromView" Ptr PrintCompositor
result
    PrintCompositor
result' <- ((ManagedPtr PrintCompositor -> PrintCompositor)
-> Ptr PrintCompositor -> IO PrintCompositor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PrintCompositor -> PrintCompositor
PrintCompositor) Ptr PrintCompositor
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    PrintCompositor -> IO PrintCompositor
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PrintCompositor
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method PrintCompositor::draw_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PrintContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #GtkPrintContext encapsulating the context information that is required when\n          drawing the page for printing."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page_nr"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of the page to print."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_draw_page" gtk_source_print_compositor_draw_page :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    Ptr Gtk.PrintContext.PrintContext ->    -- context : TInterface (Name {namespace = "Gtk", name = "PrintContext"})
    Int32 ->                                -- page_nr : TBasicType TInt
    IO ()

-- | Draw page /@pageNr@/ for printing on the the Cairo context encapsuled in /@context@/.
-- 
-- This method has been designed to be called in the handler of the [signal/@gtk@/.PrintOperation[draw_page](#g:signal:draw_page)] signal
-- as shown in the following example:
-- 
-- 
-- === /c code/
-- >// Signal handler for the GtkPrintOperation::draw_page signal
-- >
-- >static void
-- >draw_page (GtkPrintOperation *operation,
-- >           GtkPrintContext   *context,
-- >           gint               page_nr,
-- >           gpointer           user_data)
-- >{
-- >    GtkSourcePrintCompositor *compositor;
-- >
-- >    compositor = GTK_SOURCE_PRINT_COMPOSITOR (user_data);
-- >
-- >    gtk_source_print_compositor_draw_page (compositor,
-- >                                           context,
-- >                                           page_nr);
-- >}
printCompositorDrawPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a, Gtk.PrintContext.IsPrintContext b) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> b
    -- ^ /@context@/: the t'GI.Gtk.Objects.PrintContext.PrintContext' encapsulating the context information that is required when
    --           drawing the page for printing.
    -> Int32
    -- ^ /@pageNr@/: the number of the page to print.
    -> m ()
printCompositorDrawPage :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPrintCompositor a, IsPrintContext b) =>
a -> b -> Int32 -> m ()
printCompositorDrawPage a
compositor b
context Int32
pageNr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    Ptr PrintContext
context' <- b -> IO (Ptr PrintContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
context
    Ptr PrintCompositor -> Ptr PrintContext -> Int32 -> IO ()
gtk_source_print_compositor_draw_page Ptr PrintCompositor
compositor' Ptr PrintContext
context' Int32
pageNr
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
context
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorDrawPageMethodInfo
instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsPrintCompositor a, Gtk.PrintContext.IsPrintContext b) => O.OverloadedMethod PrintCompositorDrawPageMethodInfo a signature where
    overloadedMethod = printCompositorDrawPage

instance O.OverloadedMethodInfo PrintCompositorDrawPageMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorDrawPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorDrawPage"
        })


#endif

-- method PrintCompositor::get_body_font_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_body_font_name" gtk_source_print_compositor_get_body_font_name :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    IO CString

-- | Returns the name of the font used to print the text body.
-- 
-- The returned string must be freed with 'GI.GLib.Functions.free'.
printCompositorGetBodyFontName ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> m T.Text
    -- ^ __Returns:__ a new string containing the name of the font used to print the
    -- text body.
printCompositorGetBodyFontName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> m Text
printCompositorGetBodyFontName a
compositor = IO Text -> m Text
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    CString
result <- Ptr PrintCompositor -> IO CString
gtk_source_print_compositor_get_body_font_name Ptr PrintCompositor
compositor'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"printCompositorGetBodyFontName" 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
compositor
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetBodyFontNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetBodyFontNameMethodInfo a signature where
    overloadedMethod = printCompositorGetBodyFontName

instance O.OverloadedMethodInfo PrintCompositorGetBodyFontNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetBodyFontName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetBodyFontName"
        })


#endif

-- method PrintCompositor::get_bottom_margin
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "unit"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Unit" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the unit for the return value."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_bottom_margin" gtk_source_print_compositor_get_bottom_margin :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CUInt ->                                -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"})
    IO CDouble

-- | Gets the bottom margin in units of /@unit@/.
printCompositorGetBottomMargin ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Gtk.Enums.Unit
    -- ^ /@unit@/: the unit for the return value.
    -> m Double
    -- ^ __Returns:__ the bottom margin.
printCompositorGetBottomMargin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Unit -> m Double
printCompositorGetBottomMargin a
compositor Unit
unit = IO Double -> m Double
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    let unit' :: CUInt
unit' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Unit -> Int) -> Unit -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unit -> Int
forall a. Enum a => a -> Int
fromEnum) Unit
unit
    CDouble
result <- Ptr PrintCompositor -> CUInt -> IO CDouble
gtk_source_print_compositor_get_bottom_margin Ptr PrintCompositor
compositor' CUInt
unit'
    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
compositor
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetBottomMarginMethodInfo
instance (signature ~ (Gtk.Enums.Unit -> m Double), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetBottomMarginMethodInfo a signature where
    overloadedMethod = printCompositorGetBottomMargin

instance O.OverloadedMethodInfo PrintCompositorGetBottomMarginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetBottomMargin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetBottomMargin"
        })


#endif

-- method PrintCompositor::get_buffer
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GtkSource" , name = "Buffer" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_buffer" gtk_source_print_compositor_get_buffer :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    IO (Ptr GtkSource.Buffer.Buffer)

-- | Gets the [class/@buffer@/] associated with the compositor.
-- 
-- The returned object reference is owned by the compositor object and
-- should not be unreferenced.
printCompositorGetBuffer ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> m GtkSource.Buffer.Buffer
    -- ^ __Returns:__ the t'GI.GtkSource.Objects.Buffer.Buffer' associated with the compositor.
printCompositorGetBuffer :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> m Buffer
printCompositorGetBuffer a
compositor = IO Buffer -> m Buffer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    Ptr Buffer
result <- Ptr PrintCompositor -> IO (Ptr Buffer)
gtk_source_print_compositor_get_buffer Ptr PrintCompositor
compositor'
    Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"printCompositorGetBuffer" Ptr Buffer
result
    Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Buffer -> Buffer
GtkSource.Buffer.Buffer) Ptr Buffer
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    Buffer -> IO Buffer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetBufferMethodInfo
instance (signature ~ (m GtkSource.Buffer.Buffer), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetBufferMethodInfo a signature where
    overloadedMethod = printCompositorGetBuffer

instance O.OverloadedMethodInfo PrintCompositorGetBufferMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetBuffer",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetBuffer"
        })


#endif

-- method PrintCompositor::get_footer_font_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_footer_font_name" gtk_source_print_compositor_get_footer_font_name :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    IO CString

-- | Returns the name of the font used to print the page footer.
-- 
-- The returned string must be freed with 'GI.GLib.Functions.free'.
printCompositorGetFooterFontName ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> m T.Text
    -- ^ __Returns:__ a new string containing the name of the font used to print
    -- the page footer.
printCompositorGetFooterFontName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> m Text
printCompositorGetFooterFontName a
compositor = IO Text -> m Text
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    CString
result <- Ptr PrintCompositor -> IO CString
gtk_source_print_compositor_get_footer_font_name Ptr PrintCompositor
compositor'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"printCompositorGetFooterFontName" 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
compositor
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetFooterFontNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetFooterFontNameMethodInfo a signature where
    overloadedMethod = printCompositorGetFooterFontName

instance O.OverloadedMethodInfo PrintCompositorGetFooterFontNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetFooterFontName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetFooterFontName"
        })


#endif

-- method PrintCompositor::get_header_font_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_header_font_name" gtk_source_print_compositor_get_header_font_name :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    IO CString

-- | Returns the name of the font used to print the page header.
-- 
-- The returned string must be freed with 'GI.GLib.Functions.free'.
printCompositorGetHeaderFontName ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> m T.Text
    -- ^ __Returns:__ a new string containing the name of the font used to print
    -- the page header.
printCompositorGetHeaderFontName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> m Text
printCompositorGetHeaderFontName a
compositor = IO Text -> m Text
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    CString
result <- Ptr PrintCompositor -> IO CString
gtk_source_print_compositor_get_header_font_name Ptr PrintCompositor
compositor'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"printCompositorGetHeaderFontName" 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
compositor
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetHeaderFontNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetHeaderFontNameMethodInfo a signature where
    overloadedMethod = printCompositorGetHeaderFontName

instance O.OverloadedMethodInfo PrintCompositorGetHeaderFontNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetHeaderFontName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetHeaderFontName"
        })


#endif

-- method PrintCompositor::get_highlight_syntax
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_highlight_syntax" gtk_source_print_compositor_get_highlight_syntax :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    IO CInt

-- | Determines whether the printed text will be highlighted according to the
-- buffer rules.
-- 
-- Note that highlighting will happen only if the buffer to print has highlighting activated.
printCompositorGetHighlightSyntax ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the printed output will be highlighted.
printCompositorGetHighlightSyntax :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> m Bool
printCompositorGetHighlightSyntax a
compositor = IO Bool -> m Bool
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    CInt
result <- Ptr PrintCompositor -> IO CInt
gtk_source_print_compositor_get_highlight_syntax Ptr PrintCompositor
compositor'
    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
compositor
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetHighlightSyntaxMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetHighlightSyntaxMethodInfo a signature where
    overloadedMethod = printCompositorGetHighlightSyntax

instance O.OverloadedMethodInfo PrintCompositorGetHighlightSyntaxMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetHighlightSyntax",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetHighlightSyntax"
        })


#endif

-- method PrintCompositor::get_left_margin
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "unit"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Unit" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the unit for the return value."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_left_margin" gtk_source_print_compositor_get_left_margin :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CUInt ->                                -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"})
    IO CDouble

-- | Gets the left margin in units of /@unit@/.
printCompositorGetLeftMargin ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Gtk.Enums.Unit
    -- ^ /@unit@/: the unit for the return value.
    -> m Double
    -- ^ __Returns:__ the left margin
printCompositorGetLeftMargin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Unit -> m Double
printCompositorGetLeftMargin a
compositor Unit
unit = IO Double -> m Double
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    let unit' :: CUInt
unit' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Unit -> Int) -> Unit -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unit -> Int
forall a. Enum a => a -> Int
fromEnum) Unit
unit
    CDouble
result <- Ptr PrintCompositor -> CUInt -> IO CDouble
gtk_source_print_compositor_get_left_margin Ptr PrintCompositor
compositor' CUInt
unit'
    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
compositor
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetLeftMarginMethodInfo
instance (signature ~ (Gtk.Enums.Unit -> m Double), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetLeftMarginMethodInfo a signature where
    overloadedMethod = printCompositorGetLeftMargin

instance O.OverloadedMethodInfo PrintCompositorGetLeftMarginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetLeftMargin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetLeftMargin"
        })


#endif

-- method PrintCompositor::get_line_numbers_font_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_line_numbers_font_name" gtk_source_print_compositor_get_line_numbers_font_name :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    IO CString

-- | Returns the name of the font used to print line numbers on the left margin.
-- 
-- The returned string must be freed with 'GI.GLib.Functions.free'.
printCompositorGetLineNumbersFontName ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> m T.Text
    -- ^ __Returns:__ a new string containing the name of the font used to print
    -- line numbers on the left margin.
printCompositorGetLineNumbersFontName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> m Text
printCompositorGetLineNumbersFontName a
compositor = IO Text -> m Text
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    CString
result <- Ptr PrintCompositor -> IO CString
gtk_source_print_compositor_get_line_numbers_font_name Ptr PrintCompositor
compositor'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"printCompositorGetLineNumbersFontName" 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
compositor
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetLineNumbersFontNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetLineNumbersFontNameMethodInfo a signature where
    overloadedMethod = printCompositorGetLineNumbersFontName

instance O.OverloadedMethodInfo PrintCompositorGetLineNumbersFontNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetLineNumbersFontName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetLineNumbersFontName"
        })


#endif

-- method PrintCompositor::get_n_pages
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_n_pages" gtk_source_print_compositor_get_n_pages :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    IO Int32

-- | Returns the number of pages in the document or \<code>-1\<\/code> if the
-- document has not been completely paginated.
printCompositorGetNPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> m Int32
    -- ^ __Returns:__ the number of pages in the document or \<code>-1\<\/code> if the
    -- document has not been completely paginated.
printCompositorGetNPages :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> m Int32
printCompositorGetNPages a
compositor = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    Int32
result <- Ptr PrintCompositor -> IO Int32
gtk_source_print_compositor_get_n_pages Ptr PrintCompositor
compositor'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetNPagesMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetNPagesMethodInfo a signature where
    overloadedMethod = printCompositorGetNPages

instance O.OverloadedMethodInfo PrintCompositorGetNPagesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetNPages",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetNPages"
        })


#endif

-- method PrintCompositor::get_pagination_progress
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_pagination_progress" gtk_source_print_compositor_get_pagination_progress :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    IO CDouble

-- | Returns the current fraction of the document pagination that has been completed.
printCompositorGetPaginationProgress ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> m Double
    -- ^ __Returns:__ a fraction from 0.0 to 1.0 inclusive.
printCompositorGetPaginationProgress :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> m Double
printCompositorGetPaginationProgress a
compositor = IO Double -> m Double
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    CDouble
result <- Ptr PrintCompositor -> IO CDouble
gtk_source_print_compositor_get_pagination_progress Ptr PrintCompositor
compositor'
    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
compositor
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetPaginationProgressMethodInfo
instance (signature ~ (m Double), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetPaginationProgressMethodInfo a signature where
    overloadedMethod = printCompositorGetPaginationProgress

instance O.OverloadedMethodInfo PrintCompositorGetPaginationProgressMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetPaginationProgress",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetPaginationProgress"
        })


#endif

-- method PrintCompositor::get_print_footer
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_print_footer" gtk_source_print_compositor_get_print_footer :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    IO CInt

-- | Determines if a footer is set to be printed for each page.
-- 
-- A footer will be printed if this function returns 'P.True'
-- **and** some format strings have been specified
-- with [method/@printCompositor@/.set_footer_format].
printCompositorGetPrintFooter ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the footer is set to be printed.
printCompositorGetPrintFooter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> m Bool
printCompositorGetPrintFooter a
compositor = IO Bool -> m Bool
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    CInt
result <- Ptr PrintCompositor -> IO CInt
gtk_source_print_compositor_get_print_footer Ptr PrintCompositor
compositor'
    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
compositor
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetPrintFooterMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetPrintFooterMethodInfo a signature where
    overloadedMethod = printCompositorGetPrintFooter

instance O.OverloadedMethodInfo PrintCompositorGetPrintFooterMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetPrintFooter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetPrintFooter"
        })


#endif

-- method PrintCompositor::get_print_header
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_print_header" gtk_source_print_compositor_get_print_header :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    IO CInt

-- | Determines if a header is set to be printed for each page.
-- 
-- A header will be printed if this function returns 'P.True'
-- **and** some format strings have been specified
-- with [method/@printCompositor@/.set_header_format].
printCompositorGetPrintHeader ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the header is set to be printed.
printCompositorGetPrintHeader :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> m Bool
printCompositorGetPrintHeader a
compositor = IO Bool -> m Bool
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    CInt
result <- Ptr PrintCompositor -> IO CInt
gtk_source_print_compositor_get_print_header Ptr PrintCompositor
compositor'
    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
compositor
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetPrintHeaderMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetPrintHeaderMethodInfo a signature where
    overloadedMethod = printCompositorGetPrintHeader

instance O.OverloadedMethodInfo PrintCompositorGetPrintHeaderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetPrintHeader",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetPrintHeader"
        })


#endif

-- method PrintCompositor::get_print_line_numbers
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_print_line_numbers" gtk_source_print_compositor_get_print_line_numbers :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    IO Word32

-- | Returns the interval used for line number printing.
-- 
-- If the value is 0, no line numbers will be printed. The default value is
-- 1 (i.e. numbers printed in all lines).
printCompositorGetPrintLineNumbers ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> m Word32
    -- ^ __Returns:__ the interval of printed line numbers.
printCompositorGetPrintLineNumbers :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> m Word32
printCompositorGetPrintLineNumbers a
compositor = IO Word32 -> m Word32
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    Word32
result <- Ptr PrintCompositor -> IO Word32
gtk_source_print_compositor_get_print_line_numbers Ptr PrintCompositor
compositor'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetPrintLineNumbersMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetPrintLineNumbersMethodInfo a signature where
    overloadedMethod = printCompositorGetPrintLineNumbers

instance O.OverloadedMethodInfo PrintCompositorGetPrintLineNumbersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetPrintLineNumbers",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetPrintLineNumbers"
        })


#endif

-- method PrintCompositor::get_right_margin
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "unit"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Unit" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the unit for the return value."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_right_margin" gtk_source_print_compositor_get_right_margin :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CUInt ->                                -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"})
    IO CDouble

-- | Gets the right margin in units of /@unit@/.
printCompositorGetRightMargin ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Gtk.Enums.Unit
    -- ^ /@unit@/: the unit for the return value.
    -> m Double
    -- ^ __Returns:__ the right margin.
printCompositorGetRightMargin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Unit -> m Double
printCompositorGetRightMargin a
compositor Unit
unit = IO Double -> m Double
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    let unit' :: CUInt
unit' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Unit -> Int) -> Unit -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unit -> Int
forall a. Enum a => a -> Int
fromEnum) Unit
unit
    CDouble
result <- Ptr PrintCompositor -> CUInt -> IO CDouble
gtk_source_print_compositor_get_right_margin Ptr PrintCompositor
compositor' CUInt
unit'
    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
compositor
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetRightMarginMethodInfo
instance (signature ~ (Gtk.Enums.Unit -> m Double), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetRightMarginMethodInfo a signature where
    overloadedMethod = printCompositorGetRightMargin

instance O.OverloadedMethodInfo PrintCompositorGetRightMarginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetRightMargin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetRightMargin"
        })


#endif

-- method PrintCompositor::get_tab_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_tab_width" gtk_source_print_compositor_get_tab_width :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    IO Word32

-- | Returns the width of tabulation in characters for printed text.
printCompositorGetTabWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> m Word32
    -- ^ __Returns:__ width of tab.
printCompositorGetTabWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> m Word32
printCompositorGetTabWidth a
compositor = IO Word32 -> m Word32
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    Word32
result <- Ptr PrintCompositor -> IO Word32
gtk_source_print_compositor_get_tab_width Ptr PrintCompositor
compositor'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetTabWidthMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetTabWidthMethodInfo a signature where
    overloadedMethod = printCompositorGetTabWidth

instance O.OverloadedMethodInfo PrintCompositorGetTabWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetTabWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetTabWidth"
        })


#endif

-- method PrintCompositor::get_top_margin
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "unit"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Unit" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the unit for the return value."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_top_margin" gtk_source_print_compositor_get_top_margin :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CUInt ->                                -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"})
    IO CDouble

-- | Gets the top margin in units of /@unit@/.
printCompositorGetTopMargin ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Gtk.Enums.Unit
    -- ^ /@unit@/: the unit for the return value.
    -> m Double
    -- ^ __Returns:__ the top margin.
printCompositorGetTopMargin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Unit -> m Double
printCompositorGetTopMargin a
compositor Unit
unit = IO Double -> m Double
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    let unit' :: CUInt
unit' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Unit -> Int) -> Unit -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unit -> Int
forall a. Enum a => a -> Int
fromEnum) Unit
unit
    CDouble
result <- Ptr PrintCompositor -> CUInt -> IO CDouble
gtk_source_print_compositor_get_top_margin Ptr PrintCompositor
compositor' CUInt
unit'
    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
compositor
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetTopMarginMethodInfo
instance (signature ~ (Gtk.Enums.Unit -> m Double), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetTopMarginMethodInfo a signature where
    overloadedMethod = printCompositorGetTopMargin

instance O.OverloadedMethodInfo PrintCompositorGetTopMarginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetTopMargin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetTopMargin"
        })


#endif

-- method PrintCompositor::get_wrap_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "WrapMode" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_get_wrap_mode" gtk_source_print_compositor_get_wrap_mode :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    IO CUInt

-- | Gets the line wrapping mode for the printed text.
printCompositorGetWrapMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> m Gtk.Enums.WrapMode
    -- ^ __Returns:__ the line wrap mode.
printCompositorGetWrapMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> m WrapMode
printCompositorGetWrapMode a
compositor = IO WrapMode -> m WrapMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WrapMode -> m WrapMode) -> IO WrapMode -> m WrapMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    CUInt
result <- Ptr PrintCompositor -> IO CUInt
gtk_source_print_compositor_get_wrap_mode Ptr PrintCompositor
compositor'
    let result' :: WrapMode
result' = (Int -> WrapMode
forall a. Enum a => Int -> a
toEnum (Int -> WrapMode) -> (CUInt -> Int) -> CUInt -> WrapMode
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
compositor
    WrapMode -> IO WrapMode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WrapMode
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorGetWrapModeMethodInfo
instance (signature ~ (m Gtk.Enums.WrapMode), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorGetWrapModeMethodInfo a signature where
    overloadedMethod = printCompositorGetWrapMode

instance O.OverloadedMethodInfo PrintCompositorGetWrapModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorGetWrapMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorGetWrapMode"
        })


#endif

-- method PrintCompositor::ignore_tag
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tag"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextTag" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkTextTag" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_ignore_tag" gtk_source_print_compositor_ignore_tag :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    Ptr Gtk.TextTag.TextTag ->              -- tag : TInterface (Name {namespace = "Gtk", name = "TextTag"})
    IO ()

-- | Specifies a tag whose style should be ignored when compositing the
-- document to the printable page.
-- 
-- /Since: 5.2/
printCompositorIgnoreTag ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a, Gtk.TextTag.IsTextTag b) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'
    -> b
    -- ^ /@tag@/: a t'GI.Gtk.Objects.TextTag.TextTag'
    -> m ()
printCompositorIgnoreTag :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPrintCompositor a, IsTextTag b) =>
a -> b -> m ()
printCompositorIgnoreTag a
compositor b
tag = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    Ptr TextTag
tag' <- b -> IO (Ptr TextTag)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
tag
    Ptr PrintCompositor -> Ptr TextTag -> IO ()
gtk_source_print_compositor_ignore_tag Ptr PrintCompositor
compositor' Ptr TextTag
tag'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
tag
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorIgnoreTagMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsPrintCompositor a, Gtk.TextTag.IsTextTag b) => O.OverloadedMethod PrintCompositorIgnoreTagMethodInfo a signature where
    overloadedMethod = printCompositorIgnoreTag

instance O.OverloadedMethodInfo PrintCompositorIgnoreTagMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorIgnoreTag",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorIgnoreTag"
        })


#endif

-- method PrintCompositor::paginate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PrintContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #GtkPrintContext whose parameters (e.g. paper size, print margins, etc.)\nare used by the the @compositor to paginate the document."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_paginate" gtk_source_print_compositor_paginate :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    Ptr Gtk.PrintContext.PrintContext ->    -- context : TInterface (Name {namespace = "Gtk", name = "PrintContext"})
    IO CInt

-- | Paginate the document associated with the /@compositor@/.
-- 
-- In order to support non-blocking pagination, document is paginated in small chunks.
-- Each time [method/@printCompositor@/.paginate] is invoked, a chunk of the document
-- is paginated. To paginate the entire document, [method/@printCompositor@/.paginate]
-- must be invoked multiple times.
-- It returns 'P.True' if the document has been completely paginated, otherwise it returns 'P.False'.
-- 
-- This method has been designed to be invoked in the handler of the [PrintOperation::paginate]("GI.Gtk.Objects.PrintOperation#g:signal:paginate") signal,
-- as shown in the following example:
-- 
-- 
-- === /c code/
-- >// Signal handler for the GtkPrintOperation::paginate signal
-- >
-- >static gboolean
-- >paginate (GtkPrintOperation *operation,
-- >          GtkPrintContext   *context,
-- >          gpointer           user_data)
-- >{
-- >    GtkSourcePrintCompositor *compositor;
-- >
-- >    compositor = GTK_SOURCE_PRINT_COMPOSITOR (user_data);
-- >
-- >    if (gtk_source_print_compositor_paginate (compositor, context))
-- >    {
-- >        gint n_pages;
-- >
-- >        n_pages = gtk_source_print_compositor_get_n_pages (compositor);
-- >        gtk_print_operation_set_n_pages (operation, n_pages);
-- >
-- >        return TRUE;
-- >    }
-- >
-- >    return FALSE;
-- >}
-- 
-- 
-- If you don\'t need to do pagination in chunks, you can simply do it all in the
-- [PrintOperation::beginPrint]("GI.Gtk.Objects.PrintOperation#g:signal:beginPrint") handler, and set the number of pages from there, like
-- in the following example:
-- 
-- 
-- === /c code/
-- >// Signal handler for the GtkPrintOperation::begin-print signal
-- >
-- >static void
-- >begin_print (GtkPrintOperation *operation,
-- >             GtkPrintContext   *context,
-- >             gpointer           user_data)
-- >{
-- >    GtkSourcePrintCompositor *compositor;
-- >    gint n_pages;
-- >
-- >    compositor = GTK_SOURCE_PRINT_COMPOSITOR (user_data);
-- >
-- >    while (!gtk_source_print_compositor_paginate (compositor, context));
-- >
-- >    n_pages = gtk_source_print_compositor_get_n_pages (compositor);
-- >    gtk_print_operation_set_n_pages (operation, n_pages);
-- >}
printCompositorPaginate ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a, Gtk.PrintContext.IsPrintContext b) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> b
    -- ^ /@context@/: the t'GI.Gtk.Objects.PrintContext.PrintContext' whose parameters (e.g. paper size, print margins, etc.)
    -- are used by the the /@compositor@/ to paginate the document.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the document has been completely paginated, 'P.False' otherwise.
printCompositorPaginate :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPrintCompositor a, IsPrintContext b) =>
a -> b -> m Bool
printCompositorPaginate a
compositor b
context = IO Bool -> m Bool
forall a. IO a -> m a
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 PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    Ptr PrintContext
context' <- b -> IO (Ptr PrintContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
context
    CInt
result <- Ptr PrintCompositor -> Ptr PrintContext -> IO CInt
gtk_source_print_compositor_paginate Ptr PrintCompositor
compositor' Ptr PrintContext
context'
    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
compositor
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
context
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data PrintCompositorPaginateMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsPrintCompositor a, Gtk.PrintContext.IsPrintContext b) => O.OverloadedMethod PrintCompositorPaginateMethodInfo a signature where
    overloadedMethod = printCompositorPaginate

instance O.OverloadedMethodInfo PrintCompositorPaginateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorPaginate"
        })


#endif

-- method PrintCompositor::set_body_font_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "font_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the name of the default font for the body text."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_body_font_name" gtk_source_print_compositor_set_body_font_name :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CString ->                              -- font_name : TBasicType TUTF8
    IO ()

-- | Sets the default font for the printed text.
-- 
-- /@fontName@/ should be a
-- string representation of a font description Pango can understand.
-- (e.g. &quot;Monospace 10&quot;). See [func/@pango@/.FontDescription.from_string]
-- for a description of the format of the string representation.
-- 
-- This function cannot be called anymore after the first call to the
-- [method/@printCompositor@/.paginate] function.
printCompositorSetBodyFontName ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> T.Text
    -- ^ /@fontName@/: the name of the default font for the body text.
    -> m ()
printCompositorSetBodyFontName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Text -> m ()
printCompositorSetBodyFontName a
compositor Text
fontName = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    CString
fontName' <- Text -> IO CString
textToCString Text
fontName
    Ptr PrintCompositor -> CString -> IO ()
gtk_source_print_compositor_set_body_font_name Ptr PrintCompositor
compositor' CString
fontName'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
fontName'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetBodyFontNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetBodyFontNameMethodInfo a signature where
    overloadedMethod = printCompositorSetBodyFontName

instance O.OverloadedMethodInfo PrintCompositorSetBodyFontNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetBodyFontName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetBodyFontName"
        })


#endif

-- method PrintCompositor::set_bottom_margin
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "margin"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new bottom margin in units of @unit."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "unit"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Unit" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the units for @margin."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_bottom_margin" gtk_source_print_compositor_set_bottom_margin :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CDouble ->                              -- margin : TBasicType TDouble
    CUInt ->                                -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"})
    IO ()

-- | Sets the bottom margin used by /@compositor@/.
printCompositorSetBottomMargin ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Double
    -- ^ /@margin@/: the new bottom margin in units of /@unit@/.
    -> Gtk.Enums.Unit
    -- ^ /@unit@/: the units for /@margin@/.
    -> m ()
printCompositorSetBottomMargin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Double -> Unit -> m ()
printCompositorSetBottomMargin a
compositor Double
margin Unit
unit = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    let margin' :: CDouble
margin' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
margin
    let unit' :: CUInt
unit' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Unit -> Int) -> Unit -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unit -> Int
forall a. Enum a => a -> Int
fromEnum) Unit
unit
    Ptr PrintCompositor -> CDouble -> CUInt -> IO ()
gtk_source_print_compositor_set_bottom_margin Ptr PrintCompositor
compositor' CDouble
margin' CUInt
unit'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetBottomMarginMethodInfo
instance (signature ~ (Double -> Gtk.Enums.Unit -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetBottomMarginMethodInfo a signature where
    overloadedMethod = printCompositorSetBottomMargin

instance O.OverloadedMethodInfo PrintCompositorSetBottomMarginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetBottomMargin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetBottomMargin"
        })


#endif

-- method PrintCompositor::set_footer_font_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "font_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the name of the font for the footer text, or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_footer_font_name" gtk_source_print_compositor_set_footer_font_name :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CString ->                              -- font_name : TBasicType TUTF8
    IO ()

-- | Sets the font for printing the page footer.
-- 
-- If 'P.Nothing' is supplied, the default font (i.e. the one being used for the
-- text) will be used instead.
-- 
-- /@fontName@/ should be a
-- string representation of a font description Pango can understand.
-- (e.g. &quot;Monospace 10&quot;). See [func/@pango@/.FontDescription.from_string]
-- for a description of the format of the string representation.
-- 
-- This function cannot be called anymore after the first call to the
-- [method/@printCompositor@/.paginate] function.
printCompositorSetFooterFontName ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Maybe (T.Text)
    -- ^ /@fontName@/: the name of the font for the footer text, or 'P.Nothing'.
    -> m ()
printCompositorSetFooterFontName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Maybe Text -> m ()
printCompositorSetFooterFontName a
compositor Maybe Text
fontName = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    CString
maybeFontName <- case Maybe Text
fontName of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jFontName -> do
            CString
jFontName' <- Text -> IO CString
textToCString Text
jFontName
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jFontName'
    Ptr PrintCompositor -> CString -> IO ()
gtk_source_print_compositor_set_footer_font_name Ptr PrintCompositor
compositor' CString
maybeFontName
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeFontName
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetFooterFontNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetFooterFontNameMethodInfo a signature where
    overloadedMethod = printCompositorSetFooterFontName

instance O.OverloadedMethodInfo PrintCompositorSetFooterFontNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetFooterFontName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetFooterFontName"
        })


#endif

-- method PrintCompositor::set_footer_format
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "separator"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE if you want a separator line to be printed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "left"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a format string to print on the left of the footer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "center"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a format string to print on the center of the footer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "right"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a format string to print on the right of the footer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_footer_format" gtk_source_print_compositor_set_footer_format :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CInt ->                                 -- separator : TBasicType TBoolean
    CString ->                              -- left : TBasicType TUTF8
    CString ->                              -- center : TBasicType TUTF8
    CString ->                              -- right : TBasicType TUTF8
    IO ()

-- | See [method/@printCompositor@/.set_header_format] for more information
-- about the parameters.
printCompositorSetFooterFormat ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Bool
    -- ^ /@separator@/: 'P.True' if you want a separator line to be printed.
    -> Maybe (T.Text)
    -- ^ /@left@/: a format string to print on the left of the footer.
    -> Maybe (T.Text)
    -- ^ /@center@/: a format string to print on the center of the footer.
    -> Maybe (T.Text)
    -- ^ /@right@/: a format string to print on the right of the footer.
    -> m ()
printCompositorSetFooterFormat :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Bool -> Maybe Text -> Maybe Text -> Maybe Text -> m ()
printCompositorSetFooterFormat a
compositor Bool
separator Maybe Text
left Maybe Text
center Maybe Text
right = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    let separator' :: CInt
separator' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
separator
    CString
maybeLeft <- case Maybe Text
left of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jLeft -> do
            CString
jLeft' <- Text -> IO CString
textToCString Text
jLeft
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jLeft'
    CString
maybeCenter <- case Maybe Text
center of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jCenter -> do
            CString
jCenter' <- Text -> IO CString
textToCString Text
jCenter
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jCenter'
    CString
maybeRight <- case Maybe Text
right of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jRight -> do
            CString
jRight' <- Text -> IO CString
textToCString Text
jRight
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jRight'
    Ptr PrintCompositor
-> CInt -> CString -> CString -> CString -> IO ()
gtk_source_print_compositor_set_footer_format Ptr PrintCompositor
compositor' CInt
separator' CString
maybeLeft CString
maybeCenter CString
maybeRight
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeLeft
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeCenter
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeRight
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetFooterFormatMethodInfo
instance (signature ~ (Bool -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetFooterFormatMethodInfo a signature where
    overloadedMethod = printCompositorSetFooterFormat

instance O.OverloadedMethodInfo PrintCompositorSetFooterFormatMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetFooterFormat",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetFooterFormat"
        })


#endif

-- method PrintCompositor::set_header_font_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "font_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the name of the font for header text, or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_header_font_name" gtk_source_print_compositor_set_header_font_name :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CString ->                              -- font_name : TBasicType TUTF8
    IO ()

-- | Sets the font for printing the page header.
-- 
-- If 'P.Nothing' is supplied, the default font (i.e. the one being used for the
-- text) will be used instead.
-- 
-- /@fontName@/ should be a
-- string representation of a font description Pango can understand.
-- (e.g. &quot;Monospace 10&quot;). See [func/@pango@/.FontDescription.from_string]
-- for a description of the format of the string representation.
-- 
-- This function cannot be called anymore after the first call to the
-- [method/@printCompositor@/.paginate] function.
printCompositorSetHeaderFontName ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Maybe (T.Text)
    -- ^ /@fontName@/: the name of the font for header text, or 'P.Nothing'.
    -> m ()
printCompositorSetHeaderFontName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Maybe Text -> m ()
printCompositorSetHeaderFontName a
compositor Maybe Text
fontName = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    CString
maybeFontName <- case Maybe Text
fontName of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jFontName -> do
            CString
jFontName' <- Text -> IO CString
textToCString Text
jFontName
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jFontName'
    Ptr PrintCompositor -> CString -> IO ()
gtk_source_print_compositor_set_header_font_name Ptr PrintCompositor
compositor' CString
maybeFontName
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeFontName
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetHeaderFontNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetHeaderFontNameMethodInfo a signature where
    overloadedMethod = printCompositorSetHeaderFontName

instance O.OverloadedMethodInfo PrintCompositorSetHeaderFontNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetHeaderFontName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetHeaderFontName"
        })


#endif

-- method PrintCompositor::set_header_format
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "separator"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE if you want a separator line to be printed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "left"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a format string to print on the left of the header."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "center"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a format string to print on the center of the header."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "right"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a format string to print on the right of the header."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_header_format" gtk_source_print_compositor_set_header_format :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CInt ->                                 -- separator : TBasicType TBoolean
    CString ->                              -- left : TBasicType TUTF8
    CString ->                              -- center : TBasicType TUTF8
    CString ->                              -- right : TBasicType TUTF8
    IO ()

-- | Sets strftime like header format strings, to be printed on the
-- left, center and right of the top of each page.
-- 
-- The strings may include strftime(3) codes which will be expanded at print time.
-- A subset of @/strftime()/@ codes are accepted, see 'GI.GLib.Structs.DateTime.dateTimeFormat'
-- for more details on the accepted format specifiers.
-- Additionally the following format specifiers are accepted:
-- 
-- * @/N/@: the page number
-- * @/Q/@: the page count.
-- 
-- 
-- /@separator@/ specifies if a solid line should be drawn to separate
-- the header from the document text.
-- 
-- If 'P.Nothing' is given for any of the three arguments, that particular
-- string will not be printed.
-- 
-- For the header to be printed, in
-- addition to specifying format strings, you need to enable header
-- printing with [method/@printCompositor@/.set_print_header].
-- 
-- This function cannot be called anymore after the first call to the
-- [method/@printCompositor@/.paginate] function.
printCompositorSetHeaderFormat ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Bool
    -- ^ /@separator@/: 'P.True' if you want a separator line to be printed.
    -> Maybe (T.Text)
    -- ^ /@left@/: a format string to print on the left of the header.
    -> Maybe (T.Text)
    -- ^ /@center@/: a format string to print on the center of the header.
    -> Maybe (T.Text)
    -- ^ /@right@/: a format string to print on the right of the header.
    -> m ()
printCompositorSetHeaderFormat :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Bool -> Maybe Text -> Maybe Text -> Maybe Text -> m ()
printCompositorSetHeaderFormat a
compositor Bool
separator Maybe Text
left Maybe Text
center Maybe Text
right = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    let separator' :: CInt
separator' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
separator
    CString
maybeLeft <- case Maybe Text
left of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jLeft -> do
            CString
jLeft' <- Text -> IO CString
textToCString Text
jLeft
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jLeft'
    CString
maybeCenter <- case Maybe Text
center of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jCenter -> do
            CString
jCenter' <- Text -> IO CString
textToCString Text
jCenter
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jCenter'
    CString
maybeRight <- case Maybe Text
right of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jRight -> do
            CString
jRight' <- Text -> IO CString
textToCString Text
jRight
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jRight'
    Ptr PrintCompositor
-> CInt -> CString -> CString -> CString -> IO ()
gtk_source_print_compositor_set_header_format Ptr PrintCompositor
compositor' CInt
separator' CString
maybeLeft CString
maybeCenter CString
maybeRight
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeLeft
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeCenter
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeRight
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetHeaderFormatMethodInfo
instance (signature ~ (Bool -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetHeaderFormatMethodInfo a signature where
    overloadedMethod = printCompositorSetHeaderFormat

instance O.OverloadedMethodInfo PrintCompositorSetHeaderFormatMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetHeaderFormat",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetHeaderFormat"
        })


#endif

-- method PrintCompositor::set_highlight_syntax
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "highlight"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether syntax should be highlighted."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_highlight_syntax" gtk_source_print_compositor_set_highlight_syntax :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CInt ->                                 -- highlight : TBasicType TBoolean
    IO ()

-- | Sets whether the printed text will be highlighted according to the
-- buffer rules.  Both color and font style are applied.
-- 
-- This function cannot be called anymore after the first call to the
-- [method/@printCompositor@/.paginate] function.
printCompositorSetHighlightSyntax ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Bool
    -- ^ /@highlight@/: whether syntax should be highlighted.
    -> m ()
printCompositorSetHighlightSyntax :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Bool -> m ()
printCompositorSetHighlightSyntax a
compositor Bool
highlight = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    let highlight' :: CInt
highlight' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
highlight
    Ptr PrintCompositor -> CInt -> IO ()
gtk_source_print_compositor_set_highlight_syntax Ptr PrintCompositor
compositor' CInt
highlight'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetHighlightSyntaxMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetHighlightSyntaxMethodInfo a signature where
    overloadedMethod = printCompositorSetHighlightSyntax

instance O.OverloadedMethodInfo PrintCompositorSetHighlightSyntaxMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetHighlightSyntax",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetHighlightSyntax"
        })


#endif

-- method PrintCompositor::set_left_margin
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "margin"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new left margin in units of @unit."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "unit"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Unit" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the units for @margin."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_left_margin" gtk_source_print_compositor_set_left_margin :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CDouble ->                              -- margin : TBasicType TDouble
    CUInt ->                                -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"})
    IO ()

-- | Sets the left margin used by /@compositor@/.
printCompositorSetLeftMargin ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Double
    -- ^ /@margin@/: the new left margin in units of /@unit@/.
    -> Gtk.Enums.Unit
    -- ^ /@unit@/: the units for /@margin@/.
    -> m ()
printCompositorSetLeftMargin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Double -> Unit -> m ()
printCompositorSetLeftMargin a
compositor Double
margin Unit
unit = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    let margin' :: CDouble
margin' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
margin
    let unit' :: CUInt
unit' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Unit -> Int) -> Unit -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unit -> Int
forall a. Enum a => a -> Int
fromEnum) Unit
unit
    Ptr PrintCompositor -> CDouble -> CUInt -> IO ()
gtk_source_print_compositor_set_left_margin Ptr PrintCompositor
compositor' CDouble
margin' CUInt
unit'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetLeftMarginMethodInfo
instance (signature ~ (Double -> Gtk.Enums.Unit -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetLeftMarginMethodInfo a signature where
    overloadedMethod = printCompositorSetLeftMargin

instance O.OverloadedMethodInfo PrintCompositorSetLeftMarginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetLeftMargin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetLeftMargin"
        })


#endif

-- method PrintCompositor::set_line_numbers_font_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "font_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the name of the font for line numbers, or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_line_numbers_font_name" gtk_source_print_compositor_set_line_numbers_font_name :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CString ->                              -- font_name : TBasicType TUTF8
    IO ()

-- | Sets the font for printing line numbers on the left margin.
-- 
-- If 'P.Nothing' is supplied, the default font (i.e. the one being used for the
-- text) will be used instead.
-- 
-- /@fontName@/ should be a
-- string representation of a font description Pango can understand.
-- (e.g. &quot;Monospace 10&quot;). See [func/@pango@/.FontDescription.from_string]
-- for a description of the format of the string representation.
-- 
-- This function cannot be called anymore after the first call to the
-- [method/@printCompositor@/.paginate] function.
printCompositorSetLineNumbersFontName ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Maybe (T.Text)
    -- ^ /@fontName@/: the name of the font for line numbers, or 'P.Nothing'.
    -> m ()
printCompositorSetLineNumbersFontName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Maybe Text -> m ()
printCompositorSetLineNumbersFontName a
compositor Maybe Text
fontName = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    CString
maybeFontName <- case Maybe Text
fontName of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jFontName -> do
            CString
jFontName' <- Text -> IO CString
textToCString Text
jFontName
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jFontName'
    Ptr PrintCompositor -> CString -> IO ()
gtk_source_print_compositor_set_line_numbers_font_name Ptr PrintCompositor
compositor' CString
maybeFontName
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeFontName
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetLineNumbersFontNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetLineNumbersFontNameMethodInfo a signature where
    overloadedMethod = printCompositorSetLineNumbersFontName

instance O.OverloadedMethodInfo PrintCompositorSetLineNumbersFontNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetLineNumbersFontName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetLineNumbersFontName"
        })


#endif

-- method PrintCompositor::set_print_footer
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "print"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if you want the footer to be printed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_print_footer" gtk_source_print_compositor_set_print_footer :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CInt ->                                 -- print : TBasicType TBoolean
    IO ()

-- | Sets whether you want to print a footer in each page.
-- 
-- The footer consists of three pieces of text and an optional line
-- separator, configurable with
-- [method/@printCompositor@/.set_footer_format].
-- 
-- Note that by default the footer format is unspecified, and if it\'s
-- empty it will not be printed, regardless of this setting.
-- 
-- This function cannot be called anymore after the first call to the
-- [method/@printCompositor@/.paginate] function.
printCompositorSetPrintFooter ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Bool
    -- ^ /@print@/: 'P.True' if you want the footer to be printed.
    -> m ()
printCompositorSetPrintFooter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Bool -> m ()
printCompositorSetPrintFooter a
compositor Bool
print = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    let print' :: CInt
print' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
print
    Ptr PrintCompositor -> CInt -> IO ()
gtk_source_print_compositor_set_print_footer Ptr PrintCompositor
compositor' CInt
print'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetPrintFooterMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetPrintFooterMethodInfo a signature where
    overloadedMethod = printCompositorSetPrintFooter

instance O.OverloadedMethodInfo PrintCompositorSetPrintFooterMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetPrintFooter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetPrintFooter"
        })


#endif

-- method PrintCompositor::set_print_header
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "print"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if you want the header to be printed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_print_header" gtk_source_print_compositor_set_print_header :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CInt ->                                 -- print : TBasicType TBoolean
    IO ()

-- | Sets whether you want to print a header in each page.
-- 
-- The header consists of three pieces of text and an optional line
-- separator, configurable with [method/@printCompositor@/.set_header_format].
-- 
-- Note that by default the header format is unspecified, and if it\'s
-- empty it will not be printed, regardless of this setting.
-- 
-- This function cannot be called anymore after the first call to the
-- [method/@printCompositor@/.paginate] function.
printCompositorSetPrintHeader ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Bool
    -- ^ /@print@/: 'P.True' if you want the header to be printed.
    -> m ()
printCompositorSetPrintHeader :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Bool -> m ()
printCompositorSetPrintHeader a
compositor Bool
print = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    let print' :: CInt
print' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
print
    Ptr PrintCompositor -> CInt -> IO ()
gtk_source_print_compositor_set_print_header Ptr PrintCompositor
compositor' CInt
print'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetPrintHeaderMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetPrintHeaderMethodInfo a signature where
    overloadedMethod = printCompositorSetPrintHeader

instance O.OverloadedMethodInfo PrintCompositorSetPrintHeaderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetPrintHeader",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetPrintHeader"
        })


#endif

-- method PrintCompositor::set_print_line_numbers
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "interval"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "interval for printed line numbers."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_print_line_numbers" gtk_source_print_compositor_set_print_line_numbers :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    Word32 ->                               -- interval : TBasicType TUInt
    IO ()

-- | Sets the interval for printed line numbers.
-- 
-- If /@interval@/ is 0 no numbers will be printed. If greater than 0, a number will be
-- printed every /@interval@/ lines (i.e. 1 will print all line numbers).
-- 
-- Maximum accepted value for /@interval@/ is 100.
-- 
-- This function cannot be called anymore after the first call to the
-- [method/@printCompositor@/.paginate] function.
printCompositorSetPrintLineNumbers ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Word32
    -- ^ /@interval@/: interval for printed line numbers.
    -> m ()
printCompositorSetPrintLineNumbers :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Word32 -> m ()
printCompositorSetPrintLineNumbers a
compositor Word32
interval = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    Ptr PrintCompositor -> Word32 -> IO ()
gtk_source_print_compositor_set_print_line_numbers Ptr PrintCompositor
compositor' Word32
interval
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetPrintLineNumbersMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetPrintLineNumbersMethodInfo a signature where
    overloadedMethod = printCompositorSetPrintLineNumbers

instance O.OverloadedMethodInfo PrintCompositorSetPrintLineNumbersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetPrintLineNumbers",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetPrintLineNumbers"
        })


#endif

-- method PrintCompositor::set_right_margin
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "margin"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new right margin in units of @unit."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "unit"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Unit" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the units for @margin."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_right_margin" gtk_source_print_compositor_set_right_margin :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CDouble ->                              -- margin : TBasicType TDouble
    CUInt ->                                -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"})
    IO ()

-- | Sets the right margin used by /@compositor@/.
printCompositorSetRightMargin ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Double
    -- ^ /@margin@/: the new right margin in units of /@unit@/.
    -> Gtk.Enums.Unit
    -- ^ /@unit@/: the units for /@margin@/.
    -> m ()
printCompositorSetRightMargin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Double -> Unit -> m ()
printCompositorSetRightMargin a
compositor Double
margin Unit
unit = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    let margin' :: CDouble
margin' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
margin
    let unit' :: CUInt
unit' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Unit -> Int) -> Unit -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unit -> Int
forall a. Enum a => a -> Int
fromEnum) Unit
unit
    Ptr PrintCompositor -> CDouble -> CUInt -> IO ()
gtk_source_print_compositor_set_right_margin Ptr PrintCompositor
compositor' CDouble
margin' CUInt
unit'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetRightMarginMethodInfo
instance (signature ~ (Double -> Gtk.Enums.Unit -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetRightMarginMethodInfo a signature where
    overloadedMethod = printCompositorSetRightMargin

instance O.OverloadedMethodInfo PrintCompositorSetRightMarginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetRightMargin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetRightMargin"
        })


#endif

-- method PrintCompositor::set_tab_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "width of tab in characters."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_tab_width" gtk_source_print_compositor_set_tab_width :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    Word32 ->                               -- width : TBasicType TUInt
    IO ()

-- | Sets the width of tabulation in characters for printed text.
-- 
-- This function cannot be called anymore after the first call to the
-- [method/@printCompositor@/.paginate] function.
printCompositorSetTabWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Word32
    -- ^ /@width@/: width of tab in characters.
    -> m ()
printCompositorSetTabWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Word32 -> m ()
printCompositorSetTabWidth a
compositor Word32
width = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    Ptr PrintCompositor -> Word32 -> IO ()
gtk_source_print_compositor_set_tab_width Ptr PrintCompositor
compositor' Word32
width
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetTabWidthMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetTabWidthMethodInfo a signature where
    overloadedMethod = printCompositorSetTabWidth

instance O.OverloadedMethodInfo PrintCompositorSetTabWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetTabWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetTabWidth"
        })


#endif

-- method PrintCompositor::set_top_margin
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "margin"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new top margin in units of @unit"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "unit"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Unit" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the units for @margin"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_top_margin" gtk_source_print_compositor_set_top_margin :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CDouble ->                              -- margin : TBasicType TDouble
    CUInt ->                                -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"})
    IO ()

-- | Sets the top margin used by /@compositor@/.
printCompositorSetTopMargin ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Double
    -- ^ /@margin@/: the new top margin in units of /@unit@/
    -> Gtk.Enums.Unit
    -- ^ /@unit@/: the units for /@margin@/
    -> m ()
printCompositorSetTopMargin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> Double -> Unit -> m ()
printCompositorSetTopMargin a
compositor Double
margin Unit
unit = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    let margin' :: CDouble
margin' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
margin
    let unit' :: CUInt
unit' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Unit -> Int) -> Unit -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unit -> Int
forall a. Enum a => a -> Int
fromEnum) Unit
unit
    Ptr PrintCompositor -> CDouble -> CUInt -> IO ()
gtk_source_print_compositor_set_top_margin Ptr PrintCompositor
compositor' CDouble
margin' CUInt
unit'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetTopMarginMethodInfo
instance (signature ~ (Double -> Gtk.Enums.Unit -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetTopMarginMethodInfo a signature where
    overloadedMethod = printCompositorSetTopMargin

instance O.OverloadedMethodInfo PrintCompositorSetTopMarginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetTopMargin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetTopMargin"
        })


#endif

-- method PrintCompositor::set_wrap_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "compositor"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "PrintCompositor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourcePrintCompositor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "wrap_mode"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WrapMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWrapMode." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_print_compositor_set_wrap_mode" gtk_source_print_compositor_set_wrap_mode :: 
    Ptr PrintCompositor ->                  -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})
    CUInt ->                                -- wrap_mode : TInterface (Name {namespace = "Gtk", name = "WrapMode"})
    IO ()

-- | Sets the line wrapping mode for the printed text.
-- 
-- This function cannot be called anymore after the first call to the
-- [method/@printCompositor@/.paginate] function.
printCompositorSetWrapMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> Gtk.Enums.WrapMode
    -- ^ /@wrapMode@/: a t'GI.Gtk.Enums.WrapMode'.
    -> m ()
printCompositorSetWrapMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPrintCompositor a) =>
a -> WrapMode -> m ()
printCompositorSetWrapMode a
compositor WrapMode
wrapMode = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PrintCompositor
compositor' <- a -> IO (Ptr PrintCompositor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
compositor
    let wrapMode' :: CUInt
wrapMode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (WrapMode -> Int) -> WrapMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WrapMode -> Int
forall a. Enum a => a -> Int
fromEnum) WrapMode
wrapMode
    Ptr PrintCompositor -> CUInt -> IO ()
gtk_source_print_compositor_set_wrap_mode Ptr PrintCompositor
compositor' CUInt
wrapMode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetWrapModeMethodInfo
instance (signature ~ (Gtk.Enums.WrapMode -> m ()), MonadIO m, IsPrintCompositor a) => O.OverloadedMethod PrintCompositorSetWrapModeMethodInfo a signature where
    overloadedMethod = printCompositorSetWrapMode

instance O.OverloadedMethodInfo PrintCompositorSetWrapModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.PrintCompositor.printCompositorSetWrapMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-PrintCompositor.html#v:printCompositorSetWrapMode"
        })


#endif