ui/gtk/menu.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2017 Olaf Wintermann. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <stdarg.h>

#include "menu.h"
#include "toolkit.h"
#include "widget.h"
#include "../common/context.h"
#include "../common/menu.h"
#include "../common/types.h"
#include "../common/action.h"
#include "../ui/properties.h"
#include "../ui/window.h"
#include "container.h"

#include <cx/linked_list.h>
#include <cx/array_list.h>
#include <cx/printf.h>

static void contextmenu_handler(GtkWidget *widget) {
    UiContextMenuPopupCallback *cb = g_object_get_data(G_OBJECT(widget), "ui_contextmenu_handler");
    if(cb && cb->callback) {
        cb->callback(NULL, cb->userdata);
    }
}

#if GTK_MAJOR_VERSION <= 3

static ui_menu_add_f createMenuItem[] = {
    /* UI_MENU                 */ add_menu_widget,
    /* UI_MENU_ITEM            */ add_menuitem_widget,
    /* UI_MENU_CHECK_ITEM      */ add_checkitem_widget,
    /* UI_MENU_RADIO_ITEM      */ add_radioitem_widget,
    /* UI_MENU_ITEM_LIST       */ add_menuitem_list_widget,
    /* UI_MENU_CHECKITEM_LIST  */ add_menuitem_list_widget,
    /* UI_MENU_RADIOITEM_LIST  */ add_menuitem_list_widget,
    /* UI_MENU_SEPARATOR       */ add_menuseparator_widget
};

// private menu functions
GtkWidget *ui_create_menubar(UiObject *obj) {
    UiMenu *menus_begin = uic_get_menu_list();
    if(menus_begin == NULL) {
        return NULL;
    }
    
    GtkWidget *mb = gtk_menu_bar_new();
    
    UiMenu *ls = menus_begin;
    while(ls) {
        UiMenu *menu = ls;
        add_menu_widget(mb, 0, &menu->item, obj);
        
        ls = (UiMenu*)ls->item.next;
    }
    
    return mb;
}

void ui_add_menu_items(GtkWidget *parent, int i, UiMenu *menu, UiObject *obj) {
    UiMenuItemI *it = menu->items_begin;
    int index = 0;
    while(it) {
        createMenuItem[it->type](parent, index, it, obj);
        it = it->next;
        index++;
    }
}

void add_menu_widget(GtkWidget *parent, int i, UiMenuItemI *item, UiObject *obj) {
    UiMenu *menu = (UiMenu*)item;
    
    GtkWidget *menu_widget = gtk_menu_new();
    GtkWidget *menu_item = gtk_menu_item_new_with_mnemonic(menu->label);
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu_widget);
    
    ui_add_menu_items(menu_widget, i, menu, obj);
    
    
    gtk_menu_shell_append(GTK_MENU_SHELL(parent), menu_item);
}

void add_menuitem_widget(GtkWidget *parent, int index, UiMenuItemI *item, UiObject *obj) {
    UiMenuItem *i = (UiMenuItem*)item;
    
    //GtkWidget *widget = gtk_menu_item_new_with_label(i->title);
    GtkWidget *widget = gtk_menu_item_new_with_mnemonic(i->label);
    
    if(i->callback != NULL) {
        UiEventData *event = malloc(sizeof(UiEventData));
        event->obj = obj;
        event->userdata = i->userdata;
        event->callback = i->callback;
        event->value = 0;
        event->customdata = NULL;

        g_signal_connect(
                widget,
                "activate",
                G_CALLBACK(ui_menu_event_wrapper),
                event);
        g_signal_connect(
                widget,
                "destroy",
                G_CALLBACK(ui_destroy_userdata),
                event);
    }
    
    gtk_menu_shell_append(GTK_MENU_SHELL(parent), widget);
    
    if(i->states) {
        CxList *states = cxArrayListCreate(NULL, sizeof(int), i->nstates);
        cxListAddArray(states, i->states, i->nstates);
        uic_add_state_widget(obj->ctx, widget, (ui_enablefunc)ui_set_enabled, states);
        cxListFree(states);
    }
}

void add_menuseparator_widget(
        GtkWidget *parent,
        int index,
        UiMenuItemI *item,
        UiObject *obj)
{
    gtk_menu_shell_append(
            GTK_MENU_SHELL(parent),
            gtk_separator_menu_item_new());
}

void add_checkitem_widget(GtkWidget *p, int index, UiMenuItemI *item, UiObject *obj) {
    UiMenuCheckItem *ci = (UiMenuCheckItem*)item;
    GtkWidget *widget = gtk_check_menu_item_new_with_mnemonic(ci->label);
    gtk_menu_shell_append(GTK_MENU_SHELL(p), widget);
    
    UiVarEventData *event = malloc(sizeof(UiVarEventData));
    memset(event, 0, sizeof(UiVarEventData));
    event->obj = obj;
    event->userdata = ci->userdata;
    event->callback = ci->callback;
    event->var = uic_widget_var(obj->ctx, obj->ctx, NULL, ci->varname, UI_VAR_INTEGER);
    if(event->var) {
        UiInteger *v = event->var->value;
        v->obj = widget;
        v->get = ui_checkitem_get;
        v->set = ui_checkitem_set;
        if(v->value != 0) {
            gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), TRUE);
        }
    }

    g_signal_connect(
            widget,
            "toggled",
            G_CALLBACK(ui_menu_event_toggled),
            event);
    g_signal_connect(
            widget,
            "destroy",
            G_CALLBACK(ui_destroy_userdata),
            event);
}

static void ui_menu_event_radio_item_toggled(GtkRadioMenuItem *ri, UiVarEventData *event) {
    UiInteger *i = event->var->value;
    
    UiEvent evt;
    evt.obj = event->obj;
    evt.window = event->obj->window;
    evt.document = event->obj->ctx->document;
    evt.eventdata = i;
    evt.eventdatatype = i ? UI_EVENT_DATA_INTEGER_VALUE : 0;
    evt.intval = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(ri));
    
    if(event->callback) {
        event->callback(&evt, event->userdata);
    }
    
    if(evt.intval) {
        evt.intval = ui_get(i);
        ui_notify_evt(i->observers, &evt);
    }
}

static void ui_destroy_menu_radio_item(GtkWidget *unused, UiVarEventData *event) {
    if(event->customint1) {
        uic_unbind_var(event->var);
    }
    free(event);
}

void add_radioitem_widget(GtkWidget *p, int index, UiMenuItemI *item, UiObject *obj) {
    UiMenuRadioItem *ri = (UiMenuRadioItem*)item;
    
    UiVar *var = uic_widget_var(obj->ctx, obj->ctx, NULL, ri->varname, UI_VAR_INTEGER);
    if(!var) {
        fprintf(stderr, "Error: menu radioitem varname is null\n");
        return;
    }
    int first = 0;
    UiInteger *i = var->value;
    GSList *group = i->obj;
    GtkWidget *widget = gtk_radio_menu_item_new_with_label(group, ri->label);
    gtk_menu_shell_append(GTK_MENU_SHELL(p), widget);
    if(!group) {
        i->get = ui_radioitem_get;
        i->set = ui_radioitem_set;
        first = 1;
    }
    i->obj = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(widget));
    
    UiVarEventData *event = malloc(sizeof(UiVarEventData));
    memset(event, 0, sizeof(UiVarEventData));
    event->obj = obj;
    event->var = var;
    event->callback = ri->callback;
    event->userdata = ri->userdata;
    event->customint1 = first;
    
    g_signal_connect(
            widget,
            "toggled",
            G_CALLBACK(ui_menu_event_radio_item_toggled),
            event);
    g_signal_connect(
            widget,
            "destroy",
            G_CALLBACK(ui_destroy_menu_radio_item),
            event);
}

static void menuitem_list_remove_binding(void *obj) {
    UiActiveMenuItemList *ls = obj;
    UiList *list = ls->var->value;
    CxList *bindings = list->obj;
    if(bindings) {
        (void)cxListFindRemove(bindings, obj);
        if(cxListSize(bindings) == 0) {
            cxListFree(bindings);
            list->obj = NULL;
            list->update = NULL;
        }
    }
}

void add_menuitem_list_widget(GtkWidget *p, int index, UiMenuItemI *item, UiObject *obj) {
    UiMenuItemList *il = (UiMenuItemList*)item;
    const CxAllocator *a = obj->ctx->allocator;
    
    UiActiveMenuItemList *ls = cxMalloc(
            a,
            sizeof(UiActiveMenuItemList));
    
    ls->object = obj;
    ls->menu = GTK_MENU_SHELL(p);
    ls->index = index;
    ls->oldcount = 0;
    ls->getvalue = il->getvalue;
    ls->getvaluedata = il->getvaluedata;
    
    UiVar* var = uic_create_var(ui_global_context(), il->varname, UI_VAR_LIST);
    //UiVar* var = uic_create_var(obj->ctx, il->varname, UI_VAR_LIST);
    ls->var = var;
    if(var) {
        UiList *list = var->value;
        list->update = ui_menulist_update;
        list->getselection = NULL;
        list->setselection = NULL;
        
        // It is possible, that the UiVar is from a global shared context,
        // used by multiple windows. To support this usecase, the list->obj
        // binding object is a list of all connected UiActiveMenuItemList.
        CxList *bindings = list->obj;
        if(!bindings) {
            bindings = cxLinkedListCreate(var->from_ctx->mp->allocator, CX_STORE_POINTERS);
            list->obj = bindings;
        }
        cxListAdd(bindings, ls);
        
        // The destruction of the toplevel obj must remove the menulist binding
        uic_context_add_destructor(obj->ctx, menuitem_list_remove_binding, ls);
        
        ui_update_menuitem_list(ls);
    }
    
    ls->callback = il->callback;
    ls->userdata = il->userdata;
}

void ui_menulist_update(UiList *list, int ignored) {
    CxList *bindings = list->obj;
    CxIterator i = cxListIterator(bindings);
    cx_foreach(UiActiveMenuItemList *, ls, i) {
        ui_update_menuitem_list(ls);
    }
}


void ui_update_menuitem_list(UiActiveMenuItemList *list) {    
    // remove old items
    if(list->oldcount > 0) {
        int i = 0;
        GList *mi = gtk_container_get_children(GTK_CONTAINER(list->menu));
        while(mi) {
            if(i >= list->index && i < list->index + list->oldcount) {
                //gtk_container_remove(GTK_CONTAINER(list->menu), mi->data);
                gtk_widget_destroy(mi->data);
            }
            mi = mi->next;
            i++;
        }
    }
    
    UiList *ls = list->var->value;
    
    void* elm = ui_list_first(ls);
    if(elm) {
        GtkWidget *widget = gtk_separator_menu_item_new();
        gtk_menu_shell_insert(list->menu, widget, list->index);
        gtk_widget_show(widget);
    }
    
    ui_getvaluefunc2 getvalue = list->getvalue;
    void *getvaluedata = list->getvaluedata;
    int i = 1;
    int row = 0;
    while(elm) {
        UiBool freeResult = FALSE;
        char *label = (char*) (getvalue ? getvalue(ls, elm, row, 0, getvaluedata, &freeResult) : elm);
        
        GtkWidget *widget = gtk_menu_item_new_with_label(label);
        gtk_menu_shell_insert(list->menu, widget, list->index + i);
        gtk_widget_show(widget);
        
        if(list->callback) {
            UiEventData *event = malloc(sizeof(UiEventData));
            event->obj = list->object;
            event->userdata = list->userdata;
            event->callback = list->callback;
            event->value = i - 1;
            event->customdata = elm;
            event->customint = UI_EVENT_DATA_LIST_ELM;

            g_signal_connect(
                widget,
                "activate",
                G_CALLBACK(ui_menu_event_wrapper),
                event);
            g_signal_connect(
                widget,
                "destroy",
                G_CALLBACK(ui_destroy_userdata),
                event);
        }
        
        elm = ui_list_next(ls);
        i++;
        row++;
        
        if(freeResult) {
            free(label);
        }
    }
    
    list->oldcount = i;
}

void ui_menu_event_wrapper(GtkMenuItem *item, UiEventData *event) {
    UiEvent evt;
    evt.obj = event->obj;
    evt.window = event->obj->window;
    evt.document = event->obj->ctx->document;
    if(event->customdata) {
        evt.eventdata = event->customdata;
        evt.eventdatatype = event->customint;
    } else {
        evt.eventdata = uic_get_tmp_eventdata();
        evt.eventdatatype = uic_get_tmp_eventdata_type();
    }
    evt.eventdata = event->customdata;
    evt.intval = event->value;
    event->callback(&evt, event->userdata);   
    uic_set_tmp_eventdata(NULL, 0);
}

void ui_menu_event_toggled(GtkCheckMenuItem *ci, UiVarEventData *event) {
    UiInteger *i = event->var ? event->var->value : NULL;
    
    UiEvent evt;
    evt.obj = event->obj;
    evt.window = event->obj->window;
    evt.document = event->obj->ctx->document;
    evt.eventdata = i;
    evt.eventdatatype = i ? UI_EVENT_DATA_INTEGER_VALUE : 0;
    evt.intval = gtk_check_menu_item_get_active(ci);
    if(event->callback) {
        event->callback(&evt, event->userdata);
    }
    
    if(i) {
        ui_notify_evt(i->observers, &evt);
    }
}

int64_t ui_checkitem_get(UiInteger *i) {
    int state = gtk_check_menu_item_get_active(i->obj);
    i->value = state;
    return state;
}

void ui_checkitem_set(UiInteger *i, int64_t value) {
    i->value = value;
    gtk_check_menu_item_set_active(i->obj, (gboolean)value);
}

int64_t ui_radioitem_get(UiInteger *value) {
    int selection = 0;
    GSList *ls = value->obj;
    guint len = g_slist_length(ls);
    int i = 0;
    while(ls) {
        if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(ls->data))) {
            selection = len - i;
            break;
        }
        ls = ls->next;
        i++;
    }
    
    value->value = selection;
    return selection;
}

void ui_radioitem_set(UiInteger *i, int64_t value) {
    GSList *ls = i->obj;
    
    int len = g_slist_length(ls);
    if(value > len) {
        value = len;
    }
    int s = len - value;
    int j = 0;
    int unset = 1;
    while(ls) {
        if(j == s) {
            gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ls->data), TRUE);
            unset = 0;
            break;
        }
        ls = ls->next;
        j++;
    }
    
    i->value = value;
}


/*
 * widget menu functions
 */

UIMENU ui_contextmenu_create(UiMenuBuilder *builder, UiObject *obj, UIWIDGET widget) {
    GtkWidget *menu_widget = gtk_menu_new();
    ui_add_menu_items(menu_widget, 0, builder->menus_begin, obj);
    g_object_ref_sink(menu_widget);
    g_object_set_data_full(
            G_OBJECT(widget),
            "ui_context_menu",
            menu_widget,
            (GDestroyNotify)g_object_unref);
    return GTK_MENU(menu_widget);
}

static gboolean ui_button_press_event(GtkWidget *widget, GdkEvent *event, GtkMenu *menu) {
    if(event->type == GDK_BUTTON_PRESS) {
        GdkEventButton *e = (GdkEventButton*)event;
        if(e->button == 3) {
            gtk_widget_show_all(GTK_WIDGET(menu));
            ui_contextmenu_popup(menu, widget, 0, 0);
        }
    }
    return FALSE;
}

void ui_widget_set_contextmenu(GtkWidget *widget, GtkMenu *menu) {
    g_signal_connect(widget, "button-press-event", (GCallback) ui_button_press_event, menu);
}

void ui_contextmenu_popup(UIMENU menu, GtkWidget *widget, int x, int y) {
    contextmenu_handler(widget);
    gtk_widget_show_all(GTK_WIDGET(menu));
#if GTK_MAJOR_VERSION >= 3 && GTK_MINOR_VERSION >= 16
    gtk_menu_popup_at_pointer(menu, NULL);
#else
    gtk_menu_popup(menu, NULL, NULL, 0, 0, 0, gtk_get_current_event_time());
#endif
}

#endif /* GTK_MAJOR_VERSION <= 3 */


#if GTK_MAJOR_VERSION >= 4

GtkWidget *ui_create_menubar(UiObject *obj) {
    UiMenu *menus_begin = uic_get_menu_list();
    if(menus_begin == NULL) {
        return NULL;
    }
    
    GMenu *menu = g_menu_new();
    UiMenu *ls = menus_begin;
    while(ls) {
        GMenu *sub_menu = g_menu_new();
        ui_gmenu_add_menu_items(sub_menu, 0, ls, obj);
        g_menu_append_submenu(menu, ls->label, G_MENU_MODEL(sub_menu));
        ls = (UiMenu*)ls->item.next;
    }
    

    // Create a menubar from the menu model
    return gtk_popover_menu_bar_new_from_model(G_MENU_MODEL(menu));
}

static ui_gmenu_add_f createMenuItem[] = {
    /* UI_MENU                 */ ui_gmenu_add_menu,
    /* UI_MENU_ITEM            */ ui_gmenu_add_menuitem,
    /* UI_MENU_CHECK_ITEM      */ ui_gmenu_add_checkitem,
    /* UI_MENU_RADIO_ITEM      */ ui_gmenu_add_radioitem,
    /* UI_MENU_ITEM_LIST       */ ui_gmenu_add_menuitem_list,
    /* UI_MENU_CHECKITEM_LIST  */ ui_gmenu_add_menuitem_list,
    /* UI_MENU_RADIOITEM_LIST  */ ui_gmenu_add_menuitem_list,
    /* UI_MENU_SEPARATOR       */ ui_gmenu_add_menuseparator
};

void ui_gmenu_add_menu_items(GMenu *parent, int i, UiMenu *menu, UiObject *obj) {
    UiMenuItemI *it = menu->items_begin;
    int index = 0;
    int index_section = 0;
    GMenu *section = NULL;
    while(it) {
        if(it->type == UI_MENU_SEPARATOR) {
            if(section) {
                g_object_unref(section);
            }
            section = g_menu_new();
            g_menu_append_section(parent, NULL, G_MENU_MODEL(section));
            index++;
            index_section = 0;
        } else {
            if(section) {
                createMenuItem[it->type](section, index_section++, it, obj);
            } else {
                createMenuItem[it->type](parent, index++, it, obj);
            }
        }
        it = it->next;
    }
    if(section) {
        g_object_unref(section);
    }
}

void ui_gmenu_add_menu(GMenu *parent, int index, UiMenuItemI *item, UiObject *obj) {
    UiMenu *mi = (UiMenu*)item;
    GMenu *menu = g_menu_new();
    ui_gmenu_add_menu_items(menu, 0, mi, obj);
    g_menu_append_submenu(parent, mi->label, G_MENU_MODEL(menu));
    g_object_unref(menu);
}

static void action_enable(GSimpleAction *action, int enabled) {
    g_simple_action_set_enabled(action, enabled);
}

void ui_gmenu_add_menuitem(GMenu *parent, int index, UiMenuItemI *item, UiObject *obj) {
    UiMenuItem *i = (UiMenuItem*)item;
     
    GSimpleAction *action = g_simple_action_new(item->id, NULL);
    g_action_map_add_action(obj->ctx->action_map, G_ACTION(action));
    g_object_unref(action);
    
    if(i->states) {
        CxList *groups = cxArrayListCreate(NULL, sizeof(int), i->nstates);
        cxListAddArray(groups, i->states, i->nstates);
        uic_add_state_widget(obj->ctx, action, (ui_enablefunc)action_enable, groups);
        cxListFree(groups);
    }
    
    if(i->action) {
        uic_bind_action(obj->ctx, i->action, action, (ui_enablefunc)action_enable);
        UiAction *ui_action = uic_resolve_action(obj->ctx, i->action);
        if(!ui_action) {
            action_enable(action, FALSE);
        }
    }
     
    if(i->callback != NULL || i->action) {
        UiEventData *event = malloc(sizeof(UiEventData));
        event->obj = obj;
        event->userdata = i->userdata;
        event->callback = i->callback;
        event->value = 0;
        event->customdata = NULL;
        event->customint = 0;
        event->action = i->action ? strdup(i->action) : NULL;

        g_signal_connect(
                action,
                "activate",
                G_CALLBACK(ui_activate_event_wrapper),
                event);
        g_signal_connect(
                obj->widget,
                "destroy",
                G_CALLBACK(ui_destroy_eventdata),
                event);
    }
    
    char action_name[32];
    snprintf(action_name, 32, "win.%s", item->id);
     
    g_menu_append(parent, i->label, action_name);
}

void ui_gmenu_add_menuseparator(GMenu *p, int index, UiMenuItemI *item, UiObject *obj) {
    
}

void ui_gmenu_add_checkitem(GMenu *p, int index, UiMenuItemI *item, UiObject *obj) {
    UiMenuCheckItem *checkitem = (UiMenuCheckItem*)item;
    
    // TODO
}


typedef struct UiCallbackData {
    ui_callback callback;
    void *userdata;
} UiCallbackData;

static void radiogroup_remove_binding(void *obj) {
    UiMenuRadioGroup *group = obj;
    if(group->var) {
        UiInteger *i = group->var->value;
        CxList *bindings = i->obj;
        if(bindings) {
            (void)cxListFindRemove(bindings, obj);
        }
    }
}

static void stateful_action_notify_group(UiMenuRadioGroup *group, UiInteger *i) {
    int intval = ui_get(i);
    
    UiEvent event;
    event.obj = group->obj;
    event.window = event.obj->window;
    event.document = event.obj->ctx->document;
    event.eventdata = NULL;
    event.eventdatatype = 0;
    event.set = ui_get_setop();
    
    CxIterator iter = cxListIterator(group->callbacks);
    cx_foreach(UiCallbackData *, cb, iter) {
        event.intval = intval-1 == iter.index;
        if(cb->callback) {
            cb->callback(&event, cb->userdata);
        }
    }
    
    event.intval = intval;
    UiObserver *obs = i->observers;
    while(obs) {
        if(obs->callback) {
            obs->callback(&event, obs->data);
        }
        obs = obs->next;
    }
}

static void ui_action_set_state(UiInteger *i, int64_t value) {
    i->value = value;
    CxList *bindings = i->obj;
    CxIterator iter = cxListIterator(bindings);
    cx_foreach(UiMenuRadioGroup *, group, iter) {
        char buf[32];
        snprintf(buf, 32, "%d", (int)value);
        GVariant *state = g_variant_new_string(buf);
        g_action_change_state(G_ACTION(group->action), state);
        stateful_action_notify_group(group, i);
    }
}

static int64_t ui_action_get_state(UiInteger *i) {
    return i->value;
}

static UiMenuRadioGroup* create_radio_group(UiObject *obj, UiMenuRadioItem *item, GSimpleAction *action) {
    UiMenuRadioGroup *group = cxZalloc(obj->ctx->allocator, sizeof(UiMenuRadioGroup));
    group->callbacks = cxArrayListCreate(obj->ctx->allocator, sizeof(UiCallbackData), 8);
    group->var = uic_create_var(ui_global_context(), item->varname, UI_VAR_INTEGER);
    group->obj = obj;
    group->action = action;
    if(group->var) {
        UiInteger *i = group->var->value;
        CxList *bindings = i->obj;
        if(!bindings) {
            bindings = cxLinkedListCreate(group->var->from_ctx->mp->allocator, CX_STORE_POINTERS);
            i->obj = bindings;
            i->set = ui_action_set_state;
            i->get = ui_action_get_state;
        }
        cxListAdd(bindings, group);
        // the destruction of the toplevel obj must remove the binding
        uic_context_add_destructor(obj->ctx, radiogroup_remove_binding, group);
    }
    return group;
}

static void stateful_action_activate(
        GSimpleAction *action,
        GVariant      *state,
        UiMenuRadioGroup *group)
{
    g_simple_action_set_state(action, state);
    
    UiVar *var = group->var;
    if(!var) {
        return;
    }
    UiInteger *i = var->value;
    
    gsize len;
    const char *s = g_variant_get_string(state, &len);
    cxstring value = cx_strn(s, len);
    int v;
    if(!cx_strtoi(value, &v, 10)) {
        i->value = v;
    }
    
    CxList *bindings = i->obj;
    CxIterator iter = cxListIterator(bindings);
    cx_foreach(UiMenuRadioGroup *, gr, iter) {
        stateful_action_notify_group(gr, i);
    }
}


void ui_gmenu_add_radioitem(GMenu *parent, int index, UiMenuItemI *item, UiObject *obj) {
    UiMenuRadioItem *i = (UiMenuRadioItem*)item;
    
    if(!i->varname) {
        return;
    }

    // All radio buttons with the name varname use the same GAction
    UiMenuRadioGroup *group = NULL;
    GAction *action = g_action_map_lookup_action(obj->ctx->action_map, i->varname);
    if(!action) {
        GVariant *state = g_variant_new_string("0");
        GSimpleAction *newAction = g_simple_action_new_stateful(i->varname, G_VARIANT_TYPE_STRING, state);
        g_action_map_add_action(obj->ctx->action_map, G_ACTION(newAction));
        g_object_unref(newAction);

        group = create_radio_group(obj, i, newAction);
        g_object_set_data(G_OBJECT(newAction), "ui_radiogroup", group);

        g_signal_connect(
                newAction,
                "change-state",
                G_CALLBACK(stateful_action_activate),
                group);
    } else {
        group = g_object_get_data(G_OBJECT(action), "ui_radiogroup");
        if(!group) {
            fprintf(stderr, "Error: missing ui_radiogroup property for action %s\n", i->varname);
            return; // error, should not happen
        }
    }
    
    size_t item_index = cxListSize(group->callbacks);
    
    UiCallbackData cb;
    cb.callback = i->callback;
    cb.userdata = i->userdata;
    cxListAdd(group->callbacks, &cb);
    
    
    cxmutstr action_name = cx_asprintf("win.%s::%d", i->varname, (int)item_index+1);
    g_menu_append(parent, i->label, action_name.ptr);
    free(action_name.ptr);
}

static void menuitem_list_remove_binding(void *obj) {
    UiActiveGMenuItemList *ls = obj;
    UiList *list = ls->var->value;
    CxList *bindings = list->obj;
    if(bindings) {
        (void)cxListFindRemove(bindings, obj);
        if(cxListSize(bindings) == 0) {
            cxListFree(bindings);
            list->obj = NULL;
            list->update = NULL;
        }
    }
}

void ui_gmenu_add_menuitem_list(GMenu *p, int index, UiMenuItemI *item, UiObject *obj) {
    UiMenuItemList *il = (UiMenuItemList*)item; 
    
    const CxAllocator *a = obj->ctx->allocator;
    
    UiActiveGMenuItemList *ls = cxMalloc(
            a,
            sizeof(UiActiveGMenuItemList));
    
    ls->object = obj;
    ls->menu = p;
    ls->index = index;
    ls->oldcount = 0;
    ls->getvalue = il->getvalue;
    ls->getvaluedata = il->getvalue;
    
    GSimpleAction *action = g_simple_action_new(item->id, g_variant_type_new("i"));
    g_action_map_add_action(obj->ctx->action_map, G_ACTION(action));
    g_object_unref(action);
    snprintf(ls->action, 32, "win.%s", item->id);
    
    UiVar* var = uic_create_var(ui_global_context(), il->varname, UI_VAR_LIST);
    //UiVar* var = uic_create_var(obj->ctx, il->varname, UI_VAR_LIST);
    ls->var = var;
    if(var) {
        UiList *list = var->value;
        list->update = ui_menulist_update;
        list->getselection = NULL;
        list->setselection = NULL;
        
        // It is possible, that the UiVar is from a global shared context,
        // used by multiple windows. To support this usecase, the list->obj
        // binding object is a list of all connected UiActiveMenuItemList.
        CxList *bindings = list->obj;
        if(!bindings) {
            bindings = cxLinkedListCreate(var->from_ctx->mp->allocator, CX_STORE_POINTERS);
            list->obj = bindings;
        }
        cxListAdd(bindings, ls);
        
        // The destruction of the toplevel obj must remove the menulist binding
        uic_context_add_destructor(obj->ctx, menuitem_list_remove_binding, ls);
        
        ui_update_gmenu_item_list(ls);
    }
    
    ls->callback = il->callback;
    ls->userdata = il->userdata;
    
    
    UiEventData *event = malloc(sizeof(UiEventData));
    event->obj = obj;
    event->userdata = il->userdata;
    event->callback = il->callback;
    event->customdata = var;
    event->customint = 0;
    event->value = 0;
    
    g_signal_connect(
            action,
            "activate",
            G_CALLBACK(ui_menu_list_item_activate_event_wrapper),
            event);
    g_signal_connect(
            obj->widget,
            "destroy",
            G_CALLBACK(ui_destroy_userdata),
            event);
}

void ui_activate_event_wrapper(GSimpleAction* self, GVariant* parameter, UiEventData *event) {
    int intval = event->value;
    if(parameter && g_variant_is_of_type(parameter, G_VARIANT_TYPE_INT32)) {
        intval = g_variant_get_int32(parameter);
    }
    
    UiEvent evt;
    evt.obj = event->obj;
    evt.window = event->obj->window;
    evt.document = event->obj->ctx->document;
    if(event->customdata) {
        evt.eventdata = event->customdata;
        evt.eventdatatype = event->customint;
    } else {
        evt.eventdata = uic_get_tmp_eventdata();
        evt.eventdatatype = uic_get_tmp_eventdata_type();
    }
    evt.intval = intval;
    if(event->callback) {
        event->callback(&evt, event->userdata);
    }
    if(event->action) {
        uic_action_callback(&evt, event->action);
    }
    uic_set_tmp_eventdata(NULL, 0);
}

void ui_menu_list_item_activate_event_wrapper(GSimpleAction* self, GVariant* parameter, UiEventData *event) {
    int index = g_variant_get_int32(parameter);
    UiVar *var = event->customdata;
    UiList *list = var->value;
    
    if(!event->callback) {
        return;
    }
    
    UiEvent evt;
    evt.obj = event->obj;
    evt.window = event->obj->window;
    evt.document = event->obj->ctx->document;
    evt.eventdata = ui_list_get(list, index);
    evt.eventdatatype = UI_EVENT_DATA_LIST_ELM;
    evt.intval = index;
    event->callback(&evt, event->userdata);    
    
}

void ui_menulist_update(UiList *list, int ignored) {
    CxList *bindings = list->obj;
    CxIterator i = cxListIterator(bindings);
    cx_foreach(UiActiveGMenuItemList *, ls, i) {
        ui_update_gmenu_item_list(ls);
    }
}

void ui_update_gmenu_item_list(UiActiveGMenuItemList *list) {
    // remove old items
    for(int i=0;i<list->oldcount;i++) {
        g_menu_remove(list->menu, list->index);
    }
    UiList *ls = list->var->value;
    
    // add list items
    ui_getvaluefunc2 getvalue = list->getvalue;
    void *getvaluedata = list->getvaluedata;
    int i = 0;
    void* elm = ui_list_first(ls);
    while(elm) {
        UiBool freeResult = FALSE;
        char *label = (char*) (getvalue ? getvalue(ls, elm, i, 0, getvaluedata, &freeResult) : elm);
        
        GMenuItem *item = g_menu_item_new(label, NULL);
        GVariant *v = g_variant_new("i", i);
        g_menu_item_set_action_and_target_value(item, list->action, v);
        g_menu_insert_item(list->menu, list->index+i, item);
        g_object_unref(item);
        
        elm = ui_list_next(ls);
        i++;
        
        if(freeResult) {
            free(label);
        }
    }
    
    list->oldcount = i;
}


/* --------------------- context menu / menubuilder --------------------- */

static void remove_popover(GtkWidget *object, GtkPopoverMenu *menu) {
    gtk_widget_unparent(GTK_WIDGET(menu));
}

UIMENU ui_contextmenu_create(UiMenuBuilder *builder, UiObject *obj, GtkWidget *widget) {
    GMenu *menu = g_menu_new();
    ui_gmenu_add_menu_items(menu, 0, builder->menus_begin, obj);
    GtkWidget *contextmenu = gtk_popover_menu_new_from_model(G_MENU_MODEL(menu));
    g_object_unref(menu);
    gtk_popover_set_has_arrow(GTK_POPOVER(contextmenu), FALSE);
    gtk_widget_set_halign(contextmenu, GTK_ALIGN_START);
    gtk_widget_set_parent(GTK_WIDGET(contextmenu), widget);
    g_signal_connect(
                widget,
                "destroy",
                G_CALLBACK(remove_popover),
                contextmenu);
    return GTK_POPOVER_MENU(contextmenu);
}

static void gesture_button_press(GtkGestureClick *gesture, gint n_press, gdouble x, gdouble y, gpointer user_data) {
    gtk_popover_set_pointing_to(GTK_POPOVER(user_data), &(GdkRectangle){ x, y, 0, 0 });
    gtk_popover_popup(GTK_POPOVER(user_data));
}

void ui_widget_set_contextmenu(GtkWidget *widget, GtkPopoverMenu *menu) {
    GtkGesture *gesture = gtk_gesture_click_new();
    gtk_gesture_single_set_button(GTK_GESTURE_SINGLE(gesture), 3);
    gtk_widget_add_controller(widget, GTK_EVENT_CONTROLLER(gesture));
    g_signal_connect(gesture, "pressed", G_CALLBACK(gesture_button_press), menu);
}

void ui_contextmenu_popup(UIMENU menu, UIWIDGET widget, int x, int y) {
    contextmenu_handler(widget);
    gtk_popover_set_pointing_to(GTK_POPOVER(menu), &(GdkRectangle){ x, y, 0, 0 });
    gtk_popover_popup(GTK_POPOVER(menu));
}

#endif