{-# LANGUAGE TypeApplications #-}


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

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

module GI.GtkSource.Objects.PrintCompositor
    ( 

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


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

#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              ,


-- ** 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 'GI.Pango.Functions.fontDescriptionFromString'
-- 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 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/

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


-- ** buffer #attr:buffer#
-- | The GtkSourceBuffer object to print.
-- 
-- /Since: 2.2/

#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 'GI.Pango.Functions.fontDescriptionFromString'
-- 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 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/

#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 'GI.Pango.Functions.fontDescriptionFromString'
-- 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 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/

#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 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/

#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 'GI.Pango.Functions.fontDescriptionFromString'
-- 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 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/

#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.
-- 
-- /Since: 2.2/

#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 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/

#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 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/

#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 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/

#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 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/

#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 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/

#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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import 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 {-# 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 (ManagedPtr PrintCompositor)
    deriving (PrintCompositor -> PrintCompositor -> Bool
(PrintCompositor -> PrintCompositor -> Bool)
-> (PrintCompositor -> PrintCompositor -> Bool)
-> Eq PrintCompositor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintCompositor -> PrintCompositor -> Bool
$c/= :: PrintCompositor -> PrintCompositor -> Bool
== :: PrintCompositor -> PrintCompositor -> Bool
$c== :: PrintCompositor -> PrintCompositor -> Bool
Eq)
foreign import ccall "gtk_source_print_compositor_get_type"
    c_gtk_source_print_compositor_get_type :: IO GType

instance GObject PrintCompositor where
    gobjectType :: IO GType
gobjectType = IO GType
c_gtk_source_print_compositor_get_type
    

-- | Convert 'PrintCompositor' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue PrintCompositor where
    toGValue :: PrintCompositor -> IO GValue
toGValue o :: PrintCompositor
o = do
        GType
gtype <- IO GType
c_gtk_source_print_compositor_get_type
        PrintCompositor -> (Ptr PrintCompositor -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr PrintCompositor
o (GType
-> (GValue -> Ptr PrintCompositor -> IO ())
-> Ptr PrintCompositor
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr PrintCompositor -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO PrintCompositor
fromGValue gv :: GValue
gv = do
        Ptr PrintCompositor
ptr <- GValue -> IO (Ptr PrintCompositor)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr PrintCompositor)
        (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
        
    

-- | Type class for types which can be safely cast to `PrintCompositor`, for instance with `toPrintCompositor`.
class (GObject o, O.IsDescendantOf PrintCompositor o) => IsPrintCompositor o
instance (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 :: (MonadIO m, IsPrintCompositor o) => o -> m PrintCompositor
toPrintCompositor :: o -> m PrintCompositor
toPrintCompositor = IO PrintCompositor -> m PrintCompositor
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr PrintCompositor -> PrintCompositor
PrintCompositor

-- | A convenience alias for `Nothing` :: `Maybe` `PrintCompositor`.
noPrintCompositor :: Maybe PrintCompositor
noPrintCompositor :: Maybe PrintCompositor
noPrintCompositor = Maybe PrintCompositor
forall a. Maybe a
Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolvePrintCompositorMethod (t :: Symbol) (o :: *) :: * 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 "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.MethodInfo 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

#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 :: o -> m (Maybe Text)
getPrintCompositorBodyFontName obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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 "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 :: o -> Text -> m ()
setPrintCompositorBodyFontName obj :: o
obj val :: Text
val = IO () -> m ()
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 "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) => T.Text -> IO (GValueConstruct o)
constructPrintCompositorBodyFontName :: Text -> IO (GValueConstruct o)
constructPrintCompositorBodyFontName val :: Text
val = String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString "body-font-name" (Text -> Maybe Text
forall a. a -> Maybe a
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
#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 :: o -> m Buffer
getPrintCompositorBuffer obj :: o
obj = IO Buffer -> m Buffer
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
$ Text -> IO (Maybe Buffer) -> IO Buffer
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing "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 "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, GtkSource.Buffer.IsBuffer a) => a -> IO (GValueConstruct o)
constructPrintCompositorBuffer :: a -> IO (GValueConstruct o)
constructPrintCompositorBuffer val :: a
val = String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject "buffer" (a -> Maybe a
forall a. a -> Maybe a
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
#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 :: o -> m (Maybe Text)
getPrintCompositorFooterFontName obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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 "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 :: o -> Text -> m ()
setPrintCompositorFooterFontName obj :: o
obj val :: Text
val = IO () -> m ()
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 "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) => T.Text -> IO (GValueConstruct o)
constructPrintCompositorFooterFontName :: Text -> IO (GValueConstruct o)
constructPrintCompositorFooterFontName val :: Text
val = String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString "footer-font-name" (Text -> Maybe Text
forall a. a -> Maybe a
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 :: o -> m ()
clearPrintCompositorFooterFontName obj :: o
obj = IO () -> m ()
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 "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
#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 :: o -> m (Maybe Text)
getPrintCompositorHeaderFontName obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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 "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 :: o -> Text -> m ()
setPrintCompositorHeaderFontName obj :: o
obj val :: Text
val = IO () -> m ()
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 "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) => T.Text -> IO (GValueConstruct o)
constructPrintCompositorHeaderFontName :: Text -> IO (GValueConstruct o)
constructPrintCompositorHeaderFontName val :: Text
val = String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString "header-font-name" (Text -> Maybe Text
forall a. a -> Maybe a
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 :: o -> m ()
clearPrintCompositorHeaderFontName obj :: o
obj = IO () -> m ()
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 "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
#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 :: o -> m Bool
getPrintCompositorHighlightSyntax obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "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 :: o -> Bool -> m ()
setPrintCompositorHighlightSyntax obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj "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) => Bool -> IO (GValueConstruct o)
constructPrintCompositorHighlightSyntax :: Bool -> IO (GValueConstruct o)
constructPrintCompositorHighlightSyntax val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "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
#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 :: o -> m (Maybe Text)
getPrintCompositorLineNumbersFontName obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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 "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 :: o -> Text -> m ()
setPrintCompositorLineNumbersFontName obj :: o
obj val :: Text
val = IO () -> m ()
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 "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) => T.Text -> IO (GValueConstruct o)
constructPrintCompositorLineNumbersFontName :: Text -> IO (GValueConstruct o)
constructPrintCompositorLineNumbersFontName val :: Text
val = String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString "line-numbers-font-name" (Text -> Maybe Text
forall a. a -> Maybe a
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 :: o -> m ()
clearPrintCompositorLineNumbersFontName obj :: o
obj = IO () -> m ()
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 "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
#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 :: o -> m Int32
getPrintCompositorNPages obj :: o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj "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
#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 :: o -> m Bool
getPrintCompositorPrintFooter obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "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 :: o -> Bool -> m ()
setPrintCompositorPrintFooter obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj "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) => Bool -> IO (GValueConstruct o)
constructPrintCompositorPrintFooter :: Bool -> IO (GValueConstruct o)
constructPrintCompositorPrintFooter val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "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
#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 :: o -> m Bool
getPrintCompositorPrintHeader obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "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 :: o -> Bool -> m ()
setPrintCompositorPrintHeader obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj "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) => Bool -> IO (GValueConstruct o)
constructPrintCompositorPrintHeader :: Bool -> IO (GValueConstruct o)
constructPrintCompositorPrintHeader val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "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
#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 :: o -> m Word32
getPrintCompositorPrintLineNumbers obj :: o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj "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 :: o -> Word32 -> m ()
setPrintCompositorPrintLineNumbers obj :: o
obj val :: Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj "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) => Word32 -> IO (GValueConstruct o)
constructPrintCompositorPrintLineNumbers :: Word32 -> IO (GValueConstruct o)
constructPrintCompositorPrintLineNumbers val :: Word32
val = String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 "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
#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 :: o -> m Word32
getPrintCompositorTabWidth obj :: o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj "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 :: o -> Word32 -> m ()
setPrintCompositorTabWidth obj :: o
obj val :: Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj "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) => Word32 -> IO (GValueConstruct o)
constructPrintCompositorTabWidth :: Word32 -> IO (GValueConstruct o)
constructPrintCompositorTabWidth val :: Word32
val = String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 "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
#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 :: o -> m WrapMode
getPrintCompositorWrapMode obj :: o
obj = IO WrapMode -> m WrapMode
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
$ o -> String -> IO WrapMode
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj "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 :: o -> WrapMode -> m ()
setPrintCompositorWrapMode obj :: o
obj val :: WrapMode
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> WrapMode -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj "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) => Gtk.Enums.WrapMode -> IO (GValueConstruct o)
constructPrintCompositorWrapMode :: WrapMode -> IO (GValueConstruct o)
constructPrintCompositorWrapMode val :: WrapMode
val = String -> WrapMode -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum "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
#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, *)])
#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, *)])

#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
--           , 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@/.
-- 
-- /Since: 2.2/
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 :: a -> m PrintCompositor
printCompositorNew buffer :: a
buffer = IO PrintCompositor -> m PrintCompositor
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 "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 (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
--           , 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
-- t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/tab-width/@, t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/highlight-syntax/@,
-- t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/wrap-mode/@, t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/body-font-name/@ and
-- t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/print-line-numbers/@.
-- 
-- /Since: 2.2/
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 :: a -> m PrintCompositor
printCompositorNewFromView view :: a
view = IO PrintCompositor -> m PrintCompositor
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 "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 (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
--           , 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
--           , 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
--           , 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 t'GI.Gtk.Objects.PrintOperation.PrintOperation'::@/draw_page/@ signal
-- as shown in the following example:
-- 
-- \<informalexample>\<programlisting>
-- \/\/ Signal handler for the GtkPrintOperation[draw_page](#signal: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);
-- }
-- \<\/programlisting>\<\/informalexample>
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 :: a -> b -> Int32 -> m ()
printCompositorDrawPage compositor :: a
compositor context :: b
context pageNr :: Int32
pageNr = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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.MethodInfo PrintCompositorDrawPageMethodInfo a signature where
    overloadedMethod = 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
--           , 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'.
-- 
-- /Since: 2.2/
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 :: a -> m Text
printCompositorGetBodyFontName compositor :: a
compositor = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 "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 (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.MethodInfo PrintCompositorGetBodyFontNameMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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@/.
-- 
-- /Since: 2.2/
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 :: a -> Unit -> m Double
printCompositorGetBottomMargin compositor :: a
compositor unit :: Unit
unit = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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.MethodInfo PrintCompositorGetBottomMarginMethodInfo a signature where
    overloadedMethod = 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
--           , 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 t'GI.GtkSource.Objects.Buffer.Buffer' associated with the compositor. The returned
-- object reference is owned by the compositor object and
-- should not be unreferenced.
-- 
-- /Since: 2.2/
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 :: a -> m Buffer
printCompositorGetBuffer compositor :: a
compositor = IO Buffer -> m Buffer
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 "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 (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.MethodInfo PrintCompositorGetBufferMethodInfo a signature where
    overloadedMethod = 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
--           , 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'.
-- 
-- /Since: 2.2/
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 :: a -> m Text
printCompositorGetFooterFontName compositor :: a
compositor = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 "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 (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.MethodInfo PrintCompositorGetFooterFontNameMethodInfo a signature where
    overloadedMethod = 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
--           , 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'.
-- 
-- /Since: 2.2/
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 :: a -> m Text
printCompositorGetHeaderFontName compositor :: a
compositor = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 "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 (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.MethodInfo PrintCompositorGetHeaderFontNameMethodInfo a signature where
    overloadedMethod = 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
--           , 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.
-- 
-- /Since: 2.2/
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 :: a -> m Bool
printCompositorGetHighlightSyntax compositor :: a
compositor = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    Bool -> IO Bool
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.MethodInfo PrintCompositorGetHighlightSyntaxMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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@/.
-- 
-- /Since: 2.2/
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 :: a -> Unit -> m Double
printCompositorGetLeftMargin compositor :: a
compositor unit :: Unit
unit = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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.MethodInfo PrintCompositorGetLeftMarginMethodInfo a signature where
    overloadedMethod = 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
--           , 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'.
-- 
-- /Since: 2.2/
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 :: a -> m Text
printCompositorGetLineNumbersFontName compositor :: a
compositor = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 "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 (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.MethodInfo PrintCompositorGetLineNumbersFontNameMethodInfo a signature where
    overloadedMethod = 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
--           , 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.
-- 
-- /Since: 2.2/
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 :: a -> m Int32
printCompositorGetNPages compositor :: a
compositor = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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.MethodInfo PrintCompositorGetNPagesMethodInfo a signature where
    overloadedMethod = 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
--           , 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.
-- 
-- /Since: 2.2/
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 :: a -> m Double
printCompositorGetPaginationProgress compositor :: a
compositor = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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.MethodInfo PrintCompositorGetPaginationProgressMethodInfo a signature where
    overloadedMethod = 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
--           , 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'
-- \<emphasis>and\<\/emphasis> some format strings have been specified
-- with 'GI.GtkSource.Objects.PrintCompositor.printCompositorSetFooterFormat'.
-- 
-- /Since: 2.2/
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 :: a -> m Bool
printCompositorGetPrintFooter compositor :: a
compositor = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    Bool -> IO Bool
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.MethodInfo PrintCompositorGetPrintFooterMethodInfo a signature where
    overloadedMethod = 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
--           , 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'
-- \<emphasis>and\<\/emphasis> some format strings have been specified
-- with 'GI.GtkSource.Objects.PrintCompositor.printCompositorSetHeaderFormat'.
-- 
-- /Since: 2.2/
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 :: a -> m Bool
printCompositorGetPrintHeader compositor :: a
compositor = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
compositor
    Bool -> IO Bool
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.MethodInfo PrintCompositorGetPrintHeaderMethodInfo a signature where
    overloadedMethod = 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
--           , 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).
-- 
-- /Since: 2.2/
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 :: a -> m Word32
printCompositorGetPrintLineNumbers compositor :: a
compositor = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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.MethodInfo PrintCompositorGetPrintLineNumbersMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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@/.
-- 
-- /Since: 2.2/
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 :: a -> Unit -> m Double
printCompositorGetRightMargin compositor :: a
compositor unit :: Unit
unit = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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.MethodInfo PrintCompositorGetRightMarginMethodInfo a signature where
    overloadedMethod = 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
--           , 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.
-- 
-- /Since: 2.2/
printCompositorGetTabWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) =>
    a
    -- ^ /@compositor@/: a t'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'.
    -> m Word32
    -- ^ __Returns:__ width of tab.
printCompositorGetTabWidth :: a -> m Word32
printCompositorGetTabWidth compositor :: a
compositor = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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.MethodInfo PrintCompositorGetTabWidthMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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@/.
-- 
-- /Since: 2.2/
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 :: a -> Unit -> m Double
printCompositorGetTopMargin compositor :: a
compositor unit :: Unit
unit = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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.MethodInfo PrintCompositorGetTopMarginMethodInfo a signature where
    overloadedMethod = 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
--           , 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.
-- 
-- /Since: 2.2/
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 :: a -> m WrapMode
printCompositorGetWrapMode compositor :: a
compositor = IO WrapMode -> m WrapMode
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 (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.MethodInfo PrintCompositorGetWrapModeMethodInfo a signature where
    overloadedMethod = printCompositorGetWrapMode

#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
--           , 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
--           , 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 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' is invoked, a chunk of the document
-- is paginated. To paginate the entire document, 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate'
-- 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 [paginate]("GI.Gtk.Objects.PrintOperation#signal:paginate") signal,
-- as shown in the following example:
-- 
-- \<informalexample>\<programlisting>
-- \/\/ Signal handler for the GtkPrintOperation[paginate](#signal: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;
-- }
-- \<\/programlisting>\<\/informalexample>
-- 
-- If you don\'t need to do pagination in chunks, you can simply do it all in the
-- [beginPrint]("GI.Gtk.Objects.PrintOperation#signal:beginPrint") handler, and set the number of pages from there, like
-- in the following example:
-- 
-- \<informalexample>\<programlisting>
-- \/\/ Signal handler for the GtkPrintOperation[beginPrint](#signal:beginPrint) 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);
-- }
-- \<\/programlisting>\<\/informalexample>
-- 
-- /Since: 2.2/
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 :: a -> b -> m Bool
printCompositorPaginate compositor :: a
compositor context :: b
context = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
/= 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 (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.MethodInfo PrintCompositorPaginateMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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 'GI.Pango.Functions.fontDescriptionFromString'
-- for a description of the format of the string representation.
-- 
-- This function cannot be called anymore after the first call to the
-- 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/
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 :: a -> Text -> m ()
printCompositorSetBodyFontName compositor :: a
compositor fontName :: Text
fontName = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetBodyFontNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetBodyFontNameMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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
--           , 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@/.
-- 
-- /Since: 2.2/
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 :: a -> Double -> Unit -> m ()
printCompositorSetBottomMargin compositor :: a
compositor margin :: Double
margin unit :: Unit
unit = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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.MethodInfo PrintCompositorSetBottomMarginMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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 'GI.Pango.Functions.fontDescriptionFromString'
-- for a description of the format of the string representation.
-- 
-- This function cannot be called anymore after the first call to the
-- 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/
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 :: a -> Maybe Text -> m ()
printCompositorSetFooterFontName compositor :: a
compositor fontName :: Maybe Text
fontName = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
        Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just jFontName :: Text
jFontName -> do
            CString
jFontName' <- Text -> IO CString
textToCString Text
jFontName
            CString -> IO CString
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 (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.MethodInfo PrintCompositorSetFooterFontNameMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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
--           , 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
--           , 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
--           , 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 'GI.GtkSource.Objects.PrintCompositor.printCompositorSetHeaderFormat' for more information
-- about the parameters.
-- 
-- /Since: 2.2/
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 :: a -> Bool -> Maybe Text -> Maybe Text -> Maybe Text -> m ()
printCompositorSetFooterFormat compositor :: a
compositor separator :: Bool
separator left :: Maybe Text
left center :: Maybe Text
center right :: Maybe Text
right = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
separator
    CString
maybeLeft <- case Maybe Text
left of
        Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just jLeft :: Text
jLeft -> do
            CString
jLeft' <- Text -> IO CString
textToCString Text
jLeft
            CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jLeft'
    CString
maybeCenter <- case Maybe Text
center of
        Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just jCenter :: Text
jCenter -> do
            CString
jCenter' <- Text -> IO CString
textToCString Text
jCenter
            CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jCenter'
    CString
maybeRight <- case Maybe Text
right of
        Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just jRight :: Text
jRight -> do
            CString
jRight' <- Text -> IO CString
textToCString Text
jRight
            CString -> IO CString
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 (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.MethodInfo PrintCompositorSetFooterFormatMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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 'GI.Pango.Functions.fontDescriptionFromString'
-- for a description of the format of the string representation.
-- 
-- This function cannot be called anymore after the first call to the
-- 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/
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 :: a -> Maybe Text -> m ()
printCompositorSetHeaderFontName compositor :: a
compositor fontName :: Maybe Text
fontName = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
        Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just jFontName :: Text
jFontName -> do
            CString
jFontName' <- Text -> IO CString
textToCString Text
jFontName
            CString -> IO CString
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 (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.MethodInfo PrintCompositorSetHeaderFontNameMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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
--           , 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
--           , 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
--           , 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 'GI.GtkSource.Objects.PrintCompositor.printCompositorSetPrintHeader'.
-- 
-- This function cannot be called anymore after the first call to the
-- 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/
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 :: a -> Bool -> Maybe Text -> Maybe Text -> Maybe Text -> m ()
printCompositorSetHeaderFormat compositor :: a
compositor separator :: Bool
separator left :: Maybe Text
left center :: Maybe Text
center right :: Maybe Text
right = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
separator
    CString
maybeLeft <- case Maybe Text
left of
        Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just jLeft :: Text
jLeft -> do
            CString
jLeft' <- Text -> IO CString
textToCString Text
jLeft
            CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jLeft'
    CString
maybeCenter <- case Maybe Text
center of
        Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just jCenter :: Text
jCenter -> do
            CString
jCenter' <- Text -> IO CString
textToCString Text
jCenter
            CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jCenter'
    CString
maybeRight <- case Maybe Text
right of
        Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just jRight :: Text
jRight -> do
            CString
jRight' <- Text -> IO CString
textToCString Text
jRight
            CString -> IO CString
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 (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.MethodInfo PrintCompositorSetHeaderFormatMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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
-- 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/
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 :: a -> Bool -> m ()
printCompositorSetHighlightSyntax compositor :: a
compositor highlight :: Bool
highlight = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetHighlightSyntaxMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetHighlightSyntaxMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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
--           , 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@/.
-- 
-- /Since: 2.2/
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 :: a -> Double -> Unit -> m ()
printCompositorSetLeftMargin compositor :: a
compositor margin :: Double
margin unit :: Unit
unit = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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.MethodInfo PrintCompositorSetLeftMarginMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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 'GI.Pango.Functions.fontDescriptionFromString'
-- for a description of the format of the string representation.
-- 
-- This function cannot be called anymore after the first call to the
-- 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/
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 :: a -> Maybe Text -> m ()
printCompositorSetLineNumbersFontName compositor :: a
compositor fontName :: Maybe Text
fontName = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
        Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just jFontName :: Text
jFontName -> do
            CString
jFontName' <- Text -> IO CString
textToCString Text
jFontName
            CString -> IO CString
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 (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.MethodInfo PrintCompositorSetLineNumbersFontNameMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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
-- 'GI.GtkSource.Objects.PrintCompositor.printCompositorSetFooterFormat'.
-- 
-- 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
-- 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/
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 :: a -> Bool -> m ()
printCompositorSetPrintFooter compositor :: a
compositor print :: Bool
print = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetPrintFooterMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetPrintFooterMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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
-- 'GI.GtkSource.Objects.PrintCompositor.printCompositorSetHeaderFormat'.
-- 
-- 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
-- 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/
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 :: a -> Bool -> m ()
printCompositorSetPrintHeader compositor :: a
compositor print :: Bool
print = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetPrintHeaderMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetPrintHeaderMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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
-- 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/
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 :: a -> Word32 -> m ()
printCompositorSetPrintLineNumbers compositor :: a
compositor interval :: Word32
interval = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetPrintLineNumbersMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetPrintLineNumbersMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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
--           , 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@/.
-- 
-- /Since: 2.2/
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 :: a -> Double -> Unit -> m ()
printCompositorSetRightMargin compositor :: a
compositor margin :: Double
margin unit :: Unit
unit = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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.MethodInfo PrintCompositorSetRightMarginMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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
-- 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/
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 :: a -> Word32 -> m ()
printCompositorSetTabWidth compositor :: a
compositor width :: Word32
width = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PrintCompositorSetTabWidthMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetTabWidthMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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
--           , 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@/.
-- 
-- /Since: 2.2/
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 :: a -> Double -> Unit -> m ()
printCompositorSetTopMargin compositor :: a
compositor margin :: Double
margin unit :: Unit
unit = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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.MethodInfo PrintCompositorSetTopMarginMethodInfo a signature where
    overloadedMethod = 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
--           , 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
--           , 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
-- 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function.
-- 
-- /Since: 2.2/
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 :: a -> WrapMode -> m ()
printCompositorSetWrapMode compositor :: a
compositor wrapMode :: WrapMode
wrapMode = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 (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.MethodInfo PrintCompositorSetWrapModeMethodInfo a signature where
    overloadedMethod = printCompositorSetWrapMode

#endif