Changeset 8565a42 in mainline for uspace/lib/gui/grid.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/lib/gui/grid.c

    r3061bc1 r8565a42  
    5151{
    5252        grid_t *grid = (grid_t *) widget;
    53        
     53
    5454        surface_t *surface = window_claim(grid->widget.window);
    5555        if (!surface) {
    … …  
    5757                return;
    5858        }
    59        
     59
    6060        // FIXME: Replace with (accelerated) rectangle fill
    6161        for (sysarg_t y = widget->vpos; y < widget->vpos + widget->height; y++) {
    … …  
    6363                        surface_put_pixel(surface, x, y, grid->background);
    6464        }
    65        
     65
    6666        window_yield(grid->widget.window);
    6767}
    … …  
    7171        if ((col < grid->cols) && (row < grid->rows))
    7272                return grid->layout + (row * grid->cols + col);
    73        
     73
    7474        return NULL;
    7575}
    … …  
    8282                        if (cell) {
    8383                                widget_t *widget = cell->widget;
    84                                
     84
    8585                                if ((widget) && (hpos >= widget->hpos) &&
    8686                                    (vpos >= widget->vpos) &&
    … …  
    9191                }
    9292        }
    93        
     93
    9494        return NULL;
    9595}
    … …  
    104104{
    105105        grid_t *grid = (grid_t *) widget;
    106        
     106
    107107        deinit_grid(grid);
    108108        free(grid);
    … …  
    118118{
    119119        assert(run > 0);
    120        
     120
    121121        sysarg_t dim_min_part = dim_min / run;
    122122        sysarg_t dim_min_rem = dim_min % run;
    123        
     123
    124124        sysarg_t dim_max_part = dim_max / run;
    125125        sysarg_t dim_max_rem = dim_max % run;
    126        
     126
    127127        for (size_t i = 0; i < run; i++) {
    128128                sysarg_t dim_min_cur = dim_min_part;
    129129                sysarg_t dim_max_cur = dim_max_part;
    130                
     130
    131131                if (i == run - 1) {
    132132                        dim_min_cur += dim_min_rem;
    133133                        dim_max_cur += dim_max_rem;
    134134                }
    135                
     135
    136136                /*
    137137                 * We want the strongest constraint
    … …  
    140140                if (cons[i].min < dim_min_cur)
    141141                        cons[i].min = dim_min_cur;
    142                
     142
    143143                /*
    144144                 * The comparison is correct, we want
    … …  
    155155        /* Initial solution */
    156156        sysarg_t cur_sum = 0;
    157        
     157
    158158        for (size_t i = 0; i < run; i++) {
    159159                cons[i].val = cons[i].min;
    160160                cur_sum += cons[i].val;
    161161        }
    162        
     162
    163163        /* Iterative improvement */
    164164        while (cur_sum < sum) {
    … …  
    166166                if (delta == 0)
    167167                        break;
    168                
     168
    169169                cur_sum = 0;
    170                
     170
    171171                for (size_t i = 0; i < run; i++) {
    172172                        if (cons[i].val + delta < cons[i].max)
    173173                                cons[i].val += delta;
    174                        
     174
    175175                        cur_sum += cons[i].val;
    176176                }
    … …  
    182182{
    183183        grid_t *grid = (grid_t *) widget;
    184        
     184
    185185        widget_modify(widget, hpos, vpos, width, height);
    186186        paint_internal(widget);
    187        
     187
    188188        /* Compute column widths */
    189189        constraints_t *widths =
    … …  
    193193                for (size_t c = 0; c < grid->cols; c++) {
    194194                        widths[c].min = 0;
    195                        
     195
    196196                        for (size_t r = 0; r < grid->rows; r++) {
    197197                                grid_cell_t *cell = grid_cell_at(grid, c, r);
    198198                                if (!cell)
    199199                                        continue;
    200                                
     200
    201201                                widget_t *widget = cell->widget;
    202202                                if (widget)
    … …  
    205205                        }
    206206                }
    207                
     207
    208208                solve_constraints(widths, grid->cols, width);
    209209        }
    210        
     210
    211211        /* Compute row heights */
    212212        constraints_t *heights =
    … …  
    216216                for (size_t r = 0; r < grid->rows; r++) {
    217217                        heights[r].min = 0;
    218                        
     218
    219219                        for (size_t c = 0; c < grid->cols; c++) {
    220220                                grid_cell_t *cell = grid_cell_at(grid, c, r);
    221221                                if (!cell)
    222222                                        continue;
    223                                
     223
    224224                                widget_t *widget = cell->widget;
    225225                                if (widget) {
    … …  
    229229                        }
    230230                }
    231                
     231
    232232                solve_constraints(heights, grid->rows, height);
    233233        }
    234        
     234
    235235        /* Rearrange widgets */
    236236        if ((widths) && (heights)) {
    237237                sysarg_t cur_vpos = vpos;
    238                
     238
    239239                for (size_t r = 0; r < grid->rows; r++) {
    240240                        sysarg_t cur_hpos = hpos;
    241                        
     241
    242242                        for (size_t c = 0; c < grid->cols; c++) {
    243243                                grid_cell_t *cell = grid_cell_at(grid, c, r);
    244244                                if (!cell)
    245245                                        continue;
    246                                
     246
    247247                                widget_t *widget = cell->widget;
    248248                                if (widget) {
    249249                                        sysarg_t cur_width = 0;
    250250                                        sysarg_t cur_height = 0;
    251                                        
     251
    252252                                        for (size_t cd = 0; cd < cell->cols; cd++)
    253253                                                cur_width += widths[c + cd].val;
    254                                        
     254
    255255                                        for (size_t rd = 0; rd < cell->rows; rd++)
    256256                                                cur_height += heights[r + rd].val;
    257                                        
     257
    258258                                        if ((cur_width > 0) && (cur_height > 0)) {
    259259                                                sysarg_t wwidth = cur_width;
    260260                                                sysarg_t wheight = cur_height;
    261                                                
     261
    262262                                                /*
    263263                                                 * Make sure the widget is respects its
    264264                                                 * maximal constrains.
    265265                                                 */
    266                                                
     266
    267267                                                if ((widget->width_max > 0) &&
    268268                                                    (wwidth > widget->width_max))
    269269                                                        wwidth = widget->width_max;
    270                                                
     270
    271271                                                if ((widget->height_max > 0) &&
    272272                                                    (wheight > widget->height_max))
    273273                                                        wheight = widget->height_max;
    274                                                
     274
    275275                                                widget->rearrange(widget, cur_hpos, cur_vpos,
    276276                                                    wwidth, wheight);
    277277                                        }
    278                                        
    279                                        
     278
     279
    280280                                }
    281                                
     281
    282282                                cur_hpos += widths[c].val;
    283283                        }
    284                        
     284
    285285                        cur_vpos += heights[r].val;
    286286                }
    287287        }
    288        
     288
    289289        if (widths)
    290290                free(widths);
    291        
     291
    292292        if (heights)
    293293                free(heights);
    … …  
    297297{
    298298        paint_internal(widget);
    299        
     299
    300300        list_foreach(widget->children, link, widget_t, child) {
    301301                child->repaint(child);
    302302        }
    303        
     303
    304304        window_damage(widget->window);
    305305}
    … …  
    313313{
    314314        grid_t *grid = (grid_t *) widget;
    315        
     315
    316316        grid_cell_t *cell = grid_coords_at(grid, event.hpos, event.vpos);
    317317        if ((cell) && (cell->widget))
    … …  
    325325            (row + rows > grid->rows))
    326326                return false;
    327        
     327
    328328        grid_cell_t *cell = grid_cell_at(grid, col, row);
    329329        if (!cell)
    330330                return false;
    331        
     331
    332332        /*
    333333         * Check whether the cell is not occupied by an
    … …  
    336336        if ((!cell->widget) && (cell->cols > 0) && (cell->rows > 0))
    337337                return false;
    338        
     338
    339339        widget->parent = (widget_t *) grid;
    340        
     340
    341341        list_append(&widget->link, &grid->widget.children);
    342342        widget->window = grid->widget.window;
    343        
     343
    344344        /* Mark cells in layout */
    345345        for (size_t r = row; r < row + rows; r++) {
    … …  
    359359                }
    360360        }
    361        
     361
    362362        return true;
    363363}
    … …  
    368368        if ((cols == 0) || (rows == 0))
    369369                return false;
    370        
     370
    371371        grid->layout =
    372372            (grid_cell_t *) calloc(cols * rows, sizeof(grid_cell_t));
    373373        if (!grid->layout)
    374374                return false;
    375        
     375
    376376        memset(grid->layout, 0, cols * rows * sizeof(grid_cell_t));
    377        
     377
    378378        widget_init(&grid->widget, parent, data);
    379        
     379
    380380        grid->widget.destroy = grid_destroy;
    381381        grid->widget.reconfigure = grid_reconfigure;
    … …  
    384384        grid->widget.handle_keyboard_event = grid_handle_keyboard_event;
    385385        grid->widget.handle_position_event = grid_handle_position_event;
    386        
     386
    387387        grid->add = grid_add;
    388388        grid->background = background;
    389389        grid->cols = cols;
    390390        grid->rows = rows;
    391        
     391
    392392        return true;
    393393}
    … …  
    399399        if (!grid)
    400400                return NULL;
    401        
     401
    402402        if (init_grid(grid, parent, data, cols, rows, background))
    403403                return grid;
    404        
     404
    405405        free(grid);
    406406        return NULL;
Note: See TracChangeset for help on using the changeset viewer.