262 lines
8.9 KiB
C
262 lines
8.9 KiB
C
|
#include "nuklear.h"
|
||
|
|
#include "nuklear_internal.h"
|
||
|
|
|
||
|
|
/* ===============================================================
|
||
|
|
*
|
||
|
|
* SLIDER
|
||
|
|
*
|
||
|
|
* ===============================================================*/
|
||
|
|
NK_LIB float
|
||
|
|
nk_slider_behavior(nk_flags *state, struct nk_rect *logical_cursor,
|
||
|
|
struct nk_rect *visual_cursor, struct nk_input *in,
|
||
|
|
struct nk_rect bounds, float slider_min, float slider_max, float slider_value,
|
||
|
|
float slider_step, float slider_steps)
|
||
|
|
{
|
||
|
|
int left_mouse_down;
|
||
|
|
int left_mouse_click_in_cursor;
|
||
|
|
|
||
|
|
/* check if visual cursor is being dragged */
|
||
|
|
nk_widget_state_reset(state);
|
||
|
|
left_mouse_down = in && in->mouse.buttons[NK_BUTTON_LEFT].down;
|
||
|
|
left_mouse_click_in_cursor = in && nk_input_has_mouse_click_down_in_rect(in,
|
||
|
|
NK_BUTTON_LEFT, *visual_cursor, nk_true);
|
||
|
|
|
||
|
|
if (left_mouse_down && left_mouse_click_in_cursor) {
|
||
|
|
float ratio = 0;
|
||
|
|
const float d = in->mouse.pos.x - (visual_cursor->x+visual_cursor->w*0.5f);
|
||
|
|
const float pxstep = bounds.w / slider_steps;
|
||
|
|
|
||
|
|
/* only update value if the next slider step is reached */
|
||
|
|
*state = NK_WIDGET_STATE_ACTIVE;
|
||
|
|
if (NK_ABS(d) >= pxstep) {
|
||
|
|
const float steps = (float)((int)(NK_ABS(d) / pxstep));
|
||
|
|
slider_value += (d > 0) ? (slider_step*steps) : -(slider_step*steps);
|
||
|
|
slider_value = NK_CLAMP(slider_min, slider_value, slider_max);
|
||
|
|
ratio = (slider_value - slider_min)/slider_step;
|
||
|
|
logical_cursor->x = bounds.x + (logical_cursor->w * ratio);
|
||
|
|
in->mouse.buttons[NK_BUTTON_LEFT].clicked_pos.x = logical_cursor->x;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* slider widget state */
|
||
|
|
if (nk_input_is_mouse_hovering_rect(in, bounds))
|
||
|
|
*state = NK_WIDGET_STATE_HOVERED;
|
||
|
|
if (*state & NK_WIDGET_STATE_HOVER &&
|
||
|
|
!nk_input_is_mouse_prev_hovering_rect(in, bounds))
|
||
|
|
*state |= NK_WIDGET_STATE_ENTERED;
|
||
|
|
else if (nk_input_is_mouse_prev_hovering_rect(in, bounds))
|
||
|
|
*state |= NK_WIDGET_STATE_LEFT;
|
||
|
|
return slider_value;
|
||
|
|
}
|
||
|
|
NK_LIB void
|
||
|
|
nk_draw_slider(struct nk_command_buffer *out, nk_flags state,
|
||
|
|
const struct nk_style_slider *style, const struct nk_rect *bounds,
|
||
|
|
const struct nk_rect *visual_cursor, float min, float value, float max)
|
||
|
|
{
|
||
|
|
struct nk_rect fill;
|
||
|
|
struct nk_rect bar;
|
||
|
|
const struct nk_style_item *background;
|
||
|
|
|
||
|
|
/* select correct slider images/colors */
|
||
|
|
struct nk_color bar_color;
|
||
|
|
const struct nk_style_item *cursor;
|
||
|
|
|
||
|
|
NK_UNUSED(min);
|
||
|
|
NK_UNUSED(max);
|
||
|
|
NK_UNUSED(value);
|
||
|
|
|
||
|
|
if (state & NK_WIDGET_STATE_ACTIVED) {
|
||
|
|
background = &style->active;
|
||
|
|
bar_color = style->bar_active;
|
||
|
|
cursor = &style->cursor_active;
|
||
|
|
} else if (state & NK_WIDGET_STATE_HOVER) {
|
||
|
|
background = &style->hover;
|
||
|
|
bar_color = style->bar_hover;
|
||
|
|
cursor = &style->cursor_hover;
|
||
|
|
} else {
|
||
|
|
background = &style->normal;
|
||
|
|
bar_color = style->bar_normal;
|
||
|
|
cursor = &style->cursor_normal;
|
||
|
|
}
|
||
|
|
/* calculate slider background bar */
|
||
|
|
bar.x = bounds->x;
|
||
|
|
bar.y = (visual_cursor->y + visual_cursor->h/2) - bounds->h/12;
|
||
|
|
bar.w = bounds->w;
|
||
|
|
bar.h = bounds->h/6;
|
||
|
|
|
||
|
|
/* filled background bar style */
|
||
|
|
fill.w = (visual_cursor->x + (visual_cursor->w/2.0f)) - bar.x;
|
||
|
|
fill.x = bar.x;
|
||
|
|
fill.y = bar.y;
|
||
|
|
fill.h = bar.h;
|
||
|
|
|
||
|
|
/* draw background */
|
||
|
|
switch(background->type) {
|
||
|
|
case NK_STYLE_ITEM_IMAGE:
|
||
|
|
nk_draw_image(out, *bounds, &background->data.image, nk_white);
|
||
|
|
break;
|
||
|
|
case NK_STYLE_ITEM_NINE_SLICE:
|
||
|
|
nk_draw_nine_slice(out, *bounds, &background->data.slice, nk_white);
|
||
|
|
break;
|
||
|
|
case NK_STYLE_ITEM_COLOR:
|
||
|
|
nk_fill_rect(out, *bounds, style->rounding, background->data.color);
|
||
|
|
nk_stroke_rect(out, *bounds, style->rounding, style->border, style->border_color);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* draw slider bar */
|
||
|
|
nk_fill_rect(out, bar, style->rounding, bar_color);
|
||
|
|
nk_fill_rect(out, fill, style->rounding, style->bar_filled);
|
||
|
|
|
||
|
|
/* draw cursor */
|
||
|
|
if (cursor->type == NK_STYLE_ITEM_IMAGE)
|
||
|
|
nk_draw_image(out, *visual_cursor, &cursor->data.image, nk_white);
|
||
|
|
else
|
||
|
|
nk_fill_circle(out, *visual_cursor, cursor->data.color);
|
||
|
|
}
|
||
|
|
NK_LIB float
|
||
|
|
nk_do_slider(nk_flags *state,
|
||
|
|
struct nk_command_buffer *out, struct nk_rect bounds,
|
||
|
|
float min, float val, float max, float step,
|
||
|
|
const struct nk_style_slider *style, struct nk_input *in,
|
||
|
|
const struct nk_user_font *font)
|
||
|
|
{
|
||
|
|
float slider_range;
|
||
|
|
float slider_min;
|
||
|
|
float slider_max;
|
||
|
|
float slider_value;
|
||
|
|
float slider_steps;
|
||
|
|
float cursor_offset;
|
||
|
|
|
||
|
|
struct nk_rect visual_cursor;
|
||
|
|
struct nk_rect logical_cursor;
|
||
|
|
|
||
|
|
NK_ASSERT(style);
|
||
|
|
NK_ASSERT(out);
|
||
|
|
if (!out || !style)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
/* remove padding from slider bounds */
|
||
|
|
bounds.x = bounds.x + style->padding.x;
|
||
|
|
bounds.y = bounds.y + style->padding.y;
|
||
|
|
bounds.h = NK_MAX(bounds.h, 2*style->padding.y);
|
||
|
|
bounds.w = NK_MAX(bounds.w, 2*style->padding.x + style->cursor_size.x);
|
||
|
|
bounds.w -= 2 * style->padding.x;
|
||
|
|
bounds.h -= 2 * style->padding.y;
|
||
|
|
|
||
|
|
/* optional buttons */
|
||
|
|
if (style->show_buttons) {
|
||
|
|
nk_flags ws;
|
||
|
|
struct nk_rect button;
|
||
|
|
button.y = bounds.y;
|
||
|
|
button.w = bounds.h;
|
||
|
|
button.h = bounds.h;
|
||
|
|
|
||
|
|
/* decrement button */
|
||
|
|
button.x = bounds.x;
|
||
|
|
if (nk_do_button_symbol(&ws, out, button, style->dec_symbol, NK_BUTTON_DEFAULT,
|
||
|
|
&style->dec_button, in, font))
|
||
|
|
val -= step;
|
||
|
|
|
||
|
|
/* increment button */
|
||
|
|
button.x = (bounds.x + bounds.w) - button.w;
|
||
|
|
if (nk_do_button_symbol(&ws, out, button, style->inc_symbol, NK_BUTTON_DEFAULT,
|
||
|
|
&style->inc_button, in, font))
|
||
|
|
val += step;
|
||
|
|
|
||
|
|
bounds.x = bounds.x + button.w + style->spacing.x;
|
||
|
|
bounds.w = bounds.w - (2*button.w + 2*style->spacing.x);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* remove one cursor size to support visual cursor */
|
||
|
|
bounds.x += style->cursor_size.x*0.5f;
|
||
|
|
bounds.w -= style->cursor_size.x;
|
||
|
|
|
||
|
|
/* make sure the provided values are correct */
|
||
|
|
slider_max = NK_MAX(min, max);
|
||
|
|
slider_min = NK_MIN(min, max);
|
||
|
|
slider_value = NK_CLAMP(slider_min, val, slider_max);
|
||
|
|
slider_range = slider_max - slider_min;
|
||
|
|
slider_steps = slider_range / step;
|
||
|
|
cursor_offset = (slider_value - slider_min) / step;
|
||
|
|
|
||
|
|
/* calculate cursor
|
||
|
|
Basically you have two cursors. One for visual representation and interaction
|
||
|
|
and one for updating the actual cursor value. */
|
||
|
|
logical_cursor.h = bounds.h;
|
||
|
|
logical_cursor.w = bounds.w / slider_steps;
|
||
|
|
logical_cursor.x = bounds.x + (logical_cursor.w * cursor_offset);
|
||
|
|
logical_cursor.y = bounds.y;
|
||
|
|
|
||
|
|
visual_cursor.h = style->cursor_size.y;
|
||
|
|
visual_cursor.w = style->cursor_size.x;
|
||
|
|
visual_cursor.y = (bounds.y + bounds.h*0.5f) - visual_cursor.h*0.5f;
|
||
|
|
visual_cursor.x = logical_cursor.x - visual_cursor.w*0.5f;
|
||
|
|
|
||
|
|
slider_value = nk_slider_behavior(state, &logical_cursor, &visual_cursor,
|
||
|
|
in, bounds, slider_min, slider_max, slider_value, step, slider_steps);
|
||
|
|
visual_cursor.x = logical_cursor.x - visual_cursor.w*0.5f;
|
||
|
|
|
||
|
|
/* draw slider */
|
||
|
|
if (style->draw_begin) style->draw_begin(out, style->userdata);
|
||
|
|
nk_draw_slider(out, *state, style, &bounds, &visual_cursor, slider_min, slider_value, slider_max);
|
||
|
|
if (style->draw_end) style->draw_end(out, style->userdata);
|
||
|
|
return slider_value;
|
||
|
|
}
|
||
|
|
NK_API nk_bool
|
||
|
|
nk_slider_float(struct nk_context *ctx, float min_value, float *value, float max_value,
|
||
|
|
float value_step)
|
||
|
|
{
|
||
|
|
struct nk_window *win;
|
||
|
|
struct nk_panel *layout;
|
||
|
|
struct nk_input *in;
|
||
|
|
const struct nk_style *style;
|
||
|
|
|
||
|
|
int ret = 0;
|
||
|
|
float old_value;
|
||
|
|
struct nk_rect bounds;
|
||
|
|
enum nk_widget_layout_states state;
|
||
|
|
|
||
|
|
NK_ASSERT(ctx);
|
||
|
|
NK_ASSERT(ctx->current);
|
||
|
|
NK_ASSERT(ctx->current->layout);
|
||
|
|
NK_ASSERT(value);
|
||
|
|
if (!ctx || !ctx->current || !ctx->current->layout || !value)
|
||
|
|
return ret;
|
||
|
|
|
||
|
|
win = ctx->current;
|
||
|
|
style = &ctx->style;
|
||
|
|
layout = win->layout;
|
||
|
|
|
||
|
|
state = nk_widget(&bounds, ctx);
|
||
|
|
if (!state) return ret;
|
||
|
|
in = (/*state == NK_WIDGET_ROM || */ layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
|
||
|
|
|
||
|
|
old_value = *value;
|
||
|
|
*value = nk_do_slider(&ctx->last_widget_state, &win->buffer, bounds, min_value,
|
||
|
|
old_value, max_value, value_step, &style->slider, in, style->font);
|
||
|
|
return (old_value > *value || old_value < *value);
|
||
|
|
}
|
||
|
|
NK_API float
|
||
|
|
nk_slide_float(struct nk_context *ctx, float min, float val, float max, float step)
|
||
|
|
{
|
||
|
|
nk_slider_float(ctx, min, &val, max, step); return val;
|
||
|
|
}
|
||
|
|
NK_API int
|
||
|
|
nk_slide_int(struct nk_context *ctx, int min, int val, int max, int step)
|
||
|
|
{
|
||
|
|
float value = (float)val;
|
||
|
|
nk_slider_float(ctx, (float)min, &value, (float)max, (float)step);
|
||
|
|
return (int)value;
|
||
|
|
}
|
||
|
|
NK_API nk_bool
|
||
|
|
nk_slider_int(struct nk_context *ctx, int min, int *val, int max, int step)
|
||
|
|
{
|
||
|
|
int ret;
|
||
|
|
float value = (float)*val;
|
||
|
|
ret = nk_slider_float(ctx, (float)min, &value, (float)max, (float)step);
|
||
|
|
*val = (int)value;
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|