alema
/
ugui
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

rewrite

Browse Source
master
Alessandro Mauri 2 years ago
parent 14def875d6
commit 894b2763c0
3 changed files with 330 additions and 498 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 0
      renderer.c
  2. 341
      ugui.c
  3. 487
      ugui.h

0
renderer.c
Unescape View File

341
ugui.c
Unescape View File

@ -1,23 +1,59 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <err.h>
#include <errno.h> #include <errno.h>
#include <err.h>
#include "ugui.h" #include "ugui.h"
#define SALT 0xbabb0cac #define SALT 0xbabb0cac
#define DEF_SCALE 1.0 #define DEF_SCALE 1.0
#define DEF_DPI 96.0 #define DEF_PPI 96.0
#define E_STACK_STEP (1024 * 128) #define STACK_STEP 64
#define PPI_PPM(ppi, scale) (ppi * scale * 0.03937008)
#define PPI_PPD(ppi, scale) (PPI_PPM(ppi, scale) * 0.3528)
#define IS_VALID_UNIT(u) (u==UG_UNIT_PX||u==UG_UNIT_MM||u==UG_UNIT_PT)
#define UG_ERR(...) err(errno, "__FUNCTION__: " __VA_ARGS__)
// default style
// TODO: fill default style
static const ug_style_t default_style = {
.text = {
.color = RGB_FORMAT(0xffffff),
.alt_color = RGB_FORMAT(0xbbbbbb),
.size = SIZE_PX(16),
.alt_size = SIZE_PX(12),
},
};
static const ug_vec2_t max_size = {10e6, 10e6};
static ug_style_t style_cache = {0};
/*=============================================================================*
* Common Functions *
*=============================================================================*/
// grow a stack
#define grow(S) \
{ \
S.items = realloc(S.items, (S.size+STACK_STEP)*sizeof(*(S.items))); \
if(!S.items) \
UG_ERR("Could not allocate stack #S: %s", strerror(errno)); \
memset(&(S.items[S.size]), 0, STACK_STEP*sizeof(*(S.items))); \
S.size += STACK_STEP; \
}
#define TO_PPM(dpi, scale) (dpi * scale * 0.03937008)
// https://en.wikipedia.org/wiki/Jenkins_hash_function // https://en.wikipedia.org/wiki/Jenkins_hash_function
unsigned int hash(void *data, unsigned int size) static ug_id_t hash(const void *data, unsigned int size)
{ {
if (!size) if (!size)
return 0; return 0;
unsigned int hash = SALT; ug_id_t hash = SALT;
unsigned char *v = (unsigned char *)data; unsigned char *v = (unsigned char *)data;
for (; size; size--) { for (; size; size--) {
@ -33,17 +69,44 @@ unsigned int hash(void *data, unsigned int size)
} }
static void grow_stack(ug_ctx_t *ctx) // update the style cache with the correct sizes in pixels and colors
static void update_style_cache(ug_ctx_t *ctx)
{ {
if (!ctx) const ug_style_t *s = ctx->style;
err(EXIT_FAILURE, "__FUNCTION__:" "Cannot grow null context"); // TODO: do this shit
ctx->e_size += E_STACK_STEP; (void)s;
ctx->e_stack = realloc(ctx->e_stack, ctx->e_size); }
if (!ctx->e_stack)
err(errno, "__FUNCTION__:" "Could not grow stack: %s", strerror(errno));
ug_rect_t rect_to_px(ug_ctx_t *ctx, ug_rect_t rect)
{
float scale = 1.0;
switch (ctx->unit) {
case UG_UNIT_PX:
return rect;
case UG_UNIT_MM:
scale = ctx->ppm;
break;
case UG_UNIT_PT:
scale = ctx->ppd;
break;
}
rect.x *= scale;
rect.y *= scale;
rect.w *= scale;
rect.h *= scale;
return rect;
} }
/*=============================================================================*
* Context Operations *
*=============================================================================*/
// creates a new context, fills with default values, ctx is ready for ug_start() // creates a new context, fills with default values, ctx is ready for ug_start()
ug_ctx_t *ug_new_ctx(void) ug_ctx_t *ug_new_ctx(void)
{ {
@ -53,9 +116,15 @@ ug_ctx_t *ug_new_ctx(void)
memset(ctx, 0, sizeof(ug_ctx_t)); memset(ctx, 0, sizeof(ug_ctx_t));
ctx->scale = DEF_SCALE; ctx->scale = DEF_SCALE;
ctx->dpi = DEF_DPI; ctx->ppi = DEF_PPI;
ctx->ppm = TO_PPM(DEF_SCALE, DEF_DPI); ctx->ppm = PPI_PPM(DEF_SCALE, DEF_PPI);
ctx->ppd = PPI_PPD(DEF_SCALE, DEF_PPI);
ctx->unit = UG_UNIT_PX;
ctx->style = &default_style;
ctx->style_px = &style_cache;
// TODO: allocate stacks
return ctx; return ctx;
} }
@ -66,173 +135,165 @@ void ug_free_ctx(ug_ctx_t *ctx)
warn("__FUNCTION__:" "Trying to free a null context"); warn("__FUNCTION__:" "Trying to free a null context");
return; return;
} }
if (!ctx->e_stack) {
warn("__FUNCTION__:" "Context has null element stack");
return;
}
free(ctx->e_stack); // TODO: free stacks
free(ctx); free(ctx);
}
// updates the context with user information // NOTE: do not free style since the default is statically allocated, let
int ug_update_ctx(ug_ctx_t *ctx, // the user take care of it instead
unsigned int window_id,
float scale,
float dpi,
float ppm
)
{
if (!ctx)
return -1;
ctx->window_id = window_id;
if (scale)
ctx->scale = scale;
if (dpi)
ctx->dpi = dpi;
if (!ppm)
ctx->ppm = TO_PPM(ctx->dpi, ctx->scale);
else
ctx->ppm = ppm;
return 0;
} }
/*=============================================================================* #define TEST_CTX(ctx) { if (!ctx) return -1; }
* INPUT FUNCTIONS *
*=============================================================================*/
#define TEST_CTX(ctx) { \ int ug_ctx_set_displayinfo(ug_ctx_t *ctx, float scale, float ppi)
if (!ctx) { \
warn("__FUNCTION__:" "trying to use a null context"); \
return; \
} \
}
void ug_input_mousemove(ug_ctx_t *ctx, int x, int y)
{ {
TEST_CTX(ctx); TEST_CTX(ctx);
ctx->mouse.pos = (struct ug_vec2){ .x = x, .y = y }; if (scale <= 0 || ppi < 20.0)
} return -1;
ctx->ppm = PPI_PPM(scale, ppi);
ctx->ppd = PPI_PPM(scale, ppi);
ctx->scale = scale;
ctx->ppi = ppi;
update_style_cache(ctx);
void ug_input_mousedown(ug_ctx_t *ctx, int x, int y, unsigned char btn) return 0;
{
TEST_CTX(ctx);
ug_input_mousemove(ctx, x, y);
ctx->mouse.down_mask |= btn;
ctx->mouse.press_mask |= btn;
} }
void ug_input_mouseup(ug_ctx_t *ctx, int x, int y, unsigned char btn) int ug_ctx_set_drawableregion(ug_ctx_t *ctx, ug_vec2_t size)
{ {
TEST_CTX(ctx); TEST_CTX(ctx);
ug_input_mousemove(ctx, x, y); if (size.w <= 0 || size.h <= 0)
ctx->mouse.down_mask &= ~btn; return -1;
}
ctx->size.w = size.w;
ctx->size.h = size.h;
void ug_input_scroll(ug_ctx_t *ctx, int x, int y) // FIXME: do I need to do something like update_container_size() here?
{ // maybe it is redundant since each frame not every conatiner is
TEST_CTX(ctx); // re-added
ctx->mouse.scroll_delta.x += x; return 0;
ctx->mouse.scroll_delta.y += y;
} }
void ug_input_keydown(ug_ctx_t *ctx, int key) int ug_ctx_set_style(ug_ctx_t *ctx, const ug_style_t *style)
{ {
TEST_CTX(ctx); TEST_CTX(ctx);
ctx->key.down_mask |= key; if (!style)
ctx->key.press_mask |= key; return -1;
} // TODO: validate style
void ug_input_keyup(ug_ctx_t *ctx, int key) ctx->style = style;
{ update_style_cache(ctx);
TEST_CTX(ctx);
ctx->key.down_mask &= ~key; return 0;
} }
// append in input text int ug_ctx_set_unit(ug_ctx_t *ctx, ug_unit_t unit)
void ug_input_text(ug_ctx_t *ctx, const char *text)
{ {
TEST_CTX(ctx); TEST_CTX(ctx);
int size = strlen(ctx->input_text); if (!IS_VALID_UNIT(unit))
int len = strlen(text); return -1;
if ((unsigned long)(size+len) >= sizeof(ctx->input_text)) {
warn("__FUNCTION__" "Input text exceeds context buffer"); ctx->unit = unit;
return;
} return 0;
memcpy(ctx->input_text + size, text, len);
} }
/*=============================================================================* /*=============================================================================*
* BEGIN AND END * * Container Operations *
*=============================================================================*/ *=============================================================================*/
#undef TEST_CTX
#define TEST_CTX(ctx) { \
if (!ctx) { \
warn("__FUNCTION__:" "trying to use a null context"); \
return -1; \
} \
}
int ug_begin(ug_ctx_t *ctx) // get a new or existing container handle
static ug_container_t *get_container(ug_ctx_t *ctx, ug_id_t id)
{ {
// it is the beginning of a new frame ug_container_t *c = NULL;
TEST_CTX(ctx); for (int i = 0; i < ctx->container_stack.idx; i++) {
if (ctx->container_stack.items[i].id == id) {
c = &(ctx->container_stack.items[i]);
break;
}
}
// if the container was not already there allocate a new one
if (!c) {
if(ctx->container_stack.idx >= ctx->container_stack.size)
grow(ctx->container_stack);
c = &(ctx->container_stack.items[ctx->container_stack.idx++]);
}
// reset the command stack return c;
ctx->e_idx = 0;
// next frame
ctx->frame++;
// update the mouse delta
ctx->mouse.delta.x = ctx->mouse.pos.x - ctx->mouse.last_pos.x;
ctx->mouse.delta.y = ctx->mouse.pos.y - ctx->mouse.last_pos.y;
// TODO: other stuff
return 0;
} }
int ug_end(ug_ctx_t *ctx) // update the container dimensions and position according to the context information,
// also handle resizing, moving, ect. if allowed by the container
static void update_container(ug_ctx_t *ctx, ug_container_t *cnt)
{ {
// end of a frame, check that all went well // if the container was just initialized the unit might not be pixels, this
TEST_CTX(ctx); // is a problem since all mouse events are in pixels and convering back
// and forth accumulates error and in heavy on the cpu
// reset the inputs if (cnt->unit != UG_UNIT_PX) {
ctx->mouse.press_mask = 0; // FIXME: this takes the unit from the context but it should be fine
ctx->mouse.scroll_delta = (struct ug_vec2){0}; cnt->rect = rect_to_px(ctx, cnt->rect);
ctx->mouse.last_pos = ctx->mouse.pos; cnt->unit = UG_UNIT_PX;
ctx->key.press_mask = 0; }
ctx->input_text[0] = '\0';
return 0;
}
/*=============================================================================* // recalculate position
* UI ELEMENTS * // FIXME: this is the right place to do some optimization, what if the
*=============================================================================*/ // context didn't change?
// the absoulute position of the container
ug_rect_t rect_abs = cnt->rect;
// 0 -> take all the space, <0 -> take absolute
if (rect_abs.w == 0) rect_abs.w = ctx->size.w;
else if (rect_abs.w < 0) rect_abs.w = -rect_abs.w;
if (rect_abs.h == 0) rect_abs.h = ctx->size.h;
else if (rect_abs.h < 0) rect_abs.h = -rect_abs.h;
// <0 -> relative to the right margin
if (rect_abs.x < 0) rect_abs.x = ctx->size.x - rect_abs.w + rect_abs.x;
if (rect_abs.y < 0) rect_abs.y = ctx->size.y - rect_abs.h + rect_abs.y;
// if we had focus the frame before, then do shit
if (ctx->hover.cnt == cnt->id) {
// TODO: do stuff
}
#undef TEST_CTX // push the appropriate rectangles to the drawing stack
#define TEST_CTX(ctx) { \ // TODO: ^ This ^
if (!ctx) { \
warn("__FUNCTION__:" "trying to use a null context"); \
return 0; \
} \
} }
// Slider element, a rectangle with some text and another rectangle inside
// When used with a mouse the slider moves to the clicked area and stat gets // a floating container can be placed anywhere and can be resized, acts like a
// updated, in that case a non-zero value gets returned // window inside another window
int ug_slider(ug_ctx_t *ctx, float *stat, float min, float max) int ug_container_floating(ug_ctx_t *ctx, const char *name, ug_rect_t rect)
{ {
TEST_CTX(ctx); TEST_CTX(ctx);
ug_draw_rect(ctx) // TODO: verify rect
}
ug_id_t id = name ? hash(name, strlen(name)) : hash(&rect, sizeof(ug_rect_t));
ug_container_t *cnt = get_container(ctx, id);
if (cnt->id) {
// nothing? maybe we can skip updating all dimensions and stuff
} else {
cnt->id = id;
cnt->max_size = max_size;
cnt->rect = rect;
cnt->unit = ctx->unit;
cnt->flags = UG_CNT_MOVABLE |
UG_CNT_RESIZABLE |
UG_CNT_SCROLL_X |
UG_CNT_SCROLL_Y ;
}
update_container(ctx, cnt);
return 0;
}

487
ugui.h
Unescape View File

@ -1,243 +1,121 @@
#ifndef _UGUI_H #ifndef _UG_HEADER
#define _UGUI_H #define _UG_HEADER
#define UG_STACK(T) struct { T *items; int idx; int size; }
// Macros #define BIT(n) (1 << n)
#define UG_STACK(T) struct { T *items; int idx; int size; } #define RGBA_FORMAT(x) { .a=x&0xff, .b=(x>>8)&0xff, .g=(x>>16)&0xff, .r=(x>>24)&0xff }
#define RGB_FORMAT(x) { .a=0xff, .b=x&0xff, .g=(x>>8)&0xff, .r=(x>>16)&0xff }
/* Point Coordinate */ #define SIZE_PX(x) { .size=x, .unit=UG_UNIT_PX }
// coordinate type, or how it is measured #define SIZE_MM(x) { .size=x, .unit=UG_UNIT_MM }
enum { #define SIZE_PT(x) { .size=x, .unit=UG_UNIT_PT }
UG_CTYPE_PX = 0x0,
UG_CTYPE_MM = 0x1, // basic types
UG_CTYPE_REL = 0x2, typedef unsigned int ug_id_t;
}; typedef struct { union {int x, w;}; union {int y, h;}; } ug_vec2_t;
typedef struct { int x, y, w, h; } ug_rect_t;
typedef struct { unsigned char a, b, g, r; } ug_color_t;
typedef struct { int size, unit; } ug_size_t;
typedef enum {
UG_UNIT_PX = 0,
UG_UNIT_MM,
UG_UNIT_PT,
} ug_unit_t;
// container type, a container is an entity that contains layouts, a container has
// a haight a width and their maximum values, in essence a container is a rectangular
// area that can be resized and sits somewhere on the drawable region
// the z index of a container is determined by it's position on the stack
typedef struct {
ug_id_t id;
ug_unit_t unit;
ug_rect_t rect;
ug_vec2_t max_size;
unsigned int flags;
} ug_container_t;
// coordinate anchor, or where it refers // the container flags
enum { enum {
UG_CANCHOR_TOP = 0x0, // x coordinates UG_CNT_MOVABLE = BIT(0), // can be moved
UG_CANCHOR_LEFT = 0x0, UG_CNT_RESIZABLE = BIT(1), // can be resized
UG_CANCHOR_BOTTOM = 0x1, // y coordinates UG_CNT_SCROLL_X = BIT(2), // can have horizontal scrolling
UG_CANCHOR_RIGHT = 0x1, UG_CNT_SCROLL_Y = BIT(3), // can have vertical scrolling
UG_CANCHOR_VCENTER = 0x2, // for positions it should be centered
UG_CANCHOR_HCENTER = 0x2,
}; };
struct _ug_pt_flags { // style, defines default height, width, color, margins, borders, etc
unsigned long int _:56; // all dimensions should be taken as a reference when doing the layout since
unsigned long int t:4; // ultimately it's the layout that decides them. For example when deciding how to
unsigned long int a:4; // allocate space one can say that the default size of a region that allocates a
}; // slider has the style's default dimensions for a slider
typedef struct {
// first coordinate
union {
union {
int x;
struct _ug_pt_flags fx;
};
union {
int w;
struct _ug_pt_flags fw;
};
union {
int m;
struct _ug_pt_flags fm;
};
};
// second coordinate
union {
union {
int y;
struct _ug_pt_flags fy;
};
union {
int h;
struct _ug_pt_flags fh;
};
union {
int a;
struct _ug_pt_flags fa;
};
};
} ug_coord_t;
// TODO: define stroke style (f.s)
typedef struct { typedef struct {
int size; struct {
ug_color_t color, alt_color;
ug_size_t size, alt_size;
} text;
ug_color_t bg_color;
// base sizes for all elements, some elements should be different, like
// buttons and other things that need to stand out
struct { struct {
// type of size ug_size_t width, height, border_width;
unsigned char t:4; ug_color_t color, hover_color, active_color;
// stroke style } base;
unsigned char s:4;
} f;
} ug_stroke_t;
//---//
/* RGBA Color type */
typedef struct {
unsigned char a;
unsigned char b;
unsigned char g;
unsigned char r;
} ug_color_t;
//---//
/* simple position structure */
struct ug_vec2 {
int x, y;
};
typedef struct {
int x, y;
int w, h;
} ug_rect_t;
//---//
/* Mouse button mask */
enum ug_mouse_btn {
UG_MOUSEBTN_LEFT = 1,
UG_MOUSEBTN_MIDDLE = 2,
UG_MOUSEBTN_RIGHT = 4,
UG_MOUSEBTN_4 = 8,
UG_MOUSEBTN_5 = 16,
};
//---//
/* event structure */
typedef enum {
UG_EV_WINDOWMOVE,
UG_EV_WINDOWRESIZE,
UG_EV_WINDOWSHOW,
UG_EV_MOUSEMOVE,
UG_EV_MOUSEDOWN,
UG_EV_MOUSEUP,
UG_EV_KEYDOWN,
UG_EV_KEYUP,
} ug_event_type_t;
typedef struct {
ug_event_type_t type;
union {
int x;
int w;
unsigned int code;
};
union {
int y;
int h;
unsigned int mask;
};
} ug_event_t;
//---//
/* Primitive element type */
typedef enum {
UG_E_RECT = 0,
UG_E_TRIANGLE,
UG_E_DOT,
UG_E_LINE,
UG_E_ARC,
UG_E_TEXT,
UG_E_SPRITE,
} ug_element_type_t;
typedef struct {
ug_coord_t size;
ug_coord_t pos;
ug_color_t color;
} ug_rect_t;
typedef struct { // a button should stand out, hence the different colors
ug_coord_t size; struct {
ug_coord_t pos; ug_color_t bg_color, hover_color, active_color;
ug_color_t color; } button;
} ug_triangle_t;
typedef struct {
ug_stroke_t stroke;
ug_coord_t pos;
ug_color_t color;
} ug_dot_t;
typedef struct {
ug_stroke_t stroke;
ug_coord_t vert[2];
ug_color_t color;
} ug_line_t;
typedef struct {
ug_stroke_t stroke;
ug_coord_t vert[3];
ug_color_t color;
} ug_arc_t;
// draw text from view[start] to view[end]
typedef struct {
ug_stroke_t stroke;
ug_coord_t pos;
ug_color_t color;
const char *view;
int start;
int end;
} ug_text_t;
// all sprites have to be mapped into memory, map is an array of width x height // a checkbox should be smaller than a button
// bytes, the type is specified by the user struct {
typedef struct { ug_size_t width, height, tick_size;
ug_coord_t pos; ug_color_t tick_color;
void *map; } checkbox;
int width;
int height;
} ug_sprite_t;
// a slider can be thinner and generally wider than a button
struct {
ug_size_t width, height;
} slider;
// data is the actual element data, it has to be cast to the right element specified // the text color, dimension and the background of a text display can be
// by type and is variable size so that no memory is wasted, size is the size in // different
// bytes of data + id + size + type struct {
typedef struct { ug_color_t text_color, bg_color;
ug_element_type_t type; ug_size_t text_size;
unsigned int size; } textdisplay;
unsigned int id;
unsigned char data[];
} ug_element_t;
//---//
/* Layout region */ } ug_style_t;
typedef struct {
ug_rect_t rect;
// FIXME: is this needed?
unsigned int id;
// indentation level, used in trees
// FIXME: is this needed?
unsigned int indent;
} ug_layout_region_t;
//---//s
/* Global context */ // context
// one context per phisical window
// a phisical window can be anything, but here it basically represents the true
// surface where things are drawn into, a window has a scale, dpi and ppm
// (pixel per mm), only the latter is truly needed, the user sets these variables
// and has to take care of updating them when needed
typedef struct { typedef struct {
unsigned int window_id; // some style information
float scale, dpi, ppm; const ug_style_t *style;
// the user pushes the things that he wants to draw onto the element stack, // style_px is a style cache where all measurements are already in pixels
// which contains all the primitives needed to draw the wanted element const ug_style_t *style_px;
UG_STACK(unsigned char) e_stack; // ppi: pixels per inch
// the element which has focus // ppm: pixels per millimeter
unsigned int focus_id; // ppd: pixels per dot
// the element that we are hovering float scale, ppi, ppm, ppd;
unsigned int hover_id; // containers need to know how big the "main container" is so that all
// the relative positioning work
ug_vec2_t size;
// which context and element we are hovering
struct {
ug_id_t cnt, elem;
} hover;
// the id of the "active" element, active means different things for
// different elements, for exaple active for a button means to be pressed,
// and for a text box it means to be focused
ug_id_t active;
// count the frames for fun // count the frames for fun
unsigned long int frame; unsigned long int frame;
// current measurement unit
ug_unit_t unit;
// mouse data // mouse data
struct { struct {
struct ug_vec2 pos; ug_vec2_t pos;
struct ug_vec2 last_pos; ug_vec2_t last_pos;
struct ug_vec2 delta; ug_vec2_t delta;
struct ug_vec2 scroll_delta; ug_vec2_t scroll_delta;
// down/pressed masks get updated on mousedown, whereas down_mask // down/pressed masks get updated on mousedown, whereas down_mask
// only on mouseup, so the masks differ by the buttons that were // only on mouseup, so the masks differ by the buttons that were
// released // released
@ -252,146 +130,39 @@ typedef struct {
} key; } key;
// input text buffer // input text buffer
char input_text[32]; char input_text[32];
// stacks
UG_STACK(ug_container_t) container_stack;
} ug_ctx_t; } ug_ctx_t;
//---//
// creates a new context, fills with default values, ctx is ready for ug_start()
// context initialization
ug_ctx_t *ug_new_ctx(void); ug_ctx_t *ug_new_ctx(void);
void ug_free_ctx(ug_ctx_t *ctx); void ug_free_ctx(ug_ctx_t *ctx);
// updates the context with user information // updates the context with user information
int ug_update_ctx(ug_ctx_t *ctx, int ug_ctx_set_displayinfo(ug_ctx_t *ctx, float scale, float ppi);
unsigned int window_id, int ug_ctx_set_drawableregion(ug_ctx_t *ctx, ug_vec2_t size);
float scale, int ug_ctx_set_style(ug_ctx_t *ctx, const ug_style_t *style);
float dpi, int ug_ctx_set_unit(ug_ctx_t *ctx, ug_unit_t unit);
float ppm
);
// define containers, name is used as a salt for the container id, all sizes are
// register inputs // the default ones, resizing is done automagically with internal state
void ug_input_mousedown(ug_ctx_t *ctx, int x, int y, unsigned char btn);
void ug_input_mouseup(ug_ctx_t *ctx, int x, int y, unsigned char btn); // a floating container can be placed anywhere and can be resized, acts like a
void ug_input_mousemove(ug_ctx_t *ctx, int x, int y); // window inside another window
void ug_input_scroll(ug_ctx_t *ctx, int x, int y); int ug_container_floating(ug_ctx_t *ctx, const char *name, ug_rect_t rect);
void ug_input_keydown(ug_ctx_t *ctx, int key); // like a floating container but cannot be resized
void ug_input_keyup(ug_ctx_t *ctx, int key); int ug_container_popup(ug_ctx_t *ctx, const char *name, ug_rect_t rect);
void ug_input_text(ug_ctx_t *ctx, const char *text); // a menu bar is a container of fixed height, cannot be resized and sits at the
// top of the window
// between begin and end the user draws int ug_container_menu_bar(ug_ctx_t *ctx, const char *name, int height);
int ug_begin(ug_ctx_t *ctx); // a sidebar is a variable size container anchored to one side of the window
int ug_end(ug_ctx_t *ctx); int ug_container_sidebar(ug_ctx_t *ctx, const char *name, int width);
// a body is a container that scales with the window, sits at it's center and cannot
// layout control // be resized
// Split the layout vertically and horizontally, n times each time with the int ug_container_body(ug_ctx_t *ctx, const char *name);
// supplied width/height
/* Window space
* +-----------------------------+
* | |
* | |
* | |
* | |
* | |
* | |
* | |
* | |
* | |
* | |
* | |
* +-----------------------------+
*
* ug_layout_vsplit(ctx, 2, (int[]){10, 20});
* create two vertical zones
* +-----------------------------+
* | } 10px |
* +-----------------------------+
* | |> 20px |
* | | |
* +-----------------------------+
* | |
* | |
* | remainder |
* | |
* | |
* | |
* +-----------------------------+
*
* ug_layout_hsplit(ctx, 3, NULL);
* equally spaced divisions
* +-----------------------------+
* | | | |
* +-----------------------------+
* | |> 20px |
* | | |
* +-----------------------------+
* | |
* | |
* | remainder |
* | |
* | |
* | |
* +-----------------------------+
*
* ug_button(ctx, "ciao");
* ug_layout_next(ctx); // skip second square
* ug_button(ctx, "quit");
* float val = 0.3
* ug_slider(ctx, &val, 0, 1);
* ug_text(ctx, "lorem ipsum\ndolor et");
*
* +-----------------------------+
* | ciao | | quit |
* +-----------------------------+
* | # 0.3 |
* | # |
* +-----------------------------+
* | lorem ipsum |
* | dolor et |
* | |
* | |
* | |
* | |
* +-----------------------------+
*
* ug_layout_popup(ctx, {100x50, centrato});
* ug_layout_vsplit(ctx, 1, NULL);
* ug_button(ctx, "btn1");
* ug_button(ctx, "btn2");
*
* +-----------------------------+
* | ciao | | quit |
* +-----------------------------+
* | # 0.3 |
* | # +----------+ |
* +--------| btn1 |---------+
* | lorem i| | |
* | dolor e+----------+ |
* | | btn2 | |
* | | | |
* | +----------+ |
* | |
* | |
* +-----------------------------+
*/
int ug_layout_vsplit(ug_ctx_t *ctx, int n, const int *heights);
int ug_layout_hsplit(ug_ctx_t *ctx, int n, const int *widths);
// popup layout, create a rectangle that sits over the view and has a higher
// z-index, this allows it to have any position and have focus priority
// creating a popup selects it as current layout
int ug_layout_popup(ug_ctx_t *ctx, ug_rect_t rect);
// get the next rectangular region in the layout context
ug_rect_t ug_layout_next(ug_ctx_t *ctx);
// get the current layout rectangle area, but do not pop it (select the next)
// this is useful to get information about the area's width height and position
ug_rect_t ug_layout_get_current(ug_ctx_t *ctx);
// set the unit of the dimensions, in the context all units are pixels but
// when regions are defined units can be in pixels, millimiters, etc
int ui_layout_set_mm(ug_ctx_t *ctx);
int ui_layout_set_px(ug_ctx_t *ctx);
// ui elements
int ug_slider(ug_ctx_t *ctx, float *stat, float min, float max);
// un-define macros that we don't want the user to access
#undef UG_STACK #undef UG_STACK
#undef BIT
#endif #endif
Write Preview
Loading…
Cancel
Save