{-# LINE 1 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE PatternSynonyms, ViewPatterns #-}
{-# LANGUAGE RankNTypes #-}
{-# OPTIONS_GHC -Wall -fno-warn-tabs #-}

module Graphics.Cairo.Surfaces.PdfSurfaces where

import GHC.Foreign hiding (peekCString)
import Foreign.Ptr
import Foreign.ForeignPtr hiding (newForeignPtr)
import Foreign.Concurrent
import Foreign.Marshal
import Foreign.Storable
import Foreign.C.Types
import Foreign.C.String hiding (withCString)
import Control.Monad.Primitive
import Control.Concurrent.STM
import Data.Bits
import Data.Word
import System.IO

import Graphics.Cairo.Exception
import Graphics.Cairo.Surfaces.CairoWriteFuncT
import Graphics.Cairo.Surfaces.CairoSurfaceT.Internal
import Graphics.Cairo.Surfaces.CairoSurfaceTypeT
import Graphics.Cairo.Drawing.TagsAndLinks

import Graphics.Cairo.Surfaces.PdfSurfaces.Template

import qualified Data.ByteString as BS




data CairoSurfacePdfT s ps = CairoSurfacePdfT (ForeignPtr (CairoSurfaceT s ps)) (STM (TChan ()))

pattern CairoSurfaceTPdf :: CairoSurfacePdfT s ps -> CairoSurfaceT s ps
pattern $mCairoSurfaceTPdf :: forall {r} {s} {ps}.
CairoSurfaceT s ps
-> (CairoSurfacePdfT s ps -> r) -> ((# #) -> r) -> r
$bCairoSurfaceTPdf :: forall s ps. CairoSurfacePdfT s ps -> CairoSurfaceT s ps
CairoSurfaceTPdf sr <- (cairoSurfaceTPdf -> Just sr) where
	CairoSurfaceTPdf = CairoSurfacePdfT s ps -> CairoSurfaceT s ps
forall s ps. CairoSurfacePdfT s ps -> CairoSurfaceT s ps
forall (sr :: * -> * -> *) s ps.
IsCairoSurfaceT sr =>
sr s ps -> CairoSurfaceT s ps
toCairoSurfaceT

cairoSurfaceTPdf :: CairoSurfaceT s ps -> Maybe (CairoSurfacePdfT s ps)
cairoSurfaceTPdf :: forall s ps. CairoSurfaceT s ps -> Maybe (CairoSurfacePdfT s ps)
cairoSurfaceTPdf sr :: CairoSurfaceT s ps
sr@(CairoSurfaceT ForeignPtr (CairoSurfaceT s ps)
fsr) = case CairoSurfaceT s ps -> CairoSurfaceTypeT
forall (sr :: * -> * -> *) s ps.
IsCairoSurfaceT sr =>
sr s ps -> CairoSurfaceTypeT
cairoSurfaceGetType CairoSurfaceT s ps
sr of
	CairoSurfaceTypeT
CairoSurfaceTypePdf -> CairoSurfacePdfT s ps -> Maybe (CairoSurfacePdfT s ps)
forall a. a -> Maybe a
Just (CairoSurfacePdfT s ps -> Maybe (CairoSurfacePdfT s ps))
-> CairoSurfacePdfT s ps -> Maybe (CairoSurfacePdfT s ps)
forall a b. (a -> b) -> a -> b
$ ForeignPtr (CairoSurfaceT s ps)
-> STM (TChan ()) -> CairoSurfacePdfT s ps
forall s ps.
ForeignPtr (CairoSurfaceT s ps)
-> STM (TChan ()) -> CairoSurfacePdfT s ps
CairoSurfacePdfT ForeignPtr (CairoSurfaceT s ps)
fsr STM (TChan ())
forall a. STM (TChan a)
newTChan
	CairoSurfaceTypeT
_ -> Maybe (CairoSurfacePdfT s ps)
forall a. Maybe a
Nothing

instance IsCairoSurfaceT CairoSurfacePdfT where
	toCairoSurfaceT :: forall s ps. CairoSurfacePdfT s ps -> CairoSurfaceT s ps
toCairoSurfaceT (CairoSurfacePdfT ForeignPtr (CairoSurfaceT s ps)
fsr STM (TChan ())
_) = ForeignPtr (CairoSurfaceT s ps) -> CairoSurfaceT s ps
forall s ps. ForeignPtr (CairoSurfaceT s ps) -> CairoSurfaceT s ps
CairoSurfaceT ForeignPtr (CairoSurfaceT s ps)
fsr
	cairoSurfaceTFinishChecker :: forall s ps. CairoSurfacePdfT s ps -> STM (TChan ())
cairoSurfaceTFinishChecker (CairoSurfacePdfT ForeignPtr (CairoSurfaceT s ps)
_ STM (TChan ())
ck) = STM (TChan ())
ck

cairoPdfSurfaceWith :: FilePath -> CDouble -> CDouble ->
	(forall s . CairoSurfacePdfT s RealWorld -> IO a) -> IO a
cairoPdfSurfaceWith :: forall a.
FilePath
-> CDouble
-> CDouble
-> (forall s. CairoSurfacePdfT s RealWorld -> IO a)
-> IO a
cairoPdfSurfaceWith FilePath
fp CDouble
w CDouble
h forall s. CairoSurfacePdfT s RealWorld -> IO a
f = do
	sr@(CairoSurfacePdfT fsr mck) <- FilePath
-> CDouble -> CDouble -> IO (CairoSurfacePdfT Any RealWorld)
forall s.
FilePath -> CDouble -> CDouble -> IO (CairoSurfacePdfT s RealWorld)
cairoPdfSurfaceCreateNoGC FilePath
fp CDouble
w CDouble
h
	ck <- atomically mck
	f sr <* withForeignPtr fsr
		(\Ptr (CairoSurfaceT Any RealWorld)
psr -> do
			Ptr (CairoSurfaceT Any RealWorld) -> IO ()
forall s ps. Ptr (CairoSurfaceT s ps) -> IO ()
c_cairo_surface_finish Ptr (CairoSurfaceT Any RealWorld)
psr
			Ptr (CairoSurfaceT Any RealWorld) -> IO ()
forall s ps. Ptr (CairoSurfaceT s ps) -> IO ()
c_cairo_surface_destroy Ptr (CairoSurfaceT Any RealWorld)
psr
			FilePath -> IO ()
putStrLn FilePath
"PDF Surface destroyed"
			STM () -> IO ()
forall a. STM a -> IO a
atomically (TChan () -> () -> STM ()
forall a. TChan a -> a -> STM ()
writeTChan TChan ()
ck ())
			FilePath -> IO ()
putStrLn FilePath
"writeTChan ck () finished")

cairoPdfSurfaceCreate :: FilePath -> CDouble -> CDouble -> IO (CairoSurfacePdfT s RealWorld)
cairoPdfSurfaceCreate :: forall s.
FilePath -> CDouble -> CDouble -> IO (CairoSurfacePdfT s RealWorld)
cairoPdfSurfaceCreate FilePath
fp CDouble
w CDouble
h = do
	ck <- STM (TChan ()) -> IO (TChan ())
forall a. STM a -> IO a
atomically STM (TChan ())
forall a. STM (TChan a)
newTChan
	(`CairoSurfacePdfT` pure ck) <$> withCString utf8 fp \CString
cstr -> do
		p <- CString
-> CDouble -> CDouble -> IO (Ptr (CairoSurfaceT s RealWorld))
forall s ps.
CString -> CDouble -> CDouble -> IO (Ptr (CairoSurfaceT s ps))
c_cairo_pdf_surface_create CString
cstr CDouble
w CDouble
h
		newForeignPtr p (c_cairo_surface_destroy p) <* raiseIfErrorPtrSurface p

cairoPdfSurfaceCreateNoGC :: FilePath -> CDouble -> CDouble -> IO (CairoSurfacePdfT s RealWorld)
cairoPdfSurfaceCreateNoGC :: forall s.
FilePath -> CDouble -> CDouble -> IO (CairoSurfacePdfT s RealWorld)
cairoPdfSurfaceCreateNoGC FilePath
fp CDouble
w CDouble
h = do
	ck <- STM (TChan ()) -> IO (TChan ())
forall a. STM a -> IO a
atomically STM (TChan ())
forall a. STM (TChan a)
newTChan
	(`CairoSurfacePdfT` pure ck) <$> withCString utf8 fp \CString
cstr -> do
		p <- CString
-> CDouble -> CDouble -> IO (Ptr (CairoSurfaceT s RealWorld))
forall s ps.
CString -> CDouble -> CDouble -> IO (Ptr (CairoSurfaceT s ps))
c_cairo_pdf_surface_create CString
cstr CDouble
w CDouble
h
		newForeignPtr p (pure ()) <* raiseIfErrorPtrSurface p

foreign import ccall "cairo_pdf_surface_create" c_cairo_pdf_surface_create ::
	CString -> CDouble -> CDouble -> IO (Ptr (CairoSurfaceT s ps))

unsafeCairoSurfaceFinish :: CairoSurfaceT s RealWorld -> IO ()
unsafeCairoSurfaceFinish :: forall s. CairoSurfaceT s RealWorld -> IO ()
unsafeCairoSurfaceFinish (CairoSurfaceT ForeignPtr (CairoSurfaceT s RealWorld)
fsr) =
	ForeignPtr (CairoSurfaceT s RealWorld)
-> (Ptr (CairoSurfaceT s RealWorld) -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr (CairoSurfaceT s RealWorld)
fsr Ptr (CairoSurfaceT s RealWorld) -> IO ()
forall s ps. Ptr (CairoSurfaceT s ps) -> IO ()
c_cairo_surface_finish

cairoPdfSurfaceWithForStream :: PrimBase m =>
	(Ptr a -> BS.ByteString -> m WriteResult) -> Ptr a -> CDouble -> CDouble ->
	(forall s . CairoSurfacePdfT s (PrimState m) -> m a) -> m a
cairoPdfSurfaceWithForStream :: forall (m :: * -> *) a.
PrimBase m =>
(Ptr a -> ByteString -> m WriteResult)
-> Ptr a
-> CDouble
-> CDouble
-> (forall s. CairoSurfacePdfT s (PrimState m) -> m a)
-> m a
cairoPdfSurfaceWithForStream Ptr a -> ByteString -> m WriteResult
wf Ptr a
cl CDouble
w CDouble
h forall s. CairoSurfacePdfT s (PrimState m) -> m a
f = do
	sr@(CairoSurfacePdfT fsr mck) <- (Ptr a -> ByteString -> m WriteResult)
-> Ptr a
-> CDouble
-> CDouble
-> m (CairoSurfacePdfT Any (PrimState m))
forall (m :: * -> *) a s.
PrimBase m =>
(Ptr a -> ByteString -> m WriteResult)
-> Ptr a
-> CDouble
-> CDouble
-> m (CairoSurfacePdfT s (PrimState m))
cairoPdfSurfaceCreateForStreamNoGC Ptr a -> ByteString -> m WriteResult
wf Ptr a
cl CDouble
w CDouble
h
	ck <- unsafeIOToPrim $ atomically mck
	f sr <* unsafeIOToPrim (withForeignPtr fsr $
		\Ptr (CairoSurfaceT Any (PrimState m))
psr -> Ptr (CairoSurfaceT Any (PrimState m)) -> IO ()
forall s ps. Ptr (CairoSurfaceT s ps) -> IO ()
c_cairo_surface_finish Ptr (CairoSurfaceT Any (PrimState m))
psr IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> STM () -> IO ()
forall a. STM a -> IO a
atomically (TChan () -> () -> STM ()
forall a. TChan a -> a -> STM ()
writeTChan TChan ()
ck ()) IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Ptr (CairoSurfaceT Any (PrimState m)) -> IO ()
forall s ps. Ptr (CairoSurfaceT s ps) -> IO ()
c_cairo_surface_destroy Ptr (CairoSurfaceT Any (PrimState m))
psr)

cairoPdfSurfaceCreateForStream :: PrimBase m =>
	(Ptr a -> BS.ByteString -> m WriteResult) -> Ptr a -> CDouble -> CDouble ->
	m (CairoSurfacePdfT s (PrimState m))
cairoPdfSurfaceCreateForStream :: forall (m :: * -> *) a s.
PrimBase m =>
(Ptr a -> ByteString -> m WriteResult)
-> Ptr a
-> CDouble
-> CDouble
-> m (CairoSurfacePdfT s (PrimState m))
cairoPdfSurfaceCreateForStream Ptr a -> ByteString -> m WriteResult
wf Ptr a
cl CDouble
w CDouble
h = do
	ck <- IO (TChan ()) -> m (TChan ())
forall (m :: * -> *) a. PrimMonad m => IO a -> m a
unsafeIOToPrim (IO (TChan ()) -> m (TChan ())) -> IO (TChan ()) -> m (TChan ())
forall a b. (a -> b) -> a -> b
$ STM (TChan ()) -> IO (TChan ())
forall a. STM a -> IO a
atomically STM (TChan ())
forall a. STM (TChan a)
newTChan
	(`CairoSurfacePdfT` pure ck) <$> unsafeIOToPrim do
		p <- (wrapCairoWriteFuncTByteString wf >>= \FunPtr (Ptr a -> CString -> CInt -> IO Word32)
pwf ->
			FunPtr (Ptr a -> CString -> CInt -> IO Word32)
-> Ptr a
-> CDouble
-> CDouble
-> IO (Ptr (CairoSurfaceT s (PrimState m)))
forall a s ps.
FunPtr (Ptr a -> CString -> CInt -> IO Word32)
-> Ptr a -> CDouble -> CDouble -> IO (Ptr (CairoSurfaceT s ps))
c_cairo_pdf_surface_create_for_stream FunPtr (Ptr a -> CString -> CInt -> IO Word32)
pwf Ptr a
cl CDouble
w CDouble
h)
		newForeignPtr p (c_cairo_surface_destroy p) <* raiseIfErrorPtrSurface p

cairoPdfSurfaceCreateForStreamNoGC :: PrimBase m =>
	(Ptr a -> BS.ByteString -> m WriteResult) -> Ptr a -> CDouble -> CDouble ->
	m (CairoSurfacePdfT s (PrimState m))
cairoPdfSurfaceCreateForStreamNoGC :: forall (m :: * -> *) a s.
PrimBase m =>
(Ptr a -> ByteString -> m WriteResult)
-> Ptr a
-> CDouble
-> CDouble
-> m (CairoSurfacePdfT s (PrimState m))
cairoPdfSurfaceCreateForStreamNoGC Ptr a -> ByteString -> m WriteResult
wf Ptr a
cl CDouble
w CDouble
h = do
	ck <- IO (TChan ()) -> m (TChan ())
forall (m :: * -> *) a. PrimMonad m => IO a -> m a
unsafeIOToPrim (IO (TChan ()) -> m (TChan ())) -> IO (TChan ()) -> m (TChan ())
forall a b. (a -> b) -> a -> b
$ STM (TChan ()) -> IO (TChan ())
forall a. STM a -> IO a
atomically STM (TChan ())
forall a. STM (TChan a)
newTChan
	(`CairoSurfacePdfT` pure ck) <$> unsafeIOToPrim do
		p <- (wrapCairoWriteFuncTByteString wf >>= \FunPtr (Ptr a -> CString -> CInt -> IO Word32)
pwf ->
			FunPtr (Ptr a -> CString -> CInt -> IO Word32)
-> Ptr a
-> CDouble
-> CDouble
-> IO (Ptr (CairoSurfaceT s (PrimState m)))
forall a s ps.
FunPtr (Ptr a -> CString -> CInt -> IO Word32)
-> Ptr a -> CDouble -> CDouble -> IO (Ptr (CairoSurfaceT s ps))
c_cairo_pdf_surface_create_for_stream FunPtr (Ptr a -> CString -> CInt -> IO Word32)
pwf Ptr a
cl CDouble
w CDouble
h)
		newForeignPtr p (pure ()) <* raiseIfErrorPtrSurface p

foreign import ccall "cairo_pdf_surface_create_for_stream"
	c_cairo_pdf_surface_create_for_stream ::
	FunPtr (Ptr a -> CString -> CInt -> IO Word32) ->
{-# LINE 117 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}
	Ptr a -> CDouble -> CDouble -> IO (Ptr (CairoSurfaceT s ps))

newtype CairoPdfOutlineT = CairoPdfOutlineT CInt deriving Int -> CairoPdfOutlineT -> ShowS
[CairoPdfOutlineT] -> ShowS
CairoPdfOutlineT -> FilePath
(Int -> CairoPdfOutlineT -> ShowS)
-> (CairoPdfOutlineT -> FilePath)
-> ([CairoPdfOutlineT] -> ShowS)
-> Show CairoPdfOutlineT
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CairoPdfOutlineT -> ShowS
showsPrec :: Int -> CairoPdfOutlineT -> ShowS
$cshow :: CairoPdfOutlineT -> FilePath
show :: CairoPdfOutlineT -> FilePath
$cshowList :: [CairoPdfOutlineT] -> ShowS
showList :: [CairoPdfOutlineT] -> ShowS
Show

pattern CairoPdfOutlineRoot :: CairoPdfOutlineT
pattern $mCairoPdfOutlineRoot :: forall {r}. CairoPdfOutlineT -> ((# #) -> r) -> ((# #) -> r) -> r
$bCairoPdfOutlineRoot :: CairoPdfOutlineT
CairoPdfOutlineRoot <- CairoPdfOutlineT 0 where
{-# LINE 123 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}
	CairoPdfOutlineRoot = CInt -> CairoPdfOutlineT
CairoPdfOutlineT CInt
0
{-# LINE 124 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}

mkOFlag "CairoPdfOutlineFlagOpen" 1
{-# LINE 126 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}
mkOFlag "CairoPdfOutlineFlagBold" 2
{-# LINE 127 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}
mkOFlag "CairoPdfOutlineFlagItalic" 4
{-# LINE 128 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}

join :: CairoPdfOutlineFlagsT -> CairoPdfOutlineFlagsT -> CairoPdfOutlineFlagsT
join :: CairoPdfOutlineFlagsT
-> CairoPdfOutlineFlagsT -> CairoPdfOutlineFlagsT
join (CairoPdfOutlineFlagsT Word32
f1) (CairoPdfOutlineFlagsT Word32
f2) = Word32 -> CairoPdfOutlineFlagsT
CairoPdfOutlineFlagsT (Word32 -> CairoPdfOutlineFlagsT)
-> Word32 -> CairoPdfOutlineFlagsT
forall a b. (a -> b) -> a -> b
$ Word32
f1 Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. Word32
f2

cairoPdfSurfaceAddOutline :: PrimMonad m =>
	CairoSurfacePdfT s (PrimState m) -> CairoPdfOutlineT -> Name ->
	Either Name (Int, Maybe (Double, Double)) -> [CairoPdfOutlineFlagsT] -> m CairoPdfOutlineT
cairoPdfSurfaceAddOutline :: forall (m :: * -> *) s.
PrimMonad m =>
CairoSurfacePdfT s (PrimState m)
-> CairoPdfOutlineT
-> FilePath
-> Either FilePath (Int, Maybe (Double, Double))
-> [CairoPdfOutlineFlagsT]
-> m CairoPdfOutlineT
cairoPdfSurfaceAddOutline (CairoSurfacePdfT ForeignPtr (CairoSurfaceT s (PrimState m))
fsr STM (TChan ())
_) (CairoPdfOutlineT CInt
pid) FilePath
nm Either FilePath (Int, Maybe (Double, Double))
d [CairoPdfOutlineFlagsT]
fs = IO CairoPdfOutlineT -> m CairoPdfOutlineT
forall (m :: * -> *) a. PrimMonad m => IO a -> m a
unsafeIOToPrim
	(IO CairoPdfOutlineT -> m CairoPdfOutlineT)
-> IO CairoPdfOutlineT -> m CairoPdfOutlineT
forall a b. (a -> b) -> a -> b
$ CInt -> CairoPdfOutlineT
CairoPdfOutlineT (CInt -> CairoPdfOutlineT) -> IO CInt -> IO CairoPdfOutlineT
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ForeignPtr (CairoSurfaceT s (PrimState m))
-> (Ptr (CairoSurfaceT s (PrimState m)) -> IO CInt) -> IO CInt
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr (CairoSurfaceT s (PrimState m))
fsr \Ptr (CairoSurfaceT s (PrimState m))
psr -> TextEncoding -> FilePath -> (CString -> IO CInt) -> IO CInt
forall a. TextEncoding -> FilePath -> (CString -> IO a) -> IO a
withCString TextEncoding
utf8 FilePath
nm \CString
cnm -> Either FilePath (Int, Maybe (Double, Double))
-> (CString -> IO CInt) -> IO CInt
forall a.
Either FilePath (Int, Maybe (Double, Double))
-> (CString -> IO a) -> IO a
internalAttributes Either FilePath (Int, Maybe (Double, Double))
d \CString
cd ->
		Ptr (CairoSurfaceT s (PrimState m))
-> CInt -> CString -> CString -> Word32 -> IO CInt
forall s ps.
Ptr (CairoSurfaceT s ps)
-> CInt -> CString -> CString -> Word32 -> IO CInt
c_cairo_pdf_surface_add_outline Ptr (CairoSurfaceT s (PrimState m))
psr CInt
pid CString
cnm CString
cd Word32
f
	where
	CairoPdfOutlineFlagsT Word32
f = (CairoPdfOutlineFlagsT
 -> CairoPdfOutlineFlagsT -> CairoPdfOutlineFlagsT)
-> CairoPdfOutlineFlagsT
-> [CairoPdfOutlineFlagsT]
-> CairoPdfOutlineFlagsT
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr CairoPdfOutlineFlagsT
-> CairoPdfOutlineFlagsT -> CairoPdfOutlineFlagsT
join (Word32 -> CairoPdfOutlineFlagsT
CairoPdfOutlineFlagsT Word32
0) [CairoPdfOutlineFlagsT]
fs

foreign import ccall "cairo_pdf_surface_add_outline" c_cairo_pdf_surface_add_outline ::
	Ptr (CairoSurfaceT s ps) -> CInt -> CString -> CString -> Word32 -> IO CInt
{-# LINE 143 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}

cairoPdfSurfaceSetSize :: PrimMonad m =>
	CairoSurfacePdfT s (PrimState m) -> CDouble -> CDouble -> m ()
cairoPdfSurfaceSetSize :: forall (m :: * -> *) s.
PrimMonad m =>
CairoSurfacePdfT s (PrimState m) -> CDouble -> CDouble -> m ()
cairoPdfSurfaceSetSize (CairoSurfacePdfT ForeignPtr (CairoSurfaceT s (PrimState m))
fsr STM (TChan ())
_) CDouble
w CDouble
h =
	IO () -> m ()
forall (m :: * -> *) a. PrimMonad m => IO a -> m a
unsafeIOToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ForeignPtr (CairoSurfaceT s (PrimState m))
-> (Ptr (CairoSurfaceT s (PrimState m)) -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr (CairoSurfaceT s (PrimState m))
fsr \Ptr (CairoSurfaceT s (PrimState m))
psr -> Ptr (CairoSurfaceT s (PrimState m)) -> CDouble -> CDouble -> IO ()
forall s ps.
Ptr (CairoSurfaceT s ps) -> CDouble -> CDouble -> IO ()
c_cairo_pdf_surface_set_size Ptr (CairoSurfaceT s (PrimState m))
psr CDouble
w CDouble
h

foreign import ccall "cairo_pdf_surface_set_size" c_cairo_pdf_surface_set_size ::
	Ptr (CairoSurfaceT s ps) -> CDouble -> CDouble -> IO ()

mkMeta "CairoPdfMetadataTitle" 0
{-# LINE 153 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}
mkMeta "CairoPdfMetadataAuthor" 1
{-# LINE 154 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}
mkMeta "CairoPdfMetadataSubject" 2
{-# LINE 155 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}
mkMeta "CairoPdfMetadataKeywords" 3
{-# LINE 156 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}
mkMeta "CairoPdfMetadataCreator" 4
{-# LINE 157 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}
mkMeta "CairoPdfMetadataCreateDate" 5
{-# LINE 158 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}
mkMeta "CairoPdfMetadataModDate" 6
{-# LINE 159 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}

cairoPdfSurfaceSetMetadata :: PrimMonad m =>
	CairoSurfacePdfT s (PrimState m) -> CairoPdfMetadataT -> String -> m ()
cairoPdfSurfaceSetMetadata :: forall (m :: * -> *) s.
PrimMonad m =>
CairoSurfacePdfT s (PrimState m)
-> CairoPdfMetadataT -> FilePath -> m ()
cairoPdfSurfaceSetMetadata (CairoSurfacePdfT ForeignPtr (CairoSurfaceT s (PrimState m))
fsr STM (TChan ())
_) (CairoPdfMetadataT Word32
md) FilePath
v =
	IO () -> m ()
forall (m :: * -> *) a. PrimMonad m => IO a -> m a
unsafeIOToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ForeignPtr (CairoSurfaceT s (PrimState m))
-> (Ptr (CairoSurfaceT s (PrimState m)) -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr (CairoSurfaceT s (PrimState m))
fsr \Ptr (CairoSurfaceT s (PrimState m))
psr -> TextEncoding -> FilePath -> (CString -> IO ()) -> IO ()
forall a. TextEncoding -> FilePath -> (CString -> IO a) -> IO a
withCString TextEncoding
utf8 FilePath
v \CString
cv ->
		Ptr (CairoSurfaceT s (PrimState m)) -> Word32 -> CString -> IO ()
forall s ps. Ptr (CairoSurfaceT s ps) -> Word32 -> CString -> IO ()
c_cairo_pdf_surface_set_metadata Ptr (CairoSurfaceT s (PrimState m))
psr Word32
md CString
cv

foreign import ccall "cairo_pdf_surface_set_metadata" c_cairo_pdf_surface_set_metadata ::
	Ptr (CairoSurfaceT s ps) -> Word32 -> CString -> IO ()
{-# LINE 168 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}

cairoPdfSurfaceSetPageLabel :: PrimMonad m =>
	CairoSurfacePdfT s (PrimState m) -> String -> m ()
cairoPdfSurfaceSetPageLabel :: forall (m :: * -> *) s.
PrimMonad m =>
CairoSurfacePdfT s (PrimState m) -> FilePath -> m ()
cairoPdfSurfaceSetPageLabel (CairoSurfacePdfT ForeignPtr (CairoSurfaceT s (PrimState m))
fsr STM (TChan ())
_) FilePath
pl =
	IO () -> m ()
forall (m :: * -> *) a. PrimMonad m => IO a -> m a
unsafeIOToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ForeignPtr (CairoSurfaceT s (PrimState m))
-> (Ptr (CairoSurfaceT s (PrimState m)) -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr (CairoSurfaceT s (PrimState m))
fsr \Ptr (CairoSurfaceT s (PrimState m))
psr -> TextEncoding -> FilePath -> (CString -> IO ()) -> IO ()
forall a. TextEncoding -> FilePath -> (CString -> IO a) -> IO a
withCString TextEncoding
utf8 FilePath
pl \CString
cpl ->
		Ptr (CairoSurfaceT s (PrimState m)) -> CString -> IO ()
forall s ps. Ptr (CairoSurfaceT s ps) -> CString -> IO ()
c_cairo_pdf_surface_set_page_label Ptr (CairoSurfaceT s (PrimState m))
psr CString
cpl

foreign import ccall "cairo_pdf_surface_set_page_label" c_cairo_pdf_surface_set_page_label ::
	Ptr (CairoSurfaceT s ps) -> CString -> IO ()

mkVersion "CairoPdfVersion1_4" 0
{-# LINE 179 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}
mkVersion "CairoPdfVersion1_5" 1
{-# LINE 180 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}

cairoPdfSurfaceRestrictToVersion :: PrimMonad m =>
	CairoSurfacePdfT s (PrimState m) -> CairoPdfVersionT -> m ()
cairoPdfSurfaceRestrictToVersion :: forall (m :: * -> *) s.
PrimMonad m =>
CairoSurfacePdfT s (PrimState m) -> CairoPdfVersionT -> m ()
cairoPdfSurfaceRestrictToVersion (CairoSurfacePdfT ForeignPtr (CairoSurfaceT s (PrimState m))
fsr STM (TChan ())
_) (CairoPdfVersionT Word32
v) =
	IO () -> m ()
forall (m :: * -> *) a. PrimMonad m => IO a -> m a
unsafeIOToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ForeignPtr (CairoSurfaceT s (PrimState m))
-> (Ptr (CairoSurfaceT s (PrimState m)) -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr (CairoSurfaceT s (PrimState m))
fsr \Ptr (CairoSurfaceT s (PrimState m))
psr ->
		Ptr (CairoSurfaceT s (PrimState m)) -> Word32 -> IO ()
forall s ps. Ptr (CairoSurfaceT s ps) -> Word32 -> IO ()
c_cairo_pdf_surface_restrict_to_version Ptr (CairoSurfaceT s (PrimState m))
psr Word32
v

foreign import ccall "cairo_pdf_surface_restrict_to_version" c_cairo_pdf_surface_restrict_to_version ::
	Ptr (CairoSurfaceT s ps) -> Word32 -> IO ()
{-# LINE 189 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}

cairoPdfGetVersions :: IO [CairoPdfVersionT]
cairoPdfGetVersions :: IO [CairoPdfVersionT]
cairoPdfGetVersions = (Word32 -> CairoPdfVersionT
CairoPdfVersionT (Word32 -> CairoPdfVersionT) -> [Word32] -> [CairoPdfVersionT]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) ([Word32] -> [CairoPdfVersionT])
-> IO [Word32] -> IO [CairoPdfVersionT]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ptr (Ptr Word32) -> IO [Word32]) -> IO [Word32]
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca \Ptr (Ptr Word32)
ppv -> (Ptr CInt -> IO [Word32]) -> IO [Word32]
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca \Ptr CInt
pn -> do
	Ptr (Ptr Word32) -> Ptr CInt -> IO ()
c_cairo_pdf_get_versions Ptr (Ptr Word32)
ppv Ptr CInt
pn
	n <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
pn
	peekArray (fromIntegral n) =<< peek ppv

foreign import ccall "cairo_pdf_get_versions" c_cairo_pdf_get_versions ::
	Ptr (Ptr Word32) -> Ptr CInt -> IO ()
{-# LINE 198 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}

cairoPdfVersionToString :: CairoPdfVersionT -> IO String
cairoPdfVersionToString :: CairoPdfVersionT -> IO FilePath
cairoPdfVersionToString (CairoPdfVersionT Word32
v) = CString -> IO FilePath
peekCString (CString -> IO FilePath) -> IO CString -> IO FilePath
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Word32 -> IO CString
c_cairo_pdf_version_to_string Word32
v

foreign import ccall "cairo_pdf_version_to_string" c_cairo_pdf_version_to_string ::
	Word32 -> IO CString
{-# LINE 204 "src/Graphics/Cairo/Surfaces/PdfSurfaces.hsc" #-}