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

-- | Painless 2D vector graphics, animations and simulations.
--   
--   Gloss hides the pain of drawing simple vector graphics behind a nice
--   data type and a few display functions. Gloss uses OpenGL under the
--   hood, but you won't need to worry about any of that. Get something
--   cool on the screen in under 10 minutes.
@package gloss
@version 1.7.8.3

module Graphics.Gloss.Data.Quad

-- | Represents a Quadrant in the 2D plane.
data Quad

-- | North West
NW :: Quad

-- | North East
NE :: Quad

-- | South West
SW :: Quad

-- | South East
SE :: Quad

-- | A list of all quadrants. Same as [NW .. SE].
allQuads :: [Quad]
instance Show Quad
instance Eq Quad
instance Enum Quad

module Graphics.Gloss.Data.Point

-- | A point on the x-y plane. Points can also be treated as
--   Vectors, so Graphics.Gloss.Data.Vector may also be
--   useful.
type Point = (Float, Float)

-- | Test whether a point lies within a rectangular box that is oriented on
--   the x-y plane. The points P1-P2 are opposing points of the box, but
--   need not be in a particular order.
--   
--   
--   P2 +-------+
--      |       |
--      | + P0  |
--      |       |
--      +-------+ P1
--   
pointInBox :: Point -> Point -> Point -> Bool
instance Num Point

-- | Geometric functions concerning angles. If not otherwise specified, all
--   angles are in radians.
module Graphics.Gloss.Geometry.Angle

-- | Convert degrees to radians
degToRad :: Float -> Float

-- | Convert radians to degrees
radToDeg :: Float -> Float

-- | Normalise an angle to be between 0 and 2*pi radians
normaliseAngle :: Float -> Float

-- | Geometric functions concerning vectors.
module Graphics.Gloss.Data.Vector

-- | A vector can be treated as a point, and vis-versa.
type Vector = Point

-- | The magnitude of a vector.
magV :: Vector -> Float

-- | The angle of this vector, relative to the +ve x-axis.
argV :: Vector -> Float

-- | The dot product of two vectors.
dotV :: Vector -> Vector -> Float

-- | The determinant of two vectors.
detV :: Vector -> Vector -> Float

-- | Multiply a vector by a scalar.
mulSV :: Float -> Vector -> Vector

-- | Rotate a vector by an angle (in radians). +ve angle is
--   counter-clockwise.
rotateV :: Float -> Vector -> Vector

-- | Compute the inner angle (in radians) between two vectors.
angleVV :: Vector -> Vector -> Float

-- | Normalise a vector, so it has a magnitude of 1.
normaliseV :: Vector -> Vector

-- | Produce a unit vector at a given angle relative to the +ve x-axis. The
--   provided angle is in radians.
unitVectorAtAngle :: Float -> Vector

-- | Geometric functions concerning lines and segments.
--   
--   A Line is taken to be infinite in length, while a
--   Seg is finite length line segment represented by its two
--   endpoints.
module Graphics.Gloss.Geometry.Line

-- | Check if line segment (P1-P2) clears a box (P3-P4) by being well
--   outside it.
segClearsBox :: Point -> Point -> Point -> Point -> Bool

-- | Given an infinite line which intersects P1 and P1,
--   return the point on that line that is closest to P3
closestPointOnLine :: Point -> Point -> Point -> Point

-- | Given an infinite line which intersects P1 and P2, let P4 be the point
--   on the line that is closest to P3.
--   
--   Return an indication of where on the line P4 is relative to P1 and P2.
--   
--   
--   if P4 == P1 then 0
--   if P4 == P2 then 1
--   if P4 is halfway between P1 and P2 then 0.5
--   
--   
--   
--      |
--     P1
--      | 
--   P4 +---- P3      
--      |
--     P2
--      |
--   
closestPointOnLineParam :: Point -> Point -> Point -> Float

-- | Given four points specifying two lines, get the point where the two
--   lines cross, if any. Note that the lines extend off to infinity, so
--   the intersection point might not line between either of the two pairs
--   of points.
--   
--   
--   \      /
--    P1  P4
--     \ /
--      +
--     / \
--    P3  P2
--   /     \
--   
intersectLineLine :: Point -> Point -> Point -> Point -> Maybe Point

-- | Get the point where a segment P1-P2 crosses an infinite line
--   P3-P4, if any.
intersectSegLine :: Point -> Point -> Point -> Point -> Maybe Point

-- | Get the point where a segment crosses a horizontal line, if any.
--   
--   
--   
--            + P1
--           /
--   -------+---------
--         /        y0
--     P2 +
--   
intersectSegHorzLine :: Point -> Point -> Float -> Maybe Point

-- | Get the point where a segment crosses a vertical line, if any.
--   
--   
--          |
--          |   + P1
--          | /
--          +
--        / |
--   P2 +   |
--          | x0
--   
intersectSegVertLine :: Point -> Point -> Float -> Maybe Point

-- | Get the point where a segment P1-P2 crosses another segement
--   P3-P4, if any.
intersectSegSeg :: Point -> Point -> Point -> Point -> Maybe Point

-- | Check if an arbitrary segment intersects a horizontal segment.
--   
--   
--                   + P2
--                  /
--   (xa, y3)  +---+----+ (xb, y3)
--                /
--            P1 +
--   
intersectSegHorzSeg :: Point -> Point -> Float -> Float -> Float -> Maybe Point

-- | Check if an arbitrary segment intersects a vertical segment.
--   
--   
--   (x3, yb) +
--            |   + P1
--            | /
--            +
--          / |
--     P2 +   |
--            + (x3, ya)
--   
intersectSegVertSeg :: Point -> Point -> Float -> Float -> Float -> Maybe Point

-- | Represents an integral rectangular area of the 2D plane. Using
--   Ints (instead of Floats) for the bounds means we can
--   safely compare extents for equality.
module Graphics.Gloss.Data.Extent

-- | A rectangular area of the 2D plane. We keep the type abstract to
--   ensure that invalid extents cannot be constructed.
data Extent

-- | An integral coordinate.
type Coord = (Int, Int)

-- | Construct an extent. The north value must be > south, and east >
--   west, else error.
makeExtent :: Int -> Int -> Int -> Int -> Extent

-- | Take the NSEW components of an extent.
takeExtent :: Extent -> (Int, Int, Int, Int)

-- | A square extent of a given size.
squareExtent :: Int -> Extent

-- | Get the width and height of an extent.
sizeOfExtent :: Extent -> (Int, Int)

-- | Check if an extent is a square with a width and height of 1.
isUnitExtent :: Extent -> Bool

-- | Check whether a coordinate lies inside an extent.
coordInExtent :: Extent -> Coord -> Bool

-- | Check whether a point lies inside an extent.
pointInExtent :: Extent -> Point -> Bool

-- | Get the coordinate that lies at the center of an extent.
centerCoordOfExtent :: Extent -> (Int, Int)

-- | Cut one quadrant out of an extent.
cutQuadOfExtent :: Quad -> Extent -> Extent

-- | Get the quadrant that this coordinate lies in, if any.
quadOfCoord :: Extent -> Coord -> Maybe Quad

-- | Constuct a path to a particular coordinate in an extent.
pathToCoord :: Extent -> Coord -> Maybe [Quad]

-- | If a line segment (P1-P2) intersects the outer edge of an extent then
--   return the intersection point, that is closest to P1, if any. If P1 is
--   inside the extent then Nothing.
--   
--   
--              P2
--             /
--       ----/-
--       | /  |
--       +    |
--      /------
--    / 
--   P1
--   
intersectSegExtent :: Point -> Point -> Extent -> Maybe Point

-- | Check whether a line segment's endpoints are inside an extent, or if
--   it intersects with the boundary.
touchesSegExtent :: Point -> Point -> Extent -> Bool
instance Eq Extent
instance Show Extent

-- | A QuadTree can be used to recursively divide up 2D space into
--   quadrants. The smallest division corresponds to an unit Extent,
--   so the total depth of the tree will depend on what sized Extent
--   you start with.
module Graphics.Gloss.Data.QuadTree

-- | The quad tree structure.
data QuadTree a

-- | An empty node.
TNil :: QuadTree a

-- | A leaf containint some value.
TLeaf :: a -> QuadTree a

-- | A node with four children.
TNode :: (QuadTree a) -> (QuadTree a) -> (QuadTree a) -> (QuadTree a) -> QuadTree a

-- | A TNil tree.
emptyTree :: QuadTree a

-- | A node with TNil. for all its branches.
emptyNode :: QuadTree a

-- | Get a quadrant from a node. If the tree does not have an outer node
--   then Nothing.
takeQuadOfTree :: Quad -> QuadTree a -> Maybe (QuadTree a)

-- | Apply a function to a quadrant of a node. If the tree does not have an
--   outer node then return the original tree.
liftToQuad :: Quad -> (QuadTree a -> QuadTree a) -> QuadTree a -> QuadTree a

-- | Insert a value into the tree at the position given by a path. If the
--   path intersects an existing TLeaf then return the original
--   tree.
insertByPath :: [Quad] -> a -> QuadTree a -> QuadTree a

-- | Insert a value into the node containing this coordinate. The node is
--   created at maximum depth, corresponding to an unit Extent.
insertByCoord :: Extent -> Coord -> a -> QuadTree a -> Maybe (QuadTree a)

-- | Lookup a node based on a path to it.
lookupNodeByPath :: [Quad] -> QuadTree a -> Maybe (QuadTree a)

-- | Lookup an element based given a path to it.
lookupByPath :: [Quad] -> QuadTree a -> Maybe a

-- | Lookup a node if a tree given a coordinate which it contains.
lookupByCoord :: Extent -> Coord -> QuadTree a -> Maybe a

-- | Flatten a QuadTree into a list of its contained values, with
--   coordinates.
flattenQuadTree :: Extent -> QuadTree a -> [(Coord, a)]

-- | Flatten a QuadTree into a list of its contained values, with
--   coordinates.
flattenQuadTreeWithExtents :: Extent -> QuadTree a -> [(Extent, a)]
instance Show a => Show (QuadTree a)

module Graphics.Gloss.Geometry

module Graphics.Gloss.Data.Display

-- | Describes how Gloss should display its output.
data Display

-- | Display in a window with the given name, size and position.
InWindow :: String -> (Int, Int) -> (Int, Int) -> Display

-- | Display full screen with a drawing area of the given size.
FullScreen :: (Int, Int) -> Display
instance Eq Display
instance Read Display
instance Show Display

-- | Predefined and custom colors.
module Graphics.Gloss.Data.Color

-- | An abstract color value. We keep the type abstract so we can be sure
--   that the components are in the required range. To make a custom color
--   use makeColor.
data Color

-- | Make a custom color. All components are clamped to the range [0..1].
makeColor :: Float -> Float -> Float -> Float -> Color

-- | Make a custom color. You promise that all components are clamped to
--   the range [0..1]
makeColor' :: Float -> Float -> Float -> Float -> Color

-- | Make a custom color. All components are clamped to the range [0..255].
makeColor8 :: Int -> Int -> Int -> Int -> Color

-- | Make a custom color. Components should be in the range [0..1] but this
--   is not checked.
rawColor :: Float -> Float -> Float -> Float -> Color

-- | Take the RGBA components of a color.
rgbaOfColor :: Color -> (Float, Float, Float, Float)

-- | Mix two colors with the given ratios.
mixColors :: Float -> Float -> Color -> Color -> Color

-- | Add RGB components of a color component-wise, then normalise them to
--   the highest resulting one. The alpha components are averaged.
addColors :: Color -> Color -> Color

-- | Make a dimmer version of a color, scaling towards black.
dim :: Color -> Color

-- | Make a brighter version of a color, scaling towards white.
bright :: Color -> Color

-- | Lighten a color, adding white.
light :: Color -> Color

-- | Darken a color, adding black.
dark :: Color -> Color

-- | A greyness of a given magnitude.
greyN :: Float -> Color
black :: Color
white :: Color
red :: Color
green :: Color
blue :: Color
yellow :: Color
cyan :: Color
magenta :: Color
rose :: Color
violet :: Color
azure :: Color
aquamarine :: Color
chartreuse :: Color
orange :: Color
instance Show Color
instance Eq Color
instance Num Color

-- | Data types for representing pictures.
module Graphics.Gloss.Data.Picture

-- | A point on the x-y plane. Points can also be treated as
--   Vectors, so Graphics.Gloss.Data.Vector may also be
--   useful.
type Point = (Float, Float)

-- | A vector can be treated as a point, and vis-versa.
type Vector = Point

-- | A path through the x-y plane.
type Path = [Point]

-- | A 2D picture
data Picture

-- | A blank picture, with nothing in it.
Blank :: Picture

-- | A convex polygon filled with a solid color.
Polygon :: Path -> Picture

-- | A line along an arbitrary path.
Line :: Path -> Picture

-- | A circle with the given radius.
Circle :: Float -> Picture

-- | A circle with the given thickness and radius. If the thickness is 0
--   then this is equivalent to Circle.
ThickCircle :: Float -> Float -> Picture

-- | A circular arc drawn counter-clockwise between two angles (in degrees)
--   at the given radius.
Arc :: Float -> Float -> Float -> Picture

-- | A circular arc drawn counter-clockwise between two angles (in
--   degrees), with the given radius and thickness. If the thickness is 0
--   then this is equivalent to Arc.
ThickArc :: Float -> Float -> Float -> Float -> Picture

-- | Some text to draw with a vector font.
Text :: String -> Picture

-- | A bitmap image with a width, height and some 32-bit RGBA bitmap data.
--   
--   The boolean flag controls whether Gloss should cache the data between
--   frames for speed. If you are programatically generating the image for
--   each frame then use False. If you have loaded it from a file
--   then use True.
Bitmap :: Int -> Int -> BitmapData -> Bool -> Picture

-- | A picture drawn with this color.
Color :: Color -> Picture -> Picture

-- | A picture translated by the given x and y coordinates.
Translate :: Float -> Float -> Picture -> Picture

-- | A picture rotated clockwise by the given angle (in degrees).
Rotate :: Float -> Picture -> Picture

-- | A picture scaled by the given x and y factors.
Scale :: Float -> Float -> Picture -> Picture

-- | A picture consisting of several others.
Pictures :: [Picture] -> Picture

-- | Abstract 32-bit RGBA bitmap data.
data BitmapData

-- | A blank picture, with nothing in it.
blank :: Picture

-- | A convex polygon filled with a solid color.
polygon :: Path -> Picture

-- | A line along an arbitrary path.
line :: Path -> Picture

-- | A circle with the given radius.
circle :: Float -> Picture

-- | A circle with the given thickness and radius. If the thickness is 0
--   then this is equivalent to Circle.
thickCircle :: Float -> Float -> Picture

-- | A circular arc drawn counter-clockwise between two angles (in degrees)
--   at the given radius.
arc :: Float -> Float -> Float -> Picture

-- | A circular arc drawn counter-clockwise between two angles (in
--   degrees), with the given radius and thickness. If the thickness is 0
--   then this is equivalent to Arc.
thickArc :: Float -> Float -> Float -> Float -> Picture

-- | Some text to draw with a vector font.
text :: String -> Picture

-- | A bitmap image with a width, height and a Vector holding the 32-bit
--   RGBA bitmap data.
--   
--   The boolean flag controls whether Gloss should cache the data between
--   frames for speed. If you are programatically generating the image for
--   each frame then use False. If you have loaded it from a file
--   then use True.
bitmap :: Int -> Int -> BitmapData -> Bool -> Picture

-- | A picture drawn with this color.
color :: Color -> Picture -> Picture

-- | A picture translated by the given x and y coordinates.
translate :: Float -> Float -> Picture -> Picture

-- | A picture rotated clockwise by the given angle (in degrees).
rotate :: Float -> Picture -> Picture

-- | A picture scaled by the given x and y factors.
scale :: Float -> Float -> Picture -> Picture

-- | A picture consisting of several others.
pictures :: [Picture] -> Picture

-- | A closed loop along a path.
lineLoop :: Path -> Picture

-- | A solid circle with the given radius.
circleSolid :: Float -> Picture

-- | A solid arc, drawn counter-clockwise between two angles at the given
--   radius.
arcSolid :: Float -> Float -> Float -> Picture

-- | A wireframe sector of a circle. An arc is draw counter-clockwise from
--   the first to the second angle at the given radius. Lines are drawn
--   from the origin to the ends of the arc.
sectorWire :: Float -> Float -> Float -> Picture

-- | A path representing a rectangle centered about the origin
rectanglePath :: Float -> Float -> Path

-- | A wireframe rectangle centered about the origin.
rectangleWire :: Float -> Float -> Picture

-- | A solid rectangle centered about the origin.
rectangleSolid :: Float -> Float -> Picture

-- | A path representing a rectangle in the y > 0 half of the x-y plane.
rectangleUpperPath :: Float -> Float -> Path

-- | A wireframe rectangle in the y > 0 half of the x-y plane.
rectangleUpperWire :: Float -> Float -> Picture

-- | A solid rectangle in the y > 0 half of the x-y plane.
rectangleUpperSolid :: Float -> Float -> Picture

-- | O(1). Use a ForeignPtr of RGBA data as a bitmap with the given
--   width and height.
bitmapOfForeignPtr :: Int -> Int -> ForeignPtr Word8 -> Bool -> Picture

-- | O(size). Copy a ByteString of RGBA data into a bitmap with the
--   given width and height.
--   
--   The boolean flag controls whether Gloss should cache the data between
--   frames for speed. If you are programatically generating the image for
--   each frame then use False. If you have loaded it from a file
--   then use True.
bitmapOfByteString :: Int -> Int -> ByteString -> Bool -> Picture

-- | O(size). Copy a BMP file into a bitmap.
bitmapOfBMP :: BMP -> Picture

-- | Load an uncompressed 24 or 32bit RGBA BMP file as a bitmap.
loadBMP :: FilePath -> IO Picture
instance Show Picture
instance Eq Picture
instance Monoid Picture

-- | Various ray casting algorithms.
module Graphics.Gloss.Algorithms.RayCast

-- | The quadtree contains cells of unit extent (NetHack style). Given a
--   line segement (P1-P2) through the tree, get the cell closest to P1
--   that intersects the segment, if any.
--   
--   TODO: This currently uses a naive algorithm. It just calls
--   traceSegIntoCellularQuadTree and sorts the results to get the
--   one closest to P1. It'd be better to do a proper walk over the tree in
--   the direction of the ray.
castSegIntoCellularQuadTree :: Point -> Point -> Extent -> QuadTree a -> Maybe (Point, Extent, a)

-- | The quadtree contains cells of unit extent (NetHack style). Given a
--   line segment (P1-P2) through the tree, return the list of cells that
--   intersect the segment.
traceSegIntoCellularQuadTree :: Point -> Point -> Extent -> QuadTree a -> [(Point, Extent, a)]

-- | Display mode is for drawing a static picture.
module Graphics.Gloss.Interface.Pure.Display

-- | Open a new window and display the given picture.
--   
--   Use the following commands once the window is open:
--   
--   
--   
- Quit - esc-key.
--   
- Move Viewport - left-click drag, arrow keys.
--   
- Rotate Viewport - right-click drag, control-left-click drag, or
--   home/end-keys.
--   
- Zoom Viewport - mouse wheel, or page up/down-keys.
--   
display :: Display -> Color -> Picture -> IO ()

-- | Display mode is for drawing a static picture.
module Graphics.Gloss.Interface.Pure.Animate

-- | Open a new window and display the given animation.
--   
--   Once the window is open you can use the same commands as with
--   display.
animate :: Display -> Color -> (Float -> Picture) -> IO ()

-- | Display mode is for drawing a static picture.
module Graphics.Gloss.Interface.IO.Animate

-- | Open a new window and display the given animation.
--   
--   Once the window is open you can use the same commands as with
--   display.
animateIO :: Display -> Color -> (Float -> IO Picture) -> IO ()

-- | Like animateIO but don't allow the display to be panned around.
animateFixedIO :: Display -> Color -> (Float -> IO Picture) -> IO ()

-- | Simulate mode is for producing an animation of some model who's
--   picture changes over finite time steps. The behavior of the model can
--   also depent on the current ViewPort.
module Graphics.Gloss.Interface.Pure.Simulate

-- | Run a finite-time-step simulation in a window. You decide how the
--   model is represented, how to convert the model to a picture, and how
--   to advance the model for each unit of time. This function does the
--   rest.
--   
--   Once the window is open you can use the same commands as with
--   display.
simulate :: Display -> Color -> Int -> model -> (model -> Picture) -> (ViewPort -> Float -> model -> model) -> IO ()
data ViewPort
ViewPort :: !(Float, Float) -> !Float -> !Float -> ViewPort

-- | Global translation.
viewPortTranslate :: ViewPort -> !(Float, Float)

-- | Global rotation (in degrees).
viewPortRotate :: ViewPort -> !Float

-- | Global scaling (of both x and y coordinates).
viewPortScale :: ViewPort -> !Float

-- | Simulate mode is for producing an animation of some model who's
--   picture changes over finite time steps. The behavior of the model can
--   also depent on the current ViewPort.
module Graphics.Gloss.Interface.IO.Simulate
simulateIO :: Display -> Color -> Int -> model -> (model -> IO Picture) -> (ViewPort -> Float -> model -> IO model) -> IO ()
data ViewPort
ViewPort :: !(Float, Float) -> !Float -> !Float -> ViewPort

-- | Global translation.
viewPortTranslate :: ViewPort -> !(Float, Float)

-- | Global rotation (in degrees).
viewPortRotate :: ViewPort -> !Float

-- | Global scaling (of both x and y coordinates).
viewPortScale :: ViewPort -> !Float

-- | This game mode lets you manage your own input. Pressing ESC will still
--   abort the program, but you don't get automatic pan and zoom controls
--   like with displayInWindow.
module Graphics.Gloss.Interface.Pure.Game

-- | Play a game in a window.
play :: Display -> Color -> Int -> world -> (world -> Picture) -> (Event -> world -> world) -> (Float -> world -> world) -> IO ()

-- | Possible input events.
data Event
EventKey :: Key -> KeyState -> Modifiers -> (Float, Float) -> Event
EventMotion :: (Float, Float) -> Event
data Key
Char :: Char -> Key
SpecialKey :: SpecialKey -> Key
MouseButton :: MouseButton -> Key
data SpecialKey
KeyUnknown :: SpecialKey
KeySpace :: SpecialKey
KeyEsc :: SpecialKey
KeyF1 :: SpecialKey
KeyF2 :: SpecialKey
KeyF3 :: SpecialKey
KeyF4 :: SpecialKey
KeyF5 :: SpecialKey
KeyF6 :: SpecialKey
KeyF7 :: SpecialKey
KeyF8 :: SpecialKey
KeyF9 :: SpecialKey
KeyF10 :: SpecialKey
KeyF11 :: SpecialKey
KeyF12 :: SpecialKey
KeyF13 :: SpecialKey
KeyF14 :: SpecialKey
KeyF15 :: SpecialKey
KeyF16 :: SpecialKey
KeyF17 :: SpecialKey
KeyF18 :: SpecialKey
KeyF19 :: SpecialKey
KeyF20 :: SpecialKey
KeyF21 :: SpecialKey
KeyF22 :: SpecialKey
KeyF23 :: SpecialKey
KeyF24 :: SpecialKey
KeyF25 :: SpecialKey
KeyUp :: SpecialKey
KeyDown :: SpecialKey
KeyLeft :: SpecialKey
KeyRight :: SpecialKey
KeyTab :: SpecialKey
KeyEnter :: SpecialKey
KeyBackspace :: SpecialKey
KeyInsert :: SpecialKey
KeyNumLock :: SpecialKey
KeyBegin :: SpecialKey
KeyDelete :: SpecialKey
KeyPageUp :: SpecialKey
KeyPageDown :: SpecialKey
KeyHome :: SpecialKey
KeyEnd :: SpecialKey
KeyPad0 :: SpecialKey
KeyPad1 :: SpecialKey
KeyPad2 :: SpecialKey
KeyPad3 :: SpecialKey
KeyPad4 :: SpecialKey
KeyPad5 :: SpecialKey
KeyPad6 :: SpecialKey
KeyPad7 :: SpecialKey
KeyPad8 :: SpecialKey
KeyPad9 :: SpecialKey
KeyPadDivide :: SpecialKey
KeyPadMultiply :: SpecialKey
KeyPadSubtract :: SpecialKey
KeyPadAdd :: SpecialKey
KeyPadDecimal :: SpecialKey
KeyPadEqual :: SpecialKey
KeyPadEnter :: SpecialKey
data MouseButton
LeftButton :: MouseButton
MiddleButton :: MouseButton
RightButton :: MouseButton
WheelUp :: MouseButton
WheelDown :: MouseButton
AdditionalButton :: Int -> MouseButton
data KeyState
Down :: KeyState
Up :: KeyState
data Modifiers
Modifiers :: KeyState -> KeyState -> KeyState -> Modifiers
shift :: Modifiers -> KeyState
ctrl :: Modifiers -> KeyState
alt :: Modifiers -> KeyState

-- | This game mode lets you manage your own input. Pressing ESC will still
--   abort the program, but you don't get automatic pan and zoom controls
--   like with displayInWindow.
module Graphics.Gloss.Interface.IO.Game

-- | Play a game in a window, using IO actions to build the pictures.
playIO :: Display -> Color -> Int -> world -> (world -> IO Picture) -> (Event -> world -> IO world) -> (Float -> world -> IO world) -> IO ()

-- | Possible input events.
data Event
EventKey :: Key -> KeyState -> Modifiers -> (Float, Float) -> Event
EventMotion :: (Float, Float) -> Event
data Key
Char :: Char -> Key
SpecialKey :: SpecialKey -> Key
MouseButton :: MouseButton -> Key
data SpecialKey
KeyUnknown :: SpecialKey
KeySpace :: SpecialKey
KeyEsc :: SpecialKey
KeyF1 :: SpecialKey
KeyF2 :: SpecialKey
KeyF3 :: SpecialKey
KeyF4 :: SpecialKey
KeyF5 :: SpecialKey
KeyF6 :: SpecialKey
KeyF7 :: SpecialKey
KeyF8 :: SpecialKey
KeyF9 :: SpecialKey
KeyF10 :: SpecialKey
KeyF11 :: SpecialKey
KeyF12 :: SpecialKey
KeyF13 :: SpecialKey
KeyF14 :: SpecialKey
KeyF15 :: SpecialKey
KeyF16 :: SpecialKey
KeyF17 :: SpecialKey
KeyF18 :: SpecialKey
KeyF19 :: SpecialKey
KeyF20 :: SpecialKey
KeyF21 :: SpecialKey
KeyF22 :: SpecialKey
KeyF23 :: SpecialKey
KeyF24 :: SpecialKey
KeyF25 :: SpecialKey
KeyUp :: SpecialKey
KeyDown :: SpecialKey
KeyLeft :: SpecialKey
KeyRight :: SpecialKey
KeyTab :: SpecialKey
KeyEnter :: SpecialKey
KeyBackspace :: SpecialKey
KeyInsert :: SpecialKey
KeyNumLock :: SpecialKey
KeyBegin :: SpecialKey
KeyDelete :: SpecialKey
KeyPageUp :: SpecialKey
KeyPageDown :: SpecialKey
KeyHome :: SpecialKey
KeyEnd :: SpecialKey
KeyPad0 :: SpecialKey
KeyPad1 :: SpecialKey
KeyPad2 :: SpecialKey
KeyPad3 :: SpecialKey
KeyPad4 :: SpecialKey
KeyPad5 :: SpecialKey
KeyPad6 :: SpecialKey
KeyPad7 :: SpecialKey
KeyPad8 :: SpecialKey
KeyPad9 :: SpecialKey
KeyPadDivide :: SpecialKey
KeyPadMultiply :: SpecialKey
KeyPadSubtract :: SpecialKey
KeyPadAdd :: SpecialKey
KeyPadDecimal :: SpecialKey
KeyPadEqual :: SpecialKey
KeyPadEnter :: SpecialKey
data MouseButton
LeftButton :: MouseButton
MiddleButton :: MouseButton
RightButton :: MouseButton
WheelUp :: MouseButton
WheelDown :: MouseButton
AdditionalButton :: Int -> MouseButton
data KeyState
Down :: KeyState
Up :: KeyState
data Modifiers
Modifiers :: KeyState -> KeyState -> KeyState -> Modifiers
shift :: Modifiers -> KeyState
ctrl :: Modifiers -> KeyState
alt :: Modifiers -> KeyState

-- | Gloss hides the pain of drawing simple vector graphics behind a nice
--   data type and a few display functions.
--   
--   Getting something on the screen is as easy as:
--   
--   
--   import Graphics.Gloss
--   main = display (InWindow "Nice Window" (200, 200) (10, 10)) white (Circle 80)
--   
--   
--   Once the window is open you can use the following:
--   
--   
--   
- Quit - esc-key.
--   
- Move Viewport - left-click drag, arrow keys.
--   
- Rotate Viewport - right-click drag, control-left-click drag, or
--   home/end-keys.
--   
- Zoom Viewport - mouse wheel, or page up/down-keys.
--   
--   
--   Animations can be constructed similarly using the animate.
--   
--   If you want to run a simulation based around finite time steps then
--   try simulate.
--   
--   If you want to manage your own key/mouse events then use play.
--   
--   Gloss uses OpenGL under the hood, but you don't have to worry about
--   any of that.
--   
--   Gloss programs should be compiled with -threaded, otherwise
--   the GHC runtime will limit the frame-rate to around 20Hz.
--   
--   
--   Release Notes:
--   
--   For 1.7.0:
--      * Tweaked circle level-of-detail reduction code.
--      * Increased frame rate cap to 100hz.
--      Thanks to Doug Burke
--      * Primitives for drawing arcs and sectors.
--      Thanks to Thomas DuBuisson
--      * IO versions of animate, simplate and play.
--   
--   For 1.6.0:
--      Thanks to Anthony Cowley
--      * Full screen display mode.
--   
--   For 1.5.0:
--      * O(1) Conversion of ForeignPtrs to bitmaps.
--      * An extra flag on the Bitmap constructor allows bitmaps to be cached
--        in texture memory between frames.
--   
--   For 1.4.0:
--      Thanks to Christiaan Baaij: 
--      * Refactoring of Gloss internals to support multiple window manager backends.
--      * Support for using GLFW as the window library instead of GLUT.
--        GLUT is still the default, but to use GLFW install gloss with:
--           cabal install gloss --flags="GLFW -GLUT"
--   
--   
--   For more information, check out http://gloss.ouroborus.net.
module Graphics.Gloss

-- | Describes how Gloss should display its output.
data Display

-- | Display in a window with the given name, size and position.
InWindow :: String -> (Int, Int) -> (Int, Int) -> Display

-- | Display full screen with a drawing area of the given size.
FullScreen :: (Int, Int) -> Display

-- | Open a new window and display the given picture.
--   
--   Use the following commands once the window is open:
--   
--   
--   
- Quit - esc-key.
--   
- Move Viewport - left-click drag, arrow keys.
--   
- Rotate Viewport - right-click drag, control-left-click drag, or
--   home/end-keys.
--   
- Zoom Viewport - mouse wheel, or page up/down-keys.
--   
display :: Display -> Color -> Picture -> IO ()

-- | Open a new window and display the given animation.
--   
--   Once the window is open you can use the same commands as with
--   display.
animate :: Display -> Color -> (Float -> Picture) -> IO ()

-- | Run a finite-time-step simulation in a window. You decide how the
--   model is represented, how to convert the model to a picture, and how
--   to advance the model for each unit of time. This function does the
--   rest.
--   
--   Once the window is open you can use the same commands as with
--   display.
simulate :: Display -> Color -> Int -> model -> (model -> Picture) -> (ViewPort -> Float -> model -> model) -> IO ()

-- | Play a game in a window.
play :: Display -> Color -> Int -> world -> (world -> Picture) -> (Event -> world -> world) -> (Float -> world -> world) -> IO ()
