SYMBOL INDEX (728 symbols across 58 files)

FILE: examples/barchart.rs
  type App (line 19) | struct App<'a> {
  function new (line 24) | fn new() -> App<'a> {
  function on_tick (line 55) | fn on_tick(&mut self) {
  function main (line 61) | fn main() -> Result<(), Box<dyn Error>> {
  function run_app (line 90) | fn run_app<B: Backend>(
  function ui (line 116) | fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {

FILE: examples/block.rs
  function main (line 16) | fn main() -> Result<(), Box<dyn Error>> {
  function run_app (line 43) | fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> io::Result<()> {
  function ui (line 55) | fn ui<B: Backend>(f: &mut Frame<B>) {

FILE: examples/canvas.rs
  type App (line 23) | struct App {
    method new (line 35) | fn new() -> App {
    method on_tick (line 54) | fn on_tick(&mut self) {
  function main (line 80) | fn main() -> Result<(), Box<dyn Error>> {
  function run_app (line 109) | fn run_app<B: Backend>(
  function ui (line 151) | fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {

FILE: examples/chart.rs
  constant DATA (line 21) | const DATA: [(f64, f64); 5] = [(0.0, 0.0), (1.0, 1.0), (2.0, 2.0), (3.0,...
  constant DATA2 (line 22) | const DATA2: [(f64, f64); 7] = [
  type SinSignal (line 33) | pub struct SinSignal {
    method new (line 41) | pub fn new(interval: f64, period: f64, scale: f64) -> SinSignal {
  type Item (line 52) | type Item = (f64, f64);
  method next (line 53) | fn next(&mut self) -> Option<Self::Item> {
  type App (line 60) | struct App {
    method new (line 69) | fn new() -> App {
    method on_tick (line 83) | fn on_tick(&mut self) {
  function main (line 97) | fn main() -> Result<(), Box<dyn Error>> {
  function run_app (line 126) | fn run_app<B: Backend>(
  function ui (line 152) | fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {

FILE: examples/custom_widget.rs
  type Label (line 17) | struct Label<'a> {
  method render (line 22) | fn render(self, area: Rect, buf: &mut Buffer) {
  function text (line 28) | fn text(mut self, text: &'a str) -> Label<'a> {
  function main (line 34) | fn main() -> Result<(), Box<dyn Error>> {
  function run_app (line 61) | fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> io::Result<()> {
  function ui (line 73) | fn ui<B: Backend>(f: &mut Frame<B>) {

FILE: examples/demo/app.rs
  constant TASKS (line 7) | const TASKS: [&str; 24] = [
  constant LOGS (line 13) | const LOGS: [(&str, &str); 26] = [
  constant EVENTS (line 42) | const EVENTS: [(&str, u64); 24] = [
  type RandomSignal (line 70) | pub struct RandomSignal {
    method new (line 76) | pub fn new(lower: u64, upper: u64) -> RandomSignal {
  type Item (line 85) | type Item = u64;
  method next (line 86) | fn next(&mut self) -> Option<u64> {
  type SinSignal (line 92) | pub struct SinSignal {
    method new (line 100) | pub fn new(interval: f64, period: f64, scale: f64) -> SinSignal {
  type Item (line 111) | type Item = (f64, f64);
  method next (line 112) | fn next(&mut self) -> Option<Self::Item> {
  type TabsState (line 119) | pub struct TabsState<'a> {
  function new (line 125) | pub fn new(titles: Vec<&'a str>) -> TabsState {
  function next (line 128) | pub fn next(&mut self) {
  function previous (line 132) | pub fn previous(&mut self) {
  type StatefulList (line 141) | pub struct StatefulList<T> {
  function with_items (line 147) | pub fn with_items(items: Vec<T>) -> StatefulList<T> {
  function next (line 154) | pub fn next(&mut self) {
  function previous (line 168) | pub fn previous(&mut self) {
  type Signal (line 183) | pub struct Signal<S: Iterator> {
  function on_tick (line 193) | fn on_tick(&mut self) {
  type Signals (line 202) | pub struct Signals {
    method on_tick (line 209) | fn on_tick(&mut self) {
  type Server (line 217) | pub struct Server<'a> {
  type App (line 224) | pub struct App<'a> {
  function new (line 240) | pub fn new(title: &'a str, enhanced_graphics: bool) -> App<'a> {
  function on_up (line 304) | pub fn on_up(&mut self) {
  function on_down (line 308) | pub fn on_down(&mut self) {
  function on_right (line 312) | pub fn on_right(&mut self) {
  function on_left (line 316) | pub fn on_left(&mut self) {
  function on_key (line 320) | pub fn on_key(&mut self, c: char) {
  function on_tick (line 332) | pub fn on_tick(&mut self) {

FILE: examples/demo/crossterm.rs
  function run (line 17) | pub fn run(tick_rate: Duration, enhanced_graphics: bool) -> Result<(), B...
  function run_app (line 45) | fn run_app<B: Backend>(

FILE: examples/demo/main.rs
  type Cli (line 17) | struct Cli {
  function main (line 26) | fn main() -> Result<(), Box<dyn Error>> {

FILE: examples/demo/termion.rs
  function run (line 14) | pub fn run(tick_rate: Duration, enhanced_graphics: bool) -> Result<(), B...
  function run_app (line 29) | fn run_app<B: Backend>(
  type Event (line 55) | enum Event {
  function events (line 60) | fn events(tick_rate: Duration) -> mpsc::Receiver<Event> {

FILE: examples/demo/ui.rs
  function draw (line 16) | pub fn draw<B: Backend>(f: &mut Frame<B>, app: &mut App) {
  function draw_first_tab (line 39) | fn draw_first_tab<B>(f: &mut Frame<B>, app: &mut App, area: Rect)
  function draw_gauges (line 58) | fn draw_gauges<B>(f: &mut Frame<B>, app: &mut App, area: Rect)
  function draw_charts (line 112) | fn draw_charts<B>(f: &mut Frame<B>, app: &mut App, area: Rect)
  function draw_text (line 259) | fn draw_text<B>(f: &mut Frame<B>, area: Rect)
  function draw_second_tab (line 300) | fn draw_second_tab<B>(f: &mut Frame<B>, app: &mut App, area: Rect)
  function draw_third_tab (line 383) | fn draw_third_tab<B>(f: &mut Frame<B>, _app: &mut App, area: Rect)

FILE: examples/gauge.rs
  type App (line 20) | struct App {
    method new (line 28) | fn new() -> App {
    method on_tick (line 37) | fn on_tick(&mut self) {
  function main (line 57) | fn main() -> Result<(), Box<dyn Error>> {
  function run_app (line 86) | fn run_app<B: Backend>(
  function ui (line 112) | fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {

FILE: examples/layout.rs
  function main (line 14) | fn main() -> Result<(), Box<dyn Error>> {
  function run_app (line 41) | fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> io::Result<()> {
  function ui (line 53) | fn ui<B: Backend>(f: &mut Frame<B>) {

FILE: examples/list.rs
  type StatefulList (line 20) | struct StatefulList<T> {
  function with_items (line 26) | fn with_items(items: Vec<T>) -> StatefulList<T> {
  function next (line 33) | fn next(&mut self) {
  function previous (line 47) | fn previous(&mut self) {
  function unselect (line 61) | fn unselect(&mut self) {
  type App (line 72) | struct App<'a> {
  function new (line 78) | fn new() -> App<'a> {
  function on_tick (line 140) | fn on_tick(&mut self) {
  function main (line 146) | fn main() -> Result<(), Box<dyn Error>> {
  function run_app (line 175) | fn run_app<B: Backend>(
  function ui (line 205) | fn ui<B: Backend>(f: &mut Frame<B>, app: &mut App) {

FILE: examples/panic.rs
  type Result (line 33) | type Result<T> = std::result::Result<T, Box<dyn Error>>;
  type App (line 36) | struct App {
    method chain_hook (line 41) | fn chain_hook(&mut self) {
  function main (line 53) | fn main() -> Result<()> {
  function init_terminal (line 69) | fn init_terminal() -> Result<Terminal<CrosstermBackend<io::Stdout>>> {
  function reset_terminal (line 82) | fn reset_terminal() -> Result<()> {
  function run_tui (line 90) | fn run_tui<B: Backend>(terminal: &mut Terminal<B>, app: &mut App) -> io:...
  function ui (line 113) | fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {

FILE: examples/paragraph.rs
  type App (line 20) | struct App {
    method new (line 25) | fn new() -> App {
    method on_tick (line 29) | fn on_tick(&mut self) {
  function main (line 35) | fn main() -> Result<(), Box<dyn Error>> {
  function run_app (line 64) | fn run_app<B: Backend>(
  function ui (line 90) | fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {

FILE: examples/popup.rs
  type App (line 17) | struct App {
    method new (line 22) | fn new() -> App {
  function main (line 27) | fn main() -> Result<(), Box<dyn Error>> {
  function run_app (line 55) | fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::...
  function ui (line 69) | fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
  function centered_rect (line 104) | fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {

FILE: examples/sparkline.rs
  type RandomSignal (line 24) | pub struct RandomSignal {
    method new (line 30) | pub fn new(lower: u64, upper: u64) -> RandomSignal {
  type Item (line 39) | type Item = u64;
  method next (line 40) | fn next(&mut self) -> Option<u64> {
  type App (line 45) | struct App {
    method new (line 53) | fn new() -> App {
    method on_tick (line 66) | fn on_tick(&mut self) {
  function main (line 79) | fn main() -> Result<(), Box<dyn Error>> {
  function run_app (line 108) | fn run_app<B: Backend>(
  function ui (line 134) | fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {

FILE: examples/table.rs
  type App (line 15) | struct App<'a> {
  function new (line 21) | fn new() -> App<'a> {
  function next (line 47) | pub fn next(&mut self) {
  function previous (line 61) | pub fn previous(&mut self) {
  function main (line 76) | fn main() -> Result<(), Box<dyn Error>> {
  function run_app (line 104) | fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::...
  function ui (line 119) | fn ui<B: Backend>(f: &mut Frame<B>, app: &mut App) {

FILE: examples/tabs.rs
  type App (line 16) | struct App<'a> {
  function new (line 22) | fn new() -> App<'a> {
  function next (line 29) | pub fn next(&mut self) {
  function previous (line 33) | pub fn previous(&mut self) {
  function main (line 42) | fn main() -> Result<(), Box<dyn Error>> {
  function run_app (line 70) | fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::...
  function ui (line 85) | fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {

FILE: examples/user_input.rs
  type InputMode (line 28) | enum InputMode {
  type App (line 34) | struct App {
  method default (line 44) | fn default() -> App {
  function main (line 53) | fn main() -> Result<(), Box<dyn Error>> {
  function run_app (line 81) | fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::...
  function ui (line 116) | fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {

FILE: src/backend/crossterm.rs
  type CrosstermBackend (line 18) | pub struct CrosstermBackend<W: Write> {
  function new (line 26) | pub fn new(buffer: W) -> CrosstermBackend<W> {
  method write (line 35) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method flush (line 39) | fn flush(&mut self) -> io::Result<()> {
  method draw (line 48) | fn draw<'a, I>(&mut self, content: I) -> io::Result<()>
  method hide_cursor (line 92) | fn hide_cursor(&mut self) -> io::Result<()> {
  method show_cursor (line 96) | fn show_cursor(&mut self) -> io::Result<()> {
  method get_cursor (line 100) | fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
  method set_cursor (line 105) | fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
  method clear (line 109) | fn clear(&mut self) -> io::Result<()> {
  method size (line 113) | fn size(&self) -> io::Result<Rect> {
  method flush (line 120) | fn flush(&mut self) -> io::Result<()> {
  function map_error (line 125) | fn map_error(error: crossterm::Result<()>) -> io::Result<()> {
  method from (line 130) | fn from(color: Color) -> Self {
  type ModifierDiff (line 156) | struct ModifierDiff {
    method queue (line 162) | fn queue<W>(&self, mut w: W) -> io::Result<()>

FILE: src/backend/mod.rs
  type Backend (line 19) | pub trait Backend {
    method draw (line 20) | fn draw<'a, I>(&mut self, content: I) -> Result<(), io::Error>
    method hide_cursor (line 23) | fn hide_cursor(&mut self) -> Result<(), io::Error>;
    method show_cursor (line 24) | fn show_cursor(&mut self) -> Result<(), io::Error>;
    method get_cursor (line 25) | fn get_cursor(&mut self) -> Result<(u16, u16), io::Error>;
    method set_cursor (line 26) | fn set_cursor(&mut self, x: u16, y: u16) -> Result<(), io::Error>;
    method clear (line 27) | fn clear(&mut self) -> Result<(), io::Error>;
    method size (line 28) | fn size(&self) -> Result<Rect, io::Error>;
    method flush (line 29) | fn flush(&mut self) -> Result<(), io::Error>;

FILE: src/backend/termion.rs
  type TermionBackend (line 12) | pub struct TermionBackend<W>
  function new (line 23) | pub fn new(stdout: W) -> TermionBackend<W> {
  method write (line 32) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method flush (line 36) | fn flush(&mut self) -> io::Result<()> {
  method clear (line 46) | fn clear(&mut self) -> io::Result<()> {
  method hide_cursor (line 53) | fn hide_cursor(&mut self) -> io::Result<()> {
  method show_cursor (line 59) | fn show_cursor(&mut self) -> io::Result<()> {
  method get_cursor (line 65) | fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
  method set_cursor (line 70) | fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
  method draw (line 75) | fn draw<'a, I>(&mut self, content: I) -> io::Result<()>
  method size (line 125) | fn size(&self) -> io::Result<Rect> {
  method flush (line 130) | fn flush(&mut self) -> io::Result<()> {
  type Fg (line 135) | struct Fg(Color);
    method fmt (line 145) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Bg (line 137) | struct Bg(Color);
    method fmt (line 171) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type ModifierDiff (line 139) | struct ModifierDiff {
    method fmt (line 198) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

FILE: src/backend/test.rs
  type TestBackend (line 11) | pub struct TestBackend {
    method new (line 49) | pub fn new(width: u16, height: u16) -> TestBackend {
    method buffer (line 59) | pub fn buffer(&self) -> &Buffer {
    method resize (line 63) | pub fn resize(&mut self, width: u16, height: u16) {
    method assert_buffer (line 69) | pub fn assert_buffer(&self, expected: &Buffer) {
  function buffer_view (line 20) | fn buffer_view(buffer: &Buffer) -> String {
  method draw (line 109) | fn draw<'a, I>(&mut self, content: I) -> Result<(), io::Error>
  method hide_cursor (line 120) | fn hide_cursor(&mut self) -> Result<(), io::Error> {
  method show_cursor (line 125) | fn show_cursor(&mut self) -> Result<(), io::Error> {
  method get_cursor (line 130) | fn get_cursor(&mut self) -> Result<(u16, u16), io::Error> {
  method set_cursor (line 134) | fn set_cursor(&mut self, x: u16, y: u16) -> Result<(), io::Error> {
  method clear (line 139) | fn clear(&mut self) -> Result<(), io::Error> {
  method size (line 144) | fn size(&self) -> Result<Rect, io::Error> {
  method flush (line 148) | fn flush(&mut self) -> Result<(), io::Error> {

FILE: src/buffer.rs
  type Cell (line 12) | pub struct Cell {
    method set_symbol (line 20) | pub fn set_symbol(&mut self, symbol: &str) -> &mut Cell {
    method set_char (line 26) | pub fn set_char(&mut self, ch: char) -> &mut Cell {
    method set_fg (line 32) | pub fn set_fg(&mut self, color: Color) -> &mut Cell {
    method set_bg (line 37) | pub fn set_bg(&mut self, color: Color) -> &mut Cell {
    method set_style (line 42) | pub fn set_style(&mut self, style: Style) -> &mut Cell {
    method style (line 54) | pub fn style(&self) -> Style {
    method reset (line 61) | pub fn reset(&mut self) {
  method default (line 71) | fn default() -> Cell {
  type Buffer (line 109) | pub struct Buffer {
    method empty (line 119) | pub fn empty(area: Rect) -> Buffer {
    method filled (line 125) | pub fn filled(area: Rect, cell: &Cell) -> Buffer {
    method with_lines (line 135) | pub fn with_lines<S>(lines: Vec<S>) -> Buffer
    method content (line 158) | pub fn content(&self) -> &[Cell] {
    method area (line 163) | pub fn area(&self) -> &Rect {
    method get (line 168) | pub fn get(&self, x: u16, y: u16) -> &Cell {
    method get_mut (line 174) | pub fn get_mut(&mut self, x: u16, y: u16) -> &mut Cell {
    method index_of (line 207) | pub fn index_of(&self, x: u16, y: u16) -> usize {
    method pos_of (line 248) | pub fn pos_of(&self, i: usize) -> (u16, u16) {
    method set_string (line 262) | pub fn set_string<S>(&mut self, x: u16, y: u16, string: S, style: Style)
    method set_stringn (line 271) | pub fn set_stringn<S>(
    method set_spans (line 309) | pub fn set_spans<'a>(&mut self, x: u16, y: u16, spans: &Spans<'a>, wid...
    method set_span (line 330) | pub fn set_span<'a>(&mut self, x: u16, y: u16, span: &Span<'a>, width:...
    method set_background (line 338) | pub fn set_background(&mut self, area: Rect, color: Color) {
    method set_style (line 346) | pub fn set_style(&mut self, area: Rect, style: Style) {
    method resize (line 356) | pub fn resize(&mut self, area: Rect) {
    method reset (line 367) | pub fn reset(&mut self) {
    method merge (line 374) | pub fn merge(&mut self, other: &Buffer) {
    method diff (line 431) | pub fn diff<'a>(&self, other: &'a Buffer) -> Vec<(u16, u16, &'a Cell)> {
  function cell (line 462) | fn cell(s: &str) -> Cell {
  function it_translates_to_and_from_coordinates (line 469) | fn it_translates_to_and_from_coordinates() {
  function pos_of_panics_on_out_of_bounds (line 484) | fn pos_of_panics_on_out_of_bounds() {
  function index_of_panics_on_out_of_bounds (line 494) | fn index_of_panics_on_out_of_bounds() {
  function buffer_set_string (line 503) | fn buffer_set_string() {
  function buffer_set_string_zero_width (line 527) | fn buffer_set_string_zero_width() {
  function buffer_set_string_double_width (line 543) | fn buffer_set_string_double_width() {
  function buffer_with_lines (line 555) | fn buffer_with_lines() {
  function buffer_diffing_empty_empty (line 565) | fn buffer_diffing_empty_empty() {
  function buffer_diffing_empty_filled (line 574) | fn buffer_diffing_empty_filled() {
  function buffer_diffing_filled_filled (line 583) | fn buffer_diffing_filled_filled() {
  function buffer_diffing_single_width (line 592) | fn buffer_diffing_single_width() {
  function buffer_diffing_multi_width (line 621) | fn buffer_diffing_multi_width() {
  function buffer_diffing_multi_width_offset (line 644) | fn buffer_diffing_multi_width_offset() {
  function buffer_merge (line 656) | fn buffer_merge() {
  function buffer_merge2 (line 680) | fn buffer_merge2() {
  function buffer_merge3 (line 707) | fn buffer_merge3() {

FILE: src/layout.rs
  type Corner (line 10) | pub enum Corner {
  type Direction (line 18) | pub enum Direction {
  type Constraint (line 24) | pub enum Constraint {
    method apply (line 34) | pub fn apply(&self, length: u16) -> u16 {
  type Margin (line 49) | pub struct Margin {
  type Alignment (line 55) | pub enum Alignment {
  type Layout (line 62) | pub struct Layout {
    method constraints (line 90) | pub fn constraints<C>(mut self, constraints: C) -> Layout
    method margin (line 98) | pub fn margin(mut self, margin: u16) -> Layout {
    method horizontal_margin (line 106) | pub fn horizontal_margin(mut self, horizontal: u16) -> Layout {
    method vertical_margin (line 111) | pub fn vertical_margin(mut self, vertical: u16) -> Layout {
    method direction (line 116) | pub fn direction(mut self, direction: Direction) -> Layout {
    method expand_to_fill (line 121) | pub(crate) fn expand_to_fill(mut self, expand_to_fill: bool) -> Layout {
    method split (line 186) | pub fn split(&self, area: Rect) -> Vec<Rect> {
  method default (line 76) | fn default() -> Layout {
  function split (line 197) | fn split(area: Rect, layout: &Layout) -> Vec<Rect> {
  type Element (line 330) | struct Element {
    method new (line 338) | fn new() -> Element {
    method left (line 347) | fn left(&self) -> Variable {
    method top (line 351) | fn top(&self) -> Variable {
    method right (line 355) | fn right(&self) -> Expression {
    method bottom (line 359) | fn bottom(&self) -> Expression {
  type Rect (line 367) | pub struct Rect {
    method new (line 377) | pub fn new(x: u16, y: u16, width: u16, height: u16) -> Rect {
    method area (line 397) | pub fn area(self) -> u16 {
    method left (line 401) | pub fn left(self) -> u16 {
    method right (line 405) | pub fn right(self) -> u16 {
    method top (line 409) | pub fn top(self) -> u16 {
    method bottom (line 413) | pub fn bottom(self) -> u16 {
    method inner (line 417) | pub fn inner(self, margin: &Margin) -> Rect {
    method union (line 430) | pub fn union(self, other: Rect) -> Rect {
    method intersection (line 443) | pub fn intersection(self, other: Rect) -> Rect {
    method intersects (line 456) | pub fn intersects(self, other: Rect) -> bool {
  function test_vertical_split_by_height (line 469) | fn test_vertical_split_by_height() {
  function test_rect_size_truncation (line 494) | fn test_rect_size_truncation() {
  function test_rect_size_preservation (line 521) | fn test_rect_size_preservation() {

FILE: src/style.rs
  type Color (line 7) | pub enum Color {
  type Style (line 120) | pub struct Style {
    method reset (line 140) | pub fn reset() -> Style {
    method fg (line 159) | pub fn fg(mut self, color: Color) -> Style {
    method bg (line 174) | pub fn bg(mut self, color: Color) -> Style {
    method add_modifier (line 193) | pub fn add_modifier(mut self, modifier: Modifier) -> Style {
    method remove_modifier (line 213) | pub fn remove_modifier(mut self, modifier: Modifier) -> Style {
    method patch (line 232) | pub fn patch(mut self, other: Style) -> Style {
  method default (line 128) | fn default() -> Style {
  function styles (line 249) | fn styles() -> Vec<Style> {
  function combined_patch_gives_same_result_as_individual_patch (line 264) | fn combined_patch_gives_same_result_as_individual_patch() {

FILE: src/symbols.rs
  constant FULL (line 2) | pub const FULL: &str = "█";
  constant SEVEN_EIGHTHS (line 3) | pub const SEVEN_EIGHTHS: &str = "▉";
  constant THREE_QUARTERS (line 4) | pub const THREE_QUARTERS: &str = "▊";
  constant FIVE_EIGHTHS (line 5) | pub const FIVE_EIGHTHS: &str = "▋";
  constant HALF (line 6) | pub const HALF: &str = "▌";
  constant THREE_EIGHTHS (line 7) | pub const THREE_EIGHTHS: &str = "▍";
  constant ONE_QUARTER (line 8) | pub const ONE_QUARTER: &str = "▎";
  constant ONE_EIGHTH (line 9) | pub const ONE_EIGHTH: &str = "▏";
  type Set (line 12) | pub struct Set {
  constant THREE_LEVELS (line 24) | pub const THREE_LEVELS: Set = Set {
  constant NINE_LEVELS (line 36) | pub const NINE_LEVELS: Set = Set {
  constant FULL (line 50) | pub const FULL: &str = "█";
  constant SEVEN_EIGHTHS (line 51) | pub const SEVEN_EIGHTHS: &str = "▇";
  constant THREE_QUARTERS (line 52) | pub const THREE_QUARTERS: &str = "▆";
  constant FIVE_EIGHTHS (line 53) | pub const FIVE_EIGHTHS: &str = "▅";
  constant HALF (line 54) | pub const HALF: &str = "▄";
  constant THREE_EIGHTHS (line 55) | pub const THREE_EIGHTHS: &str = "▃";
  constant ONE_QUARTER (line 56) | pub const ONE_QUARTER: &str = "▂";
  constant ONE_EIGHTH (line 57) | pub const ONE_EIGHTH: &str = "▁";
  type Set (line 60) | pub struct Set {
  constant THREE_LEVELS (line 72) | pub const THREE_LEVELS: Set = Set {
  constant NINE_LEVELS (line 84) | pub const NINE_LEVELS: Set = Set {
  constant VERTICAL (line 98) | pub const VERTICAL: &str = "│";
  constant DOUBLE_VERTICAL (line 99) | pub const DOUBLE_VERTICAL: &str = "║";
  constant THICK_VERTICAL (line 100) | pub const THICK_VERTICAL: &str = "┃";
  constant HORIZONTAL (line 102) | pub const HORIZONTAL: &str = "─";
  constant DOUBLE_HORIZONTAL (line 103) | pub const DOUBLE_HORIZONTAL: &str = "═";
  constant THICK_HORIZONTAL (line 104) | pub const THICK_HORIZONTAL: &str = "━";
  constant TOP_RIGHT (line 106) | pub const TOP_RIGHT: &str = "┐";
  constant ROUNDED_TOP_RIGHT (line 107) | pub const ROUNDED_TOP_RIGHT: &str = "╮";
  constant DOUBLE_TOP_RIGHT (line 108) | pub const DOUBLE_TOP_RIGHT: &str = "╗";
  constant THICK_TOP_RIGHT (line 109) | pub const THICK_TOP_RIGHT: &str = "┓";
  constant TOP_LEFT (line 111) | pub const TOP_LEFT: &str = "┌";
  constant ROUNDED_TOP_LEFT (line 112) | pub const ROUNDED_TOP_LEFT: &str = "╭";
  constant DOUBLE_TOP_LEFT (line 113) | pub const DOUBLE_TOP_LEFT: &str = "╔";
  constant THICK_TOP_LEFT (line 114) | pub const THICK_TOP_LEFT: &str = "┏";
  constant BOTTOM_RIGHT (line 116) | pub const BOTTOM_RIGHT: &str = "┘";
  constant ROUNDED_BOTTOM_RIGHT (line 117) | pub const ROUNDED_BOTTOM_RIGHT: &str = "╯";
  constant DOUBLE_BOTTOM_RIGHT (line 118) | pub const DOUBLE_BOTTOM_RIGHT: &str = "╝";
  constant THICK_BOTTOM_RIGHT (line 119) | pub const THICK_BOTTOM_RIGHT: &str = "┛";
  constant BOTTOM_LEFT (line 121) | pub const BOTTOM_LEFT: &str = "└";
  constant ROUNDED_BOTTOM_LEFT (line 122) | pub const ROUNDED_BOTTOM_LEFT: &str = "╰";
  constant DOUBLE_BOTTOM_LEFT (line 123) | pub const DOUBLE_BOTTOM_LEFT: &str = "╚";
  constant THICK_BOTTOM_LEFT (line 124) | pub const THICK_BOTTOM_LEFT: &str = "┗";
  constant VERTICAL_LEFT (line 126) | pub const VERTICAL_LEFT: &str = "┤";
  constant DOUBLE_VERTICAL_LEFT (line 127) | pub const DOUBLE_VERTICAL_LEFT: &str = "╣";
  constant THICK_VERTICAL_LEFT (line 128) | pub const THICK_VERTICAL_LEFT: &str = "┫";
  constant VERTICAL_RIGHT (line 130) | pub const VERTICAL_RIGHT: &str = "├";
  constant DOUBLE_VERTICAL_RIGHT (line 131) | pub const DOUBLE_VERTICAL_RIGHT: &str = "╠";
  constant THICK_VERTICAL_RIGHT (line 132) | pub const THICK_VERTICAL_RIGHT: &str = "┣";
  constant HORIZONTAL_DOWN (line 134) | pub const HORIZONTAL_DOWN: &str = "┬";
  constant DOUBLE_HORIZONTAL_DOWN (line 135) | pub const DOUBLE_HORIZONTAL_DOWN: &str = "╦";
  constant THICK_HORIZONTAL_DOWN (line 136) | pub const THICK_HORIZONTAL_DOWN: &str = "┳";
  constant HORIZONTAL_UP (line 138) | pub const HORIZONTAL_UP: &str = "┴";
  constant DOUBLE_HORIZONTAL_UP (line 139) | pub const DOUBLE_HORIZONTAL_UP: &str = "╩";
  constant THICK_HORIZONTAL_UP (line 140) | pub const THICK_HORIZONTAL_UP: &str = "┻";
  constant CROSS (line 142) | pub const CROSS: &str = "┼";
  constant DOUBLE_CROSS (line 143) | pub const DOUBLE_CROSS: &str = "╬";
  constant THICK_CROSS (line 144) | pub const THICK_CROSS: &str = "╋";
  type Set (line 147) | pub struct Set {
  constant NORMAL (line 161) | pub const NORMAL: Set = Set {
  constant ROUNDED (line 175) | pub const ROUNDED: Set = Set {
  constant DOUBLE (line 183) | pub const DOUBLE: Set = Set {
  constant THICK (line 197) | pub const THICK: Set = Set {
  constant DOT (line 212) | pub const DOT: &str = "•";
  constant BLANK (line 215) | pub const BLANK: u16 = 0x2800;
  constant DOTS (line 216) | pub const DOTS: [[u16; 2]; 4] = [
  type Marker (line 226) | pub enum Marker {

FILE: src/terminal.rs
  type ResizeBehavior (line 11) | enum ResizeBehavior {
  type Viewport (line 18) | pub struct Viewport {
    method fixed (line 25) | pub fn fixed(area: Rect) -> Viewport {
  type TerminalOptions (line 35) | pub struct TerminalOptions {
  type Terminal (line 42) | pub struct Terminal<B>
  type Frame (line 59) | pub struct Frame<'a, B: 'a>
  function size (line 77) | pub fn size(&self) -> Rect {
  function render_widget (line 97) | pub fn render_widget<W>(&mut self, widget: W, area: Rect)
  function render_stateful_widget (line 129) | pub fn render_stateful_widget<W>(&mut self, widget: W, area: Rect, state...
  function set_cursor (line 142) | pub fn set_cursor(&mut self, x: u16, y: u16) {
  type CompletedFrame (line 150) | pub struct CompletedFrame<'a> {
  method drop (line 159) | fn drop(&mut self) {
  function new (line 175) | pub fn new(backend: B) -> io::Result<Terminal<B>> {
  function with_options (line 189) | pub fn with_options(backend: B, options: TerminalOptions) -> io::Result<...
  function get_frame (line 203) | pub fn get_frame(&mut self) -> Frame<B> {
  function current_buffer_mut (line 210) | pub fn current_buffer_mut(&mut self) -> &mut Buffer {
  function backend (line 214) | pub fn backend(&self) -> &B {
  function backend_mut (line 218) | pub fn backend_mut(&mut self) -> &mut B {
  function flush (line 224) | pub fn flush(&mut self) -> io::Result<()> {
  function resize (line 234) | pub fn resize(&mut self, area: Rect) -> io::Result<()> {
  function autoresize (line 242) | pub fn autoresize(&mut self) -> io::Result<()> {
  function draw (line 254) | pub fn draw<F>(&mut self, f: F) -> io::Result<CompletedFrame>
  function hide_cursor (line 292) | pub fn hide_cursor(&mut self) -> io::Result<()> {
  function show_cursor (line 298) | pub fn show_cursor(&mut self) -> io::Result<()> {
  function get_cursor (line 304) | pub fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
  function set_cursor (line 308) | pub fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
  function clear (line 313) | pub fn clear(&mut self) -> io::Result<()> {
  function size (line 321) | pub fn size(&self) -> io::Result<Rect> {

FILE: src/text.rs
  type StyledGrapheme (line 56) | pub struct StyledGrapheme<'a> {
  type Span (line 63) | pub struct Span<'a> {
  function raw (line 78) | pub fn raw<T>(content: T) -> Span<'a>
  function styled (line 99) | pub fn styled<T>(content: T, style: Style) -> Span<'a>
  function width (line 110) | pub fn width(&self) -> usize {
  function styled_graphemes (line 171) | pub fn styled_graphemes(
  function from (line 185) | fn from(s: String) -> Span<'a> {
  function from (line 191) | fn from(s: &'a str) -> Span<'a> {
  type Spans (line 198) | pub struct Spans<'a>(pub Vec<Span<'a>>);
  function width (line 214) | pub fn width(&self) -> usize {
  function from (line 220) | fn from(s: String) -> Spans<'a> {
  function from (line 226) | fn from(s: &'a str) -> Spans<'a> {
  function from (line 232) | fn from(spans: Vec<Span<'a>>) -> Spans<'a> {
  function from (line 238) | fn from(span: Span<'a>) -> Spans<'a> {
  method from (line 244) | fn from(line: Spans<'a>) -> String {
  type Text (line 277) | pub struct Text<'a> {
  function raw (line 291) | pub fn raw<T>(content: T) -> Text<'a>
  function styled (line 314) | pub fn styled<T>(content: T, style: Style) -> Text<'a>
  function width (line 332) | pub fn width(&self) -> usize {
  function height (line 349) | pub fn height(&self) -> usize {
  function patch_style (line 368) | pub fn patch_style(&mut self, style: Style) {
  function from (line 378) | fn from(s: String) -> Text<'a> {
  function from (line 384) | fn from(s: &'a str) -> Text<'a> {
  function from (line 390) | fn from(s: Cow<'a, str>) -> Text<'a> {
  function from (line 396) | fn from(span: Span<'a>) -> Text<'a> {
  function from (line 404) | fn from(spans: Spans<'a>) -> Text<'a> {
  function from (line 410) | fn from(lines: Vec<Spans<'a>>) -> Text<'a> {
  type Item (line 416) | type Item = Spans<'a>;
  type IntoIter (line 417) | type IntoIter = std::vec::IntoIter<Self::Item>;
  method into_iter (line 419) | fn into_iter(self) -> Self::IntoIter {
  function extend (line 425) | fn extend<T: IntoIterator<Item = Spans<'a>>>(&mut self, iter: T) {

FILE: src/widgets/barchart.rs
  type BarChart (line 29) | pub struct BarChart<'a> {
  method default (line 56) | fn default() -> BarChart<'a> {
  function data (line 74) | pub fn data(mut self, data: &'a [(&'a str, u64)]) -> BarChart<'a> {
  function block (line 83) | pub fn block(mut self, block: Block<'a>) -> BarChart<'a> {
  function max (line 88) | pub fn max(mut self, max: u64) -> BarChart<'a> {
  function bar_style (line 93) | pub fn bar_style(mut self, style: Style) -> BarChart<'a> {
  function bar_width (line 98) | pub fn bar_width(mut self, width: u16) -> BarChart<'a> {
  function bar_gap (line 103) | pub fn bar_gap(mut self, gap: u16) -> BarChart<'a> {
  function bar_set (line 108) | pub fn bar_set(mut self, bar_set: symbols::bar::Set) -> BarChart<'a> {
  function value_style (line 113) | pub fn value_style(mut self, style: Style) -> BarChart<'a> {
  function label_style (line 118) | pub fn label_style(mut self, style: Style) -> BarChart<'a> {
  function style (line 123) | pub fn style(mut self, style: Style) -> BarChart<'a> {
  method render (line 130) | fn render(mut self, area: Rect, buf: &mut Buffer) {

FILE: src/widgets/block.rs
  type BorderType (line 11) | pub enum BorderType {
    method line_symbols (line 19) | pub fn line_symbols(border_type: BorderType) -> line::Set {
  type Block (line 45) | pub struct Block<'a> {
  method default (line 63) | fn default() -> Block<'a> {
  function title (line 76) | pub fn title<T>(mut self, title: T) -> Block<'a>
  function title_style (line 88) | pub fn title_style(mut self, style: Style) -> Block<'a> {
  function title_alignment (line 96) | pub fn title_alignment(mut self, alignment: Alignment) -> Block<'a> {
  function border_style (line 101) | pub fn border_style(mut self, style: Style) -> Block<'a> {
  function style (line 106) | pub fn style(mut self, style: Style) -> Block<'a> {
  function borders (line 111) | pub fn borders(mut self, flag: Borders) -> Block<'a> {
  function border_type (line 116) | pub fn border_type(mut self, border_type: BorderType) -> Block<'a> {
  function inner (line 122) | pub fn inner(&self, area: Rect) -> Rect {
  method render (line 143) | fn render(self, area: Rect, buf: &mut Buffer) {
  function inner_takes_into_account_the_borders (line 246) | fn inner_takes_into_account_the_borders() {
  function inner_takes_into_account_the_title (line 523) | fn inner_takes_into_account_the_title() {

FILE: src/widgets/canvas/line.rs
  type Line (line 8) | pub struct Line {
  method draw (line 17) | fn draw(&self, painter: &mut Painter) {
  function draw_line_low (line 59) | fn draw_line_low(painter: &mut Painter, x1: usize, y1: usize, x2: usize,...
  function draw_line_high (line 78) | fn draw_line_high(painter: &mut Painter, x1: usize, y1: usize, x2: usize...

FILE: src/widgets/canvas/map.rs
  type MapResolution (line 10) | pub enum MapResolution {
    method data (line 16) | fn data(self) -> &'static [(f64, f64)] {
  type Map (line 26) | pub struct Map {
  method default (line 32) | fn default() -> Map {
  method draw (line 41) | fn draw(&self, painter: &mut Painter) {

FILE: src/widgets/canvas/mod.rs
  type Shape (line 23) | pub trait Shape {
    method draw (line 24) | fn draw(&self, painter: &mut Painter);
  type Label (line 29) | pub struct Label<'a> {
  type Layer (line 36) | struct Layer {
  type Grid (line 41) | trait Grid: Debug {
    method width (line 42) | fn width(&self) -> u16;
    method height (line 43) | fn height(&self) -> u16;
    method resolution (line 44) | fn resolution(&self) -> (f64, f64);
    method paint (line 45) | fn paint(&mut self, x: usize, y: usize, color: Color);
    method save (line 46) | fn save(&self) -> Layer;
    method reset (line 47) | fn reset(&mut self);
    method width (line 71) | fn width(&self) -> u16 {
    method height (line 75) | fn height(&self) -> u16 {
    method resolution (line 79) | fn resolution(&self) -> (f64, f64) {
    method save (line 86) | fn save(&self) -> Layer {
    method reset (line 93) | fn reset(&mut self) {
    method paint (line 102) | fn paint(&mut self, x: usize, y: usize, color: Color) {
    method width (line 136) | fn width(&self) -> u16 {
    method height (line 140) | fn height(&self) -> u16 {
    method resolution (line 144) | fn resolution(&self) -> (f64, f64) {
    method save (line 148) | fn save(&self) -> Layer {
    method reset (line 155) | fn reset(&mut self) {
    method paint (line 164) | fn paint(&mut self, x: usize, y: usize, color: Color) {
  type BrailleGrid (line 51) | struct BrailleGrid {
    method new (line 59) | fn new(width: u16, height: u16) -> BrailleGrid {
  type CharGrid (line 114) | struct CharGrid {
    method new (line 123) | fn new(width: u16, height: u16, cell_char: char) -> CharGrid {
  type Painter (line 176) | pub struct Painter<'a, 'b> {
  function get_point (line 201) | pub fn get_point(&self, x: f64, y: f64) -> Option<(usize, usize)> {
  function paint (line 229) | pub fn paint(&mut self, x: usize, y: usize, color: Color) {
  function from (line 235) | fn from(context: &'a mut Context<'b>) -> Painter<'a, 'b> {
  type Context (line 246) | pub struct Context<'a> {
  function new (line 256) | pub fn new(
  function draw (line 279) | pub fn draw<S>(&mut self, shape: &S)
  function layer (line 289) | pub fn layer(&mut self) {
  function print (line 296) | pub fn print<T>(&mut self, x: f64, y: f64, spans: T)
  function finish (line 308) | fn finish(&mut self) {
  type Canvas (line 350) | pub struct Canvas<'a, F>
  method default (line 366) | fn default() -> Canvas<'a, F> {
  function block (line 382) | pub fn block(mut self, block: Block<'a>) -> Canvas<'a, F> {
  function x_bounds (line 387) | pub fn x_bounds(mut self, bounds: [f64; 2]) -> Canvas<'a, F> {
  function y_bounds (line 392) | pub fn y_bounds(mut self, bounds: [f64; 2]) -> Canvas<'a, F> {
  function paint (line 398) | pub fn paint(mut self, f: F) -> Canvas<'a, F> {
  function background_color (line 403) | pub fn background_color(mut self, color: Color) -> Canvas<'a, F> {
  function marker (line 423) | pub fn marker(mut self, marker: symbols::Marker) -> Canvas<'a, F> {
  method render (line 433) | fn render(mut self, area: Rect, buf: &mut Buffer) {

FILE: src/widgets/canvas/points.rs
  type Points (line 8) | pub struct Points<'a> {
  method draw (line 14) | fn draw(&self, painter: &mut Painter) {
  method default (line 24) | fn default() -> Points<'a> {

FILE: src/widgets/canvas/rectangle.rs
  type Rectangle (line 8) | pub struct Rectangle {
  method draw (line 17) | fn draw(&self, painter: &mut Painter) {

FILE: src/widgets/chart.rs
  type Axis (line 20) | pub struct Axis<'a> {
  method default (line 34) | fn default() -> Axis<'a> {
  function title (line 46) | pub fn title<T>(mut self, title: T) -> Axis<'a>
  function title_style (line 58) | pub fn title_style(mut self, style: Style) -> Axis<'a> {
  function bounds (line 66) | pub fn bounds(mut self, bounds: [f64; 2]) -> Axis<'a> {
  function labels (line 71) | pub fn labels(mut self, labels: Vec<Span<'a>>) -> Axis<'a> {
  function style (line 76) | pub fn style(mut self, style: Style) -> Axis<'a> {
  function labels_alignment (line 85) | pub fn labels_alignment(mut self, alignment: Alignment) -> Axis<'a> {
  type GraphType (line 93) | pub enum GraphType {
  type Dataset (line 102) | pub struct Dataset<'a> {
  method default (line 116) | fn default() -> Dataset<'a> {
  function name (line 128) | pub fn name<S>(mut self, name: S) -> Dataset<'a>
  function data (line 136) | pub fn data(mut self, data: &'a [(f64, f64)]) -> Dataset<'a> {
  function marker (line 141) | pub fn marker(mut self, marker: symbols::Marker) -> Dataset<'a> {
  function graph_type (line 146) | pub fn graph_type(mut self, graph_type: GraphType) -> Dataset<'a> {
  function style (line 151) | pub fn style(mut self, style: Style) -> Dataset<'a> {
  type ChartLayout (line 160) | struct ChartLayout {
  type Chart (line 216) | pub struct Chart<'a> {
  function new (line 232) | pub fn new(datasets: Vec<Dataset<'a>>) -> Chart<'a> {
  function block (line 243) | pub fn block(mut self, block: Block<'a>) -> Chart<'a> {
  function style (line 248) | pub fn style(mut self, style: Style) -> Chart<'a> {
  function x_axis (line 253) | pub fn x_axis(mut self, axis: Axis<'a>) -> Chart<'a> {
  function y_axis (line 258) | pub fn y_axis(mut self, axis: Axis<'a>) -> Chart<'a> {
  function hidden_legend_constraints (line 279) | pub fn hidden_legend_constraints(mut self, constraints: (Constraint, Con...
  function layout (line 286) | fn layout(&self, area: Rect) -> ChartLayout {
  function max_width_of_labels_left_of_y_axis (line 356) | fn max_width_of_labels_left_of_y_axis(&self, area: Rect, has_y_axis: boo...
  function render_x_labels (line 381) | fn render_x_labels(
  function first_x_label_area (line 430) | fn first_x_label_area(
  function render_label (line 453) | fn render_label(buf: &mut Buffer, label: &Span, label_area: Rect, alignm...
  function render_y_labels (line 466) | fn render_y_labels(
  method render (line 495) | fn render(mut self, area: Rect, buf: &mut Buffer) {
  type LegendTestCase (line 624) | struct LegendTestCase {
  function it_should_hide_the_legend (line 631) | fn it_should_hide_the_legend() {

FILE: src/widgets/clear.rs
  type Clear (line 27) | pub struct Clear;
  method render (line 30) | fn render(self, area: Rect, buf: &mut Buffer) {

FILE: src/widgets/gauge.rs
  type Gauge (line 23) | pub struct Gauge<'a> {
  method default (line 33) | fn default() -> Gauge<'a> {
  function block (line 46) | pub fn block(mut self, block: Block<'a>) -> Gauge<'a> {
  function percent (line 51) | pub fn percent(mut self, percent: u16) -> Gauge<'a> {
  function ratio (line 61) | pub fn ratio(mut self, ratio: f64) -> Gauge<'a> {
  function label (line 70) | pub fn label<T>(mut self, label: T) -> Gauge<'a>
  function style (line 78) | pub fn style(mut self, style: Style) -> Gauge<'a> {
  function gauge_style (line 83) | pub fn gauge_style(mut self, style: Style) -> Gauge<'a> {
  function use_unicode (line 88) | pub fn use_unicode(mut self, unicode: bool) -> Gauge<'a> {
  method render (line 95) | fn render(mut self, area: Rect, buf: &mut Buffer) {
  function get_unicode_block (line 147) | fn get_unicode_block<'a>(frac: f64) -> &'a str {
  type LineGauge (line 175) | pub struct LineGauge<'a> {
  method default (line 185) | fn default() -> Self {
  function block (line 198) | pub fn block(mut self, block: Block<'a>) -> Self {
  function ratio (line 203) | pub fn ratio(mut self, ratio: f64) -> Self {
  function line_set (line 212) | pub fn line_set(mut self, set: symbols::line::Set) -> Self {
  function label (line 217) | pub fn label<T>(mut self, label: T) -> Self
  function style (line 225) | pub fn style(mut self, style: Style) -> Self {
  function gauge_style (line 230) | pub fn gauge_style(mut self, style: Style) -> Self {
  method render (line 237) | fn render(mut self, area: Rect, buf: &mut Buffer) {
  function gauge_invalid_percentage (line 298) | fn gauge_invalid_percentage() {
  function gauge_invalid_ratio_upper_bound (line 304) | fn gauge_invalid_ratio_upper_bound() {
  function gauge_invalid_ratio_lower_bound (line 310) | fn gauge_invalid_ratio_lower_bound() {

FILE: src/widgets/list.rs
  type ListState (line 11) | pub struct ListState {
    method selected (line 17) | pub fn selected(&self) -> Option<usize> {
    method select (line 21) | pub fn select(&mut self, index: Option<usize>) {
  type ListItem (line 30) | pub struct ListItem<'a> {
  function new (line 36) | pub fn new<T>(content: T) -> ListItem<'a>
  function style (line 46) | pub fn style(mut self, style: Style) -> ListItem<'a> {
  function height (line 51) | pub fn height(&self) -> usize {
  type List (line 71) | pub struct List<'a> {
  function new (line 86) | pub fn new<T>(items: T) -> List<'a>
  function block (line 101) | pub fn block(mut self, block: Block<'a>) -> List<'a> {
  function style (line 106) | pub fn style(mut self, style: Style) -> List<'a> {
  function highlight_symbol (line 111) | pub fn highlight_symbol(mut self, highlight_symbol: &'a str) -> List<'a> {
  function highlight_style (line 116) | pub fn highlight_style(mut self, style: Style) -> List<'a> {
  function repeat_highlight_symbol (line 121) | pub fn repeat_highlight_symbol(mut self, repeat: bool) -> List<'a> {
  function start_corner (line 126) | pub fn start_corner(mut self, corner: Corner) -> List<'a> {
  function get_items_bounds (line 131) | fn get_items_bounds(
  type State (line 171) | type State = ListState;
  method render (line 173) | fn render(mut self, area: Rect, buf: &mut Buffer, state: &mut Self::Stat...
  method render (line 260) | fn render(self, area: Rect, buf: &mut Buffer) {

FILE: src/widgets/mod.rs
  type Widget (line 64) | pub trait Widget {
    method render (line 67) | fn render(self, area: Rect, buf: &mut Buffer);
  type StatefulWidget (line 181) | pub trait StatefulWidget {
    method render (line 183) | fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State);

FILE: src/widgets/paragraph.rs
  function get_line_offset (line 14) | fn get_line_offset(line_width: u16, text_area_width: u16, alignment: Ali...
  type Paragraph (line 46) | pub struct Paragraph<'a> {
  type Wrap (line 89) | pub struct Wrap {
  function new (line 95) | pub fn new<T>(text: T) -> Paragraph<'a>
  function block (line 109) | pub fn block(mut self, block: Block<'a>) -> Paragraph<'a> {
  function style (line 114) | pub fn style(mut self, style: Style) -> Paragraph<'a> {
  function wrap (line 119) | pub fn wrap(mut self, wrap: Wrap) -> Paragraph<'a> {
  function scroll (line 124) | pub fn scroll(mut self, offset: (u16, u16)) -> Paragraph<'a> {
  function alignment (line 129) | pub fn alignment(mut self, alignment: Alignment) -> Paragraph<'a> {
  method render (line 136) | fn render(mut self, area: Rect, buf: &mut Buffer) {

FILE: src/widgets/reflow.rs
  constant NBSP (line 5) | const NBSP: &str = "\u{00a0}";
  type LineComposer (line 10) | pub trait LineComposer<'a> {
    method next_line (line 11) | fn next_line(&mut self) -> Option<(&[StyledGrapheme<'a>], u16)>;
  type WordWrapper (line 15) | pub struct WordWrapper<'a, 'b> {
  function new (line 25) | pub fn new(
  function next_line (line 41) | fn next_line(&mut self) -> Option<(&[StyledGrapheme<'a>], u16)> {
  type LineTruncator (line 126) | pub struct LineTruncator<'a, 'b> {
  function new (line 135) | pub fn new(
  function set_horizontal_offset (line 147) | pub fn set_horizontal_offset(&mut self, horizontal_offset: u16) {
  function next_line (line 153) | fn next_line(&mut self) -> Option<(&[StyledGrapheme<'a>], u16)> {
  function trim_offset (line 218) | fn trim_offset(src: &str, mut offset: usize) -> &str {
  type Composer (line 237) | enum Composer {
  function run_composer (line 242) | fn run_composer(which: Composer, text: &str, text_area_width: u16) -> (V...
  function line_composer_one_line (line 267) | fn line_composer_one_line() {
  function line_composer_short_lines (line 281) | fn line_composer_short_lines() {
  function line_composer_long_word (line 294) | fn line_composer_long_word() {
  function line_composer_long_sentence (line 316) | fn line_composer_long_sentence() {
  function line_composer_zero_width (line 346) | fn line_composer_zero_width() {
  function line_composer_max_line_width_of_1 (line 358) | fn line_composer_max_line_width_of_1() {
  function line_composer_max_line_width_of_1_double_width_characters (line 372) | fn line_composer_max_line_width_of_1_double_width_characters() {
  function line_composer_word_wrapper_mixed_length (line 384) | fn line_composer_word_wrapper_mixed_length() {
  function line_composer_double_width_chars (line 401) | fn line_composer_double_width_chars() {
  function line_composer_leading_whitespace_removal (line 421) | fn line_composer_leading_whitespace_removal() {
  function line_composer_lots_of_spaces (line 432) | fn line_composer_lots_of_spaces() {
  function line_composer_char_plus_lots_of_spaces (line 444) | fn line_composer_char_plus_lots_of_spaces() {
  function line_composer_word_wrapper_double_width_chars_mixed_with_spaces (line 458) | fn line_composer_word_wrapper_double_width_chars_mixed_with_spaces() {
  function line_composer_word_wrapper_nbsp (line 485) | fn line_composer_word_wrapper_nbsp() {
  function line_composer_word_wrapper_preserve_indentation (line 499) | fn line_composer_word_wrapper_preserve_indentation() {
  function line_composer_word_wrapper_preserve_indentation_with_wrap (line 507) | fn line_composer_word_wrapper_preserve_indentation_with_wrap() {
  function line_composer_word_wrapper_preserve_indentation_lots_of_whitespace (line 518) | fn line_composer_word_wrapper_preserve_indentation_lots_of_whitespace() {

FILE: src/widgets/sparkline.rs
  type Sparkline (line 24) | pub struct Sparkline<'a> {
  method default (line 39) | fn default() -> Sparkline<'a> {
  function block (line 51) | pub fn block(mut self, block: Block<'a>) -> Sparkline<'a> {
  function style (line 56) | pub fn style(mut self, style: Style) -> Sparkline<'a> {
  function data (line 61) | pub fn data(mut self, data: &'a [u64]) -> Sparkline<'a> {
  function max (line 66) | pub fn max(mut self, max: u64) -> Sparkline<'a> {
  function bar_set (line 71) | pub fn bar_set(mut self, bar_set: symbols::bar::Set) -> Sparkline<'a> {
  method render (line 78) | fn render(mut self, area: Rect, buf: &mut Buffer) {
  function it_does_not_panic_if_max_is_zero (line 141) | fn it_does_not_panic_if_max_is_zero() {
  function it_does_not_panic_if_max_is_set_to_zero (line 149) | fn it_does_not_panic_if_max_is_set_to_zero() {

FILE: src/widgets/table.rs
  type Cell (line 35) | pub struct Cell<'a> {
  function style (line 42) | pub fn style(mut self, style: Style) -> Self {
  function from (line 52) | fn from(content: T) -> Cell<'a> {
  type Row (line 90) | pub struct Row<'a> {
  function new (line 99) | pub fn new<T>(cells: T) -> Self
  function height (line 114) | pub fn height(mut self, height: u16) -> Self {
  function style (line 121) | pub fn style(mut self, style: Style) -> Self {
  function bottom_margin (line 127) | pub fn bottom_margin(mut self, margin: u16) -> Self {
  function total_height (line 133) | fn total_height(&self) -> u16 {
  type Table (line 190) | pub struct Table<'a> {
  function new (line 210) | pub fn new<T>(rows: T) -> Self
  function block (line 226) | pub fn block(mut self, block: Block<'a>) -> Self {
  function header (line 231) | pub fn header(mut self, header: Row<'a>) -> Self {
  function widths (line 236) | pub fn widths(mut self, widths: &'a [Constraint]) -> Self {
  function style (line 249) | pub fn style(mut self, style: Style) -> Self {
  function highlight_symbol (line 254) | pub fn highlight_symbol(mut self, highlight_symbol: &'a str) -> Self {
  function highlight_style (line 259) | pub fn highlight_style(mut self, highlight_style: Style) -> Self {
  function column_spacing (line 264) | pub fn column_spacing(mut self, spacing: u16) -> Self {
  function get_columns_widths (line 269) | fn get_columns_widths(&self, max_width: u16, has_selection: bool) -> Vec...
  function get_row_bounds (line 299) | fn get_row_bounds(
  type TableState (line 339) | pub struct TableState {
    method selected (line 345) | pub fn selected(&self) -> Option<usize> {
    method select (line 349) | pub fn select(&mut self, index: Option<usize>) {
  type State (line 358) | type State = TableState;
  method render (line 360) | fn render(mut self, area: Rect, buf: &mut Buffer, state: &mut Self::Stat...
  function render_cell (line 470) | fn render_cell(buf: &mut Buffer, cell: &Cell, area: Rect) {
  method render (line 481) | fn render(self, area: Rect, buf: &mut Buffer) {
  function table_invalid_percentages (line 493) | fn table_invalid_percentages() {

FILE: src/widgets/tabs.rs
  type Tabs (line 27) | pub struct Tabs<'a> {
  function new (line 43) | pub fn new(titles: Vec<Spans<'a>>) -> Tabs<'a> {
  function block (line 54) | pub fn block(mut self, block: Block<'a>) -> Tabs<'a> {
  function select (line 59) | pub fn select(mut self, selected: usize) -> Tabs<'a> {
  function style (line 64) | pub fn style(mut self, style: Style) -> Tabs<'a> {
  function highlight_style (line 69) | pub fn highlight_style(mut self, style: Style) -> Tabs<'a> {
  function divider (line 74) | pub fn divider<T>(mut self, divider: T) -> Tabs<'a>
  method render (line 84) | fn render(mut self, area: Rect, buf: &mut Buffer) {

FILE: tests/backend_termion.rs
  function backend_termion_should_only_write_diffs (line 3) | fn backend_termion_should_only_write_diffs() -> Result<(), Box<dyn std::...

FILE: tests/terminal.rs
  function terminal_buffer_size_should_be_limited (line 10) | fn terminal_buffer_size_should_be_limited() {
  function terminal_draw_returns_the_completed_frame (line 19) | fn terminal_draw_returns_the_completed_frame() -> Result<(), Box<dyn Err...

FILE: tests/widgets_barchart.rs
  function widgets_barchart_not_full_below_max_value (line 7) | fn widgets_barchart_not_full_below_max_value() {

FILE: tests/widgets_block.rs
  function widgets_block_renders (line 12) | fn widgets_block_renders() {
  function widgets_block_renders_on_small_areas (line 50) | fn widgets_block_renders_on_small_areas() {
  function widgets_block_title_alignment (line 216) | fn widgets_block_title_alignment() {

FILE: tests/widgets_canvas.rs
  function widgets_canvas_draw_labels (line 11) | fn widgets_canvas_draw_labels() {

FILE: tests/widgets_chart.rs
  function create_labels (line 13) | fn create_labels<'a>(labels: &'a [&'a str]) -> Vec<Span<'a>> {
  function axis_test_case (line 17) | fn axis_test_case<S>(width: u16, height: u16, x_axis: Axis, y_axis: Axis...
  function widgets_chart_can_render_on_small_areas (line 34) | fn widgets_chart_can_render_on_small_areas() {
  function widgets_chart_handles_long_labels (line 68) | fn widgets_chart_handles_long_labels() {
  function widgets_chart_handles_x_axis_labels_alignments (line 172) | fn widgets_chart_handles_x_axis_labels_alignments() {
  function widgets_chart_handles_y_axis_labels_alignments (line 216) | fn widgets_chart_handles_y_axis_labels_alignments() {
  function widgets_chart_can_have_axis_with_zero_length_bounds (line 259) | fn widgets_chart_can_have_axis_with_zero_length_bounds() {
  function widgets_chart_handles_overflows (line 295) | fn widgets_chart_handles_overflows() {
  function widgets_chart_can_have_empty_datasets (line 335) | fn widgets_chart_can_have_empty_datasets() {
  function widgets_chart_can_have_a_legend (line 372) | fn widgets_chart_can_have_a_legend() {

FILE: tests/widgets_gauge.rs
  function widgets_gauge_renders (line 13) | fn widgets_gauge_renders() {
  function widgets_gauge_renders_no_unicode (line 81) | fn widgets_gauge_renders_no_unicode() {
  function widgets_gauge_applies_styles (line 121) | fn widgets_gauge_applies_styles() {
  function widgets_gauge_supports_large_labels (line 187) | fn widgets_gauge_supports_large_labels() {
  function widgets_line_gauge_renders (line 204) | fn widgets_line_gauge_renders() {

FILE: tests/widgets_list.rs
  function widgets_list_should_highlight_the_selected_item (line 13) | fn widgets_list_should_highlight_the_selected_item() {
  function widgets_list_should_truncate_items (line 40) | fn widgets_list_should_truncate_items() {
  function widgets_list_should_clamp_offset_if_items_are_removed (line 92) | fn widgets_list_should_clamp_offset_if_items_are_removed() {
  function widgets_list_should_display_multiline_items (line 132) | fn widgets_list_should_display_multiline_items() {
  function widgets_list_should_repeat_highlight_symbol (line 167) | fn widgets_list_should_repeat_highlight_symbol() {

FILE: tests/widgets_paragraph.rs
  constant SAMPLE_STRING (line 10) | const SAMPLE_STRING: &str = "The library is based on the principle of im...
  function widgets_paragraph_can_wrap_its_content (line 16) | fn widgets_paragraph_can_wrap_its_content() {
  function widgets_paragraph_renders_double_width_graphemes (line 83) | fn widgets_paragraph_renders_double_width_graphemes() {
  function widgets_paragraph_renders_mixed_width_graphemes (line 115) | fn widgets_paragraph_renders_mixed_width_graphemes() {
  function widgets_paragraph_can_wrap_with_a_trailing_nbsp (line 145) | fn widgets_paragraph_can_wrap_with_a_trailing_nbsp() {
  function widgets_paragraph_can_scroll_horizontally (line 166) | fn widgets_paragraph_can_scroll_horizontally() {

FILE: tests/widgets_table.rs
  function widgets_table_column_spacing_can_be_changed (line 12) | fn widgets_table_column_spacing_can_be_changed() {
  function widgets_table_columns_widths_can_use_fixed_length_constraints (line 110) | fn widgets_table_columns_widths_can_use_fixed_length_constraints() {
  function widgets_table_columns_widths_can_use_percentage_constraints (line 198) | fn widgets_table_columns_widths_can_use_percentage_constraints() {
  function widgets_table_columns_widths_can_use_mixed_constraints (line 304) | fn widgets_table_columns_widths_can_use_mixed_constraints() {
  function widgets_table_columns_widths_can_use_ratio_constraints (line 413) | fn widgets_table_columns_widths_can_use_ratio_constraints() {
  function widgets_table_can_have_rows_with_multi_lines (line 519) | fn widgets_table_can_have_rows_with_multi_lines() {
  function widgets_table_can_have_elements_styled_individually (line 613) | fn widgets_table_can_have_elements_styled_individually() {
  function widgets_table_should_render_even_if_empty (line 690) | fn widgets_table_should_render_even_if_empty() {
  function widgets_table_columns_dont_panic (line 720) | fn widgets_table_columns_dont_panic() {
  function widgets_table_should_clamp_offset_if_rows_are_removed (line 754) | fn widgets_table_should_clamp_offset_if_rows_are_removed() {

FILE: tests/widgets_tabs.rs
  function widgets_tabs_should_not_panic_on_narrow_areas (line 7) | fn widgets_tabs_should_not_panic_on_narrow_areas() {
  function widgets_tabs_should_truncate_the_last_item (line 29) | fn widgets_tabs_should_truncate_the_last_item() {