{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DeriveAnyClass #-}
module Ipe.Attributes.Types
  ( PinType(..)
  , TransformationTypes(..)
  , HorizontalAlignment(..)
  , VerticalAlignment(..)
  , TeXStyle
  , TextSizeUnit(..)
  , IpeSize(..)
  , IpePen(..)
  , IpeDash(..)
  , FillType(..)
  , IpeOpacity
  , IpeTiling
  , IpeGradient
  , IpeArrow(..), arrowName, arrowSize
  , normalArrow
  , LineJoin(..), _Miter, _Round, _Bevel
  ) where

import Control.Lens
import Data.Text (Text)
import Ipe.Value
import Data.Default
import Data.Finitary
import GHC.Generics

--------------------------------------------------------------------------------
-- * Implementations for Common Attributes

-- | Possible values for Pin
data PinType = No | Yes | Horizontal | Vertical
             deriving (PinType -> PinType -> Bool
(PinType -> PinType -> Bool)
-> (PinType -> PinType -> Bool) -> Eq PinType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PinType -> PinType -> Bool
== :: PinType -> PinType -> Bool
$c/= :: PinType -> PinType -> Bool
/= :: PinType -> PinType -> Bool
Eq,Int -> PinType -> ShowS
[PinType] -> ShowS
PinType -> String
(Int -> PinType -> ShowS)
-> (PinType -> String) -> ([PinType] -> ShowS) -> Show PinType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PinType -> ShowS
showsPrec :: Int -> PinType -> ShowS
$cshow :: PinType -> String
show :: PinType -> String
$cshowList :: [PinType] -> ShowS
showList :: [PinType] -> ShowS
Show,ReadPrec [PinType]
ReadPrec PinType
Int -> ReadS PinType
ReadS [PinType]
(Int -> ReadS PinType)
-> ReadS [PinType]
-> ReadPrec PinType
-> ReadPrec [PinType]
-> Read PinType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PinType
readsPrec :: Int -> ReadS PinType
$creadList :: ReadS [PinType]
readList :: ReadS [PinType]
$creadPrec :: ReadPrec PinType
readPrec :: ReadPrec PinType
$creadListPrec :: ReadPrec [PinType]
readListPrec :: ReadPrec [PinType]
Read,(forall x. PinType -> Rep PinType x)
-> (forall x. Rep PinType x -> PinType) -> Generic PinType
forall x. Rep PinType x -> PinType
forall x. PinType -> Rep PinType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PinType -> Rep PinType x
from :: forall x. PinType -> Rep PinType x
$cto :: forall x. Rep PinType x -> PinType
to :: forall x. Rep PinType x -> PinType
Generic)
             deriving anyclass (Eq PinType
KnownNat (Cardinality PinType)
(Eq PinType, KnownNat (Cardinality PinType)) =>
(Finite (Cardinality PinType) -> PinType)
-> (PinType -> Finite (Cardinality PinType))
-> ((1 <= Cardinality PinType) => PinType)
-> ((1 <= Cardinality PinType) => PinType)
-> (PinType -> Maybe PinType)
-> (PinType -> Maybe PinType)
-> Finitary PinType
(1 <= Cardinality PinType) => PinType
Finite (Cardinality PinType) -> PinType
PinType -> Maybe PinType
PinType -> Finite (Cardinality PinType)
forall a.
(Eq a, KnownNat (Cardinality a)) =>
(Finite (Cardinality a) -> a)
-> (a -> Finite (Cardinality a))
-> ((1 <= Cardinality a) => a)
-> ((1 <= Cardinality a) => a)
-> (a -> Maybe a)
-> (a -> Maybe a)
-> Finitary a
$cfromFinite :: Finite (Cardinality PinType) -> PinType
fromFinite :: Finite (Cardinality PinType) -> PinType
$ctoFinite :: PinType -> Finite (Cardinality PinType)
toFinite :: PinType -> Finite (Cardinality PinType)
$cstart :: (1 <= Cardinality PinType) => PinType
start :: (1 <= Cardinality PinType) => PinType
$cend :: (1 <= Cardinality PinType) => PinType
end :: (1 <= Cardinality PinType) => PinType
$cprevious :: PinType -> Maybe PinType
previous :: PinType -> Maybe PinType
$cnext :: PinType -> Maybe PinType
next :: PinType -> Maybe PinType
Finitary)

-- | Possible values for Transformation
data TransformationTypes = Affine | Rigid | Translations
                         deriving (Int -> TransformationTypes -> ShowS
[TransformationTypes] -> ShowS
TransformationTypes -> String
(Int -> TransformationTypes -> ShowS)
-> (TransformationTypes -> String)
-> ([TransformationTypes] -> ShowS)
-> Show TransformationTypes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TransformationTypes -> ShowS
showsPrec :: Int -> TransformationTypes -> ShowS
$cshow :: TransformationTypes -> String
show :: TransformationTypes -> String
$cshowList :: [TransformationTypes] -> ShowS
showList :: [TransformationTypes] -> ShowS
Show,ReadPrec [TransformationTypes]
ReadPrec TransformationTypes
Int -> ReadS TransformationTypes
ReadS [TransformationTypes]
(Int -> ReadS TransformationTypes)
-> ReadS [TransformationTypes]
-> ReadPrec TransformationTypes
-> ReadPrec [TransformationTypes]
-> Read TransformationTypes
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TransformationTypes
readsPrec :: Int -> ReadS TransformationTypes
$creadList :: ReadS [TransformationTypes]
readList :: ReadS [TransformationTypes]
$creadPrec :: ReadPrec TransformationTypes
readPrec :: ReadPrec TransformationTypes
$creadListPrec :: ReadPrec [TransformationTypes]
readListPrec :: ReadPrec [TransformationTypes]
Read,TransformationTypes -> TransformationTypes -> Bool
(TransformationTypes -> TransformationTypes -> Bool)
-> (TransformationTypes -> TransformationTypes -> Bool)
-> Eq TransformationTypes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TransformationTypes -> TransformationTypes -> Bool
== :: TransformationTypes -> TransformationTypes -> Bool
$c/= :: TransformationTypes -> TransformationTypes -> Bool
/= :: TransformationTypes -> TransformationTypes -> Bool
Eq,(forall x. TransformationTypes -> Rep TransformationTypes x)
-> (forall x. Rep TransformationTypes x -> TransformationTypes)
-> Generic TransformationTypes
forall x. Rep TransformationTypes x -> TransformationTypes
forall x. TransformationTypes -> Rep TransformationTypes x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TransformationTypes -> Rep TransformationTypes x
from :: forall x. TransformationTypes -> Rep TransformationTypes x
$cto :: forall x. Rep TransformationTypes x -> TransformationTypes
to :: forall x. Rep TransformationTypes x -> TransformationTypes
Generic)
                         deriving anyclass (Eq TransformationTypes
KnownNat (Cardinality TransformationTypes)
(Eq TransformationTypes,
 KnownNat (Cardinality TransformationTypes)) =>
(Finite (Cardinality TransformationTypes) -> TransformationTypes)
-> (TransformationTypes
    -> Finite (Cardinality TransformationTypes))
-> ((1 <= Cardinality TransformationTypes) => TransformationTypes)
-> ((1 <= Cardinality TransformationTypes) => TransformationTypes)
-> (TransformationTypes -> Maybe TransformationTypes)
-> (TransformationTypes -> Maybe TransformationTypes)
-> Finitary TransformationTypes
(1 <= Cardinality TransformationTypes) => TransformationTypes
Finite (Cardinality TransformationTypes) -> TransformationTypes
TransformationTypes -> Maybe TransformationTypes
TransformationTypes -> Finite (Cardinality TransformationTypes)
forall a.
(Eq a, KnownNat (Cardinality a)) =>
(Finite (Cardinality a) -> a)
-> (a -> Finite (Cardinality a))
-> ((1 <= Cardinality a) => a)
-> ((1 <= Cardinality a) => a)
-> (a -> Maybe a)
-> (a -> Maybe a)
-> Finitary a
$cfromFinite :: Finite (Cardinality TransformationTypes) -> TransformationTypes
fromFinite :: Finite (Cardinality TransformationTypes) -> TransformationTypes
$ctoFinite :: TransformationTypes -> Finite (Cardinality TransformationTypes)
toFinite :: TransformationTypes -> Finite (Cardinality TransformationTypes)
$cstart :: (1 <= Cardinality TransformationTypes) => TransformationTypes
start :: (1 <= Cardinality TransformationTypes) => TransformationTypes
$cend :: (1 <= Cardinality TransformationTypes) => TransformationTypes
end :: (1 <= Cardinality TransformationTypes) => TransformationTypes
$cprevious :: TransformationTypes -> Maybe TransformationTypes
previous :: TransformationTypes -> Maybe TransformationTypes
$cnext :: TransformationTypes -> Maybe TransformationTypes
next :: TransformationTypes -> Maybe TransformationTypes
Finitary)

--------------------------------------------------------------------------------
-- * Text Attributes

-- these Attributes are speicifc to IpeObjects representing TextLabels
-- and MiniPages. The same structure as for the `CommonAttributes'
-- applies here.

data HorizontalAlignment = AlignLeft | AlignHCenter | AlignRight
                         deriving (Int -> HorizontalAlignment -> ShowS
[HorizontalAlignment] -> ShowS
HorizontalAlignment -> String
(Int -> HorizontalAlignment -> ShowS)
-> (HorizontalAlignment -> String)
-> ([HorizontalAlignment] -> ShowS)
-> Show HorizontalAlignment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HorizontalAlignment -> ShowS
showsPrec :: Int -> HorizontalAlignment -> ShowS
$cshow :: HorizontalAlignment -> String
show :: HorizontalAlignment -> String
$cshowList :: [HorizontalAlignment] -> ShowS
showList :: [HorizontalAlignment] -> ShowS
Show,ReadPrec [HorizontalAlignment]
ReadPrec HorizontalAlignment
Int -> ReadS HorizontalAlignment
ReadS [HorizontalAlignment]
(Int -> ReadS HorizontalAlignment)
-> ReadS [HorizontalAlignment]
-> ReadPrec HorizontalAlignment
-> ReadPrec [HorizontalAlignment]
-> Read HorizontalAlignment
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS HorizontalAlignment
readsPrec :: Int -> ReadS HorizontalAlignment
$creadList :: ReadS [HorizontalAlignment]
readList :: ReadS [HorizontalAlignment]
$creadPrec :: ReadPrec HorizontalAlignment
readPrec :: ReadPrec HorizontalAlignment
$creadListPrec :: ReadPrec [HorizontalAlignment]
readListPrec :: ReadPrec [HorizontalAlignment]
Read,HorizontalAlignment -> HorizontalAlignment -> Bool
(HorizontalAlignment -> HorizontalAlignment -> Bool)
-> (HorizontalAlignment -> HorizontalAlignment -> Bool)
-> Eq HorizontalAlignment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HorizontalAlignment -> HorizontalAlignment -> Bool
== :: HorizontalAlignment -> HorizontalAlignment -> Bool
$c/= :: HorizontalAlignment -> HorizontalAlignment -> Bool
/= :: HorizontalAlignment -> HorizontalAlignment -> Bool
Eq,Eq HorizontalAlignment
Eq HorizontalAlignment =>
(HorizontalAlignment -> HorizontalAlignment -> Ordering)
-> (HorizontalAlignment -> HorizontalAlignment -> Bool)
-> (HorizontalAlignment -> HorizontalAlignment -> Bool)
-> (HorizontalAlignment -> HorizontalAlignment -> Bool)
-> (HorizontalAlignment -> HorizontalAlignment -> Bool)
-> (HorizontalAlignment
    -> HorizontalAlignment -> HorizontalAlignment)
-> (HorizontalAlignment
    -> HorizontalAlignment -> HorizontalAlignment)
-> Ord HorizontalAlignment
HorizontalAlignment -> HorizontalAlignment -> Bool
HorizontalAlignment -> HorizontalAlignment -> Ordering
HorizontalAlignment -> HorizontalAlignment -> HorizontalAlignment
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: HorizontalAlignment -> HorizontalAlignment -> Ordering
compare :: HorizontalAlignment -> HorizontalAlignment -> Ordering
$c< :: HorizontalAlignment -> HorizontalAlignment -> Bool
< :: HorizontalAlignment -> HorizontalAlignment -> Bool
$c<= :: HorizontalAlignment -> HorizontalAlignment -> Bool
<= :: HorizontalAlignment -> HorizontalAlignment -> Bool
$c> :: HorizontalAlignment -> HorizontalAlignment -> Bool
> :: HorizontalAlignment -> HorizontalAlignment -> Bool
$c>= :: HorizontalAlignment -> HorizontalAlignment -> Bool
>= :: HorizontalAlignment -> HorizontalAlignment -> Bool
$cmax :: HorizontalAlignment -> HorizontalAlignment -> HorizontalAlignment
max :: HorizontalAlignment -> HorizontalAlignment -> HorizontalAlignment
$cmin :: HorizontalAlignment -> HorizontalAlignment -> HorizontalAlignment
min :: HorizontalAlignment -> HorizontalAlignment -> HorizontalAlignment
Ord,(forall x. HorizontalAlignment -> Rep HorizontalAlignment x)
-> (forall x. Rep HorizontalAlignment x -> HorizontalAlignment)
-> Generic HorizontalAlignment
forall x. Rep HorizontalAlignment x -> HorizontalAlignment
forall x. HorizontalAlignment -> Rep HorizontalAlignment x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. HorizontalAlignment -> Rep HorizontalAlignment x
from :: forall x. HorizontalAlignment -> Rep HorizontalAlignment x
$cto :: forall x. Rep HorizontalAlignment x -> HorizontalAlignment
to :: forall x. Rep HorizontalAlignment x -> HorizontalAlignment
Generic)
                         deriving anyclass (Eq HorizontalAlignment
KnownNat (Cardinality HorizontalAlignment)
(Eq HorizontalAlignment,
 KnownNat (Cardinality HorizontalAlignment)) =>
(Finite (Cardinality HorizontalAlignment) -> HorizontalAlignment)
-> (HorizontalAlignment
    -> Finite (Cardinality HorizontalAlignment))
-> ((1 <= Cardinality HorizontalAlignment) => HorizontalAlignment)
-> ((1 <= Cardinality HorizontalAlignment) => HorizontalAlignment)
-> (HorizontalAlignment -> Maybe HorizontalAlignment)
-> (HorizontalAlignment -> Maybe HorizontalAlignment)
-> Finitary HorizontalAlignment
(1 <= Cardinality HorizontalAlignment) => HorizontalAlignment
Finite (Cardinality HorizontalAlignment) -> HorizontalAlignment
HorizontalAlignment -> Maybe HorizontalAlignment
HorizontalAlignment -> Finite (Cardinality HorizontalAlignment)
forall a.
(Eq a, KnownNat (Cardinality a)) =>
(Finite (Cardinality a) -> a)
-> (a -> Finite (Cardinality a))
-> ((1 <= Cardinality a) => a)
-> ((1 <= Cardinality a) => a)
-> (a -> Maybe a)
-> (a -> Maybe a)
-> Finitary a
$cfromFinite :: Finite (Cardinality HorizontalAlignment) -> HorizontalAlignment
fromFinite :: Finite (Cardinality HorizontalAlignment) -> HorizontalAlignment
$ctoFinite :: HorizontalAlignment -> Finite (Cardinality HorizontalAlignment)
toFinite :: HorizontalAlignment -> Finite (Cardinality HorizontalAlignment)
$cstart :: (1 <= Cardinality HorizontalAlignment) => HorizontalAlignment
start :: (1 <= Cardinality HorizontalAlignment) => HorizontalAlignment
$cend :: (1 <= Cardinality HorizontalAlignment) => HorizontalAlignment
end :: (1 <= Cardinality HorizontalAlignment) => HorizontalAlignment
$cprevious :: HorizontalAlignment -> Maybe HorizontalAlignment
previous :: HorizontalAlignment -> Maybe HorizontalAlignment
$cnext :: HorizontalAlignment -> Maybe HorizontalAlignment
next :: HorizontalAlignment -> Maybe HorizontalAlignment
Finitary)


data VerticalAlignment = AlignTop | AlignVCenter | AlignBottom | AlignBaseline
                       deriving (Int -> VerticalAlignment -> ShowS
[VerticalAlignment] -> ShowS
VerticalAlignment -> String
(Int -> VerticalAlignment -> ShowS)
-> (VerticalAlignment -> String)
-> ([VerticalAlignment] -> ShowS)
-> Show VerticalAlignment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VerticalAlignment -> ShowS
showsPrec :: Int -> VerticalAlignment -> ShowS
$cshow :: VerticalAlignment -> String
show :: VerticalAlignment -> String
$cshowList :: [VerticalAlignment] -> ShowS
showList :: [VerticalAlignment] -> ShowS
Show,ReadPrec [VerticalAlignment]
ReadPrec VerticalAlignment
Int -> ReadS VerticalAlignment
ReadS [VerticalAlignment]
(Int -> ReadS VerticalAlignment)
-> ReadS [VerticalAlignment]
-> ReadPrec VerticalAlignment
-> ReadPrec [VerticalAlignment]
-> Read VerticalAlignment
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS VerticalAlignment
readsPrec :: Int -> ReadS VerticalAlignment
$creadList :: ReadS [VerticalAlignment]
readList :: ReadS [VerticalAlignment]
$creadPrec :: ReadPrec VerticalAlignment
readPrec :: ReadPrec VerticalAlignment
$creadListPrec :: ReadPrec [VerticalAlignment]
readListPrec :: ReadPrec [VerticalAlignment]
Read,VerticalAlignment -> VerticalAlignment -> Bool
(VerticalAlignment -> VerticalAlignment -> Bool)
-> (VerticalAlignment -> VerticalAlignment -> Bool)
-> Eq VerticalAlignment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VerticalAlignment -> VerticalAlignment -> Bool
== :: VerticalAlignment -> VerticalAlignment -> Bool
$c/= :: VerticalAlignment -> VerticalAlignment -> Bool
/= :: VerticalAlignment -> VerticalAlignment -> Bool
Eq,Eq VerticalAlignment
Eq VerticalAlignment =>
(VerticalAlignment -> VerticalAlignment -> Ordering)
-> (VerticalAlignment -> VerticalAlignment -> Bool)
-> (VerticalAlignment -> VerticalAlignment -> Bool)
-> (VerticalAlignment -> VerticalAlignment -> Bool)
-> (VerticalAlignment -> VerticalAlignment -> Bool)
-> (VerticalAlignment -> VerticalAlignment -> VerticalAlignment)
-> (VerticalAlignment -> VerticalAlignment -> VerticalAlignment)
-> Ord VerticalAlignment
VerticalAlignment -> VerticalAlignment -> Bool
VerticalAlignment -> VerticalAlignment -> Ordering
VerticalAlignment -> VerticalAlignment -> VerticalAlignment
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VerticalAlignment -> VerticalAlignment -> Ordering
compare :: VerticalAlignment -> VerticalAlignment -> Ordering
$c< :: VerticalAlignment -> VerticalAlignment -> Bool
< :: VerticalAlignment -> VerticalAlignment -> Bool
$c<= :: VerticalAlignment -> VerticalAlignment -> Bool
<= :: VerticalAlignment -> VerticalAlignment -> Bool
$c> :: VerticalAlignment -> VerticalAlignment -> Bool
> :: VerticalAlignment -> VerticalAlignment -> Bool
$c>= :: VerticalAlignment -> VerticalAlignment -> Bool
>= :: VerticalAlignment -> VerticalAlignment -> Bool
$cmax :: VerticalAlignment -> VerticalAlignment -> VerticalAlignment
max :: VerticalAlignment -> VerticalAlignment -> VerticalAlignment
$cmin :: VerticalAlignment -> VerticalAlignment -> VerticalAlignment
min :: VerticalAlignment -> VerticalAlignment -> VerticalAlignment
Ord,(forall x. VerticalAlignment -> Rep VerticalAlignment x)
-> (forall x. Rep VerticalAlignment x -> VerticalAlignment)
-> Generic VerticalAlignment
forall x. Rep VerticalAlignment x -> VerticalAlignment
forall x. VerticalAlignment -> Rep VerticalAlignment x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. VerticalAlignment -> Rep VerticalAlignment x
from :: forall x. VerticalAlignment -> Rep VerticalAlignment x
$cto :: forall x. Rep VerticalAlignment x -> VerticalAlignment
to :: forall x. Rep VerticalAlignment x -> VerticalAlignment
Generic)
                       deriving anyclass (Eq VerticalAlignment
KnownNat (Cardinality VerticalAlignment)
(Eq VerticalAlignment, KnownNat (Cardinality VerticalAlignment)) =>
(Finite (Cardinality VerticalAlignment) -> VerticalAlignment)
-> (VerticalAlignment -> Finite (Cardinality VerticalAlignment))
-> ((1 <= Cardinality VerticalAlignment) => VerticalAlignment)
-> ((1 <= Cardinality VerticalAlignment) => VerticalAlignment)
-> (VerticalAlignment -> Maybe VerticalAlignment)
-> (VerticalAlignment -> Maybe VerticalAlignment)
-> Finitary VerticalAlignment
(1 <= Cardinality VerticalAlignment) => VerticalAlignment
Finite (Cardinality VerticalAlignment) -> VerticalAlignment
VerticalAlignment -> Maybe VerticalAlignment
VerticalAlignment -> Finite (Cardinality VerticalAlignment)
forall a.
(Eq a, KnownNat (Cardinality a)) =>
(Finite (Cardinality a) -> a)
-> (a -> Finite (Cardinality a))
-> ((1 <= Cardinality a) => a)
-> ((1 <= Cardinality a) => a)
-> (a -> Maybe a)
-> (a -> Maybe a)
-> Finitary a
$cfromFinite :: Finite (Cardinality VerticalAlignment) -> VerticalAlignment
fromFinite :: Finite (Cardinality VerticalAlignment) -> VerticalAlignment
$ctoFinite :: VerticalAlignment -> Finite (Cardinality VerticalAlignment)
toFinite :: VerticalAlignment -> Finite (Cardinality VerticalAlignment)
$cstart :: (1 <= Cardinality VerticalAlignment) => VerticalAlignment
start :: (1 <= Cardinality VerticalAlignment) => VerticalAlignment
$cend :: (1 <= Cardinality VerticalAlignment) => VerticalAlignment
end :: (1 <= Cardinality VerticalAlignment) => VerticalAlignment
$cprevious :: VerticalAlignment -> Maybe VerticalAlignment
previous :: VerticalAlignment -> Maybe VerticalAlignment
$cnext :: VerticalAlignment -> Maybe VerticalAlignment
next :: VerticalAlignment -> Maybe VerticalAlignment
Finitary)

-- | Should be a symbolic name.
type TeXStyle = Text

-- | size of text in points
newtype TextSizeUnit r = TextSizeUnit r
                       deriving stock (Int -> TextSizeUnit r -> ShowS
[TextSizeUnit r] -> ShowS
TextSizeUnit r -> String
(Int -> TextSizeUnit r -> ShowS)
-> (TextSizeUnit r -> String)
-> ([TextSizeUnit r] -> ShowS)
-> Show (TextSizeUnit r)
forall r. Show r => Int -> TextSizeUnit r -> ShowS
forall r. Show r => [TextSizeUnit r] -> ShowS
forall r. Show r => TextSizeUnit r -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall r. Show r => Int -> TextSizeUnit r -> ShowS
showsPrec :: Int -> TextSizeUnit r -> ShowS
$cshow :: forall r. Show r => TextSizeUnit r -> String
show :: TextSizeUnit r -> String
$cshowList :: forall r. Show r => [TextSizeUnit r] -> ShowS
showList :: [TextSizeUnit r] -> ShowS
Show,ReadPrec [TextSizeUnit r]
ReadPrec (TextSizeUnit r)
Int -> ReadS (TextSizeUnit r)
ReadS [TextSizeUnit r]
(Int -> ReadS (TextSizeUnit r))
-> ReadS [TextSizeUnit r]
-> ReadPrec (TextSizeUnit r)
-> ReadPrec [TextSizeUnit r]
-> Read (TextSizeUnit r)
forall r. Read r => ReadPrec [TextSizeUnit r]
forall r. Read r => ReadPrec (TextSizeUnit r)
forall r. Read r => Int -> ReadS (TextSizeUnit r)
forall r. Read r => ReadS [TextSizeUnit r]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall r. Read r => Int -> ReadS (TextSizeUnit r)
readsPrec :: Int -> ReadS (TextSizeUnit r)
$creadList :: forall r. Read r => ReadS [TextSizeUnit r]
readList :: ReadS [TextSizeUnit r]
$creadPrec :: forall r. Read r => ReadPrec (TextSizeUnit r)
readPrec :: ReadPrec (TextSizeUnit r)
$creadListPrec :: forall r. Read r => ReadPrec [TextSizeUnit r]
readListPrec :: ReadPrec [TextSizeUnit r]
Read,TextSizeUnit r -> TextSizeUnit r -> Bool
(TextSizeUnit r -> TextSizeUnit r -> Bool)
-> (TextSizeUnit r -> TextSizeUnit r -> Bool)
-> Eq (TextSizeUnit r)
forall r. Eq r => TextSizeUnit r -> TextSizeUnit r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall r. Eq r => TextSizeUnit r -> TextSizeUnit r -> Bool
== :: TextSizeUnit r -> TextSizeUnit r -> Bool
$c/= :: forall r. Eq r => TextSizeUnit r -> TextSizeUnit r -> Bool
/= :: TextSizeUnit r -> TextSizeUnit r -> Bool
Eq,Eq (TextSizeUnit r)
Eq (TextSizeUnit r) =>
(TextSizeUnit r -> TextSizeUnit r -> Ordering)
-> (TextSizeUnit r -> TextSizeUnit r -> Bool)
-> (TextSizeUnit r -> TextSizeUnit r -> Bool)
-> (TextSizeUnit r -> TextSizeUnit r -> Bool)
-> (TextSizeUnit r -> TextSizeUnit r -> Bool)
-> (TextSizeUnit r -> TextSizeUnit r -> TextSizeUnit r)
-> (TextSizeUnit r -> TextSizeUnit r -> TextSizeUnit r)
-> Ord (TextSizeUnit r)
TextSizeUnit r -> TextSizeUnit r -> Bool
TextSizeUnit r -> TextSizeUnit r -> Ordering
TextSizeUnit r -> TextSizeUnit r -> TextSizeUnit r
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall r. Ord r => Eq (TextSizeUnit r)
forall r. Ord r => TextSizeUnit r -> TextSizeUnit r -> Bool
forall r. Ord r => TextSizeUnit r -> TextSizeUnit r -> Ordering
forall r.
Ord r =>
TextSizeUnit r -> TextSizeUnit r -> TextSizeUnit r
$ccompare :: forall r. Ord r => TextSizeUnit r -> TextSizeUnit r -> Ordering
compare :: TextSizeUnit r -> TextSizeUnit r -> Ordering
$c< :: forall r. Ord r => TextSizeUnit r -> TextSizeUnit r -> Bool
< :: TextSizeUnit r -> TextSizeUnit r -> Bool
$c<= :: forall r. Ord r => TextSizeUnit r -> TextSizeUnit r -> Bool
<= :: TextSizeUnit r -> TextSizeUnit r -> Bool
$c> :: forall r. Ord r => TextSizeUnit r -> TextSizeUnit r -> Bool
> :: TextSizeUnit r -> TextSizeUnit r -> Bool
$c>= :: forall r. Ord r => TextSizeUnit r -> TextSizeUnit r -> Bool
>= :: TextSizeUnit r -> TextSizeUnit r -> Bool
$cmax :: forall r.
Ord r =>
TextSizeUnit r -> TextSizeUnit r -> TextSizeUnit r
max :: TextSizeUnit r -> TextSizeUnit r -> TextSizeUnit r
$cmin :: forall r.
Ord r =>
TextSizeUnit r -> TextSizeUnit r -> TextSizeUnit r
min :: TextSizeUnit r -> TextSizeUnit r -> TextSizeUnit r
Ord,(forall a b. (a -> b) -> TextSizeUnit a -> TextSizeUnit b)
-> (forall a b. a -> TextSizeUnit b -> TextSizeUnit a)
-> Functor TextSizeUnit
forall a b. a -> TextSizeUnit b -> TextSizeUnit a
forall a b. (a -> b) -> TextSizeUnit a -> TextSizeUnit b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> TextSizeUnit a -> TextSizeUnit b
fmap :: forall a b. (a -> b) -> TextSizeUnit a -> TextSizeUnit b
$c<$ :: forall a b. a -> TextSizeUnit b -> TextSizeUnit a
<$ :: forall a b. a -> TextSizeUnit b -> TextSizeUnit a
Functor,(forall m. Monoid m => TextSizeUnit m -> m)
-> (forall m a. Monoid m => (a -> m) -> TextSizeUnit a -> m)
-> (forall m a. Monoid m => (a -> m) -> TextSizeUnit a -> m)
-> (forall a b. (a -> b -> b) -> b -> TextSizeUnit a -> b)
-> (forall a b. (a -> b -> b) -> b -> TextSizeUnit a -> b)
-> (forall b a. (b -> a -> b) -> b -> TextSizeUnit a -> b)
-> (forall b a. (b -> a -> b) -> b -> TextSizeUnit a -> b)
-> (forall a. (a -> a -> a) -> TextSizeUnit a -> a)
-> (forall a. (a -> a -> a) -> TextSizeUnit a -> a)
-> (forall a. TextSizeUnit a -> [a])
-> (forall a. TextSizeUnit a -> Bool)
-> (forall a. TextSizeUnit a -> Int)
-> (forall a. Eq a => a -> TextSizeUnit a -> Bool)
-> (forall a. Ord a => TextSizeUnit a -> a)
-> (forall a. Ord a => TextSizeUnit a -> a)
-> (forall a. Num a => TextSizeUnit a -> a)
-> (forall a. Num a => TextSizeUnit a -> a)
-> Foldable TextSizeUnit
forall a. Eq a => a -> TextSizeUnit a -> Bool
forall a. Num a => TextSizeUnit a -> a
forall a. Ord a => TextSizeUnit a -> a
forall m. Monoid m => TextSizeUnit m -> m
forall a. TextSizeUnit a -> Bool
forall a. TextSizeUnit a -> Int
forall a. TextSizeUnit a -> [a]
forall a. (a -> a -> a) -> TextSizeUnit a -> a
forall m a. Monoid m => (a -> m) -> TextSizeUnit a -> m
forall b a. (b -> a -> b) -> b -> TextSizeUnit a -> b
forall a b. (a -> b -> b) -> b -> TextSizeUnit a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => TextSizeUnit m -> m
fold :: forall m. Monoid m => TextSizeUnit m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> TextSizeUnit a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> TextSizeUnit a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> TextSizeUnit a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> TextSizeUnit a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> TextSizeUnit a -> b
foldr :: forall a b. (a -> b -> b) -> b -> TextSizeUnit a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> TextSizeUnit a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> TextSizeUnit a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> TextSizeUnit a -> b
foldl :: forall b a. (b -> a -> b) -> b -> TextSizeUnit a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> TextSizeUnit a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> TextSizeUnit a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> TextSizeUnit a -> a
foldr1 :: forall a. (a -> a -> a) -> TextSizeUnit a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> TextSizeUnit a -> a
foldl1 :: forall a. (a -> a -> a) -> TextSizeUnit a -> a
$ctoList :: forall a. TextSizeUnit a -> [a]
toList :: forall a. TextSizeUnit a -> [a]
$cnull :: forall a. TextSizeUnit a -> Bool
null :: forall a. TextSizeUnit a -> Bool
$clength :: forall a. TextSizeUnit a -> Int
length :: forall a. TextSizeUnit a -> Int
$celem :: forall a. Eq a => a -> TextSizeUnit a -> Bool
elem :: forall a. Eq a => a -> TextSizeUnit a -> Bool
$cmaximum :: forall a. Ord a => TextSizeUnit a -> a
maximum :: forall a. Ord a => TextSizeUnit a -> a
$cminimum :: forall a. Ord a => TextSizeUnit a -> a
minimum :: forall a. Ord a => TextSizeUnit a -> a
$csum :: forall a. Num a => TextSizeUnit a -> a
sum :: forall a. Num a => TextSizeUnit a -> a
$cproduct :: forall a. Num a => TextSizeUnit a -> a
product :: forall a. Num a => TextSizeUnit a -> a
Foldable,Functor TextSizeUnit
Foldable TextSizeUnit
(Functor TextSizeUnit, Foldable TextSizeUnit) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> TextSizeUnit a -> f (TextSizeUnit b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    TextSizeUnit (f a) -> f (TextSizeUnit a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TextSizeUnit a -> m (TextSizeUnit b))
-> (forall (m :: * -> *) a.
    Monad m =>
    TextSizeUnit (m a) -> m (TextSizeUnit a))
-> Traversable TextSizeUnit
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
TextSizeUnit (m a) -> m (TextSizeUnit a)
forall (f :: * -> *) a.
Applicative f =>
TextSizeUnit (f a) -> f (TextSizeUnit a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TextSizeUnit a -> m (TextSizeUnit b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TextSizeUnit a -> f (TextSizeUnit b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TextSizeUnit a -> f (TextSizeUnit b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TextSizeUnit a -> f (TextSizeUnit b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
TextSizeUnit (f a) -> f (TextSizeUnit a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
TextSizeUnit (f a) -> f (TextSizeUnit a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TextSizeUnit a -> m (TextSizeUnit b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TextSizeUnit a -> m (TextSizeUnit b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
TextSizeUnit (m a) -> m (TextSizeUnit a)
sequence :: forall (m :: * -> *) a.
Monad m =>
TextSizeUnit (m a) -> m (TextSizeUnit a)
Traversable,(forall x. TextSizeUnit r -> Rep (TextSizeUnit r) x)
-> (forall x. Rep (TextSizeUnit r) x -> TextSizeUnit r)
-> Generic (TextSizeUnit r)
forall x. Rep (TextSizeUnit r) x -> TextSizeUnit r
forall x. TextSizeUnit r -> Rep (TextSizeUnit r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (TextSizeUnit r) x -> TextSizeUnit r
forall r x. TextSizeUnit r -> Rep (TextSizeUnit r) x
$cfrom :: forall r x. TextSizeUnit r -> Rep (TextSizeUnit r) x
from :: forall x. TextSizeUnit r -> Rep (TextSizeUnit r) x
$cto :: forall r x. Rep (TextSizeUnit r) x -> TextSizeUnit r
to :: forall x. Rep (TextSizeUnit r) x -> TextSizeUnit r
Generic)

--------------------------------------------------------------------------------
-- * Symbol Attributes

-- | The optional Attributes for a symbol
-- data SymbolAttributeUniverse = SymbolStroke | SymbolFill | SymbolPen | Size
--                              deriving (Show,Eq)

-- | Size
newtype IpeSize  r = IpeSize  (IpeValue r)
                   deriving (Int -> IpeSize r -> ShowS
[IpeSize r] -> ShowS
IpeSize r -> String
(Int -> IpeSize r -> ShowS)
-> (IpeSize r -> String)
-> ([IpeSize r] -> ShowS)
-> Show (IpeSize r)
forall r. Show r => Int -> IpeSize r -> ShowS
forall r. Show r => [IpeSize r] -> ShowS
forall r. Show r => IpeSize r -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall r. Show r => Int -> IpeSize r -> ShowS
showsPrec :: Int -> IpeSize r -> ShowS
$cshow :: forall r. Show r => IpeSize r -> String
show :: IpeSize r -> String
$cshowList :: forall r. Show r => [IpeSize r] -> ShowS
showList :: [IpeSize r] -> ShowS
Show,IpeSize r -> IpeSize r -> Bool
(IpeSize r -> IpeSize r -> Bool)
-> (IpeSize r -> IpeSize r -> Bool) -> Eq (IpeSize r)
forall r. Eq r => IpeSize r -> IpeSize r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall r. Eq r => IpeSize r -> IpeSize r -> Bool
== :: IpeSize r -> IpeSize r -> Bool
$c/= :: forall r. Eq r => IpeSize r -> IpeSize r -> Bool
/= :: IpeSize r -> IpeSize r -> Bool
Eq,Eq (IpeSize r)
Eq (IpeSize r) =>
(IpeSize r -> IpeSize r -> Ordering)
-> (IpeSize r -> IpeSize r -> Bool)
-> (IpeSize r -> IpeSize r -> Bool)
-> (IpeSize r -> IpeSize r -> Bool)
-> (IpeSize r -> IpeSize r -> Bool)
-> (IpeSize r -> IpeSize r -> IpeSize r)
-> (IpeSize r -> IpeSize r -> IpeSize r)
-> Ord (IpeSize r)
IpeSize r -> IpeSize r -> Bool
IpeSize r -> IpeSize r -> Ordering
IpeSize r -> IpeSize r -> IpeSize r
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall r. Ord r => Eq (IpeSize r)
forall r. Ord r => IpeSize r -> IpeSize r -> Bool
forall r. Ord r => IpeSize r -> IpeSize r -> Ordering
forall r. Ord r => IpeSize r -> IpeSize r -> IpeSize r
$ccompare :: forall r. Ord r => IpeSize r -> IpeSize r -> Ordering
compare :: IpeSize r -> IpeSize r -> Ordering
$c< :: forall r. Ord r => IpeSize r -> IpeSize r -> Bool
< :: IpeSize r -> IpeSize r -> Bool
$c<= :: forall r. Ord r => IpeSize r -> IpeSize r -> Bool
<= :: IpeSize r -> IpeSize r -> Bool
$c> :: forall r. Ord r => IpeSize r -> IpeSize r -> Bool
> :: IpeSize r -> IpeSize r -> Bool
$c>= :: forall r. Ord r => IpeSize r -> IpeSize r -> Bool
>= :: IpeSize r -> IpeSize r -> Bool
$cmax :: forall r. Ord r => IpeSize r -> IpeSize r -> IpeSize r
max :: IpeSize r -> IpeSize r -> IpeSize r
$cmin :: forall r. Ord r => IpeSize r -> IpeSize r -> IpeSize r
min :: IpeSize r -> IpeSize r -> IpeSize r
Ord,(forall a b. (a -> b) -> IpeSize a -> IpeSize b)
-> (forall a b. a -> IpeSize b -> IpeSize a) -> Functor IpeSize
forall a b. a -> IpeSize b -> IpeSize a
forall a b. (a -> b) -> IpeSize a -> IpeSize b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> IpeSize a -> IpeSize b
fmap :: forall a b. (a -> b) -> IpeSize a -> IpeSize b
$c<$ :: forall a b. a -> IpeSize b -> IpeSize a
<$ :: forall a b. a -> IpeSize b -> IpeSize a
Functor,(forall m. Monoid m => IpeSize m -> m)
-> (forall m a. Monoid m => (a -> m) -> IpeSize a -> m)
-> (forall m a. Monoid m => (a -> m) -> IpeSize a -> m)
-> (forall a b. (a -> b -> b) -> b -> IpeSize a -> b)
-> (forall a b. (a -> b -> b) -> b -> IpeSize a -> b)
-> (forall b a. (b -> a -> b) -> b -> IpeSize a -> b)
-> (forall b a. (b -> a -> b) -> b -> IpeSize a -> b)
-> (forall a. (a -> a -> a) -> IpeSize a -> a)
-> (forall a. (a -> a -> a) -> IpeSize a -> a)
-> (forall a. IpeSize a -> [a])
-> (forall a. IpeSize a -> Bool)
-> (forall a. IpeSize a -> Int)
-> (forall a. Eq a => a -> IpeSize a -> Bool)
-> (forall a. Ord a => IpeSize a -> a)
-> (forall a. Ord a => IpeSize a -> a)
-> (forall a. Num a => IpeSize a -> a)
-> (forall a. Num a => IpeSize a -> a)
-> Foldable IpeSize
forall a. Eq a => a -> IpeSize a -> Bool
forall a. Num a => IpeSize a -> a
forall a. Ord a => IpeSize a -> a
forall m. Monoid m => IpeSize m -> m
forall a. IpeSize a -> Bool
forall a. IpeSize a -> Int
forall a. IpeSize a -> [a]
forall a. (a -> a -> a) -> IpeSize a -> a
forall m a. Monoid m => (a -> m) -> IpeSize a -> m
forall b a. (b -> a -> b) -> b -> IpeSize a -> b
forall a b. (a -> b -> b) -> b -> IpeSize a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => IpeSize m -> m
fold :: forall m. Monoid m => IpeSize m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> IpeSize a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> IpeSize a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> IpeSize a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> IpeSize a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> IpeSize a -> b
foldr :: forall a b. (a -> b -> b) -> b -> IpeSize a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> IpeSize a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> IpeSize a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> IpeSize a -> b
foldl :: forall b a. (b -> a -> b) -> b -> IpeSize a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> IpeSize a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> IpeSize a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> IpeSize a -> a
foldr1 :: forall a. (a -> a -> a) -> IpeSize a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> IpeSize a -> a
foldl1 :: forall a. (a -> a -> a) -> IpeSize a -> a
$ctoList :: forall a. IpeSize a -> [a]
toList :: forall a. IpeSize a -> [a]
$cnull :: forall a. IpeSize a -> Bool
null :: forall a. IpeSize a -> Bool
$clength :: forall a. IpeSize a -> Int
length :: forall a. IpeSize a -> Int
$celem :: forall a. Eq a => a -> IpeSize a -> Bool
elem :: forall a. Eq a => a -> IpeSize a -> Bool
$cmaximum :: forall a. Ord a => IpeSize a -> a
maximum :: forall a. Ord a => IpeSize a -> a
$cminimum :: forall a. Ord a => IpeSize a -> a
minimum :: forall a. Ord a => IpeSize a -> a
$csum :: forall a. Num a => IpeSize a -> a
sum :: forall a. Num a => IpeSize a -> a
$cproduct :: forall a. Num a => IpeSize a -> a
product :: forall a. Num a => IpeSize a -> a
Foldable,Functor IpeSize
Foldable IpeSize
(Functor IpeSize, Foldable IpeSize) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> IpeSize a -> f (IpeSize b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    IpeSize (f a) -> f (IpeSize a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IpeSize a -> m (IpeSize b))
-> (forall (m :: * -> *) a.
    Monad m =>
    IpeSize (m a) -> m (IpeSize a))
-> Traversable IpeSize
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => IpeSize (m a) -> m (IpeSize a)
forall (f :: * -> *) a.
Applicative f =>
IpeSize (f a) -> f (IpeSize a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IpeSize a -> m (IpeSize b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IpeSize a -> f (IpeSize b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IpeSize a -> f (IpeSize b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IpeSize a -> f (IpeSize b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
IpeSize (f a) -> f (IpeSize a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
IpeSize (f a) -> f (IpeSize a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IpeSize a -> m (IpeSize b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IpeSize a -> m (IpeSize b)
$csequence :: forall (m :: * -> *) a. Monad m => IpeSize (m a) -> m (IpeSize a)
sequence :: forall (m :: * -> *) a. Monad m => IpeSize (m a) -> m (IpeSize a)
Traversable,(forall x. IpeSize r -> Rep (IpeSize r) x)
-> (forall x. Rep (IpeSize r) x -> IpeSize r)
-> Generic (IpeSize r)
forall x. Rep (IpeSize r) x -> IpeSize r
forall x. IpeSize r -> Rep (IpeSize r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (IpeSize r) x -> IpeSize r
forall r x. IpeSize r -> Rep (IpeSize r) x
$cfrom :: forall r x. IpeSize r -> Rep (IpeSize r) x
from :: forall x. IpeSize r -> Rep (IpeSize r) x
$cto :: forall r x. Rep (IpeSize r) x -> IpeSize r
to :: forall x. Rep (IpeSize r) x -> IpeSize r
Generic)
-- | Pen/Thickness
newtype IpePen   r = IpePen   (IpeValue r)
                   deriving (Int -> IpePen r -> ShowS
[IpePen r] -> ShowS
IpePen r -> String
(Int -> IpePen r -> ShowS)
-> (IpePen r -> String) -> ([IpePen r] -> ShowS) -> Show (IpePen r)
forall r. Show r => Int -> IpePen r -> ShowS
forall r. Show r => [IpePen r] -> ShowS
forall r. Show r => IpePen r -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall r. Show r => Int -> IpePen r -> ShowS
showsPrec :: Int -> IpePen r -> ShowS
$cshow :: forall r. Show r => IpePen r -> String
show :: IpePen r -> String
$cshowList :: forall r. Show r => [IpePen r] -> ShowS
showList :: [IpePen r] -> ShowS
Show,IpePen r -> IpePen r -> Bool
(IpePen r -> IpePen r -> Bool)
-> (IpePen r -> IpePen r -> Bool) -> Eq (IpePen r)
forall r. Eq r => IpePen r -> IpePen r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall r. Eq r => IpePen r -> IpePen r -> Bool
== :: IpePen r -> IpePen r -> Bool
$c/= :: forall r. Eq r => IpePen r -> IpePen r -> Bool
/= :: IpePen r -> IpePen r -> Bool
Eq,Eq (IpePen r)
Eq (IpePen r) =>
(IpePen r -> IpePen r -> Ordering)
-> (IpePen r -> IpePen r -> Bool)
-> (IpePen r -> IpePen r -> Bool)
-> (IpePen r -> IpePen r -> Bool)
-> (IpePen r -> IpePen r -> Bool)
-> (IpePen r -> IpePen r -> IpePen r)
-> (IpePen r -> IpePen r -> IpePen r)
-> Ord (IpePen r)
IpePen r -> IpePen r -> Bool
IpePen r -> IpePen r -> Ordering
IpePen r -> IpePen r -> IpePen r
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall r. Ord r => Eq (IpePen r)
forall r. Ord r => IpePen r -> IpePen r -> Bool
forall r. Ord r => IpePen r -> IpePen r -> Ordering
forall r. Ord r => IpePen r -> IpePen r -> IpePen r
$ccompare :: forall r. Ord r => IpePen r -> IpePen r -> Ordering
compare :: IpePen r -> IpePen r -> Ordering
$c< :: forall r. Ord r => IpePen r -> IpePen r -> Bool
< :: IpePen r -> IpePen r -> Bool
$c<= :: forall r. Ord r => IpePen r -> IpePen r -> Bool
<= :: IpePen r -> IpePen r -> Bool
$c> :: forall r. Ord r => IpePen r -> IpePen r -> Bool
> :: IpePen r -> IpePen r -> Bool
$c>= :: forall r. Ord r => IpePen r -> IpePen r -> Bool
>= :: IpePen r -> IpePen r -> Bool
$cmax :: forall r. Ord r => IpePen r -> IpePen r -> IpePen r
max :: IpePen r -> IpePen r -> IpePen r
$cmin :: forall r. Ord r => IpePen r -> IpePen r -> IpePen r
min :: IpePen r -> IpePen r -> IpePen r
Ord,(forall a b. (a -> b) -> IpePen a -> IpePen b)
-> (forall a b. a -> IpePen b -> IpePen a) -> Functor IpePen
forall a b. a -> IpePen b -> IpePen a
forall a b. (a -> b) -> IpePen a -> IpePen b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> IpePen a -> IpePen b
fmap :: forall a b. (a -> b) -> IpePen a -> IpePen b
$c<$ :: forall a b. a -> IpePen b -> IpePen a
<$ :: forall a b. a -> IpePen b -> IpePen a
Functor,(forall m. Monoid m => IpePen m -> m)
-> (forall m a. Monoid m => (a -> m) -> IpePen a -> m)
-> (forall m a. Monoid m => (a -> m) -> IpePen a -> m)
-> (forall a b. (a -> b -> b) -> b -> IpePen a -> b)
-> (forall a b. (a -> b -> b) -> b -> IpePen a -> b)
-> (forall b a. (b -> a -> b) -> b -> IpePen a -> b)
-> (forall b a. (b -> a -> b) -> b -> IpePen a -> b)
-> (forall a. (a -> a -> a) -> IpePen a -> a)
-> (forall a. (a -> a -> a) -> IpePen a -> a)
-> (forall a. IpePen a -> [a])
-> (forall a. IpePen a -> Bool)
-> (forall a. IpePen a -> Int)
-> (forall a. Eq a => a -> IpePen a -> Bool)
-> (forall a. Ord a => IpePen a -> a)
-> (forall a. Ord a => IpePen a -> a)
-> (forall a. Num a => IpePen a -> a)
-> (forall a. Num a => IpePen a -> a)
-> Foldable IpePen
forall a. Eq a => a -> IpePen a -> Bool
forall a. Num a => IpePen a -> a
forall a. Ord a => IpePen a -> a
forall m. Monoid m => IpePen m -> m
forall a. IpePen a -> Bool
forall a. IpePen a -> Int
forall a. IpePen a -> [a]
forall a. (a -> a -> a) -> IpePen a -> a
forall m a. Monoid m => (a -> m) -> IpePen a -> m
forall b a. (b -> a -> b) -> b -> IpePen a -> b
forall a b. (a -> b -> b) -> b -> IpePen a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => IpePen m -> m
fold :: forall m. Monoid m => IpePen m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> IpePen a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> IpePen a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> IpePen a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> IpePen a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> IpePen a -> b
foldr :: forall a b. (a -> b -> b) -> b -> IpePen a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> IpePen a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> IpePen a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> IpePen a -> b
foldl :: forall b a. (b -> a -> b) -> b -> IpePen a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> IpePen a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> IpePen a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> IpePen a -> a
foldr1 :: forall a. (a -> a -> a) -> IpePen a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> IpePen a -> a
foldl1 :: forall a. (a -> a -> a) -> IpePen a -> a
$ctoList :: forall a. IpePen a -> [a]
toList :: forall a. IpePen a -> [a]
$cnull :: forall a. IpePen a -> Bool
null :: forall a. IpePen a -> Bool
$clength :: forall a. IpePen a -> Int
length :: forall a. IpePen a -> Int
$celem :: forall a. Eq a => a -> IpePen a -> Bool
elem :: forall a. Eq a => a -> IpePen a -> Bool
$cmaximum :: forall a. Ord a => IpePen a -> a
maximum :: forall a. Ord a => IpePen a -> a
$cminimum :: forall a. Ord a => IpePen a -> a
minimum :: forall a. Ord a => IpePen a -> a
$csum :: forall a. Num a => IpePen a -> a
sum :: forall a. Num a => IpePen a -> a
$cproduct :: forall a. Num a => IpePen a -> a
product :: forall a. Num a => IpePen a -> a
Foldable,Functor IpePen
Foldable IpePen
(Functor IpePen, Foldable IpePen) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> IpePen a -> f (IpePen b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    IpePen (f a) -> f (IpePen a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IpePen a -> m (IpePen b))
-> (forall (m :: * -> *) a.
    Monad m =>
    IpePen (m a) -> m (IpePen a))
-> Traversable IpePen
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => IpePen (m a) -> m (IpePen a)
forall (f :: * -> *) a.
Applicative f =>
IpePen (f a) -> f (IpePen a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IpePen a -> m (IpePen b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IpePen a -> f (IpePen b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IpePen a -> f (IpePen b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IpePen a -> f (IpePen b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
IpePen (f a) -> f (IpePen a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
IpePen (f a) -> f (IpePen a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IpePen a -> m (IpePen b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IpePen a -> m (IpePen b)
$csequence :: forall (m :: * -> *) a. Monad m => IpePen (m a) -> m (IpePen a)
sequence :: forall (m :: * -> *) a. Monad m => IpePen (m a) -> m (IpePen a)
Traversable,(forall x. IpePen r -> Rep (IpePen r) x)
-> (forall x. Rep (IpePen r) x -> IpePen r) -> Generic (IpePen r)
forall x. Rep (IpePen r) x -> IpePen r
forall x. IpePen r -> Rep (IpePen r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (IpePen r) x -> IpePen r
forall r x. IpePen r -> Rep (IpePen r) x
$cfrom :: forall r x. IpePen r -> Rep (IpePen r) x
from :: forall x. IpePen r -> Rep (IpePen r) x
$cto :: forall r x. Rep (IpePen r) x -> IpePen r
to :: forall x. Rep (IpePen r) x -> IpePen r
Generic)

-------------------------------------------------------------------------------
-- * Path Attributes

-- | Possible values for Dash
data IpeDash r = DashNamed Text
               | DashPattern [r] r
               deriving (Int -> IpeDash r -> ShowS
[IpeDash r] -> ShowS
IpeDash r -> String
(Int -> IpeDash r -> ShowS)
-> (IpeDash r -> String)
-> ([IpeDash r] -> ShowS)
-> Show (IpeDash r)
forall r. Show r => Int -> IpeDash r -> ShowS
forall r. Show r => [IpeDash r] -> ShowS
forall r. Show r => IpeDash r -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall r. Show r => Int -> IpeDash r -> ShowS
showsPrec :: Int -> IpeDash r -> ShowS
$cshow :: forall r. Show r => IpeDash r -> String
show :: IpeDash r -> String
$cshowList :: forall r. Show r => [IpeDash r] -> ShowS
showList :: [IpeDash r] -> ShowS
Show,IpeDash r -> IpeDash r -> Bool
(IpeDash r -> IpeDash r -> Bool)
-> (IpeDash r -> IpeDash r -> Bool) -> Eq (IpeDash r)
forall r. Eq r => IpeDash r -> IpeDash r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall r. Eq r => IpeDash r -> IpeDash r -> Bool
== :: IpeDash r -> IpeDash r -> Bool
$c/= :: forall r. Eq r => IpeDash r -> IpeDash r -> Bool
/= :: IpeDash r -> IpeDash r -> Bool
Eq,(forall a b. (a -> b) -> IpeDash a -> IpeDash b)
-> (forall a b. a -> IpeDash b -> IpeDash a) -> Functor IpeDash
forall a b. a -> IpeDash b -> IpeDash a
forall a b. (a -> b) -> IpeDash a -> IpeDash b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> IpeDash a -> IpeDash b
fmap :: forall a b. (a -> b) -> IpeDash a -> IpeDash b
$c<$ :: forall a b. a -> IpeDash b -> IpeDash a
<$ :: forall a b. a -> IpeDash b -> IpeDash a
Functor,(forall m. Monoid m => IpeDash m -> m)
-> (forall m a. Monoid m => (a -> m) -> IpeDash a -> m)
-> (forall m a. Monoid m => (a -> m) -> IpeDash a -> m)
-> (forall a b. (a -> b -> b) -> b -> IpeDash a -> b)
-> (forall a b. (a -> b -> b) -> b -> IpeDash a -> b)
-> (forall b a. (b -> a -> b) -> b -> IpeDash a -> b)
-> (forall b a. (b -> a -> b) -> b -> IpeDash a -> b)
-> (forall a. (a -> a -> a) -> IpeDash a -> a)
-> (forall a. (a -> a -> a) -> IpeDash a -> a)
-> (forall a. IpeDash a -> [a])
-> (forall a. IpeDash a -> Bool)
-> (forall a. IpeDash a -> Int)
-> (forall a. Eq a => a -> IpeDash a -> Bool)
-> (forall a. Ord a => IpeDash a -> a)
-> (forall a. Ord a => IpeDash a -> a)
-> (forall a. Num a => IpeDash a -> a)
-> (forall a. Num a => IpeDash a -> a)
-> Foldable IpeDash
forall a. Eq a => a -> IpeDash a -> Bool
forall a. Num a => IpeDash a -> a
forall a. Ord a => IpeDash a -> a
forall m. Monoid m => IpeDash m -> m
forall a. IpeDash a -> Bool
forall a. IpeDash a -> Int
forall a. IpeDash a -> [a]
forall a. (a -> a -> a) -> IpeDash a -> a
forall m a. Monoid m => (a -> m) -> IpeDash a -> m
forall b a. (b -> a -> b) -> b -> IpeDash a -> b
forall a b. (a -> b -> b) -> b -> IpeDash a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => IpeDash m -> m
fold :: forall m. Monoid m => IpeDash m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> IpeDash a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> IpeDash a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> IpeDash a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> IpeDash a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> IpeDash a -> b
foldr :: forall a b. (a -> b -> b) -> b -> IpeDash a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> IpeDash a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> IpeDash a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> IpeDash a -> b
foldl :: forall b a. (b -> a -> b) -> b -> IpeDash a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> IpeDash a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> IpeDash a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> IpeDash a -> a
foldr1 :: forall a. (a -> a -> a) -> IpeDash a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> IpeDash a -> a
foldl1 :: forall a. (a -> a -> a) -> IpeDash a -> a
$ctoList :: forall a. IpeDash a -> [a]
toList :: forall a. IpeDash a -> [a]
$cnull :: forall a. IpeDash a -> Bool
null :: forall a. IpeDash a -> Bool
$clength :: forall a. IpeDash a -> Int
length :: forall a. IpeDash a -> Int
$celem :: forall a. Eq a => a -> IpeDash a -> Bool
elem :: forall a. Eq a => a -> IpeDash a -> Bool
$cmaximum :: forall a. Ord a => IpeDash a -> a
maximum :: forall a. Ord a => IpeDash a -> a
$cminimum :: forall a. Ord a => IpeDash a -> a
minimum :: forall a. Ord a => IpeDash a -> a
$csum :: forall a. Num a => IpeDash a -> a
sum :: forall a. Num a => IpeDash a -> a
$cproduct :: forall a. Num a => IpeDash a -> a
product :: forall a. Num a => IpeDash a -> a
Foldable,Functor IpeDash
Foldable IpeDash
(Functor IpeDash, Foldable IpeDash) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> IpeDash a -> f (IpeDash b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    IpeDash (f a) -> f (IpeDash a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IpeDash a -> m (IpeDash b))
-> (forall (m :: * -> *) a.
    Monad m =>
    IpeDash (m a) -> m (IpeDash a))
-> Traversable IpeDash
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => IpeDash (m a) -> m (IpeDash a)
forall (f :: * -> *) a.
Applicative f =>
IpeDash (f a) -> f (IpeDash a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IpeDash a -> m (IpeDash b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IpeDash a -> f (IpeDash b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IpeDash a -> f (IpeDash b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IpeDash a -> f (IpeDash b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
IpeDash (f a) -> f (IpeDash a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
IpeDash (f a) -> f (IpeDash a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IpeDash a -> m (IpeDash b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IpeDash a -> m (IpeDash b)
$csequence :: forall (m :: * -> *) a. Monad m => IpeDash (m a) -> m (IpeDash a)
sequence :: forall (m :: * -> *) a. Monad m => IpeDash (m a) -> m (IpeDash a)
Traversable,(forall x. IpeDash r -> Rep (IpeDash r) x)
-> (forall x. Rep (IpeDash r) x -> IpeDash r)
-> Generic (IpeDash r)
forall x. Rep (IpeDash r) x -> IpeDash r
forall x. IpeDash r -> Rep (IpeDash r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (IpeDash r) x -> IpeDash r
forall r x. IpeDash r -> Rep (IpeDash r) x
$cfrom :: forall r x. IpeDash r -> Rep (IpeDash r) x
from :: forall x. IpeDash r -> Rep (IpeDash r) x
$cto :: forall r x. Rep (IpeDash r) x -> IpeDash r
to :: forall x. Rep (IpeDash r) x -> IpeDash r
Generic)

-- | Allowed Fill types
data FillType = Wind | EOFill
              deriving (Int -> FillType -> ShowS
[FillType] -> ShowS
FillType -> String
(Int -> FillType -> ShowS)
-> (FillType -> String) -> ([FillType] -> ShowS) -> Show FillType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FillType -> ShowS
showsPrec :: Int -> FillType -> ShowS
$cshow :: FillType -> String
show :: FillType -> String
$cshowList :: [FillType] -> ShowS
showList :: [FillType] -> ShowS
Show,ReadPrec [FillType]
ReadPrec FillType
Int -> ReadS FillType
ReadS [FillType]
(Int -> ReadS FillType)
-> ReadS [FillType]
-> ReadPrec FillType
-> ReadPrec [FillType]
-> Read FillType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FillType
readsPrec :: Int -> ReadS FillType
$creadList :: ReadS [FillType]
readList :: ReadS [FillType]
$creadPrec :: ReadPrec FillType
readPrec :: ReadPrec FillType
$creadListPrec :: ReadPrec [FillType]
readListPrec :: ReadPrec [FillType]
Read,FillType -> FillType -> Bool
(FillType -> FillType -> Bool)
-> (FillType -> FillType -> Bool) -> Eq FillType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FillType -> FillType -> Bool
== :: FillType -> FillType -> Bool
$c/= :: FillType -> FillType -> Bool
/= :: FillType -> FillType -> Bool
Eq,(forall x. FillType -> Rep FillType x)
-> (forall x. Rep FillType x -> FillType) -> Generic FillType
forall x. Rep FillType x -> FillType
forall x. FillType -> Rep FillType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FillType -> Rep FillType x
from :: forall x. FillType -> Rep FillType x
$cto :: forall x. Rep FillType x -> FillType
to :: forall x. Rep FillType x -> FillType
Generic)
              deriving anyclass (Eq FillType
KnownNat (Cardinality FillType)
(Eq FillType, KnownNat (Cardinality FillType)) =>
(Finite (Cardinality FillType) -> FillType)
-> (FillType -> Finite (Cardinality FillType))
-> ((1 <= Cardinality FillType) => FillType)
-> ((1 <= Cardinality FillType) => FillType)
-> (FillType -> Maybe FillType)
-> (FillType -> Maybe FillType)
-> Finitary FillType
(1 <= Cardinality FillType) => FillType
Finite (Cardinality FillType) -> FillType
FillType -> Maybe FillType
FillType -> Finite (Cardinality FillType)
forall a.
(Eq a, KnownNat (Cardinality a)) =>
(Finite (Cardinality a) -> a)
-> (a -> Finite (Cardinality a))
-> ((1 <= Cardinality a) => a)
-> ((1 <= Cardinality a) => a)
-> (a -> Maybe a)
-> (a -> Maybe a)
-> Finitary a
$cfromFinite :: Finite (Cardinality FillType) -> FillType
fromFinite :: Finite (Cardinality FillType) -> FillType
$ctoFinite :: FillType -> Finite (Cardinality FillType)
toFinite :: FillType -> Finite (Cardinality FillType)
$cstart :: (1 <= Cardinality FillType) => FillType
start :: (1 <= Cardinality FillType) => FillType
$cend :: (1 <= Cardinality FillType) => FillType
end :: (1 <= Cardinality FillType) => FillType
$cprevious :: FillType -> Maybe FillType
previous :: FillType -> Maybe FillType
$cnext :: FillType -> Maybe FillType
next :: FillType -> Maybe FillType
Finitary)

-- | IpeOpacity, IpeTyling, and IpeGradient are all symbolic values
type IpeOpacity  = Text
type IpeTiling   = Text
type IpeGradient = Text


-- | A type Representing possible LineJoin values
data LineJoin = Miter | Round | Bevel
  deriving (Int -> LineJoin -> ShowS
[LineJoin] -> ShowS
LineJoin -> String
(Int -> LineJoin -> ShowS)
-> (LineJoin -> String) -> ([LineJoin] -> ShowS) -> Show LineJoin
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LineJoin -> ShowS
showsPrec :: Int -> LineJoin -> ShowS
$cshow :: LineJoin -> String
show :: LineJoin -> String
$cshowList :: [LineJoin] -> ShowS
showList :: [LineJoin] -> ShowS
Show,ReadPrec [LineJoin]
ReadPrec LineJoin
Int -> ReadS LineJoin
ReadS [LineJoin]
(Int -> ReadS LineJoin)
-> ReadS [LineJoin]
-> ReadPrec LineJoin
-> ReadPrec [LineJoin]
-> Read LineJoin
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LineJoin
readsPrec :: Int -> ReadS LineJoin
$creadList :: ReadS [LineJoin]
readList :: ReadS [LineJoin]
$creadPrec :: ReadPrec LineJoin
readPrec :: ReadPrec LineJoin
$creadListPrec :: ReadPrec [LineJoin]
readListPrec :: ReadPrec [LineJoin]
Read,LineJoin -> LineJoin -> Bool
(LineJoin -> LineJoin -> Bool)
-> (LineJoin -> LineJoin -> Bool) -> Eq LineJoin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LineJoin -> LineJoin -> Bool
== :: LineJoin -> LineJoin -> Bool
$c/= :: LineJoin -> LineJoin -> Bool
/= :: LineJoin -> LineJoin -> Bool
Eq,(forall x. LineJoin -> Rep LineJoin x)
-> (forall x. Rep LineJoin x -> LineJoin) -> Generic LineJoin
forall x. Rep LineJoin x -> LineJoin
forall x. LineJoin -> Rep LineJoin x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LineJoin -> Rep LineJoin x
from :: forall x. LineJoin -> Rep LineJoin x
$cto :: forall x. Rep LineJoin x -> LineJoin
to :: forall x. Rep LineJoin x -> LineJoin
Generic)
  deriving anyclass (Eq LineJoin
KnownNat (Cardinality LineJoin)
(Eq LineJoin, KnownNat (Cardinality LineJoin)) =>
(Finite (Cardinality LineJoin) -> LineJoin)
-> (LineJoin -> Finite (Cardinality LineJoin))
-> ((1 <= Cardinality LineJoin) => LineJoin)
-> ((1 <= Cardinality LineJoin) => LineJoin)
-> (LineJoin -> Maybe LineJoin)
-> (LineJoin -> Maybe LineJoin)
-> Finitary LineJoin
(1 <= Cardinality LineJoin) => LineJoin
Finite (Cardinality LineJoin) -> LineJoin
LineJoin -> Maybe LineJoin
LineJoin -> Finite (Cardinality LineJoin)
forall a.
(Eq a, KnownNat (Cardinality a)) =>
(Finite (Cardinality a) -> a)
-> (a -> Finite (Cardinality a))
-> ((1 <= Cardinality a) => a)
-> ((1 <= Cardinality a) => a)
-> (a -> Maybe a)
-> (a -> Maybe a)
-> Finitary a
$cfromFinite :: Finite (Cardinality LineJoin) -> LineJoin
fromFinite :: Finite (Cardinality LineJoin) -> LineJoin
$ctoFinite :: LineJoin -> Finite (Cardinality LineJoin)
toFinite :: LineJoin -> Finite (Cardinality LineJoin)
$cstart :: (1 <= Cardinality LineJoin) => LineJoin
start :: (1 <= Cardinality LineJoin) => LineJoin
$cend :: (1 <= Cardinality LineJoin) => LineJoin
end :: (1 <= Cardinality LineJoin) => LineJoin
$cprevious :: LineJoin -> Maybe LineJoin
previous :: LineJoin -> Maybe LineJoin
$cnext :: LineJoin -> Maybe LineJoin
next :: LineJoin -> Maybe LineJoin
Finitary)
-- in ipe; they are converted to Int values in the range [0,2]

instance Default LineJoin where
  def :: LineJoin
def = LineJoin
Round

makePrisms ''LineJoin

-- | Possible values for an ipe arrow
data IpeArrow r = IpeArrow { forall r. IpeArrow r -> Text
_arrowName :: Text
                           , forall r. IpeArrow r -> IpeSize r
_arrowSize :: IpeSize r
                           } deriving (Int -> IpeArrow r -> ShowS
[IpeArrow r] -> ShowS
IpeArrow r -> String
(Int -> IpeArrow r -> ShowS)
-> (IpeArrow r -> String)
-> ([IpeArrow r] -> ShowS)
-> Show (IpeArrow r)
forall r. Show r => Int -> IpeArrow r -> ShowS
forall r. Show r => [IpeArrow r] -> ShowS
forall r. Show r => IpeArrow r -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall r. Show r => Int -> IpeArrow r -> ShowS
showsPrec :: Int -> IpeArrow r -> ShowS
$cshow :: forall r. Show r => IpeArrow r -> String
show :: IpeArrow r -> String
$cshowList :: forall r. Show r => [IpeArrow r] -> ShowS
showList :: [IpeArrow r] -> ShowS
Show,IpeArrow r -> IpeArrow r -> Bool
(IpeArrow r -> IpeArrow r -> Bool)
-> (IpeArrow r -> IpeArrow r -> Bool) -> Eq (IpeArrow r)
forall r. Eq r => IpeArrow r -> IpeArrow r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall r. Eq r => IpeArrow r -> IpeArrow r -> Bool
== :: IpeArrow r -> IpeArrow r -> Bool
$c/= :: forall r. Eq r => IpeArrow r -> IpeArrow r -> Bool
/= :: IpeArrow r -> IpeArrow r -> Bool
Eq,(forall a b. (a -> b) -> IpeArrow a -> IpeArrow b)
-> (forall a b. a -> IpeArrow b -> IpeArrow a) -> Functor IpeArrow
forall a b. a -> IpeArrow b -> IpeArrow a
forall a b. (a -> b) -> IpeArrow a -> IpeArrow b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> IpeArrow a -> IpeArrow b
fmap :: forall a b. (a -> b) -> IpeArrow a -> IpeArrow b
$c<$ :: forall a b. a -> IpeArrow b -> IpeArrow a
<$ :: forall a b. a -> IpeArrow b -> IpeArrow a
Functor,(forall m. Monoid m => IpeArrow m -> m)
-> (forall m a. Monoid m => (a -> m) -> IpeArrow a -> m)
-> (forall m a. Monoid m => (a -> m) -> IpeArrow a -> m)
-> (forall a b. (a -> b -> b) -> b -> IpeArrow a -> b)
-> (forall a b. (a -> b -> b) -> b -> IpeArrow a -> b)
-> (forall b a. (b -> a -> b) -> b -> IpeArrow a -> b)
-> (forall b a. (b -> a -> b) -> b -> IpeArrow a -> b)
-> (forall a. (a -> a -> a) -> IpeArrow a -> a)
-> (forall a. (a -> a -> a) -> IpeArrow a -> a)
-> (forall a. IpeArrow a -> [a])
-> (forall a. IpeArrow a -> Bool)
-> (forall a. IpeArrow a -> Int)
-> (forall a. Eq a => a -> IpeArrow a -> Bool)
-> (forall a. Ord a => IpeArrow a -> a)
-> (forall a. Ord a => IpeArrow a -> a)
-> (forall a. Num a => IpeArrow a -> a)
-> (forall a. Num a => IpeArrow a -> a)
-> Foldable IpeArrow
forall a. Eq a => a -> IpeArrow a -> Bool
forall a. Num a => IpeArrow a -> a
forall a. Ord a => IpeArrow a -> a
forall m. Monoid m => IpeArrow m -> m
forall a. IpeArrow a -> Bool
forall a. IpeArrow a -> Int
forall a. IpeArrow a -> [a]
forall a. (a -> a -> a) -> IpeArrow a -> a
forall m a. Monoid m => (a -> m) -> IpeArrow a -> m
forall b a. (b -> a -> b) -> b -> IpeArrow a -> b
forall a b. (a -> b -> b) -> b -> IpeArrow a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => IpeArrow m -> m
fold :: forall m. Monoid m => IpeArrow m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> IpeArrow a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> IpeArrow a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> IpeArrow a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> IpeArrow a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> IpeArrow a -> b
foldr :: forall a b. (a -> b -> b) -> b -> IpeArrow a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> IpeArrow a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> IpeArrow a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> IpeArrow a -> b
foldl :: forall b a. (b -> a -> b) -> b -> IpeArrow a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> IpeArrow a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> IpeArrow a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> IpeArrow a -> a
foldr1 :: forall a. (a -> a -> a) -> IpeArrow a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> IpeArrow a -> a
foldl1 :: forall a. (a -> a -> a) -> IpeArrow a -> a
$ctoList :: forall a. IpeArrow a -> [a]
toList :: forall a. IpeArrow a -> [a]
$cnull :: forall a. IpeArrow a -> Bool
null :: forall a. IpeArrow a -> Bool
$clength :: forall a. IpeArrow a -> Int
length :: forall a. IpeArrow a -> Int
$celem :: forall a. Eq a => a -> IpeArrow a -> Bool
elem :: forall a. Eq a => a -> IpeArrow a -> Bool
$cmaximum :: forall a. Ord a => IpeArrow a -> a
maximum :: forall a. Ord a => IpeArrow a -> a
$cminimum :: forall a. Ord a => IpeArrow a -> a
minimum :: forall a. Ord a => IpeArrow a -> a
$csum :: forall a. Num a => IpeArrow a -> a
sum :: forall a. Num a => IpeArrow a -> a
$cproduct :: forall a. Num a => IpeArrow a -> a
product :: forall a. Num a => IpeArrow a -> a
Foldable,Functor IpeArrow
Foldable IpeArrow
(Functor IpeArrow, Foldable IpeArrow) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> IpeArrow a -> f (IpeArrow b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    IpeArrow (f a) -> f (IpeArrow a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IpeArrow a -> m (IpeArrow b))
-> (forall (m :: * -> *) a.
    Monad m =>
    IpeArrow (m a) -> m (IpeArrow a))
-> Traversable IpeArrow
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => IpeArrow (m a) -> m (IpeArrow a)
forall (f :: * -> *) a.
Applicative f =>
IpeArrow (f a) -> f (IpeArrow a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IpeArrow a -> m (IpeArrow b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IpeArrow a -> f (IpeArrow b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IpeArrow a -> f (IpeArrow b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IpeArrow a -> f (IpeArrow b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
IpeArrow (f a) -> f (IpeArrow a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
IpeArrow (f a) -> f (IpeArrow a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IpeArrow a -> m (IpeArrow b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IpeArrow a -> m (IpeArrow b)
$csequence :: forall (m :: * -> *) a. Monad m => IpeArrow (m a) -> m (IpeArrow a)
sequence :: forall (m :: * -> *) a. Monad m => IpeArrow (m a) -> m (IpeArrow a)
Traversable,(forall x. IpeArrow r -> Rep (IpeArrow r) x)
-> (forall x. Rep (IpeArrow r) x -> IpeArrow r)
-> Generic (IpeArrow r)
forall x. Rep (IpeArrow r) x -> IpeArrow r
forall x. IpeArrow r -> Rep (IpeArrow r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (IpeArrow r) x -> IpeArrow r
forall r x. IpeArrow r -> Rep (IpeArrow r) x
$cfrom :: forall r x. IpeArrow r -> Rep (IpeArrow r) x
from :: forall x. IpeArrow r -> Rep (IpeArrow r) x
$cto :: forall r x. Rep (IpeArrow r) x -> IpeArrow r
to :: forall x. Rep (IpeArrow r) x -> IpeArrow r
Generic)
makeLenses ''IpeArrow

-- | A normal arrow
normalArrow :: IpeArrow r
normalArrow :: forall r. IpeArrow r
normalArrow = Text -> IpeSize r -> IpeArrow r
forall r. Text -> IpeSize r -> IpeArrow r
IpeArrow Text
"normal" (IpeValue r -> IpeSize r
forall r. IpeValue r -> IpeSize r
IpeSize (IpeValue r -> IpeSize r) -> IpeValue r -> IpeSize r
forall a b. (a -> b) -> a -> b
$ Text -> IpeValue r
forall v. Text -> IpeValue v
Named Text
"normal")

--------------------------------------------------------------------------------
-- * Group Attributes

-- | The only group attribute is a Clip

-- A clipping path is a Path. Which is defined in Ipe.Types. To
-- avoid circular imports, we define GroupAttrElf and GroupAttribute there.