Changeset 8565a42 in mainline for uspace/lib/draw/font


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.

Location:
uspace/lib/draw/font
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/draw/font/bitmap_backend.c

    r3061bc1 r8565a42  
    6262{
    6363        bitmap_backend_data_t *data = (bitmap_backend_data_t *) backend_data;
    64        
     64
    6565        *font_metrics = data->font_metrics;
    66        
     66
    6767        return EOK;
    6868}
    … …  
    7878{
    7979        bitmap_backend_data_t *data = (bitmap_backend_data_t *) backend_data;
    80        
     80
    8181        if (glyph_id >= data->glyph_count)
    8282                return ENOENT;
    83        
     83
    8484        if (data->glyph_cache[glyph_id].metrics_loaded) {
    8585                *glyph_metrics = data->glyph_cache[glyph_id].metrics;
    8686                return EOK;
    8787        }
    88        
     88
    8989        glyph_metrics_t gm;
    90        
     90
    9191        errno_t rc = data->decoder->load_glyph_metrics(data->decoder_data, glyph_id,
    9292            &gm);
    9393        if (rc != EOK)
    9494                return rc;
    95        
     95
    9696        if (data->scale) {
    9797                gm.left_side_bearing = (metric_t)
    … …  
    106106                    (data->scale_ratio * gm.height + 0.5);
    107107        }
    108        
    109        
    110        
     108
     109
     110
    111111        data->glyph_cache[glyph_id].metrics = gm;
    112112        data->glyph_cache[glyph_id].metrics_loaded = true;
    … …  
    120120        if (glyph_id >= data->glyph_count)
    121121                return ENOENT;
    122        
     122
    123123        if (data->glyph_cache[glyph_id].surface != NULL) {
    124124                *result = data->glyph_cache[glyph_id].surface;
    125125                return EOK;
    126126        }
    127        
     127
    128128        surface_t *raw_surface;
    129129        errno_t rc = data->decoder->load_glyph_surface(data->decoder_data, glyph_id,
    … …  
    131131        if (rc != EOK)
    132132                return rc;
    133        
     133
    134134        sysarg_t w;
    135135        sysarg_t h;
    136136        surface_get_resolution(raw_surface, &w, &h);
    137        
     137
    138138        if (!data->scale) {
    139139                *result = raw_surface;
    140140                return EOK;
    141141        }
    142        
     142
    143143        source_t source;
    144144        source_init(&source);
    … …  
    167167
    168168        surface_destroy(raw_surface);
    169        
     169
    170170        data->glyph_cache[glyph_id].surface = scaled_surface;
    171171        *result = scaled_surface;
    … …  
    177177{
    178178        bitmap_backend_data_t *data = (bitmap_backend_data_t *) backend_data;
    179        
     179
    180180        glyph_metrics_t glyph_metrics;
    181181        errno_t rc = bb_get_glyph_metrics(backend_data, glyph_id, &glyph_metrics);
    182182        if (rc != EOK)
    183183                return rc;
    184        
     184
    185185        surface_t *glyph_surface;
    186186        rc = get_glyph_surface(data, glyph_id, &glyph_surface);
    187187        if (rc != EOK)
    188188                return rc;
    189        
     189
    190190        native_t x = ox + glyph_metrics.left_side_bearing;
    191191        native_t y = oy - glyph_metrics.ascender;
    192        
     192
    193193        transform_t transform;
    194194        transform_identity(&transform);
    … …  
    230230        if (glyph_count == 0)
    231231                return EINVAL;
    232        
     232
    233233        bitmap_backend_data_t *data = malloc(sizeof(bitmap_backend_data_t));
    234234        if (data == NULL)
    … …  
    275275                return ENOMEM;
    276276        }
    277        
     277
    278278        *out_font = font;
    279279        return EOK;

  • uspace/lib/draw/font/embedded.c

    r3061bc1 r8565a42  
    5151        if (!found)
    5252                return ENOENT;
    53        
     53
    5454        *glyph_id = glyph;
    5555        return EOK;
    … …  
    6262        if (!surface)
    6363                return ENOMEM;
    64        
     64
    6565        for (unsigned int y = 0; y < FONT_SCANLINES; ++y) {
    6666                for (unsigned int x = 0; x < FONT_WIDTH; ++x) {
    … …  
    7070                }
    7171        }
    72        
     72
    7373        *out_surface = surface;
    7474        return EOK;
    … …  
    8484        gm->ascender = FONT_ASCENDER;
    8585        gm->height = FONT_SCANLINES;
    86        
     86
    8787        return EOK;
    8888}

  • uspace/lib/draw/font/pcf.c

    r3061bc1 r8565a42  
    151151{
    152152        pcf_data_t *data = (pcf_data_t *) opaque_data;
    153        
     153
    154154        /* TODO is this correct? */
    155155        uint8_t byte1 = (chr >> 8) & 0xff;
    … …  
    160160            (byte1 - e->min_byte1) * (e->max_byte2 - e->min_byte2 + 1) +
    161161            (byte2 - e->min_byte2);
    162        
     162
    163163        aoff64_t entry_offset = data->encodings_table.offset +
    164164            (sizeof(uint32_t) + 5 * sizeof(uint16_t)) +
    165165            entry_index * sizeof(uint16_t);
    166        
     166
    167167        int rc = fseek(data->file, entry_offset, SEEK_SET);
    168168        if (rc != 0)
    169169                return errno;
    170        
     170
    171171        uint16_t glyph = 0;
    172172        size_t records_read = fread(&glyph, sizeof(uint16_t), 1, data->file);
    173173        if (records_read != 1)
    174174                return EINVAL;
    175        
     175
    176176        glyph = uint16_t_pcf2host(glyph, data->encodings_table.format);
    177        
     177
    178178        if (glyph == 0xffff)
    179179                return ENOENT;
    180        
     180
    181181        *glyph_id = glyph;
    182        
     182
    183183        return EOK;
    184184}
    … …  
    190190        int rc;
    191191        size_t records_read;
    192        
     192
    193193        if (table->format & PCF_FORMAT_COMPRESSED_METRICS) {
    194194                offset = table->offset + sizeof(uint32_t) + sizeof(uint16_t) +
    195195                    glyph_id * sizeof(pcf_compressed_metrics_t);
    196                
     196
    197197                rc = fseek(data->file, offset, SEEK_SET);
    198198                if (rc != 0)
    199199                        return errno;
    200                
     200
    201201                pcf_compressed_metrics_t compressed_metrics;
    202202                records_read = fread(&compressed_metrics,
    … …  
    204204                if (records_read != 1)
    205205                        return EINVAL;
    206                
     206
    207207                metrics->left_side_bearing =
    208208                    compressed2int(compressed_metrics.left_side_bearing);
    … …  
    220220                offset = table->offset + 2 * sizeof(uint32_t) +
    221221                    glyph_id * sizeof(pcf_default_metrics_t);
    222                
     222
    223223                rc = fseek(data->file, offset, SEEK_SET);
    224224                if (rc != 0)
    225225                        return errno;
    226        
     226
    227227                pcf_default_metrics_t uncompressed_metrics;
    228228                records_read = fread(&uncompressed_metrics,
    … …  
    230230                if (records_read != 1)
    231231                        return EINVAL;
    232                
     232
    233233                metrics->left_side_bearing =
    234234                    int16_t_pcf2host(uncompressed_metrics.left_side_bearing,
    … …  
    250250                    table->format);
    251251        }
    252        
     252
    253253        return EOK;
    254254}
    … …  
    258258{
    259259        pcf_data_t *data = (pcf_data_t *) opaque_data;
    260        
     260
    261261        pcf_default_metrics_t pcf_metrics;
    262262        memset(&pcf_metrics, 0, sizeof(pcf_default_metrics_t));
    … …  
    265265        if (rc != EOK)
    266266                return rc;
    267        
     267
    268268        aoff64_t offset = data->bitmap_table.offset + (2 * sizeof(uint32_t)) +
    269269            (glyph_id * sizeof(uint32_t));
    270        
     270
    271271        if (fseek(data->file, offset, SEEK_SET) < 0)
    272272                return errno;
    273        
     273
    274274        uint32_t bitmap_offset = 0;
    275275        size_t records_read = fread(&bitmap_offset, sizeof(uint32_t), 1,
    … …  
    279279        bitmap_offset = uint32_t_pcf2host(bitmap_offset,
    280280            data->bitmap_table.format);
    281        
     281
    282282        offset = data->bitmap_table.offset + (2 * sizeof(uint32_t)) +
    283283            (data->glyph_count * sizeof(uint32_t)) + (4 * sizeof(uint32_t))
    284284            + bitmap_offset;
    285        
     285
    286286        if (fseek(data->file, offset, SEEK_SET) < 0)
    287287                return errno;
    288        
     288
    289289        surface_coord_t width = pcf_metrics.character_width;
    290290        surface_coord_t height = pcf_metrics.character_ascent +
    … …  
    294294        size_t row_bytes = ALIGN_UP(ALIGN_UP(width, 8) / 8, row_padding_bytes);
    295295        size_t bitmap_bytes = height * row_bytes;
    296        
     296
    297297        uint8_t *bitmap = malloc(bitmap_bytes);
    298298        if (bitmap == NULL)
    299299                return ENOMEM;
    300        
     300
    301301        records_read = fread(bitmap, sizeof(uint8_t), bitmap_bytes,
    302302            data->file);
    303        
     303
    304304        surface_t *surface = surface_create(width, height, NULL, 0);
    305305        if (!surface) {
    … …  
    307307                return ENOMEM;
    308308        }
    309        
     309
    310310        for (unsigned int y = 0; y < height; ++y) {
    311311                size_t row_offset = row_bytes * y;
    … …  
    334334                }
    335335        }
    336        
     336
    337337        *out_surface = surface;
    338338        free(bitmap);
    … …  
    344344{
    345345        pcf_data_t *data = (pcf_data_t *) opaque_data;
    346        
     346
    347347        pcf_default_metrics_t pcf_metrics;
    348348        memset(&pcf_metrics, 0, sizeof(pcf_default_metrics_t));
    … …  
    351351        if (rc != EOK)
    352352                return rc;
    353        
     353
    354354        gm->left_side_bearing = pcf_metrics.left_side_bearing;
    355355        gm->width = pcf_metrics.character_width;
    … …  
    359359            pcf_metrics.character_ascent;
    360360        gm->ascender = pcf_metrics.character_ascent;
    361        
     361
    362362        return EOK;
    363363}
    … …  
    366366{
    367367        pcf_data_t *data = (pcf_data_t *) opaque_data;
    368        
     368
    369369        fclose(data->file);
    370370        free(data);
    … …  
    383383        if (rc != 0)
    384384                return errno;
    385        
     385
    386386        aoff64_t file_size = ftell(data->file);
    387        
     387
    388388        rc = fseek(data->file, 0, SEEK_SET);
    389389        if (rc != 0)
    390390                return errno;
    391        
     391
    392392        char header[4];
    393393        size_t records_read = fread(header, sizeof(char), 4, data->file);
    394394        if (records_read != 4)
    395395                return EINVAL;
    396        
     396
    397397        if (header[0] != 1 || header[1] != 'f' || header[2] != 'c' ||
    398398            header[3] != 'p')
    399399                return EINVAL;
    400        
     400
    401401        uint32_t table_count;
    402402        records_read = fread(&table_count, sizeof(uint32_t), 1,
    … …  
    404404        if (records_read != 1)
    405405                return EINVAL;
    406        
     406
    407407        table_count = uint32_t_le2host(table_count);
    408        
     408
    409409        bool found_bitmap_table = false;
    410410        bool found_metrics_table = false;
    411411        bool found_encodings_table = false;
    412412        bool found_accelerators_table = false;
    413        
     413
    414414        for (uint32_t index = 0; index < table_count; index++) {
    415415                pcf_toc_entry_t toc_entry;
    … …  
    420420                toc_entry.size = uint32_t_le2host(toc_entry.size);
    421421                toc_entry.offset = uint32_t_le2host(toc_entry.offset);
    422                
     422
    423423                if (toc_entry.offset >= file_size)
    424424                        continue;
    425                
     425
    426426                aoff64_t end = ((aoff64_t) toc_entry.offset) + ((aoff64_t) toc_entry.size);
    427427                if (end > file_size)
    428428                        continue;
    429                
     429
    430430                if (toc_entry.type == PCF_TABLE_BITMAPS) {
    431431                        if (found_bitmap_table)
    … …  
    453453                }
    454454        }
    455        
     455
    456456        if (!found_bitmap_table || !found_metrics_table ||
    457457            !found_encodings_table || !found_accelerators_table)
    458458                return EINVAL;
    459        
     459
    460460        return EOK;
    461461}
    … …  
    467467        if (rc != 0)
    468468                return errno;
    469        
     469
    470470        size_t records_read = fread(&format, sizeof(uint32_t), 1, data->file);
    471471        if (records_read != 1)
    472472                return EINVAL;
    473        
     473
    474474        format = uint32_t_le2host(format);
    475475        if (format != table->format)
    476476                return EINVAL;
    477        
     477
    478478        return EOK;
    479479}
    … …  
    484484        if (rc != EOK)
    485485                return rc;
    486        
     486
    487487        if ((data->bitmap_table.format & PCF_FORMAT_MASK) != PCF_FORMAT_DEFAULT)
    488488                return EINVAL;
    489        
     489
    490490        uint32_t glyph_count = 0;
    491491        size_t records_read = fread(&glyph_count, sizeof(uint32_t), 1,
    … …  
    504504        if (rc != EOK)
    505505                return rc;
    506        
     506
    507507        size_t records_read;
    508508        uint32_t metrics_count;
    … …  
    525525                    data->metrics_table.format);
    526526        }
    527        
     527
    528528        if (metrics_count != data->glyph_count)
    529529                return EINVAL;
    530        
     530
    531531        return EOK;
    532532}
    … …  
    537537        if (rc != EOK)
    538538                return rc;
    539        
     539
    540540        pcf_encoding_t encoding;
    541541        size_t records_read = fread(&encoding, sizeof(pcf_encoding_t), 1,
    … …  
    543543        if (records_read != 1)
    544544                return EINVAL;
    545        
     545
    546546        encoding.min_byte1 = uint16_t_pcf2host(encoding.min_byte1,
    547547            data->encodings_table.format);
    … …  
    554554        encoding.default_char = uint16_t_pcf2host(encoding.default_char,
    555555            data->encodings_table.format);
    556        
     556
    557557        data->encoding = encoding;
    558558        return EOK;
    … …  
    564564        if (rc != EOK)
    565565                return rc;
    566        
     566
    567567        pcf_accelerators_t accelerators;
    568568        size_t records_read = fread(&accelerators, sizeof(pcf_accelerators_t),
    … …  
    570570        if (records_read != 1)
    571571                return EINVAL;
    572        
     572
    573573        data->font_metrics.ascender = int32_t_pcf2host(accelerators.font_ascent,
    574574            data->accelerators_table.format);
    … …  
    576576            data->accelerators_table.format);
    577577        data->font_metrics.leading = 0;
    578        
     578
    579579        return EOK;
    580580}
    … …  
    586586        if (data == NULL)
    587587                return ENOMEM;
    588        
     588
    589589        data->file = fopen(filename, "rb");
    590590        if (data->file == NULL)
    591591                goto read_error;
    592        
     592
    593593        rc = pcf_read_toc(data);
    594594        if (rc != EOK)
    595595                goto error;
    596        
     596
    597597        rc = pcf_read_bitmap_table_header(data);
    598598        if (rc != EOK)
    599599                goto error;
    600        
     600
    601601        rc = pcf_read_metrics_table_header(data);
    602602        if (rc != EOK)
    603603                goto error;
    604        
     604
    605605        rc = pcf_read_encodings_table_header(data);
    606606        if (rc != EOK)
    607607                goto error;
    608        
     608
    609609        rc = pcf_read_accelerators_table(data);
    610610        if (rc != EOK)
    611611                goto error;
    612        
     612
    613613        rc = bitmap_font_create(&fd_pcf, data, data->glyph_count,
    614614            data->font_metrics, points, font);
    615615        if (rc != EOK)
    616616                goto error;
    617        
     617
    618618        return EOK;
    619619read_error:
Note: See TracChangeset for help on using the changeset viewer.