Changeset bea947f in mainline for uspace/srv

Timestamp:

2020-05-24T17:59:02Z (5 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

b3b00b6

Parents:

ef20a91

Message:

Implement bitmap color key to allow transparent cursor background

This seems to be the simplest solution of them all. It will work
on any bit depth except 1 bit per pixel (monochrome), where we would
need to extend the bitmap with a bit mask instead.

Location:

uspace/srv/hid

Files:

• display/cursor.c (modified) (1 diff)
• display/types/display/window.h (modified) (2 diffs)
• display/window.c (modified) (7 diffs)
• rfb/main.c (modified) (3 diffs)

uspace/srv/hid/display/cursor.c

@@ -109 +109 @@
         gfx_bitmap_params_init(&bparams);
         bparams.rect = cursor->rect;
+        bparams.flags = bmpf_color_key;
+        bparams.key_color = PIXEL(0, 0, 255, 255);
 
         if (cursor->bitmap == NULL) {

uspace/srv/hid/display/types/display/window.h

@@ -42 +42 @@
 #include <gfx/context.h>
 #include <gfx/coord.h>
+#include <io/pixel.h>
 #include <io/pixelmap.h>
 
@@ -115 +116 @@
         /** Bounding rectangle */
         gfx_rect_t rect;
+        /** Bitmap flags */
+        gfx_bitmap_flags_t flags;
+        /** Key color */
+        pixel_t key_color;
 } ds_window_bitmap_t;
 

uspace/srv/hid/display/window.c

@@ -131 +131 @@
 {
         ds_window_t *wnd = (ds_window_t *) arg;
-        ds_window_bitmap_t *cbm = NULL;
+        ds_window_bitmap_t *wbm = NULL;
         errno_t rc;
 
-        cbm = calloc(1, sizeof(ds_window_bitmap_t));
-        if (cbm == NULL)
+        wbm = calloc(1, sizeof(ds_window_bitmap_t));
+        if (wbm == NULL)
                 return ENOMEM;
 
         rc = gfx_bitmap_create(ds_display_get_gc(wnd->display), params, alloc,
-            &cbm->bitmap);
+            &wbm->bitmap);
         if (rc != EOK)
                 goto error;
 
-        cbm->wnd = wnd;
-        cbm->rect = params->rect;
-        *rbm = (void *)cbm;
+        wbm->wnd = wnd;
+        wbm->rect = params->rect;
+        wbm->flags = params->flags;
+        wbm->key_color = params->key_color;
+        *rbm = (void *)wbm;
         return EOK;
 error:
-        if (cbm != NULL)
-                free(cbm);
+        if (wbm != NULL)
+                free(wbm);
         return rc;
 }
@@ -160 +162 @@
 static errno_t ds_window_bitmap_destroy(void *bm)
 {
-        ds_window_bitmap_t *cbm = (ds_window_bitmap_t *)bm;
-
-        gfx_bitmap_destroy(cbm->bitmap);
-        free(cbm);
+        ds_window_bitmap_t *wbm = (ds_window_bitmap_t *)bm;
+
+        gfx_bitmap_destroy(wbm->bitmap);
+        free(wbm);
         return EOK;
 }
@@ -177 +179 @@
     gfx_coord2_t *offs0)
 {
-        ds_window_bitmap_t *cbm = (ds_window_bitmap_t *)bm;
+        ds_window_bitmap_t *wbm = (ds_window_bitmap_t *)bm;
         gfx_coord2_t doffs;
         gfx_coord2_t offs;
@@ -192 +194 @@
         if (srect0 != NULL) {
                 /* Clip source rectangle to bitmap rectangle */
-                gfx_rect_clip(srect0, &cbm->rect, &srect);
+                gfx_rect_clip(srect0, &wbm->rect, &srect);
         } else {
                 /* Source is entire bitmap rectangle */
-                srect = cbm->rect;
+                srect = wbm->rect;
         }
 
@@ -206 +208 @@
 
         /* Transform window rectangle back to bitmap coordinate system */
-        gfx_rect_rtranslate(&offs, &cbm->wnd->rect, &swrect);
+        gfx_rect_rtranslate(&offs, &wbm->wnd->rect, &swrect);
 
         /* Clip so that transformed rectangle will be inside the window */
@@ -212 +214 @@
 
         /* Offset for rendering on screen = window pos + offs */
-        gfx_coord2_add(&cbm->wnd->dpos, &offs, &doffs);
+        gfx_coord2_add(&wbm->wnd->dpos, &offs, &doffs);
 
         /* Resulting rectangle on the screen we are drawing into */
         gfx_rect_translate(&doffs, &crect, &drect);
 
-        rc = gfx_bitmap_get_alloc(cbm->bitmap, &alloc);
+        rc = gfx_bitmap_get_alloc(wbm->bitmap, &alloc);
         if (rc != EOK)
                 return rc;
 
-        pixelmap.width = cbm->rect.p1.x - cbm->rect.p0.x;
-        pixelmap.height = cbm->rect.p1.y - cbm->rect.p0.y;
+        pixelmap.width = wbm->rect.p1.x - wbm->rect.p0.x;
+        pixelmap.height = wbm->rect.p1.y - wbm->rect.p0.y;
         pixelmap.data = alloc.pixels;
 
         /* Render a copy to the backbuffer */
-        for (y = crect.p0.y; y < crect.p1.y; y++) {
-                for (x = crect.p0.x; x < crect.p1.x; x++) {
-                        pixel = pixelmap_get_pixel(&pixelmap,
-                            x - cbm->rect.p0.x, y - cbm->rect.p0.y);
-                        pixelmap_put_pixel(&cbm->wnd->pixelmap,
-                            x + offs.x - cbm->rect.p0.x + cbm->wnd->rect.p0.x,
-                            y + offs.y - cbm->rect.p0.y + cbm->wnd->rect.p0.y,
-                            pixel);
+        if ((wbm->flags & bmpf_color_key) == 0) {
+                for (y = crect.p0.y; y < crect.p1.y; y++) {
+                        for (x = crect.p0.x; x < crect.p1.x; x++) {
+                                pixel = pixelmap_get_pixel(&pixelmap,
+                                    x - wbm->rect.p0.x, y - wbm->rect.p0.y);
+                                pixelmap_put_pixel(&wbm->wnd->pixelmap,
+                                    x + offs.x - wbm->rect.p0.x + wbm->wnd->rect.p0.x,
+                                    y + offs.y - wbm->rect.p0.y + wbm->wnd->rect.p0.y,
+                                    pixel);
+                        }
                 }
+        } else {
+                for (y = crect.p0.y; y < crect.p1.y; y++) {
+                        for (x = crect.p0.x; x < crect.p1.x; x++) {
+                                pixel = pixelmap_get_pixel(&pixelmap,
+                                    x - wbm->rect.p0.x, y - wbm->rect.p0.y);
+                                if (pixel != wbm->key_color) {
+                                        pixelmap_put_pixel(&wbm->wnd->pixelmap,
+                                            x + offs.x - wbm->rect.p0.x +
+                                            wbm->wnd->rect.p0.x,
+                                            y + offs.y - wbm->rect.p0.y +
+                                            wbm->wnd->rect.p0.y,
+                                            pixel);
+                                }
+                        }
+                }
         }
 
         /* Repaint this area of the display */
-        return ds_display_paint(cbm->wnd->display, &drect);
+        return ds_display_paint(wbm->wnd->display, &drect);
 }
 
@@ -249 +268 @@
 static errno_t ds_window_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
 {
-        ds_window_bitmap_t *cbm = (ds_window_bitmap_t *)bm;
-
-        return gfx_bitmap_get_alloc(cbm->bitmap, alloc);
+        ds_window_bitmap_t *wbm = (ds_window_bitmap_t *)bm;
+
+        return gfx_bitmap_get_alloc(wbm->bitmap, alloc);
 }
 

uspace/srv/hid/rfb/main.c

@@ -72 +72 @@
         gfx_bitmap_alloc_t alloc;
         gfx_rect_t rect;
+        gfx_bitmap_flags_t flags;
+        pixel_t key_color;
         bool myalloc;
 } rfb_bitmap_t;
@@ -199 +201 @@
         gfx_coord2_subtract(&params->rect.p1, &params->rect.p0, &dim);
         rfbbm->rect = params->rect;
+        rfbbm->flags = params->flags;
+        rfbbm->key_color = params->key_color;
 
         if (alloc == NULL) {
@@ -278 +282 @@
         pbm.data = rfbbm->alloc.pixels;
 
-        for (y = srect.p0.y; y < srect.p1.y; y++) {
-                for (x = srect.p0.x; x < srect.p1.x; x++) {
-                        color = pixelmap_get_pixel(&pbm, x, y);
-                        pixelmap_put_pixel(&rfbbm->rfb->rfb.framebuffer,
-                            x + offs.x, y + offs.y, color);
+        if ((rfbbm->flags & bmpf_color_key) == 0) {
+                for (y = srect.p0.y; y < srect.p1.y; y++) {
+                        for (x = srect.p0.x; x < srect.p1.x; x++) {
+                                color = pixelmap_get_pixel(&pbm, x, y);
+                                pixelmap_put_pixel(&rfbbm->rfb->rfb.framebuffer,
+                                    x + offs.x, y + offs.y, color);
+                        }
+                }
+        } else {
+                for (y = srect.p0.y; y < srect.p1.y; y++) {
+                        for (x = srect.p0.x; x < srect.p1.x; x++) {
+                                color = pixelmap_get_pixel(&pbm, x, y);
+                                if (color != rfbbm->key_color) {
+                                        pixelmap_put_pixel(&rfbbm->rfb->rfb.framebuffer,
+                                            x + offs.x, y + offs.y, color);
+                                }
+                        }
                 }
         }