{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE TemplateHaskell #-}
---------------------------------------------------------
-- |
-- Copyright   : (c) 2006-2016, alpheccar.org
-- License     : BSD-style
--
-- Maintainer  : misc@NOSPAMalpheccar.org
-- Stability   : experimental
-- Portability : portable
--
-- AFM Parser
---------------------------------------------------------
module Graphics.PDF.Fonts.Encoding(
      getEncoding
    , Encodings(..)
    , PostscriptName
    , parseMacEncoding
    ) where

import Data.ByteString (ByteString)
import Data.FileEmbed (embedFile)
import Graphics.PDF.LowLevel.Types
import qualified Data.Map.Strict as M
import qualified Data.ByteString.Char8 as C
import Data.Char(digitToInt)
import Data.Maybe(mapMaybe)

type PostscriptName = String

data Encodings = AdobeStandardEncoding
               | ZapfDingbatsEncoding
               deriving(Encodings -> Encodings -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Encodings -> Encodings -> Bool
$c/= :: Encodings -> Encodings -> Bool
== :: Encodings -> Encodings -> Bool
$c== :: Encodings -> Encodings -> Bool
Eq)

isLine :: C.ByteString -> Bool
isLine :: ByteString -> Bool
isLine ByteString
c | Bool -> Bool
not (ByteString -> Bool
C.null ByteString
c) = ByteString -> Char
C.head ByteString
c forall a. Eq a => a -> a -> Bool
/= Char
'#'
         | Bool
otherwise = Bool
False

from4Hexa :: C.ByteString -> Int
from4Hexa :: ByteString -> Int
from4Hexa ByteString
a = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (\(Int
x,Int
y) -> Int
x forall a. Num a => a -> a -> a
* Int
y) forall a b. (a -> b) -> a -> b
$ forall a b. [a] -> [b] -> [(a, b)]
zip (forall a b. (a -> b) -> [a] -> [b]
map Char -> Int
digitToInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Char]
C.unpack forall a b. (a -> b) -> a -> b
$ ByteString
a)  (forall a b. (a -> b) -> [a] -> [b]
map (\Integer
x -> Int
16forall a b. (Num a, Integral b) => a -> b -> a
^Integer
x) ([Integer
3,Integer
2,Integer
1,Integer
0] :: [Integer]))

from3Octal:: C.ByteString -> Int
from3Octal :: ByteString -> Int
from3Octal ByteString
a = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (\(Int
x,Int
y) -> Int
x forall a. Num a => a -> a -> a
* Int
y) forall a b. (a -> b) -> a -> b
$ forall a b. [a] -> [b] -> [(a, b)]
zip (forall a b. (a -> b) -> [a] -> [b]
map Char -> Int
digitToInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Char]
C.unpack forall a b. (a -> b) -> a -> b
$ ByteString
a)  (forall a b. (a -> b) -> [a] -> [b]
map (\Integer
x -> Int
8forall a b. (Num a, Integral b) => a -> b -> a
^Integer
x) ([Integer
2,Integer
1,Integer
0] :: [Integer]))


toData :: [C.ByteString] -> Maybe (PostscriptName,Char)
toData :: [ByteString] -> Maybe ([Char], Char)
toData (ByteString
a:ByteString
b:[ByteString]
_) = forall a. a -> Maybe a
Just (ByteString -> [Char]
C.unpack ByteString
a,forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Int
from4Hexa forall a b. (a -> b) -> a -> b
$ ByteString
b)
toData [ByteString]
_ = forall a. Maybe a
Nothing

toMacData :: [C.ByteString] -> Maybe (PostscriptName,GlyphCode)
toMacData :: [ByteString] -> Maybe ([Char], GlyphCode)
toMacData (ByteString
name:ByteString
_:ByteString
mac:[ByteString]
_) | ByteString -> [Char]
C.unpack ByteString
mac forall a. Eq a => a -> a -> Bool
== [Char]
"-" = forall a. Maybe a
Nothing
                         | Bool
otherwise = forall a. a -> Maybe a
Just (ByteString -> [Char]
C.unpack ByteString
name,forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
from3Octal ByteString
mac))
toMacData [ByteString]
_ = forall a. Maybe a
Nothing

parseGlyphListEncoding :: ByteString -> IO (M.Map PostscriptName Char)
parseGlyphListEncoding :: ByteString -> IO (Map [Char] Char)
parseGlyphListEncoding ByteString
l = forall (m :: * -> *) a. Monad m => a -> m a
return (forall k a. Ord k => [(k, a)] -> Map k a
M.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe ([ByteString] -> Maybe ([Char], Char)
toData  forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ByteString -> [ByteString]
C.split Char
';') forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
filter ByteString -> Bool
isLine forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [ByteString]
C.lines forall a b. (a -> b) -> a -> b
$ ByteString
l)

pdfencodings :: ByteString
pdfencodings :: ByteString
pdfencodings = $(embedFile "Encodings/pdfencodings.txt")

parseMacEncoding :: IO (M.Map PostscriptName GlyphCode)
parseMacEncoding :: IO (Map [Char] GlyphCode)
parseMacEncoding = do
    forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Ord k => [(k, a)] -> Map k a
M.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe ([ByteString] -> Maybe ([Char], GlyphCode)
toMacData forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ByteString -> [ByteString]
C.split Char
'\t') forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
tail forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [ByteString]
C.lines forall a b. (a -> b) -> a -> b
$ ByteString
pdfencodings

glyphlist :: ByteString
glyphlist :: ByteString
glyphlist = $(embedFile "Encodings/glyphlist.txt")

zapfdingbats :: ByteString
zapfdingbats :: ByteString
zapfdingbats = $(embedFile "Encodings/zapfdingbats.txt")

getEncoding :: Encodings -> IO (M.Map PostscriptName Char)
getEncoding :: Encodings -> IO (Map [Char] Char)
getEncoding Encodings
AdobeStandardEncoding = ByteString -> IO (Map [Char] Char)
parseGlyphListEncoding ByteString
glyphlist
getEncoding Encodings
ZapfDingbatsEncoding= ByteString -> IO (Map [Char] Char)
parseGlyphListEncoding ByteString
zapfdingbats