Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/memgfx/src/memgc.c

    r0d62c10 rbc52b5b  
    11/*
    2  * Copyright (c) 2020 Jiri Svoboda
     2 * Copyright (c) 2021 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4848#include "../private/memgc.h"
    4949
     50static errno_t mem_gc_set_clip_rect(void *, gfx_rect_t *);
    5051static errno_t mem_gc_set_color(void *, gfx_color_t *);
    5152static errno_t mem_gc_fill_rect(void *, gfx_rect_t *);
     53static errno_t mem_gc_update(void *);
    5254static errno_t mem_gc_bitmap_create(void *, gfx_bitmap_params_t *,
    5355    gfx_bitmap_alloc_t *, void **);
    … …  
    5557static errno_t mem_gc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
    5658static errno_t mem_gc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
     59static errno_t mem_gc_cursor_get_pos(void *, gfx_coord2_t *);
     60static errno_t mem_gc_cursor_set_pos(void *, gfx_coord2_t *);
     61static errno_t mem_gc_cursor_set_visible(void *, bool);
    5762static void mem_gc_invalidate_rect(mem_gc_t *, gfx_rect_t *);
    5863
    5964gfx_context_ops_t mem_gc_ops = {
     65        .set_clip_rect = mem_gc_set_clip_rect,
    6066        .set_color = mem_gc_set_color,
    6167        .fill_rect = mem_gc_fill_rect,
     68        .update = mem_gc_update,
    6269        .bitmap_create = mem_gc_bitmap_create,
    6370        .bitmap_destroy = mem_gc_bitmap_destroy,
    6471        .bitmap_render = mem_gc_bitmap_render,
    65         .bitmap_get_alloc = mem_gc_bitmap_get_alloc
     72        .bitmap_get_alloc = mem_gc_bitmap_get_alloc,
     73        .cursor_get_pos = mem_gc_cursor_get_pos,
     74        .cursor_set_pos = mem_gc_cursor_set_pos,
     75        .cursor_set_visible = mem_gc_cursor_set_visible
    6676};
    6777
     78/** Set clipping rectangle on memory GC.
     79 *
     80 * @param arg Memory GC
     81 * @param rect Rectangle
     82 *
     83 * @return EOK on success or an error code
     84 */
     85static errno_t mem_gc_set_clip_rect(void *arg, gfx_rect_t *rect)
     86{
     87        mem_gc_t *mgc = (mem_gc_t *) arg;
     88
     89        if (rect != NULL)
     90                gfx_rect_clip(rect, &mgc->rect, &mgc->clip_rect);
     91        else
     92                mgc->clip_rect = mgc->rect;
     93
     94        return EOK;
     95}
     96
    6897/** Set color on memory GC.
    6998 *
    … …  
    79108        mem_gc_t *mgc = (mem_gc_t *) arg;
    80109        uint16_t r, g, b;
     110        uint8_t attr;
    81111
    82112        gfx_color_get_rgb_i16(color, &r, &g, &b);
    83         mgc->color = PIXEL(0, r >> 8, g >> 8, b >> 8);
     113        gfx_color_get_ega(color, &attr);
     114        mgc->color = PIXEL(attr, r >> 8, g >> 8, b >> 8);
    84115        return EOK;
    85116}
    … …  
    100131
    101132        /* Make sure we have a sorted, clipped rectangle */
    102         gfx_rect_clip(rect, &mgc->rect, &crect);
     133        gfx_rect_clip(rect, &mgc->clip_rect, &crect);
    103134
    104135        assert(mgc->rect.p0.x == 0);
    … …  
    119150}
    120151
     152/** Update memory GC.
     153 *
     154 * @param arg Memory GC
     155 *
     156 * @return EOK on success or an error code
     157 */
     158static errno_t mem_gc_update(void *arg)
     159{
     160        mem_gc_t *mgc = (mem_gc_t *) arg;
     161
     162        mgc->cb->update(mgc->cb_arg);
     163        return EOK;
     164}
     165
    121166/** Create memory GC.
    122167 *
    … …  
    125170 * @param rect Bounding rectangle
    126171 * @param alloc Allocation info
    127  * @param update_cb Function called to update a rectangle
    128  * @param cb_arg Argument to callback function
     172 * @param cb Pointer to memory GC callbacks
     173 * @param cb_arg Argument to callback functions
    129174 * @param rgc Place to store pointer to new memory GC
    130175 *
    … …  
    132177 */
    133178errno_t mem_gc_create(gfx_rect_t *rect, gfx_bitmap_alloc_t *alloc,
    134     mem_gc_update_cb_t update_cb, void *cb_arg, mem_gc_t **rgc)
     179    mem_gc_cb_t *cb, void *cb_arg, mem_gc_t **rgc)
    135180{
    136181        mem_gc_t *mgc = NULL;
    … …  
    150195        mgc->gc = gc;
    151196        mgc->rect = *rect;
     197        mgc->clip_rect = *rect;
    152198        mgc->alloc = *alloc;
    153199
    154         mgc->update = update_cb;
     200        mgc->cb = cb;
    155201        mgc->cb_arg = cb_arg;
    156202
    … …  
    190236{
    191237        mgc->rect = *rect;
     238        mgc->clip_rect = *rect;
    192239        mgc->alloc = *alloc;
    193240}
    … …  
    205252static void mem_gc_invalidate_rect(mem_gc_t *mgc, gfx_rect_t *rect)
    206253{
    207         mgc->update(mgc->cb_arg, rect);
     254        mgc->cb->invalidate(mgc->cb_arg, rect);
    208255}
    209256
    … …  
    331378        gfx_rect_t srect;
    332379        gfx_rect_t drect;
     380        gfx_rect_t crect;
    333381        gfx_coord2_t offs;
    334382        gfx_coord_t x, y;
    … …  
    352400        gfx_rect_translate(&offs, &srect, &drect);
    353401
     402        /* Clip destination rectangle */
     403        gfx_rect_clip(&drect, &mbm->mgc->clip_rect, &crect);
     404
    354405        assert(mbm->alloc.pitch == (mbm->rect.p1.x - mbm->rect.p0.x) *
    355406            (int)sizeof(uint32_t));
    … …  
    369420        } else if ((mbm->flags & bmpf_color_key) == 0) {
    370421                /* Simple copy */
    371                 for (y = drect.p0.y; y < drect.p1.y; y++) {
    372                         for (x = drect.p0.x; x < drect.p1.x; x++) {
     422                for (y = crect.p0.y; y < crect.p1.y; y++) {
     423                        for (x = crect.p0.x; x < crect.p1.x; x++) {
    373424                                pixel = pixelmap_get_pixel(&smap,
    374425                                    x - mbm->rect.p0.x - offs.x,
    … …  
    379430        } else if ((mbm->flags & bmpf_colorize) == 0) {
    380431                /* Color key */
    381                 for (y = drect.p0.y; y < drect.p1.y; y++) {
    382                         for (x = drect.p0.x; x < drect.p1.x; x++) {
     432                for (y = crect.p0.y; y < crect.p1.y; y++) {
     433                        for (x = crect.p0.x; x < crect.p1.x; x++) {
    383434                                pixel = pixelmap_get_pixel(&smap,
    384435                                    x - mbm->rect.p0.x - offs.x,
    … …  
    390441        } else {
    391442                /* Color key & colorization */
    392                 for (y = drect.p0.y; y < drect.p1.y; y++) {
    393                         for (x = drect.p0.x; x < drect.p1.x; x++) {
     443                for (y = crect.p0.y; y < crect.p1.y; y++) {
     444                        for (x = crect.p0.x; x < crect.p1.x; x++) {
    394445                                pixel = pixelmap_get_pixel(&smap,
    395446                                    x - mbm->rect.p0.x - offs.x,
    … …  
    402453        }
    403454
    404         mem_gc_invalidate_rect(mbm->mgc, &drect);
     455        mem_gc_invalidate_rect(mbm->mgc, &crect);
    405456        return EOK;
    406457}
    … …  
    419470}
    420471
     472/** Get cursor position on memory GC.
     473 *
     474 * @param arg Memory GC
     475 * @param pos Place to store position
     476 *
     477 * @return EOK on success or an error code
     478 */
     479static errno_t mem_gc_cursor_get_pos(void *arg, gfx_coord2_t *pos)
     480{
     481        mem_gc_t *mgc = (mem_gc_t *) arg;
     482
     483        if (mgc->cb->cursor_get_pos != NULL)
     484                return mgc->cb->cursor_get_pos(mgc->cb_arg, pos);
     485        else
     486                return ENOTSUP;
     487}
     488
     489/** Set cursor position on memory GC.
     490 *
     491 * @param arg Memory GC
     492 * @param pos New position
     493 *
     494 * @return EOK on success or an error code
     495 */
     496static errno_t mem_gc_cursor_set_pos(void *arg, gfx_coord2_t *pos)
     497{
     498        mem_gc_t *mgc = (mem_gc_t *) arg;
     499
     500        if (mgc->cb->cursor_set_pos != NULL)
     501                return mgc->cb->cursor_set_pos(mgc->cb_arg, pos);
     502        else
     503                return ENOTSUP;
     504}
     505
     506/** Set cursor visibility on memory GC.
     507 *
     508 * @param arg Memory GC
     509 * @param visible @c true iff cursor should be made visible
     510 *
     511 * @return EOK on success or an error code
     512 */
     513static errno_t mem_gc_cursor_set_visible(void *arg, bool visible)
     514{
     515        mem_gc_t *mgc = (mem_gc_t *) arg;
     516
     517        if (mgc->cb->cursor_set_visible != NULL)
     518                return mgc->cb->cursor_set_visible(mgc->cb_arg, visible);
     519        else
     520                return ENOTSUP;
     521}
     522
    421523/** @}
    422524 */
Note: See TracChangeset for help on using the changeset viewer.