mirrors
/
Nuklear
mirror of https://github.com/Immediate-Mode-UI/Nuklear
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rewrote command buffer

This commit is contained in:
vurtun 2015-03-11 14:00:59 +01:00
parent 124859f16e
commit 3197437cac
5 changed files with 456 additions and 430 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
Makefile
View File

@ -6,14 +6,14 @@ CC = gcc
DCC = clang
# Flags
CFLAGS = -std=c89 -pedantic-errors -Wno-deprecated-declarations -D_POSIX_C_SOURCE=200809L
CFLAGS += -g -Wall -Wextra -Werror -Wformat -Wunreachable-code
CFLAGS += -Winline -Wshadow -Wwrite-strings
CFLAGS += -Wstrict-prototypes -Wold-style-definition
CFLAGS = -std=c89 -pedantic-errors -Wdeprecated-declarations -D_POSIX_C_SOURCE=200809L
CFLAGS = -g -Wextra -Werror -Wformat -Wunreachable-code
CFLAGS += -fstack-protector-strong -Winline -Wshadow -Wwrite-strings -fstrict-aliasing
CFLAGS += -Wstrict-prototypes -Wold-style-definition -Wconversion
CFLAGS += -Wredundant-decls -Wnested-externs -Wmissing-include-dirs
CFLAGS += -Wshadow -Wpointer-arith -Wcast-qual -Wmissing-prototypes
CFLAGS += -Wswitch-default -Wundef -Wstrict-overflow=5
CFLAGS += -Winit-self -Wstrict-aliasing -Wunused
CFLAGS += -Wshadow -Wpointer-arith -Wcast-qual -Wcast-align -Wmissing-prototypes -Wconversion
CFLAGS += -Wswitch-default -Wundef -Wno-unused -Wstrict-overflow=5 -Wsign-conversion
CFLAGS += -Winit-self -Wstrict-aliasing -fsanitize=address -fsanitize=undefined
SRC = gui.c opengl.c
OBJ = $(SRC:.c=.o)
@ -21,7 +21,6 @@ OBJ = $(SRC:.c=.o)
# Modes
.PHONY: gcc
gcc: CC = gcc
gcc: CFLAGS += -Wno-unused-local-typedefs
gcc: $(BIN)
.PHONY: clang

3
Readme.md
View File

@ -1,3 +1,4 @@
# TINYGUI
# GUI
# License
(The MIT License)

582
gui.c
View File

File diff suppressed because it is too large Load Diff

148
gui.h
View File

@ -13,7 +13,6 @@
* - fine tune progressbar input handling
* - fine tune slider input handling
* - make additional widgets hoverable
* - panel row call only on change
* - panel clip rects
* - panel
* o flags
@ -54,20 +53,21 @@ struct gui_vertex {
};
struct gui_draw_command {
struct gui_vertex *vertexes;
gui_size vertex_count;
gui_size vertex_write;
struct gui_rect clip_rect;
gui_texture texture;
};
struct gui_draw_queue {
struct gui_draw_command *begin;
struct gui_draw_command *end;
gui_size vertex_count;
struct gui_draw_buffer {
gui_byte *vertexes;
gui_byte *begin;
gui_byte *end;
gui_byte *memory;
gui_size size;
gui_size needed;
gui_size vertex_write;
gui_size vertex_count;
gui_size command_count;
gui_size allocated;
};
enum gui_keys {
@ -95,7 +95,7 @@ struct gui_input {
struct gui_font_glyph {
gui_int code;
gui_short xadvance;
gui_float xadvance;
gui_short width, height;
gui_float xoff, yoff;
struct gui_texCoord uv[2];
@ -112,11 +112,11 @@ struct gui_font {
};
struct gui_button {
gui_int x, y;
gui_int w, h;
gui_int pad_x, pad_y;
gui_float x, y;
gui_float w, h;
gui_float pad_x, pad_y;
const char *text;
gui_int length;
gui_size length;
struct gui_color font;
struct gui_color background;
struct gui_color foreground;
@ -124,22 +124,21 @@ struct gui_button {
};
struct gui_toggle {
gui_int x, y;
gui_int w, h;
gui_int pad_x, pad_y;
gui_float x, y;
gui_float w, h;
gui_float pad_x, pad_y;
gui_int active;
const char *text;
gui_int length;
gui_size length;
struct gui_color font;
struct gui_color background;
struct gui_color foreground;
};
struct gui_slider {
gui_int x, y;
gui_int w, h;
gui_int pad_x;
gui_int pad_y;
gui_float x, y;
gui_float w, h;
gui_float pad_x, pad_y;
gui_float min, max;
gui_float value;
gui_float step;
@ -148,10 +147,9 @@ struct gui_slider {
};
struct gui_progress {
gui_int x, y;
gui_int w, h;
gui_int pad_x;
gui_int pad_y;
gui_float x, y;
gui_float w, h;
gui_float pad_x, pad_y;
gui_size current;
gui_size max;
gui_bool modifyable;
@ -160,23 +158,22 @@ struct gui_progress {
};
struct gui_scroll {
gui_int x, y;
gui_int w, h;
gui_int offset;
gui_int target;
gui_int step;
gui_float x, y;
gui_float w, h;
gui_size offset;
gui_size target;
gui_size step;
struct gui_color background;
struct gui_color foreground;
};
struct gui_input_field {
gui_int x, y;
gui_int w, h;
gui_int pad_x;
gui_int pad_y;
gui_float x, y;
gui_float w, h;
gui_float pad_x, pad_y;
gui_char *buffer;
gui_int *length;
gui_int max;
gui_size *length;
gui_size max;
gui_bool active;
struct gui_color background;
struct gui_color foreground;
@ -184,22 +181,21 @@ struct gui_input_field {
};
struct gui_plot {
gui_int x, y;
gui_int w, h;
gui_int pad_x;
gui_int pad_y;
gui_int value_count;
gui_float x, y;
gui_float w, h;
gui_float pad_x;
gui_float pad_y;
gui_size value_count;
const gui_float *values;
struct gui_color background;
struct gui_color foreground;
};
struct gui_histo {
gui_int x, y;
gui_int w, h;
gui_int pad_x;
gui_int pad_y;
gui_int value_count;
gui_float x, y;
gui_float w, h;
gui_float pad_x, pad_y;
gui_size value_count;
const gui_float *values;
struct gui_color background;
struct gui_color foreground;
@ -257,15 +253,15 @@ enum gui_panel_flags {
struct gui_panel {
gui_flags flags;
gui_int x, y;
gui_int at_y;
gui_int width, height;
gui_int index;
gui_int row_height;
gui_int row_columns;
struct gui_draw_queue *queue;
gui_float x, y;
gui_float at_y;
gui_float width, height;
gui_size index;
gui_float row_height;
gui_size row_columns;
struct gui_draw_buffer *out;
const struct gui_font *font;
const struct gui_input *input;
const struct gui_input *in;
const struct gui_config *config;
};
@ -283,49 +279,49 @@ void gui_input_char(struct gui_input *in, gui_glyph glyph);
void gui_input_end(struct gui_input *in);
/* Output */
void gui_begin(struct gui_draw_queue *que, gui_byte *memory, gui_size size);
gui_size gui_end(struct gui_draw_queue *que);
const struct gui_draw_command *gui_next(const struct gui_draw_queue *que,
const struct gui_draw_command *cmd);
void gui_begin(struct gui_draw_buffer *buf, gui_byte *memory, gui_size size);
gui_size gui_end(struct gui_draw_buffer *buf);
gui_int gui_get_command(struct gui_draw_command *cmd,
const struct gui_draw_buffer *buf, gui_size index);
/* Widgets */
gui_int gui_button(struct gui_draw_queue *que, const struct gui_button *button,
gui_int gui_button(struct gui_draw_buffer *buf, const struct gui_button *button,
const struct gui_font *font, const struct gui_input *in);
gui_int gui_toggle(struct gui_draw_queue *que, const struct gui_toggle *toggle,
gui_int gui_toggle(struct gui_draw_buffer *buf, const struct gui_toggle *toggle,
const struct gui_font *font, const struct gui_input *in);
gui_float gui_slider(struct gui_draw_queue *que, const struct gui_slider *slider,
gui_float gui_slider(struct gui_draw_buffer *buf, const struct gui_slider *slider,
const struct gui_input *in);
gui_int gui_progress(struct gui_draw_queue *que, const struct gui_progress *prog,
gui_size gui_progress(struct gui_draw_buffer *buf, const struct gui_progress *prog,
const struct gui_input *in);
gui_int gui_scroll(struct gui_draw_queue *que, const struct gui_scroll *scroll,
gui_size gui_scroll(struct gui_draw_buffer *buf, const struct gui_scroll *scroll,
const struct gui_input *in);
gui_int gui_input(struct gui_draw_queue *que, const struct gui_input_field *f,
gui_int gui_input(struct gui_draw_buffer *buf, const struct gui_input_field *f,
const struct gui_font *font, const struct gui_input *in);
gui_int gui_histo(struct gui_draw_queue *que, const struct gui_histo *histo,
gui_int gui_histo(struct gui_draw_buffer *buf, const struct gui_histo *histo,
const struct gui_input *in);
void gui_plot(struct gui_draw_queue *que, const struct gui_plot *plot);
void gui_plot(struct gui_draw_buffer *buf, const struct gui_plot *plot);
/* Panel */
void gui_panel_init(struct gui_panel *panel, const struct gui_config *config,
const struct gui_font *font, const struct gui_input *input);
gui_int gui_panel_begin(struct gui_panel *panel, struct gui_draw_queue *q,
gui_int gui_panel_begin(struct gui_panel *panel, struct gui_draw_buffer *q,
const char *t, gui_flags f,
gui_int x, gui_int y, gui_int w, gui_int h);
void gui_panel_row(struct gui_panel *panel, gui_int height, gui_int cols);
gui_float x, gui_float y, gui_float w, gui_float h);
void gui_panel_row(struct gui_panel *panel, gui_float height, gui_size cols);
void gui_panel_space(struct gui_panel *panel, gui_int cols);
gui_int gui_panel_button(struct gui_panel *panel, const char *str, gui_int len);
gui_int gui_panel_toggle(struct gui_panel *panel, const char *str, gui_int len,
gui_int gui_panel_button(struct gui_panel *panel, const char *str, gui_size len);
gui_int gui_panel_toggle(struct gui_panel *panel, const char *str, gui_size len,
gui_int active);
gui_float gui_panel_slider(struct gui_panel *panel, gui_float min, gui_float v,
gui_float max, gui_float step);
gui_float gui_panel_progress(struct gui_panel *panel, gui_size cur, gui_size max,
gui_size gui_panel_progress(struct gui_panel *panel, gui_size cur, gui_size max,
gui_bool modifyable);
gui_int gui_panel_input(struct gui_panel *panel, gui_char *buffer, gui_int *len,
gui_int max, gui_bool active);
gui_int gui_panel_input(struct gui_panel *panel, gui_char *buffer, gui_size *len,
gui_size max, gui_bool active);
void gui_panel_plot(struct gui_panel *panel, const gui_float *values,
gui_int value_count);
gui_size value_count);
gui_int gui_panel_histo(struct gui_panel *panel, const gui_float *values,
gui_int value_count);
gui_size value_count);
void gui_panel_end(struct gui_panel *panel);
#endif

138
opengl.c
View File

@ -31,7 +31,7 @@
#define WIN_WIDTH 800
#define WIN_HEIGHT 600
#define DTIME 33
#define MAX_VERTEX_BUFFER (16 * 1024)
#define MAX_BUFFER (32 * 1024)
#define INPUT_MAX 64
#define MIN(a,b)((a) < (b) ? (a) : (b))
@ -55,7 +55,7 @@ struct XWindow {
struct GUI {
struct XWindow *win;
struct gui_draw_queue out;
struct gui_draw_buffer out;
struct gui_input in;
struct gui_font *font;
struct gui_config config;
@ -78,7 +78,7 @@ static void resize(struct GUI*, XEvent*);
static GLuint ldbmp(gui_byte*, uint32_t*, uint32_t*);
static struct gui_font *ldfont(const char*, unsigned char);
static void delfont(struct gui_font *font);
static void draw(int, int, const struct gui_draw_queue*);
static void draw(int, int, const struct gui_draw_buffer*);
/* gobals */
static void
@ -124,7 +124,7 @@ kpress(struct GUI *gui, XEvent* e)
{
int ret;
struct XWindow *xw = gui->win;
KeySym *keysym = XGetKeyboardMapping(xw->dpy, e->xkey.keycode, 1, &ret);
KeySym *keysym = XGetKeyboardMapping(xw->dpy, (KeyCode)e->xkey.keycode, 1, &ret);
if (*keysym == XK_Escape) xw->running = 0;
else if (*keysym == XK_Shift_L || *keysym == XK_Shift_R)
gui_input_key(&gui->in, GUI_KEY_SHIFT, gui_true);
@ -146,7 +146,7 @@ krelease(struct GUI *gui, XEvent* e)
{
int ret;
struct XWindow *xw = gui->win;
KeySym *keysym = XGetKeyboardMapping(xw->dpy, e->xkey.keycode, 1, &ret);
KeySym *keysym = XGetKeyboardMapping(xw->dpy, (KeyCode)e->xkey.keycode, 1, &ret);
if (*keysym == XK_Shift_L || *keysym == XK_Shift_R)
gui_input_key(&gui->in, GUI_KEY_SHIFT, gui_false);
else if (*keysym == XK_Control_L || *keysym == XK_Control_L)
@ -162,8 +162,8 @@ krelease(struct GUI *gui, XEvent* e)
static void
bpress(struct GUI *gui, XEvent *evt)
{
const float x = evt->xbutton.x;
const float y = evt->xbutton.y;
const int x = evt->xbutton.x;
const int y = evt->xbutton.y;
if (evt->xbutton.button == Button1)
gui_input_button(&gui->in, x, y, gui_true);
}
@ -171,8 +171,8 @@ bpress(struct GUI *gui, XEvent *evt)
static void
brelease(struct GUI *con, XEvent *evt)
{
const float x = evt->xbutton.x;
const float y = evt->xbutton.y;
const int x = evt->xbutton.x;
const int y = evt->xbutton.y;
UNUSED(evt);
if (evt->xbutton.button == Button1)
gui_input_button(&con->in, x, y, gui_false);
@ -207,7 +207,7 @@ ldfile(const char* path, int flags, size_t* siz)
path, strerror(errno));
if (fstat(fd, &status) < 0)
die("Failed to call fstat: %s",strerror(errno));
*siz = status.st_size;
*siz = (size_t)status.st_size;
buf = xcalloc(*siz, 1);
if (read(fd, buf, *siz) < 0)
die("Failed to call read: %s",strerror(errno));
@ -235,9 +235,9 @@ ldbmp(gui_byte *data, uint32_t *width, uint32_t *height)
if (header[0] != 'B' || header[1] != 'M')
die("[BMP]: invalid file");
*width = *(uint32_t*)&(header[0x12]);
*height = *(uint32_t*)&(header[0x12]);
ioff = *(uint32_t*)(&header[0x0A]);
memcpy(width, &header[0x12], sizeof(uint32_t));
memcpy(height, &header[0x16], sizeof(uint32_t));
memcpy(&ioff, &header[0x0A], sizeof(uint32_t));
if (*width <= 0 || *height <= 0)
die("[BMP]: invalid image size");
@ -245,21 +245,20 @@ ldbmp(gui_byte *data, uint32_t *width, uint32_t *height)
reader = data;
mem = *width * *height * 4;
target = xcalloc(mem, 1);
for (i = *height-1; i >= 0; i--) {
writer = target + (i * *width * 4);
for (i = (int32_t)*height-1; i >= 0; i--) {
writer = target + (i * (int32_t)*width * 4);
for (j = 0; j < *width; j++) {
*writer++ = *(reader + (j * 4) + 1);
*writer++ = *(reader + (j * 4) + 2);
*writer++ = *(reader + (j * 4) + 3);
*writer++ = *(reader + (j * 4) + 0);
*writer += 4;
}
reader += *width * 4;
}
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, *width, *height, 0,
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)*width, (GLsizei)*height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, target);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
@ -284,30 +283,42 @@ ldfont(const char *name, unsigned char height)
short max_height = 0;
size_t i = 0;
uint16_t num;
uint16_t indexes;
uint16_t tex_width;
uint16_t tex_height;
/* header */
gui_byte *buffer = (gui_byte*)ldfile(name, O_RDONLY, &size);
uint16_t num = *(uint16_t*)buffer;
uint16_t indexes = *(uint16_t*)&buffer[0x02] + 1;
uint16_t tex_width = *(uint16_t*)&buffer[0x04];
uint16_t tex_height = *(uint16_t*)&buffer[0x06];
memcpy(&num, buffer, sizeof(uint16_t));
memcpy(&indexes, &buffer[0x02], sizeof(uint16_t));
memcpy(&tex_width, &buffer[0x04], sizeof(uint16_t));
memcpy(&tex_height, &buffer[0x06], sizeof(uint16_t));
/* glyphes */
gui_byte *iter = &buffer[0x08];
size_t mem = sizeof(struct gui_font_glyph) * indexes;
size_t mem = sizeof(struct gui_font_glyph) * ((size_t)indexes + 1);
struct gui_font_glyph *glyphes = xcalloc(mem, 1);
for(i = 0; i < num; ++i) {
short id = *(uint16_t*)&iter[0];
short x = *(uint16_t*)&iter[2];
short y = *(uint16_t*)&iter[4];
short w = *(uint16_t*)&iter[6];
short h = *(uint16_t*)&iter[8];
uint16_t id, x, y, w, h;
float xoff, yoff, xadv;
memcpy(&id, iter, sizeof(uint16_t));
memcpy(&x, &iter[0x02], sizeof(uint16_t));
memcpy(&y, &iter[0x04], sizeof(uint16_t));
memcpy(&w, &iter[0x06], sizeof(uint16_t));
memcpy(&h, &iter[0x08], sizeof(uint16_t));
memcpy(&xoff, &iter[10], sizeof(float));
memcpy(&yoff, &iter[14], sizeof(float));
memcpy(&xadv, &iter[18], sizeof(float));
assert(id <= indexes);
glyphes[id].code = id;
glyphes[id].width = w;
glyphes[id].height = h;
glyphes[id].xoff = *(float*)&iter[10];
glyphes[id].yoff = *(float*)&iter[14];
glyphes[id].xadvance = *(float*)&iter[18];
glyphes[id].width = (short)w;
glyphes[id].height = (short)h;
glyphes[id].xoff = xoff;
glyphes[id].yoff = yoff;
glyphes[id].xadvance = xadv;
glyphes[id].uv[0].u = (float)x/(float)tex_width;
glyphes[id].uv[0].v = (float)y/(float)tex_height;
glyphes[id].uv[1].u = (float)(x+w)/(float)tex_width;
@ -329,7 +340,7 @@ ldfont(const char *name, unsigned char height)
font->tex_size.y = tex_height;
font->fallback = &glyphes['?'];
font->glyphes = glyphes;
font->glyph_count = indexes;
font->glyph_count = indexes + 1;
free(buffer);
return font;
}
@ -344,15 +355,18 @@ delfont(struct gui_font *font)
}
static void
draw(int width, int height, const struct gui_draw_queue *que)
draw(int width, int height, const struct gui_draw_buffer *buffer)
{
const struct gui_draw_command *cmd;
gui_size i = 0;
struct gui_draw_command cmd;
GLint offset = 0;
static const size_t v = sizeof(struct gui_vertex);
static const size_t p = offsetof(struct gui_vertex, pos);
static const size_t t = offsetof(struct gui_vertex, uv);
static const size_t c = offsetof(struct gui_vertex, color);
gui_byte *vertexes;
if (!que) return;
if (!buffer) return;
glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@ -372,20 +386,21 @@ draw(int width, int height, const struct gui_draw_queue *que)
glPushMatrix();
glLoadIdentity();
cmd = que->begin;
while (cmd) {
const int x = (int)cmd->clip_rect.x;
const int y = height - (int)(cmd->clip_rect.y + cmd->clip_rect.h);
const int w = (int)cmd->clip_rect.w;
const int h = (int)cmd->clip_rect.h;
gui_byte *buffer = (gui_byte*)cmd->vertexes;
glVertexPointer(2, GL_FLOAT, v, (void*)(buffer + p));
glTexCoordPointer(2, GL_FLOAT, v, (void*)(buffer + t));
glColorPointer(4, GL_UNSIGNED_BYTE, v, (void*)(buffer + c));
glBindTexture(GL_TEXTURE_2D, (unsigned long)cmd->texture);
vertexes = buffer->vertexes;
glVertexPointer(2, GL_FLOAT, (GLsizei)v, (void*)(vertexes + p));
glTexCoordPointer(2, GL_FLOAT, (GLsizei)v, (void*)(vertexes + t));
glColorPointer(4, GL_UNSIGNED_BYTE, (GLsizei)v, (void*)(vertexes + c));
for (i = 0; i < buffer->command_count; ++i) {
gui_get_command(&cmd, buffer, i);
const int x = (int)cmd.clip_rect.x;
const int y = height - (int)(cmd.clip_rect.y + cmd.clip_rect.h);
const int w = (int)cmd.clip_rect.w;
const int h = (int)cmd.clip_rect.h;
glScissor(x, y, w, h);
glDrawArrays(GL_TRIANGLES, 0, cmd->vertex_count);
cmd = gui_next(que, cmd);
glBindTexture(GL_TEXTURE_2D, (GLuint)(unsigned long)cmd.texture);
glDrawArrays(GL_TRIANGLES, offset, (GLsizei)cmd.vertex_count);
offset += (GLint)cmd.vertex_count;
}
glDisableClientState(GL_COLOR_ARRAY);
@ -405,17 +420,17 @@ main(int argc, char *argv[])
struct GUI gui;
long dt, started;
gui_byte *buffer;
const gui_size buffer_size = MAX_VERTEX_BUFFER;
const gui_size buffer_size = MAX_BUFFER;
static GLint att[] = {GLX_RGBA, GLX_DEPTH_SIZE,24, GLX_DOUBLEBUFFER, None};
gui_char input_text[INPUT_MAX];
gui_int input_len = 0;
gui_size input_len = 0;
gui_int typing = 0;
gui_float slider = 5.0f;
gui_float prog = 60.0f;
gui_size prog = 60;
gui_int selected = gui_false;
const char *s[] = {"inactive", "active"};
const gui_float values[] = {10.0f, 12.5f, 18.0f, 15.0f, 25.0f, 30.0f, 5.0f};
const gui_float values[] = {10.0f, 12.5f, 18.0f, 15.0f, 25.0f, 30.0f};
/* Window */
UNUSED(argc); UNUSED(argv);
@ -451,7 +466,7 @@ main(int argc, char *argv[])
/* GUI */
gui.win = &xw;
gui.font = ldfont("mono.font", 16);
gui.font = ldfont("mono.sdf", 16);
gui_default_config(&gui.config);
gui_panel_init(&gui.panel, &gui.config, gui.font, &gui.in);
@ -471,22 +486,17 @@ main(int argc, char *argv[])
gui_input_end(&gui.in);
/* ------------------------- GUI --------------------------*/
gui_begin(&gui.out, buffer, MAX_VERTEX_BUFFER);
gui_panel_begin(&gui.panel, &gui.out, "Console", 0, 50, 50, 200, 0);
gui_panel_row(&gui.panel, 30, 1);
gui_begin(&gui.out, buffer, MAX_BUFFER);
gui_panel_begin(&gui.panel, &gui.out, "Demo", 0, 50, 50, 200, 0);
gui_panel_row(&gui.panel, 40, 1);
if (gui_panel_button(&gui.panel, "button", 6))
fprintf(stdout, "button pressed!\n");
gui_panel_row(&gui.panel, 30, 1);
slider = gui_panel_slider(&gui.panel, 0.0f, slider, 10.0f, 1.0f);
gui_panel_row(&gui.panel, 30, 1);
prog = gui_panel_progress(&gui.panel, prog, 100, gui_true);
gui_panel_row(&gui.panel, 30, 1);
selected = gui_panel_toggle(&gui.panel, s[selected], strlen(s[selected]), selected);
gui_panel_row(&gui.panel, 30, 1);
typing = gui_panel_input(&gui.panel, input_text, &input_len, INPUT_MAX, typing);
gui_panel_row(&gui.panel, 100, 1);
gui_panel_plot(&gui.panel, values, LEN(values));
gui_panel_row(&gui.panel, 100, 1);
gui_panel_histo(&gui.panel, values, LEN(values));
gui_panel_end(&gui.panel);
gui_end(&gui.out);
@ -500,10 +510,8 @@ main(int argc, char *argv[])
/* Timing */
dt = timestamp() - started;
if (dt < DTIME) {
if (dt < DTIME)
sleep_for(DTIME - dt);
dt = DTIME;
}
}
/* Cleanup */