Ipe

Reexports the functionality for reading and writing Ipe files.

Ipe Files

data IpeFile r

A complete ipe file

Constructors

IpeFile (Maybe IpePreamble) [IpeStyle] (NonEmpty (IpePage r))

Instances

Eq r => Eq (IpeFile r)

Defined in Ipe.Types

Methods

(==) :: IpeFile r -> IpeFile r -> Bool

(/=) :: IpeFile r -> IpeFile r -> Bool

Show r => Show (IpeFile r)

Defined in Ipe.Types

Methods

showsPrec :: Int -> IpeFile r -> ShowS

show :: IpeFile r -> String

showList :: [IpeFile r] -> ShowS

(Coordinate r, Eq r) => IpeRead (IpeFile r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (IpeFile r)

IpeWriteText r => IpeWrite (IpeFile r)

Defined in Ipe.Writer

Methods

ipeWrite :: IpeFile r -> Maybe (Node Text Text)

preamble :: forall r. Lens' (IpeFile r) (Maybe IpePreamble)

styles :: forall r. Lens' (IpeFile r) [IpeStyle]

pages :: forall r r. Lens (IpeFile r) (IpeFile r) (NonEmpty (IpePage r)) (NonEmpty (IpePage r))

ipeFile :: NonEmpty (IpePage r) -> IpeFile r

Convenience constructor for creating an ipe file without preamble and with the default stylesheet.

singlePageFile :: IpePage r -> IpeFile r

Convenience function to construct an ipe file consisting of a single page.

singlePageFromContent :: [IpeObject r] -> IpeFile r

Create a single page ipe file from a list of IpeObjects

Reading Ipe files

readIpeFile :: (Coordinate r, Eq r) => FilePath -> IO (Either ConversionError (IpeFile r))

Given a file path, tries to read an ipe file.

This function applies all matrices to objects.

readSinglePageFile :: (Coordinate r, Eq r) => FilePath -> IO (Either ConversionError (IpePage r))

Since most Ipe file contain only one page, we provide a shortcut for that as well.

This function applies all matrices, and it makes sure there is at least one layer and view in the page.

readSinglePageFileThrow :: (Coordinate r, Eq r) => FilePath -> IO (IpePage r)

Tries to read a single page file, throws an error when this fails. See readSinglePageFile for further details.

readRawIpeFile :: (Coordinate r, Eq r) => FilePath -> IO (Either ConversionError (IpeFile r))

Given a file path, tries to read an ipe file

type ConversionError = Text

Reading all Geometries from a single page ipe file

readAll :: forall g r. (HasDefaultFromIpe g, r ~ NumType g) => IpePage r -> [g :+ IpeAttributes (DefaultFromIpe g) r]

Read all g's from some ipe page(s).

readAllFrom :: forall g r. (HasDefaultFromIpe g, r ~ NumType g, Coordinate r, Eq r) => FilePath -> IO [g :+ IpeAttributes (DefaultFromIpe g) r]

Convenience function from reading all g's from an ipe file. If there is an error reading or parsing the file the error is "thrown away".

Writing ipe files

writeIpeFile :: IpeWriteText r => FilePath -> IpeFile r -> IO ()

Given a prism to convert something of type g into an ipe file, a file path, and a g. Convert the geometry and write it to file.

Write an IpeFiele to file.

writeIpeFile' :: IpeWrite t => t -> FilePath -> IO ()

Convert to ipe XML and write the output to a file.

writeIpePage :: IpeWriteText r => FilePath -> IpePage r -> IO ()

Creates a single page ipe file with the given page

toIpeXML :: IpeWrite t => t -> Maybe ByteString

Convert to Ipe xml

printAsIpeSelection :: IpeWrite t => t -> IO ()

Convert the input to ipeXml, and prints it to standard out in such a way that the copied text can be pasted into ipe as a geometry object.

toIpeSelectionXML :: IpeWrite t => t -> Maybe ByteString

Convert input into an ipe selection.

Ipe Pages

data IpePage r

An IpePage is essentially a Group, together with a list of layers and a list of views.

Constructors

IpePage [LayerName] [View] [IpeObject r]

Instances

Eq r => Eq (IpePage r)

Defined in Ipe.Types

Methods

(==) :: IpePage r -> IpePage r -> Bool

(/=) :: IpePage r -> IpePage r -> Bool

Show r => Show (IpePage r)

Defined in Ipe.Types

Methods

showsPrec :: Int -> IpePage r -> ShowS

show :: IpePage r -> String

showList :: [IpePage r] -> ShowS

(Coordinate r, Eq r) => IpeRead (IpePage r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (IpePage r)

IpeWriteText r => IpeWrite (IpePage r)

Defined in Ipe.Writer

Methods

ipeWrite :: IpePage r -> Maybe (Node Text Text)

layers :: forall r. Lens' (IpePage r) [LayerName]

views :: forall r. Lens' (IpePage r) [View]

content :: forall r r. Lens (IpePage r) (IpePage r) [IpeObject r] [IpeObject r]

emptyPage :: IpePage r

Creates an empty page with one layer and view.

fromContent :: [IpeObject r] -> IpePage r

Creates a simple page with a single view.

onLayer :: LayerName -> Getting (Endo [IpeObject r]) [IpeObject r] (IpeObject r)

This allows you to filter the objects on some layer.

>>> let page = IpePage [] [] []
>>> page^..content.onLayer "myLayer"
[]

contentInView :: Word -> Getter (IpePage r) [IpeObject r]

Gets all objects that are visible in the given view.

Note that views are indexed starting from 0. If the page does not have any explicit view definitions, this function returns an empty list.

>>> let page = IpePage [] [] []
>>> page^.contentInView 0
[]

withDefaults :: IpePage r -> IpePage r

Makes sure that the page has at least one layer and at least one view, essentially matching the behaviour of ipe. In particular,

• if the page does not have any layers, it creates a layer named "alpha", and
• if the page does not have any views, it creates a view in which all layers are visible.

Content: Ipe Objects

data IpeObject r

Constructors

IpeGroup (IpeObject' Group r)

IpeImage (IpeObject' Image r)

IpeTextLabel (IpeObject' TextLabel r)

IpeMiniPage (IpeObject' MiniPage r)

IpeUse (IpeObject' IpeSymbol r)

IpePath (IpeObject' Path r)

Instances

Functor IpeObject

Defined in Ipe.Content

Methods

fmap :: (a -> b) -> IpeObject a -> IpeObject b

(<$) :: a -> IpeObject b -> IpeObject a

Foldable IpeObject

Defined in Ipe.Content

Methods

fold :: Monoid m => IpeObject m -> m

foldMap :: Monoid m => (a -> m) -> IpeObject a -> m

foldMap' :: Monoid m => (a -> m) -> IpeObject a -> m

foldr :: (a -> b -> b) -> b -> IpeObject a -> b

foldr' :: (a -> b -> b) -> b -> IpeObject a -> b

foldl :: (b -> a -> b) -> b -> IpeObject a -> b

foldl' :: (b -> a -> b) -> b -> IpeObject a -> b

foldr1 :: (a -> a -> a) -> IpeObject a -> a

foldl1 :: (a -> a -> a) -> IpeObject a -> a

toList :: IpeObject a -> [a]

null :: IpeObject a -> Bool

length :: IpeObject a -> Int

elem :: Eq a => a -> IpeObject a -> Bool

maximum :: Ord a => IpeObject a -> a

minimum :: Ord a => IpeObject a -> a

sum :: Num a => IpeObject a -> a

product :: Num a => IpeObject a -> a

Traversable IpeObject

Defined in Ipe.Content

Methods

traverse :: Applicative f => (a -> f b) -> IpeObject a -> f (IpeObject b)

sequenceA :: Applicative f => IpeObject (f a) -> f (IpeObject a)

mapM :: Monad m => (a -> m b) -> IpeObject a -> m (IpeObject b)

sequence :: Monad m => IpeObject (m a) -> m (IpeObject a)

Eq r => Eq (IpeObject r)

Defined in Ipe.Content

Methods

(==) :: IpeObject r -> IpeObject r -> Bool

(/=) :: IpeObject r -> IpeObject r -> Bool

Show r => Show (IpeObject r)

Defined in Ipe.Content

Methods

showsPrec :: Int -> IpeObject r -> ShowS

show :: IpeObject r -> String

showList :: [IpeObject r] -> ShowS

Fractional r => IsTransformable (IpeObject r)

Defined in Ipe.Content

Methods

transformBy :: Transformation (Dimension (IpeObject r)) (NumType (IpeObject r)) -> IpeObject r -> IpeObject r

(Coordinate r, Fractional r, Eq r) => IpeRead (IpeObject r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (IpeObject r)

IpeWriteText r => IpeWrite (IpeObject r)

Defined in Ipe.Writer

Methods

ipeWrite :: IpeObject r -> Maybe (Node Text Text)

type Dimension (IpeObject r)

Defined in Ipe.Content

type Dimension (IpeObject r) = 2

type NumType (IpeObject r)

Defined in Ipe.Content

type NumType (IpeObject r) = r

_IpePath :: forall r. Prism' (IpeObject r) (IpeObject' Path r)

_IpeUse :: forall r. Prism' (IpeObject r) (IpeObject' IpeSymbol r)

_IpeGroup :: forall r. Prism' (IpeObject r) (IpeObject' Group r)

_IpeTextLabel :: forall r. Prism' (IpeObject r) (IpeObject' TextLabel r)

_IpeMiniPage :: forall r. Prism' (IpeObject r) (IpeObject' MiniPage r)

_IpeImage :: forall r. Prism' (IpeObject r) (IpeObject' Image r)

type IpeObject' g r = g r :+ IpeAttributes g r

An IpeObject' is essentially the oject ogether with its attributes

ipeObject' :: ToObject i => i r -> IpeAttributes i r -> IpeObject r

Shorthand for constructing ipeObjects

class ToObject i where

Methods

mkIpeObject :: IpeObject' i r -> IpeObject r

Instances

ToObject Path

Defined in Ipe.Content

Methods

mkIpeObject :: IpeObject' Path r -> IpeObject r

ToObject Image

Defined in Ipe.Content

Methods

mkIpeObject :: IpeObject' Image r -> IpeObject r

ToObject IpeSymbol

Defined in Ipe.Content

Methods

mkIpeObject :: IpeObject' IpeSymbol r -> IpeObject r

ToObject MiniPage

Defined in Ipe.Content

Methods

mkIpeObject :: IpeObject' MiniPage r -> IpeObject r

ToObject TextLabel

Defined in Ipe.Content

Methods

mkIpeObject :: IpeObject' TextLabel r -> IpeObject r

ToObject Group

Defined in Ipe.Content

Methods

mkIpeObject :: IpeObject' Group r -> IpeObject r

Specific Ipe-Objects

newtype Path r

A path is a non-empty sequence of PathSegments.

Constructors

Path (LSeq 1 (PathSegment r))

Instances

Functor Path

Defined in Ipe.Path

Methods

fmap :: (a -> b) -> Path a -> Path b

(<$) :: a -> Path b -> Path a

Foldable Path

Defined in Ipe.Path

Methods

fold :: Monoid m => Path m -> m

foldMap :: Monoid m => (a -> m) -> Path a -> m

foldMap' :: Monoid m => (a -> m) -> Path a -> m

foldr :: (a -> b -> b) -> b -> Path a -> b

foldr' :: (a -> b -> b) -> b -> Path a -> b

foldl :: (b -> a -> b) -> b -> Path a -> b

foldl' :: (b -> a -> b) -> b -> Path a -> b

foldr1 :: (a -> a -> a) -> Path a -> a

foldl1 :: (a -> a -> a) -> Path a -> a

toList :: Path a -> [a]

null :: Path a -> Bool

length :: Path a -> Int

elem :: Eq a => a -> Path a -> Bool

maximum :: Ord a => Path a -> a

minimum :: Ord a => Path a -> a

sum :: Num a => Path a -> a

product :: Num a => Path a -> a

Traversable Path

Defined in Ipe.Path

Methods

traverse :: Applicative f => (a -> f b) -> Path a -> f (Path b)

sequenceA :: Applicative f => Path (f a) -> f (Path a)

mapM :: Monad m => (a -> m b) -> Path a -> m (Path b)

sequence :: Monad m => Path (m a) -> m (Path a)

ToObject Path

Defined in Ipe.Content

Methods

mkIpeObject :: IpeObject' Path r -> IpeObject r

Eq r => Eq (Path r)

Defined in Ipe.Path

Methods

(==) :: Path r -> Path r -> Bool

(/=) :: Path r -> Path r -> Bool

Show r => Show (Path r)

Defined in Ipe.Path

Methods

showsPrec :: Int -> Path r -> ShowS

show :: Path r -> String

showList :: [Path r] -> ShowS

Fractional r => IsTransformable (Path r)

Defined in Ipe.Path

Methods

transformBy :: Transformation (Dimension (Path r)) (NumType (Path r)) -> Path r -> Path r

(Coordinate r, Fractional r, Eq r) => IpeRead (Path r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (Path r)

(Coordinate r, Fractional r, Eq r) => IpeReadText (Path r)

Defined in Ipe.Reader

Methods

ipeReadText :: Text -> Either ConversionError (Path r)

IpeWriteText r => IpeWrite (Path r)

Defined in Ipe.Writer

Methods

ipeWrite :: Path r -> Maybe (Node Text Text)

IpeWriteText r => IpeWriteText (Path r)

Defined in Ipe.Writer

Methods

ipeWriteText :: Path r -> Maybe Text

type Dimension (Path r)

Defined in Ipe.Path

type Dimension (Path r) = 2

type NumType (Path r)

Defined in Ipe.Path

type NumType (Path r) = r

pathSegments :: forall r r. Iso (Path r) (Path r) (LSeq 1 (PathSegment r)) (LSeq 1 (PathSegment r))

data PathSegment r

Paths

Paths consist of Path Segments. PathSegments come in the following forms:

Constructors

PolyLineSegment (PolyLine 2 () r)

PolygonPath (SimplePolygon () r)

CubicBezierSegment (BezierSpline 3 2 r)

QuadraticBezierSegment (BezierSpline 2 2 r)

EllipseSegment (Ellipse r)

ArcSegment

SplineSegment

ClosedSplineSegment

Instances

Functor PathSegment

Defined in Ipe.Path

Methods

fmap :: (a -> b) -> PathSegment a -> PathSegment b

(<$) :: a -> PathSegment b -> PathSegment a

Foldable PathSegment

Defined in Ipe.Path

Methods

fold :: Monoid m => PathSegment m -> m

foldMap :: Monoid m => (a -> m) -> PathSegment a -> m

foldMap' :: Monoid m => (a -> m) -> PathSegment a -> m

foldr :: (a -> b -> b) -> b -> PathSegment a -> b

foldr' :: (a -> b -> b) -> b -> PathSegment a -> b

foldl :: (b -> a -> b) -> b -> PathSegment a -> b

foldl' :: (b -> a -> b) -> b -> PathSegment a -> b

foldr1 :: (a -> a -> a) -> PathSegment a -> a

foldl1 :: (a -> a -> a) -> PathSegment a -> a

toList :: PathSegment a -> [a]

null :: PathSegment a -> Bool

length :: PathSegment a -> Int

elem :: Eq a => a -> PathSegment a -> Bool

maximum :: Ord a => PathSegment a -> a

minimum :: Ord a => PathSegment a -> a

sum :: Num a => PathSegment a -> a

product :: Num a => PathSegment a -> a

Traversable PathSegment

Defined in Ipe.Path

Methods

traverse :: Applicative f => (a -> f b) -> PathSegment a -> f (PathSegment b)

sequenceA :: Applicative f => PathSegment (f a) -> f (PathSegment a)

mapM :: Monad m => (a -> m b) -> PathSegment a -> m (PathSegment b)

sequence :: Monad m => PathSegment (m a) -> m (PathSegment a)

Eq r => Eq (PathSegment r)

Defined in Ipe.Path

Methods

(==) :: PathSegment r -> PathSegment r -> Bool

(/=) :: PathSegment r -> PathSegment r -> Bool

Show r => Show (PathSegment r)

Defined in Ipe.Path

Methods

showsPrec :: Int -> PathSegment r -> ShowS

show :: PathSegment r -> String

showList :: [PathSegment r] -> ShowS

Fractional r => IsTransformable (PathSegment r)

Defined in Ipe.Path

Methods

transformBy :: Transformation (Dimension (PathSegment r)) (NumType (PathSegment r)) -> PathSegment r -> PathSegment r

(Coordinate r, Fractional r, Eq r) => IpeReadText (NonEmpty (PathSegment r))

Defined in Ipe.Reader

Methods

ipeReadText :: Text -> Either ConversionError (NonEmpty (PathSegment r))

IpeWriteText r => IpeWriteText (PathSegment r)

Defined in Ipe.Writer

Methods

ipeWriteText :: PathSegment r -> Maybe Text

type Dimension (PathSegment r)

Defined in Ipe.Path

type Dimension (PathSegment r) = 2

type NumType (PathSegment r)

Defined in Ipe.Path

type NumType (PathSegment r) = r

data IpeSymbol r

Ipe Symbols, i.e. Points

A symbol (point) in ipe

Constructors

Symbol (Point 2 r) Text

Instances

Functor IpeSymbol

Defined in Ipe.Content

Methods

fmap :: (a -> b) -> IpeSymbol a -> IpeSymbol b

(<$) :: a -> IpeSymbol b -> IpeSymbol a

Foldable IpeSymbol

Defined in Ipe.Content

Methods

fold :: Monoid m => IpeSymbol m -> m

foldMap :: Monoid m => (a -> m) -> IpeSymbol a -> m

foldMap' :: Monoid m => (a -> m) -> IpeSymbol a -> m

foldr :: (a -> b -> b) -> b -> IpeSymbol a -> b

foldr' :: (a -> b -> b) -> b -> IpeSymbol a -> b

foldl :: (b -> a -> b) -> b -> IpeSymbol a -> b

foldl' :: (b -> a -> b) -> b -> IpeSymbol a -> b

foldr1 :: (a -> a -> a) -> IpeSymbol a -> a

foldl1 :: (a -> a -> a) -> IpeSymbol a -> a

toList :: IpeSymbol a -> [a]

null :: IpeSymbol a -> Bool

length :: IpeSymbol a -> Int

elem :: Eq a => a -> IpeSymbol a -> Bool

maximum :: Ord a => IpeSymbol a -> a

minimum :: Ord a => IpeSymbol a -> a

sum :: Num a => IpeSymbol a -> a

product :: Num a => IpeSymbol a -> a

Traversable IpeSymbol

Defined in Ipe.Content

Methods

traverse :: Applicative f => (a -> f b) -> IpeSymbol a -> f (IpeSymbol b)

sequenceA :: Applicative f => IpeSymbol (f a) -> f (IpeSymbol a)

mapM :: Monad m => (a -> m b) -> IpeSymbol a -> m (IpeSymbol b)

sequence :: Monad m => IpeSymbol (m a) -> m (IpeSymbol a)

ToObject IpeSymbol

Defined in Ipe.Content

Methods

mkIpeObject :: IpeObject' IpeSymbol r -> IpeObject r

Eq r => Eq (IpeSymbol r)

Defined in Ipe.Content

Methods

(==) :: IpeSymbol r -> IpeSymbol r -> Bool

(/=) :: IpeSymbol r -> IpeSymbol r -> Bool

Ord r => Ord (IpeSymbol r)

Defined in Ipe.Content

Methods

compare :: IpeSymbol r -> IpeSymbol r -> Ordering

(<) :: IpeSymbol r -> IpeSymbol r -> Bool

(<=) :: IpeSymbol r -> IpeSymbol r -> Bool

(>) :: IpeSymbol r -> IpeSymbol r -> Bool

(>=) :: IpeSymbol r -> IpeSymbol r -> Bool

max :: IpeSymbol r -> IpeSymbol r -> IpeSymbol r

min :: IpeSymbol r -> IpeSymbol r -> IpeSymbol r

Show r => Show (IpeSymbol r)

Defined in Ipe.Content

Methods

showsPrec :: Int -> IpeSymbol r -> ShowS

show :: IpeSymbol r -> String

showList :: [IpeSymbol r] -> ShowS

Fractional r => IsTransformable (IpeSymbol r)

Defined in Ipe.Content

Methods

transformBy :: Transformation (Dimension (IpeSymbol r)) (NumType (IpeSymbol r)) -> IpeSymbol r -> IpeSymbol r

Coordinate r => IpeRead (IpeSymbol r)

Ipe read instances

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (IpeSymbol r)

IpeWriteText r => IpeWrite (IpeSymbol r)

Defined in Ipe.Writer

Methods

ipeWrite :: IpeSymbol r -> Maybe (Node Text Text)

type Dimension (IpeSymbol r)

Defined in Ipe.Content

type Dimension (IpeSymbol r) = 2

type NumType (IpeSymbol r)

Defined in Ipe.Content

type NumType (IpeSymbol r) = r

symbolPoint :: forall r r. Lens (IpeSymbol r) (IpeSymbol r) (Point 2 r) (Point 2 r)

symbolName :: forall r. Lens' (IpeSymbol r) Text

newtype Group r

Groups and Objects

Group Attributes

A group is essentially a list of IpeObjects.

Constructors

Group [IpeObject r]

Instances

Functor Group

Defined in Ipe.Content

Methods

fmap :: (a -> b) -> Group a -> Group b

(<$) :: a -> Group b -> Group a

Foldable Group

Defined in Ipe.Content

Methods

fold :: Monoid m => Group m -> m

foldMap :: Monoid m => (a -> m) -> Group a -> m

foldMap' :: Monoid m => (a -> m) -> Group a -> m

foldr :: (a -> b -> b) -> b -> Group a -> b

foldr' :: (a -> b -> b) -> b -> Group a -> b

foldl :: (b -> a -> b) -> b -> Group a -> b

foldl' :: (b -> a -> b) -> b -> Group a -> b

foldr1 :: (a -> a -> a) -> Group a -> a

foldl1 :: (a -> a -> a) -> Group a -> a

toList :: Group a -> [a]

null :: Group a -> Bool

length :: Group a -> Int

elem :: Eq a => a -> Group a -> Bool

maximum :: Ord a => Group a -> a

minimum :: Ord a => Group a -> a

sum :: Num a => Group a -> a

product :: Num a => Group a -> a

Traversable Group

Defined in Ipe.Content

Methods

traverse :: Applicative f => (a -> f b) -> Group a -> f (Group b)

sequenceA :: Applicative f => Group (f a) -> f (Group a)

mapM :: Monad m => (a -> m b) -> Group a -> m (Group b)

sequence :: Monad m => Group (m a) -> m (Group a)

ToObject Group

Defined in Ipe.Content

Methods

mkIpeObject :: IpeObject' Group r -> IpeObject r

Eq r => Eq (Group r)

Defined in Ipe.Content

Methods

(==) :: Group r -> Group r -> Bool

(/=) :: Group r -> Group r -> Bool

Show r => Show (Group r)

Defined in Ipe.Content

Methods

showsPrec :: Int -> Group r -> ShowS

show :: Group r -> String

showList :: [Group r] -> ShowS

Fractional r => IsTransformable (Group r)

Defined in Ipe.Content

Methods

transformBy :: Transformation (Dimension (Group r)) (NumType (Group r)) -> Group r -> Group r

(Coordinate r, Eq r) => IpeRead (Group r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (Group r)

IpeWriteText r => IpeWrite (Group r)

Defined in Ipe.Writer

Methods

ipeWrite :: Group r -> Maybe (Node Text Text)

type Dimension (Group r)

Defined in Ipe.Content

type Dimension (Group r) = 2

type NumType (Group r)

Defined in Ipe.Content

type NumType (Group r) = r

groupItems :: Lens (Group r) (Group s) [IpeObject r] [IpeObject s]

data TextLabel r

Text Objects

Constructors

Label Text (Point 2 r)

Instances

Functor TextLabel

Defined in Ipe.Content

Methods

fmap :: (a -> b) -> TextLabel a -> TextLabel b

(<$) :: a -> TextLabel b -> TextLabel a

Foldable TextLabel

Defined in Ipe.Content

Methods

fold :: Monoid m => TextLabel m -> m

foldMap :: Monoid m => (a -> m) -> TextLabel a -> m

foldMap' :: Monoid m => (a -> m) -> TextLabel a -> m

foldr :: (a -> b -> b) -> b -> TextLabel a -> b

foldr' :: (a -> b -> b) -> b -> TextLabel a -> b

foldl :: (b -> a -> b) -> b -> TextLabel a -> b

foldl' :: (b -> a -> b) -> b -> TextLabel a -> b

foldr1 :: (a -> a -> a) -> TextLabel a -> a

foldl1 :: (a -> a -> a) -> TextLabel a -> a

toList :: TextLabel a -> [a]

null :: TextLabel a -> Bool

length :: TextLabel a -> Int

elem :: Eq a => a -> TextLabel a -> Bool

maximum :: Ord a => TextLabel a -> a

minimum :: Ord a => TextLabel a -> a

sum :: Num a => TextLabel a -> a

product :: Num a => TextLabel a -> a

Traversable TextLabel

Defined in Ipe.Content

Methods

traverse :: Applicative f => (a -> f b) -> TextLabel a -> f (TextLabel b)

sequenceA :: Applicative f => TextLabel (f a) -> f (TextLabel a)

mapM :: Monad m => (a -> m b) -> TextLabel a -> m (TextLabel b)

sequence :: Monad m => TextLabel (m a) -> m (TextLabel a)

ToObject TextLabel

Defined in Ipe.Content

Methods

mkIpeObject :: IpeObject' TextLabel r -> IpeObject r

Eq r => Eq (TextLabel r)

Defined in Ipe.Content

Methods

(==) :: TextLabel r -> TextLabel r -> Bool

(/=) :: TextLabel r -> TextLabel r -> Bool

Ord r => Ord (TextLabel r)

Defined in Ipe.Content

Methods

compare :: TextLabel r -> TextLabel r -> Ordering

(<) :: TextLabel r -> TextLabel r -> Bool

(<=) :: TextLabel r -> TextLabel r -> Bool

(>) :: TextLabel r -> TextLabel r -> Bool

(>=) :: TextLabel r -> TextLabel r -> Bool

max :: TextLabel r -> TextLabel r -> TextLabel r

min :: TextLabel r -> TextLabel r -> TextLabel r

Show r => Show (TextLabel r)

Defined in Ipe.Content

Methods

showsPrec :: Int -> TextLabel r -> ShowS

show :: TextLabel r -> String

showList :: [TextLabel r] -> ShowS

Fractional r => IsTransformable (TextLabel r)

Defined in Ipe.Content

Methods

transformBy :: Transformation (Dimension (TextLabel r)) (NumType (TextLabel r)) -> TextLabel r -> TextLabel r

Coordinate r => IpeRead (TextLabel r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (TextLabel r)

IpeWriteText r => IpeWrite (TextLabel r)

Defined in Ipe.Writer

Methods

ipeWrite :: TextLabel r -> Maybe (Node Text Text)

type Dimension (TextLabel r)

Defined in Ipe.Content

type Dimension (TextLabel r) = 2

type NumType (TextLabel r)

Defined in Ipe.Content

type NumType (TextLabel r) = r

data MiniPage r

Constructors

MiniPage Text (Point 2 r) r

Instances

Functor MiniPage

Defined in Ipe.Content

Methods

fmap :: (a -> b) -> MiniPage a -> MiniPage b

(<$) :: a -> MiniPage b -> MiniPage a

Foldable MiniPage

Defined in Ipe.Content

Methods

fold :: Monoid m => MiniPage m -> m

foldMap :: Monoid m => (a -> m) -> MiniPage a -> m

foldMap' :: Monoid m => (a -> m) -> MiniPage a -> m

foldr :: (a -> b -> b) -> b -> MiniPage a -> b

foldr' :: (a -> b -> b) -> b -> MiniPage a -> b

foldl :: (b -> a -> b) -> b -> MiniPage a -> b

foldl' :: (b -> a -> b) -> b -> MiniPage a -> b

foldr1 :: (a -> a -> a) -> MiniPage a -> a

foldl1 :: (a -> a -> a) -> MiniPage a -> a

toList :: MiniPage a -> [a]

null :: MiniPage a -> Bool

length :: MiniPage a -> Int

elem :: Eq a => a -> MiniPage a -> Bool

maximum :: Ord a => MiniPage a -> a

minimum :: Ord a => MiniPage a -> a

sum :: Num a => MiniPage a -> a

product :: Num a => MiniPage a -> a

Traversable MiniPage

Defined in Ipe.Content

Methods

traverse :: Applicative f => (a -> f b) -> MiniPage a -> f (MiniPage b)

sequenceA :: Applicative f => MiniPage (f a) -> f (MiniPage a)

mapM :: Monad m => (a -> m b) -> MiniPage a -> m (MiniPage b)

sequence :: Monad m => MiniPage (m a) -> m (MiniPage a)

ToObject MiniPage

Defined in Ipe.Content

Methods

mkIpeObject :: IpeObject' MiniPage r -> IpeObject r

Eq r => Eq (MiniPage r)

Defined in Ipe.Content

Methods

(==) :: MiniPage r -> MiniPage r -> Bool

(/=) :: MiniPage r -> MiniPage r -> Bool

Ord r => Ord (MiniPage r)

Defined in Ipe.Content

Methods

compare :: MiniPage r -> MiniPage r -> Ordering

(<) :: MiniPage r -> MiniPage r -> Bool

(<=) :: MiniPage r -> MiniPage r -> Bool

(>) :: MiniPage r -> MiniPage r -> Bool

(>=) :: MiniPage r -> MiniPage r -> Bool

max :: MiniPage r -> MiniPage r -> MiniPage r

min :: MiniPage r -> MiniPage r -> MiniPage r

Show r => Show (MiniPage r)

Defined in Ipe.Content

Methods

showsPrec :: Int -> MiniPage r -> ShowS

show :: MiniPage r -> String

showList :: [MiniPage r] -> ShowS

Fractional r => IsTransformable (MiniPage r)

Defined in Ipe.Content

Methods

transformBy :: Transformation (Dimension (MiniPage r)) (NumType (MiniPage r)) -> MiniPage r -> MiniPage r

Coordinate r => IpeRead (MiniPage r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (MiniPage r)

IpeWriteText r => IpeWrite (MiniPage r)

Defined in Ipe.Writer

Methods

ipeWrite :: MiniPage r -> Maybe (Node Text Text)

type Dimension (MiniPage r)

Defined in Ipe.Content

type Dimension (MiniPage r) = 2

type NumType (MiniPage r)

Defined in Ipe.Content

type NumType (MiniPage r) = r

width :: MiniPage t -> t

data Image r

Image Objects

Constructors

Image () (Rectangle () r)

Instances

Functor Image

Defined in Ipe.Content

Methods

fmap :: (a -> b) -> Image a -> Image b

(<$) :: a -> Image b -> Image a

Foldable Image

Defined in Ipe.Content

Methods

fold :: Monoid m => Image m -> m

foldMap :: Monoid m => (a -> m) -> Image a -> m

foldMap' :: Monoid m => (a -> m) -> Image a -> m

foldr :: (a -> b -> b) -> b -> Image a -> b

foldr' :: (a -> b -> b) -> b -> Image a -> b

foldl :: (b -> a -> b) -> b -> Image a -> b

foldl' :: (b -> a -> b) -> b -> Image a -> b

foldr1 :: (a -> a -> a) -> Image a -> a

foldl1 :: (a -> a -> a) -> Image a -> a

toList :: Image a -> [a]

null :: Image a -> Bool

length :: Image a -> Int

elem :: Eq a => a -> Image a -> Bool

maximum :: Ord a => Image a -> a

minimum :: Ord a => Image a -> a

sum :: Num a => Image a -> a

product :: Num a => Image a -> a

Traversable Image

Defined in Ipe.Content

Methods

traverse :: Applicative f => (a -> f b) -> Image a -> f (Image b)

sequenceA :: Applicative f => Image (f a) -> f (Image a)

mapM :: Monad m => (a -> m b) -> Image a -> m (Image b)

sequence :: Monad m => Image (m a) -> m (Image a)

ToObject Image

Defined in Ipe.Content

Methods

mkIpeObject :: IpeObject' Image r -> IpeObject r

Eq r => Eq (Image r)

Defined in Ipe.Content

Methods

(==) :: Image r -> Image r -> Bool

(/=) :: Image r -> Image r -> Bool

Ord r => Ord (Image r)

Defined in Ipe.Content

Methods

compare :: Image r -> Image r -> Ordering

(<) :: Image r -> Image r -> Bool

(<=) :: Image r -> Image r -> Bool

(>) :: Image r -> Image r -> Bool

(>=) :: Image r -> Image r -> Bool

max :: Image r -> Image r -> Image r

min :: Image r -> Image r -> Image r

Show r => Show (Image r)

Defined in Ipe.Content

Methods

showsPrec :: Int -> Image r -> ShowS

show :: Image r -> String

showList :: [Image r] -> ShowS

Fractional r => IsTransformable (Image r)

Defined in Ipe.Content

Methods

transformBy :: Transformation (Dimension (Image r)) (NumType (Image r)) -> Image r -> Image r

Coordinate r => IpeRead (Image r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (Image r)

IpeWriteText r => IpeWrite (Image r)

Defined in Ipe.Writer

Methods

ipeWrite :: Image r -> Maybe (Node Text Text)

type Dimension (Image r)

Defined in Ipe.Content

type Dimension (Image r) = 2

type NumType (Image r)

Defined in Ipe.Content

type NumType (Image r) = r

imageData :: forall r. Lens' (Image r) ()

rect :: forall r r. Lens (Image r) (Image r) (Rectangle () r) (Rectangle () r)

type IpeBitmap = Text

Attributes

type IpeAttributes g r = Attributes' r (AttributesOf g)

type Attributes' r = Attributes (AttrMapSym1 r)

Attributes' :: * -> [AttributeUniverse] -> *

type family AttributesOf (t :: * -> *) :: [AttributeUniverse] where ...

Equations

AttributesOf Group = GroupAttributes

AttributesOf Image = CommonAttributes

AttributesOf TextLabel = CommonAttributes

AttributesOf MiniPage = CommonAttributes

AttributesOf IpeSymbol = SymbolAttributes

AttributesOf Path = PathAttributes

type family AttrMap (r :: *) (l :: AttributeUniverse) :: * where ...

The mapping between the labels of the the attributes and the types of the attributes with these labels. For example, the Matrix label/attribute should have a value of type 'Matrix 3 3 r'.

Equations

AttrMap r 'Layer = LayerName

AttrMap r Matrix = Matrix 3 3 r

AttrMap r Pin = PinType

AttrMap r Transformations = TransformationTypes

AttrMap r Stroke = IpeColor r

AttrMap r Pen = IpePen r

AttrMap r Fill = IpeColor r

AttrMap r Size = IpeSize r

AttrMap r Dash = IpeDash r

AttrMap r LineCap = Int

AttrMap r LineJoin = Int

AttrMap r FillRule = FillType

AttrMap r Arrow = IpeArrow r

AttrMap r RArrow = IpeArrow r

AttrMap r StrokeOpacity = IpeOpacity

AttrMap r Opacity = IpeOpacity

AttrMap r Tiling = IpeTiling

AttrMap r Gradient = IpeGradient

AttrMap r Clip = Path r

data AttrMapSym1 a6989586621679197913 a6989586621679197914

Instances

SuppressUnusedWarnings (AttrMapSym1 a6989586621679197913 :: TyFun AttributeUniverse Type -> Type)

Defined in Ipe.Content

Methods

suppressUnusedWarnings :: ()

type Apply (AttrMapSym1 a6989586621679197913 :: TyFun AttributeUniverse Type -> Type) (a6989586621679197914 :: AttributeUniverse)

Defined in Ipe.Content

type Apply (AttrMapSym1 a6989586621679197913 :: TyFun AttributeUniverse Type -> Type) (a6989586621679197914 :: AttributeUniverse)

attributes :: Lens' (IpeObject' g r) (IpeAttributes g r)

traverseIpeAttrs :: (Applicative f, AllConstrained TraverseIpeAttr (AttributesOf g)) => proxy g -> (r -> f s) -> IpeAttributes g r -> f (IpeAttributes g s)

traverse for ipe attributes

commonAttributes :: Lens' (IpeObject r) (Attributes (AttrMapSym1 r) CommonAttributes)

Layers and Views

newtype LayerName

Defines an Layer in Ipe.

Constructors

LayerName Text

Instances

Eq LayerName

Defined in Ipe.Layer

Methods

(==) :: LayerName -> LayerName -> Bool

(/=) :: LayerName -> LayerName -> Bool

Ord LayerName

Defined in Ipe.Layer

Methods

compare :: LayerName -> LayerName -> Ordering

(<) :: LayerName -> LayerName -> Bool

(<=) :: LayerName -> LayerName -> Bool

(>) :: LayerName -> LayerName -> Bool

(>=) :: LayerName -> LayerName -> Bool

max :: LayerName -> LayerName -> LayerName

min :: LayerName -> LayerName -> LayerName

Read LayerName

Defined in Ipe.Layer

Methods

readsPrec :: Int -> ReadS LayerName

readList :: ReadS [LayerName]

readPrec :: ReadPrec LayerName

readListPrec :: ReadPrec [LayerName]

Show LayerName

Defined in Ipe.Layer

Methods

showsPrec :: Int -> LayerName -> ShowS

show :: LayerName -> String

showList :: [LayerName] -> ShowS

IsString LayerName

Defined in Ipe.Layer

Methods

fromString :: String -> LayerName

IpeRead LayerName

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError LayerName

IpeReadText LayerName

Defined in Ipe.Reader

Methods

ipeReadText :: Text -> Either ConversionError LayerName

IpeWrite LayerName

Defined in Ipe.Writer

Methods

ipeWrite :: LayerName -> Maybe (Node Text Text)

IpeWriteText LayerName

Defined in Ipe.Writer

Methods

ipeWriteText :: LayerName -> Maybe Text

layerName :: Iso' LayerName Text

data View

The definition of a view make active layer into an index ?

Constructors

View [LayerName] LayerName

Instances

Eq View

Defined in Ipe.Types

Methods

(==) :: View -> View -> Bool

(/=) :: View -> View -> Bool

Ord View

Defined in Ipe.Types

Methods

compare :: View -> View -> Ordering

(<) :: View -> View -> Bool

(<=) :: View -> View -> Bool

(>) :: View -> View -> Bool

(>=) :: View -> View -> Bool

max :: View -> View -> View

min :: View -> View -> View

Show View

Defined in Ipe.Types

Methods

showsPrec :: Int -> View -> ShowS

show :: View -> String

showList :: [View] -> ShowS

IpeRead View

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError View

IpeWrite View

Defined in Ipe.Writer

Methods

ipeWrite :: View -> Maybe (Node Text Text)

layerNames :: Lens' View [LayerName]

activeLayer :: Lens' View LayerName

Ipe Syles and Preamble

data IpeStyle

for now we pretty much ignore these

Constructors

IpeStyle (Maybe Text) (Node Text Text)

Instances

Eq IpeStyle

Defined in Ipe.Types

Methods

(==) :: IpeStyle -> IpeStyle -> Bool

(/=) :: IpeStyle -> IpeStyle -> Bool

Show IpeStyle

Defined in Ipe.Types

Methods

showsPrec :: Int -> IpeStyle -> ShowS

show :: IpeStyle -> String

showList :: [IpeStyle] -> ShowS

IpeRead IpeStyle

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError IpeStyle

IpeWrite IpeStyle

Defined in Ipe.Writer

Methods

ipeWrite :: IpeStyle -> Maybe (Node Text Text)

styleName :: Lens' IpeStyle (Maybe Text)

styleData :: Lens' IpeStyle (Node Text Text)

basicIpeStyle :: IpeStyle

readIpeStylesheet :: FilePath -> IO (Either ConversionError IpeStyle)

Reads an Ipe stylesheet from Disk.

addStyleSheetFrom :: FilePath -> IpeFile r -> IO (IpeFile r)

Given a path to a stylesheet, add it to the ipe file with the highest priority. Throws an error when this fails.

data IpePreamble

The maybe string is the encoding

Constructors

IpePreamble (Maybe Text) Text

Instances

Eq IpePreamble

Defined in Ipe.Types

Methods

(==) :: IpePreamble -> IpePreamble -> Bool

(/=) :: IpePreamble -> IpePreamble -> Bool

Ord IpePreamble

Defined in Ipe.Types

Methods

compare :: IpePreamble -> IpePreamble -> Ordering

(<) :: IpePreamble -> IpePreamble -> Bool

(<=) :: IpePreamble -> IpePreamble -> Bool

(>) :: IpePreamble -> IpePreamble -> Bool

(>=) :: IpePreamble -> IpePreamble -> Bool

max :: IpePreamble -> IpePreamble -> IpePreamble

min :: IpePreamble -> IpePreamble -> IpePreamble

Read IpePreamble

Defined in Ipe.Types

Methods

readsPrec :: Int -> ReadS IpePreamble

readList :: ReadS [IpePreamble]

readPrec :: ReadPrec IpePreamble

readListPrec :: ReadPrec [IpePreamble]

Show IpePreamble

Defined in Ipe.Types

Methods

showsPrec :: Int -> IpePreamble -> ShowS

show :: IpePreamble -> String

showList :: [IpePreamble] -> ShowS

IpeWrite IpePreamble

Defined in Ipe.Writer

Methods

ipeWrite :: IpePreamble -> Maybe (Node Text Text)

encoding :: Lens' IpePreamble (Maybe Text)

preambleData :: Lens' IpePreamble Text

Reading Geometries *From* Ipe

class IpeRead t where

Reading an ipe lement from Xml

Methods

ipeRead :: Node Text Text -> Either ConversionError t

Instances

IpeRead LayerName

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError LayerName

IpeRead View

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError View

IpeRead IpeStyle

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError IpeStyle

(Coordinate r, Fractional r, Eq r) => IpeRead (Path r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (Path r)

Coordinate r => IpeRead (Image r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (Image r)

Coordinate r => IpeRead (IpeSymbol r)

Ipe read instances

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (IpeSymbol r)

Coordinate r => IpeRead (MiniPage r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (MiniPage r)

Coordinate r => IpeRead (TextLabel r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (TextLabel r)

(Coordinate r, Fractional r, Eq r) => IpeRead (IpeObject r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (IpeObject r)

(Coordinate r, Eq r) => IpeRead (Group r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (Group r)

(Coordinate r, Eq r) => IpeRead (IpePage r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (IpePage r)

(Coordinate r, Eq r) => IpeRead (IpeFile r)

Defined in Ipe.Reader

Methods

ipeRead :: Node Text Text -> Either ConversionError (IpeFile r)

Converting *from* IpeObjects

_asPoint :: Prism' (IpeSymbol r) (Point 2 r)

Extracts the point from a Symbol. When creating a symbol this creates a disk that supports a stroke color.

_asLineSegment :: Prism' (Path r) (LineSegment 2 () r)

Try to convert a path into a line segment, fails if the path is not a line segment or a polyline with more than two points.

_asRectangle :: forall r. (Num r, Ord r) => Prism' (Path r) (Rectangle () r)

Tries to convert a path into a rectangle.

_asTriangle :: Prism' (Path r) (Triangle 2 () r)

Convert to a triangle

_asPolyLine :: Prism' (Path r) (PolyLine 2 () r)

Convert to a polyline. Ignores all non-polyline parts

>>> testPath ^? _asPolyLine
Just (PolyLine {_points = LSeq (fromList [Point2 [0,0] :+ (),Point2 [10,10] :+ (),Point2 [200,100] :+ ()])})

_asSomePolygon :: Prism' (Path r) (SomePolygon () r)

_asSimplePolygon :: Prism' (Path r) (Polygon Simple () r)

Convert to a simple polygon

_asMultiPolygon :: Prism' (Path r) (MultiPolygon () r)

Convert to a multipolygon

Dealing with Attributes

_withAttrs :: Prism' (IpeObject r) (i r :+ IpeAttributes i r) -> Prism' (i r) g -> Prism' (IpeObject r) (g :+ IpeAttributes i r)

Use the first prism to select the ipe object to depicle with, and the second how to select the geometry object from there on. Then we can select the geometry object, directly with its attributes here.

>>> testObject ^? _withAttrs _IpePath _asPolyLine
Just (PolyLine {_points = LSeq (fromList [Point2 [0,0] :+ (),Point2 [10,10] :+ (),Point2 [200,100] :+ ()])} :+ Attrs {NoAttr, NoAttr, NoAttr, NoAttr, Attr IpeColor (Named "red"), NoAttr, NoAttr, NoAttr, NoAttr, NoAttr, NoAttr, NoAttr, NoAttr, NoAttr, NoAttr, NoAttr})

Default readers

class HasDefaultFromIpe g where

Associated Types

type DefaultFromIpe g :: * -> *

Methods

defaultFromIpe :: r ~ NumType g => Prism' (IpeObject r) (g :+ IpeAttributes (DefaultFromIpe g) r)

Instances

HasDefaultFromIpe (Ellipse r)

Defined in Ipe.FromIpe

Associated Types

type DefaultFromIpe (Ellipse r) :: Type -> Type

Methods

defaultFromIpe :: r0 ~ NumType (Ellipse r) => Prism' (IpeObject r0) (Ellipse r :+ IpeAttributes (DefaultFromIpe (Ellipse r)) r0)

HasDefaultFromIpe (SimplePolygon () r)

Defined in Ipe.FromIpe

Associated Types

type DefaultFromIpe (SimplePolygon () r) :: Type -> Type

Methods

defaultFromIpe :: r0 ~ NumType (SimplePolygon () r) => Prism' (IpeObject r0) (SimplePolygon () r :+ IpeAttributes (DefaultFromIpe (SimplePolygon () r)) r0)

HasDefaultFromIpe (MultiPolygon () r)

Defined in Ipe.FromIpe

Associated Types

type DefaultFromIpe (MultiPolygon () r) :: Type -> Type

Methods

defaultFromIpe :: r0 ~ NumType (MultiPolygon () r) => Prism' (IpeObject r0) (MultiPolygon () r :+ IpeAttributes (DefaultFromIpe (MultiPolygon () r)) r0)

(Floating r, Eq r) => HasDefaultFromIpe (Disk () r)

Defined in Ipe.FromIpe

Associated Types

type DefaultFromIpe (Disk () r) :: Type -> Type

Methods

defaultFromIpe :: r0 ~ NumType (Disk () r) => Prism' (IpeObject r0) (Disk () r :+ IpeAttributes (DefaultFromIpe (Disk () r)) r0)

(Floating r, Eq r) => HasDefaultFromIpe (Circle () r)

Defined in Ipe.FromIpe

Associated Types

type DefaultFromIpe (Circle () r) :: Type -> Type

Methods

defaultFromIpe :: r0 ~ NumType (Circle () r) => Prism' (IpeObject r0) (Circle () r :+ IpeAttributes (DefaultFromIpe (Circle () r)) r0)

HasDefaultFromIpe (Point 2 r)

Defined in Ipe.FromIpe

Associated Types

type DefaultFromIpe (Point 2 r) :: Type -> Type

Methods

defaultFromIpe :: r0 ~ NumType (Point 2 r) => Prism' (IpeObject r0) (Point 2 r :+ IpeAttributes (DefaultFromIpe (Point 2 r)) r0)

HasDefaultFromIpe (PolyLine 2 () r)

Defined in Ipe.FromIpe

Associated Types

type DefaultFromIpe (PolyLine 2 () r) :: Type -> Type

Methods

defaultFromIpe :: r0 ~ NumType (PolyLine 2 () r) => Prism' (IpeObject r0) (PolyLine 2 () r :+ IpeAttributes (DefaultFromIpe (PolyLine 2 () r)) r0)

HasDefaultFromIpe (LineSegment 2 () r)

Defined in Ipe.FromIpe

Associated Types

type DefaultFromIpe (LineSegment 2 () r) :: Type -> Type

Methods

defaultFromIpe :: r0 ~ NumType (LineSegment 2 () r) => Prism' (IpeObject r0) (LineSegment 2 () r :+ IpeAttributes (DefaultFromIpe (LineSegment 2 () r)) r0)

Converting *to* IpeObjects

IpeWrite

class IpeWrite t where

Types that correspond to an XML Element. All instances should produce an Element. If the type should produce a Node with the Text constructor, use the IpeWriteText typeclass instead.

Methods

ipeWrite :: t -> Maybe (Node Text Text)

Instances

IpeWrite ()

Defined in Ipe.Writer

Methods

ipeWrite :: () -> Maybe (Node Text Text)

IpeWrite LayerName

Defined in Ipe.Writer

Methods

ipeWrite :: LayerName -> Maybe (Node Text Text)

IpeWrite View

Defined in Ipe.Writer

Methods

ipeWrite :: View -> Maybe (Node Text Text)

IpeWrite IpeStyle

Defined in Ipe.Writer

Methods

ipeWrite :: IpeStyle -> Maybe (Node Text Text)

IpeWrite IpePreamble

Defined in Ipe.Writer

Methods

ipeWrite :: IpePreamble -> Maybe (Node Text Text)

IpeWrite t => IpeWrite [t]

Defined in Ipe.Writer

Methods

ipeWrite :: [t] -> Maybe (Node Text Text)

IpeWrite t => IpeWrite (NonEmpty t)

Defined in Ipe.Writer

Methods

ipeWrite :: NonEmpty t -> Maybe (Node Text Text)

IpeWriteText r => IpeWrite (Path r)

Defined in Ipe.Writer

Methods

ipeWrite :: Path r -> Maybe (Node Text Text)

IpeWriteText r => IpeWrite (Image r)

Defined in Ipe.Writer

Methods

ipeWrite :: Image r -> Maybe (Node Text Text)

IpeWriteText r => IpeWrite (IpeSymbol r)

Defined in Ipe.Writer

Methods

ipeWrite :: IpeSymbol r -> Maybe (Node Text Text)

IpeWriteText r => IpeWrite (MiniPage r)

Defined in Ipe.Writer

Methods

ipeWrite :: MiniPage r -> Maybe (Node Text Text)

IpeWriteText r => IpeWrite (TextLabel r)

Defined in Ipe.Writer

Methods

ipeWrite :: TextLabel r -> Maybe (Node Text Text)

IpeWriteText r => IpeWrite (IpeObject r)

Defined in Ipe.Writer

Methods

ipeWrite :: IpeObject r -> Maybe (Node Text Text)

IpeWriteText r => IpeWrite (Group r)

Defined in Ipe.Writer

Methods

ipeWrite :: Group r -> Maybe (Node Text Text)

IpeWriteText r => IpeWrite (IpePage r)

Defined in Ipe.Writer

Methods

ipeWrite :: IpePage r -> Maybe (Node Text Text)

IpeWriteText r => IpeWrite (IpeFile r)

Defined in Ipe.Writer

Methods

ipeWrite :: IpeFile r -> Maybe (Node Text Text)

(IpeWrite l, IpeWrite r) => IpeWrite (Either l r)

Defined in Ipe.Writer

Methods

ipeWrite :: Either l r -> Maybe (Node Text Text)

(AllConstrained IpeAttrName rs, RecordToList rs, RMap rs, ReifyConstraint IpeWriteText (Attr f) rs, RecAll (Attr f) rs IpeWriteText, IpeWrite g) => IpeWrite (g :+ Attributes f rs)

Defined in Ipe.Writer

Methods

ipeWrite :: (g :+ Attributes f rs) -> Maybe (Node Text Text)

(IpeWriteText r, IpeWrite p) => IpeWrite (PolyLine 2 p r)

Defined in Ipe.Writer

Methods

ipeWrite :: PolyLine 2 p r -> Maybe (Node Text Text)

IpeWriteText r => IpeWrite (LineSegment 2 p r)

Defined in Ipe.Writer

Methods

ipeWrite :: LineSegment 2 p r -> Maybe (Node Text Text)

class IpeWriteText t where

For types that can produce a text value

Methods

ipeWriteText :: t -> Maybe Text

Instances

IpeWriteText Double

Defined in Ipe.Writer

Methods

ipeWriteText :: Double -> Maybe Text

IpeWriteText Float

Defined in Ipe.Writer

Methods

ipeWriteText :: Float -> Maybe Text

IpeWriteText Int

Defined in Ipe.Writer

Methods

ipeWriteText :: Int -> Maybe Text

IpeWriteText Integer

Defined in Ipe.Writer

Methods

ipeWriteText :: Integer -> Maybe Text

IpeWriteText ()

Defined in Ipe.Writer

Methods

ipeWriteText :: () -> Maybe Text

IpeWriteText String

Defined in Ipe.Writer

Methods

ipeWriteText :: String -> Maybe Text

IpeWriteText Text

Defined in Ipe.Writer

Methods

ipeWriteText :: Text -> Maybe Text

IpeWriteText LayerName

Defined in Ipe.Writer

Methods

ipeWriteText :: LayerName -> Maybe Text

IpeWriteText FillType

Defined in Ipe.Writer

Methods

ipeWriteText :: FillType -> Maybe Text

IpeWriteText TransformationTypes

Defined in Ipe.Writer

Methods

ipeWriteText :: TransformationTypes -> Maybe Text

IpeWriteText PinType

Defined in Ipe.Writer

Methods

ipeWriteText :: PinType -> Maybe Text

Integral a => IpeWriteText (Ratio a)

This instance converts the ratio to a Pico, and then displays that.

Defined in Ipe.Writer

Methods

ipeWriteText :: Ratio a -> Maybe Text

IpeWriteText r => IpeWriteText (RGB r)

Defined in Ipe.Writer

Methods

ipeWriteText :: RGB r -> Maybe Text

IpeWriteText (RealNumber p)

Defined in Ipe.Writer

Methods

ipeWriteText :: RealNumber p -> Maybe Text

IpeWriteText r => IpeWriteText (PathSegment r)

Defined in Ipe.Writer

Methods

ipeWriteText :: PathSegment r -> Maybe Text

IpeWriteText r => IpeWriteText (Path r)

Defined in Ipe.Writer

Methods

ipeWriteText :: Path r -> Maybe Text

IpeWriteText r => IpeWriteText (Operation r)

Defined in Ipe.Writer

Methods

ipeWriteText :: Operation r -> Maybe Text

IpeWriteText v => IpeWriteText (IpeValue v)

Defined in Ipe.Writer

Methods

ipeWriteText :: IpeValue v -> Maybe Text

IpeWriteText r => IpeWriteText (IpeColor r)

Defined in Ipe.Writer

Methods

ipeWriteText :: IpeColor r -> Maybe Text

IpeWriteText r => IpeWriteText (IpeArrow r)

Defined in Ipe.Writer

Methods

ipeWriteText :: IpeArrow r -> Maybe Text

IpeWriteText r => IpeWriteText (IpeDash r)

Defined in Ipe.Writer

Methods

ipeWriteText :: IpeDash r -> Maybe Text

IpeWriteText r => IpeWriteText (IpePen r)

Defined in Ipe.Writer

Methods

ipeWriteText :: IpePen r -> Maybe Text

IpeWriteText r => IpeWriteText (IpeSize r)

Defined in Ipe.Writer

Methods

ipeWriteText :: IpeSize r -> Maybe Text

(IpeWriteText l, IpeWriteText r) => IpeWriteText (Either l r)

Defined in Ipe.Writer

Methods

ipeWriteText :: Either l r -> Maybe Text

HasResolution p => IpeWriteText (Fixed p)

Defined in Ipe.Writer

Methods

ipeWriteText :: Fixed p -> Maybe Text

IpeWriteText r => IpeWriteText (Point 2 r)

Defined in Ipe.Writer

Methods

ipeWriteText :: Point 2 r -> Maybe Text

IpeWriteText r => IpeWriteText (BezierSpline 3 2 r)

Defined in Ipe.Writer

Methods

ipeWriteText :: BezierSpline 3 2 r -> Maybe Text

IpeWriteText r => IpeWriteText (Polygon t () r)

Defined in Ipe.Writer

Methods

ipeWriteText :: Polygon t () r -> Maybe Text

IpeWriteText r => IpeWriteText (PolyLine 2 () r)

Defined in Ipe.Writer

Methods

ipeWriteText :: PolyLine 2 () r -> Maybe Text

IpeWriteText r => IpeWriteText (Matrix 3 3 r)

Defined in Ipe.Writer

Methods

ipeWriteText :: Matrix 3 3 r -> Maybe Text

IpeWriteText (Apply f at) => IpeWriteText (Attr f at)

Defined in Ipe.Writer

Methods

ipeWriteText :: Attr f at -> Maybe Text

IpeOut

module Ipe.IpeOut

Batch reexports

module Ipe.Types

module Ipe.FromIpe

module Ipe.Attributes

module Ipe.Value

newtype IpeColor r

Defines a color in Ipe. Colors are either RGB Values or Named values.

Constructors

IpeColor (IpeValue (RGB r))

Instances

Functor IpeColor

Defined in Ipe.Color

Methods

fmap :: (a -> b) -> IpeColor a -> IpeColor b

(<$) :: a -> IpeColor b -> IpeColor a

Foldable IpeColor

Defined in Ipe.Color

Methods

fold :: Monoid m => IpeColor m -> m

foldMap :: Monoid m => (a -> m) -> IpeColor a -> m

foldMap' :: Monoid m => (a -> m) -> IpeColor a -> m

foldr :: (a -> b -> b) -> b -> IpeColor a -> b

foldr' :: (a -> b -> b) -> b -> IpeColor a -> b

foldl :: (b -> a -> b) -> b -> IpeColor a -> b

foldl' :: (b -> a -> b) -> b -> IpeColor a -> b

foldr1 :: (a -> a -> a) -> IpeColor a -> a

foldl1 :: (a -> a -> a) -> IpeColor a -> a

toList :: IpeColor a -> [a]

null :: IpeColor a -> Bool

length :: IpeColor a -> Int

elem :: Eq a => a -> IpeColor a -> Bool

maximum :: Ord a => IpeColor a -> a

minimum :: Ord a => IpeColor a -> a

sum :: Num a => IpeColor a -> a

product :: Num a => IpeColor a -> a

Traversable IpeColor

Defined in Ipe.Color

Methods

traverse :: Applicative f => (a -> f b) -> IpeColor a -> f (IpeColor b)

sequenceA :: Applicative f => IpeColor (f a) -> f (IpeColor a)

mapM :: Monad m => (a -> m b) -> IpeColor a -> m (IpeColor b)

sequence :: Monad m => IpeColor (m a) -> m (IpeColor a)

Eq r => Eq (IpeColor r)

Defined in Ipe.Color

Methods

(==) :: IpeColor r -> IpeColor r -> Bool

(/=) :: IpeColor r -> IpeColor r -> Bool

Ord r => Ord (IpeColor r)

Defined in Ipe.Color

Methods

compare :: IpeColor r -> IpeColor r -> Ordering

(<) :: IpeColor r -> IpeColor r -> Bool

(<=) :: IpeColor r -> IpeColor r -> Bool

(>) :: IpeColor r -> IpeColor r -> Bool

(>=) :: IpeColor r -> IpeColor r -> Bool

max :: IpeColor r -> IpeColor r -> IpeColor r

min :: IpeColor r -> IpeColor r -> IpeColor r

Read r => Read (IpeColor r)

Defined in Ipe.Color

Methods

readsPrec :: Int -> ReadS (IpeColor r)

readList :: ReadS [IpeColor r]

readPrec :: ReadPrec (IpeColor r)

readListPrec :: ReadPrec [IpeColor r]

Show r => Show (IpeColor r)

Defined in Ipe.Color

Methods

showsPrec :: Int -> IpeColor r -> ShowS

show :: IpeColor r -> String

showList :: [IpeColor r] -> ShowS

Coordinate r => IpeReadText (IpeColor r)

Defined in Ipe.Reader

Methods

ipeReadText :: Text -> Either ConversionError (IpeColor r)

IpeWriteText r => IpeWriteText (IpeColor r)

Defined in Ipe.Writer

Methods

ipeWriteText :: IpeColor r -> Maybe Text

named :: Text -> IpeColor r

Creates a named color