Return to slk.c CVS log

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

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

1.1     ! root        1: #include <curses.h>
        !             2: #include <stddef.h>
        !             3: #include <stdlib.h>
        !             4: #include <string.h>
        !             5: #include <assert.h>
        !             6: #include "mucurses.h"
        !             7: #include "cursor.h"
        !             8: 
        !             9: /** @file
        !            10:  *
        !            11:  * Soft label key functions
        !            12:  */
        !            13: 
        !            14: #define MIN_SPACE_SIZE 2
        !            15: 
        !            16: #define SLK_MAX_LABEL_LEN 8
        !            17: 
        !            18: #define SLK_MAX_NUM_LABELS 12
        !            19: 
        !            20: #define SLK_MAX_NUM_SPACES 2
        !            21: 
        !            22: struct _softlabel {
        !            23:        // label string
        !            24:        char label[SLK_MAX_LABEL_LEN];
        !            25:        /* Format of soft label 
        !            26:           0: left justify
        !            27:           1: centre justify
        !            28:           2: right justify
        !            29:         */
        !            30:        unsigned int fmt;
        !            31: };
        !            32: 
        !            33: struct _softlabelkeys {
        !            34:        struct _softlabel fkeys[SLK_MAX_NUM_LABELS];
        !            35:        attr_t attrs;
        !            36:        /* Soft label layout format
        !            37:           0: 3-2-3
        !            38:           1: 4-4
        !            39:           2: 4-4-4
        !            40:           3: 4-4-4 with index line
        !            41:        */
        !            42:        unsigned int fmt;
        !            43:        unsigned int max_label_len;
        !            44:        unsigned int maj_space_len;
        !            45:        unsigned int num_labels;
        !            46:        unsigned int num_spaces;
        !            47:        unsigned int spaces[SLK_MAX_NUM_SPACES];
        !            48:        struct cursor_pos saved_cursor;
        !            49:        attr_t saved_attrs;
        !            50:        short saved_pair;
        !            51: };
        !            52: 
        !            53: static struct _softlabelkeys *slks;
        !            54: 
        !            55: /*
        !            56:   I either need to break the primitives here, or write a collection of
        !            57:   functions specifically for SLKs that directly access the screen
        !            58:   functions - since this technically isn't part of stdscr, I think
        !            59:   this should be ok...
        !            60:  */
        !            61: 
        !            62: static void _enter_slk ( void ) {
        !            63:        _store_curs_pos ( stdscr, &slks->saved_cursor );
        !            64:        wattr_get ( stdscr, &slks->saved_attrs, &slks->saved_pair, NULL );
        !            65:        LINES++;
        !            66:        wmove ( stdscr, LINES, 0 );
        !            67:        wattrset ( stdscr, slks->attrs );
        !            68: }
        !            69: 
        !            70: static void _leave_slk ( void ) {
        !            71:        LINES--;
        !            72:        wattr_set ( stdscr, slks->saved_attrs, slks->saved_pair, NULL );
        !            73:        _restore_curs_pos ( stdscr, &slks->saved_cursor );
        !            74: }
        !            75: 
        !            76: static void _print_label ( struct _softlabel sl ) {
        !            77:        int space_ch;
        !            78:        char str[SLK_MAX_LABEL_LEN + 1];
        !            79: 
        !            80:        assert ( slks->max_label_len <= SLK_MAX_LABEL_LEN );
        !            81:        space_ch = ' ';
        !            82: 
        !            83:        // protect against gaps in the soft label keys array
        !            84:        if ( sl.label == NULL ) {
        !            85:                memset( str, space_ch, (size_t)(slks->max_label_len) );
        !            86:        } else {
        !            87:                /* we need to pad the label with varying amounts of leading
        !            88:                   pad depending on the format of the label */
        !            89:                if ( sl.fmt == 1 ) {
        !            90:                        memset( str, space_ch, 
        !            91:                                (size_t)(slks->max_label_len 
        !            92:                                         - strlen(sl.label)) / 2 );
        !            93:                }
        !            94:                if ( sl.fmt == 2 ) {
        !            95:                        memset( str, space_ch,
        !            96:                                (size_t)(slks->max_label_len 
        !            97:                                         - strlen(sl.label)) );
        !            98:                }
        !            99:                strcat(str,sl.label);
        !           100:                
        !           101:                // post-padding
        !           102:                memset(str+strlen(str), space_ch,
        !           103:                       (size_t)(slks->max_label_len - strlen(str)) );
        !           104:        }
        !           105: 
        !           106:        // print the formatted label
        !           107:        _wputstr ( stdscr, str, NOWRAP, slks->max_label_len );
        !           108: }
        !           109: 
        !           110: /**
        !           111:  * Return the attribute used for the soft function keys
        !           112:  *
        !           113:  * @ret attrs  the current attributes of the soft function keys
        !           114:  */
        !           115: attr_t slk_attr ( void ) {
        !           116:        return ( slks == NULL ? 0 : slks->attrs );
        !           117: }
        !           118: 
        !           119: /**
        !           120:  * Turn off soft function key attributes
        !           121:  *
        !           122:  * @v attrs    attribute bit mask
        !           123:  * @ret rc     return status code
        !           124:  */
        !           125: int slk_attroff ( const chtype attrs ) {
        !           126:        if ( slks == NULL ) 
        !           127:                return ERR;
        !           128:        slks->attrs &= ~( attrs & A_ATTRIBUTES );
        !           129:        return OK;
        !           130: }
        !           131: 
        !           132: /**
        !           133:  * Turn on soft function key attributes
        !           134:  *
        !           135:  * @v attrs    attribute bit mask
        !           136:  * @ret rc     return status code
        !           137:  */
        !           138: int slk_attron ( const chtype attrs ) {
        !           139:        if ( slks == NULL )
        !           140:                return ERR;
        !           141:        slks->attrs |= ( attrs & A_ATTRIBUTES );
        !           142:        return OK;
        !           143: }
        !           144: 
        !           145: /**
        !           146:  * Set soft function key attributes
        !           147:  *
        !           148:  * @v attrs    attribute bit mask
        !           149:  * @ret rc     return status code
        !           150:  */
        !           151: int slk_attrset ( const chtype attrs ) {
        !           152:        if ( slks == NULL ) 
        !           153:                return ERR;
        !           154:        slks->attrs = ( attrs & A_ATTRIBUTES );
        !           155:        return OK;
        !           156: }
        !           157: 
        !           158: /**
        !           159:  * Turn off soft function key attributes
        !           160:  *
        !           161:  * @v attrs    attribute bit mask
        !           162:  * @v *opts    undefined (for future implementation)
        !           163:  * @ret rc     return status code
        !           164:  */
        !           165: int slk_attr_off ( const attr_t attrs, void *opts __unused ) {
        !           166:        return slk_attroff( attrs );
        !           167: }
        !           168: 
        !           169: /**
        !           170:  * Turn on soft function key attributes
        !           171:  *
        !           172:  * @v attrs    attribute bit mask
        !           173:  * @v *opts    undefined (for future implementation)
        !           174:  * @ret rc     return status code
        !           175:  */
        !           176: int slk_attr_on ( attr_t attrs, void *opts __unused ) {
        !           177:        return slk_attron( attrs );
        !           178: }
        !           179: 
        !           180: /**
        !           181:  * Set soft function key attributes
        !           182:  *
        !           183:  * @v attrs                    attribute bit mask
        !           184:  * @v colour_pair_number       colour pair integer
        !           185:  * @v *opts                    undefined (for future implementation)
        !           186:  * @ret rc                     return status code
        !           187:  */
        !           188: int slk_attr_set ( const attr_t attrs, short colour_pair_number,
        !           189:                   void *opts __unused ) {
        !           190:        if ( slks == NULL ) 
        !           191:                return ERR;
        !           192: 
        !           193:        if ( ( unsigned short )colour_pair_number > COLORS )
        !           194:                return ERR;
        !           195: 
        !           196:        slks->attrs = ( (unsigned short)colour_pair_number << CPAIR_SHIFT ) |
        !           197:                ( attrs & A_ATTRIBUTES );
        !           198:        return OK;
        !           199: }
        !           200: 
        !           201: /**
        !           202:  * Clear the soft function key labels from the screen
        !           203:  *
        !           204:  * @ret rc     return status code
        !           205:  */
        !           206: int slk_clear ( void ) {
        !           207:        if ( slks == NULL )
        !           208:                return ERR;
        !           209: 
        !           210:        _enter_slk();
        !           211:        wclrtoeol ( stdscr );
        !           212:        _leave_slk();
        !           213: 
        !           214:        return OK;
        !           215: }
        !           216: 
        !           217: /**
        !           218:  * Set soft label colour pair
        !           219:  */
        !           220: int slk_colour ( short colour_pair_number ) {
        !           221:        if ( slks == NULL ) 
        !           222:                return ERR;
        !           223:        if ( ( unsigned short )colour_pair_number > COLORS )
        !           224:                return ERR;
        !           225: 
        !           226:        slks->attrs = ( (unsigned short)colour_pair_number << CPAIR_SHIFT )
        !           227:                | ( slks->attrs & A_ATTRIBUTES );
        !           228: 
        !           229:        return OK;
        !           230: }
        !           231: 
        !           232: /**
        !           233:  * Initialise the soft function keys
        !           234:  *
        !           235:  * @v fmt      format of keys
        !           236:  * @ret rc     return status code
        !           237:  */
        !           238: int slk_init ( int fmt ) {
        !           239:        unsigned short nmaj, nmin, nblocks, available_width;
        !           240: 
        !           241:        if ( (unsigned)fmt > 3 ) {
        !           242:                return ERR;
        !           243:        }
        !           244: 
        !           245:        /* There seems to be no API call to free this data structure... */
        !           246:        if ( ! slks )
        !           247:                slks = calloc(1,sizeof(*slks));
        !           248:        if ( ! slks )
        !           249:                return ERR;
        !           250: 
        !           251:        slks->attrs = A_DEFAULT;
        !           252:        slks->fmt = fmt;
        !           253:        switch(fmt) {
        !           254:        case 0:
        !           255:                nblocks = 8; nmaj = 2; nmin = 5;
        !           256:                slks->spaces[0] = 2; slks->spaces[1] = 4;
        !           257:                break;
        !           258:        case 1:
        !           259:                nblocks = 8; nmaj = 1; nmin = 6;
        !           260:                slks->spaces[0] = 3;
        !           261:                break;
        !           262:        case 2:
        !           263:                // same allocations as format 3
        !           264:        case 3:
        !           265:                nblocks = 12; nmaj = 2; nmin = 9;
        !           266:                slks->spaces[0] = 3; slks->spaces[1] = 7;
        !           267:                break;
        !           268:        default:
        !           269:                nblocks = 0; nmaj = 0; nmin = 0;
        !           270:                break;
        !           271:        }
        !           272: 
        !           273:        // determine maximum label length and major space size
        !           274:        available_width = COLS - ( ( MIN_SPACE_SIZE * nmaj ) + nmin );
        !           275:        slks->max_label_len = available_width / nblocks;
        !           276:        slks->maj_space_len = MIN_SPACE_SIZE + 
        !           277:                ( available_width % nblocks ) / nmaj;
        !           278:        slks->num_spaces = nmaj;
        !           279:        slks->num_labels = nblocks;
        !           280: 
        !           281:        // strip a line from the screen
        !           282:        LINES -= 1;
        !           283: 
        !           284:        return OK;
        !           285: }
        !           286: 
        !           287: /**
        !           288:  * Return the label for the specified soft key
        !           289:  *
        !           290:  * @v labnum   soft key identifier
        !           291:  * @ret label  return label
        !           292:  */
        !           293: char* slk_label ( int labnum ) {
        !           294:        if ( slks == NULL ) 
        !           295:                return NULL;
        !           296: 
        !           297:        return slks->fkeys[labnum].label;
        !           298: }
        !           299: 
        !           300: /**
        !           301:  * Restore soft function key labels to the screen
        !           302:  *
        !           303:  * @ret rc     return status code
        !           304:  */
        !           305: int slk_restore ( void ) {
        !           306:        unsigned int i, j, pos_x,
        !           307:                *next_space, *last_space;
        !           308:        chtype space_ch;
        !           309: 
        !           310:        if ( slks == NULL )
        !           311:                return ERR;
        !           312: 
        !           313:        pos_x = 0;
        !           314: 
        !           315:        _enter_slk();
        !           316: 
        !           317:        space_ch = (chtype)' ' | slks->attrs;
        !           318:        next_space = &(slks->spaces[0]);
        !           319:        last_space = &(slks->spaces[slks->num_spaces-1]);
        !           320: 
        !           321:        for ( i = 0; i < slks->num_labels ; i++ ) {
        !           322:                _print_label( slks->fkeys[i] );
        !           323:                pos_x += slks->max_label_len;
        !           324: 
        !           325:                if ( i == *next_space ) {
        !           326:                        for ( j = 0; j < slks->maj_space_len; j++, pos_x++ )
        !           327:                                _wputch ( stdscr, space_ch, NOWRAP );
        !           328:                        if ( next_space < last_space )
        !           329:                                next_space++;
        !           330:                } else {
        !           331:                        if ( pos_x < COLS )
        !           332:                                _wputch ( stdscr, space_ch, NOWRAP );
        !           333:                        pos_x++;
        !           334:                }
        !           335:        }
        !           336: 
        !           337:        _leave_slk();
        !           338: 
        !           339:        return OK;
        !           340: }
        !           341: 
        !           342: /**
        !           343:  * Configure specified soft key
        !           344:  *
        !           345:  * @v labnum   soft label position to configure
        !           346:  * @v *label   string to use as soft key label
        !           347:  * @v fmt      justification format of label
        !           348:  * @ret rc     return status code
        !           349:  */
        !           350: int slk_set ( int labnum, const char *label, int fmt ) {
        !           351:        if ( slks == NULL ) 
        !           352:                return ERR;
        !           353:        if ( (unsigned short)labnum >= slks->num_labels )
        !           354:                return ERR;
        !           355:        if ( (unsigned short)fmt >= 3 )
        !           356:                return ERR;
        !           357: 
        !           358:        strncpy(slks->fkeys[labnum].label, label,
        !           359:                sizeof(slks->fkeys[labnum].label));
        !           360:        slks->fkeys[labnum].fmt = fmt;
        !           361: 
        !           362:        return OK;
        !           363: }

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