self
}
+ pub fn action(&mut self, action: &str) -> &mut Self {
+ let cstr = CString::new(action).unwrap();
+ unsafe {
+ ui_button_args_set_action(self.args, cstr.as_ptr());
+ }
+ self
+ }
+
pub fn visibility_states(&mut self, states: &[i32]) -> &mut Self {
unsafe {
ui_button_args_set_visibility_states(self.args, states.as_ptr(), states.len() as c_int);
self
}
+ pub fn action(&mut self, action: &str) -> &mut Self {
+ let cstr = CString::new(action).unwrap();
+ unsafe {
+ ui_toggle_args_set_action(self.args, cstr.as_ptr());
+ }
+ self
+ }
+
pub fn visibility_states(&mut self, states: &[i32]) -> &mut Self {
unsafe {
ui_toggle_args_set_visibility_states(self.args, states.as_ptr(), states.len() as c_int);
fn ui_button_args_set_labeltype(args: *mut UiButtonArgs, ltype: c_int);
fn ui_button_args_set_onclick(args: *mut UiButtonArgs, callback: UiCallback);
fn ui_button_args_set_onclickdata(args: *mut UiButtonArgs, data: *mut c_void);
+ fn ui_button_args_set_action(args: *mut UiButtonArgs, action: *const c_char);
fn ui_button_args_set_states(args: *mut UiButtonArgs, states: *const c_int, numstates: c_int);
fn ui_button_args_set_visibility_states(args: *mut UiButtonArgs, states: *const c_int, numstates: c_int);
fn ui_button_args_free(args: *mut UiButtonArgs);
fn ui_toggle_args_set_labeltype(args: *mut UiToggleArgs, ltype: c_int);
fn ui_toggle_args_set_onchange(args: *mut UiToggleArgs, callback: UiCallback);
fn ui_toggle_args_set_onchangedata(args: *mut UiToggleArgs, data: *mut c_void);
+ fn ui_toggle_args_set_action(args: *mut UiToggleArgs, action: *const c_char);
fn ui_toggle_args_set_varname(args: *mut UiToggleArgs, varname: *const c_char);
fn ui_toggle_args_set_value(args: *mut UiToggleArgs, ivalue: *mut UiInteger);
fn ui_toggle_args_set_enablestate(args: *mut UiToggleArgs, state: c_int);
action.userdata = userdata;
action.accelerator = accelerator ? ui_strdup(ctx, accelerator) : NULL;
action.accelerator_text = accelerator_text ? ui_strdup(ctx, accelerator_text) : NULL;
+ action.ctx = ctx;
cxMapPut(ctx->actions, name, &action);
cxMapRehash(ctx->actions);
}
UiContext *ctx,
const char *action,
void *bind_obj,
- ui_action_binding_set_enabled_func set_enabled,
- ui_action_binding_set_accelerator_text_func set_accelerator_text)
+ ui_enablefunc set_enabled)
{
if(!action) {
return;
binding.action = ui_strdup(ctx, action);
binding.userdata = bind_obj;
binding.set_enabled = set_enabled;
- binding.set_accelerator_text = set_accelerator_text;
cxListAdd(ctx->action_bindings, &binding);
}
+
+UiAction* uic_resolve_action(UiContext *ctx, const char *action) {
+ UiAction *a = NULL;
+ if(ctx->actions) {
+ a = cxMapGet(ctx->actions, action);
+ }
+ // check if any sub-document defines this action
+ // sub-document actions have precedence, the most specific action will
+ // be returned
+ CxIterator i = cxListIterator(ctx->documents);
+ cx_foreach(void *, doc, i) {
+ UiContext *doc_ctx = ui_document_context(doc);
+ UiAction *sub_action = uic_resolve_action(doc_ctx, action);
+ if(sub_action) {
+ a = sub_action;
+ // if one sub-tree has an action, we don't care about other
+ // subtrees
+ break;
+ }
+ }
+
+ if(!a && ctx->parent) {
+ // check parents
+ a = uic_resolve_action_from_parents(ctx, action);
+ }
+
+ return a;
+}
+
+UiAction* uic_resolve_action_from_parents(UiContext *ctx, const char *action) {
+ UiContext *parent = ctx->parent;
+ if(parent == NULL) {
+ return NULL;
+ }
+ if(parent->actions) {
+ UiAction *a = cxMapGet(parent->actions, action);
+ if(a) {
+ return a;
+ }
+ }
+ return uic_resolve_action_from_parents(parent, action);
+}
+
+
+
+void ui_update_action_bindings(UiContext *ctx) {
+ CxIterator i = cxListIterator(ctx->action_bindings);
+ cx_foreach(UiActionBinding*, binding, i) {
+ UiAction *action = uic_resolve_action(ctx, binding->action);
+ if(binding->set_enabled) {
+ binding->set_enabled(binding->userdata, action != NULL);
+ }
+ }
+}
+
+void uic_action_callback(UiEvent *event, const char *action_name) {
+ UiContext *ctx = ui_global_context();
+ if(event->obj) {
+ ctx = event->obj->ctx;
+ }
+
+ UiAction *action = uic_resolve_action(ctx, action_name);
+ if(action) {
+ // override event document: for actions we know that the event is
+ // for a specific document
+ event->document = action->ctx->self_doc;
+ if(action->callback) {
+ action->callback(event, action->userdata);
+ }
+ }
+}
char *accelerator_text;
ui_callback callback;
void *userdata;
+ UiContext *ctx;
};
-typedef void (*ui_action_binding_set_enabled_func)(void *bind_obj, UiBool enabled);
-typedef void (*ui_action_binding_set_accelerator_text_func)(void *bind_obj, const char *text);
struct UiActionBinding {
const char *action;
- ui_action_binding_set_enabled_func set_enabled;
- ui_action_binding_set_accelerator_text_func set_accelerator_text;
+ ui_enablefunc set_enabled;
void *userdata;
};
UiContext *ctx,
const char *action,
void *bind_obj,
- ui_action_binding_set_enabled_func set_enabled,
- ui_action_binding_set_accelerator_text_func set_accelerator_text);
+ ui_enablefunc set_enabled);
+
+UiAction* uic_resolve_action(UiContext *ctx, const char *action);
+UiAction* uic_resolve_action_from_parents(UiContext *ctx, const char *action);
+
+// action event wrapper
+void uic_action_callback(UiEvent *event, const char *action_name);
#ifdef __cplusplus
}
args->onclickdata = onclickdata;
}
+void ui_menuitem_args_set_action(UiMenuItemArgs *args, const char *action) {
+ args->action = strdup(action);
+}
+
void ui_menuitem_args_free(UiMenuItemArgs *args) {
free((void*)args->label);
free((void*)args->icon);
+ free((void*)args->action);
free(args);
}
args->onchangedata = onclickdata;
}
+void ui_menutoggleitem_args_set_action(UiMenuToggleItemArgs *args, const char *action) {
+ args->action = strdup(action);
+}
+
void ui_menutoggleitem_args_free(UiMenuToggleItemArgs *args) {
free((void*)args->label);
free((void*)args->icon);
free((void*)args->varname);
+ free((void*)args->action);
free(args);
}
args->onclickdata = onclickdata;
}
+void ui_button_args_set_action(UiButtonArgs *args, const char *action) {
+ args->action = strdup(action);
+}
+
void ui_button_args_set_states(UiButtonArgs *args, int *states, int numstates) {
args->states = calloc(numstates+1, sizeof(int));
memcpy((void*)args->states, states, numstates * sizeof(int));
free((void*)args->label);
free((void*)args->icon);
free((void*)args->tooltip);
+ free((void*)args->action);
free((void*)args->states);
free((void*)args->visibility_states);
free(args);
args->onchangedata = onchangedata;
}
+void ui_toggle_args_set_action(UiToggleArgs *args, const char *action) {
+ args->action = strdup(action);
+}
+
void ui_toggle_args_set_varname(UiToggleArgs *args, const char *varname) {
args->varname = strdup(varname);
}
free((void*)args->icon);
free((void*)args->tooltip);
free((void*)args->varname);
+ free((void*)args->action);
free((void*)args->states);
free((void*)args->visibility_states);
free(args);
args->onclickdata = userdata;
}
+void ui_linkbutton_args_set_action(UiLinkButtonArgs *args, const char *action) {
+ args->action = strdup(action);
+}
+
void ui_linkbutton_args_set_nofollow(UiLinkButtonArgs *args, UiBool value) {
args->nofollow = value;
}
free((void*)args->style_class);
free((void*)args->label);
free((void*)args->uri);
+ free((void*)args->action);
free((void*)args->varname);
free((void*)args->states);
free(args);
args->onactivatedata = onactivatedata;
}
+void ui_textfield_args_set_onactivate_action(UiTextFieldArgs *args, const char *action) {
+ args->onactivate_action = strdup(action);
+}
+
+void ui_textfield_args_set_onchange_action(UiTextFieldArgs *args, const char *action) {
+ args->onchange_action = action;
+}
+
void ui_textfield_args_set_varname(UiTextFieldArgs *args, const char *varname) {
args->varname = strdup(varname);
}
free((void*)args->name);
free((void*)args->style_class);
free((void*)args->varname);
+ free((void*)args->onactivate_action);
+ free((void*)args->onchange_action);
free((void*)args->states);
free((void*)args->visibility_states);
free(args);
UIEXPORT void ui_menuitem_args_set_icon(UiMenuItemArgs *args, const char *icon);
UIEXPORT void ui_menuitem_args_set_onclick(UiMenuItemArgs *args, ui_callback callback);
UIEXPORT void ui_menuitem_args_set_onclickdata(UiMenuItemArgs *args, void *onclickdata);
+UIEXPORT void ui_menuitem_args_set_action(UiMenuItemArgs *args, const char *action);
UIEXPORT void ui_menuitem_args_free(UiMenuItemArgs *args);
UIEXPORT UiMenuToggleItemArgs* ui_menutoggleitem_args_new(void);
UIEXPORT void ui_menutoggleitem_args_set_varname(UiMenuToggleItemArgs *args, const char *varname);
UIEXPORT void ui_menutoggleitem_args_set_onchange(UiMenuToggleItemArgs *args, ui_callback callback);
UIEXPORT void ui_menutoggleitem_args_set_onchangedata(UiMenuToggleItemArgs *args, void *onchangedata);
+UIEXPORT void ui_menutoggleitem_args_set_action(UiMenuToggleItemArgs *args, const char *action);
UIEXPORT void ui_menutoggleitem_args_free(UiMenuToggleItemArgs *args);
UIEXPORT UiMenuItemListArgs* ui_menuitemlist_args_new(void);
UIEXPORT void ui_button_args_set_labeltype(UiButtonArgs *args, int labeltype);
UIEXPORT void ui_button_args_set_onclick(UiButtonArgs *args, ui_callback callback);
UIEXPORT void ui_button_args_set_onclickdata(UiButtonArgs *args, void *onclickdata);
+UIEXPORT void ui_button_args_set_action(UiButtonArgs *args, const char *action);
UIEXPORT void ui_button_args_set_states(UiButtonArgs *args, int *states, int numstates);
UIEXPORT void ui_button_args_set_visibility_states(UiButtonArgs *args, int *states, int numstates);
UIEXPORT void ui_button_args_free(UiButtonArgs *args);
UIEXPORT void ui_toggle_args_set_labeltype(UiToggleArgs *args, int labeltype);
UIEXPORT void ui_toggle_args_set_onchange(UiToggleArgs *args, ui_callback callback);
UIEXPORT void ui_toggle_args_set_onchangedata(UiToggleArgs *args, void *onchangedata);
+UIEXPORT void ui_toggle_args_set_action(UiToggleArgs *args, const char *action);
UIEXPORT void ui_toggle_args_set_varname(UiToggleArgs *args, const char *varname);
UIEXPORT void ui_toggle_args_set_value(UiToggleArgs *args, UiInteger *value);
UIEXPORT void ui_toggle_args_set_enablestate(UiToggleArgs *args, int state);
UIEXPORT void ui_linkbutton_args_set_uri(UiLinkButtonArgs *args, const char *uri);
UIEXPORT void ui_linkbutton_args_set_onclick(UiLinkButtonArgs *args, ui_callback callback);
UIEXPORT void ui_linkbutton_args_set_onclickdata(UiLinkButtonArgs *args, void *userdata);
+UIEXPORT void ui_linkbutton_args_set_action(UiLinkButtonArgs *args, const char *action);
UIEXPORT void ui_linkbutton_args_set_nofollow(UiLinkButtonArgs *args, UiBool value);
UIEXPORT void ui_linkbutton_args_set_type(UiLinkButtonArgs *args, UiLinkType type);
UIEXPORT void ui_linkbutton_args_set_states(UiLinkButtonArgs *args, int *states, int numstates);
UIEXPORT void ui_textarea_args_set_style_class(UiTextAreaArgs *args, const char *classname);
UIEXPORT void ui_textarea_args_set_onchange(UiTextAreaArgs *args, ui_callback callback);
UIEXPORT void ui_textarea_args_set_onchangedata(UiTextAreaArgs *args, void *onchangedata);
+UIEXPORT void ui_textarea_args_set_action(UiTextAreaArgs *args, const char *action);
UIEXPORT void ui_textarea_args_set_varname(UiTextAreaArgs *args, const char *varname);
UIEXPORT void ui_textarea_args_set_value(UiTextAreaArgs *args, UiText *value);
UIEXPORT void ui_textarea_args_set_states(UiTextAreaArgs *args, int *states, int numstates);
UIEXPORT void ui_textfield_args_set_onchangedata(UiTextFieldArgs *args, void *onchangedata);
UIEXPORT void ui_textfield_args_set_onactivate(UiTextFieldArgs *args, ui_callback callback);
UIEXPORT void ui_textfield_args_set_onactivatedata(UiTextFieldArgs *args, void *onactivatedata);
+UIEXPORT void ui_textfield_args_set_onactivate_action(UiTextFieldArgs *args, const char *action);
+UIEXPORT void ui_textfield_args_set_onchange_action(UiTextFieldArgs *args, const char *action);
UIEXPORT void ui_textfield_args_set_varname(UiTextFieldArgs *args, const char *varname);
UIEXPORT void ui_textfield_args_set_value(UiTextFieldArgs *args, UiString *value);
UIEXPORT void ui_textfield_args_set_states(UiTextFieldArgs *args, int *states, int numstates);
var_ctx = var_ctx->parent;
}
+
+ ui_update_action_bindings(ctx);
}
static void uic_context_unbind_vars(UiContext *ctx) {
UiContext *docctx = ui_document_context(document);
uic_context_unbind_vars(docctx); // unbind all doc/subdoc vars from the parent
docctx->parent = NULL;
+
+ ui_update_action_bindings(ctx);
}
void uic_context_detach_all(UiContext *ctx) {
}
cxListFree(ls);
+ ui_update_action_bindings(ctx);
}
static UiVar* ctx_getvar(UiContext *ctx, CxHashKey key) {
const CxAllocator *allocator;
CxList *destroy_handler;
+ // document pointer, if this is a document context
+ void *self_doc;
+
void *document;
CxList *documents;
UiDoc *document = cxCalloc(a, sizeof(UiDoc) + size, 1);
document->ctx = ctx;
+ ctx->self_doc = document;
return &document->doc;
}
item->item.next = NULL;
item->item.type = UI_MENU_ITEM;
+ item->action = nl_strdup(args->action);
item->label = nl_strdup(args->label);
item->icon = nl_strdup(args->icon);
item->userdata = args->onclickdata;
struct UiMenuItem {
UiMenuItemI item;
ui_callback callback;
+ char *action;
char *label;
char *icon;
void *userdata;
--- /dev/null
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 2026 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 "action.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+/* ------------------------------ public API ------------------------------ */
+
+void ui_add_action(UiContext *ctx, const char *name, ui_callback callback, void *userdata) {
+ uic_add_action(ctx, name, callback, userdata, NULL, NULL);
+}
+
+void ui_add_action_with_accelerator(
+ UiContext *ctx,
+ const char *name,
+ ui_callback callback,
+ void *userdata,
+ const char *accelerator,
+ const char *accelerator_text)
+{
+ uic_add_action(ctx, name, callback, userdata, accelerator, accelerator_text);
+
+ // TODO: accelerator
+}
--- /dev/null
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 2026 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.
+ */
+
+#ifndef ACTION_H
+#define ACTION_H
+
+#include "../ui/toolkit.h"
+#include "../common/action.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ACTION_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"
cxListFree(groups);
}
- if(i->callback != NULL) {
+ 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->value = 0;
event->customdata = NULL;
event->customint = 0;
+ event->action = i->action ? strdup(i->action) : NULL;
g_signal_connect(
action,
g_signal_connect(
obj->widget,
"destroy",
- G_CALLBACK(ui_destroy_userdata),
+ 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);
}
evt.eventdatatype = uic_get_tmp_eventdata_type();
}
evt.intval = intval;
- event->callback(&evt, event->userdata);
+ if(event->callback) {
+ event->callback(&evt, event->userdata);
+ }
+ if(event->action) {
+ uic_action_callback(&evt, event->action);
+ }
uic_set_tmp_eventdata(NULL, 0);
}
GTKOBJ += headerbar.o
GTKOBJ += webview.o
GTKOBJ += widget.o
+GTKOBJ += action.o
TOOLKITOBJS += $(GTKOBJ:%=$(GTK_OBJPRE)%)
TOOLKITSOURCE += $(GTKOBJ:%.o=gtk/%.c)
free(userdata);
}
+void ui_destroy_eventdata(GtkWidget *object, UiEventData *data) {
+ free(data->action);
+ free(data);
+}
+
void ui_destroy_vardata(GtkWidget *unused, UiVarEventData *data) {
if(data->var) {
ui_destroy_boundvar(data->obj->ctx, data->var);
int value;
int customint;
void *customdata;
+ char *action;
} UiEventData;
typedef struct UiEventDataExt {
void ui_set_widget_nvisibility_states(UiContext *ctx, GtkWidget *widget, const int *states, size_t ngroups);
void ui_destroy_userdata(GtkWidget *object, void *userdata);
+void ui_destroy_eventdata(GtkWidget *object, UiEventData *data);
void ui_destroy_vardata(GtkWidget *unused, UiVarEventData *data);
void ui_destroy_widget_var(GtkWidget *object, UiVar *var);
void ui_destroy_boundvar(UiContext *ctx, UiVar *var);
const char *tooltip;
UiLabelType labeltype;
ui_callback onclick;
- void *onclickdata;
+ void *onclickdata;
+ const char *action;
const int *states;
const int *visibility_states;
const char *name;
const char *style_class;
- const char *label;
- const char *icon;
- const char *tooltip;
+ const char *label;
+ const char *icon;
+ const char *tooltip;
UiLabelType labeltype;
- UiInteger *value;
- const char *varname;
+ UiInteger *value;
+ const char *varname;
ui_callback onchange;
- void *onchangedata;
- int enable_state;
+ void *onchangedata;
+ const char *action;
+ int enable_state;
- const int *states;
- const int *visibility_states;
+ const int *states;
+ const int *visibility_states;
} UiToggleArgs;
typedef struct UiLinkButtonArgs {
const char *varname;
ui_callback onclick;
void *onclickdata;
+ const char *action;
UiBool nofollow;
UiLinkType type;
typedef struct UiMenuItemArgs {
const char *label;
const char *icon;
-
+
ui_callback onclick;
void *onclickdata;
const char *action;
const char *varname;
ui_callback onchange;
void *onchangedata;
+ const char *action;
const int *states;
const int *visibility_states;
void *onchangedata;
ui_callback onactivate;
void *onactivatedata;
+ const char *onactivate_action;
+ const char *onchange_action;
const int *states;
const int *visibility_states;
ui_callback onactivate;
void *onactivatedata;
+ const char *action;
ui_callback ondragstart;
void *ondragstartdata;
UIEXPORT void ui_widget_set_states2(UiContext *ctx, UIWIDGET widget, ui_enablefunc enable, const int *states, int nstates);
UIEXPORT void ui_widget_set_visibility_states(UiContext *ctx, UIWIDGET widget, const int *states, int nstates);
+UIEXPORT void ui_add_action(UiContext *ctx, const char *name, ui_callback callback, void *userdata);
+UIEXPORT void ui_add_action_with_accelerator(
+ UiContext *ctx,
+ const char *name,
+ ui_callback callback,
+ void *userdata,
+ const char *accelerator,
+ const char *accelerator_text);
+UIEXPORT void ui_update_action_bindings(UiContext *ctx);
+
UIEXPORT void ui_set_state(UiContext *ctx, int state);
UIEXPORT void ui_unset_state(UiContext *ctx, int state);
UIEXPORT int* ui_active_states(UiContext *ctx, int *nstates);