Changes in / [7a873f0:8596474] in mainline


Ignore:
Files:
141 added
85 deleted
35 edited

Legend:

Unmodified
Added
Removed

  • meson/part/initrd_manifest/meson.build

    r7a873f0 r8596474  
    6060if CONFIG_FB
    6161        rd_essential += [
    62                 'app/vlaunch',
    63                 'app/vterm',
     62                'app/launcher',
     63                'app/terminal',
    6464
    6565                'srv/hid/display',

  • tools/export.sh

    r7a873f0 r8596474  
    3939
    4040EXPORT_LIBS=" \
    41         uspace/lib/libmath.a \
     41        uspace/lib/c/libstartfiles.a \
    4242        uspace/lib/libclui.a \
     43        uspace/lib/libc.a \
     44        uspace/lib/libcpp.a \
    4345        uspace/lib/libdisplay.a \
    4446        uspace/lib/libgfx.a \
    45         uspace/lib/libgui.a \
     47        uspace/lib/libgfxfont.a \
     48        uspace/lib/libgfximage.a \
     49        uspace/lib/libhound.a \
    4650        uspace/lib/libipcgfx.a \
    47         uspace/lib/libdraw.a \
    48         uspace/lib/libsoftrend.a \
    49         uspace/lib/libhound.a \
     51        uspace/lib/libmath.a \
     52        uspace/lib/libmemgfx.a \
    5053        uspace/lib/libpcm.a \
    51         uspace/lib/libcpp.a \
    52         uspace/lib/libc.a \
    53         uspace/lib/c/libstartfiles.a \
     54        uspace/lib/libpixconv.a \
    5455        uspace/lib/libposix.a \
     56        uspace/lib/libriff.a \
     57        uspace/lib/libui.a \
    5558"
    5659

  • tools/xcw/bin/helenos-pkg-config

    r7a873f0 r8596474  
    11#!/bin/bash
    22#
    3 # Copyright (c) 2015 Jiri Svoboda
     3# Copyright (c) 2020 Jiri Svoboda
    44# All rights reserved.
    55#
    … …  
    4444libmath_libs="$LIB_DIR/libmath.a"
    4545
    46 libgui_cflags="-I$INCLUDE_DIR/libgui -I$INCLUDE_DIR/libdisplay -I$INCLUDE_DIR/libgfx -I$INCLUDE_DIR/libipcgfx"
    47 libgui_libs="$LIB_DIR/libgui.a $LIB_DIR/libdisplay.a $LIB_DIR/libipcgfx.a $LIB_DIR/libgfx.a"
     46libui_cflags="-I$INCLUDE_DIR/libui -I$INCLUDE_DIR/libdisplay -I$INCLUDE_DIR/libgfx -I$INCLUDE_DIR/libipcgfx"
     47libui_libs="$LIB_DIR/libui.a $LIB_DIR/libdisplay.a $LIB_DIR/libipcgfx.a $LIB_DIR/libgfx.a $LIB_DIR/libgfxfont.a $LIB_DIR/libriff.a $LIB_DIR/libmemgfx.a"
    4848
    49 libdraw_cflags="-I$INCLUDE_DIR/libdraw"
    50 libdraw_libs="$LIB_DIR/libdraw.a $LIB_DIR/libsoftrend.a"
     49libgfximage_cflags="-I$INCLUDE_DIR/libgfximage"
     50libgfximage_libs="$LIB_DIR/libgfximage.a $LIB_DIR/libpixconv.a"
    5151
    5252libhound_cflags="-I$INCLUDE_DIR/libhound"
    … …  
    7575        (.*)
    7676            case "$1" in
    77             (libgui) ;;
    78             (libdraw) ;;
     77            (libui) ;;
     78            (libgfximage) ;;
    7979            (libmath) ;;
    8080            (libhound) ;;

  • tools/xcw/demo/Makefile

    r7a873f0 r8596474  
    5050INSTALL = install
    5151TEST = helenos-test
    52 CFLAGS = -std=gnu11 -Wall `helenos-pkg-config --cflags libgui libdraw libmath` \
     52CFLAGS = -std=gnu11 -Wall `helenos-pkg-config --cflags libui libdraw libmath` \
    5353    -D_HELENOS_SOURCE
    54 LIBS = `helenos-pkg-config --libs libgui libdraw libmath`
     54LIBS = `helenos-pkg-config --libs libui libdraw libmath`
    5555PREFIX = `helenos-bld-config --install-dir`
    5656output = viewer

  • uspace/app/barber/barber.c

    r7a873f0 r8596474  
    11/*
     2 * Copyright (c) 2020 Jiri Svoboda
    23 * Copyright (c) 2014 Martin Decky
    34 * All rights reserved.
    … …  
    3334 */
    3435
     36#include <device/led_dev.h>
     37#include <errno.h>
     38#include <fibril_synch.h>
     39#include <gfximage/tga_gz.h>
     40#include <io/pixel.h>
     41#include <loc.h>
     42#include <stats.h>
    3543#include <stdbool.h>
    36 #include <errno.h>
    3744#include <stdio.h>
    3845#include <stdlib.h>
    39 #include <task.h>
    40 #include <loc.h>
    41 #include <stats.h>
    4246#include <str.h>
    43 #include <fibril_synch.h>
    44 #include <io/pixel.h>
    45 #include <device/led_dev.h>
    46 #include <window.h>
    47 #include <canvas.h>
    48 #include <draw/surface.h>
    49 #include <draw/codec.h>
     47#include <ui/ui.h>
     48#include <ui/wdecor.h>
     49#include <ui/window.h>
     50#include <ui/image.h>
    5051#include "images.h"
    5152
    … …  
    7273} led_dev_t;
    7374
    74 static char *winreg = NULL;
     75typedef struct {
     76        ui_t *ui;
     77} barber_t;
    7578
    7679static fibril_timer_t *led_timer = NULL;
    … …  
    8992
    9093static fibril_timer_t *frame_timer = NULL;
    91 static canvas_t *frame_canvas;
    92 static surface_t *frames[FRAMES];
     94static ui_image_t *frame_img;
     95static gfx_bitmap_t *frame_bmp[FRAMES];
    9396
    9497static unsigned int frame = 0;
    … …  
    98101static void frame_timer_callback(void *);
    99102
    100 static bool decode_frames(void)
    101 {
     103static void wnd_close(ui_window_t *, void *);
     104
     105static ui_window_cb_t window_cb = {
     106        .close = wnd_close
     107};
     108
     109/** Window close button was clicked.
     110 *
     111 * @param window Window
     112 * @param arg Argument (launcher)
     113 */
     114static void wnd_close(ui_window_t *window, void *arg)
     115{
     116        barber_t *barber = (barber_t *) arg;
     117
     118        ui_quit(barber->ui);
     119}
     120
     121static bool decode_frames(gfx_context_t *gc)
     122{
     123        gfx_rect_t rect;
     124        errno_t rc;
     125
    102126        for (unsigned int i = 0; i < FRAMES; i++) {
    103                 frames[i] = decode_tga_gz(images[i].addr, images[i].size, 0);
    104                 if (frames[i] == NULL) {
     127                rc = decode_tga_gz(gc, images[i].addr, images[i].size,
     128                    &frame_bmp[i], &rect);
     129                if (rc != EOK) {
    105130                        printf("Unable to decode frame %u.\n", i);
    106131                        return false;
    107132                }
     133
     134                (void) rect;
    108135        }
    109136
    110137        return true;
     138}
     139
     140static void destroy_frames(void)
     141{
     142        unsigned i;
     143
     144        for (i = 0; i < FRAMES; i++) {
     145                gfx_bitmap_destroy(frame_bmp[i]);
     146                frame_bmp[i] = NULL;
     147        }
    111148}
    112149
    … …  
    192229{
    193230        struct timespec prev;
     231        gfx_rect_t rect;
    194232        getuptime(&prev);
    195233
    … …  
    198236                frame = 0;
    199237
    200         update_canvas(frame_canvas, frames[frame]);
     238        rect.p0.x = 0;
     239        rect.p0.y = 0;
     240        rect.p1.x = FRAME_WIDTH;
     241        rect.p1.y = FRAME_HEIGHT;
     242
     243        ui_image_set_bmp(frame_img, frame_bmp[frame], &rect);
     244        (void) ui_image_paint(frame_img);
    201245
    202246        struct timespec cur;
    … …  
    255299int main(int argc, char *argv[])
    256300{
    257         const char *display_svc = DISPLAY_DEFAULT;
     301        const char *display_spec = UI_DISPLAY_DEFAULT;
     302        barber_t barber;
     303        ui_t *ui;
     304        ui_wnd_params_t params;
     305        ui_window_t *window;
     306        ui_resource_t *ui_res;
     307        gfx_rect_t rect;
     308        gfx_rect_t wrect;
     309        gfx_rect_t app_rect;
     310        gfx_context_t *gc;
     311        gfx_coord2_t off;
    258312        int i;
    259313
    … …  
    268322                        }
    269323
    270                         display_svc = argv[i++];
     324                        display_spec = argv[i++];
    271325                } else {
    272326                        printf("Invalid option '%s'.\n", argv[i]);
    … …  
    295349        }
    296350
    297         if (!decode_frames())
    298                 return 1;
    299 
    300         winreg = argv[1];
    301         window_t *main_window = window_open(display_svc, NULL,
    302             WINDOW_MAIN | WINDOW_DECORATED, "barber");
    303         if (!main_window) {
    304                 printf("Cannot open main window.\n");
    305                 return 1;
    306         }
    307 
    308         frame_canvas = create_canvas(window_root(main_window), NULL,
    309             FRAME_WIDTH, FRAME_HEIGHT, frames[frame]);
    310 
    311         if (!frame_canvas) {
    312                 window_close(main_window);
    313                 printf("Cannot create widgets.\n");
    314                 return 1;
    315         }
    316 
    317         window_resize(main_window, 0, 0, FRAME_WIDTH + 8, FRAME_HEIGHT + 28,
    318             WINDOW_PLACEMENT_RIGHT | WINDOW_PLACEMENT_BOTTOM);
    319         window_exec(main_window);
     351        rc = ui_create(display_spec, &ui);
     352        if (rc != EOK) {
     353                printf("Error creating UI on display %s.\n", display_spec);
     354                return 1;
     355        }
     356
     357        rect.p0.x = 0;
     358        rect.p0.y = 0;
     359        rect.p1.x = FRAME_WIDTH;
     360        rect.p1.y = FRAME_HEIGHT;
     361
     362        ui_wnd_params_init(&params);
     363        params.caption = "";
     364        params.placement = ui_wnd_place_bottom_right;
     365        /*
     366         * Compute window rectangle such that application area corresponds
     367         * to rect
     368         */
     369        ui_wdecor_rect_from_app(params.style, &rect, &wrect);
     370        off = wrect.p0;
     371        gfx_rect_rtranslate(&off, &wrect, &params.rect);
     372
     373        barber.ui = ui;
     374
     375        rc = ui_window_create(ui, &params, &window);
     376        if (rc != EOK) {
     377                printf("Error creating window.\n");
     378                return 1;
     379        }
     380
     381        ui_res = ui_window_get_res(window);
     382        gc = ui_window_get_gc(window);
     383        ui_window_get_app_rect(window, &app_rect);
     384        ui_window_set_cb(window, &window_cb, (void *) &barber);
     385
     386        if (!decode_frames(gc))
     387                return 1;
     388
     389        rc = ui_image_create(ui_res, frame_bmp[frame], &rect,
     390            &frame_img);
     391        if (rc != EOK) {
     392                printf("Error creating UI.\n");
     393                return 1;
     394        }
     395
     396        ui_image_set_rect(frame_img, &app_rect);
     397
     398        ui_window_add(window, ui_image_ctl(frame_img));
     399
     400        rc = ui_window_paint(window);
     401        if (rc != EOK) {
     402                printf("Error painting window.\n");
     403                return 1;
     404        }
    320405
    321406        plan_led_timer();
    322407        plan_frame_timer(0);
    323408
    324         task_retval(0);
    325         async_manager();
     409        ui_run(ui);
     410
     411        /* Unlink bitmap from image so it is not destroyed along with it */
     412        ui_image_set_bmp(frame_img, NULL, &rect);
     413
     414        ui_window_destroy(window);
     415        ui_destroy(ui);
     416
     417        destroy_frames();
    326418
    327419        return 0;

  • uspace/app/barber/meson.build

    r7a873f0 r8596474  
    2727#
    2828
    29 deps = [ 'gui', 'draw', 'compress', 'softrend', 'math' ]
     29deps = [ 'ui', 'gfximage', 'compress' ]
    3030
    3131_images = files(

  • uspace/app/gfxdemo/doc/doxygroups.h

    r7a873f0 r8596474  
    1 /** @addtogroup vdemo vdemo
    2  * @brief Demo application
     1/** @addtogroup gfxdemo gfxdemo
     2 * @brief Graphic demo
    33 * @ingroup apps
    44 */

  • uspace/app/gfxdemo/gfxdemo.c

    r7a873f0 r8596474  
    3333 */
    3434
    35 #include <canvas.h>
    3635#include <congfx/console.h>
    37 #include <draw/surface.h>
    3836#include <display.h>
    3937#include <fibril.h>
    40 #include <guigfx/canvas.h>
    4138#include <gfx/bitmap.h>
    4239#include <gfx/color.h>
    4340#include <gfx/render.h>
     41#include <gfx/font.h>
     42#include <gfx/text.h>
     43#include <gfx/typeface.h>
    4444#include <io/console.h>
    4545#include <io/pixelmap.h>
    … …  
    4848#include <str.h>
    4949#include <task.h>
    50 #include <window.h>
     50#include <ui/ui.h>
     51#include <ui/window.h>
     52#include <ui/wdecor.h>
    5153
    5254static void wnd_close_event(void *);
    … …  
    5860};
    5961
     62static void uiwnd_close_event(ui_window_t *, void *);
     63static void uiwnd_kbd_event(ui_window_t *, void *, kbd_event_t *);
     64
     65static ui_window_cb_t ui_window_cb = {
     66        .close = uiwnd_close_event,
     67        .kbd = uiwnd_kbd_event
     68};
     69
    6070static bool quit = false;
    6171
    … …  
    109119        int i, j;
    110120        errno_t rc;
     121
     122        if (quit)
     123                return EOK;
    111124
    112125        rc = clear_scr(gc, w, h);
    … …  
    265278        gfx_rect_t srect;
    266279        errno_t rc;
     280
     281        if (quit)
     282                return EOK;
    267283
    268284        rc = clear_scr(gc, w, h);
    … …  
    299315
    300316                        if (quit)
    301                                 break;
     317                                goto out;
    302318                }
    303319        }
    304320
     321out:
    305322        gfx_bitmap_destroy(bitmap);
    306323
    … …  
    324341        gfx_coord2_t offs;
    325342        errno_t rc;
     343
     344        if (quit)
     345                return EOK;
    326346
    327347        rc = clear_scr(gc, w, h);
    … …  
    366386        return rc;
    367387}
     388
    368389/** Run bitmap color key demo on a graphic context.
    369390 *
    … …  
    379400        gfx_coord2_t offs;
    380401        errno_t rc;
     402
     403        if (quit)
     404                return EOK;
    381405
    382406        rc = clear_scr(gc, w, h);
    … …  
    424448}
    425449
    426 /** Run demo loop on a graphic context.
     450/** Run text demo on a graphic context.
    427451 *
    428452 * @param gc Graphic context
    … …  
    430454 * @param h Height
    431455 */
     456static errno_t demo_text(gfx_context_t *gc, gfx_coord_t w, gfx_coord_t h)
     457{
     458        gfx_color_t *color = NULL;
     459        gfx_rect_t rect;
     460        gfx_typeface_t *tface = NULL;
     461        gfx_font_info_t *finfo;
     462        gfx_font_t *font = NULL;
     463        gfx_coord2_t pos;
     464        gfx_text_fmt_t fmt;
     465        int i;
     466        errno_t rc;
     467
     468        if (quit)
     469                return EOK;
     470
     471        rc = gfx_typeface_open(gc, "/data/font/helena.tpf", &tface);
     472        if (rc != EOK) {
     473                printf("Error opening typeface\n");
     474                goto error;
     475        }
     476
     477        finfo = gfx_typeface_first_font(tface);
     478        if (finfo == NULL) {
     479                printf("Typeface contains no font.\n");
     480                rc = ENOENT;
     481                goto error;
     482        }
     483
     484        rc = gfx_font_open(finfo, &font);
     485        if (rc != EOK) {
     486                printf("Error opening font.\n");
     487                goto error;
     488        }
     489
     490        rc = clear_scr(gc, w, h);
     491        if (rc != EOK)
     492                goto error;
     493
     494        /* Vertical bars */
     495
     496        for (i = 0; i < 20; i++) {
     497                rc = gfx_color_new_rgb_i16(0, 0x8000 * i / 20,
     498                    0x8000 * i / 20, &color);
     499                if (rc != EOK)
     500                        goto error;
     501
     502                rc = gfx_set_color(gc, color);
     503                if (rc != EOK)
     504                        goto error;
     505
     506                rect.p0.x = w * i / 20;
     507                rect.p0.y = 0;
     508                rect.p1.x = w * (i + 1) / 20;
     509                rect.p1.y = h;
     510
     511                rc = gfx_fill_rect(gc, &rect);
     512                if (rc != EOK)
     513                        goto error;
     514
     515                gfx_color_delete(color);
     516        }
     517
     518        rc = gfx_color_new_rgb_i16(0, 0, 0x8000, &color);
     519        if (rc != EOK)
     520                goto error;
     521
     522        rc = gfx_set_color(gc, color);
     523        if (rc != EOK)
     524                goto error;
     525
     526        rect.p0.x = w / 20;
     527        rect.p0.y = 2 * h / 15;
     528        rect.p1.x = w - w / 20;
     529        rect.p1.y = 5 * h / 15;
     530
     531        rc = gfx_fill_rect(gc, &rect);
     532        if (rc != EOK)
     533                goto error;
     534
     535        gfx_color_delete(color);
     536
     537        rc = gfx_color_new_rgb_i16(0xffff, 0xffff, 0xffff, &color);
     538        if (rc != EOK)
     539                goto error;
     540
     541        rc = gfx_set_color(gc, color);
     542        if (rc != EOK)
     543                goto error;
     544
     545        gfx_text_fmt_init(&fmt);
     546
     547        pos.x = rect.p0.x;
     548        pos.y = rect.p0.y;
     549        rc = gfx_puttext(font, &pos, &fmt, "Top left");
     550        if (rc != EOK) {
     551                printf("Error rendering text.\n");
     552                goto error;
     553        }
     554
     555        pos.x = (rect.p0.x + rect.p1.x - 1) / 2;
     556        pos.y = rect.p0.y;
     557        fmt.halign = gfx_halign_center;
     558        rc = gfx_puttext(font, &pos, &fmt, "Top center");
     559        if (rc != EOK)
     560                goto error;
     561
     562        pos.x = rect.p1.x - 1;
     563        pos.y = rect.p0.y;
     564        fmt.halign = gfx_halign_right;
     565        rc = gfx_puttext(font, &pos, &fmt, "Top right");
     566        if (rc != EOK)
     567                goto error;
     568
     569        fmt.valign = gfx_valign_center;
     570
     571        pos.x = rect.p0.x;
     572        pos.y = (rect.p0.y + rect.p1.y - 1) / 2;
     573        fmt.halign = gfx_halign_left;
     574        rc = gfx_puttext(font, &pos, &fmt, "Center left");
     575        if (rc != EOK)
     576                goto error;
     577
     578        pos.x = (rect.p0.x + rect.p1.x - 1) / 2;
     579        pos.y = (rect.p0.y + rect.p1.y - 1) / 2;
     580        fmt.halign = gfx_halign_center;
     581        rc = gfx_puttext(font, &pos, &fmt, "Center");
     582        if (rc != EOK)
     583                goto error;
     584
     585        pos.x = rect.p1.x - 1;
     586        pos.y = (rect.p0.y + rect.p1.y - 1) / 2;
     587        fmt.halign = gfx_halign_right;
     588        rc = gfx_puttext(font, &pos, &fmt, "Center right");
     589        if (rc != EOK)
     590                goto error;
     591
     592        fmt.valign = gfx_valign_bottom;
     593
     594        pos.x = rect.p0.x;
     595        pos.y = rect.p1.y - 1;
     596        fmt.halign = gfx_halign_left;
     597        rc = gfx_puttext(font, &pos, &fmt, "Bottom left");
     598        if (rc != EOK)
     599                goto error;
     600
     601        pos.x = (rect.p0.x + rect.p1.x - 1) / 2;
     602        pos.y = rect.p1.y - 1;
     603        fmt.halign = gfx_halign_center;
     604        rc = gfx_puttext(font, &pos, &fmt, "Bottom center");
     605        if (rc != EOK)
     606                goto error;
     607
     608        pos.x = rect.p1.x - 1;
     609        pos.y = rect.p1.y - 1;
     610        fmt.halign = gfx_halign_right;
     611        rc = gfx_puttext(font, &pos, &fmt, "Bottom right");
     612        if (rc != EOK)
     613                goto error;
     614
     615        gfx_color_delete(color);
     616
     617        gfx_text_fmt_init(&fmt);
     618
     619        for (i = 0; i < 8; i++) {
     620                rc = gfx_color_new_rgb_i16((i & 4) ? 0xffff : 0,
     621                    (i & 2) ? 0xffff : 0, (i & 1) ? 0xffff : 0, &color);
     622                if (rc != EOK)
     623                        goto error;
     624
     625                rc = gfx_set_color(gc, color);
     626                if (rc != EOK)
     627                        goto error;
     628
     629                pos.x = w / 20;
     630                pos.y = (7 + i) * h / 15;
     631                rc = gfx_puttext(font, &pos, &fmt, "The quick brown fox jumps over the lazy dog.");
     632                if (rc != EOK)
     633                        goto error;
     634
     635                gfx_color_delete(color);
     636        }
     637
     638        for (i = 0; i < 10; i++) {
     639                fibril_usleep(500 * 1000);
     640                if (quit)
     641                        break;
     642        }
     643
     644        gfx_font_close(font);
     645        gfx_typeface_destroy(tface);
     646        return EOK;
     647error:
     648        if (font != NULL)
     649                gfx_font_close(font);
     650        if (tface != NULL)
     651                gfx_typeface_destroy(tface);
     652        return rc;
     653}
     654
     655/** Run demo loop on a graphic context.
     656 *
     657 * @param gc Graphic context
     658 * @param w Width
     659 * @param h Height
     660 */
    432661static errno_t demo_loop(gfx_context_t *gc, gfx_coord_t w, gfx_coord_t h)
    433662{
    … …  
    448677
    449678                rc = demo_bitmap_kc(gc, w, h);
     679                if (rc != EOK)
     680                        return rc;
     681
     682                rc = demo_text(gc, w, h);
    450683                if (rc != EOK)
    451684                        return rc;
    … …  
    486719}
    487720
    488 /** Run demo on canvas. */
    489 static errno_t demo_canvas(const char *display_svc)
    490 {
    491         canvas_gc_t *cgc = NULL;
     721/** Run demo on UI. */
     722static errno_t demo_ui(const char *display_spec)
     723{
     724        ui_t *ui = NULL;
     725        ui_wnd_params_t params;
     726        ui_window_t *window = NULL;
    492727        gfx_context_t *gc;
    493         window_t *window = NULL;
    494         pixel_t *pixbuf = NULL;
    495         surface_t *surface = NULL;
    496         canvas_t *canvas = NULL;
    497         gfx_coord_t vw, vh;
    498         errno_t rc;
    499 
    500         printf("Init canvas..\n");
    501 
    502         window = window_open(display_svc, NULL,
    503             WINDOW_MAIN | WINDOW_DECORATED, "GFX Demo");
    504         if (window == NULL) {
     728        gfx_rect_t rect;
     729        gfx_rect_t wrect;
     730        gfx_coord2_t off;
     731        errno_t rc;
     732
     733        printf("Init UI..\n");
     734
     735        rc = ui_create(display_spec, &ui);
     736        if (rc != EOK) {
     737                printf("Error initializing UI (%s)\n", display_spec);
     738                goto error;
     739        }
     740
     741        rect.p0.x = 0;
     742        rect.p0.y = 0;
     743        rect.p1.x = 400;
     744        rect.p1.y = 300;
     745
     746        ui_wnd_params_init(&params);
     747        params.caption = "GFX Demo";
     748
     749        /*
     750         * Compute window rectangle such that application area corresponds
     751         * to rect
     752         */
     753        ui_wdecor_rect_from_app(params.style, &rect, &wrect);
     754        off = wrect.p0;
     755        gfx_rect_rtranslate(&off, &wrect, &params.rect);
     756
     757        rc = ui_window_create(ui, &params, &window);
     758        if (rc != EOK) {
    505759                printf("Error creating window.\n");
    506                 return -1;
    507         }
    508 
    509         vw = 400;
    510         vh = 300;
    511 
    512         pixbuf = calloc(vw * vh, sizeof(pixel_t));
    513         if (pixbuf == NULL) {
    514                 printf("Error allocating memory for pixel buffer.\n");
    515                 return ENOMEM;
    516         }
    517 
    518         surface = surface_create(vw, vh, pixbuf, 0);
    519         if (surface == NULL) {
    520                 printf("Error creating surface.\n");
    521                 return EIO;
    522         }
    523 
    524         canvas = create_canvas(window_root(window), NULL, vw, vh,
    525             surface);
    526         if (canvas == NULL) {
    527                 printf("Error creating canvas.\n");
    528                 return EIO;
    529         }
    530 
    531         window_resize(window, 0, 0, vw + 10, vh + 30, WINDOW_PLACEMENT_ANY);
    532         window_exec(window);
    533 
    534         printf("Create canvas GC\n");
    535         rc = canvas_gc_create(canvas, surface, &cgc);
    536         if (rc != EOK)
    537                 return rc;
    538 
    539         gc = canvas_gc_get_ctx(cgc);
     760                goto error;
     761        }
     762
     763        ui_window_set_cb(window, &ui_window_cb, NULL);
     764
     765        rc = ui_window_get_app_gc(window, &gc);
     766        if (rc != EOK) {
     767                printf("Error creating graphic context.\n");
     768                goto error;
     769        }
    540770
    541771        task_retval(0);
    542772
    543         rc = demo_loop(gc, 400, 300);
    544         if (rc != EOK)
    545                 return rc;
    546 
    547         rc = canvas_gc_delete(cgc);
    548         if (rc != EOK)
    549                 return rc;
    550 
    551         return EOK;
     773        rc = demo_loop(gc, rect.p1.x, rect.p1.y);
     774        if (rc != EOK)
     775                goto error;
     776
     777        ui_window_destroy(window);
     778        ui_destroy(ui);
     779
     780        return EOK;
     781error:
     782        if (window != NULL)
     783                ui_window_destroy(window);
     784        if (ui != NULL)
     785                ui_destroy(ui);
     786        return rc;
    552787}
    553788
    … …  
    610845
    611846static void wnd_kbd_event(void *arg, kbd_event_t *event)
     847{
     848        printf("Keyboard event type=%d key=%d\n", event->type, event->key);
     849        if (event->type == KEY_PRESS)
     850                quit = true;
     851}
     852
     853static void uiwnd_close_event(ui_window_t *window, void *arg)
     854{
     855        printf("Close event\n");
     856        quit = true;
     857}
     858
     859static void uiwnd_kbd_event(ui_window_t *window, void *arg, kbd_event_t *event)
    612860{
    613861        printf("Keyboard event type=%d key=%d\n", event->type, event->key);
    … …  
    653901                if (rc != EOK)
    654902                        return 1;
    655         } else if (str_cmp(argv[i], "canvas") == 0) {
    656                 rc = demo_canvas(display_svc);
     903        } else if (str_cmp(argv[i], "ui") == 0) {
     904                rc = demo_ui(display_svc);
    657905                if (rc != EOK)
    658906                        return 1;

  • uspace/app/gfxdemo/meson.build

    r7a873f0 r8596474  
    2727#
    2828
    29 deps = [ 'gfx', 'guigfx', 'congfx', 'ipcgfx', 'display' ]
     29deps = [ 'gfx', 'gfxfont', 'ui', 'congfx', 'ipcgfx', 'display' ]
    3030src = files(
    3131        'gfxdemo.c',

  • uspace/app/init/init.c

    r7a873f0 r8596474  
    277277}
    278278
    279 static int app_start(const char *app)
     279static int app_start(const char *app, const char *arg)
    280280{
    281281        printf("%s: Spawning %s\n", NAME, app);
    … …  
    283283        task_id_t id;
    284284        task_wait_t wait;
    285         errno_t rc = task_spawnl(&id, &wait, app, app, NULL);
     285        errno_t rc = task_spawnl(&id, &wait, app, app, arg, NULL);
    286286        if (rc != EOK) {
    287287                oom_check(rc, app);
    … …  
    471471                rc = display_server();
    472472                if (rc == EOK) {
    473                         app_start("/app/barber");
    474                         app_start("/app/vlaunch");
    475                         app_start("/app/vterm");
     473                        app_start("/app/launcher", NULL);
     474                        app_start("/app/barber", NULL);
     475                        app_start("/app/terminal", "-topleft");
    476476                }
    477477        }

  • uspace/app/meson.build

    r7a873f0 r8596474  
    3232        'bithenge',
    3333        'blkdump',
     34        'calculator',
    3435        'contacts',
    3536        'corecfg',
    … …  
    4344        'edit',
    4445        'fdisk',
    45         'fontviewer',
     46        'fontedit',
    4647        'getterm',
    4748        'gfxdemo',
    4849        'gunzip',
    4950        'hbench',
     51        'hello',
    5052        'inet',
    5153        'init',
    … …  
    5355        'killall',
    5456        'kio',
     57        'launcher',
    5558        'loc',
    5659        'logset',
    … …  
    7679        'sysinst',
    7780        'taskdump',
     81        'terminal',
    7882        'tester',
    7983        'testread',
    … …  
    8488        'top',
    8589        'trace',
     90        'uidemo',
    8691        'untar',
    8792        'usbinfo',
    88         'vcalc',
    89         'vdemo',
    9093        'viewer',
    91         'vlaunch',
    9294        'vol',
    93         'vterm',
    9495        'vuhid',
    9596        'wavplay',

  • uspace/app/viewer/meson.build

    r7a873f0 r8596474  
    2727#
    2828
    29 deps = [ 'gui' ]
     29deps = [ 'ui', 'gfximage', 'compress' ]
    3030src = files('viewer.c')
    3131

  • uspace/app/viewer/viewer.c

    r7a873f0 r8596474  
    11/*
     2 * Copyright (c) 2020 Jiri Svoboda
    23 * Copyright (c) 2013 Martin Decky
    34 * All rights reserved.
    … …  
    3334 */
    3435
     36#include <errno.h>
     37#include <gfximage/tga.h>
     38#include <stdbool.h>
    3539#include <stdio.h>
    3640#include <stdlib.h>
     41#include <str.h>
     42#include <ui/image.h>
     43#include <ui/ui.h>
     44#include <ui/wdecor.h>
     45#include <ui/window.h>
    3746#include <vfs/vfs.h>
    38 #include <errno.h>
    39 #include <stdlib.h>
    40 #include <stdbool.h>
    41 #include <window.h>
    42 #include <canvas.h>
    43 #include <draw/surface.h>
    44 #include <draw/codec.h>
    45 #include <task.h>
    46 #include <str.h>
    4747
    4848#define NAME  "viewer"
    4949
    50 #define WINDOW_WIDTH   1024
    51 #define WINDOW_HEIGHT  768
    52 
    53 #define DECORATION_WIDTH        8
    54 #define DECORATION_HEIGHT       28
     50typedef struct {
     51        ui_t *ui;
     52} viewer_t;
    5553
    5654static size_t imgs_count;
    … …  
    5856static char **imgs;
    5957
    60 static window_t *main_window;
    61 static surface_t *surface = NULL;
    62 static canvas_t *canvas = NULL;
    63 
    64 static surface_coord_t img_width;
    65 static surface_coord_t img_height;
    66 
    67 static bool img_load(const char *, surface_t **);
    68 static bool img_setup(surface_t *);
    69 
    70 static void on_keyboard_event(widget_t *widget, void *data)
    71 {
    72         kbd_event_t *event = (kbd_event_t *) data;
     58static ui_window_t *window;
     59static gfx_bitmap_t *bitmap = NULL;
     60static ui_image_t *image = NULL;
     61static gfx_context_t *window_gc;
     62
     63static gfx_rect_t img_rect;
     64
     65static bool img_load(gfx_context_t *gc, const char *, gfx_bitmap_t **,
     66    gfx_rect_t *);
     67static bool img_setup(gfx_context_t *, gfx_bitmap_t *, gfx_rect_t *);
     68
     69static void wnd_close(ui_window_t *, void *);
     70static void wnd_kbd_event(ui_window_t *, void *, kbd_event_t *);
     71
     72static ui_window_cb_t window_cb = {
     73        .close = wnd_close,
     74        .kbd = wnd_kbd_event
     75};
     76
     77/** Window close request
     78 *
     79 * @param window Window
     80 * @param arg Argument (calc_t *)
     81 */
     82static void wnd_close(ui_window_t *window, void *arg)
     83{
     84        viewer_t *viewer = (viewer_t *) arg;
     85
     86        ui_quit(viewer->ui);
     87}
     88
     89static void wnd_kbd_event(ui_window_t *window, void *arg,
     90    kbd_event_t *event)
     91{
    7392        bool update = false;
    7493
    … …  
    95114
    96115        if (update) {
    97                 surface_t *lsface;
    98 
    99                 if (!img_load(imgs[imgs_current], &lsface)) {
     116                gfx_bitmap_t *lbitmap;
     117                gfx_rect_t lrect;
     118
     119                if (!img_load(window_gc, imgs[imgs_current], &lbitmap, &lrect)) {
    100120                        printf("Cannot load image \"%s\".\n", imgs[imgs_current]);
    101121                        exit(4);
    102122                }
    103                 if (!img_setup(lsface)) {
     123                if (!img_setup(window_gc, lbitmap, &lrect)) {
    104124                        printf("Cannot setup image \"%s\".\n", imgs[imgs_current]);
    105125                        exit(6);
    … …  
    108128}
    109129
    110 static bool img_load(const char *fname, surface_t **p_local_surface)
     130static bool img_load(gfx_context_t *gc, const char *fname,
     131    gfx_bitmap_t **rbitmap, gfx_rect_t *rect)
    111132{
    112133        int fd;
    … …  
    138159        vfs_put(fd);
    139160
    140         *p_local_surface = decode_tga(tga, stat.size, 0);
    141         if (*p_local_surface == NULL) {
     161        rc = decode_tga(gc, tga, stat.size, rbitmap, rect);
     162        if (rc != EOK) {
    142163                free(tga);
    143164                return false;
    … …  
    146167        free(tga);
    147168
    148         surface_get_resolution(*p_local_surface, &img_width, &img_height);
    149 
     169        img_rect = *rect;
    150170        return true;
    151171}
    152172
    153 static bool img_setup(surface_t *local_surface)
    154 {
    155         if (canvas != NULL) {
    156                 if (!update_canvas(canvas, local_surface)) {
    157                         surface_destroy(local_surface);
     173static bool img_setup(gfx_context_t *gc, gfx_bitmap_t *bmp, gfx_rect_t *rect)
     174{
     175        gfx_rect_t arect;
     176        gfx_rect_t irect;
     177        ui_resource_t *ui_res;
     178        errno_t rc;
     179
     180        ui_res = ui_window_get_res(window);
     181
     182        ui_window_get_app_rect(window, &arect);
     183
     184        /* Center image on application area */
     185        gfx_rect_ctr_on_rect(rect, &arect, &irect);
     186
     187        if (image != NULL) {
     188                ui_image_set_bmp(image, bmp, rect);
     189                (void) ui_image_paint(image);
     190                ui_image_set_rect(image, &irect);
     191        } else {
     192                rc = ui_image_create(ui_res, bmp, rect, &image);
     193                if (rc != EOK) {
     194                        gfx_bitmap_destroy(bmp);
    158195                        return false;
    159196                }
    160         } else {
    161                 canvas = create_canvas(window_root(main_window), NULL,
    162                     img_width, img_height, local_surface);
    163                 if (canvas == NULL) {
    164                         surface_destroy(local_surface);
    165                         return false;
    166                 }
    167 
    168                 sig_connect(&canvas->keyboard_event, NULL, on_keyboard_event);
    169         }
    170 
    171         if (surface != NULL)
    172                 surface_destroy(surface);
    173 
    174         surface = local_surface;
     197
     198                ui_image_set_rect(image, &irect);
     199                ui_window_add(window, ui_image_ctl(image));
     200        }
     201
     202        if (bitmap != NULL)
     203                gfx_bitmap_destroy(bitmap);
     204
     205        bitmap = bmp;
    175206        return true;
    176207}
    … …  
    178209static void print_syntax(void)
    179210{
    180         printf("Syntax: %s [-d <display>] <image-file>...\n", NAME);
     211        printf("Syntax: %s [<options] <image-file>...\n", NAME);
     212        printf("\t-d <display-spec> Use the specified display\n");
     213        printf("\t-f                Full-screen mode\n");
    181214}
    182215
    183216int main(int argc, char *argv[])
    184217{
    185         const char *display_svc = DISPLAY_DEFAULT;
    186         window_flags_t flags;
    187         surface_t *lsface;
    188         bool fullscreen;
    189         sysarg_t dwidth;
    190         sysarg_t dheight;
     218        const char *display_spec = DISPLAY_DEFAULT;
     219        gfx_bitmap_t *lbitmap;
     220        gfx_rect_t lrect;
     221        bool fullscreen = false;
     222        gfx_rect_t rect;
     223        gfx_rect_t wrect;
     224        gfx_coord2_t off;
     225        ui_t *ui;
     226        ui_wnd_params_t params;
     227        viewer_t viewer;
     228        errno_t rc;
    191229        int i;
    192230
    … …  
    201239                        }
    202240
    203                         display_svc = argv[i++];
     241                        display_spec = argv[i++];
     242                } else if (str_cmp(argv[i], "-f") == 0) {
     243                        ++i;
     244                        fullscreen = true;
    204245                } else {
    205246                        printf("Invalid option '%s'.\n", argv[i]);
    … …  
    219260        if (imgs == NULL) {
    220261                printf("Out of memory.\n");
    221                 return 2;
     262                return 1;
    222263        }
    223264
    … …  
    230271        }
    231272
    232         if (!img_load(imgs[imgs_current], &lsface)) {
     273        rc = ui_create(display_spec, &ui);
     274        if (rc != EOK) {
     275                printf("Error creating UI on display %s.\n", display_spec);
     276                return 1;
     277        }
     278
     279        viewer.ui = ui;
     280
     281        /*
     282         * We don't know the image size yet, so create tiny window and resize
     283         * later.
     284         */
     285        ui_wnd_params_init(&params);
     286        params.caption = "Viewer";
     287        params.rect.p0.x = 0;
     288        params.rect.p0.y = 0;
     289        params.rect.p1.x = 1;
     290        params.rect.p1.y = 1;
     291
     292        if (fullscreen) {
     293                params.style &= ~ui_wds_decorated;
     294                params.placement = ui_wnd_place_full_screen;
     295        }
     296
     297        rc = ui_window_create(ui, &params, &window);
     298        if (rc != EOK) {
     299                printf("Error creating window.\n");
     300                return 1;
     301        }
     302
     303        window_gc = ui_window_get_gc(window);
     304
     305        ui_window_set_cb(window, &window_cb, (void *) &viewer);
     306
     307        if (!img_load(window_gc, imgs[imgs_current], &lbitmap, &lrect)) {
    233308                printf("Cannot load image \"%s\".\n", imgs[imgs_current]);
    234                 return 4;
    235         }
    236 
    237         fullscreen = ((img_width == WINDOW_WIDTH) &&
    238             (img_height == WINDOW_HEIGHT));
    239 
    240         flags = WINDOW_MAIN;
    241         if (!fullscreen)
    242                 flags |= WINDOW_DECORATED;
    243 
    244         main_window = window_open(display_svc, NULL, flags, "viewer");
    245         if (!main_window) {
    246                 printf("Cannot open main window.\n");
    247                 return 5;
    248         }
    249 
    250         if (!img_setup(lsface)) {
     309                return 1;
     310        }
     311
     312        /*
     313         * Compute window rectangle such that application area corresponds
     314         * to rect
     315         */
     316        ui_wdecor_rect_from_app(params.style, &lrect, &wrect);
     317        off = wrect.p0;
     318        gfx_rect_rtranslate(&off, &wrect, &rect);
     319
     320        if (!fullscreen) {
     321                rc = ui_window_resize(window, &rect);
     322                if (rc != EOK) {
     323                        printf("Error resizing window.\n");
     324                        return 1;
     325                }
     326        }
     327
     328        if (!img_setup(window_gc, lbitmap, &lrect)) {
    251329                printf("Cannot setup image \"%s\".\n", imgs[imgs_current]);
    252                 return 6;
    253         }
    254 
    255         if (!fullscreen) {
    256                 dwidth = DECORATION_WIDTH;
    257                 dheight = DECORATION_HEIGHT;
    258         } else {
    259                 dwidth = 0;
    260                 dheight = 0;
    261         }
    262 
    263         window_resize(main_window, 0, 0, img_width + dwidth,
    264             img_height + dheight, WINDOW_PLACEMENT_ANY);
    265         window_exec(main_window);
    266 
    267         task_retval(0);
    268         async_manager();
     330                return 1;
     331        }
     332
     333        rc = ui_window_paint(window);
     334        if (rc != EOK) {
     335                printf("Error painting window.\n");
     336                return 1;
     337        }
     338
     339        ui_run(ui);
    269340
    270341        return 0;

  • uspace/drv/fb/amdm37x_dispc/amdm37x_dispc.c

    r7a873f0 r8596474  
    383383
    384384        /* Check that we support all required flags */
    385         if ((params->flags & ~bmpf_color_key) != 0)
     385        if ((params->flags & ~(bmpf_color_key | bmpf_colorize)) != 0)
    386386                return ENOTSUP;
    387387
    … …  
    392392        gfx_coord2_subtract(&params->rect.p1, &params->rect.p0, &dim);
    393393        dcbm->rect = params->rect;
     394        dcbm->flags = params->flags;
    394395
    395396        if (alloc == NULL) {
    … …  
    487488        gfx_rect_clip(&srect, &skfbrect, &crect);
    488489
    489         // XXX bmpf_color_key
    490         for (pos.y = crect.p0.y; pos.y < crect.p1.y; pos.y++) {
    491                 for (pos.x = crect.p0.x; pos.x < crect.p1.x; pos.x++) {
    492                         gfx_coord2_subtract(&pos, &dcbm->rect.p0, &sp);
    493                         gfx_coord2_add(&pos, &offs, &dp);
    494 
    495                         color = pixelmap_get_pixel(&pbm, sp.x, sp.y);
    496                         dispc->active_fb.pixel2visual(dispc->fb_data +
    497                             FB_POS(dispc, dp.x, dp.y), color);
     490        if ((dcbm->flags & bmpf_color_key) == 0) {
     491                /* Simple copy */
     492                for (pos.y = crect.p0.y; pos.y < crect.p1.y; pos.y++) {
     493                        for (pos.x = crect.p0.x; pos.x < crect.p1.x; pos.x++) {
     494                                gfx_coord2_subtract(&pos, &dcbm->rect.p0, &sp);
     495                                gfx_coord2_add(&pos, &offs, &dp);
     496
     497                                color = pixelmap_get_pixel(&pbm, sp.x, sp.y);
     498                                dispc->active_fb.pixel2visual(dispc->fb_data +
     499                                    FB_POS(dispc, dp.x, dp.y), color);
     500                        }
     501                }
     502        } else if ((dcbm->flags & bmpf_colorize) == 0) {
     503                /* Color key */
     504                for (pos.y = crect.p0.y; pos.y < crect.p1.y; pos.y++) {
     505                        for (pos.x = crect.p0.x; pos.x < crect.p1.x; pos.x++) {
     506                                gfx_coord2_subtract(&pos, &dcbm->rect.p0, &sp);
     507                                gfx_coord2_add(&pos, &offs, &dp);
     508
     509                                color = pixelmap_get_pixel(&pbm, sp.x, sp.y);
     510                                if (color != dcbm->key_color) {
     511                                        dispc->active_fb.pixel2visual(dispc->fb_data +
     512                                            FB_POS(dispc, dp.x, dp.y), color);
     513                                }
     514                        }
     515                }
     516        } else {
     517                /* Color key & colorize */
     518                for (pos.y = crect.p0.y; pos.y < crect.p1.y; pos.y++) {
     519                        for (pos.x = crect.p0.x; pos.x < crect.p1.x; pos.x++) {
     520                                gfx_coord2_subtract(&pos, &dcbm->rect.p0, &sp);
     521                                gfx_coord2_add(&pos, &offs, &dp);
     522
     523                                color = pixelmap_get_pixel(&pbm, sp.x, sp.y);
     524                                if (color != dcbm->key_color) {
     525                                        dispc->active_fb.pixel2visual(dispc->fb_data +
     526                                            FB_POS(dispc, dp.x, dp.y),
     527                                            dcbm->dispc->color);
     528                                }
     529                        }
    498530                }
    499531        }

  • uspace/drv/fb/amdm37x_dispc/amdm37x_dispc.h

    r7a873f0 r8596474  
    6868
    6969typedef struct {
     70        /* Containing display controller */
    7071        amdm37x_dispc_t *dispc;
     72        /** Allocation info */
    7173        gfx_bitmap_alloc_t alloc;
     74        /** @c true if we allocated the bitmap, @c false if allocated by caller */
     75        bool myalloc;
     76        /** Rectangle covered by bitmap */
    7277        gfx_rect_t rect;
    73         bool myalloc;
     78        /** Bitmap flags */
     79        gfx_bitmap_flags_t flags;
     80        /** Key color */
     81        pixel_t key_color;
    7482} amdm37x_bitmap_t;
    7583

  • uspace/drv/fb/amdm37x_dispc/meson.build

    r7a873f0 r8596474  
    2929#
    3030
    31 deps = [ 'gfx', 'ipcgfx', 'ddev', 'softrend' ]
     31deps = [ 'gfx', 'ipcgfx', 'ddev', 'pixconv' ]
    3232src = files('amdm37x_dispc.c', 'main.c')

  • uspace/drv/fb/kfb/meson.build

    r7a873f0 r8596474  
    2929#
    3030
    31 deps = [ 'gfx', 'ipcgfx', 'ddev', 'softrend' ]
     31deps = [ 'gfx', 'ipcgfx', 'ddev', 'pixconv' ]
    3232src = files('port.c', 'kfb.c')

  • uspace/drv/fb/kfb/port.c

    r7a873f0 r8596474  
    5050#include <gfx/color.h>
    5151#include <gfx/coord.h>
    52 #include <io/mode.h>
    5352#include <io/pixelmap.h>
    5453#include <ipcgfx/server.h>
    … …  
    200199
    201200        /* Check that we support all required flags */
    202         if ((params->flags & ~bmpf_color_key) != 0)
     201        if ((params->flags & ~(bmpf_color_key | bmpf_colorize)) != 0)
    203202                return ENOTSUP;
    204203
    … …  
    307306
    308307        if ((kfbbm->flags & bmpf_color_key) != 0) {
     308                /* Simple copy */
    309309                for (pos.y = crect.p0.y; pos.y < crect.p1.y; pos.y++) {
    310310                        for (pos.x = crect.p0.x; pos.x < crect.p1.x; pos.x++) {
    … …  
    319319                        }
    320320                }
     321        } else if ((kfbbm->flags & bmpf_colorize) != 0) {
     322                /* Color key */
     323                for (pos.y = crect.p0.y; pos.y < crect.p1.y; pos.y++) {
     324                        for (pos.x = crect.p0.x; pos.x < crect.p1.x; pos.x++) {
     325                                gfx_coord2_subtract(&pos, &kfbbm->rect.p0, &sp);
     326                                gfx_coord2_add(&pos, &offs, &dp);
     327
     328                                color = pixelmap_get_pixel(&pbm, sp.x, sp.y);
     329                                kfb->pixel2visual(kfb->addr +
     330                                    FB_POS(kfb, dp.x, dp.y), color);
     331                        }
     332                }
    321333        } else {
     334                /* Color key & colorize */
    322335                for (pos.y = crect.p0.y; pos.y < crect.p1.y; pos.y++) {
    323336                        for (pos.x = crect.p0.x; pos.x < crect.p1.x; pos.x++) {

  • uspace/lib/c/include/io/pixelmap.h

    r7a873f0 r8596474  
    4242#include <stddef.h>
    4343#include <io/pixel.h>
    44 
    45 /* Defines how a pixel outside of pixmap rectangle shall be treated */
    46 typedef enum {
    47         /* Pixels outside of a pixmap are PIXEL(0, 0, 0, 0) */
    48         PIXELMAP_EXTEND_TRANSPARENT_BLACK = 0,
    49 
    50         /* The pixmap is repeated infinetely */
    51         PIXELMAP_EXTEND_TILE,
    52 
    53         /* If outside of a pixmap, return closest pixel from the edge */
    54         PIXELMAP_EXTEND_SIDES,
    55 
    56         /*
    57          * If outside of a pixmap, return closest pixel from the edge,
    58          * with alpha = 0
    59          */
    60         PIXELMAP_EXTEND_TRANSPARENT_SIDES
    61 } pixelmap_extend_t;
    6244
    6345typedef struct {
    … …  
    10688}
    10789
    108 static inline pixel_t pixelmap_get_extended_pixel(pixelmap_t *pixmap,
    109     native_t x, native_t y, pixelmap_extend_t extend)
    110 {
    111         bool transparent = false;
    112         if (extend == PIXELMAP_EXTEND_TILE) {
    113                 x %= pixmap->width;
    114                 y %= pixmap->height;
    115         } else if (extend == PIXELMAP_EXTEND_SIDES ||
    116             extend == PIXELMAP_EXTEND_TRANSPARENT_SIDES) {
    117                 bool transparent_outside =
    118                     (extend == PIXELMAP_EXTEND_TRANSPARENT_SIDES);
    119                 if (x < 0) {
    120                         x = 0;
    121                         transparent = transparent_outside;
    122                 } else if (((sysarg_t) x) >= pixmap->width) {
    123                         x = pixmap->width - 1;
    124                         transparent = transparent_outside;
    125                 }
    126 
    127                 if (y < 0) {
    128                         y = 0;
    129                         transparent = transparent_outside;
    130                 } else if (((sysarg_t) y) >= pixmap->height) {
    131                         y = pixmap->height - 1;
    132                         transparent = transparent_outside;
    133                 }
    134         }
    135 
    136         if (x < 0 || ((sysarg_t) x) >= pixmap->width ||
    137             y < 0 || ((sysarg_t) y) >= pixmap->height)
    138                 return PIXEL(0, 0, 0, 0);
    139 
    140         pixel_t pixel = pixelmap_get_pixel(pixmap, x, y);
    141 
    142         if (transparent)
    143                 pixel = PIXEL(0, RED(pixel), GREEN(pixel), BLUE(pixel));
    144 
    145         return pixel;
    146 }
    147 
    14890#endif
    14991

  • uspace/lib/congfx/src/console.c

    r7a873f0 r8596474  
    207207
    208208        /* Check that we support all requested flags */
    209         if ((params->flags & ~bmpf_color_key) != 0)
     209        if ((params->flags & ~(bmpf_color_key | bmpf_colorize)) != 0)
    210210                return ENOTSUP;
    211211
    … …  
    296296
    297297        if ((cbm->flags & bmpf_color_key) == 0) {
     298                /* Simple copy */
    298299                for (y = crect.p0.y; y < crect.p1.y; y++) {
    299300                        console_set_pos(cbm->cgc->con, crect.p0.x, y);
    … …  
    312313                        }
    313314                }
    314         } else {
     315        } else if ((cbm->flags & bmpf_colorize) == 0) {
     316                /* Color key */
    315317                for (y = crect.p0.y; y < crect.p1.y; y++) {
    316318                        for (x = crect.p0.x; x < crect.p1.x; x++) {
    … …  
    332334                        }
    333335                }
     336        } else {
     337                /* Color key & colorize */
     338                console_set_rgb_color(cbm->cgc->con, cbm->cgc->clr,
     339                    cbm->cgc->clr);
     340
     341                for (y = crect.p0.y; y < crect.p1.y; y++) {
     342                        for (x = crect.p0.x; x < crect.p1.x; x++) {
     343
     344                                clr = pixelmap_get_pixel(&pixelmap,
     345                                    x - offs.x - cbm->rect.p0.x,
     346                                    y - offs.y - cbm->rect.p0.y);
     347
     348                                if (clr != cbm->key_color) {
     349                                        console_set_pos(cbm->cgc->con, x, y);
     350                                        rv = fputc('X', cbm->cgc->fout);
     351                                        if (rv < 0)
     352                                                return EIO;
     353
     354                                        console_flush(cbm->cgc->con);
     355                                }
     356
     357                        }
     358                }
    334359        }
    335360

  • uspace/lib/display/include/types/display.h

    r7a873f0 r8596474  
    4646#define DISPLAY_DEFAULT NULL
    4747
     48struct display;
     49struct display_window;
     50
    4851/** Display server session */
    49 typedef struct {
    50         /** Session with display server */
    51         async_sess_t *sess;
    52         /** Synchronize access to display object */
    53         fibril_mutex_t lock;
    54         /** @c true if callback handler terminated */
    55         bool cb_done;
    56         /** Signalled when cb_done or ev_pending is changed */
    57         fibril_condvar_t cv;
    58         /** Windows (of display_window_t) */
    59         list_t windows;
    60 } display_t;
     52typedef struct display display_t;
     53
     54/** Display window */
     55typedef struct display_window display_window_t;
    6156
    6257/** Display window callbacks */
    … …  
    7671} display_wnd_cb_t;
    7772
    78 /** Display window */
    79 typedef struct {
    80         /** Display associated with the window */
    81         display_t *display;
    82         /** Link to @c display->windows */
    83         link_t lwindows;
    84         /** Window ID */
    85         sysarg_t id;
    86         /** Callback functions */
    87         display_wnd_cb_t *cb;
    88         /** Argument to callback functions */
    89         void *cb_arg;
    90 } display_window_t;
    91 
    9273#endif
    9374

  • uspace/lib/display/include/types/display/wndparams.h

    r7a873f0 r8596474  
    4141 *
    4242 * The window's dimensions are determined by the bounding rectangle,
    43  * the position of which does not relate to its positon on the display,
     43 * the position of which does not relate to its position on the display,
    4444 * it just determines which range of logical coordinates is used
    4545 * by the window.

  • uspace/lib/display/src/display.c

    r7a873f0 r8596474  
    3838#include <mem.h>
    3939#include <stdlib.h>
     40#include "../private/display.h"
    4041#include "../private/params.h"
    4142
    … …  
    198199/** Destroy display window.
    199200 *
    200  * @param window Window
     201 * @param window Window or @c NULL
    201202 * @return EOK on success or an error code. In both cases @a window must
    202203 *         not be accessed anymore
    … …  
    206207        async_exch_t *exch;
    207208        errno_t rc;
     209
     210        if (window == NULL)
     211                return EOK;
    208212
    209213        exch = async_exchange_begin(window->display->sess);

  • uspace/lib/display/test/display.c

    r7a873f0 r8596474  
    3838#include <loc.h>
    3939#include <pcut/pcut.h>
     40#include "../private/display.h"
    4041
    4142PCUT_INIT;
    … …  
    331332}
    332333
     334/** display_window_destroy() can handle NULL argument */
     335PCUT_TEST(window_destroy_null)
     336{
     337        display_window_destroy(NULL);
     338}
     339
    333340/** display_window_move_req() with server returning error response works. */
    334341PCUT_TEST(window_move_req_failure)

  • uspace/lib/gfx/include/gfx/coord.h

    r7a873f0 r8596474  
    4040#include <types/gfx/coord.h>
    4141
     42extern gfx_coord_t gfx_coord_div_rneg(gfx_coord_t, gfx_coord_t);
    4243extern void gfx_coord2_add(gfx_coord2_t *, gfx_coord2_t *, gfx_coord2_t *);
    4344extern void gfx_coord2_subtract(gfx_coord2_t *, gfx_coord2_t *, gfx_coord2_t *);
    … …  
    5152extern void gfx_rect_envelope(gfx_rect_t *, gfx_rect_t *, gfx_rect_t *);
    5253extern void gfx_rect_clip(gfx_rect_t *, gfx_rect_t *, gfx_rect_t *);
     54extern void gfx_rect_ctr_on_rect(gfx_rect_t *, gfx_rect_t *, gfx_rect_t *);
    5355extern void gfx_rect_points_sort(gfx_rect_t *, gfx_rect_t *);
    5456extern void gfx_rect_dims(gfx_rect_t *, gfx_coord2_t *);

  • uspace/lib/gfx/include/types/gfx/bitmap.h

    r7a873f0 r8596474  
    4747/** Bitmap flags */
    4848typedef enum {
     49        /** Directly map GC output into this bitmap */
     50        bmpf_direct_output = 0x1,
    4951        /** Enable color key */
    50         bmpf_color_key = 0x1,
    51         /** Directly map GC output into this bitmap */
    52         bmpf_direct_output = 0x2
     52        bmpf_color_key = 0x2,
     53        /** Paint non-background pixels with current drawing color */
     54        bmpf_colorize = 0x4
    5355} gfx_bitmap_flags_t;
    5456

  • uspace/lib/gfx/private/color.h

    r7a873f0 r8596474  
    3838#define _GFX_PRIVATE_COLOR_H
    3939
     40#include <stdint.h>
     41
    4042/** Actual structure of graphics color.
    4143 *

  • uspace/lib/gfx/src/bitmap.c

    r7a873f0 r8596474  
    6262 *
    6363 * @return EOK on success, EINVAL if parameters are invald,
    64  *         ENOMEM if insufficient resources, EIO if grahic device connection
     64 *         ENOMEM if insufficient resources, EIO if graphic device connection
    6565 *         was lost
    6666 */
    … …  
    9292 * @param bitmap Bitmap
    9393 *
    94  * @return EOK on success, EIO if grahic device connection was lost
     94 * @return EOK on success, EIO if graphic device connection was lost
    9595 */
    9696errno_t gfx_bitmap_destroy(gfx_bitmap_t *bitmap)
    … …  
    112112 * @param offs Bitmap offset or @c NULL for zero offset
    113113 *
    114  * @return EOK on success, EIO if grahic device connection was lost
     114 * @return EOK on success, EIO if graphic device connection was lost
    115115 */
    116116errno_t gfx_bitmap_render(gfx_bitmap_t *bitmap, gfx_rect_t *srect,
    … …  
    125125 * @param alloc Allocation info structure to fill in
    126126 *
    127  * @return EOK on success, EIO if grahic device connection was lost
     127 * @return EOK on success, EIO if graphic device connection was lost
    128128 */
    129129errno_t gfx_bitmap_get_alloc(gfx_bitmap_t *bitmap, gfx_bitmap_alloc_t *alloc)

  • uspace/lib/gfx/src/coord.c

    r7a873f0 r8596474  
    3939#include <stddef.h>
    4040
     41/** Divide @a a by @a b and round towards negative numbers.
     42 *
     43 * Regular integer division always rounds towards zero. This is not useful
     44 * e.g. for scaling down, where we always need to round towards negative
     45 * numbers.
     46 *
     47 * @param a Dividend
     48 * @param b Divisor
     49 * @return Quotient
     50 */
     51gfx_coord_t gfx_coord_div_rneg(gfx_coord_t a, gfx_coord_t b)
     52{
     53        if ((a > 0 && b > 0) || (a < 0 && b < 0)) {
     54                /* Result is non-negative, round towards zero */
     55                return a / b;
     56        } else {
     57                /* Result is negative, round away from zero */
     58                return (a - b + 1) / b;
     59        }
     60}
     61
    4162/** Add two vectors.
    4263 *
    … …  
    217238}
    218239
     240/** Center rectangle on rectangle.
     241 *
     242 * Translate rectangle @a a so that its center coincides with the
     243 * center of rectangle @a b, saving the result in @a dest.
     244 *
     245 * @param a Rectnagle to translate
     246 * @param b Rectangle on which to center
     247 * @param dest Place to store resulting rectangle
     248 */
     249void gfx_rect_ctr_on_rect(gfx_rect_t *a, gfx_rect_t *b, gfx_rect_t *dest)
     250{
     251        gfx_coord2_t adim;
     252        gfx_coord2_t bdim;
     253
     254        gfx_rect_dims(a, &adim);
     255        gfx_rect_dims(b, &bdim);
     256
     257        dest->p0.x = b->p0.x + bdim.x / 2 - adim.x / 2;
     258        dest->p0.y = b->p0.y + bdim.y / 2 - adim.y / 2;
     259
     260        dest->p1.x = dest->p0.x + adim.x;
     261        dest->p1.y = dest->p0.y + adim.y;
     262}
     263
    219264/** Sort points of a rectangle.
    220265 *

  • uspace/lib/gfx/test/coord.c

    r7a873f0 r8596474  
    3434PCUT_TEST_SUITE(coord);
    3535
     36/** gfx_coord_div_rneg rounds towards negative numbers */
     37PCUT_TEST(coord_div_rneg)
     38{
     39        PCUT_ASSERT_INT_EQUALS(-3, gfx_coord_div_rneg(-7, 3));
     40        PCUT_ASSERT_INT_EQUALS(-2, gfx_coord_div_rneg(-6, 3));
     41        PCUT_ASSERT_INT_EQUALS(-2, gfx_coord_div_rneg(-5, 3));
     42        PCUT_ASSERT_INT_EQUALS(-2, gfx_coord_div_rneg(-4, 3));
     43        PCUT_ASSERT_INT_EQUALS(-1, gfx_coord_div_rneg(-3, 3));
     44        PCUT_ASSERT_INT_EQUALS(-1, gfx_coord_div_rneg(-2, 3));
     45        PCUT_ASSERT_INT_EQUALS(-1, gfx_coord_div_rneg(-1, 3));
     46        PCUT_ASSERT_INT_EQUALS(0, gfx_coord_div_rneg(0, 3));
     47        PCUT_ASSERT_INT_EQUALS(0, gfx_coord_div_rneg(1, 3));
     48        PCUT_ASSERT_INT_EQUALS(0, gfx_coord_div_rneg(2, 3));
     49        PCUT_ASSERT_INT_EQUALS(1, gfx_coord_div_rneg(3, 3));
     50        PCUT_ASSERT_INT_EQUALS(1, gfx_coord_div_rneg(4, 3));
     51        PCUT_ASSERT_INT_EQUALS(1, gfx_coord_div_rneg(5, 3));
     52        PCUT_ASSERT_INT_EQUALS(2, gfx_coord_div_rneg(6, 3));
     53}
     54
    3655/** gfx_coord2_add should add two coordinate vectors */
    3756PCUT_TEST(coord2_add)
    … …  
    578597}
    579598
     599/** Center rectangle on rectangle */
     600PCUT_TEST(rect_ctr_on_rect)
     601{
     602        gfx_rect_t a;
     603        gfx_rect_t b;
     604        gfx_rect_t dest;
     605
     606        /* Dimensions: 20 x 20 */
     607        b.p0.x = 10;
     608        b.p0.y = 20;
     609        b.p1.x = 30;
     610        b.p1.y = 40;
     611
     612        /* Dimensions: 20 x 20 */
     613        a.p0.x = 100;
     614        a.p0.y = 200;
     615        a.p1.x = 120;
     616        a.p1.y = 220;
     617
     618        /* Centering rectangle of same size should give us the same rectangle */
     619        gfx_rect_ctr_on_rect(&a, &b, &dest);
     620        PCUT_ASSERT_INT_EQUALS(b.p0.x, dest.p0.x);
     621        PCUT_ASSERT_INT_EQUALS(b.p0.y, dest.p0.y);
     622        PCUT_ASSERT_INT_EQUALS(b.p1.x, dest.p1.x);
     623        PCUT_ASSERT_INT_EQUALS(b.p1.y, dest.p1.y);
     624
     625        /* Dimensions: 10 x 10 */
     626        a.p0.x = 100;
     627        a.p0.y = 200;
     628        a.p1.x = 110;
     629        a.p1.y = 210;
     630
     631        gfx_rect_ctr_on_rect(&a, &b, &dest);
     632        PCUT_ASSERT_INT_EQUALS(15, dest.p0.x);
     633        PCUT_ASSERT_INT_EQUALS(25, dest.p0.y);
     634        PCUT_ASSERT_INT_EQUALS(25, dest.p1.x);
     635        PCUT_ASSERT_INT_EQUALS(35, dest.p1.y);
     636}
     637
    580638/** Sort span points that are already sorted should produde indentical points */
    581639PCUT_TEST(rect_points_sort_sorted)

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

    r7a873f0 r8596474  
    225225
    226226        /* Check that we support all requested flags */
    227         if ((params->flags & ~(bmpf_color_key | bmpf_direct_output)) != 0)
     227        if ((params->flags & ~(bmpf_color_key | bmpf_colorize |
     228            bmpf_direct_output)) != 0)
    228229                return ENOTSUP;
    229230
    … …  
    367368                /* Nothing to do */
    368369        } else if ((mbm->flags & bmpf_color_key) == 0) {
     370                /* Simple copy */
    369371                for (y = drect.p0.y; y < drect.p1.y; y++) {
    370372                        for (x = drect.p0.x; x < drect.p1.x; x++) {
    … …  
    375377                        }
    376378                }
    377         } else {
     379        } else if ((mbm->flags & bmpf_colorize) == 0) {
     380                /* Color key */
    378381                for (y = drect.p0.y; y < drect.p1.y; y++) {
    379382                        for (x = drect.p0.x; x < drect.p1.x; x++) {
    … …  
    385388                        }
    386389                }
     390        } else {
     391                /* 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++) {
     394                                pixel = pixelmap_get_pixel(&smap,
     395                                    x - mbm->rect.p0.x - offs.x,
     396                                    y - mbm->rect.p0.y - offs.y);
     397                                if (pixel != mbm->key_color)
     398                                        pixelmap_put_pixel(&dmap, x, y,
     399                                            mbm->mgc->color);
     400                        }
     401                }
    387402        }
    388403

  • uspace/lib/meson.build

    r7a873f0 r8596474  
    3434        'math',
    3535        'display',
    36         'gui',
    37         'draw',
    38         'softrend',
     36        'pixconv',
    3937        'posix',
    4038        'clui',
    … …  
    4240        'hound',
    4341        'gfx',
     42        'gfximage',
    4443        'ipcgfx',
    4544        'display',
     45        'ui',
    4646]
    4747
    … …  
    5656        'crypto',
    5757        'dltest',
     58        'fbfont',
    5859        'fdisk',
    5960        'fmtutil',
    … …  
    6768        'pcm',
    6869        'pcut',
     70        'pixconv',
    6971        'posix',
     72        'riff',
    7073        'scsi',
    7174        'sif',
    72         'softrend',
    7375        'trackmod',
    7476        'untar',
    … …  
    7779        'bithenge',
    7880        'congfx',
    79         'draw',
    8081        'drv',
    8182        'ext4',
     83        'gfxfont',
     84        'gfximage',
    8285        'hound',
    8386        'ipcgfx',
    … …  
    9598        'display',
    9699
    97         'gui',
    98 
    99         'guigfx',
     100        'ui',
    100101]
    101102

  • uspace/srv/hid/display/seat.c

    r7a873f0 r8596474  
    9090void ds_seat_set_focus(ds_seat_t *seat, ds_window_t *wnd)
    9191{
     92        if (wnd == seat->focus) {
     93                /* Focus is not changing */
     94                return;
     95        }
     96
    9297        if (seat->focus != NULL)
    9398                ds_window_post_unfocus_event(seat->focus);

  • uspace/srv/hid/display/window.c

    r7a873f0 r8596474  
    160160        ds_display_remove_window(wnd);
    161161        ds_display_add_window(disp, wnd);
     162        (void) ds_display_paint(wnd->display, NULL);
    162163}
    163164

  • uspace/srv/hid/rfb/main.c

    r7a873f0 r8596474  
    196196
    197197        /* Check that we support all required flags */
    198         if ((params->flags & ~bmpf_color_key) != 0)
     198        if ((params->flags & ~(bmpf_color_key | bmpf_colorize)) != 0)
    199199                return ENOTSUP;
    200200
    … …  
    287287
    288288        if ((rfbbm->flags & bmpf_color_key) == 0) {
     289                /* Simple copy */
    289290                for (y = srect.p0.y; y < srect.p1.y; y++) {
    290291                        for (x = srect.p0.x; x < srect.p1.x; x++) {
    … …  
    294295                        }
    295296                }
    296         } else {
     297        } else if ((rfbbm->flags & bmpf_colorize) == 0) {
     298                /* Color key */
    297299                for (y = srect.p0.y; y < srect.p1.y; y++) {
    298300                        for (x = srect.p0.x; x < srect.p1.x; x++) {
    … …  
    304306                        }
    305307                }
     308        } else {
     309                /* Color key & colorization */
     310                for (y = srect.p0.y; y < srect.p1.y; y++) {
     311                        for (x = srect.p0.x; x < srect.p1.x; x++) {
     312                                color = pixelmap_get_pixel(&pbm, x, y);
     313                                if (color != rfbbm->key_color) {
     314                                        pixelmap_put_pixel(&rfbbm->rfb->rfb.framebuffer,
     315                                            x + offs.x, y + offs.y,
     316                                            rfbbm->rfb->color);
     317                                }
     318                        }
     319                }
    306320        }
    307321
Note: See TracChangeset for help on using the changeset viewer.