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


-- | A declarative terminal user interface library
--   
@package brick
@version 0.1


-- | This module provides styles for borders as used in terminal
--   applications. Your mileage may vary on some of the fancier styles due
--   to varying support for some border characters in the fonts your users
--   may be using. Because of this, we provide the <a>ascii</a> style in
--   addition to the Unicode styles. The <a>unicode</a> style is also a
--   safe bet.
--   
--   To use these in your widgets, see <a>withBorderStyle</a>. By default,
--   widgets rendered without a specified border style use <a>unicode</a>
--   via the <a>Default</a> instance provided by <a>BorderStyle</a>.
module Brick.Widgets.Border.Style

-- | A border style for use in any widget that needs to render borders in a
--   consistent style.
data BorderStyle
BorderStyle :: Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> BorderStyle

-- | Top-left corner character
bsCornerTL :: BorderStyle -> Char

-- | Top-right corner character
bsCornerTR :: BorderStyle -> Char

-- | Bottom-right corner character
bsCornerBR :: BorderStyle -> Char

-- | Bottom-left corner character
bsCornerBL :: BorderStyle -> Char

-- | Full intersection (cross)
bsIntersectFull :: BorderStyle -> Char

-- | Left side of a horizontal border intersecting a vertical one
bsIntersectL :: BorderStyle -> Char

-- | Right side of a horizontal border intersecting a vertical one
bsIntersectR :: BorderStyle -> Char

-- | Top of a vertical border intersecting a horizontal one
bsIntersectT :: BorderStyle -> Char

-- | Bottom of a vertical border intersecting a horizontal one
bsIntersectB :: BorderStyle -> Char

-- | Horizontal border character
bsHorizontal :: BorderStyle -> Char

-- | Vertical border character
bsVertical :: BorderStyle -> Char

-- | Make a border style using the specified character everywhere.
borderStyleFromChar :: Char -> BorderStyle

-- | An ASCII border style which will work in any terminal.
ascii :: BorderStyle

-- | A unicode border style with real corner and intersection characters.
unicode :: BorderStyle

-- | A unicode border style in a bold typeface.
unicodeBold :: BorderStyle

-- | A unicode border style with rounded corners.
unicodeRounded :: BorderStyle
instance Show BorderStyle
instance Read BorderStyle
instance Default BorderStyle


-- | This module provides an API for "marking up" text with arbitrary
--   values. A piece of markup can then be converted to a list of pairs
--   representing the sequences of characters assigned the same markup
--   value.
--   
--   This interface is experimental. Don't use this for your full-file
--   syntax highlighter just yet!
module Data.Text.Markup

-- | Markup with metadata type <tt>a</tt> assigned to each character.
data Markup a

-- | Convert markup to a list of pairs in which each pair contains the
--   longest subsequence of characters having the same metadata.
markupToList :: Eq a => Markup a -> [(Text, a)]

-- | Set the metadata for a range of character positions in a piece of
--   markup. This is useful for, e.g., syntax highlighting.
markupSet :: Eq a => (Int, Int) -> a -> Markup a -> Markup a

-- | Convert a list of text and metadata pairs into markup.
fromList :: [(Text, a)] -> Markup a

-- | Build markup from text with the default metadata.
fromText :: Default a => Text -> Markup a

-- | Extract the text from markup, discarding the markup metadata.
toText :: Eq a => Markup a -> Text

-- | Build a piece of markup; assign the specified metadata to every
--   character in the specified text.
(@@) :: Text -> a -> Markup a
instance Show a => Show (Markup a)
instance Default a => IsString (Markup a)
instance Monoid (Markup a)


-- | Basic types used by this library.
module Brick.Types

-- | A terminal screen location.
data Location
Location :: (Int, Int) -> Location

-- | (Column, Row)
loc :: Location -> (Int, Int)
locL :: Iso' Location (Int, Int)

-- | The class of types that behave like terminal locations.
class TerminalLocation a
columnL :: TerminalLocation a => Lens' a Int
column :: TerminalLocation a => a -> Int
rowL :: TerminalLocation a => Lens' a Int
row :: TerminalLocation a => a -> Int

-- | A cursor location. These are returned by the rendering process.
data CursorLocation
CursorLocation :: !Location -> !(Maybe Name) -> CursorLocation

-- | The location
cursorLocation :: CursorLocation -> !Location

-- | The name of the widget associated with the location
cursorLocationName :: CursorLocation -> !(Maybe Name)
cursorLocationL :: Lens' CursorLocation Location
cursorLocationNameL :: Lens' CursorLocation (Maybe Name)

-- | The class of types that provide some basic event-handling.
class HandleEvent a
handleEvent :: HandleEvent a => Event -> a -> a

-- | Names of things. Used to name cursor locations, widgets, and
--   viewports.
newtype Name
Name :: String -> Name

-- | A template haskell function to build lenses for a record type. This
--   function differs from the <a>makeLenses</a> function in that it does
--   not require the record fields to be prefixed with underscores and it
--   adds an <a>L</a> suffix to lens names to make it clear that they are
--   lenses.
suffixLenses :: Name -> DecsQ
instance TerminalLocation CursorLocation
instance Eq Name
instance Show Name
instance Ord Name
instance Show CursorLocation
instance Monoid Location
instance IsString Name
instance TerminalLocation Location
instance Field2 Location Location Int Int
instance Field1 Location Location Int Int
instance Show Location


-- | Utility functions.
module Brick.Util

-- | Given a minimum value and a maximum value, clamp a value to that range
--   (values less than the minimum map to the minimum and values greater
--   than the maximum map to the maximum).
--   
--   <pre>
--   &gt;&gt;&gt; clamp 1 10 11
--   10
--   
--   &gt;&gt;&gt; clamp 1 10 2
--   2
--   
--   &gt;&gt;&gt; clamp 5 10 1
--   5
--   </pre>
clamp :: Ord a => a -> a -> a -> a

-- | Build an attribute from a foreground color and a background color.
--   Intended to be used infix.
on :: Color -> Color -> Attr

-- | Create an attribute from the specified foreground color (the
--   background color is the "default").
fg :: Color -> Attr

-- | Create an attribute from the specified background color (the
--   background color is the "default").
bg :: Color -> Attr

-- | Add a <a>Location</a> offset to the specified <a>CursorLocation</a>.
clOffset :: CursorLocation -> Location -> CursorLocation


-- | This module provides a type and functions for handling focus rings of
--   widgets. Note that this interface is merely provided for managing the
--   focus state for a sequence of widget names; it does not do anything
--   beyond keep track of that.
--   
--   This interface is experimental.
module Brick.Focus

-- | A focus ring containing a sequence of widget names to focus and a
--   currently-focused widget name.
data FocusRing

-- | Construct a focus ring from the list of names.
focusRing :: [Name] -> FocusRing

-- | Advance focus to the next widget in the ring.
focusNext :: FocusRing -> FocusRing

-- | Advance focus to the previous widget in the ring.
focusPrev :: FocusRing -> FocusRing

-- | Get the currently-focused widget name from the ring. If the ring is
--   emtpy, return <a>Nothing</a>.
focusGetCurrent :: FocusRing -> Maybe Name

-- | Cursor selection convenience function for use as an
--   <a>appChooseCursor</a> value.
focusRingCursor :: (a -> FocusRing) -> a -> [CursorLocation] -> Maybe CursorLocation


-- | This module provides types and functions for managing an attribute map
--   which maps attribute names (<a>AttrName</a>) to attributes
--   (<a>Attr</a>). This module is designed to be used with the
--   <tt>OverloadedStrings</tt> language extension to permit easy
--   construction of <a>AttrName</a> values and you should also use
--   <a>mappend</a> (<a>&lt;&gt;</a>) to combine names.
--   
--   Attribute maps work by mapping hierarchical attribute names to
--   attributes and inheriting parent names' attributes when child names
--   specify partial attributes. Hierarchical names are created with
--   <a>mappend</a>:
--   
--   <pre>
--   let n = attrName "parent" &lt;&gt; attrName "child"
--   </pre>
--   
--   Attribute names are mapped to attributes, but some attributes may be
--   partial (specify only a foreground or background color). When
--   attribute name lookups occur, the attribute corresponding to a more
--   specific name ('parent &lt;&gt; child' as above) is sucessively merged
--   with the parent attribute (<tt>parent</tt> as above) all the way to
--   the "root" of the attribute map, the map's default attribute. In this
--   way, more specific attributes inherit what they don't specify from
--   more general attributes in the same hierarchy. This allows more
--   modularity and less repetition in specifying how elements of your user
--   interface take on different attributes.
module Brick.AttrMap

-- | An attribute map which maps <a>AttrName</a> values to <a>Attr</a>
--   values.
data AttrMap

-- | An attribute name. Attribute names are hierarchical; use
--   <a>mappend</a> (<a>&lt;&gt;</a>) to assemble them. Hierachy in an
--   attribute name is used to represent increasing levels of specificity
--   in referring to the attribute you want to use for a visual element,
--   with names to the left being general and names to the right being more
--   specific. For example:
--   
--   <pre>
--   "window" &lt;&gt; "border"
--   "window" &lt;&gt; "title"
--   "header" &lt;&gt; "clock" &lt;&gt; "seconds"
--   </pre>
data AttrName

-- | Create an attribute map.
attrMap :: Attr -> [(AttrName, Attr)] -> AttrMap

-- | Create an attribute map in which all lookups map to the same
--   attribute.
forceAttrMap :: Attr -> AttrMap

-- | Create an attribute name from a string.
attrName :: String -> AttrName

-- | Look up the specified attribute name in the map. Map lookups proceed
--   as follows. If the attribute map is forcing all lookups to a specific
--   attribute, that attribute is returned. If the attribute name is empty,
--   the map's default attribute is returned. If the attribute name is
--   non-empty, very subsequence of names from the specified name are used
--   to perform a lookup, and the results are combined as in
--   <a>mergeWithDefault</a>, with more specific results taking precedence
--   over less specific ones.
--   
--   For example:
--   
--   <pre>
--   attrMapLookup ("foo" &lt;&gt; "bar") (attrMap a []) == a
--   attrMapLookup ("foo" &lt;&gt; "bar") (attrMap (bg blue) [("foo" &lt;&gt; "bar", fg red)]) == red `on` blue
--   attrMapLookup ("foo" &lt;&gt; "bar") (attrMap (bg blue) [("foo" &lt;&gt; "bar", red <tt>on</tt> cyan)]) == red `on` cyan
--   attrMapLookup ("foo" &lt;&gt; "bar") (attrMap (bg blue) [("foo" &lt;&gt; "bar", fg red), ("foo", bg cyan)]) == red `on` cyan
--   attrMapLookup ("foo" &lt;&gt; "bar") (attrMap (bg blue) [("foo", fg red)]) == red `on` blue
--   </pre>
attrMapLookup :: AttrName -> AttrMap -> Attr

-- | Set the default attribute value in an attribute map.
setDefault :: Attr -> AttrMap -> AttrMap

-- | Insert a set of attribute mappings to an attribute map.
applyAttrMappings :: [(AttrName, Attr)] -> AttrMap -> AttrMap

-- | Given an attribute and a map, merge the attribute with the map's
--   default attribute. If the map is forcing all lookups to a specific
--   attribute, the forced attribute is returned without merging it with
--   the one specified here. Otherwise the attribute given here is merged
--   with the attribute map's default attribute in that any aspect of the
--   specified attribute that is not provided falls back to the map
--   default. For example,
--   
--   <pre>
--   mergeWithDefault (fg blue) $ attrMap (bg red) []
--   </pre>
--   
--   returns
--   
--   <pre>
--   blue `on` red
--   </pre>
mergeWithDefault :: Attr -> AttrMap -> Attr
instance Show AttrName
instance Eq AttrName
instance Ord AttrName
instance Show AttrMap
instance Default AttrMap
instance IsString AttrName
instance Monoid AttrName
instance Default AttrName


-- | This module provides the core widget combinators and rendering
--   routines. Everything this library does is in terms of these basic
--   primitives.
module Brick.Widgets.Core

-- | The type of widgets.
data Widget
Widget :: Size -> Size -> RenderM Result -> Widget

-- | This widget's horizontal growth policy
hSize :: Widget -> Size

-- | This widget's vertical growth policy
vSize :: Widget -> Size

-- | This widget's rendering function
render :: Widget -> RenderM Result

-- | Widget growth policies. These policies communicate to layout
--   algorithms how a widget uses space when being rendered. These policies
--   influence rendering order and space allocation in the box layout
--   algorithm.
data Size

-- | Fixed widgets take up the same amount of space no matter how much they
--   are given (non-greedy).
Fixed :: Size

-- | Greedy widgets take up all the space they are given.
Greedy :: Size

-- | The empty widget.
emptyWidget :: Widget

-- | Build a widget directly from a raw Vty image.
raw :: Image -> Widget

-- | Build a widget from a <a>Text</a> value. Behaves the same as
--   <a>str</a>.
txt :: Text -> Widget

-- | Build a widget from a <a>String</a>. Breaks newlines up and space-pads
--   short lines out to the length of the longest line.
str :: String -> Widget

-- | Fill all available space with the specified character. Grows both
--   horizontally and vertically.
fill :: Char -> Widget

-- | The type of padding.
data Padding

-- | Pad by the specified number of rows or columns.
Pad :: Int -> Padding

-- | Pad up to the number of available rows or columns.
Max :: Padding

-- | Pad the specified widget on the left.
padLeft :: Padding -> Widget -> Widget

-- | Pad the specified widget on the right.
padRight :: Padding -> Widget -> Widget

-- | Pad the specified widget on the top.
padTop :: Padding -> Widget -> Widget

-- | Pad the specified widget on the bottom.
padBottom :: Padding -> Widget -> Widget

-- | Pad a widget on the left and right.
padLeftRight :: Int -> Widget -> Widget

-- | Pad a widget on the top and bottom.
padTopBottom :: Int -> Widget -> Widget

-- | Pad a widget on all sides.
padAll :: Int -> Widget -> Widget

-- | Vertical box layout: put the specified widgets one above the other in
--   the specified order. Defers growth policies to the growth policies of
--   both widgets. This operator is a binary version of <a>vBox</a>.
(<=>) :: Widget -> Widget -> Widget

-- | Horizontal box layout: put the specified widgets next to each other in
--   the specified order. Defers growth policies to the growth policies of
--   both widgets. This operator is a binary version of <a>hBox</a>.
(<+>) :: Widget -> Widget -> Widget

-- | Horizontal box layout: put the specified widgets next to each other in
--   the specified order (leftmost first). Defers growth policies to the
--   growth policies of both widgets.
hBox :: [Widget] -> Widget

-- | Vertical box layout: put the specified widgets one above the other in
--   the specified order (uppermost first). Defers growth policies to the
--   growth policies of both widgets.
vBox :: [Widget] -> Widget

-- | Limit the space available to the specified widget to the specified
--   number of columns. This is important for constraining the horizontal
--   growth of otherwise-greedy widgets.
hLimit :: Int -> Widget -> Widget

-- | Limit the space available to the specified widget to the specified
--   number of rows. This is important for constraining the vertical growth
--   of otherwise-greedy widgets.
vLimit :: Int -> Widget -> Widget

-- | Update the attribute map while rendering the specified widget: set its
--   new default attribute to the one that we get by looking up the
--   specified attribute name in the map.
withDefAttr :: AttrName -> Widget -> Widget

-- | When drawing the specified widget, set the current attribute used for
--   drawing to the one with the specified name. Note that the widget may
--   use further calls to <a>withAttr</a> to override this; if you really
--   want to prevent that, use <a>forceAttr</a>. Attributes used this way
--   still get merged hierarchically and still fall back to the attribute
--   map's default attribute. If you want to change the default attribute,
--   use <a>withDefAttr</a>.
withAttr :: AttrName -> Widget -> Widget

-- | When rendering the specified widget, force all attribute lookups in
--   the attribute map to use the value currently assigned to the specified
--   attribute name.
forceAttr :: AttrName -> Widget -> Widget

-- | When rendering the specified widget, update the attribute map with the
--   specified transformation.
updateAttrMap :: (AttrMap -> AttrMap) -> Widget -> Widget

-- | When rendering the specified widget, use the specified border style
--   for any border rendering.
withBorderStyle :: BorderStyle -> Widget -> Widget

-- | When rendering the specified widget, also register a cursor
--   positioning request using the specified name and location.
showCursor :: Name -> Location -> Widget -> Widget

-- | Translate the specified widget by the specified offset amount.
translateBy :: Location -> Widget -> Widget

-- | Crop the specified widget on the left by the specified number of
--   columns.
cropLeftBy :: Int -> Widget -> Widget

-- | Crop the specified widget on the right by the specified number of
--   columns.
cropRightBy :: Int -> Widget -> Widget

-- | Crop the specified widget on the top by the specified number of rows.
cropTopBy :: Int -> Widget -> Widget

-- | Crop the specified widget on the bottom by the specified number of
--   rows.
cropBottomBy :: Int -> Widget -> Widget

-- | The type of viewports that indicates the direction(s) in which a
--   viewport is scrollable.
data ViewportType

-- | Viewports of this type are scrollable only vertically.
Vertical :: ViewportType

-- | Viewports of this type are scrollable only horizontally.
Horizontal :: ViewportType

-- | Viewports of this type are scrollable vertically and horizontally.
Both :: ViewportType

-- | Render the specified widget in a named viewport with the specified
--   type. This permits widgets to be scrolled without being
--   scrolling-aware. To make the most use of viewports, the specified
--   widget should use the <a>visible</a> combinator to make a "visibility
--   request". This viewport combinator will then translate the resulting
--   rendering to make the requested region visible. In addition, the
--   <a>EventM</a> monad provides primitives to scroll viewports created by
--   this function if <a>visible</a> is not what you want.
--   
--   If a viewport receives more than one visibility request, only the
--   first is honored. If a viewport receives more than one scrolling
--   request from <a>EventM</a>, all are honored in the order in which they
--   are received.
viewport :: Name -> ViewportType -> Widget -> Widget

-- | Request that the specified widget be made visible when it is rendered
--   inside a viewport. This permits widgets (whose sizes and positions
--   cannot be known due to being embedded in arbitrary layouts) to make a
--   request for a parent viewport to locate them and scroll enough to put
--   them in view. This, together with <a>viewport</a>, is what makes the
--   text editor and list widgets possible without making them deal with
--   the details of scrolling state management.
--   
--   This does nothing if not rendered in a viewport.
visible :: Widget -> Widget

-- | Similar to <a>visible</a>, request that a region (with the specified
--   <a>Location</a> as its origin and <a>DisplayRegion</a> as its size) be
--   made visible when it is rendered inside a viewport. The
--   <a>Location</a> is relative to the specified widget's upper-left
--   corner of (0, 0).
--   
--   This does nothing if not rendered in a viewport.
visibleRegion :: Location -> DisplayRegion -> Widget -> Widget

-- | The type of the rendering monad. This monad is used by the library's
--   rendering routines to manage rendering state and communicate rendering
--   parameters to widgets' rendering functions.
type RenderM a = ReaderT Context (State RenderState) a

-- | Get the current rendering context.
getContext :: RenderM Context

-- | Given an attribute name, obtain the attribute for the attribute name
--   by consulting the context's attribute map.
lookupAttrName :: AttrName -> RenderM Attr

-- | The rendering context. This tells widgets how to render: how much
--   space they have in which to render, which attribute they should use to
--   render, which bordring style should be used, and the attribute map
--   available for rendering.
data Context

-- | The rendering context's current drawing attribute.
attrL :: (Contravariant f, Functor f) => (Attr -> f Attr) -> Context -> f Context
availWidthL :: Lens' Context Int
availHeightL :: Lens' Context Int
ctxAttrMapL :: Lens' Context AttrMap
ctxAttrNameL :: Lens' Context AttrName
ctxBorderStyleL :: Lens' Context BorderStyle

-- | The type of result returned by a widget's rendering function. The
--   result provides the image, cursor positions, and visibility requests
--   that resulted from the rendering process.
data Result
Result :: Image -> [CursorLocation] -> [VisibilityRequest] -> Result

-- | The final rendered image for a widget
image :: Result -> Image

-- | The list of reported cursor positions for the application to choose
--   from
cursors :: Result -> [CursorLocation]

-- | The list of visibility requests made by widgets rendered while
--   rendering this one (used by viewports)
visibilityRequests :: Result -> [VisibilityRequest]
imageL :: Lens' Result Image
cursorsL :: Lens' Result [CursorLocation]
visibilityRequestsL :: Lens' Result [VisibilityRequest]
data VisibilityRequest
VR :: Location -> DisplayRegion -> VisibilityRequest
vrPosition :: VisibilityRequest -> Location
vrSize :: VisibilityRequest -> DisplayRegion
vrPositionL :: Lens' VisibilityRequest Location
vrSizeL :: Lens' VisibilityRequest DisplayRegion

-- | Add an offset to all cursor locations and visbility requests in the
--   specified rendering result. This function is critical for maintaining
--   correctness in the rendering results as they are processed
--   successively by box layouts and other wrapping combinators, since
--   calls to this function result in converting from widget-local
--   coordinates to (ultimately) terminal-global ones so they can be used
--   by other combinators. You should call this any time you render
--   something and then translate it or otherwise offset it from its
--   original origin.
addResultOffset :: Location -> Result -> Result

-- | After rendering the specified widget, crop its result image to the
--   dimensions in the rendering context.
cropToContext :: Widget -> Widget

-- | Scrolling direction.
data Direction

-- | Up/left
Up :: Direction

-- | Down/right
Down :: Direction

module Brick.Main

-- | The library application abstraction. Your application's operations are
--   represented here and passed to one of the various main functions in
--   this module. An application is in terms of an application state type
--   <tt>s</tt> and an application event type <tt>e</tt>. In the simplest
--   case <tt>e</tt> is vty's <a>Event</a> type, but you may define your
--   own event type, permitted that it has a constructor for wrapping Vty
--   events, so that Vty events can be handled by your event loop.
data App s e
App :: (s -> [Widget]) -> (s -> [CursorLocation] -> Maybe CursorLocation) -> (s -> e -> EventM (Next s)) -> (s -> EventM s) -> (s -> AttrMap) -> (Event -> e) -> App s e

-- | This function turns your application state into a list of widget
--   layers. The layers are listed topmost first.
appDraw :: App s e -> s -> [Widget]

-- | This function chooses which of the zero or more cursor locations
--   reported by the rendering process should be selected as the one to use
--   to place the cursor. If this returns <a>Nothing</a>, no cursor is
--   placed. The rationale here is that many widgets may request a cursor
--   placement but your application state is what you probably want to use
--   to decide which one wins.
appChooseCursor :: App s e -> s -> [CursorLocation] -> Maybe CursorLocation

-- | This function takes the current application state and an event and
--   returns an action to be taken and a corresponding transformed
--   application state. Possible options are <a>continue</a>,
--   <a>suspendAndResume</a>, and <a>halt</a>.
appHandleEvent :: App s e -> s -> e -> EventM (Next s)

-- | This function gets called once just prior to the first drawing of your
--   application. Here is where you can make initial scrolling requests,
--   for example.
appStartEvent :: App s e -> s -> EventM s

-- | The attribute map that should be used during rendering.
appAttrMap :: App s e -> s -> AttrMap

-- | The event constructor to use to wrap Vty events in your own event
--   type. For example, if the application's event type is <a>Event</a>,
--   this is just <a>id</a>.
appLiftVtyEvent :: App s e -> Event -> e

-- | The default main entry point which takes an application and an initial
--   state and returns the final state returned by a <a>halt</a> operation.
defaultMain :: App s Event -> s -> IO s

-- | The custom event loop entry point to use when the simpler ones don't
--   permit enough control.
customMain :: IO Vty -> Chan e -> App s e -> s -> IO s

-- | A simple main entry point which takes a widget and renders it. This
--   event loop terminates when the user presses any key, but terminal
--   resize events cause redraws.
simpleMain :: Widget -> IO ()

-- | An event-handling function which continues execution of the event loop
--   only when resize events occur; all other types of events trigger a
--   halt. This is a convenience function useful as an
--   <a>appHandleEvent</a> value for simple applications using the
--   <a>Event</a> type that do not need to get more sophisticated user
--   input.
resizeOrQuit :: s -> Event -> EventM (Next s)

-- | The monad in which event handlers run.
type EventM a = StateT EventState IO a

-- | The type of actions to take in an event handler.
data Next a

-- | Continue running the event loop with the specified application state.
continue :: s -> EventM (Next s)

-- | Halt the event loop and return the specified application state as the
--   final state value.
halt :: s -> EventM (Next s)

-- | Suspend the event loop, save the terminal state, and run the specified
--   action. When it returns an application state value, restore the
--   terminal state, redraw the application from the new state, and resume
--   the event loop.
suspendAndResume :: IO s -> EventM (Next s)

-- | Build a viewport scroller for the viewport with the specified name.
viewportScroll :: Name -> ViewportScroll

-- | A viewport scrolling handle for managing the scroll state of
--   viewports.
data ViewportScroll

-- | Scroll the viewport vertically by the specified number of rows or
--   columns depending on the orientation of the viewport.
vScrollBy :: ViewportScroll -> Int -> EventM ()

-- | Scroll the viewport vertically by one page in the specified direction.
vScrollPage :: ViewportScroll -> Direction -> EventM ()

-- | Scroll vertically to the beginning of the viewport.
vScrollToBeginning :: ViewportScroll -> EventM ()

-- | Scroll vertically to the end of the viewport.
vScrollToEnd :: ViewportScroll -> EventM ()

-- | Scroll the viewport horizontally by the specified number of rows or
--   columns depending on the orientation of the viewport.
hScrollBy :: ViewportScroll -> Int -> EventM ()

-- | Scroll the viewport horizontally by one page in the specified
--   direction.
hScrollPage :: ViewportScroll -> Direction -> EventM ()

-- | Scroll horizontally to the beginning of the viewport.
hScrollToBeginning :: ViewportScroll -> EventM ()

-- | Scroll horizontally to the end of the viewport.
hScrollToEnd :: ViewportScroll -> EventM ()

-- | Ignore all requested cursor positions returned by the rendering
--   process. This is a convenience function useful as an
--   <a>appChooseCursor</a> value when a simple application has no need to
--   position the cursor.
neverShowCursor :: s -> [CursorLocation] -> Maybe CursorLocation

-- | Always show the first cursor, if any, returned by the rendering
--   process. This is a convenience function useful as an
--   <a>appChooseCursor</a> value when a simple program has zero or more
--   widgets that advertise a cursor position.
showFirstCursor :: s -> [CursorLocation] -> Maybe CursorLocation

-- | Show the cursor with the specified name, if such a cursor location has
--   been reported.
showCursorNamed :: Name -> [CursorLocation] -> Maybe CursorLocation


-- | This module provides combinators for centering other widgets.
module Brick.Widgets.Center

-- | Center the specified widget horizontally. Consumes all available
--   horizontal space.
hCenter :: Widget -> Widget

-- | Center the specified widget horizontally. Consumes all available
--   horizontal space. Uses the specified character to fill in the space to
--   either side of the centered widget (defaults to space).
hCenterWith :: Maybe Char -> Widget -> Widget

-- | Center a widget vertically. Consumes all vertical space.
vCenter :: Widget -> Widget

-- | Center a widget vertically. Consumes all vertical space. Uses the
--   specified character to fill in the space above and below the centered
--   widget (defaults to space).
vCenterWith :: Maybe Char -> Widget -> Widget

-- | Center a widget both vertically and horizontally. Consumes all
--   available vertical and horizontal space.
center :: Widget -> Widget

-- | Center a widget both vertically and horizontally. Consumes all
--   available vertical and horizontal space. Uses the specified character
--   to fill in the space around the centered widget (defaults to space).
centerWith :: Maybe Char -> Widget -> Widget

-- | Center the widget horizontally and vertically about the specified
--   origin.
centerAbout :: Location -> Widget -> Widget


-- | This module provides an API for turning "markup" values into widgets.
--   This module uses the Data.Text.Markup interface in this package to
--   assign attributes to substrings in a text string; to manipulate markup
--   using (for example) syntax highlighters, see that module.
module Brick.Markup

-- | Markup with metadata type <tt>a</tt> assigned to each character.
data Markup a

-- | Build a widget from markup.
markup :: (Eq a, GetAttr a) => Markup a -> Widget

-- | Build a piece of markup from text with an assigned attribute name.
--   When the markup is rendered, the attribute name will be looked up in
--   the rendering context's <a>AttrMap</a> to determine the attribute to
--   use for this piece of text.
(@?) :: Text -> AttrName -> Markup AttrName

-- | A type class for types that provide access to an attribute in the
--   rendering monad. You probably won't need to instance this.
class GetAttr a
getAttr :: GetAttr a => a -> RenderM Attr
instance GetAttr AttrName
instance GetAttr Attr


-- | This module provides border widgets: vertical borders, horizontal
--   borders, and a box border wrapper widget. All functions in this module
--   use the rendering context's active <a>BorderStyle</a>; to change the
--   <a>BorderStyle</a>, use <a>withBorderStyle</a>.
module Brick.Widgets.Border

-- | Put a border around the specified widget.
border :: Widget -> Widget

-- | Put a border around the specified widget with the specified label
--   widget placed in the middle of the top horizontal border.
borderWithLabel :: Widget -> Widget -> Widget

-- | A horizontal border. Fills all horizontal space.
hBorder :: Widget

-- | A horizontal border with a label placed in the center of the border.
--   Fills all horizontal space.
hBorderWithLabel :: Widget -> Widget

-- | A vertical border. Fills all vertical space.
vBorder :: Widget

-- | Draw the specified border element using the active border style using
--   <a>borderAttr</a>.
borderElem :: (BorderStyle -> Char) -> Widget

-- | The top-level border attribute name.
borderAttr :: AttrName

-- | The vertical border attribute name.
vBorderAttr :: AttrName

-- | The horizontal border attribute name.
hBorderAttr :: AttrName

-- | The attribute used for horizontal border labels.
hBorderLabelAttr :: AttrName

-- | The attribute used for border box top-left corners.
tlCornerAttr :: AttrName

-- | The attribute used for border box top-right corners.
trCornerAttr :: AttrName

-- | The attribute used for border box bottom-left corners.
blCornerAttr :: AttrName

-- | The attribute used for border box bottom-right corners.
brCornerAttr :: AttrName


-- | This module provides a simple dialog widget. You get to pick the
--   dialog title, if any, as well as its body and buttons.
module Brick.Widgets.Dialog

-- | Dialogs present a window with a title (optional), a body, and buttons
--   (optional). They provide a <a>HandleEvent</a> instance that knows
--   about Tab and Shift-Tab for changing which button is active. Dialog
--   buttons are labeled with strings and map to values of type <tt>a</tt>,
--   which you choose.
--   
--   Dialogs handle the following events by default:
--   
--   <ul>
--   <li>Tab: selecte the next button</li>
--   <li>Shift-tab: select the previous button</li>
--   </ul>
data Dialog a

-- | The dialog title
dialogTitle :: Dialog a -> Maybe String

-- | The dialog name
dialogName :: Dialog a -> Name

-- | The dialog button labels and values
dialogButtons :: Dialog a -> [(String, a)]

-- | The currently selected dialog button index (if any)
dialogSelectedIndex :: Dialog a -> Maybe Int

-- | The maximum width of the dialog
dialogWidth :: Dialog a -> Int

-- | Create a dialog.
dialog :: Name -> Maybe String -> Maybe (Int, [(String, a)]) -> Int -> Dialog a

-- | Render a dialog with the specified body widget.
renderDialog :: Dialog a -> Widget -> Widget

-- | Obtain the value associated with the dialog's currently-selected
--   button, if any. This function is probably what you want when someone
--   presses <tt>Enter</tt> in a dialog.
dialogSelection :: Dialog a -> Maybe a

-- | The default attribute of the dialog
dialogAttr :: AttrName

-- | The default attribute for all dialog buttons
buttonAttr :: AttrName

-- | The attribute for the selected dialog button (extends
--   <a>dialogAttr</a>)
buttonSelectedAttr :: AttrName
dialogNameL :: Lens' (Dialog a_axsZ) Name
dialogButtonsL :: Lens (Dialog a_axsZ) (Dialog a_axtv) [(String, a_axsZ)] [(String, a_axtv)]
dialogSelectedIndexL :: Lens' (Dialog a_axsZ) (Maybe Int)
dialogWidthL :: Lens' (Dialog a_axsZ) Int
dialogTitleL :: Lens' (Dialog a_axsZ) (Maybe String)
instance HandleEvent (Dialog a)


-- | This module provides a basic single-line text editor widget. You'll
--   need to embed an <a>Editor</a> in your application state and transform
--   it with <a>handleEvent</a> when relevant events arrive. To get the
--   contents of the editor, just use <a>getEditContents</a>. To modify it,
--   use the <a>TextZipper</a> interface with <a>applyEdit</a>.
--   
--   The editor's <a>HandleEvent</a> instance handles a set of basic input
--   events that should suffice for most purposes; see the source for a
--   complete list.
module Brick.Widgets.Edit

-- | Editor state. Editors support the following events by default:
--   
--   <ul>
--   <li>Ctrl-a: go to beginning of line</li>
--   <li>Ctrl-e: go to end of line</li>
--   <li>Ctrl-d, Del: delete character at cursor position</li>
--   <li>Backspace: delete character prior to cursor position</li>
--   <li>Ctrl-k: delete all from cursor to end of line</li>
--   <li>Arrow keys: move cursor</li>
--   <li>Enter: break the current line at the cursor position</li>
--   </ul>
data Editor

-- | Construct an editor.
editor :: Name -> ([String] -> Widget) -> Maybe Int -> String -> Editor

-- | Get the contents of the editor.
getEditContents :: Editor -> [String]

-- | Apply an editing operation to the editor's contents. Bear in mind that
--   you should only apply zipper operations that operate on the current
--   line; the editor will only ever render the first line of text.
applyEdit :: (TextZipper String -> TextZipper String) -> Editor -> Editor
editContentsL :: Lens' Editor (TextZipper String)
editDrawContentsL :: Lens' Editor ([String] -> Widget)

-- | Turn an editor state value into a widget
renderEditor :: Editor -> Widget

-- | The attribute assigned to the editor
editAttr :: AttrName
instance HandleEvent Editor


-- | This module provides a scrollable list type and functions for
--   manipulating and rendering it.
module Brick.Widgets.List

-- | List state. Lists have an element type <tt>e</tt> that is the data
--   stored by the list. Lists handle the following events by default:
--   
--   <ul>
--   <li>Up/down arrow keys: move cursor of selected item</li>
--   </ul>
data List e

-- | Construct a list in terms of an element type <tt>e</tt>.
list :: Name -> (Bool -> e -> Widget) -> [e] -> List e

-- | Turn a list state value into a widget.
renderList :: List e -> Widget
listElementsL :: Lens' (List e_azAv) [e_azAv]
listSelectedL :: Lens' (List e_azAv) (Maybe Int)
listNameL :: Lens' (List e_azAv) Name

-- | Move the list selected index by the specified amount, subject to
--   validation.
listMoveBy :: Int -> List e -> List e

-- | Set the selected index for a list to the specified index, subject to
--   validation.
listMoveTo :: Int -> List e -> List e

-- | Move the list selected index up by one. (Moves the cursor up,
--   subtracts one from the index.)
listMoveUp :: List e -> List e

-- | Move the list selected index down by one. (Moves the cursor down, adds
--   one to the index.)
listMoveDown :: List e -> List e

-- | Insert an item into a list at the specified position.
listInsert :: Int -> e -> List e -> List e

-- | Remove an element from a list at the specified position.
listRemove :: Int -> List e -> List e

-- | Replace the contents of a list with a new set of elements but preserve
--   the currently selected index.
listReplace :: Eq e => [e] -> List e -> List e

-- | Return a list's selected element, if any.
listSelectedElement :: List e -> Maybe (Int, e)

-- | The top-level attribute used for the entire list.
listAttr :: AttrName

-- | The attribute used only for the currently-selected list item. Extends
--   <a>listAttr</a>.
listSelectedAttr :: AttrName
instance HandleEvent (List e)


-- | This module provides a progress bar widget.
module Brick.Widgets.ProgressBar

-- | Draw a progress bar with the specified (optional) label and progress
--   value. This fills available horizontal space and is one row high.
progressBar :: Maybe String -> Float -> Widget

-- | The attribute of the completed portion of the progress bar.
progressCompleteAttr :: AttrName

-- | The attribute of the incomplete portion of the progress bar.
progressIncompleteAttr :: AttrName