gi-gtksource-3.0.18: GI/GtkSource/Objects/PrintCompositor.hs

{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

/No description available in the introspection data./
-}

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

module GI.GtkSource.Objects.PrintCompositor
    ( 

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


 -- * Methods
-- ** drawPage #method:drawPage#

#if ENABLE_OVERLOADING
    PrintCompositorDrawPageMethodInfo       ,
#endif
    printCompositorDrawPage                 ,


-- ** getBodyFontName #method:getBodyFontName#

#if ENABLE_OVERLOADING
    PrintCompositorGetBodyFontNameMethodInfo,
#endif
    printCompositorGetBodyFontName          ,


-- ** getBottomMargin #method:getBottomMargin#

#if ENABLE_OVERLOADING
    PrintCompositorGetBottomMarginMethodInfo,
#endif
    printCompositorGetBottomMargin          ,


-- ** getBuffer #method:getBuffer#

#if ENABLE_OVERLOADING
    PrintCompositorGetBufferMethodInfo      ,
#endif
    printCompositorGetBuffer                ,


-- ** getFooterFontName #method:getFooterFontName#

#if ENABLE_OVERLOADING
    PrintCompositorGetFooterFontNameMethodInfo,
#endif
    printCompositorGetFooterFontName        ,


-- ** getHeaderFontName #method:getHeaderFontName#

#if ENABLE_OVERLOADING
    PrintCompositorGetHeaderFontNameMethodInfo,
#endif
    printCompositorGetHeaderFontName        ,


-- ** getHighlightSyntax #method:getHighlightSyntax#

#if ENABLE_OVERLOADING
    PrintCompositorGetHighlightSyntaxMethodInfo,
#endif
    printCompositorGetHighlightSyntax       ,


-- ** getLeftMargin #method:getLeftMargin#

#if ENABLE_OVERLOADING
    PrintCompositorGetLeftMarginMethodInfo  ,
#endif
    printCompositorGetLeftMargin            ,


-- ** getLineNumbersFontName #method:getLineNumbersFontName#

#if ENABLE_OVERLOADING
    PrintCompositorGetLineNumbersFontNameMethodInfo,
#endif
    printCompositorGetLineNumbersFontName   ,


-- ** getNPages #method:getNPages#

#if ENABLE_OVERLOADING
    PrintCompositorGetNPagesMethodInfo      ,
#endif
    printCompositorGetNPages                ,


-- ** getPaginationProgress #method:getPaginationProgress#

#if ENABLE_OVERLOADING
    PrintCompositorGetPaginationProgressMethodInfo,
#endif
    printCompositorGetPaginationProgress    ,


-- ** getPrintFooter #method:getPrintFooter#

#if ENABLE_OVERLOADING
    PrintCompositorGetPrintFooterMethodInfo ,
#endif
    printCompositorGetPrintFooter           ,


-- ** getPrintHeader #method:getPrintHeader#

#if ENABLE_OVERLOADING
    PrintCompositorGetPrintHeaderMethodInfo ,
#endif
    printCompositorGetPrintHeader           ,


-- ** getPrintLineNumbers #method:getPrintLineNumbers#

#if ENABLE_OVERLOADING
    PrintCompositorGetPrintLineNumbersMethodInfo,
#endif
    printCompositorGetPrintLineNumbers      ,


-- ** getRightMargin #method:getRightMargin#

#if ENABLE_OVERLOADING
    PrintCompositorGetRightMarginMethodInfo ,
#endif
    printCompositorGetRightMargin           ,


-- ** getTabWidth #method:getTabWidth#

#if ENABLE_OVERLOADING
    PrintCompositorGetTabWidthMethodInfo    ,
#endif
    printCompositorGetTabWidth              ,


-- ** getTopMargin #method:getTopMargin#

#if ENABLE_OVERLOADING
    PrintCompositorGetTopMarginMethodInfo   ,
#endif
    printCompositorGetTopMargin             ,


-- ** getWrapMode #method:getWrapMode#

#if ENABLE_OVERLOADING
    PrintCompositorGetWrapModeMethodInfo    ,
#endif
    printCompositorGetWrapMode              ,


-- ** new #method:new#

    printCompositorNew                      ,


-- ** newFromView #method:newFromView#

    printCompositorNewFromView              ,


-- ** paginate #method:paginate#

#if ENABLE_OVERLOADING
    PrintCompositorPaginateMethodInfo       ,
#endif
    printCompositorPaginate                 ,


-- ** setBodyFontName #method:setBodyFontName#

#if ENABLE_OVERLOADING
    PrintCompositorSetBodyFontNameMethodInfo,
#endif
    printCompositorSetBodyFontName          ,


-- ** setBottomMargin #method:setBottomMargin#

#if ENABLE_OVERLOADING
    PrintCompositorSetBottomMarginMethodInfo,
#endif
    printCompositorSetBottomMargin          ,


-- ** setFooterFontName #method:setFooterFontName#

#if ENABLE_OVERLOADING
    PrintCompositorSetFooterFontNameMethodInfo,
#endif
    printCompositorSetFooterFontName        ,


-- ** setFooterFormat #method:setFooterFormat#

#if ENABLE_OVERLOADING
    PrintCompositorSetFooterFormatMethodInfo,
#endif
    printCompositorSetFooterFormat          ,


-- ** setHeaderFontName #method:setHeaderFontName#

#if ENABLE_OVERLOADING
    PrintCompositorSetHeaderFontNameMethodInfo,
#endif
    printCompositorSetHeaderFontName        ,


-- ** setHeaderFormat #method:setHeaderFormat#

#if ENABLE_OVERLOADING
    PrintCompositorSetHeaderFormatMethodInfo,
#endif
    printCompositorSetHeaderFormat          ,


-- ** setHighlightSyntax #method:setHighlightSyntax#

#if ENABLE_OVERLOADING
    PrintCompositorSetHighlightSyntaxMethodInfo,
#endif
    printCompositorSetHighlightSyntax       ,


-- ** setLeftMargin #method:setLeftMargin#

#if ENABLE_OVERLOADING
    PrintCompositorSetLeftMarginMethodInfo  ,
#endif
    printCompositorSetLeftMargin            ,


-- ** setLineNumbersFontName #method:setLineNumbersFontName#

#if ENABLE_OVERLOADING
    PrintCompositorSetLineNumbersFontNameMethodInfo,
#endif
    printCompositorSetLineNumbersFontName   ,


-- ** setPrintFooter #method:setPrintFooter#

#if ENABLE_OVERLOADING
    PrintCompositorSetPrintFooterMethodInfo ,
#endif
    printCompositorSetPrintFooter           ,


-- ** setPrintHeader #method:setPrintHeader#

#if ENABLE_OVERLOADING
    PrintCompositorSetPrintHeaderMethodInfo ,
#endif
    printCompositorSetPrintHeader           ,


-- ** setPrintLineNumbers #method:setPrintLineNumbers#

#if ENABLE_OVERLOADING
    PrintCompositorSetPrintLineNumbersMethodInfo,
#endif
    printCompositorSetPrintLineNumbers      ,


-- ** setRightMargin #method:setRightMargin#

#if ENABLE_OVERLOADING
    PrintCompositorSetRightMarginMethodInfo ,
#endif
    printCompositorSetRightMargin           ,


-- ** setTabWidth #method:setTabWidth#

#if ENABLE_OVERLOADING
    PrintCompositorSetTabWidthMethodInfo    ,
#endif
    printCompositorSetTabWidth              ,


-- ** setTopMargin #method:setTopMargin#

#if ENABLE_OVERLOADING
    PrintCompositorSetTopMarginMethodInfo   ,
#endif
    printCompositorSetTopMargin             ,


-- ** setWrapMode #method:setWrapMode#

#if 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 ENABLE_OVERLOADING
    PrintCompositorBodyFontNamePropertyInfo ,
#endif
    constructPrintCompositorBodyFontName    ,
    getPrintCompositorBodyFontName          ,
#if ENABLE_OVERLOADING
    printCompositorBodyFontName             ,
#endif
    setPrintCompositorBodyFontName          ,


-- ** buffer #attr:buffer#
{- | The GtkSourceBuffer object to print.

/Since: 2.2/
-}
#if ENABLE_OVERLOADING
    PrintCompositorBufferPropertyInfo       ,
#endif
    constructPrintCompositorBuffer          ,
    getPrintCompositorBuffer                ,
#if 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 ENABLE_OVERLOADING
    PrintCompositorFooterFontNamePropertyInfo,
#endif
    clearPrintCompositorFooterFontName      ,
    constructPrintCompositorFooterFontName  ,
    getPrintCompositorFooterFontName        ,
#if 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 ENABLE_OVERLOADING
    PrintCompositorHeaderFontNamePropertyInfo,
#endif
    clearPrintCompositorHeaderFontName      ,
    constructPrintCompositorHeaderFontName  ,
    getPrintCompositorHeaderFontName        ,
#if 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 ENABLE_OVERLOADING
    PrintCompositorHighlightSyntaxPropertyInfo,
#endif
    constructPrintCompositorHighlightSyntax ,
    getPrintCompositorHighlightSyntax       ,
#if 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 ENABLE_OVERLOADING
    PrintCompositorLineNumbersFontNamePropertyInfo,
#endif
    clearPrintCompositorLineNumbersFontName ,
    constructPrintCompositorLineNumbersFontName,
    getPrintCompositorLineNumbersFontName   ,
#if 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 ENABLE_OVERLOADING
    PrintCompositorNPagesPropertyInfo       ,
#endif
    getPrintCompositorNPages                ,
#if 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 ENABLE_OVERLOADING
    PrintCompositorPrintFooterPropertyInfo  ,
#endif
    constructPrintCompositorPrintFooter     ,
    getPrintCompositorPrintFooter           ,
#if 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 ENABLE_OVERLOADING
    PrintCompositorPrintHeaderPropertyInfo  ,
#endif
    constructPrintCompositorPrintHeader     ,
    getPrintCompositorPrintHeader           ,
#if 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 ENABLE_OVERLOADING
    PrintCompositorPrintLineNumbersPropertyInfo,
#endif
    constructPrintCompositorPrintLineNumbers,
    getPrintCompositorPrintLineNumbers      ,
#if 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 ENABLE_OVERLOADING
    PrintCompositorTabWidthPropertyInfo     ,
#endif
    constructPrintCompositorTabWidth        ,
    getPrintCompositorTabWidth              ,
#if 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 ENABLE_OVERLOADING
    PrintCompositorWrapModePropertyInfo     ,
#endif
    constructPrintCompositorWrapMode        ,
    getPrintCompositorWrapMode              ,
#if 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.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)
foreign import ccall "gtk_source_print_compositor_get_type"
    c_gtk_source_print_compositor_get_type :: IO GType

instance GObject PrintCompositor where
    gobjectType = c_gtk_source_print_compositor_get_type
    

-- | 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 = liftIO . unsafeCastTo PrintCompositor

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

#if 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 "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 (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy 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 obj = liftIO $ B.Properties.getObjectPropertyString 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 obj val = liftIO $ B.Properties.setObjectPropertyString obj "body-font-name" (Just 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 val = B.Properties.constructObjectPropertyString "body-font-name" (Just val)

#if ENABLE_OVERLOADING
data PrintCompositorBodyFontNamePropertyInfo
instance AttrInfo PrintCompositorBodyFontNamePropertyInfo where
    type AttrAllowedOps PrintCompositorBodyFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint PrintCompositorBodyFontNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint PrintCompositorBodyFontNamePropertyInfo = IsPrintCompositor
    type AttrGetType PrintCompositorBodyFontNamePropertyInfo = (Maybe T.Text)
    type AttrLabel PrintCompositorBodyFontNamePropertyInfo = "body-font-name"
    type AttrOrigin PrintCompositorBodyFontNamePropertyInfo = PrintCompositor
    attrGet _ = getPrintCompositorBodyFontName
    attrSet _ = setPrintCompositorBodyFontName
    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 obj = liftIO $ checkUnexpectedNothing "getPrintCompositorBuffer" $ B.Properties.getObjectPropertyObject obj "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 val = B.Properties.constructObjectPropertyObject "buffer" (Just val)

#if ENABLE_OVERLOADING
data PrintCompositorBufferPropertyInfo
instance AttrInfo PrintCompositorBufferPropertyInfo where
    type AttrAllowedOps PrintCompositorBufferPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PrintCompositorBufferPropertyInfo = GtkSource.Buffer.IsBuffer
    type AttrBaseTypeConstraint PrintCompositorBufferPropertyInfo = IsPrintCompositor
    type AttrGetType PrintCompositorBufferPropertyInfo = GtkSource.Buffer.Buffer
    type AttrLabel PrintCompositorBufferPropertyInfo = "buffer"
    type AttrOrigin PrintCompositorBufferPropertyInfo = PrintCompositor
    attrGet _ = getPrintCompositorBuffer
    attrSet _ = undefined
    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 obj = liftIO $ B.Properties.getObjectPropertyString 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 obj val = liftIO $ B.Properties.setObjectPropertyString obj "footer-font-name" (Just 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 val = B.Properties.constructObjectPropertyString "footer-font-name" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyString obj "footer-font-name" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
data PrintCompositorFooterFontNamePropertyInfo
instance AttrInfo PrintCompositorFooterFontNamePropertyInfo where
    type AttrAllowedOps PrintCompositorFooterFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PrintCompositorFooterFontNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint PrintCompositorFooterFontNamePropertyInfo = IsPrintCompositor
    type AttrGetType PrintCompositorFooterFontNamePropertyInfo = (Maybe T.Text)
    type AttrLabel PrintCompositorFooterFontNamePropertyInfo = "footer-font-name"
    type AttrOrigin PrintCompositorFooterFontNamePropertyInfo = PrintCompositor
    attrGet _ = getPrintCompositorFooterFontName
    attrSet _ = setPrintCompositorFooterFontName
    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 obj = liftIO $ B.Properties.getObjectPropertyString 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 obj val = liftIO $ B.Properties.setObjectPropertyString obj "header-font-name" (Just 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 val = B.Properties.constructObjectPropertyString "header-font-name" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyString obj "header-font-name" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
data PrintCompositorHeaderFontNamePropertyInfo
instance AttrInfo PrintCompositorHeaderFontNamePropertyInfo where
    type AttrAllowedOps PrintCompositorHeaderFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PrintCompositorHeaderFontNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint PrintCompositorHeaderFontNamePropertyInfo = IsPrintCompositor
    type AttrGetType PrintCompositorHeaderFontNamePropertyInfo = (Maybe T.Text)
    type AttrLabel PrintCompositorHeaderFontNamePropertyInfo = "header-font-name"
    type AttrOrigin PrintCompositorHeaderFontNamePropertyInfo = PrintCompositor
    attrGet _ = getPrintCompositorHeaderFontName
    attrSet _ = setPrintCompositorHeaderFontName
    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 obj = liftIO $ B.Properties.getObjectPropertyBool 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 obj val = liftIO $ B.Properties.setObjectPropertyBool obj "highlight-syntax" 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 val = B.Properties.constructObjectPropertyBool "highlight-syntax" val

#if ENABLE_OVERLOADING
data PrintCompositorHighlightSyntaxPropertyInfo
instance AttrInfo PrintCompositorHighlightSyntaxPropertyInfo where
    type AttrAllowedOps PrintCompositorHighlightSyntaxPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint PrintCompositorHighlightSyntaxPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint PrintCompositorHighlightSyntaxPropertyInfo = IsPrintCompositor
    type AttrGetType PrintCompositorHighlightSyntaxPropertyInfo = Bool
    type AttrLabel PrintCompositorHighlightSyntaxPropertyInfo = "highlight-syntax"
    type AttrOrigin PrintCompositorHighlightSyntaxPropertyInfo = PrintCompositor
    attrGet _ = getPrintCompositorHighlightSyntax
    attrSet _ = setPrintCompositorHighlightSyntax
    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 obj = liftIO $ B.Properties.getObjectPropertyString 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 obj val = liftIO $ B.Properties.setObjectPropertyString obj "line-numbers-font-name" (Just 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 val = B.Properties.constructObjectPropertyString "line-numbers-font-name" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyString obj "line-numbers-font-name" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
data PrintCompositorLineNumbersFontNamePropertyInfo
instance AttrInfo PrintCompositorLineNumbersFontNamePropertyInfo where
    type AttrAllowedOps PrintCompositorLineNumbersFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PrintCompositorLineNumbersFontNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint PrintCompositorLineNumbersFontNamePropertyInfo = IsPrintCompositor
    type AttrGetType PrintCompositorLineNumbersFontNamePropertyInfo = (Maybe T.Text)
    type AttrLabel PrintCompositorLineNumbersFontNamePropertyInfo = "line-numbers-font-name"
    type AttrOrigin PrintCompositorLineNumbersFontNamePropertyInfo = PrintCompositor
    attrGet _ = getPrintCompositorLineNumbersFontName
    attrSet _ = setPrintCompositorLineNumbersFontName
    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 obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "n-pages"

#if ENABLE_OVERLOADING
data PrintCompositorNPagesPropertyInfo
instance AttrInfo PrintCompositorNPagesPropertyInfo where
    type AttrAllowedOps PrintCompositorNPagesPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint PrintCompositorNPagesPropertyInfo = (~) ()
    type AttrBaseTypeConstraint PrintCompositorNPagesPropertyInfo = IsPrintCompositor
    type AttrGetType PrintCompositorNPagesPropertyInfo = Int32
    type AttrLabel PrintCompositorNPagesPropertyInfo = "n-pages"
    type AttrOrigin PrintCompositorNPagesPropertyInfo = PrintCompositor
    attrGet _ = getPrintCompositorNPages
    attrSet _ = 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 obj = liftIO $ B.Properties.getObjectPropertyBool 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 obj val = liftIO $ B.Properties.setObjectPropertyBool obj "print-footer" 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 val = B.Properties.constructObjectPropertyBool "print-footer" val

#if ENABLE_OVERLOADING
data PrintCompositorPrintFooterPropertyInfo
instance AttrInfo PrintCompositorPrintFooterPropertyInfo where
    type AttrAllowedOps PrintCompositorPrintFooterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint PrintCompositorPrintFooterPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint PrintCompositorPrintFooterPropertyInfo = IsPrintCompositor
    type AttrGetType PrintCompositorPrintFooterPropertyInfo = Bool
    type AttrLabel PrintCompositorPrintFooterPropertyInfo = "print-footer"
    type AttrOrigin PrintCompositorPrintFooterPropertyInfo = PrintCompositor
    attrGet _ = getPrintCompositorPrintFooter
    attrSet _ = setPrintCompositorPrintFooter
    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 obj = liftIO $ B.Properties.getObjectPropertyBool 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 obj val = liftIO $ B.Properties.setObjectPropertyBool obj "print-header" 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 val = B.Properties.constructObjectPropertyBool "print-header" val

#if ENABLE_OVERLOADING
data PrintCompositorPrintHeaderPropertyInfo
instance AttrInfo PrintCompositorPrintHeaderPropertyInfo where
    type AttrAllowedOps PrintCompositorPrintHeaderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint PrintCompositorPrintHeaderPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint PrintCompositorPrintHeaderPropertyInfo = IsPrintCompositor
    type AttrGetType PrintCompositorPrintHeaderPropertyInfo = Bool
    type AttrLabel PrintCompositorPrintHeaderPropertyInfo = "print-header"
    type AttrOrigin PrintCompositorPrintHeaderPropertyInfo = PrintCompositor
    attrGet _ = getPrintCompositorPrintHeader
    attrSet _ = setPrintCompositorPrintHeader
    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 obj = liftIO $ B.Properties.getObjectPropertyUInt32 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 obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "print-line-numbers" 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 val = B.Properties.constructObjectPropertyUInt32 "print-line-numbers" val

#if ENABLE_OVERLOADING
data PrintCompositorPrintLineNumbersPropertyInfo
instance AttrInfo PrintCompositorPrintLineNumbersPropertyInfo where
    type AttrAllowedOps PrintCompositorPrintLineNumbersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint PrintCompositorPrintLineNumbersPropertyInfo = (~) Word32
    type AttrBaseTypeConstraint PrintCompositorPrintLineNumbersPropertyInfo = IsPrintCompositor
    type AttrGetType PrintCompositorPrintLineNumbersPropertyInfo = Word32
    type AttrLabel PrintCompositorPrintLineNumbersPropertyInfo = "print-line-numbers"
    type AttrOrigin PrintCompositorPrintLineNumbersPropertyInfo = PrintCompositor
    attrGet _ = getPrintCompositorPrintLineNumbers
    attrSet _ = setPrintCompositorPrintLineNumbers
    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 obj = liftIO $ B.Properties.getObjectPropertyUInt32 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 obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "tab-width" 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 val = B.Properties.constructObjectPropertyUInt32 "tab-width" val

#if ENABLE_OVERLOADING
data PrintCompositorTabWidthPropertyInfo
instance AttrInfo PrintCompositorTabWidthPropertyInfo where
    type AttrAllowedOps PrintCompositorTabWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint PrintCompositorTabWidthPropertyInfo = (~) Word32
    type AttrBaseTypeConstraint PrintCompositorTabWidthPropertyInfo = IsPrintCompositor
    type AttrGetType PrintCompositorTabWidthPropertyInfo = Word32
    type AttrLabel PrintCompositorTabWidthPropertyInfo = "tab-width"
    type AttrOrigin PrintCompositorTabWidthPropertyInfo = PrintCompositor
    attrGet _ = getPrintCompositorTabWidth
    attrSet _ = setPrintCompositorTabWidth
    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 obj = liftIO $ B.Properties.getObjectPropertyEnum 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 obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "wrap-mode" 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 val = B.Properties.constructObjectPropertyEnum "wrap-mode" val

#if ENABLE_OVERLOADING
data PrintCompositorWrapModePropertyInfo
instance AttrInfo PrintCompositorWrapModePropertyInfo where
    type AttrAllowedOps PrintCompositorWrapModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint PrintCompositorWrapModePropertyInfo = (~) Gtk.Enums.WrapMode
    type AttrBaseTypeConstraint PrintCompositorWrapModePropertyInfo = IsPrintCompositor
    type AttrGetType PrintCompositorWrapModePropertyInfo = Gtk.Enums.WrapMode
    type AttrLabel PrintCompositorWrapModePropertyInfo = "wrap-mode"
    type AttrOrigin PrintCompositorWrapModePropertyInfo = PrintCompositor
    attrGet _ = getPrintCompositorWrapMode
    attrSet _ = setPrintCompositorWrapMode
    attrConstruct _ = constructPrintCompositorWrapMode
    attrClear _ = undefined
#endif

#if 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 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 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 'GI.GtkSource.Objects.Buffer.Buffer' to print. -}
    -> m PrintCompositor
    {- ^ __Returns:__ a new print compositor object. -}
printCompositorNew buffer = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    result <- gtk_source_print_compositor_new buffer'
    checkUnexpectedReturnNULL "printCompositorNew" result
    result' <- (wrapObject PrintCompositor) result
    touchManagedPtr buffer
    return result'

#if 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
'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/tab-width/@, 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/highlight-syntax/@,
'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/wrap-mode/@, 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/body-font-name/@ and
'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/print-line-numbers/@.

/Since: 2.2/
-}
printCompositorNewFromView ::
    (B.CallStack.HasCallStack, MonadIO m, GtkSource.View.IsView a) =>
    a
    {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View' to get configuration from. -}
    -> m PrintCompositor
    {- ^ __Returns:__ a new print compositor object. -}
printCompositorNewFromView view = liftIO $ do
    view' <- unsafeManagedPtrCastPtr view
    result <- gtk_source_print_compositor_new_from_view view'
    checkUnexpectedReturnNULL "printCompositorNewFromView" result
    result' <- (wrapObject PrintCompositor) result
    touchManagedPtr view
    return result'

#if 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 'GI.Gtk.Objects.PrintOperation.PrintOperation'::@/draw_page/@ signal
as shown in the following example:

\<informalexample>\<programlisting>
\/\/ Signal handler for the GtkPrintOperation::draw_page signal

static void
draw_page (GtkPrintOperation *operation,
           GtkPrintContext   *context,
           gint               page_nr,
           gpointer           user_data)
{
    GtkSourcePrintCompositor *compositor;

    compositor = GTK_SOURCE_PRINT_COMPOSITOR (user_data);

    gtk_source_print_compositor_draw_page (compositor,
                                           context,
                                           page_nr);
}
\<\/programlisting>\<\/informalexample>
-}
printCompositorDrawPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a, Gtk.PrintContext.IsPrintContext b) =>
    a
    {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> b
    {- ^ /@context@/: the '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 compositor context pageNr = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    context' <- unsafeManagedPtrCastPtr context
    gtk_source_print_compositor_draw_page compositor' context' pageNr
    touchManagedPtr compositor
    touchManagedPtr context
    return ()

#if 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 '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 compositor = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    result <- gtk_source_print_compositor_get_body_font_name compositor'
    checkUnexpectedReturnNULL "printCompositorGetBodyFontName" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr compositor
    return result'

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Gtk.Enums.Unit
    {- ^ /@unit@/: the unit for the return value. -}
    -> m Double
    {- ^ __Returns:__ the bottom margin. -}
printCompositorGetBottomMargin compositor unit = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    let unit' = (fromIntegral . fromEnum) unit
    result <- gtk_source_print_compositor_get_bottom_margin compositor' unit'
    let result' = realToFrac result
    touchManagedPtr compositor
    return result'

#if 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 '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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> m GtkSource.Buffer.Buffer
    {- ^ __Returns:__ the 'GI.GtkSource.Objects.Buffer.Buffer' associated with the compositor. -}
printCompositorGetBuffer compositor = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    result <- gtk_source_print_compositor_get_buffer compositor'
    checkUnexpectedReturnNULL "printCompositorGetBuffer" result
    result' <- (newObject GtkSource.Buffer.Buffer) result
    touchManagedPtr compositor
    return result'

#if 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 '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 compositor = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    result <- gtk_source_print_compositor_get_footer_font_name compositor'
    checkUnexpectedReturnNULL "printCompositorGetFooterFontName" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr compositor
    return result'

#if 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 '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 compositor = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    result <- gtk_source_print_compositor_get_header_font_name compositor'
    checkUnexpectedReturnNULL "printCompositorGetHeaderFontName" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr compositor
    return result'

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the printed output will be highlighted. -}
printCompositorGetHighlightSyntax compositor = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    result <- gtk_source_print_compositor_get_highlight_syntax compositor'
    let result' = (/= 0) result
    touchManagedPtr compositor
    return result'

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Gtk.Enums.Unit
    {- ^ /@unit@/: the unit for the return value. -}
    -> m Double
    {- ^ __Returns:__ the left margin -}
printCompositorGetLeftMargin compositor unit = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    let unit' = (fromIntegral . fromEnum) unit
    result <- gtk_source_print_compositor_get_left_margin compositor' unit'
    let result' = realToFrac result
    touchManagedPtr compositor
    return result'

#if 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 '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 compositor = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    result <- gtk_source_print_compositor_get_line_numbers_font_name compositor'
    checkUnexpectedReturnNULL "printCompositorGetLineNumbersFontName" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr compositor
    return result'

#if 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 '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 compositor = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    result <- gtk_source_print_compositor_get_n_pages compositor'
    touchManagedPtr compositor
    return result

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> m Double
    {- ^ __Returns:__ a fraction from 0.0 to 1.0 inclusive. -}
printCompositorGetPaginationProgress compositor = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    result <- gtk_source_print_compositor_get_pagination_progress compositor'
    let result' = realToFrac result
    touchManagedPtr compositor
    return result'

#if 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 '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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the footer is set to be printed. -}
printCompositorGetPrintFooter compositor = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    result <- gtk_source_print_compositor_get_print_footer compositor'
    let result' = (/= 0) result
    touchManagedPtr compositor
    return result'

#if 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 '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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the header is set to be printed. -}
printCompositorGetPrintHeader compositor = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    result <- gtk_source_print_compositor_get_print_header compositor'
    let result' = (/= 0) result
    touchManagedPtr compositor
    return result'

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> m Word32
    {- ^ __Returns:__ the interval of printed line numbers. -}
printCompositorGetPrintLineNumbers compositor = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    result <- gtk_source_print_compositor_get_print_line_numbers compositor'
    touchManagedPtr compositor
    return result

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Gtk.Enums.Unit
    {- ^ /@unit@/: the unit for the return value. -}
    -> m Double
    {- ^ __Returns:__ the right margin. -}
printCompositorGetRightMargin compositor unit = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    let unit' = (fromIntegral . fromEnum) unit
    result <- gtk_source_print_compositor_get_right_margin compositor' unit'
    let result' = realToFrac result
    touchManagedPtr compositor
    return result'

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> m Word32
    {- ^ __Returns:__ width of tab. -}
printCompositorGetTabWidth compositor = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    result <- gtk_source_print_compositor_get_tab_width compositor'
    touchManagedPtr compositor
    return result

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Gtk.Enums.Unit
    {- ^ /@unit@/: the unit for the return value. -}
    -> m Double
    {- ^ __Returns:__ the top margin. -}
printCompositorGetTopMargin compositor unit = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    let unit' = (fromIntegral . fromEnum) unit
    result <- gtk_source_print_compositor_get_top_margin compositor' unit'
    let result' = realToFrac result
    touchManagedPtr compositor
    return result'

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> m Gtk.Enums.WrapMode
    {- ^ __Returns:__ the line wrap mode. -}
printCompositorGetWrapMode compositor = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    result <- gtk_source_print_compositor_get_wrap_mode compositor'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr compositor
    return result'

#if 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 'True' if the document has been completely paginated, otherwise it returns 'False'.

This method has been designed to be invoked in the handler of the 'GI.Gtk.Objects.PrintOperation.PrintOperation'::@/paginate/@ signal,
as shown in the following example:

\<informalexample>\<programlisting>
\/\/ Signal handler for the GtkPrintOperation::paginate signal

static gboolean
paginate (GtkPrintOperation *operation,
          GtkPrintContext   *context,
          gpointer           user_data)
{
    GtkSourcePrintCompositor *compositor;

    compositor = GTK_SOURCE_PRINT_COMPOSITOR (user_data);

    if (gtk_source_print_compositor_paginate (compositor, context))
    {
        gint n_pages;

        n_pages = gtk_source_print_compositor_get_n_pages (compositor);
        gtk_print_operation_set_n_pages (operation, n_pages);

        return TRUE;
    }

    return FALSE;
}
\<\/programlisting>\<\/informalexample>

If you don\'t need to do pagination in chunks, you can simply do it all in the
'GI.Gtk.Objects.PrintOperation.PrintOperation'::@/begin-print/@ handler, and set the number of pages from there, like
in the following example:

\<informalexample>\<programlisting>
\/\/ Signal handler for the GtkPrintOperation::begin-print signal

static void
begin_print (GtkPrintOperation *operation,
             GtkPrintContext   *context,
             gpointer           user_data)
{
    GtkSourcePrintCompositor *compositor;
    gint n_pages;

    compositor = GTK_SOURCE_PRINT_COMPOSITOR (user_data);

    while (!gtk_source_print_compositor_paginate (compositor, context));

    n_pages = gtk_source_print_compositor_get_n_pages (compositor);
    gtk_print_operation_set_n_pages (operation, n_pages);
}
\<\/programlisting>\<\/informalexample>

/Since: 2.2/
-}
printCompositorPaginate ::
    (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a, Gtk.PrintContext.IsPrintContext b) =>
    a
    {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> b
    {- ^ /@context@/: the '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:__ 'True' if the document has been completely paginated, 'False' otherwise. -}
printCompositorPaginate compositor context = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    context' <- unsafeManagedPtrCastPtr context
    result <- gtk_source_print_compositor_paginate compositor' context'
    let result' = (/= 0) result
    touchManagedPtr compositor
    touchManagedPtr context
    return result'

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> T.Text
    {- ^ /@fontName@/: the name of the default font for the body text. -}
    -> m ()
printCompositorSetBodyFontName compositor fontName = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    fontName' <- textToCString fontName
    gtk_source_print_compositor_set_body_font_name compositor' fontName'
    touchManagedPtr compositor
    freeMem fontName'
    return ()

#if 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 '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 compositor margin unit = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    let margin' = realToFrac margin
    let unit' = (fromIntegral . fromEnum) unit
    gtk_source_print_compositor_set_bottom_margin compositor' margin' unit'
    touchManagedPtr compositor
    return ()

#if 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
'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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Maybe (T.Text)
    {- ^ /@fontName@/: the name of the font for the footer text, or 'Nothing'. -}
    -> m ()
printCompositorSetFooterFontName compositor fontName = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    maybeFontName <- case fontName of
        Nothing -> return nullPtr
        Just jFontName -> do
            jFontName' <- textToCString jFontName
            return jFontName'
    gtk_source_print_compositor_set_footer_font_name compositor' maybeFontName
    touchManagedPtr compositor
    freeMem maybeFontName
    return ()

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Bool
    {- ^ /@separator@/: '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 compositor separator left center right = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    let separator' = (fromIntegral . fromEnum) separator
    maybeLeft <- case left of
        Nothing -> return nullPtr
        Just jLeft -> do
            jLeft' <- textToCString jLeft
            return jLeft'
    maybeCenter <- case center of
        Nothing -> return nullPtr
        Just jCenter -> do
            jCenter' <- textToCString jCenter
            return jCenter'
    maybeRight <- case right of
        Nothing -> return nullPtr
        Just jRight -> do
            jRight' <- textToCString jRight
            return jRight'
    gtk_source_print_compositor_set_footer_format compositor' separator' maybeLeft maybeCenter maybeRight
    touchManagedPtr compositor
    freeMem maybeLeft
    freeMem maybeCenter
    freeMem maybeRight
    return ()

#if 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
'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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Maybe (T.Text)
    {- ^ /@fontName@/: the name of the font for header text, or 'Nothing'. -}
    -> m ()
printCompositorSetHeaderFontName compositor fontName = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    maybeFontName <- case fontName of
        Nothing -> return nullPtr
        Just jFontName -> do
            jFontName' <- textToCString jFontName
            return jFontName'
    gtk_source_print_compositor_set_header_font_name compositor' maybeFontName
    touchManagedPtr compositor
    freeMem maybeFontName
    return ()

#if 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 '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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Bool
    {- ^ /@separator@/: '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 compositor separator left center right = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    let separator' = (fromIntegral . fromEnum) separator
    maybeLeft <- case left of
        Nothing -> return nullPtr
        Just jLeft -> do
            jLeft' <- textToCString jLeft
            return jLeft'
    maybeCenter <- case center of
        Nothing -> return nullPtr
        Just jCenter -> do
            jCenter' <- textToCString jCenter
            return jCenter'
    maybeRight <- case right of
        Nothing -> return nullPtr
        Just jRight -> do
            jRight' <- textToCString jRight
            return jRight'
    gtk_source_print_compositor_set_header_format compositor' separator' maybeLeft maybeCenter maybeRight
    touchManagedPtr compositor
    freeMem maybeLeft
    freeMem maybeCenter
    freeMem maybeRight
    return ()

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Bool
    {- ^ /@highlight@/: whether syntax should be highlighted. -}
    -> m ()
printCompositorSetHighlightSyntax compositor highlight = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    let highlight' = (fromIntegral . fromEnum) highlight
    gtk_source_print_compositor_set_highlight_syntax compositor' highlight'
    touchManagedPtr compositor
    return ()

#if 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 '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 compositor margin unit = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    let margin' = realToFrac margin
    let unit' = (fromIntegral . fromEnum) unit
    gtk_source_print_compositor_set_left_margin compositor' margin' unit'
    touchManagedPtr compositor
    return ()

#if 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
'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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Maybe (T.Text)
    {- ^ /@fontName@/: the name of the font for line numbers, or 'Nothing'. -}
    -> m ()
printCompositorSetLineNumbersFontName compositor fontName = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    maybeFontName <- case fontName of
        Nothing -> return nullPtr
        Just jFontName -> do
            jFontName' <- textToCString jFontName
            return jFontName'
    gtk_source_print_compositor_set_line_numbers_font_name compositor' maybeFontName
    touchManagedPtr compositor
    freeMem maybeFontName
    return ()

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Bool
    {- ^ /@print@/: 'True' if you want the footer to be printed. -}
    -> m ()
printCompositorSetPrintFooter compositor print = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    let print' = (fromIntegral . fromEnum) print
    gtk_source_print_compositor_set_print_footer compositor' print'
    touchManagedPtr compositor
    return ()

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Bool
    {- ^ /@print@/: 'True' if you want the header to be printed. -}
    -> m ()
printCompositorSetPrintHeader compositor print = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    let print' = (fromIntegral . fromEnum) print
    gtk_source_print_compositor_set_print_header compositor' print'
    touchManagedPtr compositor
    return ()

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Word32
    {- ^ /@interval@/: interval for printed line numbers. -}
    -> m ()
printCompositorSetPrintLineNumbers compositor interval = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    gtk_source_print_compositor_set_print_line_numbers compositor' interval
    touchManagedPtr compositor
    return ()

#if 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 '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 compositor margin unit = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    let margin' = realToFrac margin
    let unit' = (fromIntegral . fromEnum) unit
    gtk_source_print_compositor_set_right_margin compositor' margin' unit'
    touchManagedPtr compositor
    return ()

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Word32
    {- ^ /@width@/: width of tab in characters. -}
    -> m ()
printCompositorSetTabWidth compositor width = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    gtk_source_print_compositor_set_tab_width compositor' width
    touchManagedPtr compositor
    return ()

#if 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 '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 compositor margin unit = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    let margin' = realToFrac margin
    let unit' = (fromIntegral . fromEnum) unit
    gtk_source_print_compositor_set_top_margin compositor' margin' unit'
    touchManagedPtr compositor
    return ()

#if 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 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -}
    -> Gtk.Enums.WrapMode
    {- ^ /@wrapMode@/: a 'GI.Gtk.Enums.WrapMode'. -}
    -> m ()
printCompositorSetWrapMode compositor wrapMode = liftIO $ do
    compositor' <- unsafeManagedPtrCastPtr compositor
    let wrapMode' = (fromIntegral . fromEnum) wrapMode
    gtk_source_print_compositor_set_wrap_mode compositor' wrapMode'
    touchManagedPtr compositor
    return ()

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

#endif