X-Git-Url: http://ncurses.scripts.mit.edu/?a=blobdiff_plain;f=doc%2Fhtml%2Fman%2Fcurs_sp_funcs.3x.html;h=d532d6cd7f8883af1d939122909b92ea0e9ec2e1;hb=HEAD;hp=db948fe04f92adbf7a2fe574f98b98e2f84dce66;hpb=58552e8c761a70f8f0bd591fecdf576fa8216e3e;p=ncurses.git diff --git a/doc/html/man/curs_sp_funcs.3x.html b/doc/html/man/curs_sp_funcs.3x.html index db948fe0..4b84cd78 100644 --- a/doc/html/man/curs_sp_funcs.3x.html +++ b/doc/html/man/curs_sp_funcs.3x.html @@ -1,6 +1,7 @@ - - -curs_sp_funcs 3x - - + +curs_sp_funcs 3x 2024-05-11 ncurses 6.5 Library calls + + -

curs_sp_funcs 3x

curs_sp_funcs 3x 2024-05-11 ncurses 6.5 Library calls

-curs_sp_funcs(3x)                                     curs_sp_funcs(3x)
+curs_sp_funcs(3x)                Library calls               curs_sp_funcs(3x)

NAME

-       curs_sp_funcs - curses screen-pointer extension
+       curs_sp_funcs - curses screen-pointer extension

SYNOPSIS

        #include <curses.h>
 
-       int assume_default_colors_sp(SCREEN*, int, int);
-       int baudrate_sp(SCREEN*);
-       int beep_sp(SCREEN*);
-       bool can_change_color_sp(SCREEN*);
-       int cbreak_sp(SCREEN*);
-       int color_content_sp(SCREEN*, short, short*, short*, short*);
-       int curs_set_sp(SCREEN*, int);
-       int define_key_sp(SCREEN*, const char *, int);
-       int def_prog_mode_sp(SCREEN*);
-       int def_shell_mode_sp(SCREEN*);
-       int delay_output_sp(SCREEN*, int);
-       int doupdate_sp(SCREEN*);
-       int echo_sp(SCREEN*);
-       int endwin_sp(SCREEN*);
-       int erasechar_sp(SCREEN*);
-       int filter_sp(SCREEN*);
-       int flash_sp(SCREEN*);
-       int flushinp_sp(SCREEN*);
-       int get_escdelay_sp(SCREEN*);
-       int getmouse_sp(SCREEN*, MEVENT*);
-       WINDOW* getwin_sp(SCREEN*, FILE*);
-       int halfdelay_sp(SCREEN*);
-       bool has_colors_sp(SCREEN*);
-       bool has_ic_sp(SCREEN*);
-       bool has_il_sp(SCREEN*);
-       int has_key_sp(SCREEN*, int);
-       bool has_mouse_sp(SCREEN*);
-       int init_color_sp(SCREEN*, short, short, short, short);
-       int init_pair_sp(SCREEN*, short, short, short);
-       int intrflush_sp(SCREEN*, WINDOW*, bool);
-       bool isendwin_sp(SCREEN*);
-       bool is_term_resized_sp(SCREEN*, int, int);
-       char* keybound_sp(SCREEN*, int, int);
-       int key_defined_sp(SCREEN*, const char *);
-       NCURSES_CONST char * keyname_sp(SCREEN*, int);
-       int keyok_sp(SCREEN*, int, bool);
-       char killchar_sp(SCREEN*);
-       int mcprint_sp(SCREEN*, char *, int);
-       int mouseinterval_sp(SCREEN*, int);
-       mmask_t mousemask_sp(SCREEN*, mmask_t, mmask_t *);
-       int mvcur_sp(SCREEN*, int, int, int, int);
-       int napms_sp(SCREEN*, int);
-       WINDOW* newpad_sp(SCREEN*, int, int);
+       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 *wc);
+       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 c);
+       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);
+       int is_cbreak_sp(SCREEN* sp);
+
+       int is_echo_sp(SCREEN* sp);
+       int is_nl_sp(SCREEN* sp);
+       int is_raw_sp(SCREEN* sp);
+       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 *wc);
+       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*, NCURSES_CONST char *, FILE *, FILE *);
-       WINDOW* newwin_sp(SCREEN*, int, int, int, int);
-       int nl_sp(SCREEN*);
-       int nocbreak_sp(SCREEN*);
-       int noecho_sp(SCREEN*);
-       int nofilter_sp(SCREEN*);
-       int nonl_sp(SCREEN*);
-       void noqiflush_sp(SCREEN*);
-       int noraw_sp(SCREEN*);
-       int pair_content_sp(SCREEN*, short, short*, short*);
-       void qiflush_sp(SCREEN*);
-       int raw_sp(SCREEN*);
-       int reset_prog_mode_sp(SCREEN*);
-       int reset_shell_mode_sp(SCREEN*);
-       int resetty_sp(SCREEN*);
-       int resize_term_sp(SCREEN*, int, int);
-       int resizeterm_sp(SCREEN*, int, int);
-       int restartterm_sp(SCREEN*, NCURSES_CONST char*, int, int *);
-       int ripoffline_sp(SCREEN*, int, int (*)(WINDOW*, int));
-       int savetty_sp(SCREEN*);
-       int scr_init_sp(SCREEN*, const char *);
-       int scr_restore_sp(SCREEN*, const char *);
-       int scr_set_sp(SCREEN*, const char *);
-       TERMINAL* set_curterm_sp(SCREEN*, TERMINAL*);
-       int set_escdelay_sp(SCREEN*, int);
-       int set_tabsize_sp(SCREEN*, int);
-       int slk_attroff_sp(SCREEN*, const chtype);
-       int slk_attron_sp(SCREEN*, const chtype);
-       int slk_attr_set_sp(SCREEN*, const attr_t, short, void*);
-       int slk_attrset_sp(SCREEN*, const chtype);
-       int slk_attr_sp(SCREEN*);
-       int slk_clear_sp(SCREEN*);
-       int slk_color_sp(SCREEN*, short);
-       int slk_init_sp(SCREEN*, int);
-       int slk_label_sp(SCREEN*, int);
-       int slk_noutrefresh_sp(SCREEN*);
-       int slk_refresh_sp(SCREEN*);
-       int slk_restore_sp(SCREEN*);
-       int slk_set_sp(SCREEN*, int, const char *, int);
-       int slk_touch_sp(SCREEN*);
-       int start_color_sp(SCREEN*);
-       attr_t term_attrs_sp(SCREEN*);
-       chtype termattrs_sp(SCREEN*);
-       char* termname_sp(SCREEN*);
-       int typeahead_sp(SCREEN*, int);
-       NCURSES_CONST char* unctrl_sp(SCREEN*, chtype);
-       int ungetch_sp(SCREEN*, int);
-       int ungetmouse_sp(SCREEN*,MEVENT *);
-       int unget_wch_sp(SCREEN*, const wchar_t);
-       int use_default_colors_sp(SCREEN*);
-       void use_env_sp(SCREEN*, bool);
-       int use_legacy_coding_sp(SCREEN*, int);
-       int vid_attr_sp(SCREEN*, attr_t, short, void *);
-       int vidattr_sp(SCREEN*, chtype);
-       int vid_puts_sp(SCREEN*, attr_t, short, void *, NCURSES_SP_OUTC);
-       int vidputs_sp(SCREEN*, chtype, NCURSES_SP_OUTC);
-       wchar_t* wunctrl_sp(SCREEN*, cchar_t *);
+       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);
+       void reset_color_pairs_sp(SCREEN* sp);
+       int reset_prog_mode_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_attrset_sp(SCREEN* sp, const chtype a);
+       int slk_attr_set_sp(SCREEN* sp, const attr_t attrs, short pair, void*opts);
+       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 wc);
+       int ungetch_sp(SCREEN* sp, int c);
+       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 *wch);
 
        #include <form.h>
 
-       int new_form_sp(SCREEN*, FIELD **);
+       FORM* new_form_sp(SCREEN* sp, FIELD **fields);
 
        #include <menu.h>
 
-       int new_menu_sp(SCREEN*, ITEM **);
+       MENU* new_menu_sp(SCREEN* sp, ITEM **items);
 
        #include <panel.h>
 
-       int ceiling_panel(SCREEN*);
-       PANEL* ground_panel(SCREEN*);
-       int update_panels_sp(SCREEN*);
+       PANEL* ceiling_panel(SCREEN* sp);
+       PANEL* ground_panel(SCREEN* sp);
+       void update_panels_sp(SCREEN* sp);
 
        #include <term.h>
 
-       int del_curterm_sp(SCREEN*, TERMINAL *);
-       int putp_sp(SCREEN*, const char *);
-       int tgetflag_sp(SCREEN*, char *, const char *);
-       int tgetent_sp(SCREEN*, char *, const char *);
-       int tgetnum_sp(SCREEN*, NCURSES_CONST char *);
-       char* tgetstr_sp(SCREEN*, NCURSES_CONST char *, char **);
-       int tigetflag_sp(SCREEN*, NCURSES_CONST char *);
-       int tigetnum_sp(SCREEN*, NCURSES_CONST char *);
-       char* tigetstr_sp(SCREEN*, NCURSES_CONST char *);
-       int tputs_sp(SCREEN*, const char *, int, NCURSES_SP_OUTC);
+       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);
+       /* tparm_sp may use 9 long parameters rather than being variadic */
+       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 ch);

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 configu-
-       rations supported by  ncurses;  it  adds  new  entrypoints
-       without changing the meaning of any of the existing ones.
+       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
+       symbols without changing the meaning of any of the existing ones.
 
 
-

IMPROVED FUNCTIONS

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

Improved Functions

+       Most of the functions  are  new  versions  of  existing  functions.   A
+       parameter  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 reducing the number of variables
-       which must be modified to update multiple screens.
+       The existing functions all use the current screen, which  is  a  static
+       variable.   The  extended  functions  use the specified screen, thereby
+       reducing the number of variables  which  must  be  modified  to  update
+       multiple screens.
 
 
-

NEW FUNCTIONS

New Functions

        Here are the new functions:
 
        ceiling_panel
-            this returns a pointer to the topmost  panel  in  the
-            given screen.
+            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.
+            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-point-
-            er extension, there are situations where it must cre-
-            ate 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 entry-
-            point  to allow applications to customize the library
+            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 to allow  applications  to  customize  library
             initialization.
 
 
@@ -231,44 +259,42 @@
        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.
+            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  NCURS-
-            ES_SP_NAME,  which  hides  the actual implementation.
-            Currently this adds a "_sp" suffix to the name of the
-            unextended  function.   This  manual page indexes the
-            extensions showing the full name.  However the proper
-            usage  of  these functions uses the macro, to provide
-            for the possibility of changing the naming convention
-            for specific library configurations.
+            The new functions are named using the macro NCURSES_SP_NAME, which
+            hides the actual implementation.   Currently  this  adds  a  "_sp"
+            suffix  to  the name of the unextended function.  This manual page
+            indexes the extensions showing the full name.  However the  proper
+            usage  of  these  functions  uses  the  macro,  to provide for the
+            possibility of changing the naming convention for specific library
+            configurations.
 
        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.
+            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 function  passes  characters  to  the  output
-            stream, e.g., vidputs(3x).
+            This is a  function-pointer  type  used  for  the  cases  where  a
+            function   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 ex-
-       tensions be conditioned using NCURSES_SP_FUNCS.
+       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
+       NCURSES_SP_FUNCS.