-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Web graphic applications with Processing.
--   
--   <i>Processing</i> is a visual design programming language.
--   <i>Processing.js</i> is the sister project of Processing designed for
--   the web. The Haskell <i>processing</i> package is a web animation
--   library with <i>Processing.js</i> as backend.
--   
--   <i>What is this for?</i>
--   
--   With this library you are able to write scripts that, once executed in
--   a browser, will execute interactive visual programs.
--   
--   <i>Where can I see a running example?</i>
--   
--   An example output can be reached at
--   <a>http://liibe.com/experimental/rocket.html</a>. Also, take a look at
--   <a>http://liibe.com/experimental/mill.html</a>. The code of the latter
--   is included in the source distribution (/examples/mill.hs).
--   
--   <i>How do I learn to use it?</i>
--   
--   The API reference of the library includes guidance and is complemented
--   with code examples. Look also to the <i>examples</i> directory
--   included in the source distribution. It contains some fully working
--   examples.
--   
--   The library provides different APIs (interfaces). Each one with a
--   different philosophy.
--   
--   <ul>
--   <li><i>Simple</i> (<a>Graphics.Web.Processing.Simple</a>): An abstract
--   interface, focusing in what you want to be displayed, but not how. The
--   library will know how to write the processing code you need. However,
--   you may lack some features that you can find in other interfaces.</li>
--   <li><i>Mid</i> (<a>Graphics.Web.Processing.Mid</a>): More imperative
--   feeling, with variables and commands. But also convenient and
--   complete. This is the default interface, re-exported by
--   <a>Graphics.Web.Processing</a>.</li>
--   <li><i>Basic</i> (<a>Graphics.Web.Processing.Basic</a>): For people
--   that like to do things by hand. The output processing code is
--   predictable and you have great control over it.</li>
--   </ul>
--   
--   The module <a>Graphics.Web.Processing.Html</a> helps you to create the
--   HTML document where you will display the animation.
@package processing
@version 1.0.1.0


-- | Internal module defining <a>Var</a> type and functions. The
--   <i>basic</i> interface uses these variable functions. However, they
--   introduce a not-really-coherent behavior (see <a>readVar</a>).
module Graphics.Web.Processing.Core.Var

-- | Type of variables.
data Var a

-- | Get the name of a variable.
varName :: Var a -> Text

-- | Create a new variable with a starting value. The creation of variables
--   is restricted to the <a>Preamble</a>.
newVar :: (Monad (m Preamble), ProcMonad m, ProcType a) => a -> m Preamble (Var a)

-- | Read a variable.
--   
--   Funny fact: <i>it does not matter when you execute this function</i>.
--   The result will <i>always</i> hold the last value asigned to the
--   variable. For example, this code
--   
--   <pre>
--   v &lt;- newVar 10
--   ten &lt;- readVar v
--   writeVar v 20
--   point (10,ten)
--   </pre>
--   
--   will draw a point at (10,20).
readVar :: (Monad (m c), ProcMonad m, ProcType a) => Var a -> m c a

-- | Write a value to a variable.
writeVar :: (ProcMonad m, ProcType a) => Var a -> a -> m c ()


-- | Variables, commands and functions. The <i>interface</i> to the
--   processing.js API (<a>http://processingjs.org/reference</a>), with
--   some additions, deletions and modifications.
module Graphics.Web.Processing.Core.Interface

-- | Width of the canvas.
screenWidth :: Proc_Int

-- | Height of the canvas.
screenHeight :: Proc_Int

-- | Noise random function.
noise :: (ProcMonad m, Monad (m c)) => Proc_Point -> m c Proc_Float

-- | Class of contexts where the user can draw pictures in the screen.
--   Instances:
--   
--   <ul>
--   <li><a>Setup</a></li>
--   <li><a>Draw</a></li>
--   <li><a>MouseClicked</a></li>
--   <li><a>MouseReleased</a></li>
--   </ul>
class Drawing a

-- | RGBA colors. Values must be between 0 and 255, including in the alpha
--   channel.
data Color
Color :: Proc_Int -> Proc_Int -> Proc_Int -> Proc_Int -> Color

-- | Red channel.
redc :: Color -> Proc_Int

-- | Blue channel.
bluec :: Color -> Proc_Int

-- | Green channel.
greenc :: Color -> Proc_Int

-- | Alpha channel (opacity). 0 means transparent, and 255 opaque.
alphac :: Color -> Proc_Int

-- | Set the drawing color.
stroke :: (ProcMonad m, Drawing c) => Color -> m c ()

-- | Set the filling color.
fill :: (ProcMonad m, Drawing c) => Color -> m c ()

-- | Fill the screen with a given color.
background :: (ProcMonad m, Drawing c) => Color -> m c ()

-- | Set the weight of the lines.
strokeWeight :: (ProcMonad m, Drawing c) => Proc_Int -> m c ()

-- | A point as a pair of floating point numbers.
type Proc_Point = (Proc_Float, Proc_Float)

-- | Draw a ellipse.
ellipse :: (ProcMonad m, Drawing c) => Proc_Point -> Proc_Float -> Proc_Float -> m c ()

-- | Draw a circle.
circle :: (ProcMonad m, Drawing c) => Proc_Point -> Proc_Float -> m c ()

-- | Draw an arc.
--   
--   The arc is drawn following the line of an ellipse between two angles.
arc :: (ProcMonad m, Drawing c) => Proc_Point -> Proc_Float -> Proc_Float -> Proc_Float -> Proc_Float -> m c ()

-- | Draw a line.
line :: (ProcMonad m, Drawing c) => Proc_Point -> Proc_Point -> m c ()

-- | Prints a dot.
point :: (ProcMonad m, Drawing c) => Proc_Point -> m c ()

-- | A quad is a quadrilateral, a four sided polygon. The first parameter
--   is the first vertex and the subsequent parameters should proceed
--   clockwise or counter-clockwise around the defined shape.
quad :: (ProcMonad m, Drawing c) => Proc_Point -> Proc_Point -> Proc_Point -> Proc_Point -> m c ()

-- | Draws a rectangle to the screen. A rectangle is a four-sided shape
--   with every angle at ninety degrees. The first parameter set the
--   location, the second sets the width, and the third sets the height.
rect :: (ProcMonad m, Drawing c) => Proc_Point -> Proc_Float -> Proc_Float -> m c ()

-- | A triangle is a plane created by connecting three points.
triangle :: (ProcMonad m, Drawing c) => Proc_Point -> Proc_Point -> Proc_Point -> m c ()

-- | Bézier curve.
bezier :: (ProcMonad m, Drawing c) => Proc_Point -> Proc_Point -> Proc_Point -> Proc_Point -> m c ()

-- | Polygon drawer.
polygon :: (ProcMonad m, Monad (m c), Drawing c) => [Proc_Point] -> m c ()

-- | Display a text in the screen. The color is specified by <a>fill</a>.
drawtext :: (ProcMonad m, Drawing c) => Proc_Text -> Proc_Point -> Proc_Float -> Proc_Float -> m c ()

-- | Set the size of the canvas.
size :: ProcMonad m => Proc_Int -> Proc_Int -> m c ()

-- | Specify the number of frames to be displayed every second. The default
--   rate is 60 frames per second.
setFrameRate :: ProcMonad m => Proc_Int -> m Setup ()

-- | Move the current position.
translate :: (ProcMonad m, Drawing c) => Proc_Float -> Proc_Float -> m c ()

-- | Apply a rotation to the following pictures, centered at the current
--   position.
rotate :: (ProcMonad m, Drawing c) => Proc_Float -> m c ()

-- | Apply a scaling to the following pictures, centered at the current
--   position.
scale :: (ProcMonad m, Drawing c) => Proc_Float -> Proc_Float -> m c ()

-- | Reset the transformation matrix.
resetMatrix :: (ProcMonad m, Drawing c) => m c ()

-- | Get the current position of the mouse pointer.
getMousePoint :: (ProcMonad m, Monad (m c)) => m c Proc_Point

-- | Keyboard keys recognized by Processing.
data Key
CharKey :: Char -> Key
SpecialKey :: SpecialKey -> Key
ArrowKey :: ArrowKey -> Key
ModKey :: KeyModifier -> Key -> Key

-- | Arrow keys.
data ArrowKey
UP :: ArrowKey
DOWN :: ArrowKey
LEFT :: ArrowKey
RIGHT :: ArrowKey

-- | Key modifiers.
data KeyModifier
ALT :: KeyModifier
CONTROL :: KeyModifier
SHIFT :: KeyModifier

-- | Special keys.
data SpecialKey
BACKSPACE :: SpecialKey
TAB :: SpecialKey
ENTER :: SpecialKey
RETURN :: SpecialKey
ESC :: SpecialKey

-- | This function takes a variable of type <a>Proc_Bool</a> and a
--   <a>Key</a>, and sets the variable to <a>true</a> if the key pressed is
--   the given <a>Key</a>. Otherwise, the variable is set to <a>false</a>.
matchKey :: (ProcMonad m, Monad (m KeyPressed)) => Var Proc_Bool -> Key -> m KeyPressed ()

-- | Frames since the beginning of the script execution.
frameCount :: (ProcMonad m, Monad (m c)) => m c Proc_Int

-- | Approximate number of frames per second.
getFrameRate :: (ProcMonad m, Monad (m c)) => m c Proc_Int

-- | Types in this instance form a monad when they are applied to a context
--   <tt>c</tt>. Then, they are used to write Processing code.
class ProcMonad m
writeComment :: ProcMonad m => Text -> m c ()
iff :: ProcMonad m => Proc_Bool -> m c a -> m c b -> m c ()
instance Drawing MouseReleased
instance Drawing MouseClicked
instance Drawing Draw
instance Drawing Setup


-- | Code optimization module.
module Graphics.Web.Processing.Optimize

-- | Optimization by substitution. It looks for commonly repeated
--   operations and create variables for them so they are only calculated
--   once.
--   
--   This optimization is applied automatically when using
--   <tt>execScriptM</tt>.
optimizeBySubstitution :: ProcScript -> ProcScript


-- | Collection of types.
module Graphics.Web.Processing.Core.Types

-- | A complete Processing script.
--   
--   It consists in several parts, most of them optional.
--   
--   <ul>
--   <li><a>Preamble</a>: Usually the place where variables are
--   initialized.</li>
--   <li><a>Setup</a>: After running the code in the preamble, the code in
--   this part is executed once.</li>
--   <li><a>Draw</a>: After the setup, this part of the code is executed in
--   loops over and over again.</li>
--   <li><a>MouseClicked</a>: Each time the user clicks, the code here is
--   executed once.</li>
--   </ul>
--   
--   To generate each part of the code, use the <tt>ProcM</tt> monad and
--   the functions from the <a>Graphics.Web.Processing.Interface</a>
--   module. Then, run <tt>runProcM</tt> or <tt>execProcM</tt> to get the
--   code result.
data ProcScript
ProcScript :: ProcCode Preamble -> ProcCode Setup -> Maybe (ProcCode Draw) -> Maybe (ProcCode MouseClicked) -> Maybe (ProcCode MouseReleased) -> Maybe (ProcCode KeyPressed) -> ProcScript
proc_preamble :: ProcScript -> ProcCode Preamble
proc_setup :: ProcScript -> ProcCode Setup
proc_draw :: ProcScript -> Maybe (ProcCode Draw)
proc_mouseClicked :: ProcScript -> Maybe (ProcCode MouseClicked)
proc_mouseReleased :: ProcScript -> Maybe (ProcCode MouseReleased)
proc_keyPressed :: ProcScript -> Maybe (ProcCode KeyPressed)

-- | Empty script.
emptyScript :: ProcScript

-- | Render a script as a lazy <a>Text</a>.
renderScript :: ProcScript -> Text

-- | Render a script using <a>renderScript</a> and write it directly in a
--   file.
renderFile :: FilePath -> ProcScript -> IO ()

-- | A piece of Processing code. The type parameter indicates what the
--   context of the code is. This context will allow or disallow the use of
--   certain commands.
data ProcCode c

-- | The <i>preamble</i> is the code that is executed at the beginning of
--   the script.
data Preamble
Preamble :: Preamble

-- | In the <i>setup</i> part, settings like <i>size</i> or <i>frame
--   rate</i> are supplied.
data Setup
Setup :: Setup

-- | The drawing loop.
data Draw
Draw :: Draw

-- | Code that is executed when the mouse is clicked.
data MouseClicked
MouseClicked :: MouseClicked

-- | Code that is executed when the mouse is released.
data MouseReleased
MouseReleased :: MouseReleased

-- | Code executed when a key is pressed.
data KeyPressed
KeyPressed :: KeyPressed

-- | Class of Processing value types (<tt>Proc_*</tt> types).
--   
--   <tt>Proc_*</tt> types are types from the world of Processing. Some of
--   them are similar to Haskell types, like <a>Proc_Bool</a> and
--   <a>Bool</a>. However, they are not equal. <tt>Proc_*</tt> types are
--   instance of <a>Eq</a>. However, you should instead use methods from
--   analog <a>Proc_Eq</a> class. <tt>Proc_*</tt> types contain expressions
--   instead of values. Think of <tt>2+2</tt> instead of <tt>4</tt>. Under
--   this situation, <tt>2+2 /= 3+1</tt>, since they are different
--   expressions, even if they evaluate to the same value. Actually, you
--   will get <a>True</a> from the evaluation of <tt>2+2 == 3+1</tt>, since
--   the library is smart enough to figure out they are the same value.
--   But, please, don't rely on this. Use the <a>Proc_Eq</a> and
--   <a>Proc_Ord</a> classes instead. They return Processing boolean
--   expressions instead of <a>Bool</a> values. Anyway, the types of the
--   library will try to force you to use <tt>Proc_*</tt> types everywhere.
--   
--   The reason this library stores expressions instead of values is that
--   it needs to handle things like <tt>2+x</tt>, where <tt>x</tt> is an
--   unknown value. However, an effort is done to ensure that each
--   expression is reduced to its minimum extension.
class ProcType a

-- | Boolean values.
data Proc_Bool

-- | Value of <a>True</a>.
true :: Proc_Bool

-- | Value of <a>False</a>.
false :: Proc_Bool

-- | Cast a <a>Bool</a> value.
fromBool :: Bool -> Proc_Bool

-- | Negation.
pnot :: Proc_Bool -> Proc_Bool

-- | Disjunction.
(#||) :: Proc_Bool -> Proc_Bool -> Proc_Bool

-- | Conjunction.
(#&&) :: Proc_Bool -> Proc_Bool -> Proc_Bool

-- | Integer numbers.
data Proc_Int

-- | Cast an <a>Int</a> value.
fromInt :: Int -> Proc_Int

-- | Cast a <a>Proc_Int</a> to a <a>Proc_Float</a>.
intToFloat :: Proc_Int -> Proc_Float

-- | Floating point numbers. The provided <a>Eq</a> instance checks the
--   equality of the internal expression, not the value.
data Proc_Float

-- | Cast a <a>Float</a> value.
fromFloat :: Float -> Proc_Float

-- | Calculates the <a>floor</a> of a <a>Proc_Float</a>.
pfloor :: Proc_Float -> Proc_Int

-- | Type of characters.
data Proc_Char

-- | Cast a <a>Char</a> value.
fromChar :: Char -> Proc_Char

-- | Type of textual values.
data Proc_Text

-- | Cast a strict <a>Text</a> value.
fromStText :: Text -> Proc_Text

-- | Type of images.
data Proc_Image

-- | <a>Eq</a> class for <tt>Proc_*</tt> values.
class Proc_Eq a where x #== y = pnot $ x #/= y x #/= y = pnot $ x #== y
(#==) :: Proc_Eq a => a -> a -> Proc_Bool
(#/=) :: Proc_Eq a => a -> a -> Proc_Bool

-- | <a>Ord</a> class for <tt>Proc_*</tt> values.
class Proc_Ord a
(#<=) :: Proc_Ord a => a -> a -> Proc_Bool
(#<) :: Proc_Ord a => a -> a -> Proc_Bool
(#>=) :: Proc_Ord a => a -> a -> Proc_Bool
(#>) :: Proc_Ord a => a -> a -> Proc_Bool

-- | Conditional value.
if_ :: ProcType a => Proc_Bool -> a -> a -> a


-- | The <i>basic</i> interface is the closest to the original. Although it
--   contains some variations too.
--   
--   For several reasons, it is recommended to use the <i>mid</i> interface
--   instead, which can be found in the <a>Graphics.Web.Processing.Mid</a>
--   module.
module Graphics.Web.Processing.Basic

-- | Processing script producer monad. The context <tt>c</tt> indicates the
--   context of the underlying <a>ProcCode</a>. This context restricts the
--   use of certain commands only to places where they are expected.
--   
--   The commands that you can run under this monad are mostly defined in
--   <a>Graphics.Web.Processing.Interface</a>.
--   
--   Once you have all the commands you want, use <a>runProcM</a> or
--   <a>execProcM</a> to generate the corresponding Processing code under
--   the <a>ProcCode</a> type.
data ProcM c a

-- | Generate Processing code using the <a>ProcM</a> monad. The code output
--   is reduced.
runProcM :: ProcM c a -> (a, ProcCode c)

-- | Generate Processing code using the <a>ProcM</a> monad, discarding the
--   final value.
--   
--   <pre>
--   execProcM = snd . runProcM
--   </pre>
execProcM :: ProcM c a -> ProcCode c


-- | Processing scripting, <i>mid</i> interface. Unlike the <i>basic</i>
--   interface (see <a>Graphics.Web.Processing.Basic</a>) the script is
--   more guided by the types. However, the output is less predictable,
--   since it does some tricks in order to obtain semantics that are more
--   coherent with Haskell. The difference is small, but let's say that
--   this module has more freedom writing the output code. It also applies
--   code optimizations, so the output code may look different (see
--   <a>execScriptM</a> and <a>Graphics.Web.Processing.Optimize</a>).
--   
--   <i>How to work with it?</i>
--   
--   Everything is done within the <a>ScriptM</a> monad, a state monad that
--   controls the entire script, including the preamble, draw loop, setup,
--   etc. The interaction with the different parts of the script is done
--   via <i>events</i> (see <a>EventM</a>). For example, the <a>Draw</a>
--   event controls the draw loop.
--   
--   <pre>
--   mouse :: ScriptM Preamble ()
--   mouse = do
--     on Setup $ do
--        size screenWidth screenHeight
--        fill $ Color 255 255 255 255
--     on Draw  $ do
--        background $ Color 0 0 0 255
--        p &lt;- getMousePoint
--        circle p 10
--   </pre>
--   
--   Note that to make it work, the context of the script <i>must</i> be
--   <a>Preamble</a>.
--   
--   Interaction with variables is done via the <a>ProcVarMonad</a> class.
--   This class defines methods to interact with variables in both the
--   <a>ScriptM</a> monad and the <a>EventM</a> monad. To store custom
--   types in variables, see the
--   <a>Graphics.Web.Processing.Mid.CustomVar</a> module.
--   
--   Once your script is complete, use <a>execScriptM</a> to get the result
--   code.
module Graphics.Web.Processing.Mid

-- | Context of an event. The context determines which functions can be
--   used. <a>Preamble</a> is not an instance of <a>Context</a> to avoid
--   using <a>Preamble</a> as an event (see <a>on</a>).
class Context c

-- | Monad of events. Use <a>on</a> to insert an event in a script
--   (<a>ScriptM</a>). To write the event code, use the functions in
--   <a>Graphics.Web.Processing.Core.Interface</a>, since <a>EventM</a> is
--   an instance of <a>ProcMonad</a>.
data EventM c a

-- | Scripter monad. This monad is where Processing code is written.
--   Because of some implementation details, <a>ScriptM</a> has a context
--   <tt>c</tt>. However, this context is <i>always</i> <a>Preamble</a>.
data ScriptM c a

-- | Set an event. Different events are specified by the instances of the
--   <a>Context</a> class.
--   
--   For example, the following code sets the <a>fill</a> pattern in the
--   setup event (the event that is called once at the beginning of the
--   execution).
--   
--   <pre>
--   on Setup $ fill $ Color 0 0 0 255
--   </pre>
on :: Context c => c -> EventM c () -> ScriptM Preamble ()

-- | Execute the scripter monad to get the full Processing script. Use
--   <a>renderScript</a> or <a>renderFile</a> to render it.
--   
--   After generating the script, the output code is optimized using
--   <a>optimizeBySubstitution</a>.
execScriptM :: ScriptM Preamble () -> ProcScript

-- | Type of variables.
data Var a

-- | Get the name of a variable.
varName :: Var a -> Text

-- | Class of monads where variables can be set in a natural way (similar
--   to <tt>IORef</tt>). Instances of this class behave in a proper way,
--   without the weird behavior of the original <a>readVar</a>.
class ProcMonad m => ProcVarMonad m
newVar :: (ProcVarMonad m, ProcType a) => a -> m Preamble (Var a)
readVar :: (ProcVarMonad m, ProcType a) => Var a -> m c a
writeVar :: (ProcVarMonad m, ProcType a) => Var a -> a -> m c ()
instance ProcVarMonad EventM
instance ProcVarMonad ScriptM
instance Context KeyPressed
instance Context MouseReleased
instance Context MouseClicked
instance Context Draw
instance Context Setup
instance ProcMonad ScriptM
instance Monad (ScriptM c)
instance Applicative (ScriptM c)
instance Functor (ScriptM c)
instance ProcMonad EventM
instance Monad (EventM c)
instance Applicative (EventM c)
instance Functor (EventM c)


-- | This module re-exports the <i>mid</i> interface to <i>processing</i>.
module Graphics.Web.Processing


-- | This module implements variables which may contain values from types
--   different from the native types (<tt>Proc_*</tt> types).
--   
--   To make a type available to custom variables, it needs to be
--   instantiated in the <a>CustomValue</a> class, which is subclass of the
--   <a>VarLength</a> class. These instances are derivables using the
--   <tt>DeriveGeneric</tt> extension. Things you need are: enable the
--   <tt>DeriveGeneric</tt> language extension, import <a>GHC.Generics</a>,
--   derive a <a>Generic</a> instance of your type and then write the
--   following instances (where <tt>Foo</tt> is any type of interest):
--   
--   <pre>
--   instance VarLength Foo
--   instance CustomValue Foo
--   </pre>
--   
--   Note that <tt>Foo</tt> must be made from other types that are
--   instances of <a>CustomValue</a>. Also, note that instances of
--   <a>VarLength</a> or <a>CustomValue</a> can <i>not</i> be recursive or
--   sum types. An example:
--   
--   <pre>
--   {-# LANGUAGE DeriveGeneric #-}
--   
--   import Graphics.Web.Processing.Mid
--   import Graphics.Web.Processing.Mid.CustomVar
--   import GHC.Generics
--   
--   data Point = Point Proc_Float Proc_Float
--                  deriving Generic
--   
--   instance VarLength Point
--   instance CustomValue Point
--   </pre>
--   
--   Types instance of the <a>CustomValue</a> class can be contained by a
--   special type of variables, called <a>CustomVar</a> (Custom Variable).
--   Functions for custom variables are equal to the function for regular
--   variables, except that they all end in <tt>C</tt>. For example,
--   <a>newVar</a> is called <a>newVarC</a> for custom variables.
--   
--   The dependency of this module in several language extensions was the
--   reason to make it separate from the rest of the <i>mid</i> interface
--   where it belongs to. Somehow, it forces the user to use
--   <tt>DeriveGeneric</tt> and import <a>GHC.Generics</a> to do something
--   useful with it (more than use custom variables for tuples).
module Graphics.Web.Processing.Mid.CustomVar

-- | Variable with custom values.
data CustomVar a

-- | Typeclass of values that can be stored in several native variables
--   (<a>Var</a>).
class VarLength a where varLength _ = 1
varLength :: VarLength a => a -> Int

-- | Typeclass of custom values, which can be stored in custom variables
--   (<a>CustomVar</a>).
class VarLength a => CustomValue a where newVarC x = liftM castCVar $ gnewVarC (from x) readVarC v = liftM to $ greadVarC (castCVar v) writeVarC v x = gwriteVarC (castCVar v) (from x)
newVarC :: (CustomValue a, Monad (m Preamble), ProcVarMonad m) => a -> m Preamble (CustomVar a)
readVarC :: (CustomValue a, Monad (m c), ProcVarMonad m) => CustomVar a -> m c a
writeVarC :: (CustomValue a, Monad (m c), ProcVarMonad m) => CustomVar a -> a -> m c ()
instance Generic (CustomVar a)
instance Datatype D1CustomVar
instance Constructor C1_0CustomVar
instance (CustomValue a, CustomValue b, CustomValue c) => CustomValue (a, b, c)
instance (VarLength a, VarLength b, VarLength c) => VarLength (a, b, c)
instance (CustomValue a, CustomValue b) => CustomValue (a, b)
instance (VarLength a, VarLength b) => VarLength (a, b)
instance CustomValue a => GCustomValue (K1 i a)
instance GCustomValue a => GCustomValue (M1 i c a)
instance GCustomValue (a :+: b)
instance (GVarLength a, GCustomValue a, GCustomValue b) => GCustomValue (a :*: b)
instance VarLength a => GVarLength (K1 i a)
instance GVarLength a => GVarLength (M1 i c a)
instance GVarLength (a :+: b)
instance (GVarLength a, GVarLength b) => GVarLength (a :*: b)
instance GVarLength U1
instance VarLength Proc_Char
instance VarLength Proc_Image
instance VarLength Proc_Text
instance VarLength Proc_Float
instance VarLength Proc_Int
instance VarLength Proc_Bool
instance CustomValue Proc_Char
instance CustomValue Proc_Image
instance CustomValue Proc_Text
instance CustomValue Proc_Float
instance CustomValue Proc_Int
instance CustomValue Proc_Bool


-- | A <a>Monoid</a> models figures in the plane. Then, figures are
--   displayed or animated using a Processing script.
--   
--   For example, this expression represents a circle of radius 10 centered
--   at the origin:
--   
--   <pre>
--   Circle (0,0) 10
--   </pre>
--   
--   The origin will be represented at the center of the screen. As opposed
--   to the other modules, <i>y</i>-coordinates increase to the top, while
--   <i>x</i>-coordinates still increase to the right.
--   
--   This is a red rectangle with top-left corner at the origin, 10 points
--   height and 10 points width:
--   
--   <pre>
--   FillColor (Color 255 0 0 255) $ Rectangle (0,0) 10 10
--   </pre>
--   
--   To display several figures together, use the <a>Monoid</a> instance:
--   
--   <pre>
--   Circle (0,0) 10 &lt;&gt; Circle (0,20) 10
--   </pre>
--   
--   If you just want to display this figure in the target canvas, use
--   <a>displayFigure</a>. If you want to animate it, use
--   <a>animateFigure</a>. Animations depend on the number of frames since
--   the beginning of the execution, instead of in the time spent.
--   
--   Once you have created a processing script (a value of type
--   <a>ProcScript</a>), use <a>renderFile</a> to write it to a file. See
--   also the <a>Graphics.Web.Processing.Html</a> module.
--   
--   The default filling color and line color are white and black
--   respectively. Use <a>FillColor</a> and <a>LineColor</a> to change
--   these colors. <a>Color</a>s are in RGBA format, meaning that they may
--   be transparent (with an alpha value of 0), opaque (with an alpha value
--   of 255) or something in between. Use a fully transparent color to
--   indicate that a Figure should not be filled.
--   
--   You can apply transformations like translation, rotation and scaling.
--   If <tt>p</tt> is a point and <tt>f</tt> a figure, <tt>Translate p
--   f</tt> will draw <tt>f</tt> with <tt>p</tt> as the origin of
--   coordinates. Rotations and scalings are always done in respect to the
--   origin, but note that you can modify where the origin is using
--   <a>Translate</a>.
module Graphics.Web.Processing.Simple

-- | RGBA colors. Values must be between 0 and 255, including in the alpha
--   channel.
data Color
Color :: Proc_Int -> Proc_Int -> Proc_Int -> Proc_Int -> Color

-- | Red channel.
redc :: Color -> Proc_Int

-- | Blue channel.
bluec :: Color -> Proc_Int

-- | Green channel.
greenc :: Color -> Proc_Int

-- | Alpha channel (opacity). 0 means transparent, and 255 opaque.
alphac :: Color -> Proc_Int

-- | A point as a pair of floating point numbers.
type Proc_Point = (Proc_Float, Proc_Float)

-- | A path is just a list of points.
type Path = [Proc_Point]

-- | The monoid of plane figures.
data Figure

-- | Line joining a list of points.
Line :: Path -> Figure

-- | Polygon given a list of vertex.
Polygon :: Path -> Figure

-- | Ellipse centered at the given point, with width and height also
--   specified.
Ellipse :: Proc_Point -> Proc_Float -> Proc_Float -> Figure

-- | Circle centered at the given point and with the specified radius.
Circle :: Proc_Point -> Proc_Float -> Figure

-- | Arc. The arc is drawn following the line of an ellipse between two
--   angles. The first argument is the center of the ellipse. The next two
--   arguments are the width and height of the ellipse. The last two
--   arguments are the initial and end angles of the arc.
Arc :: Proc_Point -> Proc_Float -> Proc_Float -> Proc_Float -> Proc_Float -> Figure

-- | Rectangle such that the top-left corner is at the specified point, and
--   its width and height are specified by the other two arguments.
Rectangle :: Proc_Point -> Proc_Float -> Proc_Float -> Figure

-- | Bezier curve. First and last arguments are the initial and end points
--   of the curve. The other points are control points.
Bezier :: Proc_Point -> Proc_Point -> Proc_Point -> Proc_Point -> Figure

-- | Text.
Text :: Proc_Point -> Proc_Text -> Figure

-- | Set the line color of a figure.
LineColor :: Color -> Figure -> Figure

-- | Set the filling color of a figure.
FillColor :: Color -> Figure -> Figure

-- | Translate a figure in the direction of a vector.
Translate :: Proc_Point -> Figure -> Figure

-- | Rotate a figure by the given angle in radians.
Rotate :: Proc_Float -> Figure -> Figure

-- | Scale a figure by the given x and y factors.
Scale :: Proc_Float -> Proc_Float -> Figure -> Figure

-- | List of figures.
Figures :: [Figure] -> Figure

-- | Display a figure using a Processing script.
displayFigure :: Maybe Int -> Maybe Int -> Color -> Figure -> ProcScript

-- | Create a Processing animation from a <a>Figure</a>-valued function.
animateFigure :: Maybe Int -> Maybe Int -> Int -> Color -> (Proc_Int -> Figure) -> ProcScript

-- | Framework to create interactive scripts.
--   
--   Note that is required for the state to be an instance of
--   <a>CustomValue</a>. More info on how to instantiate a type in the
--   <a>CustomValue</a> class in the
--   <a>Graphics.Web.Processing.Mid.CustomVar</a> module.
interactiveFigure :: CustomValue w => Maybe Int -> Maybe Int -> Int -> w -> (w -> Figure) -> (w -> Color) -> (Proc_Int -> w -> w) -> (Proc_Point -> w -> w) -> [(Key, w -> w)] -> ProcScript

-- | Keyboard keys recognized by Processing.
data Key
CharKey :: Char -> Key
SpecialKey :: SpecialKey -> Key
ArrowKey :: ArrowKey -> Key
ModKey :: KeyModifier -> Key -> Key

-- | Arrow keys.
data ArrowKey
UP :: ArrowKey
DOWN :: ArrowKey
LEFT :: ArrowKey
RIGHT :: ArrowKey

-- | Key modifiers.
data KeyModifier
ALT :: KeyModifier
CONTROL :: KeyModifier
SHIFT :: KeyModifier

-- | Special keys.
data SpecialKey
BACKSPACE :: SpecialKey
TAB :: SpecialKey
ENTER :: SpecialKey
RETURN :: SpecialKey
ESC :: SpecialKey
instance Monoid Figure


-- | Once created, processing scripts can be included in HTML canvas. To be
--   able to reproduce the animation, you must import the
--   <i>processing.js</i> library, downloadable from
--   <a>http://processingjs.org/download</a> (do not import it from the
--   original link, download it and use your own copy). To import
--   <i>processing.js</i>, use a <tt>script</tt> tag.
--   
--   <pre>
--   &lt;script src="processing.js"&gt;&lt;/script&gt;
--   </pre>
--   
--   See <a>importScript</a>.
--   
--   <i>Note from the author: I didn't manage to run a processing animation
--   locally,</i> <i>so you may have the same issue. Once I uploaded them
--   to my server, they worked</i> <i>just fine.</i>
module Graphics.Web.Processing.Html

-- | Create a canvas element which contain a Processing animation. The
--   output is of the following form:
--   
--   <pre>
--   &lt;canvas data-processing-sources="specified path"&gt;&lt;/canvas&gt;
--   </pre>
procCanvas :: FilePath -> Html

-- | Create the following HTML element:
--   
--   <pre>
--   &lt;script src="specified path"&gt;&lt;/script&gt;
--   </pre>
--   
--   Use it to import the <i>processing.js</i> script, inside the
--   <tt>head</tt> tag.
importScript :: FilePath -> Html

-- | Default template for visualizing Processing scripts in HTML.
defaultHtml :: FilePath -> FilePath -> Text -> Html

-- | Write a Processing script and the HTML default template for it to
--   files, using <a>renderFile</a> and <a>defaultHtml</a>.
writeHtml :: FilePath -> FilePath -> Text -> FilePath -> ProcScript -> IO ()