/*

 * GUI implementation

 *

 * Copyright (c) 2009 CodeSourcery

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include "hw/hw.h"

#include "sysemu.h"

#include "stdio.h"

#include "qemu-timer.h"

#include "hw/gui.h"

#include "gui_host.h"

#include "gui_common.h"

#include "gui_parser.h"

#define HOST_ONLY_DEFS /* DFG: FIXME */

#include "hw/fb_render_engine.h"

#include "gui_png.h"

#define MAX_CONSOLES 12

typedef void (*button_action_t)(void *parameter);

struct button_actions_s

{

    button_action_t down;

    button_action_t up;

};

enum button_actions_e

{

    BUTTON_ACTION_NOACTION = 0,

    BUTTON_ACTION_SENDKEY = 1,

};

typedef enum

{

    CA_POINTERAREA,

    CA_BUTTON

} clickarea_type;

typedef struct

{

    devid_t devid;

    int absolute;

    int grab_on_click;

    int show_cursor_while_grabbing;

    QEMUPutMouseEvent *callback;

    void *opaque;

} pointer_area_t;

typedef struct

{

    ImageID pressed_img_id;

    enum button_actions_e actions;

    void* parameter;

} button_t;

typedef struct

{

    gui_area_t area;

    clickarea_type type;

    int id;

} clickable_area_t;

typedef struct

{

    /* TODO: Optimize with a geometrical index */

    clickable_area_t *areas;

    unsigned int n_areas;

    clickable_area_t *currently_grabbing; /* NULL if none */

} clickable_map_t;

typedef struct

{

    devid_t devid;

    DisplayState ds;

    vga_hw_update_ptr update;

    vga_hw_invalidate_ptr invalidate;

    vga_hw_screen_dump_ptr screen_dump;

    /*vga_hw_text_update_ptr text_update;*/

    void *opaque;

} ds_data_t;

typedef struct

{

    ds_data_t *ds_data;

    unsigned int n_ds;

    int order_priority; /* This is used to place this VT in the key sequence (i.e. skinned VTs first) */

    pointer_area_t *pointerareas;

    unsigned int n_pointerareas;

    KeyCallback key_callback;

    void *key_opaque;

    /* skin data */

    int has_skin;

    /* If has skin, the following data applies.

       Maybe all should be moved to skin_data_t.

    */

    DisplayState gui_ds; /* just for skin and host images */

    void *background_buffer;

    unsigned int background_row_size;

    render_data *rdata;

    int full_update;

    gui_image_t *images;

    unsigned int n_images;

    clickable_map_t clickable_map;

    button_t *buttons;

    unsigned int n_buttons;

} vt_t;

enum gui_input_state_t

{

    INPUT_STATE_GUI_UNLOADED, /* Compatible with old (gui-less) machines */

    INPUT_STATE_GUI_LOADED

};

typedef struct

{

    void (*gui_notify_toggle_fullscreen)(void);

    void (*gui_notify_toggle_grabmode)(void);

    void (*gui_notify_mouse_motion)(int dx, int dy, int dz, int x, int y, int state);

    void (*gui_notify_mouse_button)(int dz, int x, int y, int state);

    void (*gui_notify_mouse_warp)(int x, int y, int on);

    void (*gui_notify_new_guest_cursor)(void);

    void (*gui_notify_input_focus_lost)(void);

    void (*gui_notify_app_focus)(int gain);

} gui_input_table_t;

struct gui_data_t

{

    gui_host_callbacks_t host_callbacks;

    vt_t vts[MAX_CONSOLES];

    unsigned int n_vts;

    vt_t *current_vt;

    VtID ordered_vts[MAX_CONSOLES]; /* Vts sorted by order_priority */

    screen_data_t screen_data;

    struct QEMUTimer *gui_timer;

    uint64_t gui_timer_interval;

    int idle; /* there is nothing to update (window invisible), set by vnc/sdl */

    int updating; /* to prevent recursion */

    /* Input stuff */

    KeyCallback dev_key_callback;

    void *dev_key_opaque;

    int gui_fullscreen;

    const gui_input_table_t* input_table;

    int guest_cursor;

    int guest_x;

    int guest_y;

    int last_vm_running;

    struct {

        int absolute_enabled;

        int gui_grab; /* if true, all keyboard/mouse events are grabbed */

        int gui_saved_grab;

        int gui_fullscreen_initial_grab;

    } unloaded_state_data;

    int loaded;

};

static struct gui_data_t* gui_data = NULL;

/*******************************************/

/* Internal Functions ==================== */

static parse_result_t load_gui_xml(const char* xml_file);

static void index_map(clickable_map_t *map);

static void initialize_display_areas(VtID vtid);

static void destroy_clickable_map(clickable_map_t *map);

static void destroy_images(VtID vtid);

static void gui_update_guest_display(vt_t *vt);

static void init_background(VtID vtid);

static void gui_set_input_state(enum gui_input_state_t input_state);

static void gui_update_caption(void);

static void gui_update_ds_data(DisplayState *ds, int in_skinned_vt);

static void gui_loaded_grab_end(void);

static void gui_update_timer(int64_t ticks);

/* ======================================= */

int ds_get_width(const DisplayState *ds)

{

    return ds->width;

}

int ds_get_height(const DisplayState *ds)

{

    return ds->height;

}

int ds_get_bits_per_pixel(const DisplayState *ds)

{

    return ds->depth;

}

int ds_get_bgr(const DisplayState *ds)

{

    return ds->bgr;

}

int ds_get_linesize(const DisplayState *ds)

{

    return ds->linesize;

}

uint8_t *ds_get_data(const DisplayState *ds)

{

    return ds->data;

}

static inline int vt_enabled(void)

{

    return gui_data->current_vt != NULL;

}

static inline VtID current_vt_id(void)

{

    return gui_data->current_vt - &gui_data->vts[0];

}

static inline int is_current_vt(VtID vtid)

{

    return gui_data->current_vt == &gui_data->vts[vtid];

}

static inline void invalidate_ds(const ds_data_t* ds_data)

{

    if (ds_data->invalidate != NULL)

        ds_data->invalidate(ds_data->opaque);

}

static inline void update_ds(const ds_data_t* ds_data)

{

    if (ds_data->update != NULL)

        ds_data->update(ds_data->opaque);

}

static inline int get_vt_width(const vt_t *vt)

{

    if (vt->has_skin)

        return GET_GUI_AREA_WIDTH(&vt->images[DEF_BACKGROUND_IMAGE].area);

    else

        return vt->ds_data[0].ds.width;

}

static inline int get_vt_height(const vt_t *vt)

{

    if (vt->has_skin)

        return GET_GUI_AREA_HEIGHT(&vt->images[DEF_BACKGROUND_IMAGE].area);

    else

        return vt->ds_data[0].ds.height;

}

void dpy_update(DisplayState *s, int x, int y, int w, int h)

{

    s->dpy_update(s, x, y, w, h);

}

void dpy_cursor(DisplayState *s, int x, int y)

{

    if (s->dpy_text_cursor)

        s->dpy_text_cursor(s, x, y);

}

static int accepts_kbd(const vt_t *vt)

{

    return (vt->key_callback != NULL);

#if 0

    DFG FIXME: manage multiple text consoles

    int accepts = 0;

    if (vt->n_ds_data > 0) {

        int vtid = 0;

        do {

            accepts = (vt->ds_data[vtid++]->);

        } while (!accepts && vtid < vt->n_ds_data);

    }

    return accepts;

#endif

}

void gui_init(gui_host_callbacks_t* callbacks)

{

    gui_data = (struct gui_data_t*)qemu_mallocz(sizeof(struct gui_data_t));

    gui_set_input_state(INPUT_STATE_GUI_UNLOADED);

    if (callbacks != NULL) {

        gui_data->host_callbacks = *callbacks;

        gui_data->host_callbacks.set_screen_size(640, 480, 0);

        gui_data->host_callbacks.get_screen_data(&gui_data->screen_data);

    }

    gui_update_caption();

}

void gui_destroy(void)

{

    if (gui_data != NULL) {

        if (gui_data->loaded)

            gui_unload();

        qemu_free(gui_data);

        gui_data = NULL;

    }

}

int gui_load(const char *xml_file)

{

    parse_result_t res;

    int vt;

    res = load_gui_xml(xml_file);

    if (res == PARSE_OK) {

        gui_data->loaded = 1;

        for (vt = 0; vt < gui_data->n_vts; vt++) {

            index_map(&gui_data->vts[vt].clickable_map);

            if (gui_data->vts[vt].has_skin) {

                gui_data->vts[vt].rdata = create_render_data();

                init_background(vt);

                gui_show_image(vt, DEF_BACKGROUND_IMAGE);

            }

            initialize_display_areas(vt);

        }

        gui_set_input_state(INPUT_STATE_GUI_LOADED);

        gui_data->current_vt = &gui_data->vts[0];

        /*gui_notify_console_select(0); Done in vl.c */

    } else {

        if (parsing_location_error() != NULL)

            fprintf(stderr, "GUI parser error %d at %s\n", res, parsing_location_error());

    }

    return res == PARSE_OK;

}

void gui_unload(void)

{

    int vt;

    if (gui_data->loaded) {

        for (vt = 0; vt < gui_data->n_vts; vt++) {

            destroy_images(vt);

            destroy_clickable_map(&gui_data->vts[vt].clickable_map);

            destroy_render_data(gui_data->vts[vt].rdata);

            qemu_free(gui_data->vts[vt].background_buffer);

            qemu_free(gui_data->vts[vt].ds_data);

        }

        gui_set_input_state(INPUT_STATE_GUI_UNLOADED);

        gui_data->loaded = 0;

    }

}

int gui_needs_timer(void)

{

    return (gui_data->host_callbacks.process_events != NULL);

}

void gui_set_timer(struct QEMUTimer *timer)

{

    gui_data->gui_timer = timer;

}

static void init_background(VtID vtid)

{

    const int background_width = GET_GUI_AREA_WIDTH(&gui_data->vts[vtid].images[DEF_BACKGROUND_IMAGE].area);

    const int background_height = GET_GUI_AREA_HEIGHT(&gui_data->vts[vtid].images[DEF_BACKGROUND_IMAGE].area);

    gui_data->vts[vtid].gui_ds.width = background_width;

    gui_data->vts[vtid].gui_ds.height = background_height;

    gui_data->host_callbacks.init_ds(&gui_data->vts[vtid].gui_ds);

    gui_update_ds_data(&gui_data->vts[vtid].gui_ds, 1);

    gui_data->vts[vtid].background_row_size = background_width * 4;

    gui_data->vts[vtid].background_buffer = (void*)qemu_malloc(

        gui_data->vts[vtid].background_row_size * background_height);

    set_fb_base_from_host(gui_data->vts[vtid].rdata, 

                          gui_data->vts[vtid].background_buffer);

    set_cols(gui_data->vts[vtid].rdata, background_width);

    set_rows(gui_data->vts[vtid].rdata, background_height);

    /* FIXME: these data should be taken from the image_data,

       rather than hardcode this here. */

        /*set_pixel_order(gui_data->rdata, PO_BE);*/

        set_byte_order(gui_data->vts[vtid].rdata, BO_LE);

        set_color_order(gui_data->vts[vtid].rdata, CO_RGB);

        set_src_bpp(gui_data->vts[vtid].rdata, BPP_SRC_32);

    /* **** */

    gui_update_guest_display(&gui_data->vts[vtid]);

}

static void gui_update_guest_display(vt_t *vt)

{

    if (!nographic && vt->gui_ds.depth != 0) {

        render(&vt->gui_ds, vt->rdata, vt->full_update);

        vt->full_update = 0;

    }

}

enum what_buffer_t {

    FROM_BG_BUFFER,

    FROM_DEF_BG_IMAGE

};

static inline char* calc_bg_area_address(VtID vtid, const gui_area_t *area, enum what_buffer_t what_buffer)

{

    return (what_buffer == FROM_BG_BUFFER ? 

                (char*)gui_data->vts[vtid].background_buffer :

                (char*)gui_data->vts[vtid].images[DEF_BACKGROUND_IMAGE].image) +

        area->y0 * gui_data->vts[vtid].background_row_size +

        area->x0 * 4;

}

static void paint_rectangle(VtID vtid, gui_area_t *area, const void* source, int src_row_size)

{

    const int area_height = GET_GUI_AREA_HEIGHT(area);

    const int area_row_size = src_row_size > 0 ? src_row_size : GET_GUI_AREA_WIDTH(area) * 4;

    char* dest = calc_bg_area_address(vtid, area, FROM_BG_BUFFER);

    const char* src = (const char*)source;

    int y = 0;

    for (y=0; y < area_height; y++) {

        memcpy(dest, src, area_row_size);

        dest += gui_data->vts[vtid].background_row_size;

        src += area_row_size;

    }

}

void gui_show_image(VtID vtid, ImageID id)

{

    if (id == DEF_BACKGROUND_IMAGE) {

        /* background is the whole DS */

        memcpy(gui_data->vts[vtid].background_buffer,

               gui_data->vts[vtid].images[id].image, 

                   gui_data->vts[vtid].background_row_size *

                   GET_GUI_AREA_HEIGHT(&gui_data->vts[vtid].images[id].area));

    } else {

        paint_rectangle(vtid,

                        &gui_data->vts[vtid].images[id].area, 

                        gui_data->vts[vtid].images[id].image, 

                        0);

    }

    gui_data->vts[vtid].images[id].visible = 1;

    gui_data->vts[vtid].full_update = 1;    /* DFG TODO: IMPROVE! */

}

void gui_hide_image(VtID vtid, ImageID id)

{

    /* restore the background there */

    paint_rectangle(vtid,

                    &gui_data->vts[vtid].images[id].area, 

                    calc_bg_area_address(vtid,

                                         &gui_data->vts[vtid].images[id].area,

                                         FROM_DEF_BG_IMAGE),

                    gui_data->vts[vtid].background_row_size);

    gui_data->vts[vtid].images[id].visible = 0;

    gui_data->vts[vtid].full_update = 1;    /* DFG TODO: IMPROVE! */

}

int gui_register_mouse_event_handler(QEMUPutMouseEvent *func,

                                     void *opaque, int absolute,

                                     const char *devname)

{

    if (gui_data->loaded) {

        int found = 0;

        VtID vtid = 0;

        int parea;

        while (!found && vtid < gui_data->n_vts) {

            parea = 0;

            while (!found && parea < gui_data->vts[vtid].n_pointerareas) {

                found = (strcmp(gui_data->vts[vtid].pointerareas[parea].devid, devname) == 0);

                if (!found)

                    parea++;

            }

            if (!found)

                vtid++;

        }

        if (found) {

            gui_data->vts[vtid].pointerareas[parea].callback = func;

            gui_data->vts[vtid].pointerareas[parea].absolute = absolute;

            gui_data->vts[vtid].pointerareas[parea].opaque = opaque;

        } else {

            fprintf(stderr, "Warning: pointer device %s not accepted by the gui. Device ignored.\n", devname);

        }

        return found;

    } else {