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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

-- | 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
CursorLocation :: !Location -> !(Maybe Name) -> CursorLocation

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

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

-- | 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 a
EventM :: ReaderT (Map Name Viewport) (StateT EventState IO) a -> EventM a
[runEventM] :: EventM a -> ReaderT (Map Name Viewport) (StateT EventState IO) a

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

-- | The class of types that provide some basic event-handling.
class HandleEvent a

-- | Handle a Vty event
handleEvent :: HandleEvent a => Event -> a -> EventM 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 <a>handleEvent</a> on
--   it, and stores the resulting transformed value back in the state using
--   the lens.
handleEventLensed :: (HandleEvent b) => a -> Lens' a b -> Event -> EventM 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 a = ReaderT Context (State RenderState) a

-- | Get the current rendering context.
getContext :: RenderM 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 :: (Contravariant f, Functor f) => (Attr -> f Attr) -> Context -> f Context
availWidthL :: Lens' Context Int
availHeightL :: Lens' Context Int
ctxAttrMapL :: Lens' Context AttrMap
ctxAttrNameL :: Lens' Context AttrName
ctxBorderStyleL :: Lens' Context BorderStyle

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

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

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

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

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

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

-- | Names of things. Used to name cursor locations, widgets, and
--   viewports.
newtype Name
Name :: String -> Name
instance Brick.Types.Internal.TerminalLocation Brick.Types.Internal.CursorLocation
instance GHC.Show.Show Brick.Types.Result
instance GHC.Classes.Ord Brick.Types.Size
instance GHC.Classes.Eq Brick.Types.Size
instance GHC.Show.Show Brick.Types.Size
instance GHC.Base.Monad Brick.Types.EventM
instance GHC.Base.Applicative Brick.Types.EventM
instance GHC.Base.Functor Brick.Types.EventM
instance Data.Default.Class.Default Brick.Types.Result


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

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

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

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

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

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

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


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

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

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

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

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

-- | Where to get the attribute for this attribute metadata.
getAttr :: GetAttr a => a -> RenderM 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).
--   
--   <pre>
--   &gt;&gt;&gt; clamp 1 10 11
--   10
--   
--   &gt;&gt;&gt; clamp 1 10 2
--   2
--   
--   &gt;&gt;&gt; clamp 5 10 1
--   5
--   </pre>
clamp :: (Ord a) => a -> a -> a -> a

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

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

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

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

module Brick.Main

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | 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 :: Name -> EventM (Maybe Viewport)

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

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

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

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

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

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

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

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

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

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

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

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

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


-- | This module provides 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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Horizontal box layout: put the specified widgets next to each other in
--   the specified order (leftmost first). Defers growth policies to the
--   growth policies of the contained widgets (if any are greedy, so is the
--   box).
hBox :: [Widget] -> Widget

-- | Vertical box layout: put the specified widgets one above the other in
--   the specified order (uppermost first). Defers growth policies to the
--   growth policies of the contained widgets (if any are greedy, so is the
--   box).
vBox :: [Widget] -> Widget

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


-- | 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
--   <a>handleEvent</a> when relevant events arrive. To get the contents of
--   the editor, just use <a>getEditContents</a>. To modify it, use the
--   <a>TextZipper</a> interface with <a>applyEdit</a>.
--   
--   The editor's <a>HandleEvent</a> instance handles a set of basic input
--   events that should suffice for most purposes; see the source for a
--   complete list.
module Brick.Widgets.Edit

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

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

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

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

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

-- | The attribute assigned to the editor
editAttr :: AttrName
instance Brick.Types.HandleEvent Brick.Widgets.Edit.Editor


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

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

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

-- | Turn a list state value into a widget given an item drawing function.
renderList :: List e -> (Bool -> e -> Widget) -> Widget
listElementsL :: forall e_a113M e_a114X. Lens (List e_a113M) (List e_a114X) (Vector e_a113M) (Vector e_a114X)
listSelectedL :: forall e_a113M. Lens' (List e_a113M) (Maybe Int)
listNameL :: forall e_a113M. Lens' (List e_a113M) Name
listItemHeightL :: forall e_a113M. Lens' (List e_a113M) Int

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

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

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

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

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

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

-- | Replace the contents of a list with a new set of elements 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 :: Eq e => Vector e -> Maybe Int -> List e -> List e

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

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

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


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

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

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

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


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