kb-text-shape-0.3.0.0: src/KB/Text/Shape/Font.hs
module KB.Text.Shape.Font
( -- * Distillation
extractBlob
-- * Loading
, FontData(..)
, createFont
, destroyFont
-- * Using
, withFontData
, Handles.Font
-- * Querying
, getFontInfo
, Info(..)
, lookupFontString
, variationAxes
, Structs.VariationAxisInfo(..)
, emToCaps
-- * Loading internals
, withLoader
, loadFont
, LoadFontResult(..)
, placeBlob
) where
import Prelude hiding (id)
import Foreign
import Control.Monad (forM, when)
import Data.ByteString (ByteString)
import Data.ByteString qualified as ByteString
import Data.ByteString.Internal qualified as ByteString
import Data.ByteString.Unsafe qualified as ByteString
import Data.Maybe (catMaybes)
import Data.Text (Text)
import Data.Text.Encoding qualified as Text
import Data.Text.Encoding.Error (lenientDecode)
import KB.Text.Shape.FFI.API.Direct qualified as ShapeDirect
import KB.Text.Shape.FFI.Flags qualified as Flags
import KB.Text.Shape.FFI.Enums qualified as Enums
import KB.Text.Shape.FFI.Handles qualified as Handles
import KB.Text.Shape.FFI.Structs qualified as Structs
-- | Extract and pre-process font data needed for shaping.
extractBlob
:: ByteString -- ^ TTF font data
-> Int -- ^ Font index (use 0 for the first/only font)
-> IO ByteString -- ^ KBTS blob data
extractBlob fontData fontIndex =
withLoader \font statePtr -> do
loadFont fontData fontIndex font statePtr >>= \case
Left err ->
error $ show err
Right LoadFontNeedsBlob{scratchSize, outputSize} ->
placeBlob font statePtr scratchSize outputSize
Right LoadFontReady ->
pure fontData
createFont :: ByteString -> Int -> IO FontData
createFont fontSource fontIndex =
withLoader \font statePtr -> do
loadFont fontSource fontIndex font statePtr >>= \case
Left err ->
error $ show err
Right LoadFontNeedsBlob{scratchSize, outputSize} -> do
blobData <- placeBlob font statePtr scratchSize outputSize
pure font{fontResources = [fontSource, blobData]}
Right LoadFontReady ->
pure font{fontResources = [fontSource]}
destroyFont :: FontData -> IO ()
destroyFont font = withFontData font ShapeDirect.kbts_FreeFont
-- | Haskell-owned font data
data FontData = FontData
{ fontData :: ForeignPtr Word8
, fontResources :: [ByteString]
}
deriving (Eq, Show)
-- | Use the font handle from a loaded font
withFontData :: FontData -> (Handles.Font -> IO r) -> IO r
withFontData FontData{fontData} action = withForeignPtr fontData (action . Handles.Font . castPtr)
{- | Font metadata and metrics.
Name strings are the Windows-platform US English records, see 'lookupFontString'.
-}
getFontInfo :: Handles.Font -> IO Info
getFontInfo font = do
Structs.FontInfo2{strings = _, ..} <-
alloca \fontInfoPtr -> do
Structs.prepareFontInfo2 fontInfoPtr
ShapeDirect.kbts_GetFontInfo2 font fontInfoPtr
peek fontInfoPtr
strings <- catMaybes <$> traverse englishString allStringIds
pure Info{..}
where
englishString stringId =
fmap (stringId,) <$> lookupFontString font stringId Enums.WINDOWS_LANGUAGE_ID_ENGLISH_UNITED_STATES
allStringIds =
map (Enums.FontInfoStringId . fromIntegral) [1 .. Enums.FONT_INFO_STRING_ID_COUNT1 - 1]
{- | Fetch a name string in the given language.
Only Windows-platform name records are considered.
IDs from 'Enums.FONT_INFO_STRING_ID_COUNT1' up pass through as raw OpenType name IDs, like 'Structs.VariationAxisInfo' names.
See 'Structs.VariationInstanceInfo' for the instance name IDs that collide with the named ones.
-}
lookupFontString :: Handles.Font -> Enums.FontInfoStringId -> Enums.WindowsLanguageId -> IO (Maybe Text)
lookupFontString font stringId languageId = lookupWithCapacity 256
where
lookupWithCapacity capacity =
allocaBytes capacity \buffer ->
lookupInto buffer capacity >>= \case
0 -> pure Nothing
size
| size > capacity -> lookupWithCapacity size
| otherwise -> Just . Text.decodeUtf8With lenientDecode <$> ByteString.packCStringLen (buffer, size)
lookupInto buffer capacity =
fromIntegral <$> ShapeDirect.kbts_LookupFontString font stringId languageId buffer (fromIntegral capacity)
{- | The variation axes of a variable font, in the font's order.
A static font has none.
Look up an axis name with 'lookupFontString' and its @nameStringId@.
-}
variationAxes :: Handles.Font -> IO [Structs.VariationAxisInfo]
variationAxes font = do
axisCount <- alloca \axisCountPtr -> do
ShapeDirect.kbts_GetVariationInfo font axisCountPtr nullPtr
peek axisCountPtr
forM [0 .. axisCount - 1] \axisIndex ->
alloca \axisInfoPtr -> do
_found <- ShapeDirect.kbts_GetVariationAxisInfo font axisIndex axisInfoPtr
peek axisInfoPtr
data Info = Info
{ strings :: [(Enums.FontInfoStringId, Text)]
, styleFlags :: Flags.FontStyleFlags
, weight :: Enums.FontWeight
, width :: Enums.FontWidth
, unitsPerEm :: Word16
-- Bounding box
, xMin :: Int16
, yMin :: Int16
, xMax :: Int16
, yMax :: Int16
, ascent :: Int16
, descent :: Int16
, lineGap :: Int16
, capitalHeight :: Int16 -- ^ Zero when the font does not provide it.
}
deriving (Eq, Show)
{- | Scaling factor to go from font-specific Em units to a cap-height normalized units.
This results in more consistent font sizing when using multiple fonts.
You may even have a chance to align something vertically!
-}
{-# INLINE emToCaps #-}
emToCaps :: Fractional a => Info -> a
emToCaps Info{unitsPerEm, capitalHeight} = fromIntegral unitsPerEm / fromIntegral capitalHeight
withLoader :: (FontData -> Ptr ShapeDirect.LoadFontState -> IO a) -> IO a
withLoader action = do
fontData <- mallocForeignPtrBytes Handles.sizeOfFontData
let font = FontData{fontData, fontResources = []}
withFontData font \(Handles.Font fontPtr) ->
fillBytes fontPtr 0x00 Handles.sizeOfFontData
alloca \statePtr -> do
fillBytes statePtr 0x00 $ sizeOf (undefined :: ShapeDirect.LoadFontState)
action font statePtr
data LoadFontResult
= LoadFontReady
| LoadFontNeedsBlob { scratchSize :: Int, outputSize :: Int}
loadFont
:: ByteString
-> Int
-> FontData
-> Ptr ShapeDirect.LoadFontState
-> IO (Either Enums.LoadFontError LoadFontResult)
loadFont ttfData fontIndex font statePtr =
withFontData font \fontPtr ->
alloca \scratchSizePtr ->
alloca \outputSizePtr ->
ByteString.unsafeUseAsCStringLen ttfData \(ttfDataPtr, ttfDataSize) -> do
err <- ShapeDirect.kbts_LoadFont
fontPtr
statePtr
(castPtr ttfDataPtr)
(fromIntegral ttfDataSize)
(fromIntegral fontIndex)
scratchSizePtr
outputSizePtr
case err of
Enums.LOAD_FONT_ERROR_NONE ->
pure $ Right LoadFontReady
Enums.LOAD_FONT_ERROR_NEED_TO_CREATE_BLOB -> do
scratchSize <- fromIntegral <$> peek scratchSizePtr
outputSize <- fromIntegral <$> peek outputSizePtr
pure $ Right LoadFontNeedsBlob{..}
_ ->
pure $ Left err
placeBlob :: FontData -> Ptr ShapeDirect.LoadFontState -> Int -> Int -> IO ByteString
placeBlob font statePtr scratchSize outputSize =
allocaBytes scratchSize \scratchPtr -> do
fillBytes scratchPtr 0x00 scratchSize
outputData <- mallocForeignPtrBytes outputSize
withForeignPtr outputData \outputPtr ->
withFontData font \fontPtr -> do
fillBytes outputPtr 0x00 outputSize
err <- ShapeDirect.kbts_PlaceBlob fontPtr statePtr scratchPtr (castPtr outputPtr)
when (err /= Enums.LOAD_FONT_ERROR_NONE) $
error $ show err
pure $! ByteString.fromForeignPtr0 outputData outputSize