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

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

-- | 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 a 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 :: (Monoid 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 GHC.Base.Monoid a => Data.String.IsString (Data.Text.Markup.Markup a)

-- | 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 ascii style in
--   addition to the Unicode styles. The unicode style is also a
--   safe bet.
--   
--   To use these in your widgets, see withBorderStyle. By default,
--   widgets rendered without a specified border style use unicode
--   via the Default instance provided by BorderStyle.
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
defaultBorderStyle :: BorderStyle
instance GHC.Classes.Eq Brick.Widgets.Border.Style.BorderStyle
instance GHC.Read.Read Brick.Widgets.Border.Style.BorderStyle
instance GHC.Show.Show Brick.Widgets.Border.Style.BorderStyle

module Brick.BChan

-- | BChan is an abstract type representing a bounded FIFO
--   channel.
data BChan a

-- | Builds and returns a new instance of BChan.
newBChan :: Int -> IO (BChan a)

-- | Writes a value to a BChan; blocks if the channel is full.
writeBChan :: BChan a -> a -> IO ()

-- | Reads the next value from the BChan; blocks if necessary.
readBChan :: BChan a -> IO a

-- | Reads the next value from either BChan, prioritizing the
--   first BChan; blocks if necessary.
readBChan2 :: BChan a -> BChan b -> IO (Either a b)

-- | This module provides types and functions for managing an attribute map
--   which maps attribute names (AttrName) to attributes
--   (Attr). This module is designed to be used with the
--   OverloadedStrings language extension to permit easy
--   construction of AttrName values and you should also use
--   mappend (<>) 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
--   mappend:
--   
--   
--   let n = attrName "parent" <> attrName "child"
--   
--   
--   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 <> child' as above) is sucessively merged
--   with the parent attribute (parent 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 AttrName values to Attr
--   values.
data AttrMap

-- | An attribute name. Attribute names are hierarchical; use
--   mappend (<>) 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:
--   
--   
--   "window" <> "border"
--   "window" <> "title"
--   "header" <> "clock" <> "seconds"
--   
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
--   mergeWithDefault, with more specific results taking precedence
--   over less specific ones.
--   
--   For example:
--   
--   
--   attrMapLookup ("foo" <> "bar") (attrMap a []) == a
--   attrMapLookup ("foo" <> "bar") (attrMap (bg blue) [("foo" <> "bar", fg red)]) == red `on` blue
--   attrMapLookup ("foo" <> "bar") (attrMap (bg blue) [("foo" <> "bar", red on cyan)]) == red `on` cyan
--   attrMapLookup ("foo" <> "bar") (attrMap (bg blue) [("foo" <> "bar", fg red), ("foo", bg cyan)]) == red `on` cyan
--   attrMapLookup ("foo" <> "bar") (attrMap (bg blue) [("foo", fg red)]) == red `on` blue
--   
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,
--   
--   
--   mergeWithDefault (fg blue) $ attrMap (bg red) []
--   
--   
--   returns
--   
--   
--   blue `on` red
--   
mergeWithDefault :: Attr -> AttrMap -> Attr

-- | Update an attribute map such that a lookup of ontoName
--   returns the attribute value specified by fromName. This is
--   useful for composite widgets with specific attribute names mapping
--   those names to the sub-widget's expected name when calling that
--   sub-widget's rendering function. See the ProgressBarDemo for an
--   example usage, and overrideAttr for an alternate syntax.
mapAttrName :: AttrName -> AttrName -> AttrMap -> AttrMap

-- | Map several attributes to return the value associated with an
--   alternate name. Applies mapAttrName across a list of mappings.
mapAttrNames :: [(AttrName, AttrName)] -> AttrMap -> AttrMap
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 GHC.Base.Monoid Brick.AttrMap.AttrName
instance Data.String.IsString Brick.AttrMap.AttrName

-- | 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
locationColumnL :: TerminalLocation a => Lens' a Int
locationColumn :: TerminalLocation a => a -> Int

-- | Get the row out of the value
locationRowL :: TerminalLocation a => Lens' a Int
locationRow :: 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_arY1. Lens' (CursorLocation n_arY1) Location
cursorLocationNameL :: forall n_arY1 n_asH4. Lens (CursorLocation n_arY1) (CursorLocation n_asH4) (Maybe n_arY1) (Maybe n_asH4)

-- | 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 lookupViewport.
newtype EventM n a
EventM :: ReaderT (EventRO n) (StateT (EventState n) IO) a -> EventM n a
[runEventM] :: EventM n a -> ReaderT (EventRO n) (StateT (EventState n) IO) a

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

-- | The type of events.
data BrickEvent n e

-- | The event was a Vty event.
VtyEvent :: Event -> BrickEvent n e

-- | The event was an application event.
AppEvent :: e -> BrickEvent n e

-- | A mouse-down event on the specified region was received.
MouseDown :: n -> Button -> [Modifier] -> Location -> BrickEvent n e

-- | A mouse-up event on the specified region was received.
MouseUp :: n -> (Maybe Button) -> Location -> BrickEvent n e

-- | 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 handleEvent
--   on it, and stores the resulting transformed value back in the state
--   using the lens.
handleEventLensed :: a -> Lens' a b -> (e -> b -> EventM n b) -> e -> 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 bordering 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] -> [Extent n] -> 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]
[extents] :: Result n -> [Extent n]
emptyResult :: Result n

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

-- | An extent of a named area: its size, location, and origin.
data Extent n
Extent :: n -> Location -> (Int, Int) -> Location -> Extent n
[extentName] :: Extent n -> n
[extentUpperLeft] :: Extent n -> Location
[extentSize] :: Extent n -> (Int, Int)
[extentOffset] :: Extent n -> Location
imageL :: forall n_arV4. Lens' (Result n_arV4) Image
cursorsL :: forall n_arV4. Lens' (Result n_arV4) [CursorLocation n_arV4]
visibilityRequestsL :: forall n_arV4. Lens' (Result n_arV4) [VisibilityRequest]
extentsL :: forall n_arV4. Lens' (Result n_arV4) [Extent n_arV4]
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 makeLenses function in that it does
--   not require the record fields to be prefixed with underscores and it
--   adds an L 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.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)

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

-- | 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).
--   
--   
--   >>> clamp 1 10 11
--   10
--   
--   >>> clamp 1 10 2
--   2
--   
--   >>> clamp 5 10 1
--   5
--   
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 Location offset to the specified CursorLocation.
clOffset :: CursorLocation n -> Location -> CursorLocation n

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
--   s, an application event type e, and a resource name
--   type n. In the simplest case e is unused (left
--   polymorphic or set to '()'), but you may define your own event type
--   and use customMain to provide custom events. The state type is
--   the type of application state to be provided by you and iteratively
--   modified by event handlers. The resource name type is the type of
--   names you can assign to rendering resources such as viewports and
--   cursor locations.
data App s e n
App :: (s -> [Widget n]) -> (s -> [CursorLocation n] -> Maybe (CursorLocation n)) -> (s -> BrickEvent n e -> EventM n (Next s)) -> (s -> EventM n s) -> (s -> AttrMap) -> 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 Nothing, 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 continue,
--   suspendAndResume, and halt.
[appHandleEvent] :: App s e n -> s -> BrickEvent n 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 default main entry point which takes an application and an initial
--   state and returns the final state returned by a halt operation.
defaultMain :: (Ord n) => App s e n -> s -> IO s

-- | The custom event loop entry point to use when the simpler ones don't
--   permit enough control.
customMain :: (Ord n) => IO Vty -> Maybe (BChan 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 :: (Ord n) => 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
--   appHandleEvent value for simple applications using the
--   Event type that do not need to get more sophisticated user
--   input.
resizeOrQuit :: s -> BrickEvent n e -> 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 Nothing if no such
--   state could be found, either because the name was invalid or because
--   no rendering has occurred (e.g. in an appStartEvent handler).
lookupViewport :: (Ord n) => n -> EventM n (Maybe Viewport)

-- | Given a resource name, get the most recent rendering extent for the
--   name (if any).
lookupExtent :: (Eq n) => n -> EventM n (Maybe (Extent n))

-- | Given a mouse click location, return the extents intersected by the
--   click. The returned extents are sorted such that the first extent in
--   the list is the most specific extent and the last extent is the most
--   generic (top-level). So if two extents A and B both intersected the
--   mouse click but A contains B, then they would be returned [B, A].
findClickedExtents :: (Int, Int) -> EventM n [Extent n]

-- | Did the specified mouse coordinates (column, row) intersect the
--   specified extent?
clickedExtent :: (Int, Int) -> Extent n -> Bool

-- | Get the Vty handle currently in use.
getVtyHandle :: EventM n (Maybe Vty)

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

-- | Set the top row offset of the viewport.
setTop :: ViewportScroll n -> Int -> EventM n ()

-- | Set the left column offset of the viewport.
setLeft :: ViewportScroll n -> Int -> EventM n ()

-- | Ignore all requested cursor positions returned by the rendering
--   process. This is a convenience function useful as an
--   appChooseCursor 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
--   appChooseCursor 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 resource name, if such a cursor
--   location has been reported.
showCursorNamed :: (Eq n) => n -> [CursorLocation n] -> Maybe (CursorLocation n)

-- | Invalidate the rendering cache entry with the specified resource name.
invalidateCacheEntry :: n -> EventM n ()

-- | Invalidate the entire rendering cache.
invalidateCache :: EventM 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 class of text types that have widths measured in terminal columns.
--   NEVER use length etc. to measure the length of a string if you
--   need to compute how much screen space it will occupy; always use
--   textWidth.
class TextWidth a
textWidth :: TextWidth a => a -> Int

-- | 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 Text value. Behaves the same as
--   str.
txt :: Text -> Widget n

-- | Build a widget from a String. 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 vBox.
(<=>) :: 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 hBox.
(<+>) :: 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 withAttr to override this; if you really
--   want to prevent that, use forceAttr. 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 withDefAttr.
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

-- | Override the lookup of targetName to return the attribute
--   value associated with fromName when rendering the specified
--   widget. See also mapAttrName.
overrideAttr :: AttrName -> 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 widget 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 cropped widget 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 cropped widget 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 cropped widget 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 cropped widget for growth policy.
cropBottomBy :: Int -> Widget n -> Widget n

-- | Render the specified widget and record its rendering extent using the
--   specified name (see also lookupExtent).
reportExtent :: n -> Widget n -> Widget n

-- | Request mouse click events on the specified widget.
clickable :: n -> 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 visible combinator to make a "visibility
--   request". This viewport combinator will then translate the resulting
--   rendering to make the requested region visible. In addition, the
--   EventM monad provides primitives to scroll viewports created by
--   this function if visible 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 EventM, 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 viewport, 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 visible, request that a region (with the specified
--   Location as its origin and DisplayRegion as its size) be
--   made visible when it is rendered inside a viewport. The
--   Location 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)

-- | Render the specified widget. If the widget has an entry in the
--   rendering cache using the specified name as the cache key, use the
--   rendered version from the cache instead. If not, render the widget and
--   update the cache.
--   
--   See also invalidateCacheEntry.
cached :: (Ord n) => n -> Widget n -> Widget n

-- | Add an offset to all cursor locations, visbility requests, and extents
--   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
instance Brick.Widgets.Core.TextWidth Data.Text.Internal.Text
instance Data.Foldable.Foldable f => Brick.Widgets.Core.TextWidth (f GHC.Types.Char)

-- | 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 resource 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 resource names to focus and a
--   currently-focused name.
data FocusRing n

-- | Construct a focus ring from the list of resource 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 resource name from the ring. If the ring is
--   emtpy, return Nothing.
focusGetCurrent :: FocusRing n -> Maybe n

-- | Cursor selection convenience function for use as an
--   appChooseCursor 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 resource 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 List and Edit.
withFocusRing :: (Eq n, Named a n) => FocusRing n -> (Bool -> a -> b) -> a -> b

-- | Modify the internal circular list structure of a focus ring directly.
--   This function permits modification of the circular list using the rich
--   Data.CircularList API.
focusRingModify :: (CList n -> CList n) -> FocusRing n -> FocusRing n

-- | 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 BorderStyle; to change the
--   BorderStyle, use withBorderStyle.
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
--   borderAttr.
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). Dialog buttons are labeled with strings and map to values
--   of type a, which you choose.
--   
--   Dialogs handle the following events by default with handleDialogEvent:
--   
--   
--   
- Tab or Right Arrow: select the next button
--   
- Shift-tab or Left Arrow: select the previous button
--   
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 Enter 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
--   dialogAttr)
buttonSelectedAttr :: AttrName
dialogButtonsL :: forall a_a1dlP a_a1dmp. Lens (Dialog a_a1dlP) (Dialog a_a1dmp) [(String, a_a1dlP)] [(String, a_a1dmp)]
dialogSelectedIndexL :: forall a_a1dlP. Lens' (Dialog a_a1dlP) (Maybe Int)
dialogWidthL :: forall a_a1dlP. Lens' (Dialog a_a1dlP) Int
dialogTitleL :: forall a_a1dlP. Lens' (Dialog a_a1dlP) (Maybe String)

-- | This module provides a basic text editor widget. You'll need to embed
--   an Editor in your application state and transform it with
--   handleEvent when relevant events arrive. To get the contents
--   of the editor, just use getEditContents. To modify it, use the
--   TextZipper interface with applyEdit.
--   
--   The editor's handleEditorEvent function handles a set of basic
--   input events that should suffice for most purposes; see the source for
--   a complete list.
--   
--   Bear in mind that the editor provided by this module is intended to
--   provide basic input support for brick applications but it is not
--   intended to be a replacement for your favorite editor such as Vim or
--   Emacs. It is also not suitable for building sophisticated editors. If
--   you want to build your own editor, I suggest starting from scratch.
module Brick.Widgets.Edit

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

-- | Construct an editor over String values
editor :: GenericTextZipper a => n -> ([a] -> Widget n) -> Maybe Int -> a -> Editor a n

-- | Construct an editor over Text values
editorText :: n -> ([Text] -> Widget n) -> Maybe Int -> Text -> Editor Text n

-- | Get the contents of the editor.
getEditContents :: Monoid t => Editor t n -> [t]
handleEditorEvent :: (Eq t, Monoid t) => Event -> Editor t n -> EventM n (Editor t 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 t -> TextZipper t) -> Editor t n -> Editor t n
editContentsL :: forall t_a1flL n_a1flM. Lens' (Editor t_a1flL n_a1flM) (TextZipper t_a1flL)
editDrawContentsL :: forall t_a1flL n_a1flM. Lens' (Editor t_a1flL n_a1flM) ([t_a1flL] -> Widget n_a1flM)

-- | Turn an editor state value into a widget. This uses the editor's name
--   for its scrollable viewport handle and the name is also used to report
--   mouse events.
renderEditor :: (Ord n, Show n, Monoid t, TextWidth t, GenericTextZipper t) => Bool -> Editor t 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
--   editAttr.
editFocusedAttr :: AttrName
instance (GHC.Show.Show t, GHC.Show.Show n) => GHC.Show.Show (Brick.Widgets.Edit.Editor t n)
instance Brick.Widgets.Core.Named (Brick.Widgets.Edit.Editor t n) 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 e that is the data
--   stored by the list. Lists handle the following events by default:
--   
--   
--   
- Up/down arrow keys: move cursor of selected item
--   
- Page up / page down keys: move cursor of selected item by one page
--   at a time (based on the number of items shown)
--   
- Home/end keys: move cursor of selected item to beginning or end of
--   list
--   
data List n e

-- | Construct a list in terms of an element type e.
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 :: (Ord n) => Event -> List n e -> EventM n (List n e)
listElementsL :: forall n_a1ia5 e_a1ia6 e_a1ik9. Lens (List n_a1ia5 e_a1ia6) (List n_a1ia5 e_a1ik9) (Vector e_a1ia6) (Vector e_a1ik9)
listSelectedL :: forall n_a1ia5 e_a1ia6. Lens' (List n_a1ia5 e_a1ia6) (Maybe Int)
listNameL :: forall n_a1ia5 e_a1ia6 n_a1ika. Lens (List n_a1ia5 e_a1ia6) (List n_a1ika e_a1ia6) n_a1ia5 n_a1ika
listItemHeightL :: forall n_a1ia5 e_a1ia6. Lens' (List n_a1ia5 e_a1ia6) 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 list is empty, empty selection is used
--   instead. Otherwise, if the specified selected index (via Just)
--   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

-- | Apply a function to the selected element. If no element is selected
--   the list is not modified.
listModify :: (e -> e) -> 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 listAttr.
listSelectedAttr :: AttrName

-- | The attribute used only for the currently-selected list item when the
--   list has focus. Extends listSelectedAttr.
listSelectedFocusedAttr :: AttrName
instance Brick.Widgets.Core.Named (Brick.Widgets.List.List n e) n
instance (GHC.Show.Show n, GHC.Show.Show e) => GHC.Show.Show (Brick.Widgets.List.List n e)
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 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

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