h$      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                        None8: brickAn attribute map which maps  values to  values.brick9An attribute name. Attribute names are hierarchical; use  () to assemble them. Hierarchy 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" brick'Create an attribute name from a string.brick(Get the components of an attribute name.brickCreate an attribute map.brickCreate an attribute map in which all lookups map to the same attribute. This is functionally equivalent to AttrMap attr [].brickGiven 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, 1mergeWithDefault (fg blue) $ attrMap (bg red) [] returns blue `on` red brickLook 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 along with its style settings. If the attribute name is empty, the map's default attribute is returned. If the attribute name is non-empty, every subsequence of names from the specified name are used to perform a lookup and the results are combined as in , with more specific results taking precedence over less specific ones. As attributes are merged, styles are also merged. If a more specific attribute name introduces a style (underline, say) and a less specific attribute name introduces an additional style (bold, say) then the final result will include both styles. 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 brick4Set the default attribute value in an attribute map. brick4Get the default attribute value in an attribute map. brick7Insert a set of attribute mappings to an attribute map. brick.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. brickMap several attributes to return the value associated with an alternate name. Applies   across a list of mappings.brickThe map's default attribute to be returned when a name lookup fails, and the attribute that will be merged with successful lookups.brickThe map's initial contents.     Safe-InferredybrickBChan9 is an abstract type representing a bounded FIFO channel.brick%Builds and returns a new instance of BChan.brickWrites a value to a BChan ; blocks if the channel is full.brickAttempts to write a value to a BChan. If the channel has room, the value is written and this returns . Otherwise this returns  and returns immediately.brickReads the next value from the BChan; blocks if necessary.brick!Reads the next value from either BChan, prioritizing the first BChan; blocks if necessary.brick/maximum number of elements the channel can hold Safe-Inferred [brickA template haskell function to build lenses for a record type. This function differs from the  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. brickA more general version of  that allows customization of the lens-building rules and allows customization of the suffix. None58: !brickA terminal screen location.#brick (Column, Row)brickThe origin (upper-left corner).!"#$%&'()*+,-.None 8:+k/brickA theme provides a set of default attribute mappings, a default attribute, and a set of customizations for the default mapping and default attribute. The idea here is that the application will always need to provide a complete specification of its attribute mapping, but if the user wants to customize any aspect of that default mapping, it can be contained here and then built into an  (see W). We keep the defaults separate from customizations to permit users to serialize themes and their customizations to, say, disk files.1brickThe default attribute to use.2brick%The default attribute mapping to use.3brick0Customization for the theme's default attribute.4brickCustomizations for individual entries of the default mapping. Note that this will only affect entries in the default mapping; any attributes named here that are not present in the default mapping will not be considered.5brick'Documentation for a theme's attributes.7brickThe per-attribute documentation for a theme so e.g. documentation for theme customization can be generated mechanically.8brickAn attribute customization can specify which aspects of an attribute to customize.:brick"The customized foreground, if any.;brick"The customized background, if any.<brickThe customized style, if any.VbrickCreate a new theme with the specified default attribute and attribute mapping. The theme will have no customizations.Wbrick Build an  from a /3. This applies all customizations in the returned .XbrickApply customizations using a custom lookup function. Customizations are obtained for each attribute name in the theme. Any customizations already set are lost.YbrickLoad an INI file containing theme customizations. Use the specified theme to determine which customizations to load. Return the specified theme with customizations set. See the module documentation for the theme file format.ZbrickSave an INI file containing theme customizations. Use the specified theme to determine which customizations to save. See the module documentation for the theme file format.[brickSave an INI file containing all attributes from the specified theme. Customized attributes are saved, but if an attribute is not customized, its default is saved instead. The file can later be re-loaded as a customization file.Xbrick=An optional customization for the theme's default attribute.brickA function to obtain a customization for the specified attribute.brickThe theme to customize./0123456789:; n.brick6Increment all keys by the given amount. This is like /, but restricted to partially-applied addition.brick This function is unsafe because xs that compare equal may split their runs into different chunks; consumers must promise that they do not treat run boundaries specially.brickThis function is unsafe because it assumes there is no overlap between its arguments. That is, in the call unsafeUnion a b%, the caller must guarantee that if lookup k a = Just v then lookup k b = Nothing and vice versa.brickZippy:  combines values at equal keys, discarding any values whose key is in only one of its two arguments.tuvwxyz{|}~xtuvwz{|}~yNone58:B brickA  BorderMap a is like a Map Location a., except that there is a rectangle, and only !5s on the border of this rectangle are retained. The  can be queried for the position and size of the rectangle. There are also efficient bulk query and bulk update operations for adjacent positions on the border.brickGiven a rectangle (specified as the coordinates of the top, left, bottom, and right sides), initialize an empty .brick An empty " that only tracks the point (0,0).brickA  that tracks only the given the point (and initially maps it to the given value).brickThe positions of the edges of the rectangle whose border is retained in a . For example, if coordinates m = e$, then the top border contains the ! s on row eTop e and between columns eLeft e to eRight e inclusive.brickA complementary way to query the edges of the rectangle whose border is retained in a . For example, if  bounds m = b , then a !'s column must be between  fst (eTop b) and  snd (eTop b) to be retained. See also 6, which is in most cases a more natural border query.brickMaps giving the values along each edge. Corner values are replicated in all relevant edges.brick4Bulk insertion of horizontally-adjacent values. The !! gives the start point, and the t+ extends in the "larger columns" direction.brick2Bulk insertion of vertically-adjacent values. The !! gives the start point, and the t( extends in the "larger rows" direction.brick,Insert a single value at the given location.brick'Look up all values on a given row. The x" returned maps columns to values.brick*Look up all values on a given column. The x returned maps rows to values.brick1Bulk lookup of horizontally-adjacent values. The !$ gives the starting point, and the t1 extends in the "larger columns" direction. The x! returned maps columns to values.brick/Bulk lookup of vertically-adjacent values. The !$ gives the starting point, and the t. extends in the "larger rows" direction. The x returned maps rows to values.brickLook up a single position.brick(Set the rectangle being tracked by this , throwing away any values that do not lie on this new rectangle.brick0Ensure that the rectangle being tracked by this ( extends no farther than the given one.brick0Ensure that the rectangle being tracked by this + extends at least as far as the given one.brickMove a  by adding the given ! to all keys in the map.brickAssumes the two s are tracking the same rectangles, but have disjoint keys. This property is not checked.$%&'()+,-.$%&'().+-,None58:X=brickThe 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.brick#Clickable elements of a scroll bar.brick9The handle at the beginning (left/top) of the scroll bar.brick7The handle at the end (right/bottom) of the scroll bar.brickThe scroll bar itself.brick!The trough before the scroll bar.brick The trough after the scroll bar.brickThe type of events.brickThe event was a Vty event.brick#The event was an application event.brick>A mouse-down event on the specified region was received. The n8 value is the resource name of the clicked widget (see  clickable).brickThe lens to use to extract and store the target of the event.brickThe event handler.brickThe event to handle. !"#$%&'()*+,-.!"#* $%&'().+-,NonedbrickAfter rendering the specified widget, crop its result image to the dimensions in the rendering context. None  >brick6The class of types that store interface element names.brick$Get the name of the specified value.brickThe class of text types that have widths measured in terminal columns. NEVER use  etc. to measure the length of a string if you need to compute how much screen space it will occupy; always use .brickWhen rendering the specified widget, use the specified border style for any border rendering.brickWhen rendering the specified widget, create borders that respond dynamically to their neighbors to form seamless connections.brickWhen rendering the specified widget, use static borders. This may be marginally faster, but will introduce a small gap between neighboring orthogonal borders.0This is the default for backwards compatibility.brickAfter the specified widget has been rendered, freeze its borders. A frozen border will not be affected by neighbors, nor will it affect neighbors. Compared to ,  will not affect whether borders connect internally to a widget (whereas  prevents them from connecting). Frozen borders cannot be thawed.brickThe empty widget.brickAdd 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.brickRender the specified widget and record its rendering extent using the specified name (see also  lookupExtent).$This function is the counterpart to  makeVisible%; any visibility requests made with  makeVisible must have a corresponding  in order to work. The  function will also work for this purpose to tell the renderer about the clickable region.brick3Request mouse click events on the specified widget.Regions used with ! can be scrolled into view with  makeVisible.brickMake a widget from a string, but wrap the words in the input's lines at the available width using the default wrapping settings. The input string should not contain escape sequences or carriage returns.Unlike , this is greedy horizontally.brickMake a widget from a string, but wrap the words in the input's lines at the available width using the specified wrapping settings. The input string should not contain escape sequences or carriage returns.Unlike , this is greedy horizontally.brickMake a widget from text, but wrap the words in the input's lines at the available width using the default wrapping settings. The input text should not contain escape sequences or carriage returns.Unlike , this is greedy horizontally.brickMake a widget from text, but wrap the words in the input's lines at the available width using the specified wrapping settings. The input text should not contain escape sequences or carriage returns.Unlike , this is greedy horizontally.brickBuild a widget from a . Breaks newlines up and space-pads short lines out to the length of the longest line.The input string must not contain tab characters. If it does, interface corruption will result since the terminal will likely render it as taking up more than a single column. The caller should replace tabs with the appropriate number of spaces as desired. The input string should not contain escape sequences or carriage returns.brickBuild a widget from a  value. Behaves the same as ) when the input contains multiple lines.The input string must not contain tab characters. If it does, interface corruption will result since the terminal will likely render it as taking up more than a single column. The caller should replace tabs with the appropriate number of spaces as desired. The input text should not contain escape sequences or carriage returns.brickHyperlink the given widget to the specified URL. Not all terminal emulators support this. In those that don't, this should have no discernible effect.brickPad the specified widget on the left. If max padding is used, this grows greedily horizontally; otherwise it defers to the padded widget.brickPad the specified widget on the right. If max padding is used, this grows greedily horizontally; otherwise it defers to the padded widget.brickPad the specified widget on the top. If max padding is used, this grows greedily vertically; otherwise it defers to the padded widget.brickPad the specified widget on the bottom. If max padding is used, this grows greedily vertically; otherwise it defers to the padded widget.brickPad a widget on the left and right. Defers to the padded widget for growth policy.brickPad a widget on the top and bottom. Defers to the padded widget for growth policy.brickPad a widget on all sides. Defers to the padded widget for growth policy.brickFill all available space with the specified character. Grows both horizontally and vertically.brickVertical 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).brickHorizontal 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).brickLimit 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.brickLimit the space available to the specified widget to the specified percentage of available width, as a value between 0 and 100 inclusive. Values outside the valid range will be clamped to the range endpoints. This is important for constraining the horizontal growth of otherwise-greedy widgets. This is non-greedy horizontally and defers to the limited widget vertically.brickLimit 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.brickLimit the space available to the specified widget to the specified percentage of available height, as a value between 0 and 100 inclusive. Values outside the valid range will be clamped to the range endpoints. This is important for constraining the vertical growth of otherwise-greedy widgets. This is non-greedy vertically and defers to the limited widget horizontally.brickSet the rendering context height and width for this widget. This is useful for relaxing the rendering size constraints on e.g. layer widgets where cropping to the screen size is undesirable.brickWhen drawing the specified widget, set the attribute used for drawing to the one with the specified name. Note that the widget may use further calls to  to change the active drawing attribute, so this only takes effect if nothing in the specified widget invokes $. If you want to prevent that, use . 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 . For example:  appAttrMap = attrMap (white on blue) [ ("highlight", fg yellow) , ("warning", bg magenta) ] renderA :: (String, String) -> [Widget n] renderA (a,b) = hBox [ str a , str " is " , withAttr "highlight" (str b) ] render1 = renderA (Brick1, "fun") render2 = withAttr "warning" render1 In the example above, render1 will show  Brick is fun where the first two words are white on a blue background and the last word is yellow on a blue background. However, render2 will show the first two words in white on magenta although the last word is still rendered in yellow on blue.brickUpdate the attribute map while rendering the specified widget: set the map's default attribute to the one that we get by applying the specified function to the current map's default attribute. This is a variant of &; see the latter for more information.brickUpdate the attribute map used while rendering the specified widget (and any sub-widgets): set its new *default* attribute (i.e. the attribute components that will be applied if not overridden by any more specific attributes) to the one that we get by looking up the specified attribute name in the map. For example: & ... appAttrMap = attrMap (white on blue) [ ("highlight", fg yellow) , ("warning", bg magenta) , ("good", white on green) ] ... renderA :: (String, String) -> [Widget n] renderA (a,b) = hBox [ withAttr "good" (str a) , str " is " , withAttr "highlight" (str b) ] render1 = renderA (Brick4, "fun") render2 = withDefAttr "warning" render1 In the above, render1 will show "Brick is fun" where the first word is white on a green background, the middle word is white on a blue background, and the last word is yellow on a blue background. However, render2 will show the first word in the same colors but the middle word will be shown in whatever the terminal's normal foreground is on a magenta background, and the third word will be yellow on a magenta background.brickWhile rendering the specified widget, use a transformed version of the current attribute map. This is a very general function with broad capabilities: you probably want a more specific function such as  or .brickWhen rendering the specified widget, force all attribute lookups in the attribute map to use the value currently assigned to the specified attribute name. This means that the attribute lookups will behave as if they all used the name specified here. That further means that the resolved attribute will still inherit from its parent entry in the attribute map as would normally be the case. If you want to have more control over the resulting attribute, consider . For example: & ... appAttrMap = attrMap (white on blue) [ ("highlight", fg yellow) , ("notice", fg red) ] ... renderA :: (String, String) -> [Widget n] renderA (a,b) = hBox [ withAttr "highlight" (str a) , str " is " , withAttr "highlight" (str b) ] render1 = renderA (Brick1, "fun") render2 = forceAttr "notice" render1 In the above, render1 will show "Brick is fun" where the first and last words are yellow on a blue background and the middle word is white on a blue background. However, render2 will show all words in red on a blue background. In both versions, the middle word will be in white on a blue background.brick*Override the lookup of the attribute name  targetName0 to return the attribute value associated with fromName& when rendering the specified widget. For example:  appAttrMap = attrMap (white on blue) [ ("highlight", fg yellow) , ("notice", fg red) ] renderA :: (String, String) -> [Widget n] renderA (a, b) = str a  + str " is "  + withAttr "highlight" (str b) render1 = withAttr "notice" $ renderA (Brick, "fun") render2 = overrideAttr "highlight" "notice" render1 In the example above, render1 will show  Brick is fun> where the first two words are red on a blue background, but fun+ is yellow on a blue background. However, render28 will show all three words in red on a blue background.brick-Build a widget directly from a raw Vty image.brickTranslate the specified widget by the specified offset amount. Defers to the translated widget for growth policy.brickGiven a widget, translate it to position it relative to the upper-left coordinates of a reported extent with the specified positioning offset. This is useful for positioning something in a higher layer relative to a reported extent in a lower layer. If the specified name has no reported extent, this just draws the specified widget with no special positioning.brickCrop the specified widget on the left by the specified number of columns. Defers to the cropped widget for growth policy.brickCrop the specified widget to the specified size from the left. Defers to the cropped widget for growth policy.brickCrop the specified widget on the right by the specified number of columns. Defers to the cropped widget for growth policy.brickCrop the specified widget to the specified size from the right. Defers to the cropped widget for growth policy.brickCrop the specified widget on the top by the specified number of rows. Defers to the cropped widget for growth policy.brickCrop the specified widget to the specified size from the top. Defers to the cropped widget for growth policy.brickCrop the specified widget on the bottom by the specified number of rows. Defers to the cropped widget for growth policy.brickCrop the specified widget to the specified size from the bottom. Defers to the cropped widget for growth policy.brickWhen rendering the specified widget, also register a cursor positioning request using the specified name and location.brickWhen rendering the specified widget, also register a cursor positioning request using the specified name and location. The cursor will only be positioned but not made visible.brickIf the specified resource name has an entry in the rendering cache, use the rendered version from the cache. If not, render the specified widget and update the cache with the result.To ensure that mouse events are emitted correctly for cached widgets, in addition to the rendered widget, we also cache (the names of) any clickable extents that were rendered and restore that when utilizing the cache. See also invalidateCacheEntry.brickEnable vertical scroll bars on all viewports in the specified widget and draw them with the specified orientation.brickEnable scroll bar handles on all vertical scroll bars in the specified widget. Handles appear at the ends of the scroll bar, representing the "handles" that are typically clickable in graphical UIs to move the scroll bar incrementally. Vertical scroll bars are also clickable if mouse mode is enabled and if  is used.!This will only have an effect if  is also called.brickRender vertical viewport scroll bars in the specified widget with the specified renderer. This is only needed if you want to override the use of the default renderer, .brickThe default renderer for vertical viewport scroll bars. Override with .brickEnable horizontal scroll bars on all viewports in the specified widget and draw them with the specified orientation.brickEnable mouse click reporting on horizontal scroll bars in the specified widget. This must be used with . The provided function is used to build a resource name containing the scroll bar element clicked and the viewport name associated with the scroll bar. It is usually a data constructor of the n type.brickEnable mouse click reporting on vertical scroll bars in the specified widget. This must be used with . The provided function is used to build a resource name containing the scroll bar element clicked and the viewport name associated with the scroll bar. It is usually a data constructor of the n type.brickEnable scroll bar handles on all horizontal scroll bars in the specified widget. Handles appear at the ends of the scroll bar, representing the "handles" that are typically clickable in graphical UIs to move the scroll bar incrementally. Horizontal scroll bars are also clickable if mouse mode is enabled and if  is used.!This will only have an effect if  is also called.brickRender horizontal viewport scroll bars in the specified widget with the specified renderer. This is only needed if you want to override the use of the default renderer, .brickThe default renderer for horizontal viewport scroll bars. Override with .brickRender 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  combinator to make a "visibility request". This viewport combinator will then translate the resulting rendering to make the requested region visible. In addition, the   monad provides primitives to scroll viewports created by this function if  is not what you want.This function can automatically render vertical and horizontal scroll bars if desired. To enable scroll bars, wrap your call to  with a call to  and/or . If you don't like the appearance of the resulting scroll bars (defaults:  and =), you can customize how they are drawn by making your own  and using  and/or . Note that when you enable scrollbars, the content of your viewport will lose one column of available space if vertical scroll bars are enabled and one row of available space if horizontal scroll bars are enabled.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  ;, all are honored in the order in which they are received.Some caution should be advised when using this function. The viewport renders its contents anew each time the viewport is drawn; in many cases this is prohibitively expensive, and viewports should not be used to display large contents for scrolling. This function is best used when the contents are not too large OR when the contents are large and render-cacheable.Also, be aware that there is a rich API for accessing viewport information from within the  monad; check the docs for  Brick.Main to learn more about ways to get information about viewports after they're drawn.brick#The base attribute for scroll bars.brickThe attribute for scroll bar troughs. This attribute is a specialization of  scrollbarAttr.brickThe attribute for scroll bar handles. This attribute is a specialization of  scrollbarAttr.brickBuild a vertical scroll bar using the specified render and settings.̊ brick?Editor state. Editors support the following events by default:Meta-<: go to beginning of fileMeta->: go to end of file%Ctrl-a, Home: go to beginning of lineCtrl-e, End: go to end of line0Ctrl-d, Del: delete character at cursor position&Meta-d: delete word at cursor position4Backspace: delete character prior to cursor position-Ctrl-k: delete all from cursor to end of line3Ctrl-u: delete all from cursor to beginning of lineCtrl-t: transpose character before cursor with the one at cursor position!Meta-b: move one word to the left&Ctrl-b: move one character to the left"Meta-f: move one word to the right'Ctrl-f: move one character to the rightArrow keys: move cursor4Enter: break the current line at the cursor positionPaste: Bracketed Pastes from the terminal will be pasted, provided the incoming data is UTF-8-encoded.brickThe contents of the editorbrickThe name of the editorbrickValues that can be constructed by decoding bytestrings in UTF-8 encoding.brickDecode a bytestring assumed to be text in UTF-8 encoding. If the decoding fails, return ". This must not raise exceptions.brickConstruct an editor over Text valuesbrickConstruct an editor over  valuesbrickApply 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.brickThe attribute assigned to the editor when it does not have focus.brickThe attribute assigned to the editor when it has focus. Extends .brickGet the contents of the editor.brickTurn 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.brick"The editor's name (must be unique)brick0The limit on the number of lines in the editor ( means no limit)brickThe initial contentbrick"The editor's name (must be unique)brick0The limit on the number of lines in the editor ( means no limit)brickThe initial contentbrickThe  editing transformation to applybrickThe content drawing functionbrickWhether the editor has focus. It will report a cursor position if and only if it has focus.brick The editor. None brickCenter the specified widget horizontally. Consumes all available horizontal space.brickCenter 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.brickCenter 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).brick9Center a widget vertically. Consumes all vertical space.brickCenter 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.brickCenter 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).brickCenter a widget both vertically and horizontally. Consumes all available vertical and horizontal space.brickCenter 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).brickCenter 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.brickCenter the widget horizontally and vertically about the specified origin.  None brick$The top-level border attribute name.brickDraw the specified border element using the active border style using .Does not participate in dynamic borders (due to the difficulty of introspecting on the first argument); consider using  instead.brick)Put a border around the specified widget.brickPut a border around the specified widget with the specified label widget placed in the middle of the top horizontal border.Note that a border will wrap its child widget as tightly as possible, which means that if the child widget is narrower than the label widget, the label widget will be truncated. If you want to avoid this behavior, add a  or other space-filling wrapper to the bordered widget so that it takes up enough room to make the border horizontally able to avoid truncating the label.brick1A horizontal border. Fills all horizontal space.brickA horizontal border with a label placed in the center of the border. Fills all horizontal space.brick-A vertical border. Fills all vertical space.brickA single-character dynamic border that will react to neighboring borders, initially connecting in the given directions.brickThe label widgetbrick!The widget to put a border aroundbrickThe label widgetNonebrickA table data structure.brickA table creation exception.brick/Rows did not all have the same number of cells.brick(Some cells in the table did not use the 6 size policy for both horizontal and vertical sizing.brickRow alignment modes.brickAlign all cells to the top.brick6Center the content vertically in all cells in the row.brickAlign all cells to the bottom.brickColumn alignment modes.brickAlign all cells to the left.brick;Center the content horizontally in all cells in the column.brickAlign all cells to the right.brickConstruct a new table.The argument is the list of rows, with each element of the argument list being the columns of the respective row.By default, all columns are left-aligned. Use the alignment functions in this module to change that behavior.By default, all rows are top-aligned. Use the alignment functions in this module to change that behavior.By default, the table will draw borders between columns, between rows, and around the outside of the table. Border-drawing behavior can be configured with the API in this module. Note that tables always draw with  enabled.#All cells of all rows MUST use the  growth policy for both horizontal and vertical growth. If the argument list contains any cells that use the  policy, this will raise a .All rows must have the same number of cells. If not, this will raise a .brick;Configure whether the table draws a border on its exterior.brick;Configure whether the table draws borders between its rows.brick>Configure whether the table draws borders between its columns.brickAlign the specified column to the right. The argument is the column index, starting with zero.brickAlign the specified column to the left. The argument is the column index, starting with zero.brickAlign the specified column to center. The argument is the column index, starting with zero.brickAlign the specified row to the top. The argument is the row index, starting with zero.brickAlign the specified row to the middle. The argument is the row index, starting with zero.brickAlign the specified row to bottom. The argument is the row index, starting with zero.brickSet the alignment for the specified column index (starting at zero).brickSet the alignment for the specified row index (starting at zero).brickSet the default column alignment for columns with no explicitly configured alignment.brickSet the default row alignment for rows with no explicitly configured alignment.brickRender the table.None brickDialogs 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 button3Shift-tab or Left Arrow: select the previous buttonbrickThe dialog titlebrick#The dialog button labels and valuesbrick3The currently selected dialog button index (if any)brickThe maximum width of the dialogbrickCreate a dialog.brick#The default attribute of the dialogbrick,The default attribute for all dialog buttonsbrick6The attribute for the selected dialog button (extends )brickRender 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.brickObtain 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.brickThe dialog titlebrickThe currently-selected button index (starting at zero) and the button labels and values to usebrickThe maximum width of the dialogNone brickA focus ring containing a sequence of resource names to focus and a currently-focused name.brick7Construct a focus ring from the list of resource names.brick,Advance focus to the next value in the ring.brick0Advance focus to the previous value in the ring.brickThis 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  and   .brickGet the currently-focused resource name from the ring. If the ring is empty, return .brickSet the currently-focused resource name in the ring, provided the name is in the ring. Otherwise return the ring unmodified.brickGet the size of the FocusRing.brickReturn all of the entries in the focus ring, starting with the currently-focused entry and wrapping around the ring.For example, if a ring contains A, B, C, and D, and the current entry is B, the result will be [B, C, D, A].brickModify the internal circular list structure of a focus ring directly. This function permits modification of the circular list using the rich Data.CircularList API.brick5Cursor selection convenience function for use as an  ! value.brick3The focus ring to use as the source of focus state.brick2A function that takes a value and its focus state.brick7The widget state value that we need to check for focus.brickThe rest of the computation.brickThe function used to get the focus ring out of your application state.brickYour application state.brick'The list of available cursor positions.brickThe cursor position, if any, that matches the resource name currently focused by the .   None'brickA viewport scrolling handle for managing the scroll state of viewports.brickScroll the viewport horizontally by one page in the specified direction.brickScroll the viewport horizontally by the specified number of rows or columns depending on the orientation of the viewport.brick6Scroll horizontally to the beginning of the viewport.brick/Scroll horizontally to the end of the viewport.brickScroll the viewport vertically by one page in the specified direction.brickScroll the viewport vertically by the specified number of rows or columns depending on the orientation of the viewport.brick3Scroll vertically to the beginning of the viewport.brick-Scroll vertically to the end of the viewport.brick'Set the top row offset of the viewport.brick+Set the left column offset of the viewport.brickThe library application abstraction. Your application's operations are provided in an App and then the App is provided to one of the various main functions in this module. An application  App s e n+ 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 ()3), but you may define your own event type and use + to provide custom events. The state type s is the type of application state to be provided by you and iteratively modified by event handlers. The resource name type n is the type of names you can assign to rendering resources such as viewports and cursor locations. Your application must define this type.brickThis function turns your application state into a list of widget layers. The layers are listed topmost first.brickThis 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 , 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.brickThis 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 , , , and .brickThis function gets called once just prior to the first drawing of your application. Here is where you can make initial scrolling requests, for example.brick7The attribute map that should be used during rendering.brickThe default main entry point which takes an application and an initial state and returns the final state returned by a  operation.brickA 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.brickA simple application with reasonable defaults to be overridden as desired:Draws only the specified widget%Quits on any event other than resizesHas no start event handlerProvides no attribute mapNever shows any cursorsbrickAn 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 * value for simple applications using the = type that do not need to get more sophisticated user input.brickThe custom event loop entry point to use when the simpler ones don't permit enough control. Returns the final application state after the application halts.Note that this function guarantees that the terminal input state prior to the first Vty initialization is the terminal input state that is restored on shutdown (regardless of exceptions).brickLike , except the last  handle used by the application is returned without being shut down with (. This allows the caller to re-use the ? handle for something else, such as another Brick application.brickGiven a viewport name, get the viewport's size and offset information from the most recent rendering. Returns  if no such state could be found, either because the name was invalid or because no rendering has occurred (e.g. in an  handler). An important consequence of this behavior is that if this function is called before a viewport is rendered for the first time, no state will be found because the renderer only knows about viewports it has rendered in the most recent rendering. As a result, if you need to make viewport transformations before they are drawn for the first time, you may need to use  and its associated functions without relying on this function. Those functions queue up scrolling requests that can be made in advance of the next rendering to affect the viewport.brickDid the specified mouse coordinates (column, row) intersect the specified extent?brickGiven a resource name, get the most recent rendering extent for the name (if any).brickGiven 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].brick$Get the Vty handle currently in use.brickInvalidate the rendering cache entry with the specified resource name.brick&Invalidate the entire rendering cache.brickIgnore all requested cursor positions returned by the rendering process. This is a convenience function useful as an  value when a simple application has no need to position the cursor.brickAlways show the first cursor, if any, returned by the rendering process. This is a convenience function useful as an  value when a simple program has zero or more widgets that advertise a cursor position.brickShow the cursor with the specified resource name, if such a cursor location has been reported.brickBuild a viewport scroller for the viewport with the specified name.brickContinue running the event loop with the specified application state.brickContinue running the event loop with the specified application state without redrawing the screen. This is faster than  because it skips the redraw, but the drawback is that you need to be really sure that you don't want a screen redraw. If your state changed in a way that needs to be reflected on the screen, use . This function is for cases where you know that you did something that won't have an impact on the screen state and you want to save on redraw cost.brickHalt the event loop and return the specified application state as the final state value.brickSuspend the event loop, save the terminal state, and run the specified action. When it returns an application state value, restore the terminal state, empty the rendering cache, redraw the application from the new state, and resume the event loop.Note that any changes made to the terminal's input state are ignored when Brick resumes execution and are not preserved in the final terminal input state after the Brick application returns the terminal to the user.brickRequest that the specified UI element be made visible on the next rendering. This is provided to allow event handlers to make visibility requests in the same way that the visible" function does at rendering time.brickThe application.brickThe initial application state.brickThe widget to draw.brickThe initial Vty handle to use.brickAn IO action to build a Vty handle. This is used to build a Vty handle whenever the event loop needs to reinitialize the terminal, e.g. on resume after suspension.brickAn event channel for sending custom events to the event loop (you write to this channel, the event loop reads from it). Provide - if you don't plan on sending custom events.brickThe application.brickThe initial application state.brickThe initial Vty handle to use.brickAn IO action to build a Vty handle. This is used to build a Vty handle whenever the event loop needs to reinitialize the terminal, e.g. on resume after suspension.brickAn event channel for sending custom events to the event loop (you write to this channel, the event loop reads from it). Provide - if you don't plan on sending custom events.brickThe application.brickThe initial application state.++None  5678>9(brick#List state. Lists have a container t of element type e that is the data stored by the list. Internally, Lists handle the following events by default:0Up/down arrow keys: move cursor of selected itemPage 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 listThe  type synonym fixes t to ; for compatibility with previous versions of this library.'For a container type to be usable with , it must have instances of  and 6. The following functions impose further constraints::  and : : : brick The list's sequence of elements.brick*The list's selected element index, if any.brickThe list's name.brick-The height of an individual item in the list.brickOrdered container types where the order of elements can be reversed. Only required if you want to use .brickOrdered container types that can be split at a given index. An instance of this class is required for a container type to be usable with .brick(Split at the given index. Equivalent to (take n xs, drop n xs) and therefore total.brick#Slice the structure. Equivalent to (take n . drop i) xs and therefore total.#The default implementation applies  two times: first to drop elements leading up to the slice, and again to drop elements after the slice.brick An alias for  specialized to use a Vector as its container type.brick= 0, indexes from the start of the list (which gets evaluated up to the target index)If pos < 05, indexes from the end of the list (which evaluates  of the list).Complexity: same as  for the container type. listMoveTo for : O(1) listMoveTo for : O(log(min(i,n-i))) brickSet the selected index for a list to the index of the first occurrence of the specified element if it is in the list, or leave the list unmodified otherwise.O(n)5. Only evaluates as much of the container as needed.brickStarting from the currently-selected position, attempt to find and select the next element matching the predicate. If there are no matches for the remainder of the list or if the list has no selection at all, the search starts at the beginning. If no matching element is found anywhere in the list, leave the list unmodified.O(n)5. Only evaluates as much of the container as needed.brick)Return a list's selected element, if any.2Only evaluates as much of the container as needed.Complexity: same as  for the container type. listSelectedElement for : O(1) listSelectedElement for : O(log(min(i, n - i))) brick:Remove all elements from the list and clear the selection.O(1)brickReverse the list. The element selected before the reversal will again be the selected one.Complexity: same as  for the container type. listReverse for : O(n) listReverse for : O(n) brickApply a function to the selected element. If no element is selected the list is not modified.Complexity: same as $ for the container type (typically O(n)).brickO(log(min(i,n-i))) .brickO(1) .brickO(n) brickO(n) brick start index bricklength brick is raised while attempting to get the file information, the  field is populated with the exception. Otherwise it is populated with the  for the file.brickGet the file type for this file info entry. If the file type could not be obtained due to an  IOException , return .brick.Get the working directory of the file browser.brickReturns whether the file browser is in search mode, i.e., the mode in which user input affects the browser's active search string and displayed entries. This is used to aid in event dispatching in the calling program.brickGet the entries chosen by the user, if any. Entries are chosen by an Enter or Space8 keypress; if you want the entry under the cursor, use .brickModify the file browser's active search string. This causes the browser's displayed entries to change to those in its current directory that match the search string, if any. If a search string is provided, it is matched case-insensitively anywhere in file or directory names.brickGenerate a textual abbreviation of a file size, e.g. "10.2M" or "12 bytes".brickBuild a list of file info entries for the specified directory. This function does not catch any exceptions raised by calling  makeAbsolute or  listDirectory, but it does catch exceptions on a per-file basis. Any exceptions caught when inspecting individual files are stored in the  field of each .The entries returned are all entries in the specified directory except for . and ... Directories are always given first. Entries are sorted in case-insensitive lexicographic order.This function is exported for those who want to implement their own file browser using the types in this module.brick?Get the file information for the file under the cursor, if any.brickHandle a Vty input event. Note that event handling can cause a directory change so the caller should be aware that  may need to be checked after handling an event in case an exception was triggered while scanning the working directory."Events handled regardless of mode: Ctrl-b: Ctrl-f: Ctrl-d: Ctrl-u: g: G: j: k: Ctrl-n: Ctrl-p: #Events handled only in normal mode:/: Enter: Space: #Events handled only in search mode:Esc, Ctrl-C: cancel search mode Text input: update search stringbrick;If the browser's current entry is selectable according to fileBrowserSelectable, add it to the selection set and return. If not, and if the entry is a directory or a symlink targeting a directory, set the browser's current path to the selected directory..Otherwise, return the browser state unchanged.brickRender a file browser. This renders a list of entries in the working directory, a cursor to select from among the entries, a header displaying the working directory, and a footer displaying information about the selected entry.Note that if the most recent file browser operation produced an exception in , that exception is not rendered by this function. That exception needs to be rendered (if at all) by the calling application..The file browser is greedy in both dimensions.brick3The base attribute for all file browser attributes.brickThe attribute used for the current directory displayed at the top of the browser.brickThe attribute used for the entry information displayed at the bottom of the browser.brick/The attribute used to render directory entries.brick2The attribute used to render block device entries.brick2The attribute used to render regular file entries.brick6The attribute used to render character device entries.brick0The attribute used to render named pipe entries.brick3The attribute used to render symbolic link entries.brick1The attribute used to render Unix socket entries.brick) @@= checkboxField alive AliveField "Alive?"This can also be used to add multiple augmentations and associates right: (withDefAttr someAttribute) @@= (str "Please check: " <+>) @@= checkboxField alive AliveField "Alive?"brick%Update the state contained in a form.This updates all form fields to be consistent with the new form state. Where possible, this attempts to maintain other input state, such as text editor cursor position.Note that since this updates the form fields, this means that any field values will be completely overwritten! This may or may not be what you want, since a user actively using the form could get confused if their edits go away. Use carefully.brick Set the focused field of a form.brick*Set a form field's concatenation function.brick$Set a form's concatenation function.brickCreate a new form with the specified input fields and an initial form state. The fields are initialized from the state using their state lenses and the first form input is focused initially.brickA form field for manipulating a boolean value. This represents  as  [X] label and  as  [ ] label.This field responds to Space8 keypresses to toggle the checkbox and to mouse clicks.brickA form field for manipulating a boolean value. This represents  as  [X] label and  as  [ ] label2. This function permits the customization of the [X] notation characters.This field responds to Space8 keypresses to toggle the checkbox and to mouse clicks.brickA form field for selecting a single choice from a set of possible choices in a scrollable list. This uses a  internally.4This field responds to the same input events that a  does.brickA form field for selecting a single choice from a set of possible choices. Each choice has an associated value and text label.This field responds to Space keypresses to select a radio button option and to mouse clicks.brickA form field for selecting a single choice from a set of possible choices. Each choice has an associated value and text label. This function permits the customization of the [*] notation characters.This field responds to Space keypresses to select a radio button option and to mouse clicks.brickA form field for using an editor to edit the text representation of a value. The other editing fields in this module are special cases of this function.-This field responds to all events handled by , including mouse events.brick4A form field using a single-line editor to edit the 0 representation of a state field value of type a. This automatically uses its  instance to validate the input. This field is mostly useful in cases where the user-facing representation of a value matches the & representation exactly, such as with .-This field responds to all events handled by , including mouse events.brick4A form field using a single-line editor to edit the 0 representation of a state field value of type a. This automatically uses its  instance to validate the input, and also accepts an additional user-defined pass for validation. This field is mostly useful in cases where the user-facing representation of a value matches the ' representation exactly, such as with $, but you don't want to accept just any .-This field responds to all events handled by , including mouse events.brickA form field using an editor to edit a text value. Since the value is free-form text, it is always valid.-This field responds to all events handled by , including mouse events.brickA form field using a single-line editor to edit a free-form text value represented as a password. The value is always considered valid and is always represented with one asterisk per password character.-This field responds to all events handled by , including mouse events.brick,The namespace for the other form attributes.brick8The attribute for form input fields with invalid values.brick8The attribute for form input fields that have the focus.brickReturns whether all form fields in the form currently have valid values according to the fields' validation functions. This is useful when we need to decide whether the form state is up to date with respect to the form input fields.brickReturns the resource names associated with all form input fields that currently have invalid inputs. This is useful when we need to force the user to repair invalid inputs before moving on from a form editing session.brickManually indicate that a field has invalid contents. This can be useful in situations where validation beyond the form element's validator needs to be performed and the result of that validation needs to be fed back into the form state.brickRender a form.For each form field, each input for the field is rendered using the implementation provided by its . The inputs are then concatenated with the field's concatenation function (see ) and are then augmented using the form field's rendering augmentation function (see ). Fields with invalid inputs (either due to built-in validator failure or due to external validation failure via ) will be displayed using the  attribute.Finally, all of the resulting field renderings are concatenated with the form's concatenation function (see ).brickRender a single form field collection. This is called internally by  but is exposed in cases where a form field state needs to be rendered outside of a , so  is probably what you want.brickDispatch an event to the appropriate form field and return a new form. This handles the following events in this order:On Tab keypresses, this changes the focus to the next field in the form.On  Shift-Tab keypresses, this changes the focus to the previous field in the form.On mouse button presses (regardless of button or modifier), the focus is changed to the clicked form field and the event is forwarded to the event handler for the clicked form field.On Left or Up, if the currently-focused field is part of a collection (e.g. radio buttons), the previous entry in the collection is focused.On Right or Down, if the currently-focused field is part of a collection (e.g. radio buttons), the next entry in the collection is focused.All other events are forwarded to the currently focused form field.In all cases where an event is forwarded to a form field, validation of the field's input state is performed immediately after the event has been handled. If the form field's input state succeeds validation using the field's validator function, its value is immediately stored in the form state using the form field's state lens. The external validation flag is ignored during this step to ensure that external validators have a chance to get the intermediate validated value. brickThe form field constructors. This is intended to be populated using the various field constructors in this module.brick3The initial form state used to populate the fields.brickThe state lens for this value.brick&The resource name for the input field.brick4The label for the check box, to appear at its right.brickThe initial form state.brickLeft bracket character.brickCheckmark character.brickRight bracket character.brickThe state lens for this value.brick&The resource name for the input field.brick4The label for the check box, to appear at its right.brickThe initial form state.brickPossible choices.brick;The state lens for the initially/finally selected element.brickList item rendering function.brickList item height in rows.brick&The resource name for the input field.brickThe initial form state.brickThe state lens for this value.brickThe available choices, in order. Each choice has a value of type a$, a resource name, and a text label.brickThe initial form state.brickLeft bracket character.brickCheckmark character.brickRight bracket character.brickThe state lens for this value.brickThe available choices, in order. Each choice has a value of type a$, a resource name, and a text label.brickThe initial form state.brickThe state lens for this value.brick&The resource name for the input field.brick,The optional line limit for the editor (see ).brickThe initialization function that turns your value into the editor's initial contents. The resulting text may contain newlines.brickThe validation function that converts the editor's contents into a valid value of type a.brick7The rendering function for the editor's contents (see ).brickA rendering augmentation function to adjust the representation of the rendered editor.brickThe initial form state.brickThe state lens for this value.brick&The resource name for the input field.brickThe initial form state.brickThe state lens for this value.brick&The resource name for the input field.brick'Additional validation step for input. $ indicates that the value is valid.brickThe initial form state.brickThe state lens for this value.brick&The resource name for the input field.brick,The optional line limit for the editor (see ).brickThe initial form state.brickThe state lens for this value.brick&The resource name for the input field.brickThe initial form state.brick&Whether the field is considered valid.brick/The name of the form field to set as (in)valid.brickThe form to modify.++5#$%&'()*+,-./0123456789:;<=>?@ABCDDEFFGHIJKLMNOPPQRSTUUVWWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzz{|}~                                                                                                                           !                           !brick-0.69-8fPK8wnxc9G5SS1rkmEJSX Brick.AttrMap Brick.BChan Brick.TypesBrick.BorderMap Brick.ThemesBrick.Widgets.Border.Style Data.IMap Brick.Util Brick.MainBrick.Widgets.CoreBrick.Widgets.ProgressBarBrick.Widgets.EditBrick.Widgets.CenterBrick.Widgets.BorderBrick.Widgets.TableBrick.Widgets.Dialog Brick.FocusBrick.Widgets.ListBrick.Widgets.FileBrowser Brick.FormsBrick.Types.TH Lens.Micro.TH makeLensesBrick.Types.CommonBrick.Types.InternallookupViewportBrick.Widgets.InternalEventM Data.TextZipperListEditappChooseCursorBrickAttrMapAttrNameattrNameattrNameComponentsattrMap forceAttrMapmergeWithDefault attrMapLookupsetDefaultAttrgetDefaultAttrapplyAttrMappings mapAttrName mapAttrNames$fIsStringAttrName$fMonoidAttrName$fSemigroupAttrName $fShowAttrMap$fGenericAttrMap$fNFDataAttrMap$fShowAttrName$fReadAttrName $fEqAttrName $fOrdAttrName$fGenericAttrName$fNFDataAttrNameBChannewBChan writeBChanwriteBChanNonBlocking readBChan readBChan2 suffixLensessuffixLensesWithLocationlocEdgeseTopeBottomeLefteRightlocLeBottomLeLeftLeRightLeTopLThemethemeDefaultAttrthemeDefaultMappingthemeCustomDefaultAttrthemeCustomMappingThemeDocumentationthemeDescriptions CustomAttrcustomFgcustomBg customStyle$fMonoidCustomAttr$fSemigroupCustomAttr $fEqTheme $fReadTheme $fShowTheme$fGenericTheme $fNFDataTheme$fEqThemeDocumentation$fReadThemeDocumentation$fShowThemeDocumentation$fGenericThemeDocumentation$fNFDataThemeDocumentation$fEqCustomAttr$fReadCustomAttr$fShowCustomAttr$fGenericCustomAttr$fNFDataCustomAttr customBgL customFgL customStyleLthemeCustomDefaultAttrLthemeCustomMappingLthemeDefaultAttrLthemeDefaultMappingLthemeDescriptionsLnewThemethemeToAttrMapapplyCustomizationsloadCustomizationssaveCustomizations saveTheme BorderStyle bsCornerTL bsCornerTR bsCornerBR bsCornerBLbsIntersectFull bsIntersectL bsIntersectR bsIntersectT bsIntersectB bsHorizontal bsVerticaldefaultBorderStyleborderStyleFromCharasciiunicode unicodeBoldunicodeRounded$fShowBorderStyle$fReadBorderStyle$fEqBorderStyle$fGenericBorderStyle$fNFDataBorderStyleRunlenvalIMap unsafeRunsemptynull singletoninsertdeleterestrictlookupsplitLE addToKeysintersectionWithmapMaybefromListunsafeToAscList unsafeUnion$fTraversableRun $fFoldableRun$fApplicativeIMap $fOrdIMap$fEqIMap $fShowIMap $fFunctorIMap $fReadIMap $fGenericIMap $fNFDataIMap$fEqRun$fOrdRun $fReadRun $fShowRun $fFunctorRun $fGenericRun $fNFDataRun BorderMapemptyCoordinates coordinatesboundsvaluesinsertHinsertV lookupRow lookupCollookupHlookupVsetCoordinatescropexpand translate $fEqBorderMap$fOrdBorderMap$fShowBorderMap$fFunctorBorderMap$fReadBorderMap$fGenericBorderMap$fNFDataBorderMapContext ctxAttrName availWidth availHeight windowWidth windowHeightctxBorderStyle ctxAttrMap ctxDynBordersClickableScrollbarElementSBHandleBefore SBHandleAfterSBBarSBTroughBefore SBTroughAfter BrickEventVtyEventAppEvent MouseDownMouseUpResultimagecursorsvisibilityRequestsextentsborders DynBorderdbStyledbAttr dbSegments BorderSegmentbsAcceptbsOfferbsDrawCursorLocationcursorLocationcursorLocationNamecursorLocationVisibleTerminalLocationlocationColumnLlocationColumn locationRowL locationRow DirectionUpDownNextExtent extentNameextentUpperLeft extentSize ViewportTypeVertical HorizontalBothViewportVP_vpLeft_vpTop_vpSize_vpContentSizeVisibilityRequestVR vrPositionvrSizeScrollbarRendererrenderScrollbarrenderScrollbarTroughrenderScrollbarHandleBeforerenderScrollbarHandleAfterHScrollBarOrientationOnBottomOnTopVScrollBarOrientationOnLeftOnRightRenderM RenderStateWidgethSizevSizerenderSizeFixedGreedy getContext emptyResult vrPositionLvrSizeLcursorLocationLcursorLocationNameL availHeightL availWidthL ctxAttrMapL ctxAttrNameLctxBorderStyleLctxDynBordersLctxHScrollBarOrientationLctxHScrollBarRendererLctxVScrollBarOrientationLctxVScrollBarRendererL windowHeightL windowWidthLdbAttrL dbSegmentsLdbStyleLbordersLcursorsLextentsLimageLvisibilityRequestsL bsAcceptLbsDrawLbsOfferL vpContentSizevpLeftvpSizevpTopclamponfgbgclOffset runEventMPaddingPadMaxhandleEventLensedattrLlookupAttrName $fTerminalLocationCursorLocation$fFunctorEventM$fApplicativeEventM $fMonadEventM$fMonadIOEventM$fMonadThrowEventM$fMonadCatchEventM$fMonadMaskEventM$fMonadFailEventM renderFinal cropToContextNamedgetName TextWidth textWidthwithBorderStyle joinBordersseparateBorders freezeBorders emptyWidgetaddResultOffset reportExtent clickablestrWrap strWrapWithtxtWrap txtWrapWithstrtxt hyperlinkpadLeftpadRightpadTop padBottom padLeftRight padTopBottompadAllfillvBoxhBoxhLimit hLimitPercentvLimit vLimitPercentsetAvailableSizewithAttr modifyDefAttr withDefAttr updateAttrMap forceAttr overrideAttrraw translateBy relativeTo cropLeftBy cropLeftTo cropRightBy cropRightTo cropTopBy cropTopTo cropBottomBy cropBottomTo showCursor putCursorcachedwithVScrollBarswithVScrollBarHandleswithVScrollBarRendererverticalScrollbarRendererwithHScrollBarswithClickableHScrollBarswithClickableVScrollBarswithHScrollBarHandleswithHScrollBarRendererhorizontalScrollbarRendererviewport scrollbarAttrscrollbarTroughAttrscrollbarHandleAttrverticalScrollbarhorizontalScrollbarunsafeLookupViewportvisible visibleRegion<+><=> $fTextWidthf$fTextWidthTextprogressCompleteAttrprogressIncompleteAttr progressBarEditor editContents editorName DecodeUtf8 decodeUtf8 editContentsLhandleEditorEvent editorTexteditor applyEditeditAttreditFocusedAttrgetEditContents renderEditor$fNamedEditorn $fShowEditor$fDecodeUtf8[]$fDecodeUtf8TexthCenter hCenterLayer hCenterWithvCenter vCenterLayer vCenterWithcenter centerWith centerLayer centerAbout borderAttr borderElemborderborderWithLabelhBorderhBorderWithLabelvBorderjoinableBorderTableTableExceptionTEUnequalRowSizesTEInvalidCellSizePolicy RowAlignmentAlignTop AlignMiddle AlignBottomColumnAlignment AlignLeft AlignCenter AlignRighttablesurroundingBorder rowBorders columnBorders alignRight alignLeft alignCenteralignTop alignMiddle alignBottomsetColAlignmentsetRowAlignmentsetDefaultColAlignmentsetDefaultRowAlignment renderTable$fExceptionTableException$fEqTableException$fShowTableException$fReadTableException$fEqRowAlignment$fShowRowAlignment$fReadRowAlignment$fEqColumnAlignment$fShowColumnAlignment$fReadColumnAlignmentDialog dialogTitle dialogButtonsdialogSelectedIndex dialogWidthdialogButtonsLdialogSelectedIndexL dialogTitleL dialogWidthLhandleDialogEventdialog dialogAttr buttonAttrbuttonSelectedAttr renderDialogdialogSelection FocusRing focusRing focusNext focusPrev withFocusRingfocusGetCurrentfocusSetCurrentfocusRingLengthfocusRingToListfocusRingModifyfocusRingCursorViewportScroll hScrollPage hScrollByhScrollToBeginning hScrollToEnd vScrollPage vScrollByvScrollToBeginning vScrollToEndsetTopsetLeftAppappDrawappHandleEvent appStartEvent appAttrMap defaultMain simpleMain simpleApp resizeOrQuit customMaincustomMainWithVty clickedExtent lookupExtentfindClickedExtents getVtyHandleinvalidateCacheEntryinvalidateCachegetRenderStateresetRenderStateneverShowCursorshowFirstCursorshowCursorNamedviewportScrollcontinuecontinueWithoutRedrawhaltsuspendAndResume makeVisible GenericList listElements listSelectedlistNamelistItemHeight$fFunctorGenericList$fFoldableGenericList$fTraversableGenericList$fShowGenericList$fGenericGenericList Reversiblereverse SplittablesplitAtslice listElementsLlistItemHeightL listNameL listSelectedLhandleListEventhandleListEventVilistMoveToBeginning listMoveToEndlistAttrlistSelectedAttrlistSelectedFocusedAttrlist renderListrenderListWithIndex listInsert listRemove listReplace listMoveUplistMovePageUp listMoveDownlistMovePageDownlistMoveByPages listMoveBy listMoveTolistMoveToElement listFindBylistSelectedElement listClear listReverse listModify$fNamedGenericListn$fSplittableSeq$fSplittableVector$fReversibleSeq$fReversibleVectorFileType RegularFile BlockDeviceCharacterDevice NamedPipe Directory SymbolicLink UnixSocketFileInfofileInfoFilenamefileInfoSanitizedFilenamefileInfoFilePathfileInfoFileStatusfileInfoLinkTargetType FileStatusfileStatusSizefileStatusFileType FileBrowserfileBrowserExceptionfileBrowserSelectable$fShowFileInfo $fEqFileInfo$fShowFileStatus$fEqFileStatus$fReadFileType$fShowFileType $fEqFileTypefileBrowserSelectableLfileBrowserEntriesGfileBrowserEntryFilterGfileBrowserExceptionGfileBrowserLatestResultsGfileBrowserNameGfileBrowserSearchStringGfileBrowserSelectableGfileBrowserSelectedFilesGfileBrowserWorkingDirectoryGfileInfoFilePathLfileInfoFileStatusLfileInfoFilenameLfileInfoLinkTargetTypeLfileInfoSanitizedFilenameLfileStatusFileTypeLfileStatusSizeLnewFileBrowserselectNonDirectoriesselectDirectoriessetFileBrowserEntryFiltersetWorkingDirectory getFileInfofileInfoFileTypegetWorkingDirectoryfileBrowserIsSearchingfileBrowserSelectionupdateFileBrowserSearchprettyFileSizeentriesForDirectoryfileBrowserCursoractionFileBrowserBeginSearchactionFileBrowserSelectEnteractionFileBrowserSelectCurrentactionFileBrowserListPageUpactionFileBrowserListPageDownactionFileBrowserListHalfPageUp!actionFileBrowserListHalfPageDownactionFileBrowserListTopactionFileBrowserListBottomactionFileBrowserListNextactionFileBrowserListPrevhandleFileBrowserEventmaybeSelectCurrentEntryrenderFileBrowserfileBrowserAttrfileBrowserCurrentDirectoryAttrfileBrowserSelectionInfoAttrfileBrowserDirectoryAttrfileBrowserBlockDeviceAttrfileBrowserRegularFileAttrfileBrowserCharacterDeviceAttrfileBrowserNamedPipeAttrfileBrowserSymbolicLinkAttrfileBrowserUnixSocketAttrfileBrowserSelectedAttr fileTypeMatchfileExtensionMatchForm formFocus formStateFormFieldStateformFieldState formFieldLensformFieldUpdate formFieldsformFieldRenderHelperformFieldConcat FormField formFieldNameformFieldValidateformFieldExternallyValidformFieldRenderformFieldHandleEvent@@=updateFormState setFormFocussetFieldConcat setFormConcatnewForm checkboxFieldcheckboxCustomField listField radioFieldradioCustomField editFieldeditShowableFieldeditShowableFieldWithValidate editTextFieldeditPasswordFieldformAttrinvalidFormInputAttrfocusedFormInputAttrallFieldsValid invalidFields setFieldValid renderFormrenderFormFieldStatehandleFormEvent!vty-5.35.1-INkYPNPR6iuLgNWd3So1POGraphics.Vty.AttributesAttrbaseGHC.Basemappend<>ghc-prim GHC.TypesTrueFalseorigincontainers-0.6.2.1Data.IntMap.InternalIntMapmapKeysMonotonic<*>CharctxVScrollBarOrientationctxVScrollBarRendererctxHScrollBarOrientationctxHScrollBarRendererctxVScrollBarShowHandlesctxHScrollBarShowHandlesctxVScrollBarClickableConstrctxHScrollBarClickableConstrEventROeventViewportMapeventVtyHandle latestExtentsoldStateContinueContinueWithoutRedrawSuspendAndResumeHalt EventStateESesScrollRequestscacheInvalidateRequestsrequestedVisibleNamesCacheInvalidateRequestInvalidateSingleInvalidateEntireRS viewportMaprsScrollRequests observedNames renderCacheclickableNamesrequestedVisibleNames_reportedExtents ScrollRequest HScrollBy HScrollPageHScrollToBeginning HScrollToEnd VScrollBy VScrollPageVScrollToBeginning VScrollToEndSetTopSetLeftclickableNamesLobservedNamesL renderCacheLreportedExtentsLrequestedVisibleNames_LrsScrollRequestsL viewportMapLcursorLocationVisibleLctxHScrollBarClickableConstrLctxHScrollBarShowHandlesLctxVScrollBarClickableConstrLctxVScrollBarShowHandlesLlookupReportedExtentcropResultToContextrenderDynBorder Data.FoldablelengthString text-1.2.3.2Data.Text.InternalTextGraphics.Vty.Image DisplayRegion Data.EitherLeft GHC.MaybeNothingGraphics.Vty.Input.EventsEvent Graphics.VtyVtyshutdown&vector-0.12.3.1-41smozj8CfI8J9xSQ8WfCz Data.VectorVectorData.Traversable Traversable Applicative SemigroupMonoidData.Sequence.InternalSeqJusttraversefileBrowserEntryFilterLMaybeIntIOgetInvalidFieldsGHC.ShowShowGHC.ReadRead