Return to kb.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / hci / mucurses

Annotation of qemu/roms/ipxe/src/hci/mucurses/kb.c, revision 1.1

1.1     ! root        1: #include <curses.h>
        !             2: #include <stddef.h>
        !             3: #include <unistd.h>
        !             4: #include "mucurses.h"
        !             5: 
        !             6: /** @file
        !             7:  *
        !             8:  * MuCurses keyboard input handling functions
        !             9:  */
        !            10: 
        !            11: #define INPUT_DELAY            200 // half-blocking delay timer resolution (ms)
        !            12: #define INPUT_DELAY_TIMEOUT    1000 // half-blocking delay timeout
        !            13: 
        !            14: int m_delay; /* 
        !            15:                < 0 : blocking read
        !            16:                0   : non-blocking read
        !            17:                > 0 : timed blocking read
        !            18:             */
        !            19: bool m_echo;
        !            20: bool m_cbreak;
        !            21: 
        !            22: static int _wgetc ( WINDOW *win ) {
        !            23:        int timer, c;
        !            24: 
        !            25:        if ( win == NULL )
        !            26:                return ERR;
        !            27: 
        !            28:        timer = INPUT_DELAY_TIMEOUT;
        !            29:        while ( ! win->scr->peek( win->scr ) ) {
        !            30:                if ( m_delay == 0 ) // non-blocking read
        !            31:                        return ERR;
        !            32:                if ( timer > 0 ) {  // time-limited blocking read
        !            33:                        if ( m_delay > 0 )
        !            34:                                timer -= INPUT_DELAY;
        !            35:                        mdelay( INPUT_DELAY );
        !            36:                } else { return ERR; } // non-blocking read
        !            37:        }
        !            38: 
        !            39:        c = win->scr->getc( win->scr );
        !            40: 
        !            41:        if ( m_echo && ( c >= 32 && c <= 126 ) ) // printable ASCII characters
        !            42:                _wputch( win, (chtype) ( c | win->attrs ), WRAP );
        !            43: 
        !            44:        return c;
        !            45: }
        !            46: 
        !            47: /**
        !            48:  * Pop a character from the FIFO into a window
        !            49:  *
        !            50:  * @v *win     window in which to echo input
        !            51:  * @ret c      char from input stream
        !            52:  */
        !            53: int wgetch ( WINDOW *win ) {
        !            54:        int c;
        !            55: 
        !            56:        c = _wgetc( win );
        !            57: 
        !            58:        if ( m_echo ) {
        !            59:                if ( c >= KEY_MIN ) {
        !            60:                        switch(c) {
        !            61:                        case KEY_LEFT :
        !            62:                        case KEY_BACKSPACE :
        !            63:                                _wcursback( win );
        !            64:                                wdelch( win );
        !            65:                                break;
        !            66:                        default :
        !            67:                                beep();
        !            68:                                break;
        !            69:                        }
        !            70:                } else {
        !            71:                        _wputch( win, (chtype)( c | win->attrs ), WRAP );
        !            72:                }
        !            73:        }
        !            74: 
        !            75:        return c;
        !            76: }
        !            77: 
        !            78: /**
        !            79:  * Read at most n characters from the FIFO into a window
        !            80:  *
        !            81:  * @v *win     window in which to echo input
        !            82:  * @v *str     pointer to string in which to store result
        !            83:  * @v n                maximum number of characters to read into string (inc. NUL)
        !            84:  * @ret rc     return status code
        !            85:  */
        !            86: int wgetnstr ( WINDOW *win, char *str, int n ) {
        !            87:        char *_str;
        !            88:        int c;
        !            89: 
        !            90:        if ( n == 0 ) {
        !            91:                str = '\0';
        !            92:                return OK;
        !            93:        }
        !            94: 
        !            95:        _str = str;
        !            96: 
        !            97:        while ( ( c = _wgetc( win ) ) != ERR ) {
        !            98:                /* termination enforcement - don't let us go past the
        !            99:                   end of the allocated buffer... */
        !           100:                if ( n == 0 && ( c >= 32 && c <= 126 ) ) {
        !           101:                        _wcursback( win );
        !           102:                        wdelch( win );
        !           103:                } else {
        !           104:                        if ( c >= KEY_MIN ) {
        !           105:                                switch(c) {
        !           106:                                case KEY_LEFT :
        !           107:                                case KEY_BACKSPACE :
        !           108:                                        _wcursback( win );
        !           109:                                        wdelch( win );
        !           110:                                        break;
        !           111:                                case KEY_ENTER :
        !           112:                                        *_str = '\0';
        !           113:                                        return OK;
        !           114:                                default :
        !           115:                                        beep();
        !           116:                                        break;
        !           117:                                }
        !           118:                        }
        !           119:                        if ( c >= 32 && c <= 126 ) {
        !           120:                                *(_str++) = c; n--;
        !           121:                        }
        !           122:                }
        !           123:        }
        !           124: 
        !           125:        return ERR;
        !           126: }
        !           127: 
        !           128: 
        !           129: /**
        !           130:  *
        !           131:  */
        !           132: int echo ( void ) {
        !           133:        m_echo = TRUE;
        !           134:        return OK;
        !           135: }
        !           136: 
        !           137: /**
        !           138:  *
        !           139:  */
        !           140: int noecho ( void ) {
        !           141:        m_echo = FALSE;
        !           142:        return OK;
        !           143: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.