Return to get_entry.c CVS log

Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / uuinstall

Annotation of coherent/g/usr/lib/uucp/uuinstall/get_entry.c, revision 1.1

1.1     ! root        1: /* get_entry.c:        get a keystroke. Increment or decrement row/column
        !             2:  *             values as indicated by the keystroke. Also test for
        !             3:  *             <RETURN> or 's' being pressed. This will select the
        !             4:  *             current highlighted entry for processing. If an entry
        !             5:  *             is selected, the entry number within the file is returned.
        !             6:  *             A -1 is returned is no selection is made (user pressed 'q').
        !             7:  */
        !             8: 
        !             9: #include "uuinstall.h"
        !            10: 
        !            11: get_entry()
        !            12: {
        !            13:        short retflag = 0;      /* bogus, but needed for do...while loop. */
        !            14:        char arrow;
        !            15: 
        !            16:        do{
        !            17:                arrow = wgetch(selwin);         /* here's our keystroke */
        !            18: 
        !            19:                /* test for console arrow key. This will be represented
        !            20:                 * by a 3 char escape sequence. The first char is esc,
        !            21:                 * the second we don't care about. The third tells us
        !            22:                 * what arrow key was pressed. We will translate this third
        !            23:                 * character into a vi keystroke of h,j,k or l.
        !            24:                 */
        !            25: 
        !            26:                if (arrow == 27){               /* escape. indicates arrow */
        !            27:                        wgetch(selwin);         /* skip 2nd char of esc seq. */
        !            28:                        arrow = wgetch(selwin); /* this is the value we want */
        !            29: 
        !            30:                        switch(arrow){
        !            31:                                case 68:        arrow = 'h';
        !            32:                                                break;
        !            33:                                case 67:        arrow = 'l';
        !            34:                                                break;
        !            35:                                case 66:        arrow = 'j';
        !            36:                                                break;
        !            37:                                case 65:        arrow = 'k';
        !            38:                                                break;
        !            39:                        }
        !            40:                }
        !            41: 
        !            42:                switch(arrow){
        !            43:                        case 'h':       /* move left */
        !            44:                                newcol = prevcol - 15;
        !            45:                                if(newcol < 1)
        !            46:                                        newcol = 61;
        !            47:                        /* if the next entry position is empty, go back to
        !            48:                         * first position in this row.
        !            49:                         */
        !            50:                                if(' ' == mvwinch(selwin,newrow,newcol))
        !            51:                                        newcol = 1;
        !            52:                                break;
        !            53: 
        !            54: 
        !            55:                        case 'l':       /* move right */
        !            56:                                newcol = prevcol + 15;
        !            57:                                if(newcol > 61)
        !            58:                                        newcol = 1;
        !            59:                        /* if the next entry position is empty, go back to
        !            60:                         * first position in this row.
        !            61:                         */
        !            62:                                if(' ' == mvwinch(selwin,newrow,newcol))
        !            63:                                        newcol = 1;
        !            64:                                break;
        !            65: 
        !            66: 
        !            67:                        case 'j':       /* move down */
        !            68:                                newrow = prevrow +1;
        !            69:                        /* wrap to first row if we try to move down too far */
        !            70:                                if (newrow == 20)
        !            71:                                        newrow = 0;
        !            72:                        /* if next position is empty, wrap */
        !            73:                                if(' ' ==mvwinch(selwin,newrow,newcol))
        !            74:                                        newrow = 0;
        !            75:                                break;
        !            76: 
        !            77: 
        !            78:                        case 'k':       /* move up */
        !            79:                                newrow = prevrow -1;
        !            80:                        /* wrap to last row if we try to move down too far */
        !            81:                                if (newrow == -1)
        !            82:                                        newrow = 19;
        !            83:                        /* if next position is empty, wrap */
        !            84:                                if(' ' ==mvwinch(selwin,newrow,newcol))
        !            85:                                        newrow = 0;
        !            86:                                break;
        !            87: 
        !            88:                        case 'q':
        !            89:                                return(-1);
        !            90:                                /* NO REACHED */
        !            91:                        case 's':
        !            92:                        case '\n':
        !            93:                                return( ((prevrow * 5) + (prevcol/15)) );
        !            94:                                /* NOT REACHED */
        !            95:                }
        !            96: 
        !            97:        /* unhighlite previously highlighted entry (prevrow,prevcol) */
        !            98:                lite(selwin,prevrow,prevcol,0);
        !            99:                wrefresh(selwin);
        !           100: 
        !           101:        /* highlight newly indicated entry */
        !           102:                lite(selwin,newrow, newcol,1);
        !           103:                wrefresh(selwin);
        !           104: 
        !           105:        /* now set the old corrdinates to the current coordinates */
        !           106:                prevrow = newrow;
        !           107:                prevcol = newcol;
        !           108: 
        !           109:        }
        !           110:        while(!retflag);
        !           111: }

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