Struct pancurses::Window
[−]
[src]
pub struct Window { /* fields omitted */ }
Methods
impl Window
[src]
fn addch<T: ToChtype>(&self, ch: T) -> i32
Adds the chtype ch to the window at the current cursor position, and advances the cursor.
Note that chtypes can convey both text (a single character) and attributes, including a color pair.
fn addstr(&self, string: &str) -> i32
Write all the characters of the string to the given window.
The functionality is similar to calling window.addch() once for each character in the string.
fn addnstr(&self, string: &str, length: usize) -> i32
Write at most length characters; if length is negative, then the entire string will be added.
fn attrget(&self) -> (chtype, i16)
Retrieve attributes for the given window.
use pancurses::{A_BOLD, initscr, endwin}; let window = initscr(); window.attron(A_BOLD); let (active_attributes, color_pair) = window.attrget(); assert_eq!(A_BOLD, active_attributes); endwin();
fn attroff(&self, attributes: chtype) -> i32
Turns off the named attributes without affecting any other attributes.
fn attron(&self, attributes: chtype) -> i32
Turns on the named attributes without affecting any other attributes.
fn attrset(&self, attributes: chtype) -> i32
Sets the current attributes of the given window to attributes.
fn bkgd(&self, ch: chtype) -> i32
Not only change the background, but apply it immediately to every cell in the window.
fn bgkdset(&self, ch: chtype)
Manipulate the background of a window. The background is a chtype consisting of any combination of attributes and a character; it is combined with each chtype added or inserted to the window by addch() or insch(). Only the attribute part is used to set the background of non-blank characters, while both character and attributes are used for blank positions.
fn border<T: ToChtype>(&self,
left_side: T,
right_side: T,
top_side: T,
bottom_side: T,
top_left_corner: T,
top_right_corner: T,
bottom_left_corner: T,
bottom_right_corner: T)
-> i32
left_side: T,
right_side: T,
top_side: T,
bottom_side: T,
top_left_corner: T,
top_right_corner: T,
bottom_left_corner: T,
bottom_right_corner: T)
-> i32
Draw a border around the edges of the window.
fn chgat(&self, n: i32, attributes: chtype, color_pair: i16) -> i32
Changes the attributes of a given number of characters starting at the current cursor location. It does not update the cursor and does not perform wrapping. A character count of -1 or greater than the remaining window width means to change attributes all the way to the end of the current line.
fn clear(&self) -> i32
Similar to erase(), but also calls clearok() to ensure that the the window is cleared on the next refresh().
fn clearok(&self, bf: bool) -> i32
With clearok(), if bf is TRUE, the next call to refresh() with this window will clear the screen completely and redraw the entire screen.
fn clrtobot(&self) -> i32
Clear the window from the current cursor position to the end of the window.
fn clrtoeol(&self) -> i32
Clear the window from the current cursor position to the end of the current line.
fn color_set(&self, color_pair: i16) -> i32
Sets the current color of the given window to the foreground/background combination described by the color pair parameter.
fn copywin(&self,
destination_window: &Window,
src_tr: i32,
src_tc: i32,
dst_tr: i32,
dst_tc: i32,
dst_br: i32,
dst_bc: i32,
overlay: bool)
-> i32
destination_window: &Window,
src_tr: i32,
src_tc: i32,
dst_tr: i32,
dst_tc: i32,
dst_br: i32,
dst_bc: i32,
overlay: bool)
-> i32
Copy all text from this window to the destination window. The arguments src_tc and src_tr specify the top left corner of the region to be copied. dst_tc, dst_tr, dst_br, and dst_bc specify the region within the destination window to copy to. The argument "overlay", if TRUE, indicates that the copy is done non-destructively (as in overlay()); blanks in the source window are not copied to the destination window. When overlay is FALSE, blanks are copied.
fn delch(&self) -> i32
Delete the character under the cursor. All characters to the right of the cursor on the same line are moved to the left one position and hte last character on the line is filled with a blank. The cursor position does not change.
fn deleteln(&self) -> i32
Delete the line under the cursor. All lines below are moved up one line, and the bottom line is cleared. The cursor position does not change.
fn delwin(self) -> i32
Deletes the window, freeing all associated memory. In the case of overlapping windows, subwindows should be deleted before the main window.
fn derwin(&self,
nlines: i32,
ncols: i32,
begy: i32,
begx: i32)
-> Result<Window, i32>
nlines: i32,
ncols: i32,
begy: i32,
begx: i32)
-> Result<Window, i32>
The same as subwin(), except that begy and begx are relative to the origin of the window rather than the screen.
There is no difference between subwindows and derived windows.
fn draw_box<T: ToChtype>(&self, verch: T, horch: T) -> i32
Draw a border around the edge of the window. If any argument is zero, an appropriate default is used.
fn erase(&self) -> i32
Copies blanks (i.e. the background chtype) to every cell of the window.
fn get_beg_y(&self) -> i32
Get the upper-left y coordinate of this window
fn get_beg_x(&self) -> i32
fn get_beg_yx(&self) -> (i32, i32)
Get the upper-left y and x coordinates of this window
fn getbkgd(&self) -> chtype
Returns the given window's current background character and attributes.
fn getch(&self) -> Option<Input>
Read a character from the terminal associated with the window.
In nodelay mode, if there is no input waiting, None is returned. In delay mode, the program will hang until the system passes text through to the program. Depending on the setting of cbreak(), this will be after one character or after the first newline. Unless noecho() has been set, the character will also be echoed into the designated window.
If keypad() is TRUE, and a function key is pressed, the token for that function key will be returned instead of the raw characters. If nodelay(win, TRUE) has been called on the window and no input is waiting, None is returned.
fn get_cur_x(&self) -> i32
Return the current x coordinate of the cursor
fn get_cur_y(&self) -> i32
Return the current y coordinate of the cursor
fn get_cur_yx(&self) -> (i32, i32)
Return the current y and x coordinates of the cursor
fn get_max_x(&self) -> i32
Return the maximum x value of this Window, in other words the number of columns.
fn get_max_y(&self) -> i32
Return the maximum y value of this Window, in other words the number of rows.
fn get_max_yx(&self) -> (i32, i32)
Return the maximum y and x value of this Window
fn hline<T: ToChtype>(&self, ch: T, n: i32) -> i32
Draw a horizontal line using ch from the current cursor position. The line is at most n characters long, or as many as fit into the window.
fn keypad(&self, use_keypad: bool) -> i32
Controls whether getch() returns function/special keys as single key codes (e.g., the left arrow key as KEY_LEFT).
Per X/Open, the default for keypad mode is OFF. You'll probably want it on. With keypad mode off, if a special key is pressed, getch() does nothing or returns ERR.
fn mv(&self, y: i32, x: i32) -> i32
The cursor associated with the window is moved to the given location.
This does not move the physical cursor of the terminal until refresh() is called. The position specified is relative to the upper left corner of the window, which is (0,0).
fn mvaddch<T: ToChtype>(&self, y: i32, x: i32, ch: T) -> i32
moves the cursor to the specified position and adds ch to the specified window
fn mvaddstr(&self, y: i32, x: i32, string: &str) -> i32
Write all the characters of the string str to the given window. The functionality is similar to calling waddch() once for each character in the string.
fn mvaddnstr(&self, y: i32, x: i32, string: &str, n: i32) -> i32
Write the first'n' characters of the string str to the given window.
fn mvchgat(&self,
y: i32,
x: i32,
n: i32,
attributes: chtype,
color_pair: i16)
-> i32
y: i32,
x: i32,
n: i32,
attributes: chtype,
color_pair: i16)
-> i32
Moves the cursor and changes the attributes of a given number of characters starting at the cursor location. It does not update the cursor and does not perform wrapping. A character count of -1 or greater than the remaining window width means to change attributes all the way to the end of the current line.
fn mvinch(&self, y: i32, x: i32) -> chtype
Retrieves the character and attribute from the specified window position, in the form of a chtype.
fn mvprintw(&self, y: i32, x: i32, string: &str) -> i32
Add a string to the window at the specified cursor position.
fn nodelay(&self, enabled: bool) -> i32
Controls whether wgetch() is a non-blocking call. If the option is enabled, and no input is ready, wgetch() will return ERR. If disabled, wgetch() will hang until input is ready.
fn overlay(&self, destination_window: &Window) -> i32
Overlays this window on top of destination_window. This window and destination_window are not required to be the same size; only text where the two windows overlap is copied. overlay() is non-destructive.
fn overwrite(&self, destination_window: &Window) -> i32
Overlays this window on top of destination_window. This window and destination_window are not required to be the same size; only text where the two windows overlap is copied. overwrite() is destructive.
fn printw(&self, string: &str) -> i32
Add a string to the window at the current cursor position.
fn refresh(&self) -> i32
Copies the named window to the physical terminal screen, taking into account what is already there in order to optimize cursor movement.
This function must be called to get any output on the terminal, as other routines only manipulate data structures. Unless leaveok() has been enabled, the physical cursor of the terminal is left at the location of the window's cursor.
fn scrollok(&self, bf: bool) -> i32
If enabled and a scrolling region is set with setscrreg(), any attempt to move off the bottom margin will cause all lines in the scrolling region to scroll up one line.
fn setscrreg(&self, top: i32, bot: i32) -> i32
Sets a scrolling region in a window.
"top" and "bot" are the line numbers for the top and bottom margins.
fn subwin(&self,
nlines: i32,
ncols: i32,
begy: i32,
begx: i32)
-> Result<Window, i32>
nlines: i32,
ncols: i32,
begy: i32,
begx: i32)
-> Result<Window, i32>
Creates a new subwindow within a window.
The dimensions of the subwindow are nlines lines and ncols columns. The subwindow is at position (begy, begx) on the screen. This position is relative to the screen, and not to the window orig. Changes made to either window will affect both. When using this routine, you will often need to call touchwin() before calling wrefresh().
fn timeout(&self, milliseconds: i32)
Set blocking or non-blocking reads for the specified window.
The delay is measured in milliseconds. If it's negative, a blocking read is used; if zero, then non-blocking reads are done -- if no input is waiting, ERR is returned immediately. If the delay is positive, the read blocks for the delay period; if the period expires, ERR is returned.
fn ungetch(&self, input: &Input) -> i32
Places ch back onto the input queue to be returned by the next call to getch().
fn vline<T: ToChtype>(&self, ch: T, n: i32) -> i32
Draw a vertical line using ch from the current cursor position. The line is at most n characters long, or as many as fit into the window.