Changeset 8565a42 in mainline for uspace/srv/hid/output/output.c


Ignore:
Timestamp:
2018-03-02T20:34:50Z (7 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/output/output.c

    r3061bc1 r8565a42  
    4444typedef struct {
    4545        link_t link;
    46        
     46
    4747        size_t size;
    4848        unsigned int flags;
    … …  
    5656{
    5757        assert(ops->get_dimensions);
    58        
     58
    5959        outdev_t *dev = (outdev_t *) malloc(sizeof(outdev_t));
    6060        if (dev == NULL)
    6161                return NULL;
    62        
     62
    6363        link_initialize(&dev->link);
    64        
     64
    6565        dev->ops = *ops;
    6666        dev->data = data;
    67        
     67
    6868        ops->get_dimensions(dev, &dev->cols, &dev->rows);
    6969        dev->backbuf = chargrid_create(dev->cols, dev->rows,
    … …  
    7373                return NULL;
    7474        }
    75        
     75
    7676        list_append(&dev->link, &outdevs);
    7777        return dev;
    … …  
    8181{
    8282        errno_t ret = EOK;
    83        
     83
    8484        list_foreach(outdevs, link, outdev_t, dev) {
    8585                assert(dev->ops.yield);
    86                
     86
    8787                errno_t rc = dev->ops.yield(dev);
    8888                if (rc != EOK)
    8989                        ret = rc;
    9090        }
    91        
     91
    9292        async_answer_0(iid, ret);
    9393}
    … …  
    9696{
    9797        errno_t ret = EOK;
    98        
     98
    9999        list_foreach(outdevs, link, outdev_t, dev) {
    100100                assert(dev->ops.claim);
    101                
     101
    102102                errno_t rc = dev->ops.claim(dev);
    103103                if (rc != EOK)
    104104                        ret = rc;
    105105        }
    106        
     106
    107107        async_answer_0(iid, ret);
    108108}
    … …  
    112112        sysarg_t cols = MAX_COLS;
    113113        sysarg_t rows = MAX_ROWS;
    114        
     114
    115115        list_foreach(outdevs, link, outdev_t, dev) {
    116116                cols = min(cols, dev->cols);
    117117                rows = min(rows, dev->rows);
    118118        }
    119        
     119
    120120        async_answer_2(iid, EOK, cols, rows);
    121121}
    … …  
    124124{
    125125        console_caps_t caps = 0;
    126        
     126
    127127        list_foreach(outdevs, link, outdev_t, dev) {
    128128                assert(dev->ops.get_caps);
    129                
     129
    130130                caps |= dev->ops.get_caps(dev);
    131131        }
    132        
     132
    133133        async_answer_1(iid, EOK, caps);
    134134}
    … …  
    143143                }
    144144        }
    145        
     145
    146146        if (frontbuf == NULL) {
    147147                async_answer_0(iid, ENOENT);
    148148                return NULL;
    149149        }
    150        
     150
    151151        return frontbuf;
    152152}
    … …  
    159159                return;
    160160        }
    161        
     161
    162162        link_initialize(&frontbuf->link);
    163        
     163
    164164        ipc_callid_t callid;
    165165        if (!async_share_out_receive(&callid, &frontbuf->size,
    … …  
    169169                return;
    170170        }
    171        
     171
    172172        errno_t rc = async_share_out_finalize(callid, &frontbuf->data);
    173173        if ((rc != EOK) || (frontbuf->data == AS_MAP_FAILED)) {
    … …  
    176176                return;
    177177        }
    178        
     178
    179179        list_append(&frontbuf->link, &frontbufs);
    180180        async_answer_1(iid, EOK, (sysarg_t) frontbuf);
    … …  
    186186        if (frontbuf == NULL)
    187187                return;
    188        
     188
    189189        list_remove(&frontbuf->link);
    190190        as_area_destroy(frontbuf->data);
    191191        free(frontbuf);
    192        
     192
    193193        async_answer_0(iid, EOK);
    194194}
    … …  
    199199        if (frontbuf == NULL)
    200200                return;
    201        
     201
    202202        chargrid_t *buf = (chargrid_t *) frontbuf->data;
    203203        bool visible = chargrid_get_cursor_visibility(buf);
    204        
     204
    205205        sysarg_t col;
    206206        sysarg_t row;
    207207        chargrid_get_cursor(buf, &col, &row);
    208        
     208
    209209        list_foreach(outdevs, link, outdev_t, dev) {
    210210                assert(dev->ops.cursor_update);
    211                
     211
    212212                sysarg_t prev_col;
    213213                sysarg_t prev_row;
    214214                chargrid_get_cursor(dev->backbuf, &prev_col, &prev_row);
    215                
     215
    216216                chargrid_set_cursor(dev->backbuf, col, row);
    217217                chargrid_set_cursor_visibility(dev->backbuf, visible);
    218                
     218
    219219                dev->ops.cursor_update(dev, prev_col, prev_row, col, row,
    220220                    visible);
    … …  
    222222
    223223        }
    224        
     224
    225225        async_answer_0(iid, EOK);
    226226}
    … …  
    233233                    (console_style_t) IPC_GET_ARG1(*icall);
    234234        }
    235        
     235
    236236        async_answer_0(iid, EOK);
    237237}
    … …  
    248248                    (console_color_attr_t) IPC_GET_ARG3(*icall);
    249249        }
    250        
     250
    251251        async_answer_0(iid, EOK);
    252252}
    … …  
    259259                dev->attrs.val.rgb.fgcolor = IPC_GET_ARG2(*icall);
    260260        }
    261        
     261
    262262        async_answer_0(iid, EOK);
    263263}
    … …  
    266266{
    267267        assert(dev->ops.char_update);
    268        
     268
    269269        sysarg_t top_row = chargrid_get_top_row(buf);
    270        
     270
    271271        if (dev->top_row == top_row)
    272272                return false;
    273        
     273
    274274        dev->top_row = top_row;
    275        
     275
    276276        for (sysarg_t y = 0; y < dev->rows; y++) {
    277277                for (sysarg_t x = 0; x < dev->cols; x++) {
    … …  
    281281                            chargrid_charfield_at(dev->backbuf, x, y);
    282282                        bool update = false;
    283                        
     283
    284284                        if (front_field->ch != back_field->ch) {
    285285                                back_field->ch = front_field->ch;
    286286                                update = true;
    287287                        }
    288                        
     288
    289289                        if (!attrs_same(front_field->attrs, back_field->attrs)) {
    290290                                back_field->attrs = front_field->attrs;
    291291                                update = true;
    292292                        }
    293                        
     293
    294294                        front_field->flags &= ~CHAR_FLAG_DIRTY;
    295                        
     295
    296296                        if (update)
    297297                                dev->ops.char_update(dev, x, y);
    298298                }
    299299        }
    300        
     300
    301301        return true;
    302302}
    … …  
    307307        if (frontbuf == NULL)
    308308                return;
    309        
     309
    310310        chargrid_t *buf = (chargrid_t *) frontbuf->data;
    311        
     311
    312312        list_foreach(outdevs, link, outdev_t, dev) {
    313313                assert(dev->ops.char_update);
    314                
     314
    315315                if (srv_update_scroll(dev, buf))
    316316                        continue;
    317                
     317
    318318                for (sysarg_t y = 0; y < dev->rows; y++) {
    319319                        for (sysarg_t x = 0; x < dev->cols; x++) {
    … …  
    323323                                    chargrid_charfield_at(dev->backbuf, x, y);
    324324                                bool update = false;
    325                                
     325
    326326                                if ((front_field->flags & CHAR_FLAG_DIRTY) ==
    327327                                    CHAR_FLAG_DIRTY) {
    … …  
    330330                                                update = true;
    331331                                        }
    332                                        
     332
    333333                                        if (!attrs_same(front_field->attrs,
    334334                                            back_field->attrs)) {
    … …  
    336336                                                update = true;
    337337                                        }
    338                                        
     338
    339339                                        front_field->flags &= ~CHAR_FLAG_DIRTY;
    340340                                }
    341                                
     341
    342342                                if (update)
    343343                                        dev->ops.char_update(dev, x, y);
    344344                        }
    345345                }
    346                
     346
    347347                dev->ops.flush(dev);
    348348        }
    349        
    350        
     349
     350
    351351        async_answer_0(iid, EOK);
    352352}
    … …  
    357357        if (frontbuf == NULL)
    358358                return;
    359        
     359
    360360        chargrid_t *buf = (chargrid_t *) frontbuf->data;
    361        
     361
    362362        list_foreach(outdevs, link, outdev_t, dev) {
    363363                assert(dev->ops.char_update);
    364                
     364
    365365                if (srv_update_scroll(dev, buf))
    366366                        continue;
    367                
     367
    368368                sysarg_t col = IPC_GET_ARG2(*icall);
    369369                sysarg_t row = IPC_GET_ARG3(*icall);
    370                
     370
    371371                sysarg_t cols = IPC_GET_ARG4(*icall);
    372372                sysarg_t rows = IPC_GET_ARG5(*icall);
    373                
     373
    374374                for (sysarg_t y = 0; y < rows; y++) {
    375375                        for (sysarg_t x = 0; x < cols; x++) {
    … …  
    378378                                charfield_t *back_field =
    379379                                    chargrid_charfield_at(dev->backbuf, col + x, row + y);
    380                                
     380
    381381                                back_field->ch = front_field->ch;
    382382                                back_field->attrs = front_field->attrs;
    … …  
    395395        /* Accept the connection */
    396396        async_answer_0(iid, EOK);
    397        
     397
    398398        while (true) {
    399399                ipc_call_t call;
    400400                ipc_callid_t callid = async_get_call(&call);
    401                
     401
    402402                if (!IPC_GET_IMETHOD(call)) {
    403403                        async_answer_0(callid, EOK);
    404404                        break;
    405405                }
    406                
     406
    407407                switch (IPC_GET_IMETHOD(call)) {
    408408                case OUTPUT_YIELD:
    … …  
    418418                        srv_get_caps(callid, &call);
    419419                        break;
    420                
     420
    421421                case OUTPUT_FRONTBUF_CREATE:
    422422                        srv_frontbuf_create(callid, &call);
    … …  
    425425                        srv_frontbuf_destroy(callid, &call);
    426426                        break;
    427                        
     427
    428428                case OUTPUT_CURSOR_UPDATE:
    429429                        srv_cursor_update(callid, &call);
    … …  
    444444                        srv_damage(callid, &call);
    445445                        break;
    446                        
     446
    447447                default:
    448448                        async_answer_0(callid, EINVAL);
    … …  
    462462                return 1;
    463463        }
    464        
     464
    465465        printf("%s: HelenOS output service\n", NAME);
    466        
     466
    467467        /* Register server */
    468468        async_set_fallback_port_handler(client_connection, NULL);
    … …  
    472472                return rc;
    473473        }
    474        
     474
    475475        service_id_t service_id;
    476476        rc = loc_service_register(argv[1], &service_id);
    … …  
    479479                return rc;
    480480        }
    481        
     481
    482482        if (!config_key_exists("console")) {
    483483                ega_init();
    484484        }
    485        
     485
    486486        chardev_init();
    487        
     487
    488488        printf("%s: Accepting connections\n", NAME);
    489489        task_retval(0);
    490490        async_manager();
    491        
     491
    492492        /* Never reached */
    493493        return 0;
Note: See TracChangeset for help on using the changeset viewer.