{-# LANGUAGE OverloadedStrings #-}
-- | Infrastructure for parsing & desugaring grid-layout related CSS properties.
module Graphics.Layout.Grid.CSS(CSSGrid(..), Axis(..), CSSCell(..), Placement(..),
                                finalizeGrid, Areas, parseASCIIGrid) where

import Stylist (PropertyParser(..), parseOperands)
import Data.CSS.Syntax.Tokens (Token(..), NumericValue(..))

import Data.Text (Text)
import qualified Data.Text as Txt
import Data.Char (isAlphaNum)
import Data.Maybe (fromMaybe, isNothing)
import Data.List (nub)
import qualified Data.HashMap.Lazy as HM

import Graphics.Layout.CSS.Length
import Graphics.Layout.Box
import Graphics.Layout.Grid
import Graphics.Layout

type Areas = HM.HashMap Text ((Int, Int), (Int, Maybe Int))

-- | Converts a grid to lookup table start & indices for row & columns.
-- Exported for the sake of testing
parseASCIIGrid :: [[Text]] -> Int -> Areas -> Maybe Areas
parseASCIIGrid :: [[Text]] -> Int -> Areas -> Maybe Areas
parseASCIIGrid (row :: [Text]
row:rows :: [[Text]]
rows) i :: Int
i prev :: Areas
prev
    | [Text]
names [Text] -> [Text] -> Bool
forall a. Eq a => a -> a -> Bool
== [Text] -> [Text]
forall a. Eq a => [a] -> [a]
nub [Text]
names, [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [(Int, Int)
span (Int, Int) -> (Int, Int) -> Bool
forall a. Eq a => a -> a -> Bool
== ((Int, Int), (Int, Maybe Int)) -> (Int, Int)
forall a b. (a, b) -> a
fst ((Int, Int), (Int, Maybe Int))
rec Bool -> Bool -> Bool
&& Maybe Int -> Bool
forall a. Maybe a -> Bool
isNothing ((Int, Maybe Int) -> Maybe Int
forall a b. (a, b) -> b
snd ((Int, Maybe Int) -> Maybe Int) -> (Int, Maybe Int) -> Maybe Int
forall a b. (a -> b) -> a -> b
$ ((Int, Int), (Int, Maybe Int)) -> (Int, Maybe Int)
forall a b. (a, b) -> b
snd ((Int, Int), (Int, Maybe Int))
rec)
            | (name :: Text
name, span :: (Int, Int)
span) <- [(Text, (Int, Int))]
row', Just rec :: ((Int, Int), (Int, Maybe Int))
rec <- [Text
name Text -> Areas -> Maybe ((Int, Int), (Int, Maybe Int))
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
`HM.lookup` Areas
prev]] =
        [[Text]] -> Int -> Areas -> Maybe Areas
parseASCIIGrid [[Text]]
rows (Int -> Int
forall a. Enum a => a -> a
succ Int
i) (Areas -> Maybe Areas) -> Areas -> Maybe Areas
forall a b. (a -> b) -> a -> b
$ (Text
 -> ((Int, Int), (Int, Maybe Int))
 -> ((Int, Int), (Int, Maybe Int)))
-> Areas -> Areas
forall k v1 v2. (k -> v1 -> v2) -> HashMap k v1 -> HashMap k v2
HM.mapWithKey Text
-> ((Int, Int), (Int, Maybe Int)) -> ((Int, Int), (Int, Maybe Int))
forall a a. Text -> (a, (a, Maybe Int)) -> (a, (a, Maybe Int))
closeAreas (Areas -> Areas) -> Areas -> Areas
forall a b. (a -> b) -> a -> b
$ Areas -> Areas -> Areas
forall k v.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k v -> HashMap k v
HM.union Areas
prev (Areas -> Areas) -> Areas -> Areas
forall a b. (a -> b) -> a -> b
$
            [(Text, ((Int, Int), (Int, Maybe Int)))] -> Areas
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList [(Text
name, ((Int, Int)
span, (Int
i, Maybe Int
forall a. Maybe a
Nothing))) | (name :: Text
name, span :: (Int, Int)
span) <- [(Text, (Int, Int))]
row']
    | Bool
otherwise = Maybe Areas
forall a. Maybe a
Nothing
  where
    names :: [Text]
names = ((Text, (Int, Int)) -> Text) -> [(Text, (Int, Int))] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map (Text, (Int, Int)) -> Text
forall a b. (a, b) -> a
fst [(Text, (Int, Int))]
row'
    row' :: [(Text, (Int, Int))]
row' = [(Int, Text)] -> [(Text, (Int, Int))]
forall a. Eq a => [(Int, a)] -> [(a, (Int, Int))]
parseAsciiRow ([(Int, Text)] -> [(Text, (Int, Int))])
-> [(Int, Text)] -> [(Text, (Int, Int))]
forall a b. (a -> b) -> a -> b
$ [Text] -> [(Int, Text)]
forall b. [b] -> [(Int, b)]
enumerate [Text]
row
    parseAsciiRow :: [(Int, a)] -> [(a, (Int, Int))]
parseAsciiRow ((j :: Int
j, cell :: a
cell):cells :: [(Int, a)]
cells) =
        let (self :: [(Int, a)]
self, cells' :: [(Int, a)]
cells') = ((Int, a) -> Bool) -> [(Int, a)] -> ([(Int, a)], [(Int, a)])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span (\z :: (Int, a)
z -> (Int, a) -> a
forall a b. (a, b) -> b
snd (Int, a)
z a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
cell) [(Int, a)]
cells
        in (a
cell, (Int
j, Int -> Int
forall a. Enum a => a -> a
succ Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ [(Int, a)] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(Int, a)]
self))(a, (Int, Int)) -> [(a, (Int, Int))] -> [(a, (Int, Int))]
forall a. a -> [a] -> [a]
:[(Int, a)] -> [(a, (Int, Int))]
parseAsciiRow [(Int, a)]
cells'
    parseAsciiRow [] = []
    enumerate :: [b] -> [(Int, b)]
enumerate = [Int] -> [b] -> [(Int, b)]
forall a b. [a] -> [b] -> [(a, b)]
zip [0..]
    closeAreas :: Text -> (a, (a, Maybe Int)) -> (a, (a, Maybe Int))
closeAreas name :: Text
name (a :: a
a, (b :: a
b, Nothing)) | Text
name Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Text]
names = (a
a, (a
b, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
i))
    closeAreas _ ret :: (a, (a, Maybe Int))
ret = (a, (a, Maybe Int))
ret
parseASCIIGrid [] _ ret :: Areas
ret = Areas -> Maybe Areas
forall a. a -> Maybe a
Just Areas
ret

-- | Parsed CSS Grid properties
data CSSGrid = CSSGrid {
    -- | Parsed CSS grid-auto-columns
    CSSGrid -> Unitted
autoColumns :: Unitted,
    -- | Parsed grid-auto-flow
    CSSGrid -> Axis
autoFlow :: Axis,
    -- | Whether grid-auto-flow: dense was specified.
    CSSGrid -> Bool
autoFlowDense :: Bool,
    -- | Parsed CSS grid-auto-rows
    CSSGrid -> Unitted
autoRows :: Unitted,
    -- | Parsed CSS grid-template-areas
    CSSGrid -> Areas
templateAreas :: Areas,
    -- | Parsed CSS grid-template-columns
    CSSGrid -> [([Text], Unitted)]
templateColumns :: [([Text], Unitted)],
    -- | Parsed CSS grid-template-rows
    CSSGrid -> [([Text], Unitted)]
templateRows :: [([Text], Unitted)],
    -- | Parsed CSS row-gap & column-gap
    CSSGrid -> Size Unitted Unitted
cssGap :: Size Unitted Unitted,
    -- | Parsed CSS justify-items & align-items
    CSSGrid -> Size Alignment Alignment
alignItems :: Size Alignment Alignment
}
-- | A grid axis.
data Axis = Row | Col deriving Axis -> Axis -> Bool
(Axis -> Axis -> Bool) -> (Axis -> Axis -> Bool) -> Eq Axis
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Axis -> Axis -> Bool
$c/= :: Axis -> Axis -> Bool
== :: Axis -> Axis -> Bool
$c== :: Axis -> Axis -> Bool
Eq
-- | Parsed CSS grid item properties.
data CSSCell = CSSCell {
    -- | Parsed CSS grid-column-start
    CSSCell -> Placement
columnStart :: Placement,
    -- | Parsed CSS grid-column-end
    CSSCell -> Placement
columnEnd :: Placement,
    -- | Parsed CSS grid-row-start
    CSSCell -> Placement
rowStart :: Placement,
    -- | Parsed CSS grid-row-end
    CSSCell -> Placement
rowEnd :: Placement,
    -- | Parsed CSS align-self & justify-self
    CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
}
-- | Identifies a cell in the CSS grid.
data Placement = Autoplace | Named Text | Numbered Int (Maybe Text) |
        Span Int (Maybe Text)

instance PropertyParser CSSGrid where
    temp :: CSSGrid
temp = CSSGrid :: Unitted
-> Axis
-> Bool
-> Unitted
-> Areas
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> Size Unitted Unitted
-> Size Alignment Alignment
-> CSSGrid
CSSGrid {
        autoColumns :: Unitted
autoColumns = Unitted
auto,
        autoFlow :: Axis
autoFlow = Axis
Row,
        autoFlowDense :: Bool
autoFlowDense = Bool
False,
        autoRows :: Unitted
autoRows = Unitted
auto,
        templateAreas :: Areas
templateAreas = Areas
forall k v. HashMap k v
HM.empty,
        templateColumns :: [([Text], Unitted)]
templateColumns = [],
        templateRows :: [([Text], Unitted)]
templateRows = [],
        cssGap :: Size Unitted Unitted
cssGap = Unitted -> Unitted -> Size Unitted Unitted
forall m n. n -> m -> Size m n
Size (0,"px") (0,"px"),
        alignItems :: Size Alignment Alignment
alignItems = Alignment -> Alignment -> Size Alignment Alignment
forall m n. n -> m -> Size m n
Size Alignment
Start Alignment
Start -- FIXME: Should be stretch, unsupported.
    }
    inherit :: CSSGrid -> CSSGrid
inherit _ = CSSGrid
forall a. PropertyParser a => a
temp
    priority :: CSSGrid -> [Text]
priority _ = []

    longhand :: CSSGrid -> CSSGrid -> Text -> [Token] -> Maybe CSSGrid
longhand _ s :: CSSGrid
s "grid-auto-columns" toks :: [Token]
toks | Just x :: Unitted
x <- [Token] -> Maybe Unitted
parseFR [Token]
toks = CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
s {autoColumns :: Unitted
autoColumns=Unitted
x}
    longhand _ s :: CSSGrid
s "grid-auto-rows" toks :: [Token]
toks | Just x :: Unitted
x <- [Token] -> Maybe Unitted
parseFR [Token]
toks = CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
s { autoRows :: Unitted
autoRows = Unitted
x }

    longhand _ self :: CSSGrid
self "grid-auto-flow" [Ident "row"] = CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self {
        autoFlow :: Axis
autoFlow = Axis
Row, autoFlowDense :: Bool
autoFlowDense = Bool
False
      }
    longhand _ self :: CSSGrid
self "grid-auto-flow" [Ident "column"] = CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self {
        autoFlow :: Axis
autoFlow = Axis
Col, autoFlowDense :: Bool
autoFlowDense = Bool
False
      }
    longhand _ self :: CSSGrid
self "grid-auto-flow" [Ident "row", Ident "dense"] = CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self {
        autoFlow :: Axis
autoFlow = Axis
Row, autoFlowDense :: Bool
autoFlowDense = Bool
True
      }
    longhand _ self :: CSSGrid
self "grid-auto-flow" [Ident "column", Ident "dense"] = CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self {
        autoFlow :: Axis
autoFlow = Axis
Col, autoFlowDense :: Bool
autoFlowDense = Bool
True
      }

    -- FIXME Parse & validate the ASCII-art grid into rectangles.
    longhand _ self :: CSSGrid
self "grid-template-areas" [Ident "none"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { templateAreas :: Areas
templateAreas = Areas
forall k v. HashMap k v
HM.empty }
    longhand _ self :: CSSGrid
self "grid-template-areas" [Ident "initial"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { templateAreas :: Areas
templateAreas = Areas
forall k v. HashMap k v
HM.empty }
    longhand _ self :: CSSGrid
self "grid-template-areas" toks :: [Token]
toks
        | (Token -> Bool) -> [Token] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Token -> Bool
isString [Token]
toks, let grid :: [[Text]]
grid = [Text -> [Text]
Txt.words Text
x | String x :: Text
x <- [Token]
toks],
            [[Text]] -> Bool
validate [[Text]]
grid, Just areas :: Areas
areas <- [[Text]] -> Int -> Areas -> Maybe Areas
parseASCIIGrid [[Text]]
grid 0 Areas
forall k v. HashMap k v
HM.empty =
                CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { templateAreas :: Areas
templateAreas = Areas
areas }
      where
        isString :: Token -> Bool
isString (String _) = Bool
True
        isString _ = Bool
False
        validate :: [[Text]] -> Bool
validate grid :: [[Text]]
grid@(row :: [Text]
row:rows :: [[Text]]
rows) =
            (Text -> Bool) -> [Text] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Text -> Bool
isValidName ([[Text]] -> [Text]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Text]]
grid) Bool -> Bool -> Bool
&& ([Text] -> Bool) -> [[Text]] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (\x :: [Text]
x -> [Text] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Text]
row Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== [Text] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Text]
x) [[Text]]
rows
        validate [] = Bool
False
        isValidName :: Text -> Bool
isValidName name :: Text
name = (Char -> Bool) -> Text -> Bool
Txt.all (\c :: Char
c -> Char -> Bool
isAlphaNum Char
c Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== '-') Text
name

    longhand _ self :: CSSGrid
self "grid-template-columns" toks :: [Token]
toks | Just x :: [([Text], Unitted)]
x <- [Token] -> Maybe [([Text], Unitted)]
parseTemplate [Token]
toks =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { templateColumns :: [([Text], Unitted)]
templateColumns = [([Text], Unitted)]
x }
    longhand _ self :: CSSGrid
self "grid-template-rows" toks :: [Token]
toks | Just x :: [([Text], Unitted)]
x <- [Token] -> Maybe [([Text], Unitted)]
parseTemplate [Token]
toks =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { templateRows :: [([Text], Unitted)]
templateRows = [([Text], Unitted)]
x}

    longhand _ self :: CSSGrid
self "row-gap" toks :: [Token]
toks | Just x :: Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { cssGap :: Size Unitted Unitted
cssGap = (CSSGrid -> Size Unitted Unitted
cssGap CSSGrid
self) { inline :: Unitted
inline = Unitted
x } }
    longhand _ self :: CSSGrid
self "column-gap" toks :: [Token]
toks | Just x :: Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { cssGap :: Size Unitted Unitted
cssGap = (CSSGrid -> Size Unitted Unitted
cssGap CSSGrid
self) { block :: Unitted
block = Unitted
x } }

    longhand _ self :: CSSGrid
self "justify-items" [Ident "start"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
Start } }
    longhand _ self :: CSSGrid
self "justify-items" [Ident "flex-start"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
Start } }
    longhand _ self :: CSSGrid
self "justify-items" [Ident "self-start"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
Start } }
    longhand _ self :: CSSGrid
self "justify-items" [Ident "left"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
Start } }
    longhand _ self :: CSSGrid
self "justify-items" [Ident "center"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
Mid } }
    longhand _ self :: CSSGrid
self "justify-items" [Ident "end"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
End } }
    longhand _ self :: CSSGrid
self "justify-items" [Ident "flex-end"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
End } }
    longhand _ self :: CSSGrid
self "justify-items" [Ident "self-end"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
End } }
    longhand _ self :: CSSGrid
self "justify-items" [Ident "right"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
End } }
    longhand parent :: CSSGrid
parent self :: CSSGrid
self "justify-items" (Ident "unsafe":toks :: [Token]
toks) =
        CSSGrid -> CSSGrid -> Text -> [Token] -> Maybe CSSGrid
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSGrid
parent CSSGrid
self "justify-items" [Token]
toks
    longhand _ self :: CSSGrid
self "justify-items" [Ident "normal"] = -- FIXME Should be stretch, unsupported.
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
Start } }
    longhand _ self :: CSSGrid
self "justify-items" [Ident "initial"] = -- FIXME Should be stretch, unsupported.
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
Start } }

    longhand _ self :: CSSGrid
self "align-items" [Ident "start"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
Start } }
    longhand _ self :: CSSGrid
self "align-items" [Ident "flex-start"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
Start } }
    longhand _ self :: CSSGrid
self "align-items" [Ident "self-start"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
Start } }
    longhand _ self :: CSSGrid
self "align-items" [Ident "center"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
Mid } }
    longhand _ self :: CSSGrid
self "align-items" [Ident "end"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
End } }
    longhand _ self :: CSSGrid
self "align-items" [Ident "flex-end"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
End } }
    longhand _ self :: CSSGrid
self "align-items" [Ident "self-end"] =
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
End } }
    longhand parent :: CSSGrid
parent self :: CSSGrid
self "align-items" (Ident "unsafe":toks :: [Token]
toks) =
        CSSGrid -> CSSGrid -> Text -> [Token] -> Maybe CSSGrid
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSGrid
parent CSSGrid
self "align-items" [Token]
toks
    longhand _ self :: CSSGrid
self "align-items" [Ident "normal"] = -- FIXME Should be stretch, unsupported.
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
Start } }
    longhand _ self :: CSSGrid
self "align-items" [Ident "initial"] = -- FIXME Should be stretch, unsupported.
        CSSGrid -> Maybe CSSGrid
forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
Start } }

    longhand _ _ _ _ = Maybe CSSGrid
forall a. Maybe a
Nothing

instance PropertyParser CSSCell where
    temp :: CSSCell
temp = CSSCell :: Placement
-> Placement
-> Placement
-> Placement
-> Size (Maybe Alignment) (Maybe Alignment)
-> CSSCell
CSSCell {
        columnStart :: Placement
columnStart = Placement
Autoplace,
        columnEnd :: Placement
columnEnd = Placement
Autoplace,
        rowStart :: Placement
rowStart = Placement
Autoplace,
        rowEnd :: Placement
rowEnd = Placement
Autoplace,
        alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = Maybe Alignment
-> Maybe Alignment -> Size (Maybe Alignment) (Maybe Alignment)
forall m n. n -> m -> Size m n
Size Maybe Alignment
forall a. Maybe a
Nothing Maybe Alignment
forall a. Maybe a
Nothing
    }
    inherit :: CSSCell -> CSSCell
inherit _ = CSSCell
forall a. PropertyParser a => a
temp
    priority :: CSSCell -> [Text]
priority _ = []

    longhand :: CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
longhand _ self :: CSSCell
self "grid-column-start" toks :: [Token]
toks | Just x :: Placement
x <- [Token] -> Maybe Placement
placement [Token]
toks =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { columnStart :: Placement
columnStart = Placement
x}
    longhand _ s :: CSSCell
s "grid-column-end" toks :: [Token]
toks | Just x :: Placement
x <- [Token] -> Maybe Placement
placement [Token]
toks = CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
s {columnEnd :: Placement
columnEnd=Placement
x}
    longhand _ s :: CSSCell
s "grid-row-start" toks :: [Token]
toks | Just x :: Placement
x <- [Token] -> Maybe Placement
placement [Token]
toks = CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
s {rowStart :: Placement
rowStart = Placement
x}
    longhand _ s :: CSSCell
s "grid-row-end" toks :: [Token]
toks | Just x :: Placement
x <- [Token] -> Maybe Placement
placement [Token]
toks = CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
s { rowEnd :: Placement
rowEnd = Placement
x }

    longhand _ self :: CSSCell
self "align-self" [Ident "start"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
Start } }
    longhand _ self :: CSSCell
self "align-self" [Ident "self-start"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
Start } }
    longhand _ self :: CSSCell
self "align-self" [Ident "flex-start"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
Start } }
    longhand _ self :: CSSCell
self "align-self" [Ident "center"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
Mid } }
    longhand _ self :: CSSCell
self "align-self" [Ident "end"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
End } }
    longhand _ self :: CSSCell
self "align-self" [Ident "self-end"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
End } }
    longhand _ self :: CSSCell
self "align-self" [Ident "flex-end"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
End } }
    longhand _ self :: CSSCell
self "align-self" [Ident "normal"] = -- FIXME should be stretch, unsupported
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
Start } }
    longhand parent :: CSSCell
parent self :: CSSCell
self "align-self" (Ident "unsafe":toks :: [Token]
toks) =
        CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
parent CSSCell
self "align-self" [Token]
toks
    longhand _ self :: CSSCell
self "align-self" [Ident "auto"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = Maybe Alignment
forall a. Maybe a
Nothing } }
    longhand _ self :: CSSCell
self "align-self" [Ident "initial"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = Maybe Alignment
forall a. Maybe a
Nothing } }

    longhand _ self :: CSSCell
self "justify-self" [Ident "start"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
Start } }
    longhand _ self :: CSSCell
self "justify-self" [Ident "self-start"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
Start } }
    longhand _ self :: CSSCell
self "justify-self" [Ident "flex-start"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
Start } }
    longhand _ self :: CSSCell
self "justify-self" [Ident "left"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
Start } }
    longhand _ self :: CSSCell
self "justify-self" [Ident "center"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
Mid } }
    longhand _ self :: CSSCell
self "justify-self" [Ident "end"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
End } }
    longhand _ self :: CSSCell
self "justify-self" [Ident "self-end"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
End } }
    longhand _ self :: CSSCell
self "justify-self" [Ident "flex-end"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
End } }
    longhand _ self :: CSSCell
self "justify-self" [Ident "right"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
End } }
    longhand _ self :: CSSCell
self "justify-self" [Ident "normal"] = -- FIXME should be stretch, unsupported
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = Alignment -> Maybe Alignment
forall a. a -> Maybe a
Just Alignment
Start } }
    longhand parent :: CSSCell
parent self :: CSSCell
self "justify-self" (Ident "unsafe":toks :: [Token]
toks) =
        CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
parent CSSCell
self "justify-self" [Token]
toks
    longhand _ self :: CSSCell
self "justify-self" [Ident "auto"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = Maybe Alignment
forall a. Maybe a
Nothing } }
    longhand _ self :: CSSCell
self "justify-self" [Ident "initial"] =
        CSSCell -> Maybe CSSCell
forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = Maybe Alignment
forall a. Maybe a
Nothing } }

    longhand _ _ _ _ = Maybe CSSCell
forall a. Maybe a
Nothing

    shorthand :: CSSCell -> Text -> [Token] -> Props
shorthand _ "grid-column" toks :: [Token]
toks = case (Token -> Bool) -> [Token] -> ([Token], [Token])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Token -> Token -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Token
Delim '/') [Token]
toks of
        (a :: [Token]
a, Delim '/':b :: [Token]
b) | Just _ <- [Token] -> Maybe Placement
placement [Token]
a, Just _ <- [Token] -> Maybe Placement
placement [Token]
b ->
            [("grid-column-start", [Token]
a), ("grid-column-end", [Token]
b)]
        _ | Just _ <- [Token] -> Maybe Placement
placement [Token]
toks ->
            [("grid-column-start", [Token]
toks), ("grid-column-end", [Token]
toks)]
        _ -> []
    shorthand self :: CSSCell
self "grid-gap" toks :: [Token]
toks = case [Token] -> [[Token]]
parseOperands [Token]
toks of
        [a :: [Token]
a] | Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-row-gap" [Token]
a ->
            [("grid-row-gap", [Token]
a), ("grid-column-gap", [Token]
a)]
        [a :: [Token]
a, b :: [Token]
b] | Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-row-gap" [Token]
a,
            Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-column-gap" [Token]
b ->
                [("grid-row-gap", [Token]
a), ("grid-column-gap", [Token]
b)]
        _ -> []
    shorthand _ "grid-row" toks :: [Token]
toks = case (Token -> Bool) -> [Token] -> ([Token], [Token])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Token -> Token -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Token
Delim '/') [Token]
toks of
        (a :: [Token]
a, Delim '/':b :: [Token]
b) | Just _ <- [Token] -> Maybe Placement
placement [Token]
a, Just _ <- [Token] -> Maybe Placement
placement [Token]
b ->
            [("grid-row-start", [Token]
a), ("grid-row-end", [Token]
b)]
        _ | Just _ <- [Token] -> Maybe Placement
placement [Token]
toks ->
            [("grid-row-start", [Token]
toks), ("grid-row-end", [Token]
toks)]
        _ -> []
    shorthand _ "grid-template" toks :: [Token]
toks@[Ident "none"] =
        [("grid-template-columns", [Token]
toks), ("grid-template-rows", [Token]
toks),
         ("grid-template-areas", [Token]
toks)]
    shorthand self :: CSSCell
self "grid-template" toks :: [Token]
toks
        | (rows :: [Token]
rows, Delim '/':cols :: [Token]
cols) <- (Token -> Bool) -> [Token] -> ([Token], [Token])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Token -> Token -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Token
Delim '/') [Token]
toks,
            Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-template-rows" [Token]
rows,
            Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-template-columns" [Token]
cols =
                [("grid-template-rows", [Token]
rows), ("grid-template-columns", [Token]
cols),
                 ("grid-template-areas", [Text -> Token
Ident "none"])]
        | (rowsTemplate :: [Token]
rowsTemplate, Delim '/':cols :: [Token]
cols) <- (Token -> Bool) -> [Token] -> ([Token], [Token])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Token -> Token -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Token
Delim '/') [Token]
toks,
            Just (areas :: [Token]
areas, rows :: [[Token]]
rows) <- [Token] -> Maybe ([Token], [[Token]])
splitTemplate [Token]
rowsTemplate,
            Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-template-cols" [Token]
cols,
            Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-template-areas" [Token]
areas =
                [("grid-template-rows", [[Token]] -> [Token]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Token]]
rows),
                 ("grid-template-columns", [Token]
cols), ("grid-template-areas", [Token]
areas)]
      where
        splitTemplate :: [Token] -> Maybe ([Token], [[Token]])
splitTemplate (LeftSquareBracket:t :: [Token]
t)
            | (names :: [Token]
names, RightSquareBracket:t' :: [Token]
t') <- (Token -> Bool) -> [Token] -> ([Token], [Token])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Token -> Token -> Bool
forall a. Eq a => a -> a -> Bool
== Token
RightSquareBracket) [Token]
t,
              (Token -> Bool) -> [Token] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Token -> Bool
isIdent [Token]
names, Just (areas :: [Token]
areas, row :: [Token]
row:rows :: [[Token]]
rows) <- [Token] -> Maybe ([Token], [[Token]])
splitTemplate [Token]
t' =
                ([Token], [[Token]]) -> Maybe ([Token], [[Token]])
forall a. a -> Maybe a
Just ([Token]
areas,
                    (Token
LeftSquareBracketToken -> [Token] -> [Token]
forall a. a -> [a] -> [a]
:[Token]
names [Token] -> [Token] -> [Token]
forall a. [a] -> [a] -> [a]
++ Token
RightSquareBracketToken -> [Token] -> [Token]
forall a. a -> [a] -> [a]
:[Token]
row)[Token] -> [[Token]] -> [[Token]]
forall a. a -> [a] -> [a]
:[[Token]]
rows)
        splitTemplate (x :: Token
x@(String _):toks :: [Token]
toks)
            | Just (areas :: [Token]
areas, rows :: [[Token]]
rows) <- [Token] -> Maybe ([Token], [[Token]])
splitTemplate' [Token]
toks = ([Token], [[Token]]) -> Maybe ([Token], [[Token]])
forall a. a -> Maybe a
Just (Token
xToken -> [Token] -> [Token]
forall a. a -> [a] -> [a]
:[Token]
areas, [[Token]]
rows)
        splitTemplate _ = Maybe ([Token], [[Token]])
forall a. Maybe a
Nothing
        splitTemplate' :: [Token] -> Maybe ([Token], [[Token]])
splitTemplate' (x :: Token
x:LeftSquareBracket:t :: [Token]
t)
            | (names :: [Token]
names, RightSquareBracket:t' :: [Token]
t') <- (Token -> Bool) -> [Token] -> ([Token], [Token])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Token -> Token -> Bool
forall a. Eq a => a -> a -> Bool
== Token
RightSquareBracket) [Token]
t,
              (Token -> Bool) -> [Token] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Token -> Bool
isIdent [Token]
names, Just _ <- [Token] -> Maybe Unitted
parseFR' [Token
x],
              Just (areas :: [Token]
areas, rows :: [[Token]]
rows) <- [Token] -> Maybe ([Token], [[Token]])
splitTemplate [Token]
t' =
                ([Token], [[Token]]) -> Maybe ([Token], [[Token]])
forall a. a -> Maybe a
Just ([Token]
areas,
                    (Token
xToken -> [Token] -> [Token]
forall a. a -> [a] -> [a]
:Token
LeftSquareBracketToken -> [Token] -> [Token]
forall a. a -> [a] -> [a]
:[Token]
names [Token] -> [Token] -> [Token]
forall a. [a] -> [a] -> [a]
++ [Token
RightSquareBracket])[Token] -> [[Token]] -> [[Token]]
forall a. a -> [a] -> [a]
:[[Token]]
rows)
        splitTemplate' (x :: Token
x:toks :: [Token]
toks)
            | Just _ <- [Token] -> Maybe Unitted
parseFR' [Token
x], Just (areas :: [Token]
areas, rows :: [[Token]]
rows) <- [Token] -> Maybe ([Token], [[Token]])
splitTemplate [Token]
toks =
                ([Token], [[Token]]) -> Maybe ([Token], [[Token]])
forall a. a -> Maybe a
Just ([Token]
areas, [Token
x][Token] -> [[Token]] -> [[Token]]
forall a. a -> [a] -> [a]
:[[Token]]
rows)
        splitTemplate' (LeftSquareBracket:t :: [Token]
t)
            | (names :: [Token]
names, RightSquareBracket:t' :: [Token]
t') <- (Token -> Bool) -> [Token] -> ([Token], [Token])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Token -> Token -> Bool
forall a. Eq a => a -> a -> Bool
== Token
RightSquareBracket) [Token]
t,
              (Token -> Bool) -> [Token] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Token -> Bool
isIdent [Token]
names, Just (areas :: [Token]
areas, rows :: [[Token]]
rows) <- [Token] -> Maybe ([Token], [[Token]])
splitTemplate [Token]
t' =
                ([Token], [[Token]]) -> Maybe ([Token], [[Token]])
forall a. a -> Maybe a
Just ([Token]
areas,
                    (Token
LeftSquareBracketToken -> [Token] -> [Token]
forall a. a -> [a] -> [a]
:[Token]
names [Token] -> [Token] -> [Token]
forall a. [a] -> [a] -> [a]
++ [Token
RightSquareBracket])[Token] -> [[Token]] -> [[Token]]
forall a. a -> [a] -> [a]
:[[Token]]
rows)
        splitTemplate' toks :: [Token]
toks
            | Just (areas :: [Token]
areas, rows :: [[Token]]
rows) <- [Token] -> Maybe ([Token], [[Token]])
splitTemplate [Token]
toks = ([Token], [[Token]]) -> Maybe ([Token], [[Token]])
forall a. a -> Maybe a
Just ([Token]
areas, [][Token] -> [[Token]] -> [[Token]]
forall a. a -> [a] -> [a]
:[[Token]]
rows)
            | Bool
otherwise = Maybe ([Token], [[Token]])
forall a. Maybe a
Nothing
        isIdent :: Token -> Bool
isIdent (Ident _) = Bool
True
        isIdent _ = Bool
False
    shorthand self :: CSSCell
self "grid" toks :: [Token]
toks
        | ret :: Props
ret@(_:_) <- CSSCell -> Text -> [Token] -> Props
forall a. PropertyParser a => a -> Text -> [Token] -> Props
shorthand CSSCell
self "grid-template" [Token]
toks =
            ("grid-auto-flow", [Text -> Token
Ident "row"])(Text, [Token]) -> Props -> Props
forall a. a -> [a] -> [a]
:Props
ret
    shorthand self :: CSSCell
self "grid" toks :: [Token]
toks = case (Token -> Bool) -> [Token] -> ([Token], [Token])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Token -> Token -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Token
Delim '/') [Token]
toks of
        (rows :: [Token]
rows, Delim '/':Ident "auto-flow":Ident "dense":cols :: [Token]
cols) |
          Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-template-rows" [Token]
rows,
          Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-auto-columns" [Token]
cols ->
            [("grid-template-rows", [Token]
rows),
             ("grid-template-columns", [Text -> Token
Ident "none"]),
             ("grid-auto-columns", [Token]
cols), ("grid-auto-rows", [Text -> Token
Ident "none"]),
             ("grid-auto-flow", [Text -> Token
Ident "column", Text -> Token
Ident "dense"])]
        (rows :: [Token]
rows, Delim '/':Ident "dense":Ident "auto-flow":cols :: [Token]
cols) |
          Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-template-rows" [Token]
rows,
          Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-auto-columns" [Token]
cols ->
            [("grid-template-rows", [Token]
rows),
             ("grid-template-columns", [Text -> Token
Ident "none"]),
             ("grid-auto-columns", [Token]
cols), ("grid-auto-rows", [Text -> Token
Ident "none"]),
             ("grid-auto-flow", [Text -> Token
Ident "column", Text -> Token
Ident "dense"])]
        (rows :: [Token]
rows, Delim '/':Ident "auto-flow":cols :: [Token]
cols) |
          Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-template-rows" [Token]
rows,
          Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-auto-columns" [Token]
cols ->
            [("grid-template-rows", [Token]
rows),
             ("grid-template-columns", [Text -> Token
Ident "none"]),
             ("grid-auto-columns", [Token]
cols), ("grid-auto-rows", [Text -> Token
Ident "none"]),
             ("grid-auto-flow", [Text -> Token
Ident "column"])]
        (Ident "auto-flow":Ident "dense":rows :: [Token]
rows, Delim '/':cols :: [Token]
cols) |
          Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-auto-rows" [Token]
rows,
          Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-template-columns" [Token]
cols ->
            [("grid-auto-rows", [Token]
rows), ("grid-auto-columns", [Text -> Token
Ident "none"]),
             ("grid-template-columns", [Token]
cols),
             ("grid-template-rows", [Text -> Token
Ident "none"]),
             ("grid-auto-flow", [Text -> Token
Ident "row", Text -> Token
Ident "dense"])]
        (Ident "dense":Ident "auto-flow":rows :: [Token]
rows, Delim '/':cols :: [Token]
cols) |
          Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-auto-rows" [Token]
rows,
          Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-template-columns" [Token]
cols ->
            [("grid-auto-rows", [Token]
rows), ("grid-auto-columns", [Text -> Token
Ident "none"]),
             ("grid-template-columns", [Token]
cols),
             ("grid-template-rows", [Text -> Token
Ident "none"]),
             ("grid-auto-flow", [Text -> Token
Ident "row", Text -> Token
Ident "dense"])]
        (Ident "auto-flow":rows :: [Token]
rows, Delim '/':cols :: [Token]
cols) |
          Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-auto-rows" [Token]
rows,
          Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self "grid-template-columns" [Token]
cols ->
            [("grid-auto-rows", [Token]
rows), ("grid-auto-columns", [Text -> Token
Ident "none"]),
             ("grid-template-columns", [Token]
cols),
             ("grid-template-rows", [Text -> Token
Ident "none"]),
             ("grid-auto-flow", [Text -> Token
Ident "row"])]
        _ -> []
    shorthand self :: CSSCell
self k :: Text
k v :: [Token]
v | Just _ <- CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
k [Token]
v = [(Text
k, [Token]
v)]
        | Bool
otherwise = []

-- | Parse a length or FR unit.
parseFR :: [Token] -> Maybe Unitted
parseFR [Dimension _ x :: NumericValue
x "fr"] = Unitted -> Maybe Unitted
forall a. a -> Maybe a
Just (NumericValue -> Double
forall x. (Fractional x, RealFloat x) => NumericValue -> x
n2f NumericValue
x,"fr")
parseFR toks :: [Token]
toks = [Token] -> Maybe Unitted
parseLength [Token]
toks
-- | Parse a length or FR unit, including extended keywords.
parseFR' :: [Token] -> Maybe Unitted
parseFR' [Dimension _ x :: NumericValue
x "fr"] = Unitted -> Maybe Unitted
forall a. a -> Maybe a
Just (NumericValue -> Double
forall x. (Fractional x, RealFloat x) => NumericValue -> x
n2f NumericValue
x,"fr")
parseFR' toks :: [Token]
toks = [Token] -> Maybe Unitted
parseLength' [Token]
toks

-- | Parse an identifier for a grid cell.
placement :: [Token] -> Maybe Placement
placement [Ident "auto"] = Placement -> Maybe Placement
forall a. a -> Maybe a
Just (Placement -> Maybe Placement) -> Placement -> Maybe Placement
forall a b. (a -> b) -> a -> b
$ Placement
Autoplace
placement [Ident x :: Text
x] = Placement -> Maybe Placement
forall a. a -> Maybe a
Just (Placement -> Maybe Placement) -> Placement -> Maybe Placement
forall a b. (a -> b) -> a -> b
$ Text -> Placement
Named Text
x
placement [Number _ (NVInteger x :: Integer
x)] = Placement -> Maybe Placement
forall a. a -> Maybe a
Just (Placement -> Maybe Placement) -> Placement -> Maybe Placement
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Numbered (Integer -> Int
forall a. Enum a => a -> Int
fromEnum Integer
x) Maybe Text
forall a. Maybe a
Nothing
placement [Number _ (NVInteger x :: Integer
x), Ident y :: Text
y] = Placement -> Maybe Placement
forall a. a -> Maybe a
Just (Placement -> Maybe Placement) -> Placement -> Maybe Placement
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Numbered (Integer -> Int
forall a. Enum a => a -> Int
fromEnum Integer
x) (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
y)
placement [Ident "span", Number _ (NVInteger x :: Integer
x)]
    | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> 0 = Placement -> Maybe Placement
forall a. a -> Maybe a
Just (Placement -> Maybe Placement) -> Placement -> Maybe Placement
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Span (Integer -> Int
forall a. Enum a => a -> Int
fromEnum Integer
x) Maybe Text
forall a. Maybe a
Nothing
placement [Ident "span", Ident x :: Text
x] = Placement -> Maybe Placement
forall a. a -> Maybe a
Just (Placement -> Maybe Placement) -> Placement -> Maybe Placement
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Span 1 (Maybe Text -> Placement) -> Maybe Text -> Placement
forall a b. (a -> b) -> a -> b
$ Text -> Maybe Text
forall a. a -> Maybe a
Just Text
x
placement [Ident "span", Number _ (NVInteger x :: Integer
x), Ident y :: Text
y]
    | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> 0 = Placement -> Maybe Placement
forall a. a -> Maybe a
Just (Placement -> Maybe Placement) -> Placement -> Maybe Placement
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Span (Integer -> Int
forall a. Enum a => a -> Int
fromEnum Integer
x) (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
y)
placement [Ident "span", Ident y :: Text
y, Number _ (NVInteger x :: Integer
x)]
    | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> 0 = Placement -> Maybe Placement
forall a. a -> Maybe a
Just (Placement -> Maybe Placement) -> Placement -> Maybe Placement
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Span (Integer -> Int
forall a. Enum a => a -> Int
fromEnum Integer
x) (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
y)
placement _ = Maybe Placement
forall a. Maybe a
Nothing

-- | Parse grid-template-*
parseTemplate :: [Token] -> Maybe [([Text], Unitted)]
parseTemplate [Ident "none"] = [([Text], Unitted)] -> Maybe [([Text], Unitted)]
forall a. a -> Maybe a
Just []
parseTemplate [Ident "initial"] = [([Text], Unitted)] -> Maybe [([Text], Unitted)]
forall a. a -> Maybe a
Just []
parseTemplate toks :: [Token]
toks | (tracks :: [([Text], Unitted)]
tracks@(_:_), []) <- [Token] -> ([([Text], Unitted)], [Token])
parseTrack [Token]
toks = [([Text], Unitted)] -> Maybe [([Text], Unitted)]
forall a. a -> Maybe a
Just [([Text], Unitted)]
tracks
parseTemplate _ = Maybe [([Text], Unitted)]
forall a. Maybe a
Nothing
-- | Parse an individual track specified by grid-template-*
parseTrack :: [Token] -> ([([Text], Unitted)], [Token])
parseTrack (LeftSquareBracket:toks :: [Token]
toks)
    | Just (names' :: [Text]
names', toks' :: [Token]
toks') <- [Token] -> Maybe ([Text], [Token])
parseNames [Token]
toks,
        ((names :: [Text]
names,size :: Unitted
size):cells :: [([Text], Unitted)]
cells,toks :: [Token]
toks) <- [Token] -> ([([Text], Unitted)], [Token])
parseTrack [Token]
toks' = (([Text]
names' [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text]
names,Unitted
size)([Text], Unitted) -> [([Text], Unitted)] -> [([Text], Unitted)]
forall a. a -> [a] -> [a]
:[([Text], Unitted)]
cells,[Token]
toks)
    | Just (names' :: [Text]
names', toks' :: [Token]
toks') <- [Token] -> Maybe ([Text], [Token])
parseNames [Token]
toks = ([([Text]
names',(0,"end"))],[Token]
toks')
parseTrack (tok :: Token
tok:toks :: [Token]
toks) | Just x :: Unitted
x <- [Token] -> Maybe Unitted
parseFR' [Token
tok] =
    (([], Unitted
x)([Text], Unitted) -> [([Text], Unitted)] -> [([Text], Unitted)]
forall a. a -> [a] -> [a]
:([([Text], Unitted)], [Token]) -> [([Text], Unitted)]
forall a b. (a, b) -> a
fst ([Token] -> ([([Text], Unitted)], [Token])
parseTrack [Token]
toks), ([([Text], Unitted)], [Token]) -> [Token]
forall a b. (a, b) -> b
snd (([([Text], Unitted)], [Token]) -> [Token])
-> ([([Text], Unitted)], [Token]) -> [Token]
forall a b. (a -> b) -> a -> b
$ [Token] -> ([([Text], Unitted)], [Token])
parseTrack [Token]
toks)
parseTrack (Function "repeat":Number _ (NVInteger x :: Integer
x):Comma:toks :: [Token]
toks)
    | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> 0, (tracks :: [([Text], Unitted)]
tracks@(_:_), RightParen:toks' :: [Token]
toks') <- [Token] -> ([([Text], Unitted)], [Token])
parseTrack [Token]
toks =
        ([[([Text], Unitted)]] -> [([Text], Unitted)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[([Text], Unitted)]] -> [([Text], Unitted)])
-> [[([Text], Unitted)]] -> [([Text], Unitted)]
forall a b. (a -> b) -> a -> b
$ Int -> [([Text], Unitted)] -> [[([Text], Unitted)]]
forall a. Int -> a -> [a]
replicate (Integer -> Int
forall a. Enum a => a -> Int
fromEnum Integer
x) [([Text], Unitted)]
tracks, [Token]
toks')
parseTrack toks :: [Token]
toks = ([], [Token]
toks)
-- | (UNUSED) Parse a subgrid specified by grid-template-*
parseSubgrid :: [Token] -> ([[Text]], [Token])
parseSubgrid (LeftSquareBracket:toks :: [Token]
toks)
    | Just (names' :: [Text]
names', toks' :: [Token]
toks') <- [Token] -> Maybe ([Text], [Token])
parseNames [Token]
toks, (names :: [[Text]]
names,toks'' :: [Token]
toks'') <- [Token] -> ([[Text]], [Token])
parseSubgrid [Token]
toks' =
        ([Text]
names' [Text] -> [[Text]] -> [[Text]]
forall a. a -> [a] -> [a]
: [[Text]]
names, [Token]
toks')
parseSubgrid (Function "repeat":Number _ (NVInteger x :: Integer
x):Comma:toks :: [Token]
toks)
    | Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> 0, (names :: [[Text]]
names@(_:_), RightParen:toks' :: [Token]
toks') <- [Token] -> ([[Text]], [Token])
parseSubgrid [Token]
toks =
        ([[[Text]]] -> [[Text]]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[[Text]]] -> [[Text]]) -> [[[Text]]] -> [[Text]]
forall a b. (a -> b) -> a -> b
$ Int -> [[Text]] -> [[[Text]]]
forall a. Int -> a -> [a]
replicate (Integer -> Int
forall a. Enum a => a -> Int
fromEnum Integer
x) [[Text]]
names, [Token]
toks')
parseSubgrid toks :: [Token]
toks = ([], [Token]
toks)
-- | Parse a track's names.
parseNames :: [Token] -> Maybe ([Text], [Token])
parseNames (Ident x :: Text
x:toks :: [Token]
toks)
    | Just (names :: [Text]
names,toks' :: [Token]
toks') <- [Token] -> Maybe ([Text], [Token])
parseNames [Token]
toks = ([Text], [Token]) -> Maybe ([Text], [Token])
forall a. a -> Maybe a
Just (Text
xText -> [Text] -> [Text]
forall a. a -> [a] -> [a]
:[Text]
names,[Token]
toks')
parseNames (RightSquareBracket:toks :: [Token]
toks) = ([Text], [Token]) -> Maybe ([Text], [Token])
forall a. a -> Maybe a
Just ([], [Token]
toks)
parseNames _ = Maybe ([Text], [Token])
forall a. Maybe a
Nothing

-- | Desugar grid properties to a grid layout.
finalizeGrid :: PropertyParser x => CSSGrid -> Font' ->
    [CSSCell] -> [LayoutItem Length Length x] -> LayoutItem Length Length x
finalizeGrid :: CSSGrid
-> Font'
-> [CSSCell]
-> [LayoutItem Length Length x]
-> LayoutItem Length Length x
finalizeGrid self :: CSSGrid
self@CSSGrid {
        templateColumns :: CSSGrid -> [([Text], Unitted)]
templateColumns = [([Text], Unitted)]
cols', templateRows :: CSSGrid -> [([Text], Unitted)]
templateRows = [([Text], Unitted)]
rows'
    } font :: Font'
font cells :: [CSSCell]
cells childs :: [LayoutItem Length Length x]
childs = x
-> Grid Length Length
-> [GridItem]
-> [LayoutItem Length Length x]
-> LayoutItem Length Length x
forall m n x.
x
-> Grid m n -> [GridItem] -> [LayoutItem m n x] -> LayoutItem m n x
LayoutGrid x
forall a. PropertyParser a => a
temp Grid Length Length
self' [GridItem]
cells' [LayoutItem Length Length x]
childs
  where
    self' :: Grid Length Length
self' = Track Length -> Track Length -> Grid Length Length
forall m n. n -> m -> Size m n
Size Track :: forall x. [Either x Double] -> [Double] -> [Double] -> x -> Track x
Track {
        cells :: [Either Length Double]
cells = (Unitted -> Either Length Double)
-> [Unitted] -> [Either Length Double]
forall a b. (a -> b) -> [a] -> [b]
map Unitted -> Either Length Double
finalizeFR ([Unitted] -> [Either Length Double])
-> [Unitted] -> [Either Length Double]
forall a b. (a -> b) -> a -> b
$ (([Text], Unitted) -> Unitted) -> [([Text], Unitted)] -> [Unitted]
forall a b. (a -> b) -> [a] -> [b]
map ([Text], Unitted) -> Unitted
forall a b. (a, b) -> b
snd [([Text], Unitted)]
rows0,
        trackMins :: [Double]
trackMins = [], trackNats :: [Double]
trackNats = [],
        gap :: Length
gap = Unitted -> Font' -> Length
finalizeLength (Size Unitted Unitted -> Unitted
forall m n. Size m n -> n
inline (Size Unitted Unitted -> Unitted)
-> Size Unitted Unitted -> Unitted
forall a b. (a -> b) -> a -> b
$ CSSGrid -> Size Unitted Unitted
cssGap CSSGrid
self) Font'
font
      } Track :: forall x. [Either x Double] -> [Double] -> [Double] -> x -> Track x
Track {
        cells :: [Either Length Double]
cells = (Unitted -> Either Length Double)
-> [Unitted] -> [Either Length Double]
forall a b. (a -> b) -> [a] -> [b]
map Unitted -> Either Length Double
finalizeFR ([Unitted] -> [Either Length Double])
-> [Unitted] -> [Either Length Double]
forall a b. (a -> b) -> a -> b
$ (([Text], Unitted) -> Unitted) -> [([Text], Unitted)] -> [Unitted]
forall a b. (a -> b) -> [a] -> [b]
map ([Text], Unitted) -> Unitted
forall a b. (a, b) -> b
snd [([Text], Unitted)]
cols0,
        trackMins :: [Double]
trackMins = [], trackNats :: [Double]
trackNats = [],
        gap :: Length
gap = Unitted -> Font' -> Length
finalizeLength (Size Unitted Unitted -> Unitted
forall m n. Size m n -> m
block (Size Unitted Unitted -> Unitted)
-> Size Unitted Unitted -> Unitted
forall a b. (a -> b) -> a -> b
$ CSSGrid -> Size Unitted Unitted
cssGap CSSGrid
self) Font'
font
      }

    (cells' :: [GridItem]
cells', rows0 :: [([Text], Unitted)]
rows0, cols0 :: [([Text], Unitted)]
cols0) = [CSSCell]
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> ([GridItem], [([Text], Unitted)], [([Text], Unitted)])
finalizeCells [CSSCell]
cells [([Text], Unitted)]
rows' [([Text], Unitted)]
cols'
    finalizeCells :: [CSSCell] -> [([Text], Unitted)] -> [([Text], Unitted)] ->
            ([GridItem], [([Text], Unitted)], [([Text], Unitted)])
    finalizeCells :: [CSSCell]
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> ([GridItem], [([Text], Unitted)], [([Text], Unitted)])
finalizeCells (cell :: CSSCell
cell:cells :: [CSSCell]
cells) rows :: [([Text], Unitted)]
rows cols :: [([Text], Unitted)]
cols = (GridItem
cell'GridItem -> [GridItem] -> [GridItem]
forall a. a -> [a] -> [a]
:[GridItem]
cells', [([Text], Unitted)]
rows_, [([Text], Unitted)]
cols_)
      where
        (cell' :: GridItem
cell', rows0 :: [([Text], Unitted)]
rows0, cols0 :: [([Text], Unitted)]
cols0) = CSSCell
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> (GridItem, [([Text], Unitted)], [([Text], Unitted)])
finalizeCell CSSCell
cell [([Text], Unitted)]
rows [([Text], Unitted)]
cols
        (cells' :: [GridItem]
cells', rows_ :: [([Text], Unitted)]
rows_, cols_ :: [([Text], Unitted)]
cols_) = [CSSCell]
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> ([GridItem], [([Text], Unitted)], [([Text], Unitted)])
finalizeCells [CSSCell]
cells [([Text], Unitted)]
rows0 [([Text], Unitted)]
cols0
    finalizeCells [] rows :: [([Text], Unitted)]
rows cols :: [([Text], Unitted)]
cols = ([], [([Text], Unitted)]
rows, [([Text], Unitted)]
cols)
    finalizeCell :: CSSCell -> [([Text], Unitted)] -> [([Text], Unitted)] ->
            (GridItem, [([Text], Unitted)], [([Text], Unitted)])
    finalizeCell :: CSSCell
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> (GridItem, [([Text], Unitted)], [([Text], Unitted)])
finalizeCell cell :: CSSCell
cell@CSSCell {
            rowStart :: CSSCell -> Placement
rowStart = Placement
Autoplace, columnStart :: CSSCell -> Placement
columnStart = Placement
Autoplace
        } rows :: [([Text], Unitted)]
rows cols :: [([Text], Unitted)]
cols | CSSGrid -> Axis
autoFlow CSSGrid
self Axis -> Axis -> Bool
forall a. Eq a => a -> a -> Bool
== Axis
Row =
            CSSCell
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> (GridItem, [([Text], Unitted)], [([Text], Unitted)])
finalizeCell CSSCell
cell { columnStart :: Placement
columnStart = Int -> Maybe Text -> Placement
Numbered 1 Maybe Text
forall a. Maybe a
Nothing } [([Text], Unitted)]
rows [([Text], Unitted)]
cols
        | CSSGrid -> Axis
autoFlow CSSGrid
self Axis -> Axis -> Bool
forall a. Eq a => a -> a -> Bool
== Axis
Col =
            CSSCell
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> (GridItem, [([Text], Unitted)], [([Text], Unitted)])
finalizeCell CSSCell
cell { rowStart :: Placement
rowStart = Int -> Maybe Text -> Placement
Numbered 1 Maybe Text
forall a. Maybe a
Nothing } [([Text], Unitted)]
rows [([Text], Unitted)]
cols
    finalizeCell cell :: CSSCell
cell rows :: [([Text], Unitted)]
rows cols :: [([Text], Unitted)]
cols = (GridItem' -> GridItem' -> GridItem
forall m n. n -> m -> Size m n
Size GridItem :: Int -> Int -> Alignment -> Double -> Double -> GridItem'
GridItem {
            cellStart :: Int
cellStart = Int
startCol', cellEnd :: Int
cellEnd = Int
endCol',
            minSize :: Double
minSize = 0, natSize :: Double
natSize = 0,
            alignment :: Alignment
alignment = Alignment -> Maybe Alignment -> Alignment
forall a. a -> Maybe a -> a
fromMaybe (Size Alignment Alignment -> Alignment
forall m n. Size m n -> n
inline (Size Alignment Alignment -> Alignment)
-> Size Alignment Alignment -> Alignment
forall a b. (a -> b) -> a -> b
$ CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) (Size (Maybe Alignment) (Maybe Alignment) -> Maybe Alignment
forall m n. Size m n -> n
inline (Size (Maybe Alignment) (Maybe Alignment) -> Maybe Alignment)
-> Size (Maybe Alignment) (Maybe Alignment) -> Maybe Alignment
forall a b. (a -> b) -> a -> b
$ CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
cell)
        } GridItem :: Int -> Int -> Alignment -> Double -> Double -> GridItem'
GridItem {
            cellStart :: Int
cellStart = Int
startRow', cellEnd :: Int
cellEnd = Int
endRow',
            minSize :: Double
minSize = 0, natSize :: Double
natSize = 0,
            alignment :: Alignment
alignment = Alignment -> Maybe Alignment -> Alignment
forall a. a -> Maybe a -> a
fromMaybe (Size Alignment Alignment -> Alignment
forall m n. Size m n -> n
inline (Size Alignment Alignment -> Alignment)
-> Size Alignment Alignment -> Alignment
forall a b. (a -> b) -> a -> b
$ CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) (Size (Maybe Alignment) (Maybe Alignment) -> Maybe Alignment
forall m n. Size m n -> n
inline (Size (Maybe Alignment) (Maybe Alignment) -> Maybe Alignment)
-> Size (Maybe Alignment) (Maybe Alignment) -> Maybe Alignment
forall a b. (a -> b) -> a -> b
$ CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
cell)
        }, [([Text], Unitted)]
rows', [([Text], Unitted)]
cols')
      where
        (startRow' :: Int
startRow', endRow' :: Int
endRow', rows' :: [([Text], Unitted)]
rows') = [([Text], Unitted)]
-> ([Text], Unitted)
-> Placement
-> Placement
-> (Int, Int, [([Text], Unitted)])
forall b.
[([Text], b)]
-> ([Text], b)
-> Placement
-> Placement
-> (Int, Int, [([Text], b)])
lowerTrack2 [([Text], Unitted)]
rows ([], CSSGrid -> Unitted
autoRows CSSGrid
self)
                (CSSCell -> Placement
rowStart CSSCell
cell) (CSSCell -> Placement
rowEnd CSSCell
cell)
        (startCol' :: Int
startCol', endCol' :: Int
endCol', cols' :: [([Text], Unitted)]
cols') = [([Text], Unitted)]
-> ([Text], Unitted)
-> Placement
-> Placement
-> (Int, Int, [([Text], Unitted)])
forall b.
[([Text], b)]
-> ([Text], b)
-> Placement
-> Placement
-> (Int, Int, [([Text], b)])
lowerTrack2 [([Text], Unitted)]
cols ([], CSSGrid -> Unitted
autoColumns CSSGrid
self) 
                (CSSCell -> Placement
columnStart CSSCell
cell) (CSSCell -> Placement
columnEnd CSSCell
cell)

    lowerTrack2 :: [([Text], b)]
-> ([Text], b)
-> Placement
-> Placement
-> (Int, Int, [([Text], b)])
lowerTrack2 tracks :: [([Text], b)]
tracks auto :: ([Text], b)
auto start :: Placement
start Autoplace = [([Text], b)]
-> ([Text], b)
-> Placement
-> Placement
-> (Int, Int, [([Text], b)])
lowerTrack2 [([Text], b)]
tracks ([Text], b)
auto Placement
start (Placement -> (Int, Int, [([Text], b)]))
-> Placement -> (Int, Int, [([Text], b)])
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Span 1 Maybe Text
forall a. Maybe a
Nothing
    lowerTrack2 tracks :: [([Text], b)]
tracks auto :: ([Text], b)
auto start :: Placement
start@(Span _ _) end :: Placement
end@(Span _ _) =
        [([Text], b)]
-> ([Text], b)
-> Placement
-> Placement
-> (Int, Int, [([Text], b)])
lowerTrack2 [([Text], b)]
tracks ([Text], b)
auto Placement
start (Placement -> (Int, Int, [([Text], b)]))
-> Placement -> (Int, Int, [([Text], b)])
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Numbered (Int -> Int
forall a. Enum a => a -> a
pred (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ [([Text], b)] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [([Text], b)]
tracks) Maybe Text
forall a. Maybe a
Nothing
    lowerTrack2 tracks :: [([Text], b)]
tracks auto :: ([Text], b)
auto start :: Placement
start@(Span _ _) end :: Placement
end = (Int
start', Int
end', [([Text], b)]
tracks')
      where
        (end' :: Int
end', tracks0 :: [([Text], b)]
tracks0) = [([Text], b)]
-> ([Text], b) -> Int -> Placement -> (Int, [([Text], b)])
forall b.
[([Text], b)]
-> ([Text], b) -> Int -> Placement -> (Int, [([Text], b)])
lowerTrack [([Text], b)]
tracks ([Text], b)
auto 0 Placement
end -- Already checked for spans.
        (start' :: Int
start', tracks' :: [([Text], b)]
tracks') = [([Text], b)]
-> ([Text], b) -> Int -> Placement -> (Int, [([Text], b)])
forall b.
[([Text], b)]
-> ([Text], b) -> Int -> Placement -> (Int, [([Text], b)])
lowerTrack [([Text], b)]
tracks ([Text], b)
auto (Int -> Int
forall a. Num a => a -> a
negate Int
end') Placement
start
    lowerTrack2 tracks :: [([Text], b)]
tracks auto :: ([Text], b)
auto start :: Placement
start end :: Placement
end = (Int
start', Int
end', [([Text], b)]
tracks')
      where
        (start' :: Int
start', tracks0 :: [([Text], b)]
tracks0) = [([Text], b)]
-> ([Text], b) -> Int -> Placement -> (Int, [([Text], b)])
forall b.
[([Text], b)]
-> ([Text], b) -> Int -> Placement -> (Int, [([Text], b)])
lowerTrack [([Text], b)]
tracks ([Text], b)
auto 0 Placement
start -- already checked for spans.
        (end' :: Int
end', tracks' :: [([Text], b)]
tracks') = [([Text], b)]
-> ([Text], b) -> Int -> Placement -> (Int, [([Text], b)])
forall b.
[([Text], b)]
-> ([Text], b) -> Int -> Placement -> (Int, [([Text], b)])
lowerTrack [([Text], b)]
tracks ([Text], b)
auto Int
start' Placement
end
    lowerTrack :: [([Text], b)]
-> ([Text], b) -> Int -> Placement -> (Int, [([Text], b)])
lowerTrack tracks :: [([Text], b)]
tracks auto :: ([Text], b)
auto _ (Named name :: Text
name)
        | ix :: Int
ix:_ <- [Int
ix | (ix :: Int
ix, (names :: [Text]
names, _)) <- [([Text], b)] -> [(Int, ([Text], b))]
forall b. [b] -> [(Int, b)]
enumerate [([Text], b)]
tracks, Text
name Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
names] = (Int
ix, [([Text], b)]
tracks)
        | Bool
otherwise = ([([Text], b)] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [([Text], b)]
tracks, [([Text], b)]
tracks [([Text], b)] -> [([Text], b)] -> [([Text], b)]
forall a. [a] -> [a] -> [a]
++ [([Text], b)
auto])

    -- TODO Take into account placement strategy.
    lowerTrack tracks :: [([Text], b)]
tracks auto :: ([Text], b)
auto _ Autoplace = ([([Text], b)] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [([Text], b)]
tracks, [([Text], b)]
tracks [([Text], b)] -> [([Text], b)] -> [([Text], b)]
forall a. [a] -> [a] -> [a]
++ [([Text], b)
auto])
    lowerTrack tracks :: [([Text], b)]
tracks _ _ (Numbered ix :: Int
ix Nothing) = (Int
ix, [([Text], b)]
tracks)
    lowerTrack tracks :: [([Text], b)]
tracks auto :: ([Text], b)
auto _ (Numbered ix :: Int
ix (Just name :: Text
name))
        | Int
ix Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< [Int] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int]
tracks' = ([Int]
tracks' [Int] -> Int -> Int
forall a. [a] -> Int -> a
!! Int
ix, [([Text], b)]
tracks)
        | Bool
otherwise = ([([Text], b)] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [([Text], b)]
tracks, [([Text], b)]
tracks [([Text], b)] -> [([Text], b)] -> [([Text], b)]
forall a. [a] -> [a] -> [a]
++ [([Text], b)
auto])
      where tracks' :: [Int]
tracks' = [Int
ix | (ix :: Int
ix, (names :: [Text]
names, _)) <- [([Text], b)] -> [(Int, ([Text], b))]
forall b. [b] -> [(Int, b)]
enumerate [([Text], b)]
tracks, Text
name Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
names]
    lowerTrack tracks :: [([Text], b)]
tracks _ start :: Int
start (Span x :: Int
x Nothing)
        | Int
start Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> 0 = (Int
start Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
x,[([Text], b)]
tracks)
        | Bool
otherwise = (-Int
start Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
x,[([Text], b)]
tracks)
    lowerTrack tracks :: [([Text], b)]
tracks (_, auto :: b
auto) start :: Int
start (Span x :: Int
x (Just name :: Text
name)) = ([Int]
tracks' [Int] -> Int -> Int
forall a. [a] -> Int -> a
!! Int
x,[([Text], b)]
tracks)
      where
        tracks0 :: [([Text], b)]
tracks0 | Int
start Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< 0 = [([Text], b)] -> [([Text], b)]
forall a. [a] -> [a]
reverse [([Text], b)]
tracks
            | Bool
otherwise = [([Text], b)]
tracks
        tracks' :: [Int]
tracks' = [Int
ix | (ix :: Int
ix, (names :: [Text]
names, _)) <-
            Int -> [(Int, ([Text], b))] -> [(Int, ([Text], b))]
forall a. Int -> [a] -> [a]
drop (Int -> Int
forall a. Num a => a -> a
abs Int
start) ([(Int, ([Text], b))] -> [(Int, ([Text], b))])
-> [(Int, ([Text], b))] -> [(Int, ([Text], b))]
forall a b. (a -> b) -> a -> b
$ [([Text], b)] -> [(Int, ([Text], b))]
forall b. [b] -> [(Int, b)]
enumerate ([([Text], b)]
tracks0 [([Text], b)] -> [([Text], b)] -> [([Text], b)]
forall a. [a] -> [a] -> [a]
++ ([Text], b) -> [([Text], b)]
forall a. a -> [a]
repeat ([Text
name],b
auto)),
            Text
name Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
names]

    finalizeFR :: Unitted -> Either Length Double
finalizeFR (x :: Double
x,"fr") = Double -> Either Length Double
forall a b. b -> Either a b
Right Double
x
    finalizeFR x :: Unitted
x = Length -> Either Length Double
forall a b. a -> Either a b
Left (Length -> Either Length Double) -> Length -> Either Length Double
forall a b. (a -> b) -> a -> b
$ Unitted -> Font' -> Length
finalizeLength Unitted
x Font'
font