toaruos/lib/menu.c

1056 lines
29 KiB
C
Raw Normal View History

/**
* @brief Cascading graphical menu library.
2018-08-14 11:24:25 +03:00
*
* C reimplementation of the original Python menu library.
* Used to provide menu bars and the applications menu.
*
* @copyright
* This file is part of ToaruOS and is released under the terms
* of the NCSA / University of Illinois License - see LICENSE.md
* Copyright (C) 2018-2021 K. Lange
2018-08-14 11:24:25 +03:00
*/
2018-04-24 14:58:41 +03:00
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <math.h>
#include <sys/types.h>
2018-09-24 06:22:00 +03:00
#include <dlfcn.h>
2018-04-24 14:58:41 +03:00
#include <toaru/yutani.h>
#include <toaru/graphics.h>
#include <toaru/hashmap.h>
#include <toaru/list.h>
#include <toaru/icon_cache.h>
#include <toaru/text.h>
#include <toaru/markup_text.h>
2018-04-24 14:58:41 +03:00
#include <toaru/menu.h>
#define MENU_ENTRY_HEIGHT 20
#define MENU_BACKGROUND rgb(239,238,232)
#define MENU_ICON_SIZE 16
#define HILIGHT_BORDER_TOP rgb(54,128,205)
#define HILIGHT_GRADIENT_TOP rgb(93,163,236)
#define HILIGHT_GRADIENT_BOTTOM rgb(56,137,220)
#define HILIGHT_BORDER_BOTTOM rgb(47,106,167)
static hashmap_t * menu_windows = NULL;
static yutani_t * my_yctx = NULL;
2018-05-19 13:05:27 +03:00
static struct MenuList * hovered_menu = NULL;
int menu_definitely_close(struct MenuList * menu);
2018-04-24 14:58:41 +03:00
__attribute__((constructor))
static void _init_menus(void) {
menu_windows = hashmap_create_int(10);
markup_text_init();
2018-04-24 14:58:41 +03:00
}
2018-05-20 06:37:22 +03:00
hashmap_t * menu_get_windows_hash(void) {
return menu_windows;
}
2018-09-24 06:22:00 +03:00
static int string_width(const char * s) {
return markup_string_width(s);
2018-09-24 06:22:00 +03:00
}
static int draw_string(gfx_context_t * ctx, int x, int y, uint32_t color, const char * s) {
return markup_draw_string(ctx,x,y+13,s,color);
2018-09-24 06:22:00 +03:00
}
2018-04-24 14:58:41 +03:00
void _menu_draw_MenuEntry_Normal(gfx_context_t * ctx, struct MenuEntry * self, int offset) {
struct MenuEntry_Normal * _self = (struct MenuEntry_Normal *)self;
2018-05-19 13:05:27 +03:00
_self->offset = offset;
2018-04-24 14:58:41 +03:00
/* Background gradient */
if (_self->hilight) {
draw_line(ctx, 1, _self->width-2, offset, offset, HILIGHT_BORDER_TOP);
draw_line(ctx, 1, _self->width-2, offset + _self->height - 1, offset + _self->height - 1, HILIGHT_BORDER_BOTTOM);
for (int i = 1; i < self->height-1; ++i) {
int thing = ((i - 1) * 256) / (_self->height - 2);
if (thing > 255) thing = 255;
if (thing < 0) thing = 0;
uint32_t c = interp_colors(HILIGHT_GRADIENT_TOP, HILIGHT_GRADIENT_BOTTOM, thing);
draw_line(ctx, 1, self->width-2, offset + i, offset + i, c);
}
}
/* Icon */
2018-04-27 15:30:51 +03:00
if (_self->icon) {
sprite_t * icon = icon_get_16(_self->icon);
if (icon->width == MENU_ICON_SIZE) {
draw_sprite(ctx, icon, 4, offset + 2);
} else {
draw_sprite_scaled(ctx, icon, 4, offset + 2, MENU_ICON_SIZE, MENU_ICON_SIZE);
}
2018-04-24 14:58:41 +03:00
}
/* Foreground text color */
uint32_t color = _self->hilight ? rgb(255,255,255) : rgb(0,0,0);
/* Draw title */
2018-09-24 06:22:00 +03:00
draw_string(ctx, 22, offset + 1, color, _self->title);
2018-04-24 14:58:41 +03:00
}
void _menu_focus_MenuEntry_Normal(struct MenuEntry * self, int focused) {
2018-05-19 13:05:27 +03:00
if (focused) {
if (self->_owner && self->_owner->child) {
menu_definitely_close(self->_owner->child);
self->_owner->child = NULL;
}
}
2018-04-24 14:58:41 +03:00
}
void _menu_activate_MenuEntry_Normal(struct MenuEntry * self, int flags) {
struct MenuEntry_Normal * _self = (struct MenuEntry_Normal *)self;
2018-05-19 13:05:27 +03:00
list_t * menu_keys = hashmap_keys(menu_windows);
hovered_menu = NULL;
foreach(_key, menu_keys) {
2021-05-31 04:47:02 +03:00
yutani_window_t * window = hashmap_get(menu_windows, (void*)(uintptr_t)_key->value);
2018-05-19 13:05:27 +03:00
if (window) {
struct MenuList * menu = window->user_data;
menu_definitely_close(menu);
if (menu->parent && menu->parent->child == menu) {
menu->parent->child = NULL;
}
}
}
list_free(menu_keys);
free(menu_keys);
2018-04-24 14:58:41 +03:00
if (_self->callback) {
_self->callback(_self);
}
}
2021-10-24 15:20:25 +03:00
static struct MenuEntryVTable _menu_vtable_MenuEntry_Normal = {
.methods = 3,
.renderer = _menu_draw_MenuEntry_Normal,
.focus_change = _menu_focus_MenuEntry_Normal,
.activate = _menu_activate_MenuEntry_Normal,
};
2018-04-24 14:58:41 +03:00
struct MenuEntry * menu_create_normal(const char * icon, const char * action, const char * title, void (*callback)(struct MenuEntry *)) {
struct MenuEntry_Normal * out = calloc(1,sizeof(struct MenuEntry_Normal));
2018-04-24 14:58:41 +03:00
out->_type = MenuEntry_Normal;
out->height = MENU_ENTRY_HEIGHT;
out->hilight = 0;
2021-10-24 15:20:25 +03:00
out->vtable = &_menu_vtable_MenuEntry_Normal;
2018-04-27 15:30:51 +03:00
out->icon = icon ? strdup(icon) : NULL;
2018-04-24 14:58:41 +03:00
out->title = strdup(title);
2018-04-27 15:30:51 +03:00
out->action = action ? strdup(action) : NULL;
2018-04-24 14:58:41 +03:00
out->callback = callback;
2018-09-24 06:22:00 +03:00
out->rwidth = 50 + string_width(out->title);
2018-04-24 14:58:41 +03:00
return (struct MenuEntry *)out;
}
void _menu_draw_MenuEntry_Submenu(gfx_context_t * ctx, struct MenuEntry * self, int offset) {
2018-07-23 13:32:58 +03:00
2018-06-20 05:17:27 +03:00
struct MenuEntry_Submenu * _self = (struct MenuEntry_Submenu *)self;
2018-07-23 13:32:58 +03:00
int h = _self->hilight;
if (_self->_owner && _self->_my_child && _self->_owner->child == _self->_my_child && !_self->_my_child->closed) {
2018-07-23 13:32:58 +03:00
_self->hilight = 1;
}
_menu_draw_MenuEntry_Normal(ctx,self,offset);
2018-06-20 05:17:27 +03:00
/* Draw the tick on the right side to indicate this is a submenu */
uint32_t color = _self->hilight ? rgb(255,255,255) : rgb(0,0,0);
sprite_t * tick = icon_get_16("menu-tick");
draw_sprite_alpha_paint(ctx, tick, _self->width - 16, offset + 2, 1.0, color);
2018-07-23 13:32:58 +03:00
_self->hilight = h;
2018-04-24 14:58:41 +03:00
}
void _menu_focus_MenuEntry_Submenu(struct MenuEntry * self, int focused) {
2018-05-19 13:05:27 +03:00
if (focused) {
2021-10-24 15:20:25 +03:00
self->vtable->activate(self, focused);
2018-05-19 13:05:27 +03:00
}
2018-04-24 14:58:41 +03:00
}
void _menu_activate_MenuEntry_Submenu(struct MenuEntry * self, int focused) {
2018-05-19 13:05:27 +03:00
struct MenuEntry_Submenu * _self = (struct MenuEntry_Submenu *)self;
if (_self->_owner && _self->_owner->set) {
/* Show a menu */
struct MenuList * new_menu = menu_set_get_menu(_self->_owner->set, (char *)_self->action);
if (_self->_owner->child && _self->_owner->child != new_menu) {
menu_definitely_close(_self->_owner->child);
_self->_owner->child = NULL;
}
2018-05-19 13:43:00 +03:00
new_menu->parent = _self->_owner;
new_menu->parent->child = new_menu;
2018-07-23 13:32:58 +03:00
_self->_my_child = new_menu;
2018-05-19 13:43:00 +03:00
if (new_menu->closed) {
menu_prepare(new_menu, _self->_owner->window->ctx);
int offset_x = _self->_owner->window->width - 2;
if (_self->_owner->window->width + _self->_owner->window->x - 2 + new_menu->window->width > _self->_owner->window->ctx->display_width) {
offset_x = 2 - new_menu->window->width;
}
yutani_window_move_relative(_self->_owner->window->ctx, new_menu->window, _self->_owner->window,
offset_x, _self->offset - 4);
2021-08-12 04:36:58 +03:00
yutani_flip(_self->_owner->window->ctx, new_menu->window);
2018-05-19 13:05:27 +03:00
}
}
2018-04-24 14:58:41 +03:00
}
2021-10-24 15:20:25 +03:00
static struct MenuEntryVTable _menu_vtable_MenuEntry_Submenu = {
.methods = 3,
.renderer = _menu_draw_MenuEntry_Submenu,
.focus_change = _menu_focus_MenuEntry_Submenu,
.activate = _menu_activate_MenuEntry_Submenu,
};
2018-04-24 14:58:41 +03:00
struct MenuEntry * menu_create_submenu(const char * icon, const char * action, const char * title) {
struct MenuEntry_Submenu * out = calloc(1,sizeof(struct MenuEntry_Submenu));
2018-04-24 14:58:41 +03:00
out->_type = MenuEntry_Submenu;
out->height = MENU_ENTRY_HEIGHT;
out->hilight = 0;
2021-10-24 15:20:25 +03:00
out->vtable = &_menu_vtable_MenuEntry_Submenu;
2018-04-27 15:30:51 +03:00
out->icon = icon ? strdup(icon) : NULL;
2018-04-24 14:58:41 +03:00
out->title = strdup(title);
2018-04-27 15:30:51 +03:00
out->action = action ? strdup(action) : NULL;
2018-04-24 14:58:41 +03:00
2018-09-24 06:22:00 +03:00
out->rwidth = 50 + string_width(out->title);
2018-04-24 14:58:41 +03:00
return (struct MenuEntry *)out;
}
void _menu_draw_MenuEntry_Separator(gfx_context_t * ctx, struct MenuEntry * self, int offset) {
2018-05-19 13:05:27 +03:00
self->offset = offset;
2018-04-24 14:58:41 +03:00
draw_line(ctx, 2, self->width-4, offset+3, offset+3, rgb(178,178,178));
draw_line(ctx, 2, self->width-5, offset+4, offset+4, rgb(250,250,250));
}
void _menu_focus_MenuEntry_Separator(struct MenuEntry * self, int focused) {
2018-05-19 13:05:27 +03:00
if (focused) {
if (self->_owner && self->_owner->child) {
menu_definitely_close(self->_owner->child);
self->_owner->child = NULL;
}
}
2018-04-24 14:58:41 +03:00
}
void _menu_activate_MenuEntry_Separator(struct MenuEntry * self, int focused) {
}
2021-10-24 15:20:25 +03:00
static struct MenuEntryVTable _menu_vtable_MenuEntry_Separator = {
.methods = 3,
.renderer = _menu_draw_MenuEntry_Separator,
.focus_change = _menu_focus_MenuEntry_Separator,
.activate = _menu_activate_MenuEntry_Separator,
};
2018-04-24 14:58:41 +03:00
struct MenuEntry * menu_create_separator(void) {
struct MenuEntry_Separator * out = calloc(1,sizeof(struct MenuEntry_Separator));
2018-04-24 14:58:41 +03:00
out->_type = MenuEntry_Separator;
out->height = 6;
out->hilight = 0;
out->rwidth = 10; /* at least a bit please */
2021-10-24 15:20:25 +03:00
out->vtable = &_menu_vtable_MenuEntry_Separator;
2018-04-24 14:58:41 +03:00
return (struct MenuEntry *)out;
}
2018-07-20 17:08:12 +03:00
void menu_update_title(struct MenuEntry * self, char * new_title) {
if (self->_type == MenuEntry_Normal) {
struct MenuEntry_Normal * _self = (struct MenuEntry_Normal *)self;
if (_self->title) {
free((void*)_self->title);
}
_self->title = strdup(new_title);
2018-09-24 06:22:00 +03:00
_self->rwidth = 50 + string_width(_self->title);
2018-07-20 17:08:12 +03:00
} else if (self->_type == MenuEntry_Submenu) {
struct MenuEntry_Submenu * _self = (struct MenuEntry_Submenu *)self;
if (_self->title) {
free((void*)_self->title);
}
_self->title = strdup(new_title);
2018-09-24 06:22:00 +03:00
_self->rwidth = 50 + string_width(_self->title);
2018-07-20 17:08:12 +03:00
}
}
void menu_update_icon(struct MenuEntry * self, char * newIcon) {
switch (self->_type) {
case MenuEntry_Normal: {
struct MenuEntry_Normal * _self = (struct MenuEntry_Normal *)self;
if (_self->icon) free(_self->icon);
_self->icon = newIcon ? strdup(newIcon) : NULL;
break;
}
case MenuEntry_Submenu: {
struct MenuEntry_Submenu * _self = (struct MenuEntry_Submenu *)self;
if (_self->icon) free(_self->icon);
_self->icon = newIcon ? strdup(newIcon) : NULL;
break;
}
default:
break;
}
}
2021-06-06 12:34:12 +03:00
void menu_free_entry(struct MenuEntry * self) {
switch (self->_type) {
case MenuEntry_Normal: {
struct MenuEntry_Normal * _self = (struct MenuEntry_Normal *)self;
if (_self->icon) free(_self->icon);
if (_self->title) free(_self->title);
if (_self->action) free(_self->action);
break;
}
case MenuEntry_Submenu: {
struct MenuEntry_Submenu * _self = (struct MenuEntry_Submenu *)self;
if (_self->icon) free(_self->icon);
if (_self->title) free(_self->title);
if (_self->action) free(_self->action);
break;
}
default:
break;
}
free(self);
}
2018-04-24 14:58:41 +03:00
static int _close_enough(struct yutani_msg_window_mouse_event * me) {
if (me->command == YUTANI_MOUSE_EVENT_RAISE && sqrt(pow(me->new_x - me->old_x, 2) + pow(me->new_y - me->old_y, 2)) < 10) {
return 1;
}
return 0;
}
static char read_buf[1024];
static size_t available = 0;
static size_t offset = 0;
static size_t read_from = 0;
static char * read_line(FILE * f, char * out, ssize_t len) {
while (len > 0) {
if (available == 0) {
if (offset == 1024) {
offset = 0;
}
size_t r = read(fileno(f), &read_buf[offset], 1024 - offset);
read_from = offset;
available = r;
offset += available;
}
if (available == 0) {
*out = '\0';
return out;
}
while (read_from < offset && len > 0) {
*out = read_buf[read_from];
len--;
read_from++;
available--;
if (*out == '\n') {
return out;
}
out++;
}
}
return out;
}
void menu_calculate_dimensions(struct MenuList * menu, int * height, int * width) {
2018-04-24 14:58:41 +03:00
list_t * list = menu->entries;
*width = 0;
*height = (menu->flags & MENU_FLAG_BUBBLE) ? 16 : 8; /* TODO top and height */
2018-04-24 14:58:41 +03:00
foreach(node, list) {
struct MenuEntry * entry = node->value;
*height += entry->height;
if (*width < entry->rwidth) {
*width = entry->rwidth;
}
}
/* Go back through and update actual widths */
foreach(node, list) {
struct MenuEntry * entry = node->value;
entry->width = *width;
}
}
struct MenuList * menu_set_get_root(struct MenuSet * menu) {
return (void*)hashmap_get(menu->_menus,"_");
}
2018-05-19 13:05:27 +03:00
struct MenuList * menu_set_get_menu(struct MenuSet * menu, char * submenu) {
return (void*)hashmap_get(menu->_menus, submenu);
}
2018-04-27 15:30:51 +03:00
void menu_insert(struct MenuList * menu, struct MenuEntry * entry) {
list_insert(menu->entries, entry);
entry->_owner = menu;
}
struct MenuList * menu_create(void) {
struct MenuList * p = malloc(sizeof(struct MenuList));
p->entries = list_create();
p->ctx = NULL;
p->window = NULL;
2018-05-19 13:05:27 +03:00
p->set = NULL;
p->child = NULL;
p->_bar = NULL;
2018-05-19 13:05:27 +03:00
p->parent = NULL;
p->closed = 1;
p->flags = 0;
p->tail_offset = 0;
2018-04-27 15:30:51 +03:00
return p;
}
2018-05-20 06:37:22 +03:00
struct MenuSet * menu_set_create(void) {
struct MenuSet * _out = malloc(sizeof(struct MenuSet));
_out->_menus = hashmap_create(10);
return _out;
}
void menu_set_insert(struct MenuSet * set, char * action, struct MenuList * menu) {
hashmap_set(set->_menus, action, menu);
menu->set = set;
2018-05-20 06:37:22 +03:00
}
2018-04-24 14:58:41 +03:00
struct MenuSet * menu_set_from_description(const char * path, void (*callback)(struct MenuEntry *)) {
FILE * f;
if (!strcmp(path,"-")) {
f = stdin;
} else {
f = fopen(path,"r");
}
if (!f) {
return NULL;
}
2018-05-19 13:05:27 +03:00
struct MenuSet * _out = malloc(sizeof(struct MenuSet));
2018-04-24 14:58:41 +03:00
hashmap_t * out = hashmap_create(10);
2018-05-19 13:05:27 +03:00
_out->_menus = out;
2018-04-24 14:58:41 +03:00
2018-04-27 15:30:51 +03:00
struct MenuList * current_menu = NULL;
2018-04-24 14:58:41 +03:00
/* Read through the file */
char line[256];
while (1) {
memset(line, 0, 256);
read_line(f, line, 256);
if (!*line) break;
if (line[strlen(line)-1] == '\n') {
line[strlen(line)-1] = '\0';
}
if (!*line) continue; /* skip blank */
if (*line == ':') {
/* New menu */
struct MenuList * p = menu_create();
2018-05-19 13:05:27 +03:00
p->set = _out;
2018-04-27 15:30:51 +03:00
hashmap_set(out, line+1, p);
current_menu = p;
2018-04-24 14:58:41 +03:00
} else if (*line == '#') {
/* Comment */
continue;
} else if (*line == '-') {
2018-04-27 15:30:51 +03:00
if (!current_menu) {
2018-04-24 14:58:41 +03:00
fprintf(stderr, "Tried to add separator with no active menu.\n");
goto failure;
}
2018-04-27 15:30:51 +03:00
menu_insert(current_menu, menu_create_separator());
2018-04-24 14:58:41 +03:00
} else if (*line == '&') {
2018-04-27 15:30:51 +03:00
if (!current_menu) {
2018-04-24 14:58:41 +03:00
fprintf(stderr, "Tried to add submenu with no active menu.\n");
goto failure;
}
char * action = line+1;
char * icon = strstr(action,",");
if (!icon) {
fprintf(stderr, "Malformed line in submenu: no icon\n");
goto failure;
}
*icon = '\0';
icon++;
char * title = strstr(icon,",");
if (!title) {
fprintf(stderr, "Malformed line in submenu: no title\n");
goto failure;
}
*title = '\0';
title++;
2018-04-27 15:30:51 +03:00
menu_insert(current_menu, menu_create_submenu(icon,action,title));
2018-04-24 14:58:41 +03:00
} else {
2018-04-27 15:30:51 +03:00
if (!current_menu) {
2018-04-24 14:58:41 +03:00
fprintf(stderr, "Tried to add item with no active menu.\n");
goto failure;
}
char * action = line;
char * icon = strstr(action,",");
if (!icon) {
fprintf(stderr, "Malformed line in action: no icon\n");
goto failure;
}
*icon = '\0';
icon++;
char * title = strstr(icon,",");
if (!title) {
fprintf(stderr, "Malformed line in action: no title\n");
goto failure;
}
*title = '\0';
title++;
2018-04-27 15:30:51 +03:00
menu_insert(current_menu, menu_create_normal(icon,action,title,callback));
2018-04-24 14:58:41 +03:00
}
}
return _out;
failure:
fprintf(stderr, "malformed description file\n");
if (f != stdin) {
fclose(f);
}
free(out);
return NULL;
}
static void _menu_redraw(yutani_window_t * menu_window, yutani_t * yctx, struct MenuList * menu, int expose) {
2018-04-24 14:58:41 +03:00
gfx_context_t * ctx = menu->ctx;
list_t * entries = menu->entries;
/* Window background */
if (menu->flags & MENU_FLAG_BUBBLE) {
draw_fill(ctx, rgba(0,0,0,0));
draw_rounded_rectangle(ctx, 0, 6, ctx->width, ctx->height - 6, 6, rgb(109,111,112));
draw_rounded_rectangle(ctx, 1, 7, ctx->width-2, ctx->height - 8, 5, MENU_BACKGROUND);
/* Figure out where to draw the tail */
int tail_left = 0;
/* Do we have a set tail? */
#define TAIL_BOUND 8
if (menu->flags & MENU_FLAG_TAIL_POSITION) {
tail_left = (menu->tail_offset < TAIL_BOUND) ? TAIL_BOUND : (menu->tail_offset > ctx->width - TAIL_BOUND) ? (ctx->width - TAIL_BOUND) : menu->tail_offset;
} else if (menu->flags & MENU_FLAG_BUBBLE_LEFT) {
tail_left = 16;
} else if (menu->flags & MENU_FLAG_BUBBLE_RIGHT) {
tail_left = ctx->width - 16;
} else if (menu->flags & MENU_FLAG_BUBBLE_CENTER) {
tail_left = ctx->width / 2;
}
for (int i = 1; i < 7; ++i) {
draw_line(ctx, tail_left - i, tail_left + i, i, i, MENU_BACKGROUND);
}
draw_line_aa(ctx, tail_left - 6, tail_left, 6, 0, rgb(109,111,112), 0.5);
draw_line_aa(ctx, tail_left + 6, tail_left, 6, 0, rgb(109,111,112), 0.5);
} else {
draw_fill(ctx, MENU_BACKGROUND);
2018-04-24 14:58:41 +03:00
/* Window border */
draw_line(ctx, 0, ctx->width-1, 0, 0, rgb(109,111,112));
draw_line(ctx, 0, 0, 0, ctx->height-1, rgb(109,111,112));
draw_line(ctx, ctx->width-1, ctx->width-1, 0, ctx->height-1, rgb(109,111,112));
draw_line(ctx, 0, ctx->width-1, ctx->height-1, ctx->height-1, rgb(109,111,112));
}
2018-04-24 14:58:41 +03:00
/* Draw menu entries */
int offset = (menu->flags & MENU_FLAG_BUBBLE) ? 12 : 4;
2018-04-24 14:58:41 +03:00
foreach(node, entries) {
struct MenuEntry * entry = node->value;
2021-10-24 15:20:25 +03:00
if (entry->vtable->methods >= 1 && entry->vtable->renderer) {
entry->vtable->renderer(ctx, entry, offset);
2018-04-24 14:58:41 +03:00
}
offset += entry->height;
}
flip(ctx);
if (expose) {
yutani_flip(yctx, menu_window);
}
2018-04-24 14:58:41 +03:00
}
void menu_prepare(struct MenuList * menu, yutani_t * yctx) {
2018-04-24 14:58:41 +03:00
/* Calculate window dimensions */
int height, width;
menu_calculate_dimensions(menu,&height, &width);
2018-04-24 14:58:41 +03:00
my_yctx = yctx;
2018-05-19 13:05:27 +03:00
menu->closed = 0;
2018-04-24 14:58:41 +03:00
/* Create window */
yutani_window_t * menu_window = yutani_window_create_flags(yctx, width, height,
((menu->flags & MENU_FLAG_BUBBLE) ? YUTANI_WINDOW_FLAG_ALT_ANIMATION :
YUTANI_WINDOW_FLAG_NO_ANIMATION) | YUTANI_WINDOW_FLAG_DISALLOW_DRAG | YUTANI_WINDOW_FLAG_DISALLOW_RESIZE);
yutani_set_stack(yctx, menu_window, YUTANI_ZORDER_MENU);
2018-04-24 15:19:06 +03:00
if (menu->ctx) {
reinit_graphics_yutani(menu->ctx, menu_window);
} else {
menu->ctx = init_graphics_yutani_double_buffer(menu_window);
}
2018-04-24 14:58:41 +03:00
menu_window->user_data = menu;
menu->window = menu_window;
_menu_redraw(menu_window, yctx, menu, 0);
2018-04-24 14:58:41 +03:00
2021-05-31 04:47:02 +03:00
hashmap_set(menu_windows, (void*)(uintptr_t)menu_window->wid, menu_window);
2018-04-24 14:58:41 +03:00
}
void menu_show(struct MenuList * menu, yutani_t * yctx) {
menu_prepare(menu, yctx);
yutani_flip(yctx, menu->window);
}
2019-01-07 08:04:55 +03:00
void menu_show_at(struct MenuList * menu, yutani_window_t * parent, int x, int y) {
menu_prepare(menu, parent->ctx);
2019-01-07 08:04:55 +03:00
if (parent->x + x + menu->window->width > parent->ctx->display_width) x -= menu->window->width;
if (parent->y + y + menu->window->height > parent->ctx->display_height) y -= menu->window->height;
2019-01-07 08:04:55 +03:00
yutani_window_move_relative(parent->ctx, menu->window, parent, x, y);
2021-08-12 04:36:58 +03:00
yutani_flip(parent->ctx, menu->window);
2019-01-07 08:04:55 +03:00
}
2018-05-19 13:05:27 +03:00
int menu_has_eventual_child(struct MenuList * root, struct MenuList * child) {
2018-05-19 13:43:00 +03:00
if (!child) return 0;
2018-05-19 13:05:27 +03:00
if (root == child) return 1;
struct MenuList * candidate = root->child;
while (candidate && candidate != child) {
2018-05-19 13:43:00 +03:00
if (candidate == root->child) {
return 1;
}
2018-05-19 13:05:27 +03:00
candidate = root->child;
}
return (candidate == child);
}
int menu_definitely_close(struct MenuList * menu) {
if (menu->child) {
menu_definitely_close(menu->child);
menu->child = NULL;
}
if (menu->closed) {
return 0;
}
/* if focused_widget, leave focus on widget */
2018-05-19 13:43:00 +03:00
foreach(node, menu->entries) {
struct MenuEntry * entry = node->value;
entry->hilight = 0;
}
2018-05-19 13:05:27 +03:00
menu->closed = 1;
yutani_wid_t wid = menu->window->wid;
yutani_close(menu->window->ctx, menu->window);
menu->window = NULL;
2021-05-31 04:47:02 +03:00
hashmap_remove(menu_windows, (void*)(uintptr_t)wid);
2018-05-19 13:05:27 +03:00
return 0;
}
int menu_leave(struct MenuList * menu) {
2018-05-19 13:43:00 +03:00
if (!hovered_menu) {
while (menu->parent) {
menu = menu->parent;
}
menu_definitely_close(menu);
return 0;
}
2018-05-19 13:05:27 +03:00
if (!menu_has_eventual_child(menu, hovered_menu)) {
/* Get all menus */
list_t * menu_keys = hashmap_keys(menu_windows);
foreach(_key, menu_keys) {
2021-05-31 04:47:02 +03:00
yutani_window_t * window = hashmap_get(menu_windows, (void *)(uintptr_t)_key->value);
2018-05-19 13:05:27 +03:00
if (window) {
struct MenuList * menu = window->user_data;
2018-05-19 13:43:00 +03:00
if (!hovered_menu || (menu != hovered_menu->child && !menu_has_eventual_child(menu, hovered_menu))) {
2018-05-19 13:05:27 +03:00
menu_definitely_close(menu);
if (menu->parent && menu->parent->child == menu) {
menu->parent->child = NULL;
}
}
}
}
list_free(menu_keys);
free(menu_keys);
}
2018-05-19 13:43:00 +03:00
return 0;
}
2018-07-20 16:15:46 +03:00
void menu_key_action(struct MenuList * menu, struct yutani_msg_key_event * me) {
if (me->event.action != KEY_ACTION_DOWN) return;
yutani_window_t * window = menu->window;
yutani_t * yctx = window->ctx;
hovered_menu = menu;
/* Find hilighted entry */
struct MenuEntry * hilighted = NULL;
struct MenuEntry * previous = NULL;
struct MenuEntry * next = NULL;
int got_it = 0;
foreach(node, menu->entries) {
struct MenuEntry * entry = node->value;
if (entry->hilight) {
hilighted = entry;
got_it = 1;
continue;
}
if (got_it && entry->_type != MenuEntry_Separator) {
2018-07-20 16:15:46 +03:00
next = entry;
break;
}
if (entry->_type != MenuEntry_Separator) {
previous = entry;
}
2018-07-20 16:15:46 +03:00
}
if (me->event.keycode == KEY_ARROW_DOWN) {
if (hilighted) {
hilighted->hilight = 0;
hilighted = next;
}
if (!hilighted) {
/* Use the first entry */
hilighted = menu->entries->head->value;
}
hilighted->hilight = 1;
_menu_redraw(window,yctx,menu,1);
2018-07-20 16:15:46 +03:00
} else if (me->event.keycode == KEY_ARROW_UP) {
if (hilighted) {
hilighted->hilight = 0;
hilighted = previous;
}
if (!hilighted) {
/* Use the last entry */
hilighted = menu->entries->tail->value;
}
hilighted->hilight = 1;
_menu_redraw(window,yctx,menu,1);
2018-07-20 16:15:46 +03:00
} else if (me->event.keycode == KEY_ARROW_RIGHT) {
2018-07-20 16:24:05 +03:00
if (!hilighted) {
hilighted = menu->entries->head->value;
}
if (hilighted) {
hilighted->hilight = 1;
if (hilighted->_type == MenuEntry_Submenu) {
2021-10-24 15:20:25 +03:00
if (hilighted->vtable->methods >= 3 && hilighted->vtable->activate) {
hilighted->vtable->activate(hilighted, 0);
}
_menu_redraw(window,yctx,menu,1);
} else {
struct menu_bar * bar = NULL;
struct MenuList * p = menu;
do {
if (p->_bar) {
bar = p->_bar;
break;
}
} while ((p = p->parent));
if (bar) {
menu_definitely_close(p);
int active = (bar->active_entry_idx + 1 + bar->num_entries) % (bar->num_entries);
bar->active_entry = &bar->entries[active];
if (bar->redraw_callback) {
bar->redraw_callback(bar);
}
menu_bar_show_menu(yctx, bar->window, bar, -1, bar->active_entry);
} else {
_menu_redraw(window,yctx,menu,1);
}
}
2018-07-20 16:15:46 +03:00
}
} else if (me->event.key == '\n') {
2018-07-20 16:24:05 +03:00
if (!hilighted) {
hilighted = menu->entries->head->value;
}
2018-07-20 16:15:46 +03:00
if (hilighted) {
2018-07-20 16:24:05 +03:00
hilighted->hilight = 1;
2021-10-24 15:20:25 +03:00
if (hilighted->vtable->methods >= 3 && hilighted->vtable->activate) {
hilighted->vtable->activate(hilighted, 0);
}
2018-07-20 16:15:46 +03:00
}
} else if (me->event.keycode == KEY_ARROW_LEFT) {
if (menu->parent) {
hovered_menu = menu->parent;
} /* else previous from menu bar? */
2018-07-20 16:15:46 +03:00
menu_definitely_close(menu);
if (menu->_bar) {
int active = (menu->_bar->active_entry_idx - 1 + menu->_bar->num_entries) % (menu->_bar->num_entries);
menu->_bar->active_entry = &menu->_bar->entries[active];
if (menu->_bar->redraw_callback) {
menu->_bar->redraw_callback(menu->_bar);
}
menu_bar_show_menu(yctx, menu->_bar->window, menu->_bar, -1, menu->_bar->active_entry);
} else if (menu->parent && menu->parent->window) {
yutani_focus_window(yctx, menu->parent->window->wid);
}
2018-07-20 16:37:31 +03:00
} else if (me->event.keycode == KEY_ESCAPE) {
hovered_menu = NULL;
menu_leave(menu);
2018-07-20 16:15:46 +03:00
}
}
2018-05-19 13:43:00 +03:00
void menu_mouse_action(struct MenuList * menu, struct yutani_msg_window_mouse_event * me) {
yutani_window_t * window = menu->window;
yutani_t * yctx = window->ctx;
int offset = (menu->flags & MENU_FLAG_BUBBLE) ? 12 : 4;
2018-05-19 13:43:00 +03:00
int changed = 0;
foreach(node, menu->entries) {
struct MenuEntry * entry = node->value;
if (me->new_y >= offset && me->new_y < offset + entry->height &&
me->new_x >= 0 && me->new_x < entry->width) {
if (!entry->hilight) {
changed = 1;
entry->hilight = 1;
2021-10-24 15:20:25 +03:00
if (entry->vtable->methods >= 2 && entry->vtable->focus_change) {
entry->vtable->focus_change(entry, 1);
}
2018-05-19 13:43:00 +03:00
}
2021-10-24 15:20:25 +03:00
if (entry->vtable->methods >= 4 && entry->vtable->mouse_event) {
if (entry->vtable->mouse_event(entry, me)) {
_menu_redraw(window,yctx,menu,1);
}
} else if (me->command == YUTANI_MOUSE_EVENT_CLICK || _close_enough(me)) {
if (entry->vtable->methods >= 3 && entry->vtable->activate) {
entry->vtable->activate(entry, 0);
2018-05-19 13:43:00 +03:00
}
}
} else {
if (entry->hilight) {
changed = 1;
entry->hilight = 0;
2021-10-24 15:20:25 +03:00
if (entry->vtable->methods >= 2 && entry->vtable->focus_change) {
entry->vtable->focus_change(entry, 0);
}
2018-05-19 13:43:00 +03:00
}
2018-05-19 13:05:27 +03:00
}
2018-05-19 13:43:00 +03:00
offset += entry->height;
}
if (changed) {
_menu_redraw(window,yctx,menu,1);
2018-05-19 13:05:27 +03:00
}
2018-05-19 13:43:00 +03:00
}
2018-05-19 13:05:27 +03:00
void menu_force_redraw(struct MenuList * menu) {
yutani_window_t * window = menu->window;
yutani_t * yctx = window->ctx;
_menu_redraw(window,yctx,menu,1);
}
2018-05-19 13:43:00 +03:00
struct MenuList * menu_any_contains(int x, int y) {
struct MenuList * out = NULL;
list_t * menu_keys = hashmap_keys(menu_windows);
foreach(_key, menu_keys) {
yutani_window_t * window = hashmap_get(menu_windows, (void*)_key->value);
if (window) {
if (x >= (int)window->x && x < (int)window->x + (int)window->width && y >= (int)window->y && y < (int)window->y + (int)window->height) {
out = window->user_data;
break;
}
}
}
list_free(menu_keys);
free(menu_keys);
return out;
2018-05-19 13:05:27 +03:00
}
2018-04-24 14:58:41 +03:00
int menu_process_event(yutani_t * yctx, yutani_msg_t * m) {
if (m) {
switch (m->type) {
2018-07-20 16:15:46 +03:00
case YUTANI_MSG_KEY_EVENT:
{
struct yutani_msg_key_event * me = (void*)m->data;
2021-05-31 04:47:02 +03:00
if (hashmap_has(menu_windows, (void*)(uintptr_t)me->wid)) {
yutani_window_t * window = hashmap_get(menu_windows, (void *)(uintptr_t)me->wid);
2018-07-20 16:15:46 +03:00
struct MenuList * menu = window->user_data;
menu_key_action(menu, me);
}
}
break;
2018-04-24 14:58:41 +03:00
case YUTANI_MSG_WINDOW_MOUSE_EVENT:
{
struct yutani_msg_window_mouse_event * me = (void*)m->data;
2021-05-31 04:47:02 +03:00
if (hashmap_has(menu_windows, (void*)(uintptr_t)me->wid)) {
yutani_window_t * window = hashmap_get(menu_windows, (void *)(uintptr_t)me->wid);
2018-04-24 14:58:41 +03:00
struct MenuList * menu = window->user_data;
2018-05-19 13:05:27 +03:00
if (me->new_x >= 0 && me->new_x < (int)window->width && me->new_y >= 0 && me->new_y < (int)window->height) {
2018-05-19 13:43:00 +03:00
if (hovered_menu != menu) {
hovered_menu = menu;
}
2018-05-19 13:05:27 +03:00
} else {
2018-05-19 13:43:00 +03:00
if (hovered_menu) {
struct MenuList * t = menu_any_contains(me->new_x + window->x, me->new_y + window->y);
if (t) {
hovered_menu = t;
} else {
hovered_menu = NULL;
2018-04-24 14:58:41 +03:00
}
}
}
2018-05-19 13:43:00 +03:00
menu_mouse_action(menu, me);
2018-04-24 14:58:41 +03:00
}
}
break;
case YUTANI_MSG_WINDOW_FOCUS_CHANGE:
{
2018-04-24 15:19:06 +03:00
struct yutani_msg_window_focus_change * me = (void*)m->data;
2021-05-31 04:47:02 +03:00
if (hashmap_has(menu_windows, (void*)(uintptr_t)me->wid)) {
yutani_window_t * window = hashmap_get(menu_windows, (void *)(uintptr_t)me->wid);
2018-04-24 15:19:06 +03:00
struct MenuList * menu = window->user_data;
if (!me->focused) {
/* XXX leave menu */
2018-05-19 13:05:27 +03:00
menu_leave(menu);
2018-04-24 15:19:06 +03:00
/* if root and not window.root.menus and window.root.focused */
return 1;
} else {
window->focused = me->focused;
/* Redraw? */
}
}
2018-04-24 14:58:41 +03:00
}
break;
default:
break;
}
}
2018-04-24 15:19:06 +03:00
return 0;
2018-04-24 14:58:41 +03:00
}
2018-07-21 11:56:10 +03:00
void menu_bar_render(struct menu_bar * self, gfx_context_t * ctx) {
int _x = self->x;
int _y = self->y;
int width = self->width;
int height = MENU_BAR_HEIGHT;
if (_x < 0) _x = 0;
if (_y < 0) _y = 0;
if (_x + width > ctx->width) width = ctx->width - _x;
if (_y + height > ctx->height) height = ctx->height - _y;
gfx_context_t * subctx = init_graphics_subregion(ctx, _x, _y, width, height);
2018-07-21 11:56:10 +03:00
uint32_t menu_bar_color = rgb(59,59,59);
draw_rectangle(subctx, 0, 0, width, height, menu_bar_color);
2018-07-21 11:56:10 +03:00
/* for each menu entry */
int offset = 0;
2018-07-21 11:56:10 +03:00
struct menu_bar_entries * _entries = self->entries;
if (!self->num_entries) {
while (_entries->title) {
_entries++;
self->num_entries++;
}
_entries = self->entries;
}
2018-07-21 11:56:10 +03:00
while (_entries->title) {
2021-07-19 07:49:30 +03:00
int w = string_width(_entries->title) + 11;
2021-05-31 04:47:02 +03:00
if ((self->active_menu && hashmap_has(menu_get_windows_hash(), (void*)(uintptr_t)self->active_menu_wid)) && _entries == self->active_entry) {
draw_rectangle(subctx, offset + 2, 0, w, height, rgb(93,163,236));
2018-07-21 11:56:10 +03:00
}
draw_string(subctx, offset + 7, 2, 0xFFFFFFFF, _entries->title);
2021-07-19 07:49:30 +03:00
offset += w;
2018-07-21 11:56:10 +03:00
_entries++;
}
free(subctx);
2018-07-21 11:56:10 +03:00
}
void menu_bar_show_menu(yutani_t * yctx, yutani_window_t * window, struct menu_bar * self, int offset, struct menu_bar_entries * _entries) {
struct MenuList * new_menu = menu_set_get_menu(self->set, _entries->action);
int i = 0;
if (offset == -1) {
/* Must calculate */
offset = self->x;
struct menu_bar_entries * e = self->entries;
while (e->title) {
if (e == _entries) break;
2018-09-24 06:22:00 +03:00
offset += string_width(e->title) + 10;
e++;
i++;
}
} else {
struct menu_bar_entries * e = self->entries;
while (e->title) {
if (e == _entries) break;
e++;
i++;
}
}
menu_prepare(new_menu, yctx);
yutani_window_move_relative(yctx, new_menu->window, window, offset, self->y + MENU_BAR_HEIGHT);
2021-08-12 04:36:58 +03:00
yutani_flip(yctx, new_menu->window);
2018-07-21 11:56:10 +03:00
self->active_menu = new_menu;
self->active_menu->_bar = self;
2018-07-21 11:56:10 +03:00
self->active_menu_wid = new_menu->window->wid;
self->active_entry = _entries;
self->active_entry_idx = i;
2018-07-21 11:56:10 +03:00
if (self->redraw_callback) {
self->redraw_callback(self);
2018-07-21 11:56:10 +03:00
}
}
int menu_bar_mouse_event(yutani_t * yctx, yutani_window_t * window, struct menu_bar * self, struct yutani_msg_window_mouse_event * me, int x, int y) {
if (x < self->x || x >= self->x + self->width || y < self->y || y >= self->y + 24 /* base height */) {
return 0;
}
int offset = self->x;
struct menu_bar_entries * _entries = self->entries;
while (_entries->title) {
2021-07-19 07:49:30 +03:00
int w = string_width(_entries->title) + 11;
2018-07-21 11:56:10 +03:00
if (x >= offset && x < offset + w) {
if (me->command == YUTANI_MOUSE_EVENT_CLICK || _close_enough(me)) {
menu_bar_show_menu(yctx, window, self,offset,_entries);
2021-05-31 04:47:02 +03:00
} else if (self->active_menu && hashmap_has(menu_get_windows_hash(), (void*)(uintptr_t)self->active_menu_wid) && _entries != self->active_entry) {
2018-07-21 11:56:10 +03:00
menu_definitely_close(self->active_menu);
menu_bar_show_menu(yctx, window, self,offset,_entries);
}
}
offset += w;
_entries++;
}
if (x >= offset && me->command == YUTANI_MOUSE_EVENT_DOWN && me->buttons & YUTANI_MOUSE_BUTTON_LEFT) {
yutani_window_drag_start(yctx, window);
}
2018-07-21 11:56:10 +03:00
return 0;
}