{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.GtkSource.Objects.PrintCompositor
    ( 

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


 -- * Methods
-- ** drawPage #method:drawPage#
    PrintCompositorDrawPageMethodInfo       ,
    printCompositorDrawPage                 ,


-- ** getBodyFontName #method:getBodyFontName#
    PrintCompositorGetBodyFontNameMethodInfo,
    printCompositorGetBodyFontName          ,


-- ** getBottomMargin #method:getBottomMargin#
    PrintCompositorGetBottomMarginMethodInfo,
    printCompositorGetBottomMargin          ,


-- ** getBuffer #method:getBuffer#
    PrintCompositorGetBufferMethodInfo      ,
    printCompositorGetBuffer                ,


-- ** getFooterFontName #method:getFooterFontName#
    PrintCompositorGetFooterFontNameMethodInfo,
    printCompositorGetFooterFontName        ,


-- ** getHeaderFontName #method:getHeaderFontName#
    PrintCompositorGetHeaderFontNameMethodInfo,
    printCompositorGetHeaderFontName        ,


-- ** getHighlightSyntax #method:getHighlightSyntax#
    PrintCompositorGetHighlightSyntaxMethodInfo,
    printCompositorGetHighlightSyntax       ,


-- ** getLeftMargin #method:getLeftMargin#
    PrintCompositorGetLeftMarginMethodInfo  ,
    printCompositorGetLeftMargin            ,


-- ** getLineNumbersFontName #method:getLineNumbersFontName#
    PrintCompositorGetLineNumbersFontNameMethodInfo,
    printCompositorGetLineNumbersFontName   ,


-- ** getNPages #method:getNPages#
    PrintCompositorGetNPagesMethodInfo      ,
    printCompositorGetNPages                ,


-- ** getPaginationProgress #method:getPaginationProgress#
    PrintCompositorGetPaginationProgressMethodInfo,
    printCompositorGetPaginationProgress    ,


-- ** getPrintFooter #method:getPrintFooter#
    PrintCompositorGetPrintFooterMethodInfo ,
    printCompositorGetPrintFooter           ,


-- ** getPrintHeader #method:getPrintHeader#
    PrintCompositorGetPrintHeaderMethodInfo ,
    printCompositorGetPrintHeader           ,


-- ** getPrintLineNumbers #method:getPrintLineNumbers#
    PrintCompositorGetPrintLineNumbersMethodInfo,
    printCompositorGetPrintLineNumbers      ,


-- ** getRightMargin #method:getRightMargin#
    PrintCompositorGetRightMarginMethodInfo ,
    printCompositorGetRightMargin           ,


-- ** getTabWidth #method:getTabWidth#
    PrintCompositorGetTabWidthMethodInfo    ,
    printCompositorGetTabWidth              ,


-- ** getTopMargin #method:getTopMargin#
    PrintCompositorGetTopMarginMethodInfo   ,
    printCompositorGetTopMargin             ,


-- ** getWrapMode #method:getWrapMode#
    PrintCompositorGetWrapModeMethodInfo    ,
    printCompositorGetWrapMode              ,


-- ** new #method:new#
    printCompositorNew                      ,


-- ** newFromView #method:newFromView#
    printCompositorNewFromView              ,


-- ** paginate #method:paginate#
    PrintCompositorPaginateMethodInfo       ,
    printCompositorPaginate                 ,


-- ** setBodyFontName #method:setBodyFontName#
    PrintCompositorSetBodyFontNameMethodInfo,
    printCompositorSetBodyFontName          ,


-- ** setBottomMargin #method:setBottomMargin#
    PrintCompositorSetBottomMarginMethodInfo,
    printCompositorSetBottomMargin          ,


-- ** setFooterFontName #method:setFooterFontName#
    PrintCompositorSetFooterFontNameMethodInfo,
    printCompositorSetFooterFontName        ,


-- ** setFooterFormat #method:setFooterFormat#
    PrintCompositorSetFooterFormatMethodInfo,
    printCompositorSetFooterFormat          ,


-- ** setHeaderFontName #method:setHeaderFontName#
    PrintCompositorSetHeaderFontNameMethodInfo,
    printCompositorSetHeaderFontName        ,


-- ** setHeaderFormat #method:setHeaderFormat#
    PrintCompositorSetHeaderFormatMethodInfo,
    printCompositorSetHeaderFormat          ,


-- ** setHighlightSyntax #method:setHighlightSyntax#
    PrintCompositorSetHighlightSyntaxMethodInfo,
    printCompositorSetHighlightSyntax       ,


-- ** setLeftMargin #method:setLeftMargin#
    PrintCompositorSetLeftMarginMethodInfo  ,
    printCompositorSetLeftMargin            ,


-- ** setLineNumbersFontName #method:setLineNumbersFontName#
    PrintCompositorSetLineNumbersFontNameMethodInfo,
    printCompositorSetLineNumbersFontName   ,


-- ** setPrintFooter #method:setPrintFooter#
    PrintCompositorSetPrintFooterMethodInfo ,
    printCompositorSetPrintFooter           ,


-- ** setPrintHeader #method:setPrintHeader#
    PrintCompositorSetPrintHeaderMethodInfo ,
    printCompositorSetPrintHeader           ,


-- ** setPrintLineNumbers #method:setPrintLineNumbers#
    PrintCompositorSetPrintLineNumbersMethodInfo,
    printCompositorSetPrintLineNumbers      ,


-- ** setRightMargin #method:setRightMargin#
    PrintCompositorSetRightMarginMethodInfo ,
    printCompositorSetRightMargin           ,


-- ** setTabWidth #method:setTabWidth#
    PrintCompositorSetTabWidthMethodInfo    ,
    printCompositorSetTabWidth              ,


-- ** setTopMargin #method:setTopMargin#
    PrintCompositorSetTopMarginMethodInfo   ,
    printCompositorSetTopMargin             ,


-- ** setWrapMode #method:setWrapMode#
    PrintCompositorSetWrapModeMethodInfo    ,
    printCompositorSetWrapMode              ,




 -- * Properties
-- ** bodyFontName #attr:bodyFontName#
    PrintCompositorBodyFontNamePropertyInfo ,
    constructPrintCompositorBodyFontName    ,
    getPrintCompositorBodyFontName          ,
    printCompositorBodyFontName             ,
    setPrintCompositorBodyFontName          ,


-- ** buffer #attr:buffer#
    PrintCompositorBufferPropertyInfo       ,
    constructPrintCompositorBuffer          ,
    getPrintCompositorBuffer                ,
    printCompositorBuffer                   ,


-- ** footerFontName #attr:footerFontName#
    PrintCompositorFooterFontNamePropertyInfo,
    clearPrintCompositorFooterFontName      ,
    constructPrintCompositorFooterFontName  ,
    getPrintCompositorFooterFontName        ,
    printCompositorFooterFontName           ,
    setPrintCompositorFooterFontName        ,


-- ** headerFontName #attr:headerFontName#
    PrintCompositorHeaderFontNamePropertyInfo,
    clearPrintCompositorHeaderFontName      ,
    constructPrintCompositorHeaderFontName  ,
    getPrintCompositorHeaderFontName        ,
    printCompositorHeaderFontName           ,
    setPrintCompositorHeaderFontName        ,


-- ** highlightSyntax #attr:highlightSyntax#
    PrintCompositorHighlightSyntaxPropertyInfo,
    constructPrintCompositorHighlightSyntax ,
    getPrintCompositorHighlightSyntax       ,
    printCompositorHighlightSyntax          ,
    setPrintCompositorHighlightSyntax       ,


-- ** lineNumbersFontName #attr:lineNumbersFontName#
    PrintCompositorLineNumbersFontNamePropertyInfo,
    clearPrintCompositorLineNumbersFontName ,
    constructPrintCompositorLineNumbersFontName,
    getPrintCompositorLineNumbersFontName   ,
    printCompositorLineNumbersFontName      ,
    setPrintCompositorLineNumbersFontName   ,


-- ** nPages #attr:nPages#
    PrintCompositorNPagesPropertyInfo       ,
    getPrintCompositorNPages                ,
    printCompositorNPages                   ,


-- ** printFooter #attr:printFooter#
    PrintCompositorPrintFooterPropertyInfo  ,
    constructPrintCompositorPrintFooter     ,
    getPrintCompositorPrintFooter           ,
    printCompositorPrintFooter              ,
    setPrintCompositorPrintFooter           ,


-- ** printHeader #attr:printHeader#
    PrintCompositorPrintHeaderPropertyInfo  ,
    constructPrintCompositorPrintHeader     ,
    getPrintCompositorPrintHeader           ,
    printCompositorPrintHeader              ,
    setPrintCompositorPrintHeader           ,


-- ** printLineNumbers #attr:printLineNumbers#
    PrintCompositorPrintLineNumbersPropertyInfo,
    constructPrintCompositorPrintLineNumbers,
    getPrintCompositorPrintLineNumbers      ,
    printCompositorPrintLineNumbers         ,
    setPrintCompositorPrintLineNumbers      ,


-- ** tabWidth #attr:tabWidth#
    PrintCompositorTabWidthPropertyInfo     ,
    constructPrintCompositorTabWidth        ,
    getPrintCompositorTabWidth              ,
    printCompositorTabWidth                 ,
    setPrintCompositorTabWidth              ,


-- ** wrapMode #attr:wrapMode#
    PrintCompositorWrapModePropertyInfo     ,
    constructPrintCompositorWrapMode        ,
    getPrintCompositorWrapMode              ,
    printCompositorWrapMode                 ,
    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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 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

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
    

class GObject o => IsPrintCompositor o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError PrintCompositor a) =>
    IsPrintCompositor a
#endif
instance IsPrintCompositor PrintCompositor
instance GObject.Object.IsObject PrintCompositor

toPrintCompositor :: IsPrintCompositor o => o -> IO PrintCompositor
toPrintCompositor = unsafeCastTo PrintCompositor

noPrintCompositor :: Maybe PrintCompositor
noPrintCompositor = Nothing

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 "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 "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolvePrintCompositorMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    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) => O.IsLabelProxy t (PrintCompositor -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolvePrintCompositorMethod t PrintCompositor, O.MethodInfo info PrintCompositor p) => O.IsLabel t (PrintCompositor -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

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

getPrintCompositorBodyFontName :: (MonadIO m, IsPrintCompositor o) => o -> m (Maybe T.Text)
getPrintCompositorBodyFontName obj = liftIO $ getObjectPropertyString obj "body-font-name"

setPrintCompositorBodyFontName :: (MonadIO m, IsPrintCompositor o) => o -> T.Text -> m ()
setPrintCompositorBodyFontName obj val = liftIO $ setObjectPropertyString obj "body-font-name" (Just val)

constructPrintCompositorBodyFontName :: (IsPrintCompositor o) => T.Text -> IO (GValueConstruct o)
constructPrintCompositorBodyFontName val = constructObjectPropertyString "body-font-name" (Just val)

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

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

getPrintCompositorBuffer :: (MonadIO m, IsPrintCompositor o) => o -> m GtkSource.Buffer.Buffer
getPrintCompositorBuffer obj = liftIO $ checkUnexpectedNothing "getPrintCompositorBuffer" $ getObjectPropertyObject obj "buffer" GtkSource.Buffer.Buffer

constructPrintCompositorBuffer :: (IsPrintCompositor o, GtkSource.Buffer.IsBuffer a) => a -> IO (GValueConstruct o)
constructPrintCompositorBuffer val = constructObjectPropertyObject "buffer" (Just val)

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

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

getPrintCompositorFooterFontName :: (MonadIO m, IsPrintCompositor o) => o -> m (Maybe T.Text)
getPrintCompositorFooterFontName obj = liftIO $ getObjectPropertyString obj "footer-font-name"

setPrintCompositorFooterFontName :: (MonadIO m, IsPrintCompositor o) => o -> T.Text -> m ()
setPrintCompositorFooterFontName obj val = liftIO $ setObjectPropertyString obj "footer-font-name" (Just val)

constructPrintCompositorFooterFontName :: (IsPrintCompositor o) => T.Text -> IO (GValueConstruct o)
constructPrintCompositorFooterFontName val = constructObjectPropertyString "footer-font-name" (Just val)

clearPrintCompositorFooterFontName :: (MonadIO m, IsPrintCompositor o) => o -> m ()
clearPrintCompositorFooterFontName obj = liftIO $ setObjectPropertyString obj "footer-font-name" (Nothing :: Maybe T.Text)

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

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

getPrintCompositorHeaderFontName :: (MonadIO m, IsPrintCompositor o) => o -> m (Maybe T.Text)
getPrintCompositorHeaderFontName obj = liftIO $ getObjectPropertyString obj "header-font-name"

setPrintCompositorHeaderFontName :: (MonadIO m, IsPrintCompositor o) => o -> T.Text -> m ()
setPrintCompositorHeaderFontName obj val = liftIO $ setObjectPropertyString obj "header-font-name" (Just val)

constructPrintCompositorHeaderFontName :: (IsPrintCompositor o) => T.Text -> IO (GValueConstruct o)
constructPrintCompositorHeaderFontName val = constructObjectPropertyString "header-font-name" (Just val)

clearPrintCompositorHeaderFontName :: (MonadIO m, IsPrintCompositor o) => o -> m ()
clearPrintCompositorHeaderFontName obj = liftIO $ setObjectPropertyString obj "header-font-name" (Nothing :: Maybe T.Text)

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

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

getPrintCompositorHighlightSyntax :: (MonadIO m, IsPrintCompositor o) => o -> m Bool
getPrintCompositorHighlightSyntax obj = liftIO $ getObjectPropertyBool obj "highlight-syntax"

setPrintCompositorHighlightSyntax :: (MonadIO m, IsPrintCompositor o) => o -> Bool -> m ()
setPrintCompositorHighlightSyntax obj val = liftIO $ setObjectPropertyBool obj "highlight-syntax" val

constructPrintCompositorHighlightSyntax :: (IsPrintCompositor o) => Bool -> IO (GValueConstruct o)
constructPrintCompositorHighlightSyntax val = constructObjectPropertyBool "highlight-syntax" val

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

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

getPrintCompositorLineNumbersFontName :: (MonadIO m, IsPrintCompositor o) => o -> m (Maybe T.Text)
getPrintCompositorLineNumbersFontName obj = liftIO $ getObjectPropertyString obj "line-numbers-font-name"

setPrintCompositorLineNumbersFontName :: (MonadIO m, IsPrintCompositor o) => o -> T.Text -> m ()
setPrintCompositorLineNumbersFontName obj val = liftIO $ setObjectPropertyString obj "line-numbers-font-name" (Just val)

constructPrintCompositorLineNumbersFontName :: (IsPrintCompositor o) => T.Text -> IO (GValueConstruct o)
constructPrintCompositorLineNumbersFontName val = constructObjectPropertyString "line-numbers-font-name" (Just val)

clearPrintCompositorLineNumbersFontName :: (MonadIO m, IsPrintCompositor o) => o -> m ()
clearPrintCompositorLineNumbersFontName obj = liftIO $ setObjectPropertyString obj "line-numbers-font-name" (Nothing :: Maybe T.Text)

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

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

getPrintCompositorNPages :: (MonadIO m, IsPrintCompositor o) => o -> m Int32
getPrintCompositorNPages obj = liftIO $ getObjectPropertyInt32 obj "n-pages"

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

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

getPrintCompositorPrintFooter :: (MonadIO m, IsPrintCompositor o) => o -> m Bool
getPrintCompositorPrintFooter obj = liftIO $ getObjectPropertyBool obj "print-footer"

setPrintCompositorPrintFooter :: (MonadIO m, IsPrintCompositor o) => o -> Bool -> m ()
setPrintCompositorPrintFooter obj val = liftIO $ setObjectPropertyBool obj "print-footer" val

constructPrintCompositorPrintFooter :: (IsPrintCompositor o) => Bool -> IO (GValueConstruct o)
constructPrintCompositorPrintFooter val = constructObjectPropertyBool "print-footer" val

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

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

getPrintCompositorPrintHeader :: (MonadIO m, IsPrintCompositor o) => o -> m Bool
getPrintCompositorPrintHeader obj = liftIO $ getObjectPropertyBool obj "print-header"

setPrintCompositorPrintHeader :: (MonadIO m, IsPrintCompositor o) => o -> Bool -> m ()
setPrintCompositorPrintHeader obj val = liftIO $ setObjectPropertyBool obj "print-header" val

constructPrintCompositorPrintHeader :: (IsPrintCompositor o) => Bool -> IO (GValueConstruct o)
constructPrintCompositorPrintHeader val = constructObjectPropertyBool "print-header" val

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

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

getPrintCompositorPrintLineNumbers :: (MonadIO m, IsPrintCompositor o) => o -> m Word32
getPrintCompositorPrintLineNumbers obj = liftIO $ getObjectPropertyUInt32 obj "print-line-numbers"

setPrintCompositorPrintLineNumbers :: (MonadIO m, IsPrintCompositor o) => o -> Word32 -> m ()
setPrintCompositorPrintLineNumbers obj val = liftIO $ setObjectPropertyUInt32 obj "print-line-numbers" val

constructPrintCompositorPrintLineNumbers :: (IsPrintCompositor o) => Word32 -> IO (GValueConstruct o)
constructPrintCompositorPrintLineNumbers val = constructObjectPropertyUInt32 "print-line-numbers" val

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

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

getPrintCompositorTabWidth :: (MonadIO m, IsPrintCompositor o) => o -> m Word32
getPrintCompositorTabWidth obj = liftIO $ getObjectPropertyUInt32 obj "tab-width"

setPrintCompositorTabWidth :: (MonadIO m, IsPrintCompositor o) => o -> Word32 -> m ()
setPrintCompositorTabWidth obj val = liftIO $ setObjectPropertyUInt32 obj "tab-width" val

constructPrintCompositorTabWidth :: (IsPrintCompositor o) => Word32 -> IO (GValueConstruct o)
constructPrintCompositorTabWidth val = constructObjectPropertyUInt32 "tab-width" val

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

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

getPrintCompositorWrapMode :: (MonadIO m, IsPrintCompositor o) => o -> m Gtk.Enums.WrapMode
getPrintCompositorWrapMode obj = liftIO $ getObjectPropertyEnum obj "wrap-mode"

setPrintCompositorWrapMode :: (MonadIO m, IsPrintCompositor o) => o -> Gtk.Enums.WrapMode -> m ()
setPrintCompositorWrapMode obj val = liftIO $ setObjectPropertyEnum obj "wrap-mode" val

constructPrintCompositorWrapMode :: (IsPrintCompositor o) => Gtk.Enums.WrapMode -> IO (GValueConstruct o)
constructPrintCompositorWrapMode val = constructObjectPropertyEnum "wrap-mode" val

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

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, *)])

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

type instance O.SignalList PrintCompositor = PrintCompositorSignalList
type PrintCompositorSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

-- 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'

-- 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'

-- 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 ()

data PrintCompositorDrawPageMethodInfo
instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsPrintCompositor a, Gtk.PrintContext.IsPrintContext b) => O.MethodInfo PrintCompositorDrawPageMethodInfo a signature where
    overloadedMethod _ = printCompositorDrawPage

-- 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'

data PrintCompositorGetBodyFontNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetBodyFontNameMethodInfo a signature where
    overloadedMethod _ = printCompositorGetBodyFontName

-- 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'

data PrintCompositorGetBottomMarginMethodInfo
instance (signature ~ (Gtk.Enums.Unit -> m Double), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetBottomMarginMethodInfo a signature where
    overloadedMethod _ = printCompositorGetBottomMargin

-- 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'

data PrintCompositorGetBufferMethodInfo
instance (signature ~ (m GtkSource.Buffer.Buffer), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetBufferMethodInfo a signature where
    overloadedMethod _ = printCompositorGetBuffer

-- 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'

data PrintCompositorGetFooterFontNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetFooterFontNameMethodInfo a signature where
    overloadedMethod _ = printCompositorGetFooterFontName

-- 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'

data PrintCompositorGetHeaderFontNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetHeaderFontNameMethodInfo a signature where
    overloadedMethod _ = printCompositorGetHeaderFontName

-- 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'

data PrintCompositorGetHighlightSyntaxMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetHighlightSyntaxMethodInfo a signature where
    overloadedMethod _ = printCompositorGetHighlightSyntax

-- 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'

data PrintCompositorGetLeftMarginMethodInfo
instance (signature ~ (Gtk.Enums.Unit -> m Double), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetLeftMarginMethodInfo a signature where
    overloadedMethod _ = printCompositorGetLeftMargin

-- 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'

data PrintCompositorGetLineNumbersFontNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetLineNumbersFontNameMethodInfo a signature where
    overloadedMethod _ = printCompositorGetLineNumbersFontName

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

data PrintCompositorGetNPagesMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetNPagesMethodInfo a signature where
    overloadedMethod _ = printCompositorGetNPages

-- 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'

data PrintCompositorGetPaginationProgressMethodInfo
instance (signature ~ (m Double), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetPaginationProgressMethodInfo a signature where
    overloadedMethod _ = printCompositorGetPaginationProgress

-- 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'

data PrintCompositorGetPrintFooterMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetPrintFooterMethodInfo a signature where
    overloadedMethod _ = printCompositorGetPrintFooter

-- 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'

data PrintCompositorGetPrintHeaderMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetPrintHeaderMethodInfo a signature where
    overloadedMethod _ = printCompositorGetPrintHeader

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

data PrintCompositorGetPrintLineNumbersMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetPrintLineNumbersMethodInfo a signature where
    overloadedMethod _ = printCompositorGetPrintLineNumbers

-- 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'

data PrintCompositorGetRightMarginMethodInfo
instance (signature ~ (Gtk.Enums.Unit -> m Double), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetRightMarginMethodInfo a signature where
    overloadedMethod _ = printCompositorGetRightMargin

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

data PrintCompositorGetTabWidthMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetTabWidthMethodInfo a signature where
    overloadedMethod _ = printCompositorGetTabWidth

-- 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'

data PrintCompositorGetTopMarginMethodInfo
instance (signature ~ (Gtk.Enums.Unit -> m Double), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetTopMarginMethodInfo a signature where
    overloadedMethod _ = printCompositorGetTopMargin

-- 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'

data PrintCompositorGetWrapModeMethodInfo
instance (signature ~ (m Gtk.Enums.WrapMode), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetWrapModeMethodInfo a signature where
    overloadedMethod _ = printCompositorGetWrapMode

-- 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'

data PrintCompositorPaginateMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsPrintCompositor a, Gtk.PrintContext.IsPrintContext b) => O.MethodInfo PrintCompositorPaginateMethodInfo a signature where
    overloadedMethod _ = printCompositorPaginate

-- 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 ()

data PrintCompositorSetBodyFontNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetBodyFontNameMethodInfo a signature where
    overloadedMethod _ = printCompositorSetBodyFontName

-- 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 ()

data PrintCompositorSetBottomMarginMethodInfo
instance (signature ~ (Double -> Gtk.Enums.Unit -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetBottomMarginMethodInfo a signature where
    overloadedMethod _ = printCompositorSetBottomMargin

-- 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 ()

data PrintCompositorSetFooterFontNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetFooterFontNameMethodInfo a signature where
    overloadedMethod _ = printCompositorSetFooterFontName

-- 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 ()

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

-- 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 ()

data PrintCompositorSetHeaderFontNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetHeaderFontNameMethodInfo a signature where
    overloadedMethod _ = printCompositorSetHeaderFontName

-- 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 ()

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

-- 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 ()

data PrintCompositorSetHighlightSyntaxMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetHighlightSyntaxMethodInfo a signature where
    overloadedMethod _ = printCompositorSetHighlightSyntax

-- 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 ()

data PrintCompositorSetLeftMarginMethodInfo
instance (signature ~ (Double -> Gtk.Enums.Unit -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetLeftMarginMethodInfo a signature where
    overloadedMethod _ = printCompositorSetLeftMargin

-- 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 ()

data PrintCompositorSetLineNumbersFontNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetLineNumbersFontNameMethodInfo a signature where
    overloadedMethod _ = printCompositorSetLineNumbersFontName

-- 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 ()

data PrintCompositorSetPrintFooterMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetPrintFooterMethodInfo a signature where
    overloadedMethod _ = printCompositorSetPrintFooter

-- 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 ()

data PrintCompositorSetPrintHeaderMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetPrintHeaderMethodInfo a signature where
    overloadedMethod _ = printCompositorSetPrintHeader

-- 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 ()

data PrintCompositorSetPrintLineNumbersMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetPrintLineNumbersMethodInfo a signature where
    overloadedMethod _ = printCompositorSetPrintLineNumbers

-- 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 ()

data PrintCompositorSetRightMarginMethodInfo
instance (signature ~ (Double -> Gtk.Enums.Unit -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetRightMarginMethodInfo a signature where
    overloadedMethod _ = printCompositorSetRightMargin

-- 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 ()

data PrintCompositorSetTabWidthMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetTabWidthMethodInfo a signature where
    overloadedMethod _ = printCompositorSetTabWidth

-- 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 ()

data PrintCompositorSetTopMarginMethodInfo
instance (signature ~ (Double -> Gtk.Enums.Unit -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetTopMarginMethodInfo a signature where
    overloadedMethod _ = printCompositorSetTopMargin

-- 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 ()

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