Changes in / [37d4c91:3541cb9] in mainline


Ignore:
Files:
141 added
85 deleted
35 edited

Legend:

Unmodified
Added
Removed
  • meson/part/initrd_manifest/meson.build

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    2727#
    2828
    29 deps = [ 'gui', 'draw', 'compress', 'softrend', 'math' ]
     29deps = [ 'ui', 'gfximage', 'compress' ]
    3030
    3131_images = files(
  • uspace/app/gfxdemo/doc/doxygroups.h

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    2727#
    2828
    29 deps = [ 'gui' ]
     29deps = [ 'ui', 'gfximage', 'compress' ]
    3030src = files('viewer.c')
    3131
  • uspace/app/viewer/viewer.c

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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

    r37d4c91 r3541cb9  
    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.