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


-- | A declarative terminal user interface library
--   
--   Write terminal applications painlessly with <a>brick</a>! You write an
--   event handler and a drawing function and the library does the rest.
--   
--   <pre>
--   module Main where
--   
--   import Brick
--   
--   ui :: Widget n
--   ui = str "Hello, world!"
--   
--   main :: IO ()
--   main = simpleMain ui
--   </pre>
--   
--   To get started, see:
--   
--   <ul>
--   <li><a>The README</a></li>
--   <li>The <a>Brick user guide</a></li>
--   <li>The demonstration programs in the <a>programs</a> directory</li>
--   </ul>
--   
--   This package deprecates <a>vty-ui</a>.
@package brick
@version 0.8


-- | 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 GHC.Read.Read Brick.Widgets.Border.Style.BorderStyle
instance GHC.Show.Show Brick.Widgets.Border.Style.BorderStyle
instance Data.Default.Class.Default Brick.Widgets.Border.Style.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 lines. Each line is represented by 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 GHC.Show.Show a => GHC.Show.Show (Data.Text.Markup.Markup a)
instance GHC.Base.Monoid (Data.Text.Markup.Markup a)
instance Data.Default.Class.Default a => Data.String.IsString (Data.Text.Markup.Markup a)


-- | 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> (<tt>&lt;&gt;</tt>) 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> (<tt>&lt;&gt;</tt>) 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 GHC.Show.Show Brick.AttrMap.AttrMap
instance GHC.Classes.Ord Brick.AttrMap.AttrName
instance GHC.Classes.Eq Brick.AttrMap.AttrName
instance GHC.Show.Show Brick.AttrMap.AttrName
instance Data.Default.Class.Default Brick.AttrMap.AttrName
instance GHC.Base.Monoid Brick.AttrMap.AttrName
instance Data.String.IsString Brick.AttrMap.AttrName
instance Data.Default.Class.Default Brick.AttrMap.AttrMap


-- | 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 n -> Location -> CursorLocation n


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

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

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

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

-- | This widget's rendering function
[render] :: Widget n -> RenderM n (Result n)

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

-- | (Column, Row)
[loc] :: Location -> (Int, Int)
locL :: Lens' Location (Int, Int)

-- | The class of types that behave like terminal locations.
class TerminalLocation a

-- | Get the column out of the value
columnL :: TerminalLocation a => Lens' a Int
column :: TerminalLocation a => a -> Int

-- | Get the row out of the value
rowL :: TerminalLocation a => Lens' a Int
row :: TerminalLocation a => a -> Int

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

-- | The location
[cursorLocation] :: CursorLocation n -> !Location

-- | The name of the widget associated with the location
[cursorLocationName] :: CursorLocation n -> !(Maybe n)
cursorLocationL :: forall n_aw7h. Lens' (CursorLocation n_aw7h) Location
cursorLocationNameL :: forall n_aw7h n_awgq. Lens (CursorLocation n_aw7h) (CursorLocation n_awgq) (Maybe n_aw7h) (Maybe n_awgq)

-- | Describes the state of a viewport as it appears as its most recent
--   rendering.
data Viewport
VP :: Int -> Int -> DisplayRegion -> Viewport

-- | The column offset of left side of the viewport.
[_vpLeft] :: Viewport -> Int

-- | The row offset of the top of the viewport.
[_vpTop] :: Viewport -> Int

-- | The size of the viewport.
[_vpSize] :: Viewport -> DisplayRegion

-- | 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
vpSize :: Lens' Viewport DisplayRegion
vpTop :: Lens' Viewport Int
vpLeft :: Lens' Viewport Int

-- | The monad in which event handlers run. Although it may be tempting to
--   dig into the reader value yourself, just use <a>lookupViewport</a>.
newtype EventM n a
EventM :: ReaderT (Map n Viewport) (StateT (EventState n) IO) a -> EventM n a
[runEventM] :: EventM n a -> ReaderT (Map n Viewport) (StateT (EventState n) IO) a

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

-- | A convenience function for handling events intended for values that
--   are targets of lenses in your application state. This function obtains
--   the target value of the specified lens, invokes <tt>handleEvent</tt>
--   on it, and stores the resulting transformed value back in the state
--   using the lens.
handleEventLensed :: a -> Lens' a b -> (Event -> b -> EventM n b) -> Event -> EventM n a

-- | 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 n a = ReaderT Context (State (RenderState n)) a

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

-- | 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 :: forall r. Getting r Context Attr
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 n
Result :: Image -> [CursorLocation n] -> [VisibilityRequest] -> Result n

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

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

-- | The list of visibility requests made by widgets rendered while
--   rendering this one (used by viewports)
[visibilityRequests] :: Result n -> [VisibilityRequest]

-- | Given an attribute name, obtain the attribute for the attribute name
--   by consulting the context's attribute map.
lookupAttrName :: AttrName -> RenderM n Attr
imageL :: forall n_azJ4. Lens' (Result n_azJ4) Image
cursorsL :: forall n_azJ4 n_aAvg. Lens (Result n_azJ4) (Result n_aAvg) [CursorLocation n_azJ4] [CursorLocation n_aAvg]
visibilityRequestsL :: forall n_azJ4. Lens' (Result n_azJ4) [VisibilityRequest]
data VisibilityRequest
VR :: Location -> DisplayRegion -> VisibilityRequest
[vrPosition] :: VisibilityRequest -> Location
[vrSize] :: VisibilityRequest -> DisplayRegion
vrPositionL :: Lens' VisibilityRequest Location
vrSizeL :: Lens' VisibilityRequest DisplayRegion

-- | 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

-- | 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 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

-- | Scrolling direction.
data Direction

-- | Up/left
Up :: Direction

-- | Down/right
Down :: Direction
instance Brick.Types.Internal.TerminalLocation (Brick.Types.Internal.CursorLocation n)
instance GHC.Show.Show n => GHC.Show.Show (Brick.Types.Result n)
instance GHC.Classes.Ord Brick.Types.Size
instance GHC.Classes.Eq Brick.Types.Size
instance GHC.Show.Show Brick.Types.Size
instance Control.Monad.IO.Class.MonadIO (Brick.Types.EventM n)
instance GHC.Base.Monad (Brick.Types.EventM n)
instance GHC.Base.Applicative (Brick.Types.EventM n)
instance GHC.Base.Functor (Brick.Types.EventM n)
instance Data.Default.Class.Default (Brick.Types.Result n)


-- | 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 empty widget.
emptyWidget :: Widget n

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

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

-- | 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 n

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

-- | Pad the specified widget on the left. If max padding is used, this
--   grows greedily horizontally; otherwise it defers to the padded widget.
padLeft :: Padding -> Widget n -> Widget n

-- | Pad the specified widget on the right. If max padding is used, this
--   grows greedily horizontally; otherwise it defers to the padded widget.
padRight :: Padding -> Widget n -> Widget n

-- | Pad the specified widget on the top. If max padding is used, this
--   grows greedily vertically; otherwise it defers to the padded widget.
padTop :: Padding -> Widget n -> Widget n

-- | Pad the specified widget on the bottom. If max padding is used, this
--   grows greedily vertically; otherwise it defers to the padded widget.
padBottom :: Padding -> Widget n -> Widget n

-- | Pad a widget on the left and right. Defers to the padded widget for
--   growth policy.
padLeftRight :: Int -> Widget n -> Widget n

-- | Pad a widget on the top and bottom. Defers to the padded widget for
--   growth policy.
padTopBottom :: Int -> Widget n -> Widget n

-- | Pad a widget on all sides. Defers to the padded widget for growth
--   policy.
padAll :: Int -> Widget n -> Widget n

-- | 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 n -> Widget n -> Widget n

-- | 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 n -> Widget n -> Widget n

-- | 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 the contained widgets (if any are greedy, so is the
--   box).
hBox :: [Widget n] -> Widget n

-- | 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 the contained widgets (if any are greedy, so is the
--   box).
vBox :: [Widget n] -> Widget n

-- | 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. This is non-greedy horizontally
--   and defers to the limited widget vertically.
hLimit :: Int -> Widget n -> Widget n

-- | 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. This is non-greedy vertically and defers
--   to the limited widget horizontally.
vLimit :: Int -> Widget n -> Widget n

-- | 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 n -> Widget n

-- | 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 n -> Widget n

-- | 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 n -> Widget n

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

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

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

-- | The class of types that store interface element names.
class Named a n

-- | Get the name of the specified value.
getName :: Named a n => a -> n

-- | Translate the specified widget by the specified offset amount. Defers
--   to the translated width for growth policy.
translateBy :: Location -> Widget n -> Widget n

-- | Crop the specified widget on the left by the specified number of
--   columns. Defers to the translated width for growth policy.
cropLeftBy :: Int -> Widget n -> Widget n

-- | Crop the specified widget on the right by the specified number of
--   columns. Defers to the translated width for growth policy.
cropRightBy :: Int -> Widget n -> Widget n

-- | Crop the specified widget on the top by the specified number of rows.
--   Defers to the translated width for growth policy.
cropTopBy :: Int -> Widget n -> Widget n

-- | Crop the specified widget on the bottom by the specified number of
--   rows. Defers to the translated width for growth policy.
cropBottomBy :: Int -> Widget n -> Widget n

-- | 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, then the
--   visibility requests are merged with the inner visibility request
--   taking preference. 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 :: (Ord n, Show n) => n -> ViewportType -> Widget n -> Widget n

-- | 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 n -> Widget n

-- | 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 n -> Widget n

-- | Given a name, obtain the viewport for that name by consulting the
--   viewport map in the rendering monad. NOTE! Some care must be taken
--   when calling this function, since it only returns useful values after
--   the viewport in question has been rendered. If you call this function
--   during rendering before a viewport has been rendered, you may get
--   nothing or you may get a stale version of the viewport. This is
--   because viewports are updated during rendering and the one you are
--   interested in may not have been rendered yet. So if you want to use
--   this, be sure you know what you are doing.
unsafeLookupViewport :: (Ord n) => n -> RenderM n (Maybe Viewport)

-- | 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 n -> Result n

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


-- | 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 n

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

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

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

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

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

-- | This function is a convenience function to look up a widget state
--   value's name in a focus ring and set its focus setting according to
--   the focus ring's state. This function determines whether a given
--   widget state value is the focus of the ring and passes the resulting
--   boolean to a rendering function, along with the state value (a), to
--   produce whatever comes next (b).
--   
--   Focus-aware widgets have rendering functions that should be usable
--   with this combinator; see <a>List</a> and <a>Edit</a>.
withFocusRing :: (Eq n, Named a n) => FocusRing n -> (Bool -> a -> b) -> a -> b


-- | This module provides an API for turning "markup" values into widgets.
--   This module uses the <a>Data.Text.Markup</a> 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 n

-- | 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

-- | Where to get the attribute for this attribute metadata.
getAttr :: GetAttr a => a -> RenderM n Attr
instance Brick.Markup.GetAttr Graphics.Vty.Attributes.Attr
instance Brick.Markup.GetAttr Brick.AttrMap.AttrName


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

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

-- | 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 n -> Widget n

-- | Center the specified widget horizontally using a Vty image
--   translation. Consumes all available horizontal space. Unlike hCenter,
--   this does not fill the surrounding space so it is suitable for use as
--   a layer. Layers underneath this widget will be visible in regions
--   surrounding the centered widget.
hCenterLayer :: Widget n -> Widget n

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

-- | 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 n -> Widget n

-- | Center the specified widget vertically using a Vty image translation.
--   Consumes all available vertical space. Unlike vCenter, this does not
--   fill the surrounding space so it is suitable for use as a layer.
--   Layers underneath this widget will be visible in regions surrounding
--   the centered widget.
vCenterLayer :: Widget n -> Widget n

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

-- | 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 n -> Widget n

-- | Center a widget both vertically and horizontally using a Vty image
--   translation. Consumes all available vertical and horizontal space.
--   Unlike center, this does not fill in the surrounding space with a
--   character so it is usable as a layer. Any widget underneath this one
--   will be visible in the region surrounding the centered widget.
centerLayer :: Widget n -> Widget n

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


-- | 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 n -> Widget n

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

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

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

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

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

-- | 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 <tt>HandleEvent</tt> 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 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 :: Maybe String -> Maybe (Int, [(String, a)]) -> Int -> Dialog a

-- | Render a dialog with the specified body widget. This renders the
--   dialog as a layer, which makes this suitable as a top-level layer in
--   your rendering function to be rendered on top of the rest of your
--   interface.
renderDialog :: Dialog a -> Widget n -> Widget n
handleDialogEvent :: Event -> Dialog a -> EventM n (Dialog a)

-- | 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
dialogButtonsL :: forall a_a1545 a_a154F. Lens (Dialog a_a1545) (Dialog a_a154F) [(String, a_a1545)] [(String, a_a154F)]
dialogSelectedIndexL :: forall a_a1545. Lens' (Dialog a_a1545) (Maybe Int)
dialogWidthL :: forall a_a1545. Lens' (Dialog a_a1545) Int
dialogTitleL :: forall a_a1545. Lens' (Dialog a_a1545) (Maybe String)


-- | This module provides a basic text editor widget. You'll need to embed
--   an <a>Editor</a> in your application state and transform it with
--   <tt>handleEvent</tt> 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 <tt>HandleEvent</tt> 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 n

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

-- | Get the contents of the editor.
getEditContents :: Editor n -> [String]
handleEditorEvent :: Event -> Editor n -> EventM n (Editor n)

-- | 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 n -> Editor n
editContentsL :: forall n_a16WI. Lens' (Editor n_a16WI) (TextZipper String)
editDrawContentsL :: forall n_a16WI. Lens' (Editor n_a16WI) ([String] -> Widget n_a16WI)

-- | Turn an editor state value into a widget
renderEditor :: (Ord n, Show n) => Bool -> Editor n -> Widget n

-- | The attribute assigned to the editor when it does not have focus.
editAttr :: AttrName

-- | The attribute assigned to the editor when it has focus. Extends
--   <a>editAttr</a>.
editFocusedAttr :: AttrName
instance Brick.Widgets.Core.Named (Brick.Widgets.Edit.Editor n) n


-- | 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 n

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

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

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>, an application event type <tt>e</tt>, and a name type
--   <tt>n</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. The state type is the type of application state to
--   be provided by you and iteratively modified by event handlers. The
--   name type is the type of names you can assign to viewports and
--   widgets.
data App s e n
App :: (s -> [Widget n]) -> (s -> [CursorLocation n] -> Maybe (CursorLocation n)) -> (s -> e -> EventM n (Next s)) -> (s -> EventM n s) -> (s -> AttrMap) -> (Event -> e) -> App s e n

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

-- | 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 n -> s -> [CursorLocation n] -> Maybe (CursorLocation n)

-- | 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 n -> s -> e -> EventM n (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 n -> s -> EventM n s

-- | The attribute map that should be used during rendering.
[appAttrMap] :: App s e n -> 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 n -> 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 n -> 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 n -> 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 n -> 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 n (Next s)

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

-- | Halt the event loop and return the specified application state as the
--   final state value.
halt :: s -> EventM n (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 n (Next s)

-- | Given a viewport name, get the viewport's size and offset information
--   from the most recent rendering. Returns <a>Nothing</a> if no such
--   state could be found, either because the name was invalid or because
--   no rendering has occurred (e.g. in an <a>appStartEvent</a> handler).
lookupViewport :: (Ord n) => n -> EventM n (Maybe Viewport)

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

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

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

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

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

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

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

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

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

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

-- | 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 n] -> Maybe (CursorLocation n)

-- | 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 n] -> Maybe (CursorLocation n)

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


-- | 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>
--   <li>Page up / page down keys: move cursor of selected item by one page
--   at a time (based on the number of items shown)</li>
--   <li>Home/end keys: move cursor of selected item to beginning or end of
--   list</li>
--   </ul>
data List n e

-- | Construct a list in terms of an element type <tt>e</tt>.
list :: n -> Vector e -> Int -> List n e

-- | Turn a list state value into a widget given an item drawing function.
renderList :: (Ord n, Show n) => (Bool -> e -> Widget n) -> Bool -> List n e -> Widget n
handleListEvent :: (Show n, Ord n) => Event -> List n e -> EventM n (List n e)
listElementsL :: forall n_a1f4A e_a1f4B e_a1fc7. Lens (List n_a1f4A e_a1f4B) (List n_a1f4A e_a1fc7) (Vector e_a1f4B) (Vector e_a1fc7)
listSelectedL :: forall n_a1f4A e_a1f4B. Lens' (List n_a1f4A e_a1f4B) (Maybe Int)
listNameL :: forall n_a1f4A e_a1f4B n_a1fc8. Lens (List n_a1f4A e_a1f4B) (List n_a1fc8 e_a1f4B) n_a1f4A n_a1fc8
listItemHeightL :: forall n_a1f4A e_a1f4B. Lens' (List n_a1f4A e_a1f4B) Int

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

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

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

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

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

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

-- | Replace the contents of a list with a new set of elements and update
--   the new selected index. If the specified selected index (via
--   <a>Just</a>) is not in the list bounds, zero is used instead.
listReplace :: Vector e -> Maybe Int -> List n e -> List n e

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

-- | Remove all elements from the list and clear the selection.
listClear :: List n e -> List n e

-- | Reverse the list. The element selected before the reversal will again
--   be the selected one.
listReverse :: List n e -> List n e

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

-- | The attribute used only for the currently-selected list item when the
--   list does not have focus. Extends <a>listAttr</a>.
listSelectedAttr :: AttrName

-- | The attribute used only for the currently-selected list item when the
--   list has focus. Extends <a>listSelectedAttr</a>.
listSelectedFocusedAttr :: AttrName
instance Brick.Widgets.Core.Named (Brick.Widgets.List.List n e) n
instance Data.Traversable.Traversable (Brick.Widgets.List.List n)
instance Data.Foldable.Foldable (Brick.Widgets.List.List n)
instance GHC.Base.Functor (Brick.Widgets.List.List n)


-- | This module is provided as a convenience to import the most important
--   parts of the API all at once.
module Brick