# curs_sp_funcs 3x

    curs_sp_funcs(3x)                                            curs_sp_funcs(3x)

## NAME

           curs_sp_funcs - curses screen-pointer extension

## SYNOPSIS

           #include <curses.h>

           int alloc_pair_sp(SCREEN* sp, int fg, int bg);
           int assume_default_colors_sp(SCREEN* sp, int fg, int bg);
           int baudrate_sp(SCREEN* sp);
           int beep_sp(SCREEN* sp);
           bool can_change_color_sp(SCREEN* sp);
           int cbreak_sp(SCREEN* sp);
           int color_content_sp(SCREEN* sp, short color, short* r, short* g, short* b);
           int curs_set_sp(SCREEN* sp, int visibility);
           int def_prog_mode_sp(SCREEN* sp);
           int def_shell_mode_sp(SCREEN* sp);

           int define_key_sp(SCREEN* sp, const char * definition, int keycode);
           int delay_output_sp(SCREEN* sp, int ms);
           int doupdate_sp(SCREEN* sp);
           int echo_sp(SCREEN* sp);
           int endwin_sp(SCREEN* sp);
           char erasechar_sp(SCREEN* sp);
           int erasewchar_sp(SCREEN* sp, wchar_t *ch);
           int extended_color_content_sp(SCREEN * sp, int color, int * r, int * g, int * b);
           int extended_pair_content_sp(SCREEN* sp, int pair, int * fg, int * bg);
           int extended_slk_color_sp(SCREEN* sp, int pair);

           void filter_sp(SCREEN* sp);
           int find_pair_sp(SCREEN* sp, int fg, int bg);
           int flash_sp(SCREEN* sp);
           int flushinp_sp(SCREEN* sp);
           int free_pair_sp(SCREEN* sp, int pair);
           int get_escdelay_sp(SCREEN* sp);
           int getmouse_sp(SCREEN* sp, MEVENT* event);
           WINDOW* getwin_sp(SCREEN* sp, FILE* filep);
           int halfdelay_sp(SCREEN* sp, int tenths);
           bool has_colors_sp(SCREEN* sp);

           bool has_ic_sp(SCREEN* sp);
           bool has_il_sp(SCREEN* sp);
           int has_key_sp(SCREEN* sp, int ch);
           bool has_mouse_sp(SCREEN* sp);
           int init_color_sp(SCREEN* sp, short color, short r, short g, short b);
           int init_extended_color_sp(SCREEN* sp, int color, int r, int g, int b);
           int init_extended_pair_sp(SCREEN* sp, int pair, int fg, int bg);
           int init_pair_sp(SCREEN* sp, short pair, short fg, short bg);
           int intrflush_sp(SCREEN* sp, WINDOW* win, bool bf);
           bool is_term_resized_sp(SCREEN* sp, int lines, int columns);

           bool isendwin_sp(SCREEN* sp);
           int key_defined_sp(SCREEN* sp, const char *definition);
           char* keybound_sp(SCREEN* sp, int keycode, int count);
           NCURSES_CONST char * keyname_sp(SCREEN* sp, int c);
           int keyok_sp(SCREEN* sp, int keycode, bool enable);
           char killchar_sp(SCREEN* sp);
           int killwchar_sp(SCREEN* sp, wchar_t *ch);
           char* longname_sp(SCREEN* sp);
           int mcprint_sp(SCREEN* sp, char *data, int len);
           int mouseinterval_sp(SCREEN* sp, int erval);

           mmask_t mousemask_sp(SCREEN* sp, mmask_t newmask, mmask_t *oldmask);
           int mvcur_sp(SCREEN* sp, int oldrow, int oldcol, int newrow, int newcol);
           int napms_sp(SCREEN* sp, int ms);
           WINDOW* newpad_sp(SCREEN* sp, int nrows, int ncols);
           SCREEN* new_prescr(void);
           SCREEN* newterm_sp(SCREEN* sp, const char *type, FILE *outfd, FILE *infd);
           WINDOW* newwin_sp(SCREEN* sp, int nlines, int ncols, int begin_y, int begin_x);
           int nl_sp(SCREEN* sp);
           int nocbreak_sp(SCREEN* sp);
           int noecho_sp(SCREEN* sp);

           void nofilter_sp(SCREEN* sp);
           int nonl_sp(SCREEN* sp);
           void noqiflush_sp(SCREEN* sp);
           int noraw_sp(SCREEN* sp);
           int pair_content_sp(SCREEN* sp, short pair, short* fg, short* bg);
           void qiflush_sp(SCREEN* sp);
           int raw_sp(SCREEN* sp);
           int reset_prog_mode_sp(SCREEN* sp);
           void reset_color_pairs_sp(SCREEN* sp);
           int reset_shell_mode_sp(SCREEN* sp);

           int resetty_sp(SCREEN* sp);
           int resize_term_sp(SCREEN* sp, int lines, int columns);
           int resizeterm_sp(SCREEN* sp, int lines, int columns);
           int ripoffline_sp(SCREEN* sp, int line, int (*init)(WINDOW* win, int fmt));
           int savetty_sp(SCREEN* sp);
           int scr_init_sp(SCREEN* sp, const char *filename);
           int scr_restore_sp(SCREEN* sp, const char *filename);
           int scr_set_sp(SCREEN* sp, const char *filename);
           int set_escdelay_sp(SCREEN* sp, int ms);
           int set_tabsize_sp(SCREEN* sp, int cols);

           int slk_attr_set_sp(SCREEN* sp, const attr_t attrs, short pair, void*opts);
           int slk_attrset_sp(SCREEN* sp, const chtype a);
           int slk_attroff_sp(SCREEN* sp, const chtype a);
           int slk_attron_sp(SCREEN* sp, const chtype a);
           attr_t slk_attr_sp(SCREEN* sp);
           int slk_clear_sp(SCREEN* sp);
           int slk_color_sp(SCREEN* sp, short pair);
           int slk_init_sp(SCREEN* sp, int fmt);
           char* slk_label_sp(SCREEN* sp, int labnum);
           int slk_noutrefresh_sp(SCREEN* sp);

           int slk_refresh_sp(SCREEN* sp);
           int slk_restore_sp(SCREEN* sp);
           int slk_set_sp(SCREEN* sp, int labnum, const char * label, int fmt);
           int slk_touch_sp(SCREEN* sp);
           int start_color_sp(SCREEN* sp);
           attr_t term_attrs_sp(SCREEN* sp);
           chtype termattrs_sp(SCREEN* sp);
           char* termname_sp(SCREEN* sp);
           int typeahead_sp(SCREEN* sp, int fd);
           int unget_wch_sp(SCREEN* sp, const wchar_t wch);

           int ungetch_sp(SCREEN* sp, int ch);
           int ungetmouse_sp(SCREEN* sp,MEVENT * event);
           int use_default_colors_sp(SCREEN* sp);
           void use_env_sp(SCREEN* sp, bool bf);
           int use_legacy_coding_sp(SCREEN* sp, int level);
           void use_tioctl_sp(SCREEN *sp, bool bf);
           int vid_attr_sp(SCREEN* sp, attr_t attrs, short pair, void * opts);
           int vid_puts_sp(SCREEN* sp, attr_t attrs, short pair, void * opts, NCURSES_SP_OUTC putc);
           int vidattr_sp(SCREEN* sp, chtype attrs);
           int vidputs_sp(SCREEN* sp, chtype attrs, NCURSES_SP_OUTC putc);
           wchar_t* wunctrl_sp(SCREEN* sp, cchar_t *ch);

           #include <form.h>

           FORM* new_form_sp(SCREEN* sp, FIELD **fields);

           #include <menu.h>

           MENU* new_menu_sp(SCREEN* sp, ITEM **items);

           #include <panel.h>

           PANEL* ceiling_panel(SCREEN* sp);
           PANEL* ground_panel(SCREEN* sp);
           void update_panels_sp(SCREEN* sp);

           #include <term.h>

           int del_curterm_sp(SCREEN* sp, TERMINAL *oterm);
           int putp_sp(SCREEN* sp, const char *str);
           int restartterm_sp(SCREEN* sp, NCURSES_CONST char*term, int filedes, int *errret);
           TERMINAL* set_curterm_sp(SCREEN* sp, TERMINAL*nterm);
           int tgetent_sp(SCREEN* sp, char *bp, const char *name);
           int tgetflag_sp(SCREEN* sp, const char *capname);
           int tgetnum_sp(SCREEN* sp, const char *capname);
           char* tgetstr_sp(SCREEN* sp, const char *capname, char **area);
           char* tgoto_sp(SCREEN* sp, const char *capname, int col, int row);
           int tigetflag_sp(SCREEN* sp, const char *capname);
           int tigetnum_sp(SCREEN* sp, const char *capname);
           char* tigetstr_sp(SCREEN* sp, const char *capname);
           /* may instead use 9 long parameters */
           char* tparm_sp(SCREEN* sp, const char *str, ...);
           int tputs_sp(SCREEN* sp, const char *str, int affcnt, NCURSES_SP_OUTC putc);

           #include <unctrl.h>

           NCURSES_CONST char* unctrl_sp(SCREEN* sp, chtype c);

## DESCRIPTION

           This  implementation  can  be  configured to provide a set of functions
           which improve the ability to manage multiple screens.  This feature can
           be added to any of the configurations supported by ncurses; it adds new
           entrypoints without changing the meaning of any of the existing ones.

### IMPROVED FUNCTIONS

           Most of the functions are new versions of existing functions.  A param-
           eter  is  added  at  the  front  of the parameter list.  It is a SCREEN
           pointer.

           The existing functions all use the current screen, which  is  a  static
           variable.  The extended functions use the specified screen, thereby re-
           ducing the number of variables which must be modified to update  multi-
           ple screens.

### NEW FUNCTIONS

           Here are the new functions:

           ceiling_panel
                this returns a pointer to the topmost panel in the given screen.

           ground_panel
                this returns a pointer to the lowest panel in the given screen.

           new_prescr
                when  creating  a  new  screen,  the library uses static variables
                which have been preset, e.g.,  by  use_env(3x),  filter(3x),  etc.
                With  the  screen-pointer extension, there are situations where it
                must create a current screen before the unextended  library  does.
                The  new_prescr function is used internally to handle these cases.
                It is also provided as an entrypoint to allow applications to cus-
                tomize the library initialization.

## NOTES

           This extension introduces some new names:

           NCURSES_SP_FUNCS
                This  is set to the library patch-level number.  In the unextended
                library, this is zero (0), to make it useful for checking  if  the
                extension is provided.

           NCURSES_SP_NAME
                The new functions are named using the macro NCURSES_SP_NAME, which
                hides the actual implementation.  Currently this adds a "_sp" suf-
                fix  to the name of the unextended function.  This manual page in-
                dexes the extensions showing the full name.   However  the  proper
                usage of these functions uses the macro, to provide for the possi-
                bility of changing the naming convention for specific library con-
                figurations.

           NCURSES_SP_OUTC
                This  is  a new function-pointer type to use in the screen-pointer
                functions where an NCURSES_OUTC is used in the unextended library.

           NCURSES_OUTC
                This is a function-pointer type used for the cases where  a  func-
                tion passes characters to the output stream, e.g., vidputs(3x).

## PORTABILITY

           These  routines  are  specific  to ncurses.  They were not supported on
           Version 7, BSD or System V implementations.  It is recommended that any
           code  depending  on  ncurses  extensions  be  conditioned  using NCURS-
           ES_SP_FUNCS.

## SEE ALSO

           curses(3x), curs_opaque(3x), curs_threads(3x).

                                                                 curs_sp_funcs(3x)