Changeset 8565a42 in mainline for uspace/srv/hid/console


Ignore:
Timestamp:
2018-03-02T20:34:50Z (8 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a1a81f69, d5e5fd1
Parents:
3061bc1 (diff), 34e1206 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:34:50)
git-committer:
GitHub <noreply@…> (2018-03-02 20:34:50)
Message:

Remove all trailing whitespace, everywhere.

See individual commit messages for details.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/hid/console/console.c

    r3061bc1 r8565a42  
    6262        atomic_t refcnt;      /**< Connection reference count */
    6363        prodcons_t input_pc;  /**< Incoming keyboard events */
    64        
     64
    6565        /**
    6666         * Not yet sent bytes of last char event.
    … …  
    6868        char char_remains[UTF8_CHAR_BUFFER_SIZE];
    6969        size_t char_remains_len;  /**< Number of not yet sent bytes. */
    70        
     70
    7171        fibril_mutex_t mtx;  /**< Lock protecting mutable fields */
    72        
     72
    7373        size_t index;           /**< Console index */
    7474        service_id_t dsid;      /**< Service handle */
    75        
     75
    7676        sysarg_t cols;         /**< Number of columns */
    7777        sysarg_t rows;         /**< Number of rows */
    7878        console_caps_t ccaps;  /**< Console capabilities */
    79        
     79
    8080        chargrid_t *frontbuf;    /**< Front buffer */
    8181        frontbuf_handle_t fbid;  /**< Front buffer handle */
    … …  
    162162        fibril_mutex_lock(&switch_mtx);
    163163        fibril_mutex_lock(&cons->mtx);
    164        
     164
    165165        if ((active) && (cons == active_console)) {
    166166                output_update(output_sess, cons->fbid);
    167167                output_cursor_update(output_sess, cons->fbid);
    168168        }
    169        
     169
    170170        fibril_mutex_unlock(&cons->mtx);
    171171        fibril_mutex_unlock(&switch_mtx);
    … …  
    176176        fibril_mutex_lock(&switch_mtx);
    177177        fibril_mutex_lock(&cons->mtx);
    178        
     178
    179179        if ((active) && (cons == active_console))
    180180                output_cursor_update(output_sess, cons->fbid);
    181        
     181
    182182        fibril_mutex_unlock(&cons->mtx);
    183183        fibril_mutex_unlock(&switch_mtx);
    … …  
    188188        fibril_mutex_lock(&switch_mtx);
    189189        fibril_mutex_lock(&cons->mtx);
    190        
     190
    191191        if ((active) && (cons == active_console)) {
    192192                output_damage(output_sess, cons->fbid, 0, 0, cons->cols,
    … …  
    194194                output_cursor_update(output_sess, cons->fbid);
    195195        }
    196        
     196
    197197        fibril_mutex_unlock(&cons->mtx);
    198198        fibril_mutex_unlock(&switch_mtx);
    … …  
    208208                if (console_kcon())
    209209                        active = false;
    210                
     210
    211211                return;
    212212        }
    213        
     213
    214214        if (index > CONSOLE_COUNT)
    215215                return;
    216        
     216
    217217        console_t *cons = &consoles[index];
    218        
     218
    219219        fibril_mutex_lock(&switch_mtx);
    220        
     220
    221221        if (cons == active_console) {
    222222                fibril_mutex_unlock(&switch_mtx);
    223223                return;
    224224        }
    225        
     225
    226226        active_console = cons;
    227        
     227
    228228        fibril_mutex_unlock(&switch_mtx);
    229        
     229
    230230        cons_damage(cons);
    231231}
    … …  
    236236        output_claim(output_sess);
    237237        cons_damage(active_console);
    238        
     238
    239239        return EOK;
    240240}
    … …  
    244244        active = false;
    245245        output_yield(output_sess);
    246        
     246
    247247        return EOK;
    248248}
    … …  
    261261                        return ENOMEM;
    262262                }
    263                
     263
    264264                link_initialize(&event->link);
    265265                event->type = type;
    … …  
    267267                event->mods = mods;
    268268                event->c = c;
    269                
     269
    270270                prodcons_produce(&active_console->input_pc,
    271271                    &event->link);
    272272        }
    273        
     273
    274274        return EOK;
    275275}
    … …  
    295295{
    296296        sysarg_t updated = 0;
    297        
    298         fibril_mutex_lock(&cons->mtx);
    299        
     297
     298        fibril_mutex_lock(&cons->mtx);
     299
    300300        switch (ch) {
    301301        case '\n':
    … …  
    313313                updated = chargrid_putchar(cons->frontbuf, ch, true);
    314314        }
    315        
    316         fibril_mutex_unlock(&cons->mtx);
    317        
     315
     316        fibril_mutex_unlock(&cons->mtx);
     317
    318318        if (updated > 1)
    319319                cons_update(cons);
    … …  
    325325        chargrid_set_cursor_visibility(cons->frontbuf, visible);
    326326        fibril_mutex_unlock(&cons->mtx);
    327        
     327
    328328        cons_update_cursor(cons);
    329329}
    … …  
    344344        console_t *cons = srv_to_console(srv);
    345345        size_t pos = 0;
    346        
     346
    347347        /*
    348348         * Read input from keyboard and copy it to the buffer.
    … …  
    355355                        bbuf[pos] = cons->char_remains[0];
    356356                        pos++;
    357                        
     357
    358358                        /* Unshift the array. */
    359359                        for (size_t i = 1; i < cons->char_remains_len; i++)
    360360                                cons->char_remains[i - 1] = cons->char_remains[i];
    361                        
     361
    362362                        cons->char_remains_len--;
    363363                }
    364                
     364
    365365                /* Still not enough? Then get another key from the queue. */
    366366                if (pos < size) {
    367367                        link_t *link = prodcons_consume(&cons->input_pc);
    368368                        kbd_event_t *event = list_get_instance(link, kbd_event_t, link);
    369                        
     369
    370370                        /* Accept key presses of printable chars only. */
    371371                        if ((event->type == KEY_PRESS) && (event->c != 0)) {
    … …  
    374374                                cons->char_remains_len = str_size(cons->char_remains);
    375375                        }
    376                        
     376
    377377                        free(event);
    378378                }
    379379        }
    380        
     380
    381381        *nread = size;
    382382        return EOK;
    … …  
    390390        while (off < size)
    391391                cons_write_char(cons, str_decode(data, &off, size));
    392        
     392
    393393        *nwritten = size;
    394394        return EOK;
    … …  
    398398{
    399399        console_t *cons = srv_to_console(srv);
    400        
     400
    401401        cons_update(cons);
    402402}
    … …  
    405405{
    406406        console_t *cons = srv_to_console(srv);
    407        
     407
    408408        fibril_mutex_lock(&cons->mtx);
    409409        chargrid_clear(cons->frontbuf);
    410410        fibril_mutex_unlock(&cons->mtx);
    411        
     411
    412412        cons_update(cons);
    413413}
    … …  
    416416{
    417417        console_t *cons = srv_to_console(srv);
    418        
     418
    419419        fibril_mutex_lock(&cons->mtx);
    420420        chargrid_set_cursor(cons->frontbuf, col, row);
    421421        fibril_mutex_unlock(&cons->mtx);
    422        
     422
    423423        cons_update_cursor(cons);
    424424}
    … …  
    427427{
    428428        console_t *cons = srv_to_console(srv);
    429        
     429
    430430        fibril_mutex_lock(&cons->mtx);
    431431        chargrid_get_cursor(cons->frontbuf, col, row);
    432432        fibril_mutex_unlock(&cons->mtx);
    433        
     433
    434434        return EOK;
    435435}
    … …  
    438438{
    439439        console_t *cons = srv_to_console(srv);
    440        
     440
    441441        fibril_mutex_lock(&cons->mtx);
    442442        *cols = cons->cols;
    443443        *rows = cons->rows;
    444444        fibril_mutex_unlock(&cons->mtx);
    445        
     445
    446446        return EOK;
    447447}
    … …  
    450450{
    451451        console_t *cons = srv_to_console(srv);
    452        
     452
    453453        fibril_mutex_lock(&cons->mtx);
    454454        *ccaps = cons->ccaps;
    455455        fibril_mutex_unlock(&cons->mtx);
    456        
     456
    457457        return EOK;
    458458}
    … …  
    461461{
    462462        console_t *cons = srv_to_console(srv);
    463        
     463
    464464        fibril_mutex_lock(&cons->mtx);
    465465        chargrid_set_style(cons->frontbuf, style);
    … …  
    471471{
    472472        console_t *cons = srv_to_console(srv);
    473        
     473
    474474        fibril_mutex_lock(&cons->mtx);
    475475        chargrid_set_color(cons->frontbuf, bgcolor, fgcolor, attr);
    … …  
    481481{
    482482        console_t *cons = srv_to_console(srv);
    483        
     483
    484484        fibril_mutex_lock(&cons->mtx);
    485485        chargrid_set_rgb_color(cons->frontbuf, bgcolor, fgcolor);
    … …  
    490490{
    491491        console_t *cons = srv_to_console(srv);
    492        
     492
    493493        cons_set_cursor_vis(cons, visible);
    494494}
    … …  
    499499        link_t *link = prodcons_consume(&cons->input_pc);
    500500        kbd_event_t *kevent = list_get_instance(link, kbd_event_t, link);
    501        
     501
    502502        event->type = CEV_KEY;
    503503        event->ev.key = *kevent;
    504        
     504
    505505        free(kevent);
    506506        return EOK;
    … …  
    510510{
    511511        console_t *cons = NULL;
    512        
     512
    513513        for (size_t i = 0; i < CONSOLE_COUNT; i++) {
    514514                if (consoles[i].dsid == (service_id_t) IPC_GET_ARG2(*icall)) {
    … …  
    517517                }
    518518        }
    519        
     519
    520520        if (cons == NULL) {
    521521                async_answer_0(iid, ENOENT);
    522522                return;
    523523        }
    524        
     524
    525525        if (atomic_postinc(&cons->refcnt) == 0)
    526526                cons_set_cursor_vis(cons, true);
    527        
     527
    528528        con_conn(iid, icall, &cons->srvs);
    529529}
    … …  
    533533        async_sess_t *sess;
    534534        service_id_t dsid;
    535        
     535
    536536        errno_t rc = loc_service_get_id(svc, &dsid, 0);
    537537        if (rc != EOK) {
    … …  
    546546                return EIO;
    547547        }
    548        
     548
    549549        rc = input_open(sess, &input_ev_ops, NULL, &input);
    550550        if (rc != EOK) {
    … …  
    554554                return rc;
    555555        }
    556        
     556
    557557        return EOK;
    558558}
    … …  
    562562        async_sess_t *sess;
    563563        service_id_t dsid;
    564        
     564
    565565        errno_t rc = loc_service_get_id(svc, &dsid, 0);
    566566        if (rc == EOK) {
    … …  
    573573        } else
    574574                return NULL;
    575        
     575
    576576        return sess;
    577577}
    … …  
    583583        if (rc != EOK)
    584584                return false;
    585        
     585
    586586        /* Connect to output service */
    587587        output_sess = output_connect(output_svc);
    588588        if (output_sess == NULL)
    589589                return false;
    590        
     590
    591591        /* Register server */
    592592        async_set_fallback_port_handler(client_connection, NULL);
    … …  
    597597                return false;
    598598        }
    599        
     599
    600600        output_get_dimensions(output_sess, &cols, &rows);
    601601        output_set_style(output_sess, STYLE_NORMAL);
    602        
     602
    603603        console_caps_t ccaps;
    604604        output_get_caps(output_sess, &ccaps);
    605        
     605
    606606        /*
    607607         * Inititalize consoles only if there are
    … …  
    615615                        prodcons_initialize(&consoles[i].input_pc);
    616616                        consoles[i].char_remains_len = 0;
    617                        
     617
    618618                        consoles[i].cols = cols;
    619619                        consoles[i].rows = rows;
    … …  
    621621                        consoles[i].frontbuf =
    622622                            chargrid_create(cols, rows, CHARGRID_FLAG_SHARED);
    623                        
     623
    624624                        if (consoles[i].frontbuf == NULL) {
    625625                                printf("%s: Unable to allocate frontbuffer %zu\n", NAME, i);
    626626                                return false;
    627627                        }
    628                        
     628
    629629                        consoles[i].fbid = output_frontbuf_create(output_sess,
    630630                            consoles[i].frontbuf);
    … …  
    633633                                return false;
    634634                        }
    635                        
     635
    636636                        con_srvs_init(&consoles[i].srvs);
    637637                        consoles[i].srvs.ops = &con_ops;
    638638                        consoles[i].srvs.sarg = &consoles[i];
    639                        
     639
    640640                        char vc[LOC_NAME_MAXLEN + 1];
    641641                        snprintf(vc, LOC_NAME_MAXLEN, "%s/vc%zu", NAMESPACE, i);
    642                        
     642
    643643                        if (loc_service_register(vc, &consoles[i].dsid) != EOK) {
    644644                                printf("%s: Unable to register device %s\n", NAME, vc);
    … …  
    646646                        }
    647647                }
    648                
     648
    649649                input_activate(input);
    650650        }
    651        
     651
    652652        return true;
    653653}
    … …  
    664664                return -1;
    665665        }
    666        
     666
    667667        printf("%s: HelenOS Console service\n", NAME);
    668        
     668
    669669        if (!console_srv_init(argv[1], argv[2]))
    670670                return -1;
    671        
     671
    672672        printf("%s: Accepting connections\n", NAME);
    673673        task_retval(0);
    674674        async_manager();
    675        
     675
    676676        /* Never reached */
    677677        return 0;
Note: See TracChangeset for help on using the changeset viewer.