h*9!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq r s t u v wx y z { | } ~                                                                                                                                          2.4! Safe-Inferred<>nbrickAn 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: attrName "window" <> attrName "border" attrName "window" <> attrName "title" attrName "header" <> attrName "clock" <> attrName "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 []. 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 (attrName "foo" <> attrName "bar") (attrMap a []) == a attrMapLookup (attrName "foo" <> attrName "bar") (attrMap (bg blue) [(attrName "foo" <> attrName "bar", fg red)]) == red `on` blue attrMapLookup (attrName "foo" <> attrName "bar") (attrMap (bg blue) [(attrName "foo" <> attrName "bar", red on cyan)]) == red `on` cyan attrMapLookup (attrName "foo" <> attrName "bar") (attrMap (bg blue) [(attrName "foo" <> attrName "bar", fg red), ("foo", bg cyan)]) == red `on` cyan attrMapLookup (attrName "foo" <> attrName "bar") (attrMap (bg blue) [(attrName "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-Inferred"DbrickBChan9 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$$brick'A bidirectional mapping between events k and their user-readable names.%brick Build a new $ map from the specified list of events and names. Key event names are stored in lowercase.Calls  if any events have the same name (ignoring case) or if multiple names map to the same event.&brick Convert the $ to a list.'brickLook up the specified event name to get its abstract event. The lookup ignores leading and trailing whitespace as well as case.(brick,Given an abstract event, get its event name.$%&'($%&'( Safe-Inferred%+brickA keybinding involving modifiers should have its key character normalized to lowercase since it's impossible to get uppercase keys from the terminal when modifiers are present.++ Safe-Inferred6g,brick.The class of types that can form the basis of 3s.This is provided to make it easy to write and modify bindings in less verbose ways.-brickBinding constructor..brick*A configuration of custom key bindings. A . stores everything needed to resolve a key event into one or more key bindings. Make a . with 8, then use it to dispatch to KeyEventHandlers with . Make a new . with 8.A . stores:9A collection of named key events, mapping the event type k to Text labels.For each event k, optionally store a list of default key bindings for that event.An optional customized binding list for each event, setting the event to either 23 or providing explicit overridden bindings with 1.brickThe list of custom binding states for events with custom bindings. We use a list to ensure that we preserve key bindings for keys that are mapped to more than one event. This may be valid or invalid depending on the events in question; whether those bindings constitute a collision is up to the application developer to check./brickThe base mapping of events and their names that is used in this configuration.brick , if any.>brickReturn all active key bindings for the specified event. This returns customized bindings if any have been set in the .7, no bindings if the event has been explicitly set to 2, or the default bindings if the event is absent from the customized bindings.?brickAdd Meta to a binding. If the binding is for a character key, force it to lowercase.@brickAdd Ctrl to a binding. If the binding is for a character key, force it to lowercase.AbrickAdd Shift to a binding. If the binding is for a character key, force it to lowercase.BbrickFunction key binding.8brick0The base mapping of key events and names to use.brickDefault bindings by key event, such as from a configuration file or embedded code. Optional on a per-event basis.brickCustom bindings by key event, such as from a configuration file. Explicitly setting an event to 2 here has the effect of disabling its default bindings. Optional on a per-event basis. Note that this function does not check for collisions since it is up to the application to determine whether a key bound to more than one event constitutes a collision!./80123456,-7B?@A;=<>9:.80123456,-7B?@A;=<>9/: Safe-InferredF_Nbrick$A handler for an abstract key event.In general, you should never need to create these manually. Instead, use b and c. The internals of this type are exposed to allow inspection of handler data for e.g. custom help generation.PbrickThe handler to invoke.QbrickThe trigger for the handler.RbrickA trigger for an event handler.Sbrick4The key event is always triggered by a specific key.Tbrick%The trigger is an abstract key event.UbrickA handler for a specific key.In general, you should never need to create one of these manually. The internals are exposed to make inspection easy.WbrickThe handler to invoke. Note that this maintains the original abstract key event handler; this allows us to obtain the original R for the N upon which this U is built. This can be important for keybinding consistency checks or collision checks as well as help text generation.Xbrick;The specific key binding that should trigger this handler.YbrickA Y represents a handler implementation to be invoked in response to some event that runs in the monad m.In general, you should never need to make one of these manually. Instead, use b and c. This type's internals are exposed for easy inspection, not construction.[brick+The description of this handler's behavior.\brick0The action to take when this handler is invoked.]brick.A dispatcher keys that map to abstract events k& and whose handlers run in the monad m.^brickFind the key handler that matches a Vty key event, if any. Modifier order is unimportant since the lookup for a matching binding ignores modifier order.This works by looking up an event handler whose binding is the specified key and modifiers based on the . that was used to build the ].7Ordinarily you will not need to use this function; use _; instead. This is provided for more direct access to the ] internals._brick0Handle a keyboard event by looking it up in the ] and invoking the matching binding's handler if one is found. Return True5 if the a matching handler was found and run; return False# if no matching binding was found.`brickBuild a ], to dispatch keys to handle events of type k using actions in a Monad m3. If any collisions are detected, this fails with  and returns the list of colliding event handlers for each overloaded binding. (Each returned U contains the original N that was used to build it so those can be inspected to understand which handlers are mapped to the same key, either via an abstract key event using b+ or via a statically configured key using c.)(This works by taking a list of abstract Ns and building a ] of event handlers based on specific Vty keys using the provided .- to map between abstract key events of type k5 and Vty keys. Event handlers triggered by an event k are set up to be triggered by either the customized bindings for k in the ., no bindings at all if the . has marked k as 2, or the default bindings for k otherwise.Once you have a ], you can dispatch an input key event to it and invoke the corresponding handler (if any) with _.abrickConvert a key dispatcher to a list of pairs of bindings and their handlers.bbrick.Specify a handler for the specified key event.cbrick(Specify a handler for the specified key._brickThe dispatcher to use.brickThe key to handle.brick"The modifiers for the key, if any.bbrick9The key event whose bindings should trigger this handler.brickThe description of the handler.brickThe handler to invoke.cbrick-The binding that should trigger this handler.brickThe description of the handler.brickThe handler to invoke.]`_bcYZ[\UVWXNOPQRSTa^]`_bcYZ[\UVWXNOPQRSTa^ Safe-Inferred"Ogbrick Parse a key binding list into a 0.%A key binding list either the string  "unbound"" or is a comma-separated list of 3s parsed with h.hbrickParse a key binding string. Key binding strings specify zero or more modifier keys and a base key, separated by hyphens. (modifier "-")* key e.g. c-down,  backspace,  ctrl-shift-f1. where each modifier) is parsed case-insensitively as follows: "s", "shift":  "m", "meta":  "a", "alt": "c", "ctrl", "control": and key) is parsed case-insensitively as follows:"f1", "f2", ...: "esc":  "backspace":  "enter": "left":  "right": "up": "down":  "upleft":  "upright":  "downleft":  "downright":  "center":  "backtab": "printscreen":  "pause":  "insert": "home": "pgup": "del": "end":  "pgdown":  "begin": "menu":  "space": ' '"tab": '\t' Otherwise, ibrickParse custom key bindings from the specified INI file using the provided event name mapping.4Each line in the specified section can take the form ( = <"unbound"|[binding,...]>where the event name must be a valid event name in the specified $( and each binding is valid as parsed by h.Returns Nothing if the named section was not found; otherwise returns a (possibly empty) list of binding states for each event in evs.jbrickParse custom key bindings from the specified INI file path. This does not catch or convert any exceptions resulting from I/O errors. See i for details.kbrickThe low-level INI parser for custom key bindings used by this module, exported for applications that use the  config-ini package.ibrickThe key event name mapping to use to parse the configuration data.brick3The name of the INI configuration section to read.brick%The text of the INI document to read.jbrickThe key event name mapping to use to parse the configuration data.brick3The name of the INI configuration section to read.brick!The path to the INI file to read.hg+ijkhg+ijk  Safe-InferredQlbrickA 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.mbrickA more general version of l that allows customization of the lens-building rules and allows customization of the suffix.lm# Safe-Inferred9<>RBnbrickA terminal screen location.pbrick (Column, Row)brickThe origin (upper-left corner).nopwqrstuv{xzy  Safe-Inferred"<>]_|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 ). We keep the defaults separate from customizations to permit users to serialize themes and their customizations to, say, disk files.~brickThe default attribute to use.brick%The default attribute mapping to use.brick0Customization for the theme's default attribute.brickCustomizations 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.brick'Documentation for a theme's attributes.brickThe per-attribute documentation for a theme so e.g. documentation for theme customization can be generated mechanically.brickAn 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.brickCreate a new theme with the specified default attribute and attribute mapping. The theme will have no customizations.brick Build an  from a |3. This applies all customizations in the returned .brickThis function is lossy in the sense that we only internally support 240 colors but the #RRGGBB format supports 16^3 colors.brickApply customizations using a custom lookup function. Customizations are obtained for each attribute name in the theme. Any customizations already set are lost.brickLoad 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.brickSave 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.brick=An optional customization for the theme's default attribute.brickA function to obtain a customization for the specified attribute.brickThe theme to customize.|}~|}~  Safe-Inferred<>abrickA border style for use in any widget that needs to render borders in a consistent style.brickTop-left corner characterbrickTop-right corner characterbrickBottom-right corner characterbrickBottom-left corner characterbrickFull intersection (cross)brickh brickRun n a represents n copies of the value a.brickSemantically,  and  are identical; but  is more efficient when large sequences of contiguous keys are mapped to the same value.brick This function is unsafe because s that compare equal may split their runs into different chunks; consumers must promise that they do not treat run boundaries specially.brickGiven a range of keys (as specified by a starting key and a length for consistency with other functions in this module), restrict the map to keys in that range. restrict k r m is equivalent to ,intersectionWith const m (insert k r empty) but potentially more efficient.brick splitLE n m produces a tuple (le, gt) where le has all the associations of m where the keys are <= n and gt has all the associations of m where the keys are > n.brick6Increment all keys by the given amount. This is like /, but restricted to partially-applied addition.brick This function is unsafe because s 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.  Safe-Inferred9<>tbrickA  BorderMap a is like a Map Location a., except that there is a rectangle, and only n5s 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.brickInternal use only.brickGiven a rectangle (specified as the coordinates of the top, left, bottom, and right sides), initialize an empty .brick An empty * that tracks the same points as the input.brick An empty  that does not track any points.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 n 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 n'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 n! gives the start point, and the + extends in the "larger columns" direction.brick2Bulk insertion of vertically-adjacent values. The n! gives the start point, and the ( 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 " returned maps columns to values.brick*Look up all values on a given column. The  returned maps rows to values.brick1Bulk lookup of horizontally-adjacent values. The n$ gives the starting point, and the 1 extends in the "larger columns" direction. The ! returned maps columns to values.brick/Bulk lookup of vertically-adjacent values. The n$ gives the starting point, and the . extends in the "larger rows" direction. The  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 n to all keys in the map.brickAssumes the two s are tracking the same rectangles, but have disjoint keys. This property is not checked.qrstuv{xzyqrstuv{xzy$ Safe-Inferred9<>ZbrickThe 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 size of the display region in which to render the layers. Safe-Inferred"brickThe process of rendering widgets in a box layout is exactly the same except for the dimension under consideration (width vs. height), in which case all of the same operations that consider one dimension in the layout algorithm need to be switched to consider the other. Because of this we fill a BoxRenderer with all of the functions needed to consider the "primary" dimension (e.g. vertical if the box layout is vertical) as well as the "secondary" dimension (e.g. horizontal if the box layout is vertical). Doing this permits us to have one implementation for box layout and parameterizing on the orientation of all of the operations.brickThe type of padding.brick/Pad by the specified number of rows or columns.brick2Pad up to the number of available rows or columns.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, visibility 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 . 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 string should not contain escape sequences or carriage returns.brickBuild a widget from a  value. 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 text should not contain escape sequences or carriage returns.brick=Take up to the given width, having regard to character width.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).Allocates space to  elements first and % elements second. For example, if a  contains three elements A, B, and C , and if A and B are , then  first renders A and B3. Suppose those two take up 10 rows total, and the  was given 50 rows. This means * then allocates the remaining 40 rows to C. If, on the other hand, A and B take up 50 rows together, C will not be rendered at all.If all elements are ,  allocates the available height evenly among the elements. So, for example, if a ' is rendered in 90 rows and has three 3 elements, each element will be allocated 30 rows.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).Allocates space to  elements first and & elements second. For example, if an  contains three elements A, B, and C , and if A and B are , then  first renders A and B7. Suppose those two take up 10 columns total, and the " was given 50 columns. This means - then allocates the remaining 40 columns to C. If, on the other hand, A and B take up 50 columns together, C will not be rendered at all.If all elements are ,  allocates the available width evenly among the elements. So, for example, if an * is rendered in 90 columns and has three 6 elements, each element will be allocated 30 columns.brick>Render a series of widgets in a box layout in the order given.The growth policy of a box layout is the most unrestricted of the growth policies of the widgets it contains, so to determine the hSize and vSize of the box we just take the maximum (using the Ord instance for Size) of all of the widgets to be rendered in the box.Then the box layout algorithm proceeds as follows. We'll use the vertical case to concretely describe the algorithm, but the horizontal case can be envisioned just by exchanging all "vertical""horizontal" and "rows"%"columns", etc., in the description.The growth policies of the child widgets determine the order in which they are rendered, i.e., the order in which space in the box is allocated to widgets as the algorithm proceeds. This is because order matters: if we render greedy widgets first, there will be no space left for non-greedy ones.#So we render all widgets with size  in the vertical dimension first. Each is rendered with as much room as the overall box has, but we assume that they will not be greedy and use it all. If they do, maybe it's because the terminal is small and there just isn't enough room to render everything.Then the remaining height is distributed evenly amongst all remaining (greedy) widgets and they are rendered in sub-boxes that are as high as this even slice of rows and as wide as the box is permitted to be. We only do this step at all if rendering the non-greedy widgets left us any space, i.e., if there were any rows left.After rendering the non-greedy and then greedy widgets, their images are sorted so that they are stored in the order the original widgets were given. All cursor locations and visibility requests in each sub-widget are translated according to the position of the sub-widget in the box.All images are padded to be as wide as the widest sub-widget to prevent attribute over-runs. Without this step the attribute used by a sub-widget may continue on in an undesirable fashion until it hits something with a different attribute. To prevent this and to behave in the least surprising way, we pad the image on the right with whitespace using the context's current attribute.Finally, the padded images are concatenated together vertically and returned along with the translated cursor positions and visibility requests.brickGiven borders that should be placed next to each other (the first argument on the right or bottom, and the second argument on the left or top), compute new borders and the rewrites that should be done along the edges of the two images to keep the image in sync with the border information.The input borders are assumed to be disjoint. This property is not checked.brickGiven a direction to concatenate borders in, and the border information itself (which list is assumed to be already shifted so that borders do not overlap and are strictly increasing in the primary direction), produce: a list of rewrites for the lo and hi directions of each border, respectively, and the borders describing the fully concatenated object.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 make further changes to the active drawing attribute, so this only takes effect if nothing in the specified widget invokes  or otherwise changes the rendering context's attribute setup. 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 ("Brick", "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 ("Brick", "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.brickLike , except that the style of attribute lookups in the attribute map is preserved and merged with the forced attribute. This allows for situations where  would otherwise ignore style information that is important to preserve.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. If the specified name has no reported extent, this just draws the specified widget with no special positioning.This is only useful for positioning something in a higher layer relative to a reported extent in a lower layer. Any other use is likely to result in the specified widget being rendered as-is with no translation. This is because this function relies on information about lower layer renderings in order to work; using it with a resource name that wasn't rendered in a lower layer will result in this being equivalent to id.$For example, if you have two layers topLayer and  bottomLayer, then a widget drawn in  bottomLayer with reportExtent Foo1 can be used to relatively position a widget in topLayer with topLayer = relativeTo Foo ....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  or  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 renderer and settings.: 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  valuesbrick4Apply an editing operation to the editor's contents.This is subject to the restrictions of the underlying text zipper; for example, if the underlying zipper has a line limit configured, any edits applied here will be ignored if they edit text outside the line limit.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.brick4Get the cursor position of the editor (row, column).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. Safe-Inferred. 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.   Safe-Inferred"6M brick$The top-level border attribute name.brick4The horizontal border attribute name. Inherits from .brick2The vertical border attribute name. Inherits from .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.brick>A horizontal border. Fills all horizontal space. Draws using .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. Draws using .brick Initialize a  . It will be n and ing in the given directions to begin with, and accept join offers from all directions. We consult the context to choose the  and .This is likely to be useful only for custom widgets that need more complicated dynamic border behavior than , , or  offer.brick Replace the 's dynamic borders with the given one, provided the context says to use dynamic borders at all.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 widget   Safe-InferredK^#brickThe result of performing table cell intermediate rendering and layout.brick%The table's cells in row-major order.brick"The widths of the table's columns.brick The heights of the table's rows.brick The border configuration to use.brick#A border configuration for a table.brick+A table data structure for widgets of type  n. Create a table with .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. Use these modes with the alignment functions in this module to configure row alignment behavior.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. Use these modes with the alignment functions in this module to configure column alignment behavior.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 the topmost row first, with each element of the argument list being the contents of the cells in in each column of the respective row, with the leftmost cell first.Each row's height is determined by the height of the tallest cell in that row, and each column's width is determined by the width of the widest cell in that column. This means that control over row and column dimensions is a matter of controlling the size of the individual cells, such as by wrapping cell contents in padding,  and  or , etc. This also means that it is not necessary to explicitly set the width of most table cells because the table will determine the per-row and per-column dimensions by looking at the largest cell contents. In particular, this means that the table's alignment logic only has an effect when a given cell's contents are smaller than the maximum for its row and column, thus giving the table some way to pad the contents to result in the desired alignment. By default:All columns are left-aligned. Use the alignment functions in this module to change that behavior.All rows are top-aligned. Use the alignment functions in this module to change that behavior.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. If a cell's contents has smart borders but you don't want those borders to connect to the surrounding table borders, wrap the cell's contents with .#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 function will raise a .All rows MUST have the same number of cells. If not, this function 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. Silently does nothing if the index is out of range.brickAlign the specified column to the left. The argument is the column index, starting with zero. Silently does nothing if the index is out of range.brickAlign the specified column to center. The argument is the column index, starting with zero. Silently does nothing if the index is out of range.brickAlign the specified row to the top. The argument is the row index, starting with zero. Silently does nothing if the index is out of range.brickAlign the specified row to the middle. The argument is the row index, starting with zero. Silently does nothing if the index is out of range.brickAlign the specified row to bottom. The argument is the row index, starting with zero. Silently does nothing if the index is out of range.brickSet the alignment for the specified column index (starting at zero). Silently does nothing if the index is out of range.brickSet the alignment for the specified row index (starting at zero). Silently does nothing if the index is out of range.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.brickAugment rendered table cells with borders according to the border configuration accompanying the cells.brickGiven a "table row" of widgets, align each one according to the list of specified column alignments in columns of the specified widths.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))) brick)Split-based clamp that avoids evaluating  of the structure (unless the structure is already fully evaluated).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.brick4Traversal that targets the selected element, if any.Complexity: depends on usage as well as the list's container type. listSelectedElementL for : O(1) -- preview, fold O(n) -- set, modify, traverse listSelectedElementL for +: O(log(min(i, n - i))) -- all operations 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)).Complexity: same as  for the list's container type. listModify for : O(n) listModify for : O(log(min(i, n - i))) 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: Ctrl-n: Ctrl-p: #Events handled only in normal mode:/: Enter: Space: g: G: j: k: #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.brickSanitize a filename for terminal display, replacing non-printable characters with ?.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.brick9:YZ[\]UVWXNOPQRST`_bca^+hgijk Safe-Inferred ")*!00brickA form: a sequence of input fields that manipulate the fields of an underlying state that you choose. This value must be stored in the Brick application's state.Type variables are as follows:s - the data type of your choosing containing the values manipulated by the fields in this form.e - your application's event typen( - your application's resource name typebrickThe focus ring for the form, indicating which form field has input focus.brickThe current state of the form. Forms guarantee that only valid inputs ever get stored in the state, and that after each input event on a form field, if that field contains a valid state value then the value is immediately saved to its corresponding field in this state value using the form field's lens over s.brick8Concatenation function for this form's field renderings.brickA form field state accompanied by the fields that manipulate that state. The idea is that some record field in your form state has one or more form fields that manipulate that value. This data type maps that state field (using a lens into your state) to the form input fields responsible for managing that state field, along with a current value for that state field and an optional function to control how the form inputs are rendered.Most form fields will just have one input, such as text editors, but others, such as radio button collections, will have many, which is why this type supports more than one input corresponding to a state field.Type variables are as follows:s - the data type containing the value manipulated by these form fields.e - your application's event typen( - your application's resource name typebrickThe current state value associated with the field collection. Note that this type is existential. All form fields in the collection must validate to this type.brickA lens to extract and store a successfully-validated form input back into your form state.brickGiven a new form state value, update the form field state in place.brickThe form fields, in order, that the user will interact with to manipulate this state value.brickA helper function to augment the rendered representation of this collection of form fields. It receives the default representation and can augment it, for example, by adding a label on the left.brick:Concatenation function for this field's input renderings.brick3This field's visibility mode for use in viewports.brickHow to bring form fields into view when a form is rendered in a viewport with .brickMake only the focused field's selected input visible. For composite fields this will not bring all options into view.brickMake all inputs in the focused field visible. For composite fields this will bring all options into view as long as the viewport is large enough to show them all.brickLike 4 but includes rendering augmentations applied with .brickA form field. This represents an interactive input field in the form. Its user input is validated and thus converted into a type of your choosing.Type variables are as follows:a - the type of the field in your form state that this field manipulatesb' - the form field's internal state typee - your application's event typen( - your application's resource name typebrick%The name identifying this form field.brickA validation function converting this field's state into a value of your choosing. Nothing indicates a validation failure. For example, this might validate an  state value by parsing its text contents as an integer and return  . This is for pure value validation; if additional validation is required (e.g. via ), use this field's state value in an external validation routine and use ( to feed the result back into the form.brickWhether the field is valid according to an external validation source. Defaults to always being  and can be set with 8. The value of this field also affects the behavior of  and .brickA function to render this form field. Parameters are whether the field is currently focused, followed by the field state.brick An event handler for this field.brickCompose a new rendering augmentation function with the one in the form field collection. For example, we might put a label on the left side of a form field: (str "Please check: " <+>) @@= 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.=This field's attributes are governed by those exported from .(.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's attributes are governed by those exported from .).-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's attributes are governed by those exported from .).-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's attributes are governed by those exported from .).-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's attributes are governed by those exported from .).-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's attributes are governed by those exported from .).-This field responds to all events handled by , including mouse events.brick,The namespace for the other form attributes.brickThe attribute for form input fields with invalid values. Note that this attribute will affect any field considered invalid and will take priority over any attributes that the field uses to render itself.brickThe attribute for form input fields that have the focus. Note that this attribute only affects fields that do not already use their own attributes when rendering, such as editor- and list-based fields. Those need to be styled by setting the appropriate attributes; see the documentation for field constructors to find out which attributes need to be configured.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.brickSet the visibility mode of the specified form field's collection when the form is rendered in viewport. This is used to change how focused fields are brought into view when they're outside of view in a viewport and gain focus. In practice, this means this function need only be called on one form field name in a collection in order to affect the visibility behavior of that field's entire input collection.There are two visibility modes: - this is the default behavior. In this mode, when a field receives focus, it is brought into view but other inputs in the same field collection (e.g. a set of radio buttons) will not be brought into view along with it. - in this mode, when a field receives focus, all of the inputs in its collection (e.g. a set of radio buttons) are brought into view as long as the viewport is large enough to show them all. If it isn't, the viewport will show as many as space allows. - in this mode, when a field receives focus, all of the inputs in its collection (e.g. a set of radio buttons) and its rendering augmentations (as applied with ) are brought into view as long as the viewport is large enough to show them all.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 ). A visibility request is also issued for the currently-focused form field in case the form is rendered within a viewport.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 currently focused form field. 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>The name of the form field whose visibility mode is to be set.brickThe mode to set.brickThe form to modify.brick&Whether the field is considered valid.brick/The name of the form field to set as (in)valid.brickThe form to modify.115/0123423523623789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeffghijklmnopqrstuvwxyz{|}~,  ##############                                                                                                                                      $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$      %'&&&*(#  $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%'%%&&brick-2.4-inplace Brick.Types Brick.AttrMap Brick.BChanBrick.Keybindings.KeyEventsBrick.Keybindings.NormalizeBrick.Keybindings.KeyConfigBrick.Keybindings.KeyDispatcherBrick.Keybindings.ParseBrick.BorderMap Brick.ThemesBrick.Widgets.Border.Style Data.IMap Brick.Util Brick.MainBrick.Widgets.CoreBrick.Widgets.ProgressBarBrick.Widgets.EditBrick.Widgets.CenterBrick.Widgets.BorderBrick.Widgets.Table Brick.FocusBrick.Widgets.DialogBrick.Widgets.ListBrick.Widgets.FileBrowserBrick.Keybindings.Pretty Brick.FormsbrickBrick.Keybindings.KeyHandlerMap keyDispatcherGraphics.Vty.InputKDownBrick.Types.TH Lens.Micro.TH makeLensesBrick.Types.CommonBrick.Types.InternalBrick.Types.EventMBrick.Widgets.InternalEventMListEditappChooseCursorBrick parseBindingBrick.Keybindings Brick.Widgetsmcrlns-mtl-0.2.0.3-343c3248Lens.Micro.Mtl.Internalzoom mtl-2.3.1Control.Monad.State.ClassgetsmodifygetputAttrMapAttrNameattrNameattrNameComponentsattrMap forceAttrMapforceAttrMapAllowStylemergeWithDefault attrMapLookupsetDefaultAttrgetDefaultAttrapplyAttrMappings mapAttrName mapAttrNames$fMonoidAttrName$fSemigroupAttrName $fShowAttrMap$fGenericAttrMap$fNFDataAttrMap$fShowAttrName$fReadAttrName $fEqAttrName $fOrdAttrName$fGenericAttrName$fNFDataAttrNameBChannewBChan writeBChanwriteBChanNonBlocking readBChan readBChan2 KeyEvents keyEvents keyEventsListlookupKeyEvent keyEventName $fEqKeyEvents$fShowKeyEvents normalizeKey ToBindingbind KeyConfigkeyConfigEvents BindingState BindingListUnboundBindingkbKeykbModsbinding newKeyConfigkeyEventMappingslookupKeyConfigBindingsfirstDefaultBindingallDefaultBindingsfirstActiveBindingallActiveBindingsmetactrlshiftfn$fToBindingBinding$fToBindingChar$fToBindingKey$fShowKeyConfig $fEqKeyConfig$fShowBindingState$fEqBindingState$fOrdBindingState $fEqBinding $fShowBinding $fOrdBindingKeyEventHandler kehHandlerkehEventTrigger EventTriggerByKeyByEvent KeyHandler khHandler khBindingHandlerhandlerDescription handlerAction KeyDispatcherlookupVtyEvent handleKeykeyDispatcherToListonEventonKey$fShowEventTrigger$fEqEventTrigger$fOrdEventTriggerparseBindingListkeybindingsFromInikeybindingsFromFilekeybindingIniParser 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 BorderMapemptyCoordinatesclear 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 DirectionUpDownExtent extentNameextentUpperLeft extentSize ViewportTypeVertical HorizontalBothViewportVP_vpLeft_vpTop_vpSize_vpContentSizeVisibilityRequestVR vrPositionvrSizeHScrollbarRendererrenderHScrollbarrenderHScrollbarTroughrenderHScrollbarHandleBeforerenderHScrollbarHandleAfterscrollbarHeightAllocationVScrollbarRendererrenderVScrollbarrenderVScrollbarTroughrenderVScrollbarHandleBeforerenderVScrollbarHandleAfterscrollbarWidthAllocationHScrollBarOrientationOnBottomOnTopVScrollBarOrientationOnLeftOnRightRenderM RenderStateWidgethSizevSizerenderSizeFixedGreedy getContext emptyResult vrPositionLvrSizeLcursorLocationLcursorLocationNameL availHeightL availWidthL ctxAttrMapL ctxAttrNameLctxBorderStyleLctxDynBordersLctxHScrollBarOrientationLctxHScrollBarRendererLctxVScrollBarOrientationLctxVScrollBarRendererL windowHeightL windowWidthLdbAttrL dbSegmentsLdbStyleLbordersLcursorsLextentsLimageLvisibilityRequestsL bsAcceptLbsDrawLbsOfferL vpContentSizevpLeftvpSizevpTopclamponfgbgstyleclOffset nestEventM' nestEventMattrLlookupAttrName $fTerminalLocationCursorLocation renderFinal cropToContext renderWidgetPaddingPadMaxNamedgetName TextWidth textWidthwithBorderStyle joinBordersseparateBorders freezeBorders emptyWidgetaddResultOffset reportExtent clickablestrWrap strWrapWithtxtWrap txtWrapWithstrtxt hyperlinkpadLeftpadRightpadTop padBottom padLeftRight padTopBottompadAllfillvBoxhBoxhLimit hLimitPercentvLimit vLimitPercentsetAvailableSizewithAttr modifyDefAttr withDefAttr updateAttrMap forceAttrforceAttrAllowStyle overrideAttrraw translateBy relativeTo cropLeftBy cropLeftTo cropRightBy cropRightTo cropTopBy cropTopTo cropBottomBy cropBottomTo showCursor putCursorcachedwithVScrollBarswithVScrollBarHandleswithVScrollBarRendererverticalScrollbarRendererwithHScrollBarswithClickableHScrollBarswithClickableVScrollBarswithHScrollBarHandleswithHScrollBarRendererhorizontalScrollbarRendererviewport scrollbarAttrscrollbarTroughAttrscrollbarHandleAttrverticalScrollbarhorizontalScrollbarunsafeLookupViewportvisible visibleRegion<+><=> $fTextWidthf$fTextWidthTextprogressCompleteAttrprogressIncompleteAttr progressBarEditor editContents editorName DecodeUtf8 decodeUtf8 editContentsLhandleEditorEvent editorTexteditor applyEditeditAttreditFocusedAttrgetEditContentsgetCursorPosition renderEditor$fNamedEditorn $fShowEditor$fDecodeUtf8List$fDecodeUtf8TexthCenter hCenterLayer hCenterWithvCenter vCenterLayer vCenterWithcenter centerWith centerLayer centerAbout borderAttr hBorderAttr vBorderAttr borderElemborderborderWithLabelhBorderhBorderWithLabelvBorderjoinableBorderRenderedTableCellsrenderedTableRowsrenderedTableColumnWidthsrenderedTableRowHeightsborderConfigurationBorderConfigurationdrawSurroundingBorderdrawRowBordersdrawColumnBordersTableTableExceptionTEUnequalRowSizesTEInvalidCellSizePolicy RowAlignmentAlignTop AlignMiddle AlignBottomColumnAlignment AlignLeft AlignCenter AlignRighttablesurroundingBorder rowBorders columnBorders alignRight alignLeft alignCenteralignTop alignMiddle alignBottomsetColAlignmentsetRowAlignmentsetDefaultColAlignmentsetDefaultRowAlignment renderTable addBorderstableCellLayout alignColumns$fExceptionTableException$fEqTableException$fShowTableException$fReadTableException$fEqRowAlignment$fShowRowAlignment$fReadRowAlignment$fEqColumnAlignment$fShowColumnAlignment$fReadColumnAlignment FocusRing focusRing focusNext focusPrev withFocusRingfocusGetCurrentfocusSetCurrentfocusRingLengthfocusRingToListfocusRingModifyfocusRingCursor$fShowFocusRingDialog dialogTitle dialogButtons dialogWidthdialogButtonsL dialogTitleL dialogWidthLhandleDialogEventsetDialogFocusgetDialogFocusdialog dialogAttr buttonAttrbuttonSelectedAttr renderDialogdialogSelectionViewportScroll hScrollPage hScrollByhScrollToBeginning hScrollToEnd vScrollPage vScrollByvScrollToBeginning vScrollToEndsetTopsetLeftAppappDrawappHandleEvent appStartEvent appAttrMap defaultMain simpleMain simpleApp resizeOrQuit customMaincustomMainWithDefaultVtycustomMainWithVtylookupViewport clickedExtent lookupExtentfindClickedExtents getVtyHandleinvalidateCacheEntryinvalidateCachegetRenderStateresetRenderStateneverShowCursorshowFirstCursorshowCursorNamedviewportScrollcontinueWithoutRedrawhaltsuspendAndResumesuspendAndResume' makeVisible GenericList listElements listSelectedlistNamelistItemHeight$fFunctorGenericList$fFoldableGenericList$fTraversableGenericList$fShowGenericList$fGenericGenericList Reversiblereverse SplittablesplitAtslice listElementsLlistItemHeightL listNameL listSelectedLhandleListEventhandleListEventVilistMoveToBeginning listMoveToEndlistAttrlistSelectedAttrlistSelectedFocusedAttrlist renderListrenderListWithIndex listInsert listRemove listReplace listMoveUplistMovePageUp listMoveDownlistMovePageDownlistMoveByPages listMoveBy listMoveTolistMoveToElement listFindBylistSelectedElementLlistSelectedElement listClear listReverse listModify$fNamedGenericListn$fSplittableSeq$fSplittableVector$fReversibleSeq$fReversibleVectorFileType RegularFile BlockDeviceCharacterDevice NamedPipe Directory SymbolicLink UnixSocketFileInfofileInfoFilenamefileInfoSanitizedFilenamefileInfoFilePathfileInfoFileStatusfileInfoLinkTargetType FileStatusfileStatusSizefileStatusFileType FileBrowserfileBrowserExceptionfileBrowserSelectable$fNamedFileBrowsern$fShowFileInfo $fEqFileInfo$fShowFileStatus$fEqFileStatus$fReadFileType$fShowFileType $fEqFileTypefileBrowserSelectableLfileBrowserEntriesGfileBrowserEntryFilterGfileBrowserExceptionGfileBrowserLatestResultsGfileBrowserNameGfileBrowserSearchStringGfileBrowserSelectableGfileBrowserSelectedFilesGfileBrowserWorkingDirectoryGfileInfoFilePathLfileInfoFileStatusLfileInfoFilenameLfileInfoLinkTargetTypeLfileInfoSanitizedFilenameLfileStatusFileTypeLfileStatusSizeLnewFileBrowserselectNonDirectoriesselectDirectoriessetFileBrowserEntryFiltersetWorkingDirectory getFileInfofileInfoFileTypegetWorkingDirectoryfileBrowserIsSearchingfileBrowserSelectionupdateFileBrowserSearchprettyFileSizeentriesForDirectoryfileBrowserCursoractionFileBrowserBeginSearchactionFileBrowserSelectEnteractionFileBrowserSelectCurrentactionFileBrowserListPageUpactionFileBrowserListPageDownactionFileBrowserListHalfPageUp!actionFileBrowserListHalfPageDownactionFileBrowserListTopactionFileBrowserListBottomactionFileBrowserListNextactionFileBrowserListPrevhandleFileBrowserEventmaybeSelectCurrentEntryrenderFileBrowserfileBrowserAttrfileBrowserCurrentDirectoryAttrfileBrowserSelectionInfoAttrfileBrowserDirectoryAttrfileBrowserBlockDeviceAttrfileBrowserRegularFileAttrfileBrowserCharacterDeviceAttrfileBrowserNamedPipeAttrfileBrowserSymbolicLinkAttrfileBrowserUnixSocketAttrfileBrowserSelectedAttr fileTypeMatchfileExtensionMatchkeybindingMarkdownTablekeybindingTextTablekeybindingHelpWidget ppBindingppMaybeBindingppKey ppModifierkeybindingHelpBaseAttr eventNameAttreventDescriptionAttrkeybindingAttrForm formFocus formStateFormFieldStateformFieldState formFieldLensformFieldUpdate formFieldsformFieldRenderHelperformFieldConcatformFieldVisibilityModeFormFieldVisibilityModeShowFocusedFieldOnlyShowCompositeFieldShowAugmentedField FormField formFieldNameformFieldValidateformFieldExternallyValidformFieldRenderformFieldHandleEvent$fEqFormFieldVisibilityMode$fShowFormFieldVisibilityMode@@=updateFormState setFormFocussetFieldConcat setFormConcatnewForm checkboxFieldcheckboxCustomField listField radioFieldradioCustomField editFieldeditShowableFieldeditShowableFieldWithValidate editTextFieldeditPasswordFieldformAttrinvalidFormInputAttrfocusedFormInputAttrallFieldsValid invalidFieldssetFieldVisibilityMode setFieldValid renderFormrenderFormFieldStatehandleFormEventvty-6.2-8a07c82cGraphics.Vty.AttributesAttrbaseGHC.Basemappend<>ghc-prim GHC.TypesTrueFalseGHC.ErrerrorkeyConfigCustomBindingskeyConfigDefaultBindings GHC.MaybeNothing Data.EitherLeftGraphics.Vty.Input.EventsMShiftMMetaMAltMCtrlKFunKEscKBSKEnterKLeftKRightKUpKUpLeftKUpRight KDownLeft KDownRightKCenterKBackTabKPrtScrKPauseKInsKHomeKPageUpKDelKEnd KPageDownKBeginKMenuKCharorigin parseColorcontainers-0.6.7Data.IntMap.InternalIntMapmapKeysMonotonic<*> neighborsChar NextAction ScrollRequest HScrollBy HScrollPageHScrollToBeginning HScrollToEnd VScrollBy VScrollPageVScrollToBeginning VScrollToEndSetTopSetLeftRS viewportMaprsScrollRequests observedNames renderCacheclickableNamesrequestedVisibleNames_reportedExtentscursorLocationVisibleLctxVScrollBarOrientationctxVScrollBarRendererctxHScrollBarOrientationctxHScrollBarRendererctxVScrollBarShowHandlesctxHScrollBarShowHandlesctxVScrollBarClickableConstrctxHScrollBarClickableConstrctxVScrollBarShowHandlesLctxHScrollBarShowHandlesLctxVScrollBarClickableConstrLctxHScrollBarClickableConstrL EventStateESesScrollRequestscacheInvalidateRequestsrequestedVisibleNames nextAction vtyContext VtyContextvtyContextBuildervtyContextHandlevtyContextThreadvtyContextPutEventEventROeventViewportMap latestExtentsoldStateContinueContinueWithoutRedrawHaltCacheInvalidateRequestInvalidateSingleInvalidateEntirelookupReportedExtentrsScrollRequestsL viewportMapLclickableNamesLreportedExtentsL renderCacheLobservedNamesLrequestedVisibleNames_L runEventM getVtyContextGraphics.Vty.PicturePicturecropResultToContextrenderDynBorder BoxRenderer Data.FoldablelengthString text-2.0.2Data.Text.InternalText takeColumnsT renderBox catBorders catAllBordersGraphics.Vty.Image DisplayRegionverticalScrollbar'horizontalScrollbar'txt-zppr-0.13-aba90d14Data.Text.Zipper TextZipperdynBorderFromDirections setDynBorders dialogFocus viewportNameEvent Graphics.VtyVtyshutdownvctr-0.13.1.0-a7c2f32b Data.VectorVectorData.Traversable Traversable Applicative SemigroupMonoiddrawListElementsData.Sequence.InternalSeqJust splitClamptraverseremoveTrailingSlashfileBrowserWorkingDirectoryfileBrowserEntryFilterLsanitizeFilenameKeyppCharModifier formConcatAllMaybeIntIOgetInvalidFieldsGHC.ShowShowGHC.ReadRead