repos/blastem: nuklear_ui/nuklear.h comparison

comparison nuklear_ui/nuklear.h @ 1931:374a5ae694e8 mame_interp

Merge from default

author	Michael Pavone <pavone@retrodev.com>
date	Sat, 18 Apr 2020 11:42:53 -0700
parents	13abdc98379e 92532eb6986d
children	638eb2d25696

comparison

equal deleted inserted replaced

-:13abdc98379e
+:374a5ae694e8
 NK_WIDGET_STATE_ACTIVED     = NK_FLAG(5),/* widget is currently activated */
 NK_WIDGET_STATE_LEFT        = NK_FLAG(6), /* widget is from this frame on not hovered anymore */
 NK_WIDGET_STATE_HOVERED     = NK_WIDGET_STATE_HOVER|NK_WIDGET_STATE_MODIFIED, /* widget is being hovered */
 NK_WIDGET_STATE_ACTIVE      = NK_WIDGET_STATE_ACTIVED|NK_WIDGET_STATE_MODIFIED /* widget is currently activated */
 };
-NK_API enum nk_widget_layout_states nk_widget(struct nk_rect*, const struct nk_context*);
+NK_API enum nk_widget_layout_states nk_widget(struct nk_rect*, struct nk_context*);
+NK_API enum nk_widget_layout_states nk_keynav_widget(struct nk_rect *, struct nk_context *);
 NK_API enum nk_widget_layout_states nk_widget_fitting(struct nk_rect*, struct nk_context*, struct nk_vec2);
 NK_API struct nk_rect nk_widget_bounds(struct nk_context*);
 NK_API struct nk_vec2 nk_widget_position(struct nk_context*);
 NK_API struct nk_vec2 nk_widget_size(struct nk_context*);
 NK_API float nk_widget_width(struct nk_context*);
 };
 struct nk_input {
 struct nk_keyboard keyboard;
 struct nk_mouse mouse;
+	int widget_counter;
+	int selected_widget;
 };
 NK_API int nk_input_has_mouse_click(const struct nk_input*, enum nk_buttons);
 NK_API int nk_input_has_mouse_click_in_rect(const struct nk_input*, enum nk_buttons, struct nk_rect);
 NK_API int nk_input_has_mouse_click_down_in_rect(const struct nk_input*, enum nk_buttons, struct nk_rect, int down);
 in->mouse.prev.y = in->mouse.pos.y;
 in->mouse.delta.x = 0;
 in->mouse.delta.y = 0;
 for (i = 0; i < NK_KEY_MAX; i++)
 in->keyboard.keys[i].clicked = 0;
+	in->widget_counter = -1;
 }
 NK_API void
 nk_input_end(struct nk_context *ctx)
 {
 struct nk_rect b)
 {
 const struct nk_mouse_button *btn;
 if (!i) return nk_false;
 btn = &i->mouse.buttons[id];
-if (!NK_INBOX(btn->clicked_pos.x,btn->clicked_pos.y,b.x,b.y,b.w,b.h))
+if (NK_INBOX(btn->clicked_pos.x,btn->clicked_pos.y,b.x,b.y,b.w,b.h))
-return nk_false;
+return nk_true;
-return nk_true;
+	if (i->selected_widget == i->widget_counter && i->keyboard.keys[NK_KEY_ENTER].clicked)
+		return nk_true;
+return nk_false;
 }
 NK_API int
 nk_input_has_mouse_click_down_in_rect(const struct nk_input *i, enum nk_buttons id,
 struct nk_rect b, int down)
 NK_API int
 nk_input_is_mouse_hovering_rect(const struct nk_input *i, struct nk_rect rect)
 {
 if (!i) return nk_false;
-return NK_INBOX(i->mouse.pos.x, i->mouse.pos.y, rect.x, rect.y, rect.w, rect.h);
+return i->selected_widget == i->widget_counter || NK_INBOX(i->mouse.pos.x, i->mouse.pos.y, rect.x, rect.y, rect.w, rect.h);
 }
 NK_API int
 nk_input_is_mouse_prev_hovering_rect(const struct nk_input *i, struct nk_rect rect)
 {
 NK_API int
 nk_input_is_mouse_down(const struct nk_input *i, enum nk_buttons id)
 {
 if (!i) return nk_false;
-return i->mouse.buttons[id].down;
+return i->mouse.buttons[id].down || (
+		id == NK_BUTTON_LEFT && i->widget_counter == i->selected_widget && i->keyboard.keys[NK_KEY_ENTER].down
+	);
 }
 NK_API int
 nk_input_is_mouse_pressed(const struct nk_input *i, enum nk_buttons id)
 {
 const struct nk_mouse_button *b;
 if (!i) return nk_false;
 b = &i->mouse.buttons[id];
 if (b->down && b->clicked)
 return nk_true;
+	if (
+		id == NK_BUTTON_LEFT && i->widget_counter == i->selected_widget
+		&& i->keyboard.keys[NK_KEY_ENTER].down && i->keyboard.keys[NK_KEY_ENTER].clicked
+	)
+		return nk_true;
 return nk_false;
 }
 NK_API int
 nk_input_is_mouse_released(const struct nk_input *i, enum nk_buttons id)
 {
 if (!i) return nk_false;
-return (!i->mouse.buttons[id].down && i->mouse.buttons[id].clicked);
+if (!i->mouse.buttons[id].down && i->mouse.buttons[id].clicked)
+		return nk_true;
+	if (
+		id == NK_BUTTON_LEFT && i->widget_counter == i->selected_widget
+		&& !i->keyboard.keys[NK_KEY_ENTER].down && i->keyboard.keys[NK_KEY_ENTER].clicked
+	)
+		return nk_true;
+	return nk_false;
 }
 NK_API int
 nk_input_is_key_pressed(const struct nk_input *i, enum nk_keys key)
 {
 }
 NK_INTERN int
 nk_do_selectable(nk_flags *state, struct nk_command_buffer *out,
 struct nk_rect bounds, const char *str, int len, nk_flags align, int *value,
-const struct nk_style_selectable *style, const struct nk_input *in,
+const struct nk_style_selectable *style, struct nk_input *in,
 const struct nk_user_font *font)
 {
 int old_value;
 struct nk_rect touch;
 touch.h = bounds.h + style->touch_padding.y * 2;
 /* update button */
 if (nk_button_behavior(state, touch, in, NK_BUTTON_DEFAULT))
 *value = !(*value);
+	if (!old_value && !(*value) && in && in->selected_widget == in->widget_counter) {
+		*value = 1;
+	} else if (!old_value && *value && in) {
+		in->selected_widget = in->widget_counter;
+	}
 /* draw selectable */
 if (style->draw_begin) style->draw_begin(out, style->userdata);
 nk_draw_selectable(out, *state, style, *value, &bounds, 0,0, str, len, align, font);
 if (style->draw_end) style->draw_end(out, style->userdata);
 /* draw property */
 if (style->draw_begin) style->draw_begin(out, style->userdata);
 nk_draw_property(out, style, &property, &label, *ws, name, name_len, font);
 if (style->draw_end) style->draw_end(out, style->userdata);
-/* execute right button  */
+	int selected = in && in->selected_widget == in->widget_counter;
-if (nk_do_button_symbol(ws, out, left, style->sym_left, behavior, &style->dec_button, in, font)) {
+	int enter_clicked;
+	if (selected) {
+		//prevent left/right buttons from activating when enter is pressed
+		enter_clicked = in->keyboard.keys[NK_KEY_ENTER].clicked;
+		in->keyboard.keys[NK_KEY_ENTER].clicked = 0;
+	}
+/* execute left button  */
+if (
+		nk_do_button_symbol(ws, out, left, style->sym_left, behavior, &style->dec_button, in, font)
+		|| (selected && in->keyboard.keys[NK_KEY_LEFT].clicked && in->keyboard.keys[NK_KEY_LEFT].down)
+	) {
 switch (variant->kind) {
 default: break;
 case NK_PROPERTY_INT:
 variant->value.i = NK_CLAMP(variant->min_value.i, variant->value.i - variant->step.i, variant->max_value.i); break;
 case NK_PROPERTY_FLOAT:
 variant->value.f = NK_CLAMP(variant->min_value.f, variant->value.f - variant->step.f, variant->max_value.f); break;
 case NK_PROPERTY_DOUBLE:
 variant->value.d = NK_CLAMP(variant->min_value.d, variant->value.d - variant->step.d, variant->max_value.d); break;
 }
 }
-/* execute left button  */
+/* execute right button  */
-if (nk_do_button_symbol(ws, out, right, style->sym_right, behavior, &style->inc_button, in, font)) {
+if (
+		nk_do_button_symbol(ws, out, right, style->sym_right, behavior, &style->inc_button, in, font)
+		|| (selected && in->keyboard.keys[NK_KEY_RIGHT].clicked && in->keyboard.keys[NK_KEY_RIGHT].down)
+	) {
 switch (variant->kind) {
 default: break;
 case NK_PROPERTY_INT:
 variant->value.i = NK_CLAMP(variant->min_value.i, variant->value.i + variant->step.i, variant->max_value.i); break;
 case NK_PROPERTY_FLOAT:
 variant->value.f = NK_CLAMP(variant->min_value.f, variant->value.f + variant->step.f, variant->max_value.f); break;
 case NK_PROPERTY_DOUBLE:
 variant->value.d = NK_CLAMP(variant->min_value.d, variant->value.d + variant->step.d, variant->max_value.d); break;
 }
 }
+	if (selected) {
+		in->keyboard.keys[NK_KEY_ENTER].clicked = enter_clicked;
+	}
 if (old != NK_PROPERTY_EDIT && (*state == NK_PROPERTY_EDIT)) {
 /* property has been activated so setup buffer */
 NK_MEMCPY(buffer, dst, (nk_size)*length);
 *cursor = nk_utf_len(buffer, *length);
 *len = *length;
 ctx->seq = 1;
 if (font) ctx->style.font = font;
 #ifdef NK_INCLUDE_VERTEX_BUFFER_OUTPUT
 nk_draw_list_init(&ctx->draw_list);
 #endif
+	ctx->input.widget_counter = -1;
 }
 #ifdef NK_INCLUDE_DEFAULT_ALLOCATOR
 NK_API int
 nk_init_default(struct nk_context *ctx, const struct nk_user_font *font)
 return 0;
 return nk_input_has_mouse_click_down_in_rect(&ctx->input, btn, bounds, down);
 }
 NK_API enum nk_widget_layout_states
-nk_widget(struct nk_rect *bounds, const struct nk_context *ctx)
+nk_widget_gen(struct nk_rect *bounds, struct nk_context *ctx, nk_byte is_keynav)
 {
 struct nk_rect c, v;
 struct nk_window *win;
 struct nk_panel *layout;
 const struct nk_input *in;
 c.x = (float)((int)c.x);
 c.y = (float)((int)c.y);
 c.w = (float)((int)c.w);
 c.h = (float)((int)c.h);
+	int newly_selected = nk_false;
+	if (is_keynav) {
+		ctx->input.widget_counter++;
+		if (
+			ctx->input.selected_widget == (ctx->input.widget_counter + 1) &&
+			ctx->input.keyboard.keys[NK_KEY_UP].clicked && ctx->input.keyboard.keys[NK_KEY_UP].down
+		) {
+			ctx->input.selected_widget--;
+			newly_selected = nk_true;
+		} else if (
+			ctx->input.selected_widget == (ctx->input.widget_counter - 1) &&
+			ctx->input.keyboard.keys[NK_KEY_DOWN].clicked && ctx->input.keyboard.keys[NK_KEY_DOWN].down
+		) {
+			ctx->input.keyboard.keys[NK_KEY_DOWN].clicked = 0;
+			ctx->input.selected_widget++;
+			newly_selected = nk_true;
+		}
+	}
 nk_unify(&v, &c, bounds->x, bounds->y, bounds->x + bounds->w, bounds->y + bounds->h);
+	if (is_keynav && newly_selected) {
+		//ensure widget is fully on-screen if it was newly selected via a keyboard action
+		if ((bounds->y + bounds->h) > (c.y + c.h)) {
+			*layout->offset_y += bounds->y + bounds->h - (c.y + c.h);
+		} else if(c.y > bounds->y){
+			*layout->offset_y -= c.y - bounds->y;
+		}
+	}
 if (!NK_INTERSECT(c.x, c.y, c.w, c.h, bounds->x, bounds->y, bounds->w, bounds->h))
 return NK_WIDGET_INVALID;
-if (!NK_INBOX(in->mouse.pos.x, in->mouse.pos.y, v.x, v.y, v.w, v.h))
+if ((is_keynav && ctx->input.selected_widget == ctx->input.widget_counter ) || NK_INBOX(in->mouse.pos.x, in->mouse.pos.y, v.x, v.y, v.w, v.h))
-return NK_WIDGET_ROM;
+return NK_WIDGET_VALID;
-return NK_WIDGET_VALID;
+return NK_WIDGET_ROM;
+}
+NK_API enum nk_widget_layout_states
+nk_widget(struct nk_rect *bounds, struct nk_context *ctx)
+{
+	return nk_widget_gen(bounds, ctx, 0);
+}
+NK_API enum nk_widget_layout_states
+nk_keynav_widget(struct nk_rect *bounds, struct nk_context *ctx)
+{
+	return nk_widget_gen(bounds, ctx, 1);
 }
 NK_API enum nk_widget_layout_states
 nk_widget_fitting(struct nk_rect *bounds, struct nk_context *ctx,
 struct nk_vec2 item_padding)
 return NK_WIDGET_INVALID;
 win = ctx->current;
 style = &ctx->style;
 layout = win->layout;
-state = nk_widget(bounds, ctx);
+state = nk_keynav_widget(bounds, ctx);
 panel_padding = nk_panel_get_padding(style, layout->type);
 if (layout->row.index == 1) {
 bounds->w += panel_padding.x;
 bounds->x -= panel_padding.x;
 NK_ASSERT(ctx->current->layout);
 if (!style || !ctx || !ctx->current || !ctx->current->layout) return 0;
 win = ctx->current;
 layout = win->layout;
-state = nk_widget(&bounds, ctx);
+state = nk_keynav_widget(&bounds, ctx);
 if (!state) return 0;
 in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
-return nk_do_button_text(&ctx->last_widget_state, &win->buffer, bounds,
+int ret = nk_do_button_text(&ctx->last_widget_state, &win->buffer, bounds,
 title, len, style->text_alignment, ctx->button_behavior,
 style, in, ctx->style.font);
+	if (ctx->last_widget_state & NK_WIDGET_STATE_ENTERED) {
+		ctx->input.selected_widget = ctx->input.widget_counter;
+	}
+	return ret;
 }
 NK_API int
 nk_button_text(struct nk_context *ctx, const char *title, int len)
 {
 return 0;
 win = ctx->current;
 layout = win->layout;
-state = nk_widget(&bounds, ctx);
+state = nk_keynav_widget(&bounds, ctx);
 if (!state) return 0;
 in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
 button = ctx->style.button;
 button.normal = nk_style_item_color(color);
 button.hover = nk_style_item_color(color);
 button.active = nk_style_item_color(color);
 ret = nk_do_button(&ctx->last_widget_state, &win->buffer, bounds,
 &button, in, ctx->button_behavior, &content);
 nk_draw_button(&win->buffer, &bounds, ctx->last_widget_state, &button);
+	if (ctx->last_widget_state & NK_WIDGET_STATE_ENTERED) {
+		ctx->input.selected_widget = ctx->input.widget_counter;
+	}
 return ret;
 }
 NK_API int
 nk_button_symbol_styled(struct nk_context *ctx,
 if (!ctx || !ctx->current || !ctx->current->layout)
 return 0;
 win = ctx->current;
 layout = win->layout;
-state = nk_widget(&bounds, ctx);
+state = nk_keynav_widget(&bounds, ctx);
 if (!state) return 0;
 in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
-return nk_do_button_symbol(&ctx->last_widget_state, &win->buffer, bounds,
+int ret = nk_do_button_symbol(&ctx->last_widget_state, &win->buffer, bounds,
 symbol, ctx->button_behavior, style, in, ctx->style.font);
+	if (ctx->last_widget_state & NK_WIDGET_STATE_ENTERED) {
+		ctx->input.selected_widget = ctx->input.widget_counter;
+	}
+	return ret;
 }
 NK_API int
 nk_button_symbol(struct nk_context *ctx, enum nk_symbol_type symbol)
 {
 return 0;
 win = ctx->current;
 layout = win->layout;
-state = nk_widget(&bounds, ctx);
+state = nk_keynav_widget(&bounds, ctx);
 if (!state) return 0;
 in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
 return nk_do_button_image(&ctx->last_widget_state, &win->buffer, bounds,
 img, ctx->button_behavior, style, in);
 }
 return 0;
 win = ctx->current;
 layout = win->layout;
-state = nk_widget(&bounds, ctx);
+state = nk_keynav_widget(&bounds, ctx);
 if (!state) return 0;
 in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
 return nk_do_button_text_symbol(&ctx->last_widget_state, &win->buffer, bounds,
 symbol, text, len, align, ctx->button_behavior,
 style, ctx->style.font, in);
 return 0;
 win = ctx->current;
 layout = win->layout;
-state = nk_widget(&bounds, ctx);
+state = nk_keynav_widget(&bounds, ctx);
 if (!state) return 0;
 in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
 return nk_do_button_text_image(&ctx->last_widget_state, &win->buffer,
 bounds, img, text, len, align, ctx->button_behavior,
 style, ctx->style.font, in);
 nk_selectable_text(struct nk_context *ctx, const char *str, int len,
 nk_flags align, int *value)
 {
 struct nk_window *win;
 struct nk_panel *layout;
-const struct nk_input *in;
+struct nk_input *in;
 const struct nk_style *style;
 enum nk_widget_layout_states state;
 struct nk_rect bounds;
 win = ctx->current;
 layout = win->layout;
 style = &ctx->style;
-state = nk_widget(&bounds, ctx);
+state = nk_keynav_widget(&bounds, ctx);
 if (!state) return 0;
 in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
 return nk_do_selectable(&ctx->last_widget_state, &win->buffer, bounds,
 str, len, align, value, &style->selectable, in, style->font);
 }
 win = ctx->current;
 style = &ctx->style;
 layout = win->layout;
-state = nk_widget(&bounds, ctx);
+state = nk_keynav_widget(&bounds, ctx);
 if (!state) return active;
 in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
 nk_do_toggle(&ctx->last_widget_state, &win->buffer, bounds, &active,
 text, len, NK_TOGGLE_CHECK, &style->checkbox, in, style->font);
 return active;
 return;
 win = ctx->current;
 layout = win->layout;
 style = &ctx->style;
-s = nk_widget(&bounds, ctx);
+s = nk_keynav_widget(&bounds, ctx);
 if (!s) return;
 /* calculate hash from name */
 if (name[0] == '#') {
 hash = nk_murmur_hash(name, (int)nk_strlen(name), win->property.seq++);
 win->property.select_end = *select_end;
 if (*state == NK_PROPERTY_DRAG) {
 ctx->input.mouse.grab = nk_true;
 ctx->input.mouse.grabbed = nk_true;
 }
+		ctx->input.selected_widget = ctx->input.widget_counter;
 }
 /* check if previously active property is now inactive */
 if (*state == NK_PROPERTY_DEFAULT && old_state != NK_PROPERTY_DEFAULT) {
 if (old_state == NK_PROPERTY_DRAG) {
 ctx->input.mouse.grab = nk_false;
 struct nk_vec2 padding = nk_panel_get_padding(&ctx->style, panel->type);
 body = panel->bounds;
 body.y = (panel->at_y + panel->footer_height + panel->border + padding.y + panel->row.height);
 body.h = (panel->bounds.y + panel->bounds.h) - body.y;
 }
+		int selected = ctx->input.selected_widget;
+		ctx->input.selected_widget = -1;
 {int pressed = nk_input_is_mouse_pressed(&ctx->input, NK_BUTTON_LEFT);
 int in_body = nk_input_is_mouse_hovering_rect(&ctx->input, body);
+		ctx->input.selected_widget = selected;
 if (pressed && in_body)
 popup->flags |= NK_WINDOW_HIDDEN;
 }
 }
 if (popup->flags & NK_WINDOW_HIDDEN)
 if (!ctx || !ctx->current || !ctx->current->layout || !selected)
 return 0;
 win = ctx->current;
 style = &ctx->style;
-s = nk_widget(&header, ctx);
+s = nk_keynav_widget(&header, ctx);
 if (s == NK_WIDGET_INVALID)
 return 0;
 in = (win->layout->flags & NK_WINDOW_ROM || s == NK_WIDGET_ROM)? 0: &ctx->input;
 if (nk_button_behavior(&ctx->last_widget_state, header, in, NK_BUTTON_DEFAULT))
 max_height = count * item_height + count * (int)item_spacing.y;
 max_height += (int)item_spacing.y * 2 + (int)window_padding.y * 2;
 size.y = NK_MIN(size.y, (float)max_height);
 if (nk_combo_begin_label(ctx, items[selected], size)) {
 nk_layout_row_dynamic(ctx, (float)item_height, 1);
+		int main_item_widget = ctx->input.widget_counter;
 for (i = 0; i < count; ++i) {
-if (nk_combo_item_label(ctx, items[i], NK_TEXT_LEFT))
+if (nk_combo_item_label(ctx, items[i], NK_TEXT_LEFT)) {
 selected = i;
+				ctx->input.selected_widget = main_item_widget;
+				//prevent below code from advancing selected widget
+				main_item_widget--;
+			}
 }
 nk_combo_end(ctx);
+		if (ctx->input.selected_widget <= main_item_widget) {
+			ctx->input.selected_widget = main_item_widget + 1;
+		} else if (ctx->input.selected_widget > main_item_widget + count) {
+			ctx->input.selected_widget = main_item_widget + count;
+		}
 }
 return selected;
 }
 NK_API int

Mercurial > repos > blastem

comparison nuklear_ui/nuklear.h @ 1931:374a5ae694e8 mame_interp