freetype2 0.0.1 → 0.1.0

raw patch · 30 files changed

+1513/−76 lines, 30 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• Graphics/Rendering/FreeType/Internal.hsc +170/−0
• Graphics/Rendering/FreeType/Internal/BBox.hsc +46/−0
• Graphics/Rendering/FreeType/Internal/BitmapGlyph.hsc +36/−0
• Graphics/Rendering/FreeType/Internal/BitmapSize.hsc +41/−0
• Graphics/Rendering/FreeType/Internal/CharMap.hsc +35/−0
• Graphics/Rendering/FreeType/Internal/Driver.hs +10/−0
• Graphics/Rendering/FreeType/Internal/Face.hsc +150/−18
• Graphics/Rendering/FreeType/Internal/FaceType.hs +10/−0
• Graphics/Rendering/FreeType/Internal/Generic.hsc +37/−0
• Graphics/Rendering/FreeType/Internal/Glyph.hsc +4/−12
• Graphics/Rendering/FreeType/Internal/GlyphMetrics.hsc +59/−0
• Graphics/Rendering/FreeType/Internal/GlyphSlot.hsc +69/−18
• Graphics/Rendering/FreeType/Internal/Library.hs +11/−0
• Graphics/Rendering/FreeType/Internal/Library.hsc +0/−26
• Graphics/Rendering/FreeType/Internal/Memory.hsc +49/−0
• Graphics/Rendering/FreeType/Internal/Module.hs +11/−0
• Graphics/Rendering/FreeType/Internal/OpenArgs.hsc +53/−0
• Graphics/Rendering/FreeType/Internal/Outline.hsc +108/−0
• Graphics/Rendering/FreeType/Internal/OutlineGlyph.hsc +28/−0
• Graphics/Rendering/FreeType/Internal/Parameter.hsc +34/−0
• Graphics/Rendering/FreeType/Internal/PrimitiveTypes.hsc +168/−0
• Graphics/Rendering/FreeType/Internal/RasterParams.hsc +85/−0
• Graphics/Rendering/FreeType/Internal/Renderer.hs +11/−0
• Graphics/Rendering/FreeType/Internal/Size.hsc +35/−0
• Graphics/Rendering/FreeType/Internal/SizeMetrics.hsc +59/−0
• Graphics/Rendering/FreeType/Internal/SizeRequest.hsc +48/−0
• Graphics/Rendering/FreeType/Internal/Span.hsc +41/−0
• Graphics/Rendering/FreeType/Internal/Stream.hsc +71/−0
• Graphics/Rendering/FreeType/Internal/SubGlyph.hs +10/−0
• freetype2.cabal +24/−2

@@ -11,6 +11,15 @@ import Graphics.Rendering.FreeType.Internal.Vector import Graphics.Rendering.FreeType.Internal.Glyph import Graphics.Rendering.FreeType.Internal.GlyphSlot+import Graphics.Rendering.FreeType.Internal.OpenArgs+import Graphics.Rendering.FreeType.Internal.SizeRequest+import Graphics.Rendering.FreeType.Internal.CharMap+import Graphics.Rendering.FreeType.Internal.Outline+import Graphics.Rendering.FreeType.Internal.Memory+import Graphics.Rendering.FreeType.Internal.BBox+import Graphics.Rendering.FreeType.Internal.Bitmap+import Graphics.Rendering.FreeType.Internal.RasterParams+import Graphics.Rendering.FreeType.Internal.Size  #include "ft2build.h" #include FT_FREETYPE_H@@ -58,3 +67,164 @@ foreign import ccall "FT_Glyph_To_Bitmap"   ft_Glyph_To_Bitmap :: Ptr FT_Glyph  -> FT_Render_Mode                      -> Ptr FT_Vector -> FT_Bool -> IO FT_Error++foreign import ccall "FT_Library_Version"+  ft_Library_Version :: FT_Library -> Ptr FT_Int+                     -> Ptr FT_Int -> Ptr FT_Int -> IO ()++-- | This is just here for completeness,+-- TrueType hinting is no longer patented+foreign import ccall "FT_Face_CheckTrueTypePatents"+  ft_Face_CheckTrueTypePatents :: FT_Face -> IO FT_Bool++-- | This is just here for completeness,+-- TrueType hinting is no longer patented.+foreign import ccall "FT_Face_SetUnpatentedHinting"+  ft_Face_SetUnpatentedHinting :: FT_Face -> FT_Bool -> IO FT_Bool++foreign import ccall "FT_New_Memory_Face"+  ft_New_Memory_Face :: FT_Library -> FT_Bytes -> FT_Long+                     -> FT_Long -> Ptr FT_Face -> IO FT_Error++foreign import ccall "FT_Open_Face"+  ft_Open_Face :: FT_Library -> Ptr FT_Open_Args+               -> FT_Long -> Ptr FT_Face -> IO FT_Error++foreign import ccall "FT_Attach_File"+  ft_Attach_File :: FT_Face -> CString -> IO FT_Error++foreign import ccall "FT_Attach_Stream"+  ft_Attach_Stream :: FT_Face -> Ptr FT_Open_Args -> IO FT_Error++foreign import ccall "FT_Reference_Face"+  ft_Reference_Face :: FT_Face -> IO FT_Error++foreign import ccall "FT_Select_Size"+  ft_Select_Size :: FT_Face -> FT_Int -> IO FT_Error++foreign import ccall "FT_Request_Size"+  ft_Request_Size :: FT_Face -> FT_Size_Request -> IO FT_Error++foreign import ccall "FT_Render_Glyph"+  ft_Render_Glyph :: FT_GlyphSlot -> FT_Render_Mode -> IO FT_Error++foreign import ccall "FT_Get_Kerning"+  ft_Get_Kerning :: FT_Face -> FT_UInt -> FT_UInt -> FT_UInt+                 -> Ptr FT_Vector -> IO FT_Error++foreign import ccall "FT_Get_Track_Kerning"+  ft_Get_Track_Kerning :: FT_Face -> FT_Fixed -> FT_Int+                       -> Ptr FT_Fixed -> IO FT_Error++foreign import ccall "FT_Get_Glyph_Name"+  ft_Get_Glyph_Name :: FT_Face -> FT_UInt -> FT_Pointer+                    -> FT_UInt -> IO FT_Error++foreign import ccall "FT_Get_Postscript_Name"+  ft_Get_Postscript_Name :: FT_Face -> IO CString++foreign import ccall "FT_Select_Charmap"+  ft_Select_Charmap :: FT_Face -> FT_Encoding -> IO FT_Error++foreign import ccall "FT_Set_Charmap"+  ft_Set_Charmap :: FT_Face -> FT_CharMap -> IO FT_Error++foreign import ccall "FT_Get_Charmap_Index"+  ft_Get_Charmap_Index :: FT_CharMap -> IO FT_Int++foreign import ccall "FT_Get_First_Char"+  ft_Get_First_Char :: FT_Face -> Ptr FT_UInt -> IO FT_ULong ++foreign import ccall "FT_Get_Next_Char"+  ft_Get_Next_Char :: FT_Face -> FT_ULong -> Ptr FT_UInt -> IO FT_ULong++foreign import ccall "FT_Get_Name_Index"+  ft_Get_Name_Index :: FT_Face -> CString -> IO FT_UInt++foreign import ccall "FT_Get_SubGlyph_Info"+  ft_Get_SubGlyph_Info :: FT_GlyphSlot -> FT_UInt+                       -> Ptr FT_Int -> Ptr FT_UInt+                       -> Ptr FT_Int -> Ptr FT_Int+                       -> Ptr FT_Matrix -> IO FT_Error++foreign import ccall "FT_Get_FSType_Flags"+  ft_Get_FSType_Flags :: FT_Face -> IO FT_UShort++foreign import ccall "FT_Face_GetCharVariantIndex"+  ft_Face_GetCharVariantIndex :: FT_Face -> FT_ULong -> FT_ULong -> IO FT_UInt++foreign import ccall "FT_Face_GetCharVariantIsDefault"+  ft_Face_GetCharVariantIsDefault :: FT_Face -> FT_ULong+                                  -> FT_ULong -> IO FT_Int++foreign import ccall "FT_Face_GetVariantSelectors"+  ft_Face_GetVariantSelectors :: FT_Face -> IO (Ptr FT_UInt32)++foreign import ccall "FT_Face_GetVariantsOfChar"+  ft_Face_GetVariantsOfChar :: FT_Face -> FT_ULong -> IO (Ptr FT_UInt32)++foreign import ccall "FT_Face_GetCharsOfVariant"+  ft_Face_GetCharsOfVariant :: FT_Face -> FT_ULong -> IO (Ptr FT_UInt32)++foreign import ccall "FT_Outline_New"+  ft_Outline_New :: FT_Library -> FT_UInt -> FT_Int+                 -> Ptr FT_Outline -> IO FT_Error++foreign import ccall "FT_Outline_New_Internal"+  ft_Outline_New_Internal :: FT_Memory -> FT_UInt -> FT_Int+                          -> Ptr FT_Outline -> IO FT_Error++foreign import ccall "FT_Outline_Done"+  ft_Outline_Done :: FT_Library -> Ptr FT_Outline -> IO FT_Error++foreign import ccall "FT_Outline_Done_Internal"+  ft_Outline_Done_Internal :: FT_Memory -> Ptr FT_Outline -> IO FT_Error++foreign import ccall "FT_Outline_Copy"+  ft_Outline_Copy :: Ptr FT_Outline -> Ptr FT_Outline -> IO FT_Error++foreign import ccall "FT_Outline_Translate"+  ft_Outline_Translate :: Ptr FT_Outline -> FT_Pos -> FT_Pos -> IO ()++foreign import ccall "FT_Outline_Transform"+  ft_Outline_Transform :: Ptr FT_Outline -> Ptr FT_Matrix -> IO ()++foreign import ccall "FT_Outline_Embolden"+  ft_Outline_Embolden :: Ptr FT_Outline -> FT_Pos -> IO FT_Error++foreign import ccall "FT_Outline_Reverse"+  ft_Outline_Reverse :: Ptr FT_Outline -> IO ()++foreign import ccall "FT_Outline_Check"+  ft_Outline_Check :: Ptr FT_Outline -> IO FT_Error++foreign import ccall "FT_Outline_Get_BBox"+  ft_Outline_Get_BBox :: Ptr FT_Outline -> Ptr FT_BBox -> IO FT_Error++foreign import ccall "FT_Outline_Decompose"+  ft_Outline_Decompose :: Ptr FT_Outline -> Ptr FT_Outline_Funcs+                       -> Ptr a -> IO FT_Error++foreign import ccall "FT_Outline_Get_CBox"+  ft_Outline_Get_CBox :: Ptr FT_Outline -> Ptr FT_BBox -> IO ()++foreign import ccall "FT_Outline_Get_Bitmap"+  ft_Outline_Get_Bitmap :: FT_Library -> Ptr FT_Outline+                        -> Ptr FT_Bitmap -> IO FT_Error++foreign import ccall "FT_Outline_Render"+  ft_Outline_Render :: FT_Library -> Ptr FT_Outline+                    -> Ptr FT_Raster_Params -> IO FT_Error++foreign import ccall "FT_Outline_Get_Orientation"+  ft_Outline_Get_Orientation :: Ptr FT_Outline -> IO FT_Orientation++foreign import ccall "FT_New_Size"+  ft_New_Size :: FT_Face -> Ptr FT_Size -> IO FT_Error++foreign import ccall "FT_Done_Size"+  ft_Done_Size :: FT_Size -> IO FT_Error++foreign import ccall "FT_Activate_Size"+  ft_Activate_Size :: FT_Size -> IO FT_Error+

@@ -0,0 +1,46 @@+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.BBox
+( FT_BBox(..)
+) where
+
+import Foreign
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+#include "freetype/ftimage.h"
+
+data FT_BBox = FT_BBox
+  { xMin :: FT_Pos
+  , yMin :: FT_Pos
+  , xMax :: FT_Pos
+  , yMax :: FT_Pos
+  }
+  deriving (Read, Show, Eq)
+
+instance Storable FT_BBox where
+  sizeOf    _ = #size FT_BBox
+  alignment _ = #alignment FT_BBox
+  peek ptr = do
+    xMin' <- (#peek FT_BBox, xMin) ptr
+    yMin' <- (#peek FT_BBox, yMin) ptr
+    xMax' <- (#peek FT_BBox, xMax) ptr
+    yMax' <- (#peek FT_BBox, yMax) ptr
+    return $ FT_BBox
+      { xMin = xMin'
+      , yMin = yMin'
+      , xMax = xMax'
+      , yMax = yMax'
+      }
+  poke ptr val = do
+    (#poke FT_BBox, xMin) ptr (xMin val)
+    (#poke FT_BBox, yMin) ptr (yMin val)
+    (#poke FT_BBox, xMax) ptr (xMax val)
+    (#poke FT_BBox, yMax) ptr (yMax val)
+

@@ -0,0 +1,36 @@+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.BitmapGlyph
+( FT_BitmapGlyph
+, root
+, left
+, top
+, bitmap
+, cast
+) where
+
+import Foreign
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+#include "freetype/ftglyph.h"
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+import Graphics.Rendering.FreeType.Internal.Bitmap
+import Graphics.Rendering.FreeType.Internal.Glyph
+
+newtype FT_BitmapGlyph = FT_BitmapGlyph FT_Glyph
+
+root :: FT_BitmapGlyph -> FT_Glyph
+root (FT_BitmapGlyph ptr) = ptr
+
+left :: FT_BitmapGlyph -> Ptr FT_Int
+left (FT_BitmapGlyph ptr) = (#ptr struct FT_BitmapGlyphRec_, left) ptr
+
+top :: FT_BitmapGlyph -> Ptr FT_Int
+top (FT_BitmapGlyph ptr) = (#ptr struct FT_BitmapGlyphRec_, top) ptr
+
+bitmap :: FT_BitmapGlyph -> Ptr FT_Bitmap
+bitmap (FT_BitmapGlyph ptr) = (#ptr struct FT_BitmapGlyphRec_, bitmap) ptr
+
+cast :: FT_Glyph -> FT_BitmapGlyph
+cast = FT_BitmapGlyph

@@ -0,0 +1,41 @@+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.BitmapSize
+( FT_Bitmap_Size(..)
+) where
+
+import Foreign
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+data FT_Bitmap_Size = FT_Bitmap_Size
+  { height :: FT_Short
+  , width  :: FT_Short
+  , size   :: FT_Pos
+  , x_ppem :: FT_Pos
+  , y_ppem :: FT_Pos
+  }
+  deriving (Read, Show, Eq)
+
+instance Storable FT_Bitmap_Size where
+  sizeOf   _  = #size FT_Bitmap_Size
+  alignment _ = #alignment FT_Bitmap_Size
+  peek ptr = do
+    height' <- (#peek FT_Bitmap_Size, height) ptr
+    width'  <- (#peek FT_Bitmap_Size, width) ptr
+    size'   <- (#peek FT_Bitmap_Size, size) ptr
+    x_ppem' <- (#peek FT_Bitmap_Size, x_ppem) ptr
+    y_ppem' <- (#peek FT_Bitmap_Size, y_ppem) ptr
+    return $ FT_Bitmap_Size
+      { height = height'
+      , width = width'
+      , size = size'
+      , x_ppem = x_ppem'
+      , y_ppem = y_ppem'
+      }

@@ -0,0 +1,35 @@+{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.CharMap
+( FT_CharMapRec
+, FT_CharMap
+, face
+, encoding
+, platform_id
+, encoding_id
+) where
+
+import Foreign
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+import Graphics.Rendering.FreeType.Internal.FaceType
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+data FT_CharMapRec
+type FT_CharMap = Ptr FT_CharMapRec
+
+face :: FT_CharMap -> Ptr FT_Face
+face = #ptr FT_CharMapRec, face
+
+encoding :: FT_CharMap -> Ptr FT_Encoding
+encoding = #ptr FT_CharMapRec, encoding
+
+platform_id :: FT_CharMap -> Ptr FT_UShort
+platform_id = #ptr FT_CharMapRec, platform_id
+
+encoding_id :: FT_CharMap -> Ptr FT_UShort
+encoding_id = #ptr FT_CharMapRec, encoding_id

@@ -0,0 +1,10 @@+{-# LANGUAGE EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.Driver
+( FT_DriverRec_
+, FT_Driver
+) where
+
+import Foreign
+
+data FT_DriverRec_
+type FT_Driver = Ptr FT_DriverRec_

@@ -1,45 +1,177 @@-{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-}+{-# LANGUAGE ForeignFunctionInterface #-} module Graphics.Rendering.FreeType.Internal.Face ( FT_FaceRec_ , FT_Face , num_faces+, face_index+, face_flags+, style_flags , num_glyphs-, glyph+, family_name+, style_name+, num_fixed_sizes+, available_sizes+, num_charmaps+, charmaps+, generic+, bbox+, units_per_EM+, ascender+, descender+, height+, max_advance_width+, max_advance_height+, underline_position , underline_thickness+, glyph+, size+, charmap+, ft_HAS_HORIZONTAL+, ft_HAS_VERTICAL+, ft_HAS_KERNING+, ft_IS_SCALABLE+, ft_IS_SFNT+, ft_IS_FIXED_WIDTH+, ft_HAS_FIXED_SIZES+, ft_HAS_FAST_GLYPHS+, ft_HAS_GLYPH_NAMES+, ft_HAS_MULTIPLE_MASTERS+, ft_IS_CID_KEYED+, ft_IS_TRICKY+, ft_STYLE_FLAG_ITALIC+, ft_STYLE_FLAG_BOLD ) where  import Foreign-import Foreign.Storable+import Foreign.C.String +import Graphics.Rendering.FreeType.Internal.FaceType import Graphics.Rendering.FreeType.Internal.PrimitiveTypes+import qualified Graphics.Rendering.FreeType.Internal.Generic as G import qualified Graphics.Rendering.FreeType.Internal.GlyphSlot as GS--#include <stddef.h>-#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)+import qualified Graphics.Rendering.FreeType.Internal.Size as S+import qualified Graphics.Rendering.FreeType.Internal.BitmapSize as BS+import qualified Graphics.Rendering.FreeType.Internal.CharMap as CM+import qualified Graphics.Rendering.FreeType.Internal.BBox as BB  #include "ft2build.h" #include FT_FREETYPE_H -#include "internal/ftobjs.h"+num_faces :: FT_Face -> Ptr FT_Long+num_faces = #ptr struct FT_FaceRec_, num_faces -data FT_FaceRec_-type FT_Face = Ptr FT_FaceRec_+face_index :: FT_Face -> Ptr FT_Long+face_index = #ptr struct FT_FaceRec_, face_index -instance Storable FT_FaceRec_ where-  sizeOf _    = #size struct FT_FaceRec_-  alignment _ = #alignment struct FT_FaceRec_-  peek = error "peek not implemented for FT_FaceRec_"-  poke = error "poke not implemented for FT_FaceRec_"+face_flags :: FT_Face -> Ptr FT_Long+face_flags = #ptr struct FT_FaceRec_, face_flags -num_faces :: FT_Face -> Ptr FT_Long-num_faces = #ptr struct FT_FaceRec_, num_faces+style_flags :: FT_Face -> Ptr FT_Long+style_flags = #ptr struct FT_FaceRec_, style_flags  num_glyphs :: FT_Face -> Ptr FT_Long num_glyphs = #ptr struct FT_FaceRec_, num_glyphs -glyph :: FT_Face -> Ptr GS.FT_GlyphSlot-glyph = #ptr struct FT_FaceRec_, glyph+family_name :: FT_Face -> Ptr CString+family_name = #ptr struct FT_FaceRec_, family_name +style_name :: FT_Face -> Ptr CString+style_name = #ptr struct FT_FaceRec_, style_name++num_fixed_sizes :: FT_Face -> Ptr FT_Int+num_fixed_sizes = #ptr struct FT_FaceRec_, num_fixed_sizes++available_sizes :: FT_Face -> Ptr (Ptr BS.FT_Bitmap_Size)+available_sizes = #ptr struct FT_FaceRec_, available_sizes++num_charmaps :: FT_Face -> Ptr FT_Int+num_charmaps = #ptr struct FT_FaceRec_, num_charmaps++charmaps :: FT_Face -> Ptr (Ptr CM.FT_CharMap)+charmaps = #ptr struct FT_FaceRec_, charmaps++generic :: FT_Face -> Ptr G.FT_Generic+generic = #ptr struct FT_FaceRec_, generic++bbox :: FT_Face -> Ptr BB.FT_BBox+bbox = #ptr struct FT_FaceRec_, bbox++units_per_EM :: FT_Face -> Ptr FT_UShort+units_per_EM = #ptr struct FT_FaceRec_, units_per_EM++ascender :: FT_Face -> Ptr FT_Short+ascender = #ptr struct FT_FaceRec_, ascender++descender :: FT_Face -> Ptr FT_Short+descender = #ptr struct FT_FaceRec_, descender++height :: FT_Face -> Ptr FT_Short+height = #ptr struct FT_FaceRec_, height++max_advance_width :: FT_Face -> Ptr FT_Short+max_advance_width = #ptr struct FT_FaceRec_, max_advance_width++max_advance_height :: FT_Face -> Ptr FT_Short+max_advance_height = #ptr struct FT_FaceRec_, max_advance_height++underline_position :: FT_Face -> Ptr FT_Short+underline_position = #ptr struct FT_FaceRec_, underline_position+ underline_thickness :: FT_Face -> Ptr FT_Short underline_thickness = #ptr struct FT_FaceRec_, underline_thickness +glyph :: FT_Face -> Ptr GS.FT_GlyphSlot+glyph = #ptr struct FT_FaceRec_, glyph++size :: FT_Face -> Ptr S.FT_Size+size = #ptr struct FT_FaceRec_, size++charmap :: FT_Face -> Ptr CM.FT_CharMap+charmap = #ptr struct FT_FaceRec_, charmap++ft_HAS :: FT_FACE_FLAG -> FT_Face -> IO Bool+ft_HAS flag face = do+  f <- peek $ face_flags face+  return $ 0 /= (f .&. fromIntegral flag)++ft_HAS_HORIZONTAL :: FT_Face -> IO Bool+ft_HAS_HORIZONTAL = ft_HAS ft_FACE_FLAG_HORIZONTAL++ft_HAS_VERTICAL :: FT_Face -> IO Bool+ft_HAS_VERTICAL = ft_HAS ft_FACE_FLAG_VERTICAL++ft_HAS_KERNING :: FT_Face -> IO Bool+ft_HAS_KERNING = ft_HAS ft_FACE_FLAG_KERNING++ft_IS_SCALABLE :: FT_Face -> IO Bool+ft_IS_SCALABLE = ft_HAS ft_FACE_FLAG_SCALABLE++ft_IS_SFNT :: FT_Face -> IO Bool+ft_IS_SFNT = ft_HAS ft_FACE_FLAG_SFNT++ft_IS_FIXED_WIDTH :: FT_Face -> IO Bool+ft_IS_FIXED_WIDTH = ft_HAS ft_FACE_FLAG_FIXED_WIDTH++ft_HAS_FIXED_SIZES :: FT_Face -> IO Bool+ft_HAS_FIXED_SIZES = ft_HAS ft_FACE_FLAG_FIXED_SIZES++ft_HAS_FAST_GLYPHS :: FT_Face -> IO Bool+ft_HAS_FAST_GLYPHS = ft_HAS ft_FACE_FLAG_FAST_GLYPHS++ft_HAS_GLYPH_NAMES :: FT_Face -> IO Bool+ft_HAS_GLYPH_NAMES = ft_HAS ft_FACE_FLAG_GLYPH_NAMES++ft_HAS_MULTIPLE_MASTERS :: FT_Face -> IO Bool+ft_HAS_MULTIPLE_MASTERS = ft_HAS ft_FACE_FLAG_MULTIPLE_MASTERS++ft_IS_CID_KEYED :: FT_Face -> IO Bool+ft_IS_CID_KEYED = ft_HAS ft_FACE_FLAG_CID_KEYED++ft_IS_TRICKY :: FT_Face -> IO Bool+ft_IS_TRICKY = ft_HAS ft_FACE_FLAG_TRICKY++ft_STYLE_FLAG_ITALIC :: FT_Long+ft_STYLE_FLAG_ITALIC = #const FT_STYLE_FLAG_ITALIC++ft_STYLE_FLAG_BOLD :: FT_Long+ft_STYLE_FLAG_BOLD = #const FT_STYLE_FLAG_BOLD 

@@ -0,0 +1,10 @@+{-# LANGUAGE EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.FaceType
+( FT_FaceRec_
+, FT_Face
+) where
+
+import Foreign
+
+data FT_FaceRec_
+type FT_Face = Ptr FT_FaceRec_

@@ -0,0 +1,37 @@+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.Generic
+( FT_Generic(..)
+, FT_Generic_Finalizer
+) where
+
+import Foreign
+import Foreign.Storable
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+type FT_Generic_Finalizer = FunPtr (Ptr () -> IO ())
+
+data FT_Generic = FT_Generic
+  { data_ :: Ptr ()
+  , finalizer :: FT_Generic_Finalizer
+  }
+
+instance Storable FT_Generic where
+  sizeOf    _ = #size FT_Generic
+  alignment _ = #alignment FT_Generic
+  -- Is peek/poke defined correctly given that data is a void*
+  -- and finalizer is a function pointer?
+  peek ptr = do
+    data_'     <- (#peek FT_Generic, data) ptr
+    finalizer' <- (#peek FT_Generic, finalizer) ptr
+    return $ FT_Generic
+      { data_ = data_'
+      , finalizer = finalizer'
+      }
+  poke ptr val = do
+    (#poke FT_Generic, data) ptr (data_ val)
+    (#poke FT_Generic, finalizer) ptr (finalizer val) 

@@ -3,14 +3,14 @@ ( FT_GlyphRec_
 , FT_Glyph
 , library
+, format
 , advance
 ) where
 
 import Foreign
-import Foreign.Storable
 
--- import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
-import qualified Graphics.Rendering.FreeType.Internal.Library as Lib
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+import qualified Graphics.Rendering.FreeType.Internal.Library as L
 import qualified Graphics.Rendering.FreeType.Internal.Vector  as V
 
 #include <stddef.h>
@@ -24,19 +24,11 @@ data FT_GlyphRec_
 type FT_Glyph = Ptr FT_GlyphRec_
 
-instance Storable FT_GlyphRec_ where
-  sizeOf    _  = #size struct FT_GlyphRec_
-  alignment _  = #alignment struct FT_GlyphRec_
-  peek = error "peek not implemented for FT_GlyphRec_"
-  poke = error "peek not implemented for FT_GlyphRec_"
-
-library :: FT_Glyph -> Ptr Lib.FT_Library
+library :: FT_Glyph -> Ptr L.FT_Library
 library = #ptr struct FT_GlyphRec_, library
 
-{- TODO: implement FT_Glyph_Format
 format :: FT_Glyph -> Ptr FT_Glyph_Format
 format = #ptr struct FT_GlyphRec_, format
--}
 
 advance :: FT_Glyph -> Ptr V.FT_Vector
 advance = #ptr struct FT_GlyphRec_, advance

@@ -0,0 +1,59 @@+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.GlyphMetrics
+( FT_Glyph_Metrics(..)
+) where
+
+import Foreign
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+data FT_Glyph_Metrics = FT_Glyph_Metrics
+  { width        :: FT_Pos
+  , height       :: FT_Pos
+  , horiBearingX :: FT_Pos
+  , horiBearingY :: FT_Pos
+  , horiAdvance  :: FT_Pos
+  , vertBearingX :: FT_Pos
+  , vertBearingY :: FT_Pos
+  , vertAdvance  :: FT_Pos
+  }
+  deriving (Read, Show, Eq)
+
+instance Storable FT_Glyph_Metrics where
+  sizeOf    _ = #size FT_Glyph_Metrics
+  alignment _ = #alignment FT_Glyph_Metrics
+  peek ptr = do
+    width'  <- (#peek FT_Glyph_Metrics, width) ptr
+    height' <- (#peek FT_Glyph_Metrics, height) ptr
+    horiBearingX' <- (#peek FT_Glyph_Metrics, horiBearingX) ptr
+    horiBearingY' <- (#peek FT_Glyph_Metrics, horiBearingY) ptr
+    horiAdvance'  <- (#peek FT_Glyph_Metrics, horiAdvance) ptr
+    vertBearingX' <- (#peek FT_Glyph_Metrics, vertBearingX) ptr
+    vertBearingY' <- (#peek FT_Glyph_Metrics, vertBearingY) ptr
+    vertAdvance'  <- (#peek FT_Glyph_Metrics, vertAdvance) ptr
+    return $ FT_Glyph_Metrics
+      { width = width'
+      , height = height'
+      , horiBearingX = horiBearingX'
+      , horiBearingY = horiBearingY'
+      , horiAdvance  = horiAdvance'
+      , vertBearingX = vertBearingX'
+      , vertBearingY = vertBearingY'
+      , vertAdvance  = vertAdvance'
+      }
+  poke ptr val = do
+    (#poke FT_Glyph_Metrics, width) ptr (width val)
+    (#poke FT_Glyph_Metrics, height) ptr (height val)
+    (#poke FT_Glyph_Metrics, horiBearingX) ptr (horiBearingX val)
+    (#poke FT_Glyph_Metrics, horiBearingY) ptr (horiBearingY val)
+    (#poke FT_Glyph_Metrics, horiAdvance) ptr (horiAdvance val)
+    (#poke FT_Glyph_Metrics, vertBearingX) ptr (vertBearingX val)
+    (#poke FT_Glyph_Metrics, vertBearingY) ptr (vertBearingY val)
+    (#poke FT_Glyph_Metrics, vertAdvance) ptr (vertAdvance val)

@@ -3,48 +3,99 @@ ( FT_GlyphSlotRec_
 , FT_GlyphSlot
 , library
+, face
+, next
+, generic
+, metrics
+, linearHoriAdvance
+, linearVertAdvance
 , advance
+, format
 , bitmap
 , bitmap_top
 , bitmap_left
+, outline
+, num_subglyphs
+, subglyphs
+, control_data
+, control_len
+, lsb_delta
+, rsb_delta
 ) where
 
 import Foreign
-import Foreign.Storable
+import Foreign.C.Types
 
 import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
-import qualified Graphics.Rendering.FreeType.Internal.Library as Lib
+import qualified Graphics.Rendering.FreeType.Internal.Generic as G
+import qualified Graphics.Rendering.FreeType.Internal.Library as L
+import qualified Graphics.Rendering.FreeType.Internal.FaceType as F
 import qualified Graphics.Rendering.FreeType.Internal.Vector  as V
 import qualified Graphics.Rendering.FreeType.Internal.Bitmap as B
-
-#include <stddef.h>
-#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+import qualified Graphics.Rendering.FreeType.Internal.SubGlyph as SG
+import qualified Graphics.Rendering.FreeType.Internal.GlyphMetrics as GM
+import qualified Graphics.Rendering.FreeType.Internal.Outline as O
 
 #include "ft2build.h"
 #include FT_FREETYPE_H
 
-#include "internal/ftobjs.h"
-
 data FT_GlyphSlotRec_
 type FT_GlyphSlot = Ptr FT_GlyphSlotRec_
 
-instance Storable FT_GlyphSlotRec_ where
-  sizeOf _    = #size struct FT_GlyphSlotRec_
-  alignment _ = #alignment struct FT_GlyphSlotRec_
-  peek = error "peek not implemented for FT_GlyphSlotRec_"
-  poke = error "poke not implemented for FT_GlyphSlotRec_"
+library :: FT_GlyphSlot -> Ptr L.FT_Library
+library = #ptr struct FT_GlyphSlotRec_, library
 
-library :: FT_GlyphSlot -> Lib.FT_Library
-library = (#ptr struct FT_GlyphSlotRec_, library)
+face :: FT_GlyphSlot -> Ptr F.FT_Face
+face = #ptr struct FT_GlyphSlotRec_, face
 
+next :: FT_GlyphSlot -> Ptr FT_GlyphSlot
+next = #ptr struct FT_GlyphSlotRec_, next
+
+generic :: FT_GlyphSlot -> Ptr G.FT_Generic
+generic = #ptr struct FT_GlyphSlotRec_, generic
+
+metrics :: FT_GlyphSlot -> Ptr GM.FT_Glyph_Metrics
+metrics = #ptr struct FT_GlyphSlotRec_, metrics
+
+linearHoriAdvance :: FT_GlyphSlot -> Ptr FT_Fixed
+linearHoriAdvance = #ptr struct FT_GlyphSlotRec_, linearHoriAdvance
+
+linearVertAdvance :: FT_GlyphSlot -> Ptr FT_Fixed
+linearVertAdvance = #ptr struct FT_GlyphSlotRec_, linearVertAdvance
+
 advance :: FT_GlyphSlot -> Ptr V.FT_Vector
-advance = (#ptr struct FT_GlyphSlotRec_, advance)
+advance = #ptr struct FT_GlyphSlotRec_, advance
 
+format :: FT_GlyphSlot -> Ptr FT_Glyph_Format
+format = #ptr struct FT_GlyphSlotRec_, format
+
 bitmap :: FT_GlyphSlot -> Ptr B.FT_Bitmap
-bitmap = (#ptr struct FT_GlyphSlotRec_, bitmap)
+bitmap = #ptr struct FT_GlyphSlotRec_, bitmap
 
 bitmap_left :: FT_GlyphSlot -> Ptr FT_Int
-bitmap_left = (#ptr struct FT_GlyphSlotRec_, bitmap_left)
+bitmap_left = #ptr struct FT_GlyphSlotRec_, bitmap_left
 
 bitmap_top :: FT_GlyphSlot -> Ptr FT_Int
-bitmap_top = (#ptr struct FT_GlyphSlotRec_, bitmap_top)
+bitmap_top = #ptr struct FT_GlyphSlotRec_, bitmap_top
+
+outline :: FT_GlyphSlot -> Ptr O.FT_Outline
+outline = #ptr struct FT_GlyphSlotRec_, outline
+
+num_subglyphs :: FT_GlyphSlot -> Ptr FT_UInt
+num_subglyphs = #ptr struct FT_GlyphSlotRec_, num_subglyphs
+
+subglyphs :: FT_GlyphSlot -> Ptr SG.FT_SubGlyph
+subglyphs = #ptr struct FT_GlyphSlotRec_, subglyphs
+
+control_data :: FT_GlyphSlot -> Ptr a
+control_data = #ptr struct FT_GlyphSlotRec_, control_data
+
+control_len :: FT_GlyphSlot -> Ptr CLong
+control_len = #ptr struct FT_GlyphSlotRec_, control_len
+
+lsb_delta :: FT_GlyphSlot -> Ptr FT_Pos
+lsb_delta = #ptr struct FT_GlyphSlotRec_, lsb_delta
+
+rsb_delta :: FT_GlyphSlot -> Ptr FT_Pos
+rsb_delta = #ptr struct FT_GlyphSlotRec_, rsb_delta
+

@@ -0,0 +1,11 @@+{-# LANGUAGE EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.Library
+( FT_LibraryRec_
+, FT_Library
+) where
+
+import Foreign
+
+data FT_LibraryRec_
+type FT_Library = Ptr FT_LibraryRec_
+

@@ -1,26 +0,0 @@-{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-}
-module Graphics.Rendering.FreeType.Internal.Library
-( FT_LibraryRec_
-, FT_Library
-) where
-
-import Foreign
-import Foreign.Storable
-
-#include <stddef.h>
-#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
-
-#include "ft2build.h"
-#include FT_FREETYPE_H
-
-#include "internal/ftobjs.h"
-
-data FT_LibraryRec_
-type FT_Library = Ptr FT_LibraryRec_
-
-instance Storable FT_LibraryRec_ where
-  sizeOf _    = #size struct FT_LibraryRec_
-  alignment _ = #alignment struct FT_LibraryRec_
-  peek = error "peek not implemented for FT_LibraryRec_"
-  poke = error "poke not implemented for FT_LibraryRec_"
-

@@ -0,0 +1,49 @@+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.Memory
+( FT_MemoryRec(..)
+, FT_Memory
+) where
+
+import Foreign hiding (free, realloc)
+import Foreign.C.Types
+import Foreign.Storable
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+type FT_Alloc_Func   = FunPtr (FT_Memory -> CLong -> IO (Ptr ()))
+type FT_Free_Func    = FunPtr (FT_Memory -> Ptr () -> IO ())
+type FT_Realloc_Func = FunPtr
+  (FT_Memory -> CLong -> CLong -> Ptr () -> IO (Ptr ()))
+                     
+
+type FT_Memory = Ptr FT_MemoryRec
+data FT_MemoryRec = FT_MemoryRec
+  { user    :: Ptr ()
+  , alloc   :: FT_Alloc_Func
+  , free    :: FT_Free_Func
+  , realloc :: FT_Realloc_Func
+  }
+
+instance Storable FT_MemoryRec where
+  sizeOf    _ = #size struct FT_MemoryRec_
+  alignment _ = #alignment struct FT_MemoryRec_
+  peek ptr = do
+    user'    <- (#peek struct FT_MemoryRec_, user) ptr
+    alloc'   <- (#peek struct FT_MemoryRec_, alloc) ptr
+    free'    <- (#peek struct FT_MemoryRec_, free) ptr
+    realloc'  <- (#peek struct FT_MemoryRec_, realloc) ptr
+    return $ FT_MemoryRec
+      { user = user'
+      , alloc = alloc'
+      , free = free'
+      , realloc = realloc'
+      }
+  poke ptr val = do
+    (#poke struct FT_MemoryRec_, user) ptr (user val)
+    (#poke struct FT_MemoryRec_, alloc) ptr (alloc val)
+    (#poke struct FT_MemoryRec_, free) ptr (free val)
+    (#poke struct FT_MemoryRec_, realloc) ptr (realloc val)

@@ -0,0 +1,11 @@+{-# LANGUAGE EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.Module
+( FT_ModuleRec_
+, FT_Module
+) where
+
+import Foreign
+
+data FT_ModuleRec_
+type FT_Module = Ptr FT_ModuleRec_
+

@@ -0,0 +1,53 @@+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.OpenArgs
+( FT_Open_Args(..)
+) where
+
+import Foreign
+import Foreign.C.String
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+import Graphics.Rendering.FreeType.Internal.Stream
+import Graphics.Rendering.FreeType.Internal.Module
+import Graphics.Rendering.FreeType.Internal.Parameter
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+data FT_Open_Args = FT_Open_Args
+  { flags       :: FT_UInt
+  , memory_base :: FT_Bytes
+  , memory_size :: FT_Long
+  , pathname    :: CString
+  , stream      :: FT_Stream
+  , driver      :: FT_Module
+  , num_params  :: FT_Int
+  , params      :: Ptr FT_Parameter
+  }
+
+instance Storable FT_Open_Args where
+  sizeOf    _ = #size FT_Open_Args
+  alignment _ = #alignment FT_Open_Args
+  peek ptr = do
+    flags'       <- (#peek FT_Open_Args, flags) ptr
+    memory_base' <- (#peek FT_Open_Args, memory_base) ptr
+    memory_size' <- (#peek FT_Open_Args, memory_size) ptr
+    pathname'    <- (#peek FT_Open_Args, pathname) ptr
+    stream'      <- (#peek FT_Open_Args, stream) ptr
+    driver'      <- (#peek FT_Open_Args, driver) ptr
+    num_params'  <- (#peek FT_Open_Args, num_params) ptr
+    params'      <- (#peek FT_Open_Args, params) ptr
+    return $ FT_Open_Args
+      { flags = flags'
+      , memory_base = memory_base'
+      , memory_size = memory_size'
+      , pathname = pathname'
+      , stream = stream'
+      , driver = driver'
+      , num_params = num_params'
+      , params = params'
+      }

@@ -0,0 +1,108 @@+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.Outline
+( FT_Outline(..)
+, FT_Outline_MoveToFunc
+, FT_Outline_LineToFunc
+, FT_Outline_ConicToFunc
+, FT_Outline_CubicToFunc
+, FT_Outline_Funcs(..)
+) where
+
+import Foreign hiding (shift)
+import Foreign.C.Types
+import Foreign.C.String
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.Vector
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+#include "freetype/ftimage.h"
+
+data FT_Outline = FT_Outline
+  { n_contours :: CShort
+  , n_points   :: CShort
+  , points     :: Ptr FT_Vector
+  , tags       :: CString
+  , contours   :: Ptr CShort
+  , flags      :: FT_OUTLINE_FLAGS
+  }
+
+instance Storable FT_Outline where
+  sizeOf    _ = #size FT_Outline
+  alignment _ = #alignment FT_Outline
+  peek ptr = do
+    n_contours' <- (#peek FT_Outline, n_contours) ptr
+    n_points'   <- (#peek FT_Outline, n_points)   ptr
+    points'     <- (#peek FT_Outline, points)     ptr
+    tags'       <- (#peek FT_Outline, tags)       ptr
+    contours'   <- (#peek FT_Outline, contours)   ptr
+    flags'      <- (#peek FT_Outline, flags)      ptr
+    return $ FT_Outline
+      { n_contours = n_contours'
+      , n_points   = n_points'
+      , points     = points'
+      , tags       = tags'
+      , contours   = contours'
+      , flags      = flags'
+      }
+  poke ptr val = do
+    (#poke FT_Outline, n_contours) ptr (n_contours val)
+    (#poke FT_Outline, n_points)   ptr (n_points   val)
+    (#poke FT_Outline, points)     ptr (points     val)
+    (#poke FT_Outline, tags)       ptr (tags       val)
+    (#poke FT_Outline, contours)   ptr (contours   val)
+    (#poke FT_Outline, flags)      ptr (flags      val)
+
+type FT_Outline_MoveToFunc = FunPtr
+  (Ptr FT_Vector -> Ptr () -> IO CInt)
+
+type FT_Outline_LineToFunc = FunPtr
+  (Ptr FT_Vector -> Ptr () -> IO CInt)
+
+type FT_Outline_ConicToFunc = FunPtr
+  (Ptr FT_Vector -> Ptr FT_Vector -> Ptr () -> IO CInt)
+
+type FT_Outline_CubicToFunc = FunPtr
+  (Ptr FT_Vector -> Ptr FT_Vector -> Ptr FT_Vector -> Ptr () -> IO CInt)
+
+data FT_Outline_Funcs = FT_Outline_Funcs
+  { move_to  :: FT_Outline_MoveToFunc
+  , line_to  :: FT_Outline_LineToFunc
+  , conic_to :: FT_Outline_ConicToFunc
+  , cubic_to :: FT_Outline_CubicToFunc
+  , shift    :: CInt
+  , delta    :: FT_Pos
+  }
+
+instance Storable FT_Outline_Funcs where
+  sizeOf    _ = #size FT_Outline_Funcs
+  alignment _ = #alignment FT_Outline_Funcs
+  peek ptr = do
+    move_to'  <- (#peek FT_Outline_Funcs, move_to) ptr
+    line_to'  <- (#peek FT_Outline_Funcs, line_to) ptr
+    conic_to' <- (#peek FT_Outline_Funcs, conic_to) ptr
+    cubic_to' <- (#peek FT_Outline_Funcs, cubic_to) ptr
+    shift'    <- (#peek FT_Outline_Funcs, shift) ptr
+    delta'    <- (#peek FT_Outline_Funcs, delta) ptr
+    return $ FT_Outline_Funcs
+      { move_to  = move_to'
+      , line_to  = line_to'
+      , conic_to = conic_to'
+      , cubic_to = cubic_to'
+      , shift    = shift'
+      , delta    = delta'
+      }
+  poke ptr val = do
+    (#poke FT_Outline_Funcs, move_to) ptr (move_to val)
+    (#poke FT_Outline_Funcs, line_to) ptr (line_to val)
+    (#poke FT_Outline_Funcs, conic_to) ptr (conic_to val)
+    (#poke FT_Outline_Funcs, cubic_to) ptr (cubic_to val)
+    (#poke FT_Outline_Funcs, shift) ptr (shift val)
+    (#poke FT_Outline_Funcs, delta) ptr (delta val)
+

@@ -0,0 +1,28 @@+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.OutlineGlyph
+( FT_OutlineGlyph
+, root
+, outline
+, cast
+) where
+
+import Foreign
+
+import Graphics.Rendering.FreeType.Internal.Glyph
+import Graphics.Rendering.FreeType.Internal.Outline
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+#include "freetype/ftglyph.h"
+
+newtype FT_OutlineGlyph = FT_OutlineGlyph FT_Glyph
+
+root :: FT_OutlineGlyph -> FT_Glyph
+root (FT_OutlineGlyph ptr) = ptr
+
+outline :: FT_OutlineGlyph -> Ptr FT_Outline
+outline (FT_OutlineGlyph ptr) = (#ptr struct FT_OutlineGlyphRec_, outline) ptr
+
+cast :: FT_Glyph -> FT_OutlineGlyph
+cast = FT_OutlineGlyph

@@ -0,0 +1,34 @@+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.Parameter
+( FT_Parameter(..)
+) where
+
+import Foreign
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+data FT_Parameter = FT_Parameter
+  { tag   :: FT_ULong
+  , data_ :: FT_Pointer
+  }
+
+instance Storable FT_Parameter where
+  sizeOf    _ = #size FT_Parameter
+  alignment _ = #alignment FT_Parameter
+  peek ptr = do
+    tag'   <- (#peek FT_Parameter, tag) ptr
+    data_' <- (#peek FT_Parameter, data) ptr
+    return $ FT_Parameter
+      { tag = tag'
+      , data_ = data_'
+      }
+  poke ptr val = do
+    (#poke FT_Parameter, tag) ptr (tag val)
+    (#poke FT_Parameter, data) ptr (data_ val)

@@ -1,4 +1,5 @@ {-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-} module Graphics.Rendering.FreeType.Internal.PrimitiveTypes where  import Foreign@@ -9,6 +10,8 @@ #include "ft2build.h" #include FT_FREETYPE_H +#include "freetype/ftoutln.h"+ ft_LOAD_DEFAULT :: FT_Int32 ft_LOAD_DEFAULT = #const FT_LOAD_DEFAULT ft_LOAD_NO_SCALE :: FT_Int32@@ -60,8 +63,10 @@ type FT_F26Dot6 = CLong type FT_Fixed   = CLong type FT_Pos     = CLong+type FT_Pointer = Ptr ()  newtype FT_Render_Mode = FT_Render_Mode CUInt+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)  #{enum FT_Render_Mode, FT_Render_Mode,   ft_RENDER_MODE_NORMAL = FT_RENDER_MODE_NORMAL,@@ -69,4 +74,167 @@   ft_RENDER_MODE_MONO   = FT_RENDER_MODE_MONO,   ft_RENDER_MODE_LCD    = FT_RENDER_MODE_LCD,   ft_RENDER_MODE_LCD_V  = FT_RENDER_MODE_LCD_V+}++fREETYPE_MAJOR :: FT_Int+fREETYPE_MAJOR = #const FREETYPE_MAJOR+fREETYPE_MINOR :: FT_Int+fREETYPE_MINOR = #const FREETYPE_MINOR+fREETYPE_PATCH :: FT_Int+fREETYPE_PATCH = #const FREETYPE_PATCH++newtype FT_Encoding = FT_Encoding FT_UInt32+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)++#{enum FT_Encoding, FT_Encoding,+  ft_ENCODING_NONE           = FT_ENCODING_NONE,+  ft_ENCODING_MS_SYMBOL      = FT_ENCODING_MS_SYMBOL,+  ft_ENCODING_UNICODE        = FT_ENCODING_UNICODE,+  ft_ENCODING_SJIS           = FT_ENCODING_SJIS,+  ft_ENCODING_GB2312         = FT_ENCODING_GB2312,+  ft_ENCODING_BIG5           = FT_ENCODING_BIG5,+  ft_ENCODING_WANSUNG        = FT_ENCODING_WANSUNG,+  ft_ENCODING_JOHAB          = FT_ENCODING_JOHAB,+  ft_ENCODING_MS_SJIS        = FT_ENCODING_MS_SJIS,+  ft_ENCODING_MS_GB2312      = FT_ENCODING_MS_GB2312,+  ft_ENCODING_MS_BIG5        = FT_ENCODING_MS_BIG5,+  ft_ENCODING_MS_WANSUNG     = FT_ENCODING_MS_WANSUNG,+  ft_ENCODING_MS_JOHAB       = FT_ENCODING_MS_JOHAB,+  ft_ENCODING_ADOBE_STANDARD = FT_ENCODING_ADOBE_STANDARD,+  ft_ENCODING_ADOBE_EXPERT   = FT_ENCODING_ADOBE_EXPERT,+  ft_ENCODING_ADOBE_CUSTOM   = FT_ENCODING_ADOBE_CUSTOM,+  ft_ENCODING_ADOBE_LATIN_1  = FT_ENCODING_ADOBE_LATIN_1,+  ft_ENCODING_OLD_LATIN_2    = FT_ENCODING_OLD_LATIN_2,+  ft_ENCODING_APPLE_ROMAN    = FT_ENCODING_APPLE_ROMAN+}++newtype FT_FACE_FLAG = FT_FACE_FLAG FT_Int+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)++#{enum FT_FACE_FLAG, FT_FACE_FLAG,+  ft_FACE_FLAG_SCALABLE = FT_FACE_FLAG_SCALABLE,+  ft_FACE_FLAG_FIXED_SIZES = FT_FACE_FLAG_FIXED_SIZES,+  ft_FACE_FLAG_FIXED_WIDTH = FT_FACE_FLAG_FIXED_WIDTH,+  ft_FACE_FLAG_SFNT = FT_FACE_FLAG_SFNT,+  ft_FACE_FLAG_HORIZONTAL = FT_FACE_FLAG_HORIZONTAL,+  ft_FACE_FLAG_VERTICAL = FT_FACE_FLAG_VERTICAL,+  ft_FACE_FLAG_KERNING = FT_FACE_FLAG_KERNING,+  ft_FACE_FLAG_FAST_GLYPHS = FT_FACE_FLAG_FAST_GLYPHS,+  ft_FACE_FLAG_MULTIPLE_MASTERS = FT_FACE_FLAG_MULTIPLE_MASTERS,+  ft_FACE_FLAG_GLYPH_NAMES = FT_FACE_FLAG_GLYPH_NAMES,+  ft_FACE_FLAG_EXTERNAL_STREAM = FT_FACE_FLAG_EXTERNAL_STREAM,+  ft_FACE_FLAG_HINTER = FT_FACE_FLAG_HINTER,+  ft_FACE_FLAG_CID_KEYED = FT_FACE_FLAG_CID_KEYED,+  ft_FACE_FLAG_TRICKY = FT_FACE_FLAG_TRICKY+}++newtype FT_OPEN = FT_OPEN FT_UInt+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)++#{enum FT_OPEN, FT_OPEN,+  ft_OPEN_MEMORY   = FT_OPEN_MEMORY,+  ft_OPEN_STREAM   = FT_OPEN_STREAM,+  ft_OPEN_PATHNAME = FT_OPEN_PATHNAME,+  ft_OPEN_DRIVER   = FT_OPEN_DRIVER,+  ft_OPEN_PARAMS   = FT_OPEN_PARAMS+}++newtype FT_Size_Request_Type = FT_Size_Request_Type FT_UInt+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)++#{enum FT_Size_Request_Type, FT_Size_Request_Type,+  ft_SIZE_REQUEST_TYPE_NOMINAL  = FT_SIZE_REQUEST_TYPE_NOMINAL,+  ft_SIZE_REQUEST_TYPE_REAL_DIM = FT_SIZE_REQUEST_TYPE_REAL_DIM,+  ft_SIZE_REQUEST_TYPE_BBOX     = FT_SIZE_REQUEST_TYPE_BBOX,+  ft_SIZE_REQUEST_TYPE_CELL     = FT_SIZE_REQUEST_TYPE_CELL,+  ft_SIZE_REQUEST_TYPE_SCALES   = FT_SIZE_REQUEST_TYPE_SCALES+}++ft_LOAD_TARGET_NORMAL :: FT_UInt32+ft_LOAD_TARGET_NORMAL = #const FT_LOAD_TARGET_NORMAL  +ft_LOAD_TARGET_LIGHT :: FT_UInt32+ft_LOAD_TARGET_LIGHT = #const FT_LOAD_TARGET_LIGHT+ft_LOAD_TARGET_MONO :: FT_UInt32+ft_LOAD_TARGET_MONO = #const FT_LOAD_TARGET_MONO+ft_LOAD_TARGET_LCD :: FT_UInt32+ft_LOAD_TARGET_LCD = #const FT_LOAD_TARGET_LCD+ft_LOAD_TARGET_LCD_V :: FT_UInt32+ft_LOAD_TARGET_LCD_V = #const FT_LOAD_TARGET_LCD_V++newtype FT_Kerning_Mode = FT_Kerning_Mode FT_UInt32+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)++#{enum FT_Kerning_Mode, FT_Kerning_Mode,+  ft_KERNING_DEFAULT  = FT_KERNING_DEFAULT,+  ft_KERNING_UNFITTED = FT_KERNING_UNFITTED,+  ft_KERNING_UNSCALED = FT_KERNING_UNSCALED+}++newtype FT_SUBGLYPH_FLAG = FT_SUBGLYPH_FLAG FT_UInt+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)++#{enum FT_SUBGLYPH_FLAG, FT_SUBGLYPH_FLAG,+  ft_SUBGLYPH_FLAG_ARGS_ARE_WORDS = FT_SUBGLYPH_FLAG_ARGS_ARE_WORDS,+  ft_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES,+  ft_SUBGLYPH_FLAG_ROUND_XY_TO_GRID = FT_SUBGLYPH_FLAG_ROUND_XY_TO_GRID,+  ft_SUBGLYPH_FLAG_SCALE = FT_SUBGLYPH_FLAG_SCALE,+  ft_SUBGLYPH_FLAG_XY_SCALE = FT_SUBGLYPH_FLAG_XY_SCALE,+  ft_SUBGLYPH_FLAG_2X2 = FT_SUBGLYPH_FLAG_2X2,+  ft_SUBGLYPH_FLAG_USE_MY_METRICS = FT_SUBGLYPH_FLAG_USE_MY_METRICS+}++ft_FSTYPE_INSTALLABLE_EMBEDDING :: FT_UShort+ft_FSTYPE_INSTALLABLE_EMBEDDING =+  #const FT_FSTYPE_INSTALLABLE_EMBEDDING+ft_FSTYPE_RESTRICTED_LICENSE_EMBEDDING :: FT_UShort+ft_FSTYPE_RESTRICTED_LICENSE_EMBEDDING =+  #const FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING+ft_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING :: FT_UShort+ft_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING =+  #const FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING+ft_FSTYPE_EDITABLE_EMBEDDING :: FT_UShort+ft_FSTYPE_EDITABLE_EMBEDDING =+  #const FT_FSTYPE_EDITABLE_EMBEDDING+ft_FSTYPE_NO_SUBSETTING :: FT_UShort+ft_FSTYPE_NO_SUBSETTING =+  #const FT_FSTYPE_NO_SUBSETTING+ft_FSTYPE_BITMAP_EMBEDDING_ONLY :: FT_UShort+ft_FSTYPE_BITMAP_EMBEDDING_ONLY =+  #const FT_FSTYPE_BITMAP_EMBEDDING_ONLY++newtype FT_Glyph_Format = FT_Glyph_Format FT_UInt32+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)++#{enum FT_Glyph_Format, FT_Glyph_Format,+  ft_GLYPH_FORMAT_NONE = FT_GLYPH_FORMAT_NONE,+  ft_GLYPH_FORMAT_COMPOSITE = FT_GLYPH_FORMAT_COMPOSITE,+  ft_GLYPH_FORMAT_BITMAP = FT_GLYPH_FORMAT_BITMAP,+  ft_GLYPH_FORMAT_OUTLINE = FT_GLYPH_FORMAT_OUTLINE,+  ft_GLYPH_FORMAT_PLOTTER = FT_GLYPH_FORMAT_PLOTTER+}++newtype FT_OUTLINE_FLAGS = FT_OUTLINE_FLAGS FT_UInt32+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)++#{enum FT_OUTLINE_FLAGS, FT_OUTLINE_FLAGS,+  ft_OUTLINE_NONE = FT_OUTLINE_NONE,+  ft_OUTLINE_OWNER = FT_OUTLINE_OWNER,+  ft_OUTLINE_EVEN_ODD_FILL = FT_OUTLINE_EVEN_ODD_FILL,+  ft_OUTLINE_REVERSE_FILL = FT_OUTLINE_REVERSE_FILL,+  ft_OUTLINE_IGNORE_DROPOUTS = FT_OUTLINE_IGNORE_DROPOUTS,+  ft_OUTLINE_SMART_DROPOUTS = FT_OUTLINE_SMART_DROPOUTS,+  ft_OUTLINE_INCLUDE_STUBS = FT_OUTLINE_INCLUDE_STUBS,+  ft_OUTLINE_HIGH_PRECISION = FT_OUTLINE_HIGH_PRECISION,+  ft_OUTLINE_SINGLE_PASS = FT_OUTLINE_SINGLE_PASS+}++newtype FT_Orientation = FT_Orientation FT_UInt+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)++#{enum FT_Orientation, FT_Orientation,+  ft_ORIENTATION_TRUETYPE = FT_ORIENTATION_TRUETYPE,+  ft_ORIENTATION_POSTSCRIPT = FT_ORIENTATION_POSTSCRIPT,+  ft_ORIENTATION_FILL_RIGHT = FT_ORIENTATION_FILL_RIGHT,+  ft_ORIENTATION_FILL_LEFT = FT_ORIENTATION_FILL_LEFT,+  ft_ORIENTATION_NONE = FT_ORIENTATION_NONE }

@@ -0,0 +1,85 @@+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.RasterParams
+( FT_Raster_Params
+, FT_SpanFunc
+, FT_Raster_BitTest_Func
+, FT_Raster_BitSet_Func
+, target
+, source
+, flags
+, gray_spans
+, user
+, clip_box
+) where
+
+import Foreign
+import Foreign.C.Types
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.BBox
+import Graphics.Rendering.FreeType.Internal.Bitmap
+import Graphics.Rendering.FreeType.Internal.Span
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+#include "freetype/ftimage.h"
+
+data FT_Raster_Params = FT_Raster_Params
+  { target      :: Ptr FT_Bitmap
+  , source      :: Ptr ()
+  , flags       :: CInt
+  , gray_spans  :: FT_SpanFunc
+  , black_spans :: FT_SpanFunc            -- doesn't work according to FT docs
+  , bit_test    :: FT_Raster_BitTest_Func -- doesn't work according to FT docs
+  , bit_set     :: FT_Raster_BitSet_Func  -- doesn't work according to FT docs
+  , user        :: Ptr ()
+  , clip_box    :: FT_BBox
+  }
+
+instance Storable FT_Raster_Params where
+  sizeOf    _ = #size FT_Raster_Params
+  alignment _ = #alignment FT_Raster_Params
+  peek ptr = do
+    target'      <- (#peek FT_Raster_Params, target) ptr
+    source'      <- (#peek FT_Raster_Params, source) ptr
+    flags'       <- (#peek FT_Raster_Params, flags) ptr
+    gray_spans'  <- (#peek FT_Raster_Params, gray_spans) ptr
+    black_spans' <- (#peek FT_Raster_Params, black_spans) ptr
+    bit_test'    <- (#peek FT_Raster_Params, bit_test) ptr
+    bit_set'     <- (#peek FT_Raster_Params, bit_set) ptr
+    user'        <- (#peek FT_Raster_Params, user) ptr
+    clip_box'    <- (#peek FT_Raster_Params, clip_box) ptr
+    return $ FT_Raster_Params
+      { target = target'
+      , source = source'
+      , flags = flags'
+      , gray_spans = gray_spans'
+      , black_spans = black_spans'
+      , bit_test = bit_test'
+      , bit_set = bit_set'
+      , user = user'
+      , clip_box = clip_box'
+      }
+  poke ptr val = do
+    (#poke FT_Raster_Params, target) ptr (target val)
+    (#poke FT_Raster_Params, source) ptr (source val)
+    (#poke FT_Raster_Params, flags) ptr (flags val)
+    (#poke FT_Raster_Params, gray_spans) ptr (gray_spans val)
+    (#poke FT_Raster_Params, black_spans) ptr (black_spans val)
+    (#poke FT_Raster_Params, bit_test) ptr (bit_test val)
+    (#poke FT_Raster_Params, bit_set) ptr (bit_set val)
+    (#poke FT_Raster_Params, user) ptr (user val)
+    (#poke FT_Raster_Params, clip_box) ptr (clip_box val)
+
+type FT_SpanFunc = FunPtr
+  (CInt -> CInt -> Ptr FT_Span -> Ptr () -> IO ())
+
+type FT_Raster_BitTest_Func = FunPtr
+  (CInt -> CInt -> Ptr () -> IO CInt)
+
+type FT_Raster_BitSet_Func = FunPtr
+  (CInt -> CInt -> Ptr () -> IO ())

@@ -0,0 +1,11 @@+{-# LANGUAGE EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.Renderer
+( FT_RendererRec_
+, FT_Renderer
+) where
+
+import Foreign
+
+data FT_RendererRec_
+type FT_Renderer = Ptr FT_RendererRec_
+

@@ -0,0 +1,35 @@+{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.Size
+( FT_SizeRec_
+, FT_Size
+, face
+, generic
+, metrics
+) where
+
+import Foreign
+
+import Graphics.Rendering.FreeType.Internal.FaceType
+import Graphics.Rendering.FreeType.Internal.SizeMetrics
+import Graphics.Rendering.FreeType.Internal.Generic
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+#include "internal/ftobjs.h"
+
+data FT_SizeRec_
+type FT_Size = Ptr FT_SizeRec_
+
+face :: FT_Size -> Ptr FT_Face
+face = #ptr struct FT_SizeRec_, face
+
+generic :: FT_Size -> Ptr FT_Generic
+generic = #ptr struct FT_SizeRec_, generic
+
+metrics :: FT_Size -> Ptr FT_Size_Metrics
+metrics = #ptr struct FT_SizeRec_, metrics
+

@@ -0,0 +1,59 @@+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.SizeMetrics
+( FT_Size_Metrics(..)
+) where
+
+import Foreign
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+data FT_Size_Metrics = FT_Size_Metrics
+  { x_ppem      :: FT_UShort
+  , y_ppem      :: FT_UShort
+  , x_scale     :: FT_Fixed
+  , y_scale     :: FT_Fixed
+  , ascender    :: FT_Pos
+  , descender   :: FT_Pos
+  , height      :: FT_Pos
+  , max_advance :: FT_Pos
+  }
+  deriving (Read, Show, Eq)
+
+instance Storable FT_Size_Metrics where
+  sizeOf    _ = #size FT_Size_Metrics
+  alignment _ = #alignment FT_Size_Metrics
+  peek ptr = do
+    x_ppem'      <- (#peek FT_Size_Metrics, x_ppem) ptr
+    y_ppem'      <- (#peek FT_Size_Metrics, y_ppem) ptr
+    x_scale'     <- (#peek FT_Size_Metrics, x_scale) ptr
+    y_scale'     <- (#peek FT_Size_Metrics, y_scale) ptr
+    ascender'    <- (#peek FT_Size_Metrics, ascender) ptr
+    descender'   <- (#peek FT_Size_Metrics, descender) ptr
+    height'      <- (#peek FT_Size_Metrics, height) ptr
+    max_advance' <- (#peek FT_Size_Metrics, max_advance) ptr
+    return $ FT_Size_Metrics
+      { x_ppem = x_ppem'
+      , y_ppem = y_ppem'
+      , x_scale = x_scale'
+      , y_scale = y_scale'
+      , ascender = ascender'
+      , descender = descender'
+      , height = height'
+      , max_advance = max_advance'
+      }
+  poke ptr val = do
+    (#poke FT_Size_Metrics, x_ppem) ptr (x_ppem val)
+    (#poke FT_Size_Metrics, y_ppem) ptr (y_ppem val)
+    (#poke FT_Size_Metrics, x_scale) ptr (x_scale val)
+    (#poke FT_Size_Metrics, y_scale) ptr (y_scale val)
+    (#poke FT_Size_Metrics, ascender) ptr (ascender val)
+    (#poke FT_Size_Metrics, descender) ptr (descender val)
+    (#poke FT_Size_Metrics, height) ptr (height val)
+    (#poke FT_Size_Metrics, max_advance) ptr (max_advance val)

@@ -0,0 +1,48 @@+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.SizeRequest
+( FT_Size_RequestRec(..)
+, FT_Size_Request
+) where
+
+import Foreign
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+type FT_Size_Request = Ptr FT_Size_RequestRec
+
+data FT_Size_RequestRec = FT_Size_RequestRec
+  { type_  :: FT_Size_Request_Type
+  , width  :: FT_Long
+  , height :: FT_Long
+  , horiResolution :: FT_UInt
+  , vertResolution :: FT_UInt
+  }
+
+instance Storable FT_Size_RequestRec where
+  sizeOf    _ = #size FT_Size_RequestRec
+  alignment _ = #alignment FT_Size_RequestRec
+  peek ptr = do
+    type_'          <- (#peek FT_Size_RequestRec, type) ptr
+    width'          <- (#peek FT_Size_RequestRec, width) ptr
+    height'         <- (#peek FT_Size_RequestRec, height) ptr
+    horiResolution' <- (#peek FT_Size_RequestRec, horiResolution) ptr
+    vertResolution' <- (#peek FT_Size_RequestRec, vertResolution) ptr
+    return $ FT_Size_RequestRec
+      { type_ = type_'
+      , width = width'
+      , height = height'
+      , horiResolution = horiResolution'
+      , vertResolution = vertResolution'
+      }
+  poke ptr val = do
+    (#poke FT_Size_RequestRec, type) ptr (type_ val)
+    (#poke FT_Size_RequestRec, height) ptr (height val)
+    (#poke FT_Size_RequestRec, horiResolution) ptr (horiResolution val)
+    (#poke FT_Size_RequestRec, vertResolution) ptr (vertResolution val)

@@ -0,0 +1,41 @@+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.Span
+( FT_Span(..)
+) where
+
+import Foreign
+import Foreign.C.Types
+import Foreign.Storable
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+#include "freetype/ftimage.h"
+
+data FT_Span = FT_Span
+  { x        :: CShort
+  , len      :: CUShort
+  , coverage :: CUChar
+  }
+  deriving (Read, Show, Eq)
+
+instance Storable FT_Span where
+  sizeOf    _ = #size FT_Span
+  alignment _ = #alignment FT_Span
+  peek ptr = do
+    x'        <- (#peek FT_Span, x) ptr
+    len'      <- (#peek FT_Span, len) ptr
+    coverage' <- (#peek FT_Span, coverage) ptr
+    return $ FT_Span
+      { x = x'
+      , len = len'
+      , coverage = coverage'
+      }
+  poke ptr val = do
+    (#poke FT_Span, x) ptr (x val)
+    (#poke FT_Span, len) ptr (len val)
+    (#poke FT_Span, coverage) ptr (coverage val)
+

@@ -0,0 +1,71 @@+{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.Stream
+( FT_StreamRec_
+, FT_Stream
+, FT_StreamDesc
+, FT_Stream_IoFunc
+, FT_Stream_CloseFunc
+, base
+, size
+, pos
+, descriptor
+, read
+, close
+, memory
+, cursor
+, limit
+) where
+
+import Prelude hiding (read)
+
+import Foreign
+import Foreign.C.Types
+
+import Graphics.Rendering.FreeType.Internal.Memory
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+#include "freetype/ftsystem.h"
+
+-- We don't have FILE* in Haskell, so we cheat and only
+-- consider the long part of the FT_StreamDesc union...
+type FT_StreamDesc = CLong
+
+type FT_Stream_IoFunc = FunPtr
+  (FT_Stream -> CULong -> Ptr CUChar -> CULong -> IO CULong)
+
+type FT_Stream_CloseFunc = FunPtr (FT_Stream -> IO ())
+
+data FT_StreamRec_
+type FT_Stream = Ptr FT_StreamRec_
+
+base :: FT_Stream -> Ptr (Ptr CUChar)
+base = #ptr struct FT_StreamRec_, base
+
+size :: FT_Stream -> Ptr CULong
+size = #ptr struct FT_StreamRec_, size
+
+pos :: FT_Stream -> Ptr CULong
+pos = #ptr struct FT_StreamRec_, pos 
+
+descriptor :: FT_Stream -> Ptr FT_StreamDesc
+descriptor = #ptr struct FT_StreamRec_, descriptor
+
+read :: FT_Stream -> Ptr FT_Stream_IoFunc
+read = #ptr struct FT_StreamRec_, read
+
+close :: FT_Stream -> Ptr FT_Stream_CloseFunc
+close = #ptr struct FT_StreamRec_, close
+
+memory :: FT_Stream -> Ptr FT_Memory
+memory = #ptr struct FT_StreamRec_, memory
+
+cursor :: FT_Stream -> Ptr (Ptr CUChar)
+cursor = #ptr struct FT_StreamRec_, cursor
+
+limit :: FT_Stream -> Ptr (Ptr CUChar)
+limit = #ptr struct FT_StreamRec_, limit

@@ -0,0 +1,10 @@+{-# LANGUAGE EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.SubGlyph
+( FT_SubGlyphRec_
+, FT_SubGlyph
+) where
+
+import Foreign
+
+data FT_SubGlyphRec_
+type FT_SubGlyph = Ptr FT_SubGlyphRec_

@@ -1,5 +1,5 @@ Name:                freetype2-Version:             0.0.1+Version:             0.1.0 Synopsis:            Haskell binding for FreeType 2 library Description:         Wrapper around FreeType 2 library.  Relevant                      exerpts from the FreeType 2 website:@@ -156,14 +156,36 @@ Library   -- Modules exported by the library.   Exposed-modules: Graphics.Rendering.FreeType.Internal+                   Graphics.Rendering.FreeType.Internal.BBox                    Graphics.Rendering.FreeType.Internal.Bitmap+                   Graphics.Rendering.FreeType.Internal.BitmapGlyph+                   Graphics.Rendering.FreeType.Internal.BitmapSize+                   Graphics.Rendering.FreeType.Internal.CharMap+                   Graphics.Rendering.FreeType.Internal.Driver                    Graphics.Rendering.FreeType.Internal.Face+                   Graphics.Rendering.FreeType.Internal.FaceType+                   Graphics.Rendering.FreeType.Internal.Generic+                   Graphics.Rendering.FreeType.Internal.Glyph+                   Graphics.Rendering.FreeType.Internal.GlyphMetrics                    Graphics.Rendering.FreeType.Internal.GlyphSlot                    Graphics.Rendering.FreeType.Internal.Library                    Graphics.Rendering.FreeType.Internal.Matrix+                   Graphics.Rendering.FreeType.Internal.Memory+                   Graphics.Rendering.FreeType.Internal.Module+                   Graphics.Rendering.FreeType.Internal.OpenArgs+                   Graphics.Rendering.FreeType.Internal.Outline+                   Graphics.Rendering.FreeType.Internal.OutlineGlyph+                   Graphics.Rendering.FreeType.Internal.Parameter                    Graphics.Rendering.FreeType.Internal.PrimitiveTypes+                   Graphics.Rendering.FreeType.Internal.RasterParams+                   Graphics.Rendering.FreeType.Internal.Renderer+                   Graphics.Rendering.FreeType.Internal.Size+                   Graphics.Rendering.FreeType.Internal.SizeMetrics+                   Graphics.Rendering.FreeType.Internal.SizeRequest+                   Graphics.Rendering.FreeType.Internal.Stream+                   Graphics.Rendering.FreeType.Internal.Span+                   Graphics.Rendering.FreeType.Internal.SubGlyph                    Graphics.Rendering.FreeType.Internal.Vector-                   Graphics.Rendering.FreeType.Internal.Glyph    -- Packages needed in order to build this package.   Build-depends: base > 3 && < 5