{-# LANGUAGE OverloadedStrings, FlexibleInstances #-}
module Graphics.Rendering.Rect.CSS.Backgrounds (Backgrounds(..),
Pattern(..), RadialShape(..), Extent(..),
Resize(..), Length(..), resolveSize) where
import Stylist (PropertyParser(..), parseUnorderedShorthand, parseOperands)
import Data.CSS.Syntax.Tokens (Token(..), NumericValue(..))
import Data.Maybe (isJust, catMaybes)
import Data.Text (Text)
import Data.Scientific (scientific, toRealFloat)
import Graphics.Rendering.Rect.CSS.Colour (ColourPallet, parseColour)
import Data.Colour (AlphaColour, transparent)
import Graphics.Rendering.Rect.Types (Rects(..), Rect(..))
data Backgrounds img = Backgrounds {
pallet :: ColourPallet,
background :: C,
clip :: [Rects -> Rect],
origin :: [Rects -> Rect],
image :: [Pattern img],
bgPos :: [(Length, Length)],
bgSize :: [Resize],
bgRepeat :: [(Bool, Bool)]
} deriving (Eq, Show, Read)
type C = AlphaColour Float
data Pattern img = None | Img img | Linear Float [(C, Length)]
| Radial RadialShape Extent (Length, Length) [(C, Length)]
| Conical Float (Length, Length) [(C, Length)]
deriving (Eq, Show, Read)
data RadialShape = Circle | Ellipse deriving (Eq, Show, Read)
data Extent = Extent Length Length | ClosestCorner
| ClosestSide | FarthestCorner | FarthestSide deriving (Eq, Show, Read)
-- We need to resolve images before we can compute the actual lengths!
data Resize = Cover | Contain | Size Length Length deriving (Eq, Show, Read)
data Length = Absolute Float | Scale Float | Auto deriving (Eq, Show, Read)
instance PropertyParser (Backgrounds Text) where
temp = Backgrounds {
pallet = temp, background = transparent, clip = [borderBox],
image = [None], bgSize = [Size Auto Auto], origin = [paddingBox],
bgPos = [(Absolute 0, Absolute 0)], bgRepeat = [(True, True)]
}
inherit _ = temp
priority _ = []
longhand _ self@Backgrounds{ pallet = c } "background-color" toks
| Just ([], val) <- parseColour c toks = Just self { background = val }
longhand _ self "background-clip" t | val@(_:_) <- parseCSSList box t =
Just self { clip = reverse val }
longhand _ self@Backgrounds { pallet = pp } "background-image" t
| val@(_:_) <- parseCSSList inner t = Just self { image = reverse val }
where
inner [Ident "none"] = Just None
inner [Ident "initial"] = Just None
inner [Url ret] = Just $ Img ret
inner [Function "url", String ret, RightParen] = Just $ Img ret
inner (Function "linear-gradient":toks)
| Just cs@(_:_:_)<-colourStops pp (Comma:toks) = Just $ Linear pi cs
inner (Function "linear-gradient":Dimension _ x unit:toks)
| Just s <- lookup unit angularUnits,
Just cs@(_:_:_) <- colourStops pp toks = Just $ Linear (f x*s) cs
inner (Function "linear-gradient":Ident "to":Ident a:Ident b:toks)
| Just angle<-corner a b, Just stops@(_:_:_)<-colourStops pp toks =
Just $ Linear angle stops
| Just angle<-corner b a, Just stops@(_:_:_)<-colourStops pp toks =
Just $ Linear angle stops
where
corner "top" "right" = Just $ 0.25*pi
corner "bottom" "right" = Just $ 0.75*pi
corner "bottom" "left" = Just $ 1.25*pi
corner "top" "left" = Just $ 1.75*pi
corner _ _ = Nothing
inner (Function "linear-gradient":Ident "to":Ident side:toks)
| Just angle <- lookup side [
("top", 0), ("right", pi/2), ("bottom", pi), ("left", pi*1.5)],
Just cs@(_:_:_) <- colourStops pp toks = Just $ Linear angle cs
inner (Function "radial-gradient":toks)
| Just cs@(_:_:_) <- colourStops pp (Comma:toks) =
Just $ Radial Ellipse FarthestCorner center cs
| (shp, org, ext, ts) <- radArgs toks,
Just cs@(_:_:_) <- colourStops pp ts = Just $ Radial shp ext org cs
where
radArgs (Ident s:Ident "at":ts) | Just shape <- radShape s,
Just (org, ts') <- position ts =
(shape, org, FarthestCorner, ts')
radArgs (Ident "at":ts) | Just (org, ts') <- position ts =
(Ellipse, org, FarthestCorner, ts')
radArgs (Ident "circle":Ident "at":ts)
| Just (org, ts') <- position ts = (Circle,org,FarthestCorner,ts')
radArgs (Ident "circle":ts)
| Just (_, Ident "at":ts') <- circleExt ts,
Just (org, stops) <- position ts' =
(Circle, org, FarthestCorner, stops)
| Just (_,ts')<-circleExt ts=(Circle,center,FarthestCorner,ts')
| otherwise = (Circle, center, FarthestCorner, ts)
radArgs (Ident "ellipse":Ident "at":ts)
| Just (org,ts')<-position ts=(Ellipse,org,FarthestCorner,ts')
radArgs (Ident "ellipse":ts)
| Just (_, Ident "at":ts') <- ellipseExt ts,
Just (org, stops) <- position ts' =
(Ellipse, org, FarthestCorner, stops)
| Just (_,ts')<-ellipseExt ts=(Ellipse,center,FarthestCorner,ts')
| otherwise = (Ellipse, center, FarthestCorner, ts)
radArgs ts | Just (_, Ident "at":ts') <- ellipseExt ts,
Just (org, stops) <- position ts' =
(Ellipse, org, FarthestCorner, stops)
| Just (_, Ident "ellipse":Ident "at":ts') <- ellipseExt ts,
Just (org, stops) <- position ts' =
(Ellipse, org, FarthestCorner, stops)
| Just (_, Ident "ellipse":ts') <- ellipseExt ts =
(Ellipse, center, FarthestCorner, ts')
| Just (_, Ident "circle":Ident "at":ts') <- circleExt ts,
Just (org, stops) <- position ts' =
(Circle, org, FarthestCorner, stops)
| Just (_, Ident "circle":ts') <- circleExt ts =
(Circle, center, FarthestCorner, ts')
| otherwise = (Ellipse, center, FarthestCorner, ts)
radShape "circle" = Just Circle
radShape "ellipse" = Just Ellipse
radShape _ = Nothing
radExt (Ident "closest-corner":ts) = Just (ClosestCorner, ts)
radExt (Ident "closest-side":ts) = Just (ClosestSide, ts)
radExt (Ident "farthest-corner":ts) = Just (FarthestCorner, ts)
radExt (Ident "farthest-side":ts) = Just (FarthestSide, ts)
radExt _ = Nothing
ellipseExt ts | Just ret <- radExt ts = Just ret
ellipseExt (Percentage _ x:Percentage _ y:ts) =
Just (p' x `Extent` p' y, ts)
ellipseExt (Percentage _ x:Dimension _ y "px":ts) =
Just (p' x `Extent` f' y, ts)
ellipseExt (Dimension _ x "px":Percentage _ y:ts) =
Just (f' x `Extent` p' y, ts)
ellipseExt (Dimension _ x "px":Dimension _ y "px":ts) =
Just (f' x `Extent` p' y, ts)
ellipseExt _ = Nothing
circleExt (Dimension _ x "px":ts) = Just (f' x `Extent` f' x, ts)
circleExt ts = radExt ts
-- NOTE: Not implementing colourspaces yet...
inner (Function "conic-gradient":Ident "from":Dimension _ x unit:
Ident "at":ts)
| Just (org, ts') <- position ts, Just s <- lookup unit angularUnits,
Just stops@(_:_:_) <- colourStops pp ts' =
Just $ Conical (f x*s) org stops
inner (Function "conic-gradient":Ident "from":Dimension _ x unit:ts)
| Just s <- lookup unit angularUnits,
Just stops@(_:_:_) <- colourStops pp ts =
Just $ Conical (f x*s) center stops
inner (Function "conic-gradient":Ident "at":ts)
| Just (org, ts') <- position ts,
Just cs@(_:_:_) <- colourStops pp ts' = Just $ Conical 0 org cs
inner (Function "conic-gradient":ts)
| Just stops@(_:_:_) <- colourStops pp (Comma:ts) =
Just $ Conical 0 center stops
inner _ = Nothing
angularUnits = [("deg",pi/180),("grad",pi/200),("rad",1),("turn",2*pi)]
center = (Scale 0.5, Scale 0.5)
longhand _ self "background-origin" t | val@(_:_) <- parseCSSList box t =
Just self { origin = reverse val }
longhand _ self "background-position" t | val@(_:_) <- parseCSSList position t,
all (null . snd) val = Just self { bgPos = reverse $ map fst val }
longhand _ self "background-repeat" t | val@(_:_) <- parseCSSList inner t =
Just self { bgRepeat = reverse val }
where
inner [Ident "initial"] = Just (True, True)
inner [Ident "repeat-x"] = Just (True, False)
inner [Ident "repeat-y"] = Just (False, True)
inner [x] | Just y <- inner' x = Just (y, y)
inner [x, y] | Just x' <- inner' x, Just y' <- inner' y = Just (x', y')
inner _ = Nothing
inner' (Ident "repeat") = Just True
inner' (Ident "no-repeat") = Just False
inner' _ = Nothing
longhand _ self "background-size" t | val@(_:_) <- parseCSSList inner t =
Just self { bgSize = reverse val }
where -- TODO: Add shorthand support, after background-position.
inner [x, y] | Just a <- l x, Just b <- l y = Just $ Size a b
inner [Ident "contain"] = Just Contain
inner [Ident "cover"] = Just Cover
inner [Ident "auto"] = Just $ Size Auto Auto
inner [Ident "initial"] = Just $ Size Auto Auto
inner _ = Nothing
-- NOTE: Leave lowering other units to CatTrap.
l (Ident "auto") = Just Auto
l (Dimension _ x "px") = Just $ Absolute $ f x
l (Percentage _ x) = Just $ Scale $ p x
l _ = Nothing
longhand _ _ _ _ = Nothing
-- The multi-layered shorthand is one source of parsing complexity.
shorthand self "background" t = catProps $ reverse $ parseCSSList inner t
where
catProps [] = []
catProps (props:pss)
| Just [Ident "initial"] <- "background-color" `lookup` catProps pss =
map (catProp $ catProps pss) props
| otherwise = [] -- Only allow background-color in bottommost layer.
catProp _ ret@("background-color", _) = ret
catProp bases (key, val)
| Just base <- key `lookup` bases = (key, base ++ Comma:val)
-- Shouldn't happen, `inner` expands all props at least to "initial"!
| otherwise = (key, val)
inner toks | ret@(_:_) <- parseUnorderedShorthand self [
"background-color", "background-clip", "background-image",
"background-origin", "background-position"
] toks = Just ret
| otherwise = Nothing
shorthand self key val | Just _ <- longhand self self key val = [(key, val)]
| otherwise = []
box :: [Token] -> Maybe (Rects -> Rect)
box [Ident "content-box"] = Just contentBox
box [Ident "padding-box"] = Just paddingBox
box [Ident "border-box"] = Just borderBox
box [Ident "initial"] = Just borderBox -- To aid shorthand implementation.
box _ = Nothing
position :: [Token] -> Maybe ((Length, Length), [Token])
position (x:y:ts) = position' x y ts <* position' y x ts <* position' x x (y:ts)
position [x] = position' x x []
position _ = Nothing
position' :: Token -> Token -> [Token] -> Maybe ((Length, Length), [Token])
position' x y ts = case ((case x of
Ident "left" -> Scale 0
Ident "center" -> Scale 0.5
Ident "right" -> Scale 1
Percentage _ a -> p' a
Dimension _ a "px" -> f' a
_ -> Auto,
case y of
Ident "top" -> Scale 0
Ident "center" -> Scale 0.5
Ident "bottom" -> Scale 1
Percentage _ a -> p' a
Dimension _ a "px" -> f' a
_ -> Auto),
ts) of
((Auto, _), _) -> Nothing
((_, Auto), _) -> Nothing
ret -> Just ret
colourStops :: ColourPallet
-> [Token] -> Maybe [(AlphaColour Float, Length)]
colourStops _ [RightParen] = Just []
colourStops cs (Comma:toks)
| Just (Percentage _ x:toks', c) <- parseColour cs toks,
Just ret <- colourStops cs toks' = Just $ (c, Scale $ p x):ret
| Just (Dimension _ x "px":toks', c) <- parseColour cs toks,
Just ret <- colourStops cs toks' = Just $ (c, Absolute $ f x):ret
| Just (toks', c) <- parseColour cs toks,
Just ret <- colourStops cs toks' = Just $ (c, Auto):ret
colourStops cs (Comma:Percentage _ x:toks)
| Just (toks', c) <- parseColour cs toks,
Just ret <- colourStops cs toks' = Just $ (c, Scale $ p x):ret
colourStops cs (Comma:Dimension _ x "px":toks)
| Just (toks', c) <- parseColour cs toks,
Just ret <- colourStops cs toks' = Just $ (c, Absolute $ f x):ret
colourStops _ _ = Nothing
parseCSSList :: ([Token] -> Maybe a) -> [Token] -> [a]
parseCSSList cb toks | all isJust ret = catMaybes ret
| otherwise = []
where ret = map cb $ map concat $ splitList [Comma] $ parseOperands toks
f :: NumericValue -> Float
f (NVInteger x) = fromInteger x
f (NVNumber x) = toRealFloat x
p :: NumericValue -> Float
p (NVInteger x) = fromInteger x / 100
-- Do the division while we're in base-10!
p (NVNumber x) = toRealFloat (x/scientific 1 2)
p' :: NumericValue -> Length
p' = Scale . p
f' :: NumericValue -> Length
f' = Absolute . f
------
--- Utils taken from HappStack
------
-- | Repeadly splits a list by the provided separator and collects the results
splitList :: Eq a => a -> [a] -> [[a]]
splitList _ [] = []
splitList sep list = h:splitList sep t
where (h,t)=split (==sep) list
-- | Split is like break, but the matching element is dropped.
split :: (a -> Bool) -> [a] -> ([a], [a])
split filt s = (x,y)
where
(x,y')=break filt s
y = if null y' then [] else tail y'
------
--- Dynamically-computed properties
------
resolveSize :: (Float, Float) -> (Float, Float) -> Resize -> (Float, Float)
resolveSize (owidth, oheight) (width, height) Contain
| width > owidth, height*sw > oheight, height > width = (width*sh, height*sh)
| width > owidth = (width*sw, height*sw)
| height > oheight = (width*sh, height*sh)
| height > width = (width*sw, height*sw)
| otherwise = (width*sh, height*sh)
where
sh = oheight/height
sw = owidth/width
resolveSize (owidth, oheight) (width, height) Cover
| owidth > width, oheight > height*sw = (width*sh, height*sh)
| oheight > height, owidth > width*sh = (width*sw, height*sw)
| owidth > width = (width*sw, height*sw)
| oheight > height = (width*sh, height*sh)
| oheight > height*sw = (width*sh, height*sh)
| owidth > width*sh = (width*sw, height*sw)
| height > width = (width*sw, height*sw)
| otherwise = (width*sh, height*sh)
where
sh = oheight/height
sw = owidth/width
resolveSize _ ret (Size Auto Auto) = ret
resolveSize _ (width, height) (Size x y) = (x', y')
where
x' | Absolute ret <- x = ret
| Scale s <- x = width*s
| Auto <- x = y' * width/height
y' | Absolute ret <- y = ret
| Scale s <- y = height*s
-- NOTE: If Auto,Auto case wasn't handled above this'd be an infinite loop.
| Auto <- y = x' * height/width