Changeset 2c9fdeed in mainline


Ignore:
Timestamp:
2020-11-12T20:47:57Z (4 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
38f5598
Parents:
12008adf
Message:

Port viewer to UI

Location:
uspace/app/viewer
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/viewer/meson.build

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

    r12008adf r2c9fdeed  
    11/*
     2 * Copyright (c) 2020 Jiri Svoboda
    23 * Copyright (c) 2013 Martin Decky
    34 * All rights reserved.
     
    3334 */
    3435
     36#include <draw/surface.h>
     37#include <draw/codec.h>
     38#include <errno.h>
     39#include <stdbool.h>
    3540#include <stdio.h>
    3641#include <stdlib.h>
     42#include <str.h>
     43#include <ui/image.h>
     44#include <ui/ui.h>
     45#include <ui/wdecor.h>
     46#include <ui/window.h>
    3747#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>
    4748
    4849#define NAME  "viewer"
    4950
    50 #define WINDOW_WIDTH   1024
    51 #define WINDOW_HEIGHT  768
    52 
    53 #define DECORATION_WIDTH        8
    54 #define DECORATION_HEIGHT       28
     51typedef struct {
     52        ui_t *ui;
     53} viewer_t;
    5554
    5655static size_t imgs_count;
     
    5857static char **imgs;
    5958
    60 static window_t *main_window;
     59static ui_window_t *window;
    6160static surface_t *surface = NULL;
    62 static canvas_t *canvas = NULL;
     61static ui_image_t *image = NULL;
     62static gfx_context_t *window_gc;
    6363
    6464static surface_coord_t img_width;
     
    6666
    6767static 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;
     68static bool img_setup(gfx_context_t *, surface_t *);
     69
     70static void wnd_close(ui_window_t *, void *);
     71static void wnd_kbd_event(ui_window_t *, void *, kbd_event_t *);
     72
     73static ui_window_cb_t window_cb = {
     74        .close = wnd_close,
     75        .kbd = wnd_kbd_event
     76};
     77
     78/** Window close request
     79 *
     80 * @param window Window
     81 * @param arg Argument (calc_t *)
     82 */
     83static void wnd_close(ui_window_t *window, void *arg)
     84{
     85        viewer_t *viewer = (viewer_t *) arg;
     86
     87        ui_quit(viewer->ui);
     88}
     89
     90static void wnd_kbd_event(ui_window_t *window, void *arg,
     91    kbd_event_t *event)
     92{
    7393        bool update = false;
    7494
     
    101121                        exit(4);
    102122                }
    103                 if (!img_setup(lsface)) {
     123                if (!img_setup(window_gc, lsface)) {
    104124                        printf("Cannot setup image \"%s\".\n", imgs[imgs_current]);
    105125                        exit(6);
     
    138158        vfs_put(fd);
    139159
    140         *p_local_surface = decode_tga(tga, stat.size, 0);
     160        *p_local_surface = decode_tga(tga, stat.size, SURFACE_FLAG_SHARED);
    141161        if (*p_local_surface == NULL) {
    142162                free(tga);
     
    151171}
    152172
    153 static bool img_setup(surface_t *local_surface)
    154 {
    155         if (canvas != NULL) {
    156                 if (!update_canvas(canvas, local_surface)) {
     173static bool img_setup(gfx_context_t *gc, surface_t *local_surface)
     174{
     175        surface_coord_t w, h;
     176        gfx_bitmap_params_t params;
     177        gfx_bitmap_alloc_t alloc;
     178        gfx_bitmap_t *bmp;
     179        gfx_rect_t arect;
     180        gfx_rect_t irect;
     181        ui_resource_t *ui_res;
     182        errno_t rc;
     183
     184        ui_res = ui_window_get_res(window);
     185
     186        surface_get_resolution(local_surface, &w, &h);
     187        gfx_bitmap_params_init(&params);
     188        params.rect.p1.x = w;
     189        params.rect.p1.y = h;
     190
     191        ui_window_get_app_rect(window, &arect);
     192        gfx_rect_translate(&arect.p0, &params.rect, &irect);
     193
     194        alloc.pitch = sizeof(uint32_t) * w;
     195        alloc.off0 = 0;
     196        alloc.pixels = surface_direct_access(local_surface);
     197
     198        rc = gfx_bitmap_create(gc, &params, &alloc, &bmp);
     199        if (rc != EOK) {
     200                surface_destroy(local_surface);
     201                return false;
     202        }
     203
     204        if (image != NULL) {
     205                ui_image_set_bmp(image, bmp, &params.rect);
     206                (void) ui_image_paint(image);
     207                ui_image_set_rect(image, &irect);
     208        } else {
     209                rc = ui_image_create(ui_res, bmp, &params.rect, &image);
     210                if (rc != EOK) {
     211                        gfx_bitmap_destroy(bmp);
    157212                        surface_destroy(local_surface);
    158213                        return false;
    159214                }
    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);
     215
     216                ui_image_set_rect(image, &irect);
     217                ui_window_add(window, ui_image_ctl(image));
    169218        }
    170219
     
    178227static void print_syntax(void)
    179228{
    180         printf("Syntax: %s [-d <display>] <image-file>...\n", NAME);
     229        printf("Syntax: %s [<options] <image-file>...\n", NAME);
     230        printf("\t-d <display-spec> Use the specified display\n");
     231        printf("\t-f                Full-screen mode\n");
    181232}
    182233
    183234int main(int argc, char *argv[])
    184235{
    185         const char *display_svc = DISPLAY_DEFAULT;
    186         window_flags_t flags;
     236        const char *display_spec = DISPLAY_DEFAULT;
    187237        surface_t *lsface;
    188         bool fullscreen;
    189         sysarg_t dwidth;
    190         sysarg_t dheight;
     238        bool fullscreen = false;
     239        gfx_rect_t rect;
     240        gfx_rect_t wrect;
     241        gfx_coord2_t off;
     242        ui_t *ui;
     243        ui_wnd_params_t params;
     244        viewer_t viewer;
     245        errno_t rc;
    191246        int i;
    192247
     
    201256                        }
    202257
    203                         display_svc = argv[i++];
     258                        display_spec = argv[i++];
     259                } else if (str_cmp(argv[i], "-f") == 0) {
     260                        fullscreen = true;
    204261                } else {
    205262                        printf("Invalid option '%s'.\n", argv[i]);
     
    219276        if (imgs == NULL) {
    220277                printf("Out of memory.\n");
    221                 return 2;
     278                return 1;
    222279        }
    223280
     
    232289        if (!img_load(imgs[imgs_current], &lsface)) {
    233290                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)) {
     291                return 1;
     292        }
     293
     294        // TODO Fullscreen mode
     295        if (fullscreen) {
     296                printf("Fullscreen mode not implemented.\n");
     297                return 1;
     298        }
     299
     300        rc = ui_create(display_spec, &ui);
     301        if (rc != EOK) {
     302                printf("Error creating UI on display %s.\n", display_spec);
     303                return 1;
     304        }
     305
     306        viewer.ui = ui;
     307
     308        rect.p0.x = 0;
     309        rect.p0.y = 0;
     310        rect.p1.x = img_width;
     311        rect.p1.y = img_height;
     312
     313        ui_wnd_params_init(&params);
     314        params.caption = "Viewer";
     315        /*
     316         * Compute window rectangle such that application area corresponds
     317         * to rect
     318         */
     319        ui_wdecor_rect_from_app(&rect, &wrect);
     320        off = wrect.p0;
     321        gfx_rect_rtranslate(&off, &wrect, &params.rect);
     322
     323        rc = ui_window_create(ui, &params, &window);
     324        if (rc != EOK) {
     325                printf("Error creating window.\n");
     326                return 1;
     327        }
     328
     329        window_gc = ui_window_get_gc(window);
     330
     331        ui_window_set_cb(window, &window_cb, (void *) &viewer);
     332
     333        if (!img_setup(window_gc, lsface)) {
    251334                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();
     335                return 1;
     336        }
     337
     338        rc = ui_window_paint(window);
     339        if (rc != EOK) {
     340                printf("Error painting window.\n");
     341                return 1;
     342        }
     343
     344        ui_run(ui);
    269345
    270346        return 0;
Note: See TracChangeset for help on using the changeset viewer.