Makefile- button.c
- button.h
- container.c
- container.h
- display.c
- display.h
- dnd.c
- dnd.h
- draw_cairo.c
- draw_cairo.h
- draw_gdk.c
- draw_gdk.h
- entry.c
- entry.h
- graphics.c
- graphics.h
- headerbar.c
- headerbar.h
- icon.c
- icon.h
- image.c
- image.h
- list.c
- list.h
- menu.c
- menu.h
- objs.mk
- range.c
- range.h
- text.c
- text.h
- toolbar.c
- toolbar.h
- toolkit.c
- toolkit.h
- window.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 "../common/context.h"
#include "../common/menu.h"
#include "../common/types.h"
#include "../ui/properties.h"
#include "../ui/window.h"
#include "container.h"
#include <cx/linked_list.h>
#include <cx/array_list.h>
#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->groups) {
CxList *groups = cxArrayListCreateSimple(sizeof(int), i->ngroups);
cxListAddArray(groups, i->groups, i->ngroups);
uic_add_group_widget(obj->ctx, widget, (ui_enablefunc)ui_set_enabled, groups);
cxListFree(groups);
}
}
/*
void add_menuitem_st_widget(
GtkWidget *parent,
int index,
UiMenuItemI *item,
UiObject *obj)
{
UiStMenuItem *i = (UiStMenuItem*)item;
GtkWidget *widget = gtk_image_menu_item_new_from_stock(i->stockid, obj->ctx->accel_group);
if(i->callback != NULL) {
UiEventData *event = malloc(sizeof(UiEventData));
event->obj = obj;
event->userdata = i->userdata;
event->callback = i->callback;
event->value = 0;
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->groups) {
uic_add_group_widget(obj->ctx, widget, (ui_enablefunc)ui_set_enabled, i->groups);
}
}
*/
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);
if(ci->callback) {
UiEventData *event = malloc(sizeof(UiEventData));
event->obj = obj;
event->userdata = ci->userdata;
event->callback = ci->callback;
event->value = 0;
event->customdata = NULL;
g_signal_connect(
widget,
"toggled",
G_CALLBACK(ui_menu_event_toggled),
event);
g_signal_connect(
widget,
"destroy",
G_CALLBACK(ui_destroy_userdata),
event);
}
}
void add_radioitem_widget(GtkWidget *p, int index, UiMenuItemI *item, UiObject *obj) {
// TODO
}
/*
void add_checkitemnv_widget(GtkWidget *p, int index, UiMenuItemI *item, UiObject *obj) {
UiCheckItemNV *ci = (UiCheckItemNV*)item;
GtkWidget *widget = gtk_check_menu_item_new_with_mnemonic(ci->label);
gtk_menu_shell_append(GTK_MENU_SHELL(p), widget);
UiVar *var = uic_create_var(obj->ctx, ci->varname, UI_VAR_INTEGER);
if(var) {
UiInteger *value = var->value;
value->obj = widget;
value->get = ui_checkitem_get;
value->set = ui_checkitem_set;
value = 0;
} else {
// TODO: error
}
}
*/
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;
UiVar* var = uic_create_var(ui_global_context(), il->varname, UI_VAR_LIST);
ls->list = var->value;
ls->callback = il->callback;
ls->userdata = il->userdata;
UiObserver *observer = ui_observer_new((ui_callback)ui_update_menuitem_list, ls);
ls->list->observers = ui_obsvlist_add(ls->list->observers, observer);
uic_list_register_observer_destructor(obj->ctx, ls->list, observer);
ui_update_menuitem_list(NULL, ls);
}
void ui_update_menuitem_list(UiEvent *event, 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++;
}
}
void* elm = ui_list_first(list->list);
if(elm) {
GtkWidget *widget = gtk_separator_menu_item_new();
gtk_menu_shell_insert(list->menu, widget, list->index);
gtk_widget_show(widget);
}
ui_getvaluefunc getvalue = list->getvalue;
int i = 1;
while(elm) {
char *label = (char*) (getvalue ? getvalue(elm, 0) : 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;
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(list->list);
i++;
}
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;
evt.eventdata = event->customdata;
evt.intval = event->value;
event->callback(&evt, event->userdata);
}
void ui_menu_event_toggled(GtkCheckMenuItem *ci, UiEventData *event) {
UiEvent evt;
evt.obj = event->obj;
evt.window = event->obj->window;
evt.document = event->obj->ctx->document;
evt.eventdata = NULL;
evt.intval = gtk_check_menu_item_get_active(ci);
event->callback(&evt, event->userdata);
}
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, 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);
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) {
#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) {
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;
}
}
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));
}
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));
if(i->groups) {
CxList *groups = cxArrayListCreateSimple(sizeof(int), i->ngroups);
cxListAddArray(groups, i->groups, i->ngroups);
uic_add_group_widget(obj->ctx, action, (ui_enablefunc)action_enable, groups);
cxListFree(groups);
}
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(
action,
"activate",
G_CALLBACK(ui_activate_event_wrapper),
event);
g_signal_connect(
obj->widget,
"destroy",
G_CALLBACK(ui_destroy_userdata),
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
}
void ui_gmenu_add_radioitem(GMenu *p, int index, UiMenuItemI *item, UiObject *obj) {
}
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;
UiVar* var = uic_create_var(ui_global_context(), il->varname, UI_VAR_LIST);
ls->var = var;
UiList *list = var->value;
ls->callback = il->callback;
ls->userdata = il->userdata;
UiObserver *observer = ui_observer_new((ui_callback)ui_update_gmenu_item_list, ls);
list->observers = ui_obsvlist_add(list->observers, observer);
uic_list_register_observer_destructor(obj->ctx, list, observer);
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));
snprintf(ls->action, 32, "win.%s", item->id);
UiEventData *event = malloc(sizeof(UiEventData));
event->obj = obj;
event->userdata = il->userdata;
event->callback = il->callback;
event->customdata = var;
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);
ui_update_gmenu_item_list(NULL, ls);
}
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;
evt.eventdata = event->customdata;
evt.intval = intval;
event->callback(&evt, event->userdata);
}
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;
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.intval = index;
event->callback(&evt, event->userdata);
}
void ui_update_gmenu_item_list(UiEvent *event, 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_getvaluefunc getvalue = list->getvalue;
int i = 0;
void* elm = ui_list_first(ls);
while(elm) {
char *label = (char*) (getvalue ? getvalue(elm, 0) : 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);
elm = ui_list_next(ls);
i++;
}
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));
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) {
gtk_popover_set_pointing_to(GTK_POPOVER(menu), &(GdkRectangle){ x, y, 0, 0 });
gtk_popover_popup(GTK_POPOVER(menu));
}
#endif