Mercurial > hg > toolkit / file revision

/*
 * 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();
    ui_add_menu(hMenu, 0, &menu->item, obj);



    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);
        }
    }
}

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

}

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) {

}