Bug #4748 » ruby_doc_updates-20110613_update-curses_vbatts.patch
| ext/curses/curses.c | ||
|---|---|---|
|
*
|
||
|
* This will read and pop the mouse event data off the queue
|
||
|
*
|
||
|
* TODO: all the BUTTON* constants are needed here, to examine the mask of the event
|
||
|
* See the BUTTON*, ALL_MOUSE_EVENTS and REPORT_MOUSE_POSITION constants, to examine the mask of the event
|
||
|
*/
|
||
|
static VALUE
|
||
|
curses_getmouse(VALUE obj)
|
||
| ... | ... | |
|
* :include: rain.rb
|
||
|
*
|
||
|
*
|
||
|
* == TODO
|
||
|
*
|
||
|
* * document all the A_* constants
|
||
|
* * document all the BUTTON*_* constants
|
||
|
* * document all the ALL_MOUSE_EVENTS and REPORT_MOUSE_POSITION constants
|
||
|
*/
|
||
|
void
|
||
|
Init_curses(void)
|
||
| ... | ... | |
|
#define rb_curses_define_const(c) rb_define_const(mCurses,#c,UINT2NUM(c))
|
||
|
#ifdef USE_COLOR
|
||
|
/* Document-const: A_ATTRIBUTES
|
||
|
*
|
||
|
* Character attribute mask:
|
||
|
* Bit-mask to extract attributes
|
||
|
*
|
||
|
* See Curses.inch or Curses::Window.inch
|
||
|
*/
|
||
|
rb_curses_define_const(A_ATTRIBUTES);
|
||
|
#ifdef A_NORMAL
|
||
|
/* Document-const: A_NORMAL
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* Normal display (no highlight)
|
||
|
*
|
||
|
* See Curses.attrset
|
||
|
*/
|
||
|
rb_curses_define_const(A_NORMAL);
|
||
|
#endif
|
||
|
/* Document-const: A_STANDOUT
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* Best highlighting mode of the terminal.
|
||
|
*
|
||
|
* See Curses.attrset
|
||
|
*/
|
||
|
rb_curses_define_const(A_STANDOUT);
|
||
|
/* Document-const: A_UNDERLINE
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* Underlining
|
||
|
*
|
||
|
* See Curses.attrset
|
||
|
*/
|
||
|
rb_curses_define_const(A_UNDERLINE);
|
||
|
/* Document-const: A_REVERSE
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* Reverse video
|
||
|
*
|
||
|
* See Curses.attrset
|
||
|
*/
|
||
|
rb_curses_define_const(A_REVERSE);
|
||
|
/* Document-const: A_BLINK
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* Blinking
|
||
|
*
|
||
|
* See Curses.attrset
|
||
|
*/
|
||
|
rb_curses_define_const(A_BLINK);
|
||
|
/* Document-const: A_DIM
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* Half bright
|
||
|
*
|
||
|
* See Curses.attrset
|
||
|
*/
|
||
|
rb_curses_define_const(A_DIM);
|
||
|
/* Document-const: A_BOLD
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* Extra bright or bold
|
||
|
*
|
||
|
* See Curses.attrset
|
||
|
*/
|
||
|
rb_curses_define_const(A_BOLD);
|
||
|
/* Document-const: A_PROTECT
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* Protected mode
|
||
|
*
|
||
|
* See Curses.attrset
|
||
|
*/
|
||
|
rb_curses_define_const(A_PROTECT);
|
||
|
#ifdef A_INVIS /* for NetBSD */
|
||
|
/* Document-const: A_INVIS
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* Invisible or blank mode
|
||
|
*
|
||
|
* See Curses.attrset
|
||
|
*/
|
||
|
rb_curses_define_const(A_INVIS);
|
||
|
#endif
|
||
|
/* Document-const: A_ALTCHARSET
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* Alternate character set
|
||
|
*
|
||
|
* See Curses.attrset
|
||
|
*/
|
||
|
rb_curses_define_const(A_ALTCHARSET);
|
||
|
/* Document-const: A_CHARTEXT
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* Bit-mask to extract a character
|
||
|
*
|
||
|
* See Curses.attrset
|
||
|
*/
|
||
|
rb_curses_define_const(A_CHARTEXT);
|
||
|
#ifdef A_HORIZONTAL
|
||
|
/* Document-const: A_HORIZONTAL
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* horizontal highlight
|
||
|
*
|
||
|
* Check system curs_attr(3x) for support
|
||
|
*/
|
||
|
rb_curses_define_const(A_HORIZONTAL);
|
||
|
#endif
|
||
|
#ifdef A_LEFT
|
||
|
/* Document-const: A_LEFT
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* left highlight
|
||
|
*
|
||
|
* Check system curs_attr(3x) for support
|
||
|
*/
|
||
|
rb_curses_define_const(A_LEFT);
|
||
|
#endif
|
||
|
#ifdef A_LOW
|
||
|
/* Document-const: A_LOW
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* low highlight
|
||
|
*
|
||
|
* Check system curs_attr(3x) for support
|
||
|
*/
|
||
|
rb_curses_define_const(A_LOW);
|
||
|
#endif
|
||
|
#ifdef A_RIGHT
|
||
|
/* Document-const: A_RIGHT
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* right highlight
|
||
|
*
|
||
|
* Check system curs_attr(3x) for support
|
||
|
*/
|
||
|
rb_curses_define_const(A_RIGHT);
|
||
|
#endif
|
||
|
#ifdef A_TOP
|
||
|
/* Document-const: A_TOP
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* top highlight
|
||
|
*
|
||
|
* Check system curs_attr(3x) for support
|
||
|
*/
|
||
|
rb_curses_define_const(A_TOP);
|
||
|
#endif
|
||
|
#ifdef A_VERTICAL
|
||
|
/* Document-const: A_VERTICAL
|
||
|
*
|
||
|
* Attribute mask:
|
||
|
* vertical highlight
|
||
|
*
|
||
|
* Check system curs_attr(3x) for support
|
||
|
*/
|
||
|
rb_curses_define_const(A_VERTICAL);
|
||
|
#endif
|
||
|
/* Document-const: A_COLOR
|
||
|
*
|
||
|
* Character attribute mask:
|
||
|
* Bit-mask to extract color-pair field information
|
||
|
*
|
||
|
* See Curses.inch or Curses::Window.inch
|
||
|
*/
|
||
|
rb_curses_define_const(A_COLOR);
|
||
|
#ifdef COLORS
|
||
| ... | ... | |
|
#endif /* USE_COLOR */
|
||
|
#ifdef USE_MOUSE
|
||
|
#ifdef BUTTON1_PRESSED
|
||
|
/* Document-const: BUTTON1_PRESSED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 1 down
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON1_PRESSED);
|
||
|
#endif
|
||
|
#ifdef BUTTON1_RELEASED
|
||
|
/* Document-const: BUTTON1_RELEASED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 1 up
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON1_RELEASED);
|
||
|
#endif
|
||
|
#ifdef BUTTON1_CLICKED
|
||
|
/* Document-const: BUTTON1_CLICKED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 1 clicked
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON1_CLICKED);
|
||
|
#endif
|
||
|
#ifdef BUTTON1_DOUBLE_CLICKED
|
||
|
/* Document-const: BUTTON1_DOUBLE_CLICKED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 1 double clicked
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON1_DOUBLE_CLICKED);
|
||
|
#endif
|
||
|
#ifdef BUTTON1_TRIPLE_CLICKED
|
||
|
/* Document-const: BUTTON1_TRIPLE_CLICKED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 1 triple clicked
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON1_TRIPLE_CLICKED);
|
||
|
#endif
|
||
|
#ifdef BUTTON2_PRESSED
|
||
|
/* Document-const: BUTTON2_PRESSED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 2 down
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON2_PRESSED);
|
||
|
#endif
|
||
|
#ifdef BUTTON2_RELEASED
|
||
|
/* Document-const: BUTTON2_RELEASED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 2 up
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON2_RELEASED);
|
||
|
#endif
|
||
|
#ifdef BUTTON2_CLICKED
|
||
|
/* Document-const: BUTTON2_CLICKED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 2 clicked
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON2_CLICKED);
|
||
|
#endif
|
||
|
#ifdef BUTTON2_DOUBLE_CLICKED
|
||
|
/* Document-const: BUTTON2_DOUBLE_CLICKED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 2 double clicked
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON2_DOUBLE_CLICKED);
|
||
|
#endif
|
||
|
#ifdef BUTTON2_TRIPLE_CLICKED
|
||
|
/* Document-const: BUTTON2_TRIPLE_CLICKED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 2 triple clicked
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON2_TRIPLE_CLICKED);
|
||
|
#endif
|
||
|
#ifdef BUTTON3_PRESSED
|
||
|
/* Document-const: BUTTON3_PRESSED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 3 down
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON3_PRESSED);
|
||
|
#endif
|
||
|
#ifdef BUTTON3_RELEASED
|
||
|
/* Document-const: BUTTON3_RELEASED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 3 up
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON3_RELEASED);
|
||
|
#endif
|
||
|
#ifdef BUTTON3_CLICKED
|
||
|
/* Document-const: BUTTON3_CLICKED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 3 clicked
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON3_CLICKED);
|
||
|
#endif
|
||
|
#ifdef BUTTON3_DOUBLE_CLICKED
|
||
|
/* Document-const: BUTTON3_DOUBLE_CLICKED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 3 double clicked
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON3_DOUBLE_CLICKED);
|
||
|
#endif
|
||
|
#ifdef BUTTON3_TRIPLE_CLICKED
|
||
|
/* Document-const: BUTTON3_TRIPLE_CLICKED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 3 triple clicked
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON3_TRIPLE_CLICKED);
|
||
|
#endif
|
||
|
#ifdef BUTTON4_PRESSED
|
||
|
/* Document-const: BUTTON4_PRESSED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 4 down
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON4_PRESSED);
|
||
|
#endif
|
||
|
#ifdef BUTTON4_RELEASED
|
||
|
/* Document-const: BUTTON4_RELEASED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 4 up
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON4_RELEASED);
|
||
|
#endif
|
||
|
#ifdef BUTTON4_CLICKED
|
||
|
/* Document-const: BUTTON4_CLICKED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 4 clicked
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON4_CLICKED);
|
||
|
#endif
|
||
|
#ifdef BUTTON4_DOUBLE_CLICKED
|
||
|
/* Document-const: BUTTON4_DOUBLE_CLICKED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 4 double clicked
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON4_DOUBLE_CLICKED);
|
||
|
#endif
|
||
|
#ifdef BUTTON4_TRIPLE_CLICKED
|
||
|
/* Document-const: BUTTON4_TRIPLE_CLICKED
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* mouse button 4 triple clicked
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON4_TRIPLE_CLICKED);
|
||
|
#endif
|
||
|
#ifdef BUTTON_SHIFT
|
||
|
/* Document-const: BUTTON_SHIFT
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* shift was down during button state change
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON_SHIFT);
|
||
|
#endif
|
||
|
#ifdef BUTTON_CTRL
|
||
|
/* Document-const: BUTTON_CTRL
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* control was down during button state change
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON_CTRL);
|
||
|
#endif
|
||
|
#ifdef BUTTON_ALT
|
||
|
/* Document-const: BUTTON_ALT
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* alt was down during button state change
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(BUTTON_ALT);
|
||
|
#endif
|
||
|
#ifdef ALL_MOUSE_EVENTS
|
||
|
/* Document-const: ALL_MOUSE_EVENTS
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* report all button state changes
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(ALL_MOUSE_EVENTS);
|
||
|
#endif
|
||
|
#ifdef REPORT_MOUSE_POSITION
|
||
|
/* Document-const: REPORT_MOUSE_POSITION
|
||
|
*
|
||
|
* Mouse event mask:
|
||
|
* report mouse movement
|
||
|
*
|
||
|
* See Curses.getmouse
|
||
|
*/
|
||
|
rb_curses_define_const(REPORT_MOUSE_POSITION);
|
||
|
#endif
|
||
|
#endif /* USE_MOUSE */
|
||
|
#if defined(KEY_MOUSE) && defined(USE_MOUSE)
|
||
|
/* Document-const: KEY_MOUSE
|
||
|
* Mouse event read
|
||
|
*/
|
||
|
/* Document-const: MOUSE
|
||
|
*
|
||
|
* Mouse event read
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_MOUSE);
|
||
|
rb_define_const(mKey, "MOUSE", INT2NUM(KEY_MOUSE));
|
||
|
#endif
|
||
|
#ifdef KEY_MIN
|
||
|
/* Document-const: KEY_MIN
|
||
|
* The minimum allowed curses key value.
|
||
|
*/
|
||
|
/* Document-const: MIN
|
||
|
*
|
||
|
* The minimum allowed curses key value.
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_MIN);
|
||
|
rb_define_const(mKey, "MIN", INT2NUM(KEY_MIN));
|
||
|
#endif
|
||
|
#ifdef KEY_BREAK
|
||
|
/* Document-const: KEY_BREAK
|
||
|
* Break key
|
||
|
*/
|
||
|
/* Document-const: BREAK
|
||
|
*
|
||
|
* Break key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_BREAK);
|
||
|
rb_define_const(mKey, "BREAK", INT2NUM(KEY_BREAK));
|
||
|
#endif
|
||
|
#ifdef KEY_DOWN
|
||
|
/* Document-const: KEY_DOWN
|
||
|
* the down arrow key
|
||
|
*/
|
||
|
/* Document-const: DOWN
|
||
|
*
|
||
|
* the down arrow key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_DOWN);
|
||
|
rb_define_const(mKey, "DOWN", INT2NUM(KEY_DOWN));
|
||
|
#endif
|
||
|
#ifdef KEY_UP
|
||
|
/* Document-const: KEY_UP
|
||
|
* the up arrow key
|
||
|
*/
|
||
|
/* Document-const: UP
|
||
|
*
|
||
|
* the up arrow key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_UP);
|
||
|
rb_define_const(mKey, "UP", INT2NUM(KEY_UP));
|
||
|
#endif
|
||
|
#ifdef KEY_LEFT
|
||
|
/* Document-const: KEY_LEFT
|
||
|
* the left arrow key
|
||
|
*/
|
||
|
/* Document-const: LEFT
|
||
|
*
|
||
|
* the left arrow key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_LEFT);
|
||
|
rb_define_const(mKey, "LEFT", INT2NUM(KEY_LEFT));
|
||
|
#endif
|
||
|
#ifdef KEY_RIGHT
|
||
|
/* Document-const: KEY_RIGHT
|
||
|
* the right arrow key
|
||
|
*/
|
||
|
/* Document-const: RIGHT
|
||
|
*
|
||
|
* the right arrow key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_RIGHT);
|
||
|
rb_define_const(mKey, "RIGHT", INT2NUM(KEY_RIGHT));
|
||
|
#endif
|
||
|
#ifdef KEY_HOME
|
||
|
/* Document-const: KEY_HOME
|
||
|
* Home key (upward+left arrow)
|
||
|
*/
|
||
|
/* Document-const: HOME
|
||
|
*
|
||
|
* Home key (upward+left arrow)
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_HOME);
|
||
|
rb_define_const(mKey, "HOME", INT2NUM(KEY_HOME));
|
||
|
#endif
|
||
|
#ifdef KEY_BACKSPACE
|
||
|
/* Document-const: KEY_BACKSPACE
|
||
|
* Backspace
|
||
|
*/
|
||
|
/* Document-const: BACKSPACE
|
||
|
*
|
||
|
* Backspace
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_BACKSPACE);
|
||
| ... | ... | |
|
}
|
||
|
#endif
|
||
|
#ifdef KEY_DL
|
||
|
/* Document-const: KEY_DL
|
||
|
* Delete line
|
||
|
*/
|
||
|
/* Document-const: DL
|
||
|
*
|
||
|
* Delete line
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_DL);
|
||
|
rb_define_const(mKey, "DL", INT2NUM(KEY_DL));
|
||
|
#endif
|
||
|
#ifdef KEY_IL
|
||
|
/* Document-const: KEY_IL
|
||
|
* Insert line
|
||
|
*/
|
||
|
/* Document-const: IL
|
||
|
*
|
||
|
* Insert line
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_IL);
|
||
|
rb_define_const(mKey, "IL", INT2NUM(KEY_IL));
|
||
|
#endif
|
||
|
#ifdef KEY_DC
|
||
|
/* Document-const: KEY_DC
|
||
|
* Delete character
|
||
|
*/
|
||
|
/* Document-const: DC
|
||
|
*
|
||
|
* Delete character
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_DC);
|
||
|
rb_define_const(mKey, "DC", INT2NUM(KEY_DC));
|
||
|
#endif
|
||
|
#ifdef KEY_IC
|
||
|
/* Document-const: KEY_IC
|
||
|
* Insert char or enter insert mode
|
||
|
*/
|
||
|
/* Document-const: IC
|
||
|
*
|
||
|
* Insert char or enter insert mode
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_IC);
|
||
|
rb_define_const(mKey, "IC", INT2NUM(KEY_IC));
|
||
|
#endif
|
||
|
#ifdef KEY_EIC
|
||
|
/* Document-const: KEY_EIC
|
||
|
* Enter insert char mode
|
||
|
*/
|
||
|
/* Document-const: EIC
|
||
|
*
|
||
|
* Enter insert char mode
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_EIC);
|
||
|
rb_define_const(mKey, "EIC", INT2NUM(KEY_EIC));
|
||
|
#endif
|
||
|
#ifdef KEY_CLEAR
|
||
|
/* Document-const: KEY_CLEAR
|
||
|
* Clear Screen
|
||
|
*/
|
||
|
/* Document-const: CLEAR
|
||
|
*
|
||
|
* Clear Screen
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_CLEAR);
|
||
|
rb_define_const(mKey, "CLEAR", INT2NUM(KEY_CLEAR));
|
||
|
#endif
|
||
|
#ifdef KEY_EOS
|
||
|
/* Document-const: KEY_EOS
|
||
|
* Clear to end of screen
|
||
|
*/
|
||
|
/* Document-const: EOS
|
||
|
*
|
||
|
* Clear to end of screen
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_EOS);
|
||
|
rb_define_const(mKey, "EOS", INT2NUM(KEY_EOS));
|
||
|
#endif
|
||
|
#ifdef KEY_EOL
|
||
|
/* Document-const: KEY_EOL
|
||
|
* Clear to end of line
|
||
|
*/
|
||
|
/* Document-const: EOL
|
||
|
*
|
||
|
* Clear to end of line
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_EOL);
|
||
|
rb_define_const(mKey, "EOL", INT2NUM(KEY_EOL));
|
||
|
#endif
|
||
|
#ifdef KEY_SF
|
||
|
/* Document-const: KEY_SF
|
||
|
* Scroll 1 line forward
|
||
|
*/
|
||
|
/* Document-const: SF
|
||
|
*
|
||
|
* Scroll 1 line forward
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SF);
|
||
|
rb_define_const(mKey, "SF", INT2NUM(KEY_SF));
|
||
|
#endif
|
||
|
#ifdef KEY_SR
|
||
|
/* Document-const: KEY_SR
|
||
|
* Scroll 1 line backware (reverse)
|
||
|
*/
|
||
|
/* Document-const: SR
|
||
|
*
|
||
|
* Scroll 1 line backware (reverse)
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SR);
|
||
|
rb_define_const(mKey, "SR", INT2NUM(KEY_SR));
|
||
|
#endif
|
||
|
#ifdef KEY_NPAGE
|
||
|
/* Document-const: KEY_NPAGE
|
||
|
* Next page
|
||
|
*/
|
||
|
/* Document-const: NPAGE
|
||
|
*
|
||
|
* Next page
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_NPAGE);
|
||
|
rb_define_const(mKey, "NPAGE", INT2NUM(KEY_NPAGE));
|
||
|
#endif
|
||
|
#ifdef KEY_PPAGE
|
||
|
/* Document-const: KEY_PPAGE
|
||
|
* Previous page
|
||
|
*/
|
||
|
/* Document-const: PPAGE
|
||
|
*
|
||
|
* Previous page
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_PPAGE);
|
||
|
rb_define_const(mKey, "PPAGE", INT2NUM(KEY_PPAGE));
|
||
|
#endif
|
||
|
#ifdef KEY_STAB
|
||
|
/* Document-const: KEY_STAB
|
||
|
* Set tab
|
||
|
*/
|
||
|
/* Document-const: STAB
|
||
|
*
|
||
|
* Set tab
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_STAB);
|
||
|
rb_define_const(mKey, "STAB", INT2NUM(KEY_STAB));
|
||
|
#endif
|
||
|
#ifdef KEY_CTAB
|
||
|
/* Document-const: KEY_CTAB
|
||
|
* Clear tab
|
||
|
*/
|
||
|
/* Document-const: CTAB
|
||
|
*
|
||
|
* Clear tab
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_CTAB);
|
||
|
rb_define_const(mKey, "CTAB", INT2NUM(KEY_CTAB));
|
||
|
#endif
|
||
|
#ifdef KEY_CATAB
|
||
|
/* Document-const: KEY_CATAB
|
||
|
* Clear all tabs
|
||
|
*/
|
||
|
/* Document-const: CATAB
|
||
|
*
|
||
|
* Clear all tabs
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_CATAB);
|
||
|
rb_define_const(mKey, "CATAB", INT2NUM(KEY_CATAB));
|
||
|
#endif
|
||
|
#ifdef KEY_ENTER
|
||
|
/* Document-const: KEY_ENTER
|
||
|
* Enter or send
|
||
|
*/
|
||
|
/* Document-const: ENTER
|
||
|
*
|
||
|
* Enter or send
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_ENTER);
|
||
|
rb_define_const(mKey, "ENTER", INT2NUM(KEY_ENTER));
|
||
|
#endif
|
||
|
#ifdef KEY_SRESET
|
||
|
/* Document-const: KEY_SRESET
|
||
|
* Soft (partial) reset
|
||
|
*/
|
||
|
/* Document-const: SRESET
|
||
|
*
|
||
|
* Soft (partial) reset
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SRESET);
|
||
|
rb_define_const(mKey, "SRESET", INT2NUM(KEY_SRESET));
|
||
|
#endif
|
||
|
#ifdef KEY_RESET
|
||
|
/* Document-const: KEY_RESET
|
||
|
* Reset or hard reset
|
||
|
*/
|
||
|
/* Document-const: RESET
|
||
|
*
|
||
|
* Reset or hard reset
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_RESET);
|
||
|
rb_define_const(mKey, "RESET", INT2NUM(KEY_RESET));
|
||
|
#endif
|
||
|
#ifdef KEY_PRINT
|
||
|
/* Document-const: KEY_PRINT
|
||
|
* Print or copy
|
||
|
*/
|
||
|
/* Document-const: PRINT
|
||
|
*
|
||
|
* Print or copy
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_PRINT);
|
||
|
rb_define_const(mKey, "PRINT", INT2NUM(KEY_PRINT));
|
||
|
#endif
|
||
|
#ifdef KEY_LL
|
||
|
/* Document-const: KEY_LL
|
||
|
* Home down or bottom (lower left)
|
||
|
*/
|
||
|
/* Document-const: LL
|
||
|
*
|
||
|
* Home down or bottom (lower left)
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_LL);
|
||
|
rb_define_const(mKey, "LL", INT2NUM(KEY_LL));
|
||
|
#endif
|
||
|
#ifdef KEY_A1
|
||
|
/* Document-const: KEY_A1
|
||
|
* Upper left of keypad
|
||
|
*/
|
||
|
/* Document-const: A1
|
||
|
*
|
||
|
* Upper left of keypad
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_A1);
|
||
|
rb_define_const(mKey, "A1", INT2NUM(KEY_A1));
|
||
|
#endif
|
||
|
#ifdef KEY_A3
|
||
|
/* Document-const: KEY_A3
|
||
|
* Upper right of keypad
|
||
|
*/
|
||
|
/* Document-const: A3
|
||
|
*
|
||
|
* Upper right of keypad
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_A3);
|
||
|
rb_define_const(mKey, "A3", INT2NUM(KEY_A3));
|
||
|
#endif
|
||
|
#ifdef KEY_B2
|
||
|
/* Document-const: KEY_B2
|
||
|
* Center of keypad
|
||
|
*/
|
||
|
/* Document-const: B2
|
||
|
*
|
||
|
* Center of keypad
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_B2);
|
||
|
rb_define_const(mKey, "B2", INT2NUM(KEY_B2));
|
||
|
#endif
|
||
|
#ifdef KEY_C1
|
||
|
/* Document-const: KEY_C1
|
||
|
* Lower left of keypad
|
||
|
*/
|
||
|
/* Document-const: C1
|
||
|
*
|
||
|
* Lower left of keypad
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_C1);
|
||
|
rb_define_const(mKey, "C1", INT2NUM(KEY_C1));
|
||
|
#endif
|
||
|
#ifdef KEY_C3
|
||
|
/* Document-const: KEY_C3
|
||
|
* Lower right of keypad
|
||
|
*/
|
||
|
/* Document-const: C3
|
||
|
*
|
||
|
* Lower right of keypad
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_C3);
|
||
| ... | ... | |
|
#endif
|
||
|
#ifdef KEY_BTAB
|
||
|
/* Document-const: BTAB
|
||
|
*
|
||
|
* Back tab key
|
||
|
*/
|
||
|
/* Document-const: KEY_BTAB
|
||
|
* Back tab key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_BTAB);
|
||
|
rb_define_const(mKey, "BTAB", INT2NUM(KEY_BTAB));
|
||
|
#endif
|
||
|
#ifdef KEY_BEG
|
||
|
/* Document-const: KEY_BEG
|
||
|
* Beginning key
|
||
|
*/
|
||
|
/* Document-const: BEG
|
||
|
*
|
||
|
* Beginning key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_BEG);
|
||
|
rb_define_const(mKey, "BEG", INT2NUM(KEY_BEG));
|
||
|
#endif
|
||
|
#ifdef KEY_CANCEL
|
||
|
/* Document-const: KEY_CANCEL
|
||
|
* Cancel key
|
||
|
*/
|
||
|
/* Document-const: CANCEL
|
||
|
*
|
||
|
* Cancel key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_CANCEL);
|
||
|
rb_define_const(mKey, "CANCEL", INT2NUM(KEY_CANCEL));
|
||
|
#endif
|
||
|
#ifdef KEY_CLOSE
|
||
|
/* Document-const: KEY_CLOSE
|
||
|
* Close key
|
||
|
*/
|
||
|
/* Document-const: CLOSE
|
||
|
*
|
||
|
* Close key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_CLOSE);
|
||
|
rb_define_const(mKey, "CLOSE", INT2NUM(KEY_CLOSE));
|
||
|
#endif
|
||
|
#ifdef KEY_COMMAND
|
||
|
/* Document-const: KEY_COMMAND
|
||
|
* Cmd (command) key
|
||
|
*/
|
||
|
/* Document-const: COMMAND
|
||
|
*
|
||
|
* Cmd (command) key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_COMMAND);
|
||
|
rb_define_const(mKey, "COMMAND", INT2NUM(KEY_COMMAND));
|
||
|
#endif
|
||
|
#ifdef KEY_COPY
|
||
|
/* Document-const: KEY_COPY
|
||
|
* Copy key
|
||
|
*/
|
||
|
/* Document-const: COPY
|
||
|
*
|
||
|
* Copy key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_COPY);
|
||
|
rb_define_const(mKey, "COPY", INT2NUM(KEY_COPY));
|
||
|
#endif
|
||
|
#ifdef KEY_CREATE
|
||
|
/* Document-const: KEY_CREATE
|
||
|
* Create key
|
||
|
*/
|
||
|
/* Document-const: CREATE
|
||
|
*
|
||
|
* Create key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_CREATE);
|
||
|
rb_define_const(mKey, "CREATE", INT2NUM(KEY_CREATE));
|
||
|
#endif
|
||
|
#ifdef KEY_END
|
||
|
/* Document-const: KEY_END
|
||
|
* End key
|
||
|
*/
|
||
|
/* Document-const: END
|
||
|
*
|
||
|
* End key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_END);
|
||
|
rb_define_const(mKey, "END", INT2NUM(KEY_END));
|
||
|
#endif
|
||
|
#ifdef KEY_EXIT
|
||
|
/* Document-const: KEY_EXIT
|
||
|
* Exit key
|
||
|
*/
|
||
|
/* Document-const: EXIT
|
||
|
*
|
||
|
* Exit key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_EXIT);
|
||
|
rb_define_const(mKey, "EXIT", INT2NUM(KEY_EXIT));
|
||
|
#endif
|
||
|
#ifdef KEY_FIND
|
||
|
/* Document-const: KEY_FIND
|
||
|
* Find key
|
||
|
*/
|
||
|
/* Document-const: FIND
|
||
|
*
|
||
|
* Find key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_FIND);
|
||
|
rb_define_const(mKey, "FIND", INT2NUM(KEY_FIND));
|
||
|
#endif
|
||
|
#ifdef KEY_HELP
|
||
|
/* Document-const: KEY_HELP
|
||
|
* Help key
|
||
|
*/
|
||
|
/* Document-const: HELP
|
||
|
*
|
||
|
* Help key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_HELP);
|
||
|
rb_define_const(mKey, "HELP", INT2NUM(KEY_HELP));
|
||
|
#endif
|
||
|
#ifdef KEY_MARK
|
||
|
/* Document-const: KEY_MARK
|
||
|
* Mark key
|
||
|
*/
|
||
|
/* Document-const: MARK
|
||
|
*
|
||
|
* Mark key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_MARK);
|
||
|
rb_define_const(mKey, "MARK", INT2NUM(KEY_MARK));
|
||
|
#endif
|
||
|
#ifdef KEY_MESSAGE
|
||
|
/* Document-const: KEY_MESSAGE
|
||
|
* Message key
|
||
|
*/
|
||
|
/* Document-const: MESSAGE
|
||
|
*
|
||
|
* Message key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_MESSAGE);
|
||
|
rb_define_const(mKey, "MESSAGE", INT2NUM(KEY_MESSAGE));
|
||
|
#endif
|
||
|
#ifdef KEY_MOVE
|
||
|
/* Document-const: KEY_MOVE
|
||
|
* Move key
|
||
|
*/
|
||
|
/* Document-const: MOVE
|
||
|
*
|
||
|
* Move key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_MOVE);
|
||
|
rb_define_const(mKey, "MOVE", INT2NUM(KEY_MOVE));
|
||
|
#endif
|
||
|
#ifdef KEY_NEXT
|
||
|
/* Document-const: KEY_NEXT
|
||
|
* Next object key
|
||
|
*/
|
||
|
/* Document-const: NEXT
|
||
|
*
|
||
|
* Next object key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_NEXT);
|
||
|
rb_define_const(mKey, "NEXT", INT2NUM(KEY_NEXT));
|
||
|
#endif
|
||
|
#ifdef KEY_OPEN
|
||
|
/* Document-const: KEY_OPEN
|
||
|
* Open key
|
||
|
*/
|
||
|
/* Document-const: OPEN
|
||
|
*
|
||
|
* Open key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_OPEN);
|
||
|
rb_define_const(mKey, "OPEN", INT2NUM(KEY_OPEN));
|
||
|
#endif
|
||
|
#ifdef KEY_OPTIONS
|
||
|
/* Document-const: KEY_OPTIONS
|
||
|
* Options key
|
||
|
*/
|
||
|
/* Document-const: OPTIONS
|
||
|
*
|
||
|
* Options key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_OPTIONS);
|
||
|
rb_define_const(mKey, "OPTIONS", INT2NUM(KEY_OPTIONS));
|
||
|
#endif
|
||
|
#ifdef KEY_PREVIOUS
|
||
|
/* Document-const: KEY_PREVIOUS
|
||
|
* Previous object key
|
||
|
*/
|
||
|
/* Document-const: PREVIOUS
|
||
|
*
|
||
|
* Previous object key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_PREVIOUS);
|
||
|
rb_define_const(mKey, "PREVIOUS", INT2NUM(KEY_PREVIOUS));
|
||
|
#endif
|
||
|
#ifdef KEY_REDO
|
||
|
/* Document-const: KEY_REDO
|
||
|
* Redo key
|
||
|
*/
|
||
|
/* Document-const: REDO
|
||
|
*
|
||
|
* Redo key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_REDO);
|
||
|
rb_define_const(mKey, "REDO", INT2NUM(KEY_REDO));
|
||
|
#endif
|
||
|
#ifdef KEY_REFERENCE
|
||
|
/* Document-const: KEY_REFERENCE
|
||
|
* Reference key
|
||
|
*/
|
||
|
/* Document-const: REFERENCE
|
||
|
*
|
||
|
* Reference key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_REFERENCE);
|
||
|
rb_define_const(mKey, "REFERENCE", INT2NUM(KEY_REFERENCE));
|
||
|
#endif
|
||
|
#ifdef KEY_REFRESH
|
||
|
/* Document-const: KEY_REFRESH
|
||
|
* Refresh key
|
||
|
*/
|
||
|
/* Document-const: REFRESH
|
||
|
*
|
||
|
* Refresh key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_REFRESH);
|
||
|
rb_define_const(mKey, "REFRESH", INT2NUM(KEY_REFRESH));
|
||
|
#endif
|
||
|
#ifdef KEY_REPLACE
|
||
|
/* Document-const: KEY_REPLACE
|
||
|
* Replace key
|
||
|
*/
|
||
|
/* Document-const: REPLACE
|
||
|
*
|
||
|
* Replace key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_REPLACE);
|
||
|
rb_define_const(mKey, "REPLACE", INT2NUM(KEY_REPLACE));
|
||
|
#endif
|
||
|
#ifdef KEY_RESTART
|
||
|
/* Document-const: KEY_RESTART
|
||
|
* Restart key
|
||
|
*/
|
||
|
/* Document-const: RESTART
|
||
|
*
|
||
|
* Restart key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_RESTART);
|
||
|
rb_define_const(mKey, "RESTART", INT2NUM(KEY_RESTART));
|
||
|
#endif
|
||
|
#ifdef KEY_RESUME
|
||
|
/* Document-const: KEY_RESUME
|
||
|
* Resume key
|
||
|
*/
|
||
|
/* Document-const: RESUME
|
||
|
*
|
||
|
* Resume key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_RESUME);
|
||
|
rb_define_const(mKey, "RESUME", INT2NUM(KEY_RESUME));
|
||
|
#endif
|
||
|
#ifdef KEY_SAVE
|
||
|
/* Document-const: KEY_SAVE
|
||
|
* Save key
|
||
|
*/
|
||
|
/* Document-const: SAVE
|
||
|
*
|
||
|
* Save key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SAVE);
|
||
|
rb_define_const(mKey, "SAVE", INT2NUM(KEY_SAVE));
|
||
|
#endif
|
||
|
#ifdef KEY_SBEG
|
||
|
/* Document-const: KEY_SBEG
|
||
|
* Shifted beginning key
|
||
|
*/
|
||
|
/* Document-const: SBEG
|
||
|
*
|
||
|
* Shifted beginning key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SBEG);
|
||
|
rb_define_const(mKey, "SBEG", INT2NUM(KEY_SBEG));
|
||
|
#endif
|
||
|
#ifdef KEY_SCANCEL
|
||
|
/* Document-const: KEY_SCANCEL
|
||
|
* Shifted cancel key
|
||
|
*/
|
||
|
/* Document-const: SCANCEL
|
||
|
*
|
||
|
* Shifted cancel key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SCANCEL);
|
||
|
rb_define_const(mKey, "SCANCEL", INT2NUM(KEY_SCANCEL));
|
||
|
#endif
|
||
|
#ifdef KEY_SCOMMAND
|
||
|
/* Document-const: KEY_SCOMMAND
|
||
|
* Shifted command key
|
||
|
*/
|
||
|
/* Document-const: SCOMMAND
|
||
|
*
|
||
|
* Shifted command key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SCOMMAND);
|
||
|
rb_define_const(mKey, "SCOMMAND", INT2NUM(KEY_SCOMMAND));
|
||
|
#endif
|
||
|
#ifdef KEY_SCOPY
|
||
|
/* Document-const: KEY_SCOPY
|
||
|
* Shifted copy key
|
||
|
*/
|
||
|
/* Document-const: SCOPY
|
||
|
*
|
||
|
* Shifted copy key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SCOPY);
|
||
|
rb_define_const(mKey, "SCOPY", INT2NUM(KEY_SCOPY));
|
||
|
#endif
|
||
|
#ifdef KEY_SCREATE
|
||
|
/* Document-const: KEY_SCREATE
|
||
|
* Shifted create key
|
||
|
*/
|
||
|
/* Document-const: SCREATE
|
||
|
*
|
||
|
* Shifted create key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SCREATE);
|
||
|
rb_define_const(mKey, "SCREATE", INT2NUM(KEY_SCREATE));
|
||
|
#endif
|
||
|
#ifdef KEY_SDC
|
||
|
/* Document-const: KEY_SDC
|
||
|
* Shifted delete char key
|
||
|
*/
|
||
|
/* Document-const: SDC
|
||
|
*
|
||
|
* Shifted delete char key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SDC);
|
||
|
rb_define_const(mKey, "SDC", INT2NUM(KEY_SDC));
|
||
|
#endif
|
||
|
#ifdef KEY_SDL
|
||
|
/* Document-const: KEY_SDL
|
||
|
* Shifted delete line key
|
||
|
*/
|
||
|
/* Document-const: SDL
|
||
|
*
|
||
|
* Shifted delete line key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SDL);
|
||
|
rb_define_const(mKey, "SDL", INT2NUM(KEY_SDL));
|
||
|
#endif
|
||
|
#ifdef KEY_SELECT
|
||
|
/* Document-const: KEY_SELECT
|
||
|
* Select key
|
||
|
*/
|
||
|
/* Document-const: SELECT
|
||
|
*
|
||
|
* Select key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SELECT);
|
||
|
rb_define_const(mKey, "SELECT", INT2NUM(KEY_SELECT));
|
||
|
#endif
|
||
|
#ifdef KEY_SEND
|
||
|
/* Document-const: KEY_SEND
|
||
|
* Shifted end key
|
||
|
*/
|
||
|
/* Document-const: SEND
|
||
|
*
|
||
|
* Shifted end key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SEND);
|
||
|
rb_define_const(mKey, "SEND", INT2NUM(KEY_SEND));
|
||
|
#endif
|
||
|
#ifdef KEY_SEOL
|
||
|
/* Document-const: KEY_SEOL
|
||
|
* Shifted clear line key
|
||
|
*/
|
||
|
/* Document-const: SEOL
|
||
|
*
|
||
|
* Shifted clear line key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SEOL);
|
||
|
rb_define_const(mKey, "SEOL", INT2NUM(KEY_SEOL));
|
||
|
#endif
|
||
|
#ifdef KEY_SEXIT
|
||
|
/* Document-const: KEY_SEXIT
|
||
|
* Shifted exit key
|
||
|
*/
|
||
|
/* Document-const: SEXIT
|
||
|
*
|
||
|
* Shifted exit key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SEXIT);
|
||
|
rb_define_const(mKey, "SEXIT", INT2NUM(KEY_SEXIT));
|
||
|
#endif
|
||
|
#ifdef KEY_SFIND
|
||
|
/* Document-const: KEY_SFIND
|
||
|
* Shifted find key
|
||
|
*/
|
||
|
/* Document-const: SFIND
|
||
|
*
|
||
|
* Shifted find key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SFIND);
|
||
|
rb_define_const(mKey, "SFIND", INT2NUM(KEY_SFIND));
|
||
|
#endif
|
||
|
#ifdef KEY_SHELP
|
||
|
/* Document-const: KEY_SHELP
|
||
|
* Shifted help key
|
||
|
*/
|
||
|
/* Document-const: SHELP
|
||
|
*
|
||
|
* Shifted help key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SHELP);
|
||
|
rb_define_const(mKey, "SHELP", INT2NUM(KEY_SHELP));
|
||
|
#endif
|
||
|
#ifdef KEY_SHOME
|
||
|
/* Document-const: KEY_SHOME
|
||
|
* Shifted home key
|
||
|
*/
|
||
|
/* Document-const: SHOME
|
||
|
*
|
||
|
* Shifted home key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SHOME);
|
||
|
rb_define_const(mKey, "SHOME", INT2NUM(KEY_SHOME));
|
||
|
#endif
|
||
|
#ifdef KEY_SIC
|
||
|
/* Document-const: KEY_SIC
|
||
|
* Shifted input key
|
||
|
*/
|
||
|
/* Document-const: SIC
|
||
|
*
|
||
|
* Shifted input key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SIC);
|
||
|
rb_define_const(mKey, "SIC", INT2NUM(KEY_SIC));
|
||
|
#endif
|
||
|
#ifdef KEY_SLEFT
|
||
|
/* Document-const: KEY_SLEFT
|
||
|
* Shifted left arrow key
|
||
|
*/
|
||
|
/* Document-const: SLEFT
|
||
|
*
|
||
|
* Shifted left arrow key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SLEFT);
|
||
|
rb_define_const(mKey, "SLEFT", INT2NUM(KEY_SLEFT));
|
||
|
#endif
|
||
|
#ifdef KEY_SMESSAGE
|
||
|
/* Document-const: KEY_SMESSAGE
|
||
|
* Shifted message key
|
||
|
*/
|
||
|
/* Document-const: SMESSAGE
|
||
|
*
|
||
|
* Shifted message key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SMESSAGE);
|
||
|
rb_define_const(mKey, "SMESSAGE", INT2NUM(KEY_SMESSAGE));
|
||
|
#endif
|
||
|
#ifdef KEY_SMOVE
|
||
|
/* Document-const: KEY_SMOVE
|
||
|
* Shifted move key
|
||
|
*/
|
||
|
/* Document-const: SMOVE
|
||
|
*
|
||
|
* Shifted move key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SMOVE);
|
||
|
rb_define_const(mKey, "SMOVE", INT2NUM(KEY_SMOVE));
|
||
|
#endif
|
||
|
#ifdef KEY_SNEXT
|
||
|
/* Document-const: KEY_SNEXT
|
||
|
* Shifted next key
|
||
|
*/
|
||
|
/* Document-const: SNEXT
|
||
|
*
|
||
|
* Shifted next key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SNEXT);
|
||
|
rb_define_const(mKey, "SNEXT", INT2NUM(KEY_SNEXT));
|
||
|
#endif
|
||
|
#ifdef KEY_SOPTIONS
|
||
|
/* Document-const: KEY_SOPTIONS
|
||
|
* Shifted options key
|
||
|
*/
|
||
|
/* Document-const: SOPTIONS
|
||
|
*
|
||
|
* Shifted options key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SOPTIONS);
|
||
|
rb_define_const(mKey, "SOPTIONS", INT2NUM(KEY_SOPTIONS));
|
||
|
#endif
|
||
|
#ifdef KEY_SPREVIOUS
|
||
|
/* Document-const: KEY_SPREVIOUS
|
||
|
* Shifted previous key
|
||
|
*/
|
||
|
/* Document-const: SPREVIOUS
|
||
|
*
|
||
|
* Shifted previous key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SPREVIOUS);
|
||
|
rb_define_const(mKey, "SPREVIOUS", INT2NUM(KEY_SPREVIOUS));
|
||
|
#endif
|
||
|
#ifdef KEY_SPRINT
|
||
|
/* Document-const: KEY_SPRINT
|
||
|
* Shifted print key
|
||
|
*/
|
||
|
/* Document-const: SPRINT
|
||
|
*
|
||
|
* Shifted print key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SPRINT);
|
||
|
rb_define_const(mKey, "SPRINT", INT2NUM(KEY_SPRINT));
|
||
|
#endif
|
||
|
#ifdef KEY_SREDO
|
||
|
/* Document-const: KEY_SREDO
|
||
|
* Shifted redo key
|
||
|
*/
|
||
|
/* Document-const: SREDO
|
||
|
*
|
||
|
* Shifted redo key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SREDO);
|
||
|
rb_define_const(mKey, "SREDO", INT2NUM(KEY_SREDO));
|
||
|
#endif
|
||
|
#ifdef KEY_SREPLACE
|
||
|
/* Document-const: KEY_SREPLACE
|
||
|
* Shifted replace key
|
||
|
*/
|
||
|
/* Document-const: SREPLACE
|
||
|
*
|
||
|
* Shifted replace key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SREPLACE);
|
||
|
rb_define_const(mKey, "SREPLACE", INT2NUM(KEY_SREPLACE));
|
||
|
#endif
|
||
|
#ifdef KEY_SRIGHT
|
||
|
/* Document-const: KEY_SRIGHT
|
||
|
* Shifted right arrow key
|
||
|
*/
|
||
|
/* Document-const: SRIGHT
|
||
|
*
|
||
|
* Shifted right arrow key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SRIGHT);
|
||
|
rb_define_const(mKey, "SRIGHT", INT2NUM(KEY_SRIGHT));
|
||
|
#endif
|
||
|
#ifdef KEY_SRSUME
|
||
|
/* Document-const: KEY_SRSUME
|
||
|
* Shifted resume key
|
||
|
*/
|
||
|
/* Document-const: SRSUME
|
||
|
*
|
||
|
* Shifted resume key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SRSUME);
|
||
|
rb_define_const(mKey, "SRSUME", INT2NUM(KEY_SRSUME));
|
||
|
#endif
|
||
|
#ifdef KEY_SSAVE
|
||
|
/* Document-const: KEY_SSAVE
|
||
|
* Shifted save key
|
||
|
*/
|
||
|
/* Document-const: SSAVE
|
||
|
*
|
||
|
* Shifted save key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SSAVE);
|
||
|
rb_define_const(mKey, "SSAVE", INT2NUM(KEY_SSAVE));
|
||
|
#endif
|
||
|
#ifdef KEY_SSUSPEND
|
||
|
/* Document-const: KEY_SSUSPEND
|
||
|
* Shifted suspend key
|
||
|
*/
|
||
|
/* Document-const: SSUSPEND
|
||
|
*
|
||
|
* Shifted suspend key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SSUSPEND);
|
||
|
rb_define_const(mKey, "SSUSPEND", INT2NUM(KEY_SSUSPEND));
|
||
|
#endif
|
||
|
#ifdef KEY_SUNDO
|
||
|
/* Document-const: KEY_SUNDO
|
||
|
* Shifted undo key
|
||
|
*/
|
||
|
/* Document-const: SUNDO
|
||
|
*
|
||
|
* Shifted undo key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SUNDO);
|
||
|
rb_define_const(mKey, "SUNDO", INT2NUM(KEY_SUNDO));
|
||
|
#endif
|
||
|
#ifdef KEY_SUSPEND
|
||
|
/* Document-const: KEY_SUSPEND
|
||
|
* Suspend key
|
||
|
*/
|
||
|
/* Document-const: SUSPEND
|
||
|
*
|
||
|
* Suspend key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_SUSPEND);
|
||
|
rb_define_const(mKey, "SUSPEND", INT2NUM(KEY_SUSPEND));
|
||
|
#endif
|
||
|
#ifdef KEY_UNDO
|
||
|
/* Document-const: KEY_UNDO
|
||
|
* Undo key
|
||
|
*/
|
||
|
/* Document-const: UNDO
|
||
|
*
|
||
|
* Undo key
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_UNDO);
|
||
|
rb_define_const(mKey, "UNDO", INT2NUM(KEY_UNDO));
|
||
|
#endif
|
||
|
#ifdef KEY_RESIZE
|
||
|
/* Document-const: KEY_RESIZE
|
||
|
* Screen Resized
|
||
|
*/
|
||
|
/* Document-const: RESIZE
|
||
|
*
|
||
|
* Screen Resized
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_RESIZE);
|
||
|
rb_define_const(mKey, "RESIZE", INT2NUM(KEY_RESIZE));
|
||
|
#endif
|
||
|
#ifdef KEY_MAX
|
||
|
/* Document-const: KEY_MAX
|
||
|
* The maximum allowed curses key value.
|
||
|
*/
|
||
|
/* Document-const: MAX
|
||
|
*
|
||
|
* The maximum allowed curses key value.
|
||
|
*/
|
||
|
rb_curses_define_const(KEY_MAX);
|
||
- « Previous
- 1
- 2
- Next »