ui/win32/menu.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2024 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 "menu.h"

#include <cx/array_list.h>

static ui_menu_add_f createMenuItem[] = {
    /* UI_MENU                 */ ui_add_menu,
    /* UI_MENU_ITEM            */ ui_add_menu_item,
    /* UI_MENU_CHECK_ITEM      */ ui_add_menu_checkitem,
    /* UI_MENU_RADIO_ITEM      */ ui_add_menu_radioitem,
    /* UI_MENU_ITEM_LIST       */ ui_add_menu_list,
    /* UI_MENU_CHECKITEM_LIST  */ ui_add_menu_checklist,
    /* UI_MENU_RADIOITEM_LIST  */ ui_add_menu_radiolist,
    /* UI_MENU_SEPARATOR       */ ui_add_menu_separator
};


HMENU ui_create_main_menu(UiObject *obj) {
    UiMenu *menu = uic_get_menu_list();
    if (!menu) {
        return NULL;
    }

    HMENU hMenu = CreateMenu();
    while (menu) {
        ui_add_menu(hMenu, 0, &menu->item, obj);
        UiMenuItemI *next = menu->item.next;
        menu = next && next->type == UI_MENU ? (UiMenu*)next : NULL;
    }

    return hMenu;
}

void ui_add_menu(HMENU parent, int pos, UiMenuItemI *item, UiObject *obj) {
    UiMenu *menu = (UiMenu*)item;
    HMENU hMenu = CreatePopupMenu();
    AppendMenu(parent, MF_POPUP, (UINT_PTR)hMenu, menu->label);
    int i = 0;
    UiMenuItemI *child = menu->items_begin;
    while (child) {
        createMenuItem[child->type](hMenu, i++, child, obj);
        child = child->next;
    }
}

static void menu_item_clicked(UiObject *obj, uint64_t id, UiMenuItem *item) {
    UiEvent event;
    event.obj = obj;
    event.window = obj->window;
    event.document = obj->ctx->document;
    event.eventdata = NULL;
    event.eventdatatype = 0;
    event.intval = 0;
    event.set = 0;
    if (item->callback) {
        item->callback(&event, item->userdata);
    }
}

void ui_add_menu_item(HMENU parent, int pos, UiMenuItemI *item, UiObject *obj) {
    uint64_t id = ++obj->ctx->command_id_counter;

    UiMenuItem *i = (UiMenuItem*)item;
    AppendMenu(parent, MF_STRING, id, i->label);

    UiCommand cmd;
    cmd.callback = (ui_command_func)menu_item_clicked;
    cmd.userdata = i;
    cxMapPut(obj->ctx->command_map, id, &cmd);
}

static void menu_stateitem_update(UiStateMenuItem *item) {
    MENUITEMINFO mi = { 0 };
    mi.cbSize = sizeof(mi);
    mi.fMask = MIIM_STATE;
    mi.fState = item->state ? MFS_CHECKED : MFS_UNCHECKED;
    SetMenuItemInfo(item->menu, item->id, FALSE, &mi);
}

static void menu_checkitem_clicked(UiObject *obj, uint64_t id, UiStateMenuItem *item) {
    item->state = !item->state;
    menu_stateitem_update(item);

    UiEvent event;
    event.obj = obj;
    event.window = obj->window;
    event.document = obj->ctx->document;
    event.eventdata = NULL;
    event.eventdatatype = 0;
    event.intval = 0;
    event.set = 0;
    if (item->onchange) {
        item->onchange(&event, item->userdata);
    }

    if (item->var) {
        UiInteger *i = item->var->value;
        ui_notify_evt(i->observers, &event);
    }
}

void ui_add_menu_checkitem(HMENU parent, int pos, UiMenuItemI *item, UiObject *obj) {
    uint64_t id = ++obj->ctx->command_id_counter;

    UiMenuCheckItem *i = (UiMenuCheckItem*)item;
    AppendMenu(parent, MF_STRING, id, i->label);

    // create an UiStateMenuItem with the same lifetime as the UiObject
    UiStateMenuItem *sitem = ui_malloc(obj->ctx, sizeof(UiStateMenuItem));
    memset(sitem, 0, sizeof(UiStateMenuItem));
    sitem->obj = obj;
    sitem->menu = parent;
    sitem->id = id;
    sitem->onchange = i->callback;
    sitem->userdata = i->userdata;
    sitem->var = uic_widget_var(obj->ctx, obj->ctx, NULL, i->varname, UI_VAR_INTEGER);
    // bind to var
    if (sitem->var) {
        UiInteger *v = sitem->var->value;
        sitem->state = v->value != 0;
        v->obj = sitem;
        v->get = ui_checkitem_get;
        v->set = ui_checkitem_set;
    }

    // register command id
    UiCommand cmd;
    cmd.callback = (ui_command_func)menu_checkitem_clicked;
    cmd.userdata = sitem;
    cxMapPut(obj->ctx->command_map, id, &cmd);

    menu_stateitem_update(sitem);
}

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

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

static void menu_radioitem_clicked(UiObject *obj, uint64_t id, UiStateMenuItem *item) {
    UiInteger *i = item->var->value; // UiVar is always not NULL for radio items
    ui_set(i, item->index+1);

    UiEvent event;
    event.obj = obj;
    event.window = obj->window;
    event.document = obj->ctx->document;
    event.eventdata = i;
    event.eventdatatype = UI_EVENT_DATA_INTEGER_VALUE;
    event.intval = item->state;
    event.set = ui_get_setop();

    if (item->onchange) {
        item->onchange(&event, item->userdata);
    }

    event.intval = (int)ui_get(i);
    ui_notify_evt(i->observers, &event);
}

void ui_add_menu_radioitem(HMENU parent, int pos, UiMenuItemI *item, UiObject *obj) {
    uint64_t id = ++obj->ctx->command_id_counter;

    UiMenuRadioItem *i = (UiMenuRadioItem*)item;
    AppendMenu(parent, MF_STRING, id, i->label);

    UiVar *var = uic_widget_var(obj->ctx, obj->ctx, NULL, i->varname, UI_VAR_INTEGER);
    if (!var) {
        return; // radio item without var is useless
    }

    UiInteger *v = var->value;
    CxList *group = v->obj;
    if (!group) {
        // first radio button in this group
        group = cxArrayListCreate(obj->ctx->allocator, sizeof(UiStateMenuItem), 4);
        v->obj = group;
        v->get = ui_radioitem_get;
        v->set = ui_radioitem_set;
    }

    UiStateMenuItem sitem = { 0 };
    sitem.obj = obj;
    sitem.menu = parent;
    sitem.id = id;
    sitem.onchange = i->callback;
    sitem.userdata = i->userdata;
    sitem.var = var;
    sitem.index = (int)cxListSize(group);
    cxListAdd(group, &sitem);

    if (v->value == sitem.index+1) {
        sitem.state = 1;
        menu_stateitem_update(&sitem);
    }


    UiStateMenuItem *sitem_ptr = cxListAt(group, sitem.index);
    // register command id
    UiCommand cmd;
    cmd.callback = (ui_command_func)menu_radioitem_clicked;
    cmd.userdata = sitem_ptr;
    cxMapPut(obj->ctx->command_map, id, &cmd);
}

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

void ui_radioitem_set(UiInteger *i, int64_t value) {
    CxList *group = i->obj;
    // de-select all items
    CxIterator it = cxListIterator(group);
    cx_foreach(UiStateMenuItem *, item, it) {
        if (item->state) {
            item->state = FALSE;
            menu_stateitem_update(item);
        }
    }

    if (value > 0) {
        UiStateMenuItem *item = cxListAt(group, value-1);
        if (item) {
            item->state = TRUE;
            menu_stateitem_update(item);
        }
    }
}

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 ui_add_menu_list(HMENU parent, int pos, UiMenuItemI *item, UiObject *obj) {
    UiMenuItemList *il = (UiMenuItemList*)item;
    const CxAllocator *a = obj->ctx->allocator;

    UiVar *var = uic_create_var(ui_global_context(), il->varname, UI_VAR_LIST);
    if (!var) {
        return;
    }

    UiActiveMenuItemList *ls = cxMalloc(
            a,
            sizeof(UiActiveMenuItemList));
    ls->object = obj;
    ls->menu = parent;
    ls->command_ids = cxArrayListCreate(a, sizeof(uint64_t), 16);
    ls->index = pos;
    ls->getvalue = il->getvalue;
    ls->callback = il->callback;
    ls->userdata = il->userdata;
    ls->addseparator = il->addseparator;
    ls->var = var;

    UiList *list = ls->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(ls->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);
}

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) {
    UiObject *obj = list->object;

    UiList *ls;
    if(list->var && list->var->value) {
        ls = list->var->value;
    } else {
        return;
    }

    CxIterator i = cxListIterator(list->command_ids);
    cx_foreach(uint64_t *, id, i) {
        DeleteMenu(list->menu, *id, MF_BYCOMMAND);
    }
    cxListClear(list->command_ids); // TODO: we could reuse some of the ids

    ui_getvaluefunc getvalue = list->getvalue;
    void* elm = ui_list_first(ls);

    int pos = list->index;
    while(elm) {
        char *label = (char*) (getvalue ? getvalue(elm, 0) : elm);
        if (!label) {
            label = "";
        }

        uint64_t id = ++obj->ctx->command_id_counter;
        InsertMenu(list->menu, pos++, MF_STRING, id, label);
        cxListAdd(list->command_ids, &id);

        elm = ui_list_next(ls);
    }
}


void ui_add_menu_checklist(HMENU parent, int pos, UiMenuItemI *item, UiObject *obj) {

}

void ui_add_menu_radiolist(HMENU parent, int pos, UiMenuItemI *item, UiObject *obj) {

}

void ui_add_menu_separator(HMENU parent, int pos, UiMenuItemI *item, UiObject *obj) {

}