2015-03-03 19:24:02 +03:00
|
|
|
/*
|
|
|
|
Copyright (c) 2015
|
|
|
|
vurtun <polygone@gmx.net>
|
|
|
|
MIT licence
|
2015-06-06 13:45:18 +03:00
|
|
|
|
|
|
|
GUI
|
|
|
|
-----------------------
|
2015-06-21 18:16:11 +03:00
|
|
|
This two file provide both the interface and implementation for a bloat free
|
2015-06-06 13:45:18 +03:00
|
|
|
minimal state immediate mode graphical user interface toolkit. The Toolkit
|
|
|
|
does not have any library or runtine dependencies like libc but does not
|
|
|
|
handle os window/input management, have a render backend or a font library which
|
|
|
|
need to be provided by the user.
|
2015-03-03 19:24:02 +03:00
|
|
|
*/
|
2015-03-09 22:04:45 +03:00
|
|
|
#ifndef GUI_H_
|
|
|
|
#define GUI_H_
|
2015-03-20 12:58:11 +03:00
|
|
|
|
2015-04-10 19:35:17 +03:00
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
2015-06-20 20:06:36 +03:00
|
|
|
#ifndef GUI_ASSERT
|
|
|
|
#define GUI_ASSERT(expr)
|
|
|
|
#endif
|
|
|
|
|
2015-05-11 13:45:22 +03:00
|
|
|
/* Constants */
|
2015-06-20 20:06:36 +03:00
|
|
|
#define GUI_UTF_INVALID 0xFFFD
|
2015-03-03 19:24:02 +03:00
|
|
|
#define GUI_UTF_SIZE 4
|
2015-06-04 23:17:54 +03:00
|
|
|
/* describes the number of bytes a glyph consists of*/
|
2015-03-07 19:02:37 +03:00
|
|
|
#define GUI_INPUT_MAX 16
|
2015-06-06 13:45:18 +03:00
|
|
|
/* defines the max number of bytes to be added as text input in one frame */
|
2015-05-29 15:18:23 +03:00
|
|
|
#define GUI_MAX_COLOR_STACK 32
|
2015-06-04 23:17:54 +03:00
|
|
|
/* defines the number of temporary configuration color changes that can be stored */
|
2015-05-29 15:18:23 +03:00
|
|
|
#define GUI_MAX_ATTRIB_STACK 32
|
2015-06-04 23:17:54 +03:00
|
|
|
/* defines the number of temporary configuration attribute changes that can be stored */
|
2015-04-10 19:35:17 +03:00
|
|
|
|
2015-06-04 23:17:54 +03:00
|
|
|
/*
|
|
|
|
Since the gui uses ANSI C which does not guarantee to have fixed types, you need
|
|
|
|
to set the appropriate size of each type. However if your developer environment
|
2015-06-16 00:46:13 +03:00
|
|
|
supports fixed size types by the <stdint> header you can just use
|
2015-06-04 23:17:54 +03:00
|
|
|
#define GUI_USE_FIXED_TYPES
|
|
|
|
to automatically set the correct size for each type in the library.
|
|
|
|
*/
|
2015-04-10 19:35:17 +03:00
|
|
|
#ifdef GUI_USE_FIXED_TYPES
|
|
|
|
#include <stdint.h>
|
2015-06-14 00:50:25 +03:00
|
|
|
typedef char gui_char;
|
2015-04-10 19:35:17 +03:00
|
|
|
typedef int32_t gui_int;
|
|
|
|
typedef int32_t gui_bool;
|
|
|
|
typedef int16_t gui_short;
|
|
|
|
typedef int64_t gui_long;
|
|
|
|
typedef float gui_float;
|
2015-04-27 17:22:56 +03:00
|
|
|
typedef uint16_t gui_ushort;
|
2015-04-10 19:35:17 +03:00
|
|
|
typedef uint32_t gui_uint;
|
|
|
|
typedef uint64_t gui_ulong;
|
|
|
|
typedef uint32_t gui_flags;
|
|
|
|
typedef uint8_t gui_byte;
|
|
|
|
typedef uint32_t gui_flag;
|
|
|
|
typedef uint64_t gui_size;
|
|
|
|
#else
|
2015-03-03 19:24:02 +03:00
|
|
|
typedef int gui_int;
|
2015-04-10 19:35:17 +03:00
|
|
|
typedef int gui_bool;
|
2015-05-31 15:41:46 +03:00
|
|
|
typedef char gui_char;
|
2015-03-05 21:50:56 +03:00
|
|
|
typedef short gui_short;
|
|
|
|
typedef long gui_long;
|
2015-04-10 19:35:17 +03:00
|
|
|
typedef float gui_float;
|
2015-04-27 17:22:56 +03:00
|
|
|
typedef unsigned short gui_ushort;
|
2015-04-10 19:35:17 +03:00
|
|
|
typedef unsigned int gui_uint;
|
2015-03-20 12:58:11 +03:00
|
|
|
typedef unsigned long gui_ulong;
|
2015-03-05 17:37:11 +03:00
|
|
|
typedef unsigned int gui_flags;
|
2015-03-03 19:24:02 +03:00
|
|
|
typedef unsigned char gui_byte;
|
2015-03-07 19:02:37 +03:00
|
|
|
typedef unsigned int gui_flag;
|
2015-03-03 19:24:02 +03:00
|
|
|
typedef unsigned long gui_size;
|
2015-04-10 19:35:17 +03:00
|
|
|
#endif
|
|
|
|
|
2015-05-11 13:45:22 +03:00
|
|
|
/* Utilities */
|
2015-03-03 19:24:02 +03:00
|
|
|
enum {gui_false, gui_true};
|
2015-03-17 16:42:49 +03:00
|
|
|
enum gui_heading {GUI_UP, GUI_RIGHT, GUI_DOWN, GUI_LEFT};
|
2015-03-03 19:24:02 +03:00
|
|
|
struct gui_color {gui_byte r,g,b,a;};
|
|
|
|
struct gui_vec2 {gui_float x,y;};
|
|
|
|
struct gui_rect {gui_float x,y,w,h;};
|
2015-04-04 19:26:22 +03:00
|
|
|
struct gui_key {gui_bool down, clicked;};
|
2015-04-19 23:12:37 +03:00
|
|
|
typedef gui_char gui_glyph[GUI_UTF_SIZE];
|
2015-06-06 21:13:28 +03:00
|
|
|
typedef union {void *ptr; gui_int id;} gui_handle;
|
|
|
|
struct gui_image {gui_handle handle; struct gui_rect region;};
|
2015-06-04 23:17:54 +03:00
|
|
|
|
|
|
|
/* Callbacks */
|
|
|
|
struct gui_font;
|
2015-05-10 21:27:13 +03:00
|
|
|
typedef gui_bool(*gui_filter)(gui_long unicode);
|
2015-05-31 15:41:46 +03:00
|
|
|
typedef gui_size(*gui_text_width_f)(gui_handle, const gui_char*, gui_size);
|
2015-07-05 00:36:01 +03:00
|
|
|
typedef gui_size(*gui_paste_f)(gui_handle, char *buffer, gui_size max);
|
|
|
|
typedef void(*gui_copy_f)(gui_handle, const char*, gui_size size);
|
|
|
|
|
2015-06-20 20:06:36 +03:00
|
|
|
/*
|
|
|
|
* ==============================================================
|
|
|
|
*
|
|
|
|
* Utility
|
|
|
|
*
|
|
|
|
* ===============================================================
|
|
|
|
*/
|
2015-07-05 00:36:01 +03:00
|
|
|
/* Utility
|
|
|
|
----------------------------
|
|
|
|
The utility API provides mainly a number of object construction function
|
|
|
|
for some gui specific objects like image handle, vector, color and rectangle.
|
|
|
|
|
|
|
|
USAGE
|
|
|
|
----------------------------
|
|
|
|
Utility function API
|
|
|
|
gui_get_null_rect() -- returns a default clipping rectangle
|
|
|
|
gui_utf_decode() -- decodes a utf-8 glyph into u32 unicode glyph and len
|
|
|
|
gui_utf_encode() -- encodes a u32 unicode glyph into a utf-8 glyph
|
|
|
|
gui_image_ptr() -- create a image handle from pointer
|
|
|
|
gui_image_id() -- create a image handle from integer id
|
|
|
|
gui_subimage_ptr() -- create a sub-image handle from pointer and region
|
|
|
|
gui_subimage_id() -- create a sub-image handle from integer id and region
|
|
|
|
gui_rect_is_valid() -- check if a rectangle inside the image command is valid
|
|
|
|
gui_rect() -- creates a rectangle from x,y-Position and width and height
|
|
|
|
gui_vec2() -- creates a 2D vector, in the best case should not be needed by the user
|
|
|
|
gui_rgba() -- create a gui color struct from rgba color code
|
|
|
|
gui_rgb() -- create a gui color struct from rgb color code
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
struct gui_rect gui_get_null_rect(void);
|
|
|
|
gui_size gui_utf_decode(const gui_char*, gui_long*, gui_size);
|
|
|
|
gui_size gui_utf_encode(gui_long, gui_char*, gui_size);
|
|
|
|
struct gui_image gui_image_ptr(void*);
|
|
|
|
struct gui_image gui_image_id(gui_int);
|
|
|
|
struct gui_image gui_subimage_ptr(void*, struct gui_rect);
|
|
|
|
struct gui_image gui_subimage_id(gui_int, struct gui_rect);
|
2015-07-01 15:01:53 +03:00
|
|
|
gui_bool gui_rect_is_valid(const struct gui_rect*);
|
|
|
|
gui_bool gui_image_is_subimage(const struct gui_image* img);
|
2015-06-22 14:14:34 +03:00
|
|
|
struct gui_rect gui_rect(gui_float x, gui_float y, gui_float w, gui_float h);
|
|
|
|
struct gui_vec2 gui_vec2(gui_float x, gui_float y);
|
|
|
|
struct gui_color gui_rgba(gui_byte r, gui_byte g, gui_byte b, gui_byte a);
|
|
|
|
struct gui_color gui_rgb(gui_byte r, gui_byte g, gui_byte b);
|
2015-05-29 15:18:23 +03:00
|
|
|
/*
|
|
|
|
* ==============================================================
|
|
|
|
*
|
|
|
|
* Input
|
|
|
|
*
|
|
|
|
* ===============================================================
|
|
|
|
*/
|
2015-06-04 23:17:54 +03:00
|
|
|
/* INPUT
|
|
|
|
----------------------------
|
2015-06-16 00:46:13 +03:00
|
|
|
The input API is responsible for holding input by keeping track of
|
2015-06-04 23:17:54 +03:00
|
|
|
mouse, key and text input state. The core of the API is the persistent
|
2015-06-16 00:46:13 +03:00
|
|
|
gui_input struct which holds the input state while running.
|
2015-06-04 23:17:54 +03:00
|
|
|
It is important to note that no direct os or window handling is done by the input
|
|
|
|
API, instead all the input state has to be provided from the user. This in one hand
|
|
|
|
expects more work from the user and complicates the usage but on the other hand
|
|
|
|
provides simple abstraction over a big number of platforms, libraries and other
|
|
|
|
already provided functionality.
|
|
|
|
|
|
|
|
USAGE
|
|
|
|
----------------------------
|
|
|
|
To instantiate the Input API the gui_input structure has to be zeroed at
|
|
|
|
the beginning of the program by either using memset or setting it to {0},
|
|
|
|
since the internal state is persistent over all frames.
|
|
|
|
|
|
|
|
To modify the internal input state you have to first set the gui_input struct
|
|
|
|
into a modifiable state with gui_input_begin. After the gui_input struct is
|
|
|
|
now ready you can add input state changes until everything is up to date.
|
|
|
|
Finally to revert back into a read state you have to call gui_input_end.
|
|
|
|
|
|
|
|
Input function API
|
|
|
|
gui_input_begin() -- begins the modification state
|
|
|
|
gui_input_motion() -- notifies of a cursor motion update
|
|
|
|
gui_input_key() -- notifies of a keyboard key update
|
|
|
|
gui_input_button() -- notifies of a action event
|
|
|
|
gui_input_char() -- adds a text glyph to gui_input
|
|
|
|
gui_input_end() -- ends the modification state
|
|
|
|
|
|
|
|
*/
|
|
|
|
#if 0
|
|
|
|
/* Example */
|
|
|
|
#define GUI_IMPLEMENTATION
|
|
|
|
#include "gui.h"
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
struct gui_input input;
|
|
|
|
memset(&input, 0, sizeof(input));
|
|
|
|
while (1) {
|
|
|
|
gui_input_begin(&in);
|
|
|
|
if (Key_state_changed)
|
|
|
|
gui_input_key(&input, key, is_down);
|
|
|
|
else if (button_state_changed)
|
|
|
|
gui_input_button(&in, mouse_x, mouse_y, is_down);
|
|
|
|
else if (mouse_position_changed)
|
|
|
|
gui_input_motion(&input, mouse_x, mouse_y);
|
|
|
|
else if (text_input)
|
|
|
|
gui_input_char(&input, glyph);
|
|
|
|
gui_input_end(&in);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* every key that is being used inside the library */
|
2015-03-23 19:18:18 +03:00
|
|
|
enum gui_keys {
|
|
|
|
GUI_KEY_SHIFT,
|
|
|
|
GUI_KEY_DEL,
|
|
|
|
GUI_KEY_ENTER,
|
|
|
|
GUI_KEY_BACKSPACE,
|
|
|
|
GUI_KEY_SPACE,
|
2015-07-05 00:36:01 +03:00
|
|
|
GUI_KEY_COPY,
|
|
|
|
GUI_KEY_PASTE,
|
2015-03-23 19:18:18 +03:00
|
|
|
GUI_KEY_MAX
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_input {
|
|
|
|
struct gui_key keys[GUI_KEY_MAX];
|
2015-06-04 23:17:54 +03:00
|
|
|
/* state of every used key */
|
2015-03-23 19:18:18 +03:00
|
|
|
gui_char text[GUI_INPUT_MAX];
|
2015-06-04 23:17:54 +03:00
|
|
|
/* utf8 text input frame buffer */
|
2015-03-23 19:18:18 +03:00
|
|
|
gui_size text_len;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* text input frame buffer length in bytes */
|
2015-03-23 19:18:18 +03:00
|
|
|
struct gui_vec2 mouse_pos;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* current mouse position */
|
2015-03-23 19:18:18 +03:00
|
|
|
struct gui_vec2 mouse_prev;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* mouse position in the last frame */
|
2015-03-23 19:18:18 +03:00
|
|
|
struct gui_vec2 mouse_delta;
|
2015-06-16 00:46:13 +03:00
|
|
|
/* mouse travelling distance from last to current frame */
|
2015-03-23 19:18:18 +03:00
|
|
|
gui_bool mouse_down;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* current mouse button state */
|
2015-03-23 19:18:18 +03:00
|
|
|
gui_uint mouse_clicked;
|
2015-06-16 00:46:13 +03:00
|
|
|
/* number of mouse button state transistions between frames */
|
2015-06-10 18:35:46 +03:00
|
|
|
gui_float scroll_delta;
|
2015-06-16 00:46:13 +03:00
|
|
|
/* number of steps in the up or down scroll direction */
|
2015-03-23 19:18:18 +03:00
|
|
|
struct gui_vec2 mouse_clicked_pos;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* mouse position of the last mouse button state change */
|
2015-03-23 19:18:18 +03:00
|
|
|
};
|
|
|
|
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_input_begin(struct gui_input*);
|
2015-06-16 00:46:13 +03:00
|
|
|
/* this function sets the input state to writeable */
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_input_motion(struct gui_input*, gui_int x, gui_int y);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function updates the current mouse position
|
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- local os window X position
|
|
|
|
- local os window Y position
|
2015-06-04 23:17:54 +03:00
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_input_key(struct gui_input*, enum gui_keys, gui_bool down);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function updates the current state of a key
|
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- key identifier
|
2015-06-04 23:17:54 +03:00
|
|
|
- the new state of the key
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_input_button(struct gui_input*, gui_int x, gui_int y, gui_bool down);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function updates the current state of the button
|
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- local os window X position
|
|
|
|
- local os window Y position
|
2015-06-04 23:17:54 +03:00
|
|
|
- the new state of the button
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_input_scroll(struct gui_input*, gui_float y);
|
2015-06-10 18:35:46 +03:00
|
|
|
/* this function updates the current page scroll delta
|
|
|
|
Input:
|
|
|
|
- vector with each direction (< 0 down > 0 up and scroll distance)
|
|
|
|
*/
|
2015-07-02 12:56:51 +03:00
|
|
|
void gui_input_glyph(struct gui_input*, const gui_glyph);
|
2015-06-16 00:46:13 +03:00
|
|
|
/* this function adds a utf-8 glpyh into the internal text frame buffer
|
2015-06-04 23:17:54 +03:00
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- utf8 glyph to add to the text buffer
|
2015-06-04 23:17:54 +03:00
|
|
|
*/
|
2015-07-02 12:56:51 +03:00
|
|
|
void gui_input_char(struct gui_input*, char);
|
|
|
|
/* this function adds char into the internal text frame buffer
|
|
|
|
Input:
|
|
|
|
- character to add to the text buffer
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_input_end(struct gui_input*);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function sets the input state to readable
|
|
|
|
*/
|
2015-05-29 15:18:23 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ==============================================================
|
|
|
|
*
|
|
|
|
* Buffer
|
|
|
|
*
|
|
|
|
* ===============================================================
|
|
|
|
*/
|
2015-06-04 23:17:54 +03:00
|
|
|
/* BUFFER
|
|
|
|
----------------------------
|
|
|
|
A basic buffer API with linear allocation and resetting as only freeing policy.
|
|
|
|
The buffer main purpose is to control all memory management inside
|
|
|
|
the GUI toolkit and still leave memory control as much as possible in the hand
|
2015-06-16 00:46:13 +03:00
|
|
|
of the user. The memory is provided in three different ways.
|
2015-06-04 23:17:54 +03:00
|
|
|
The first way is to use a fixed size block of memory to be filled up.
|
2015-06-16 00:46:13 +03:00
|
|
|
Biggest advantage is a simple memory model. Downside is that if the buffer
|
|
|
|
is full there is no way to accesses more memory, which fits target application
|
|
|
|
with a GUI with roughly known memory consumptions.
|
2015-06-04 23:17:54 +03:00
|
|
|
The second way to mnamge memory is by extending the fixed size block by querying
|
2015-06-16 00:46:13 +03:00
|
|
|
information from the buffer about the used size and needed size and allocate new
|
2015-06-04 23:17:54 +03:00
|
|
|
memory if the buffer is full. While this approach is still better than just using
|
|
|
|
a fixed size memory block the reallocation still has one invalid frame as consquence
|
|
|
|
since the used memory information is only available at the end of the frame which leads
|
|
|
|
to the last way of handling memory.
|
|
|
|
The last and most complicated way of handling memory is by allocator callbacks.
|
|
|
|
The user herby registers callbacks to be called to allocate, free and reallocate
|
|
|
|
memory if needed. While this solves most allocation problems it causes some
|
|
|
|
loss of flow control on the user side.
|
|
|
|
|
|
|
|
USAGE
|
|
|
|
----------------------------
|
2015-06-06 13:45:18 +03:00
|
|
|
To instantiate the buffer you either have to call the fixed size or allocator
|
2015-06-04 23:17:54 +03:00
|
|
|
initialization function and provide a memory block in the first case and
|
|
|
|
an allocator in the second case.
|
|
|
|
To allocate memory from the buffer you would call gui_buffer_alloc with a request
|
|
|
|
memory block size aswell as an alignment for the block. Finally to reset the memory
|
|
|
|
at the end of the frame and when the memory buffer inside the buffer is no longer
|
|
|
|
needed you would call gui_buffer_reset. To free all memory that has been allocated
|
|
|
|
by an allocator if the buffer is no longer being used you have to call gui_buffer_clear.
|
|
|
|
|
|
|
|
Buffer function API
|
|
|
|
gui_buffer_init -- initializes a dynamic buffer
|
|
|
|
gui_buffer_init_fixed -- initializes a static buffer
|
|
|
|
gui_buffer_info -- provides memory information about a buffer
|
|
|
|
gui_buffer_alloc -- allocates a block of memory from the buffer
|
|
|
|
gui_buffer_reset -- resets the buffer back to an empty state
|
|
|
|
gui_buffer_clear -- frees all memory if the buffer is dynamic
|
|
|
|
|
|
|
|
*/
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_memory_status {
|
|
|
|
void *memory;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* pointer to the currently used memory block inside the referenced buffer */
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_uint type;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* type of the buffer which is either fixed size or dynamic */
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_size size;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* total size of the memory block */
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_size allocated;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* allocated amount of memory */
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_size needed;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* memory size that would have been allocated if enough memory was present */
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_size calls;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* number of allocation calls referencing this buffer */
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_allocator {
|
2015-05-31 15:41:46 +03:00
|
|
|
gui_handle userdata;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* handle to your own allocator */
|
2015-05-31 15:41:46 +03:00
|
|
|
void*(*alloc)(gui_handle, gui_size);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* allocation function pointer */
|
2015-05-31 15:41:46 +03:00
|
|
|
void*(*realloc)(gui_handle, void*, gui_size);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* reallocation pointer of a previously allocated memory block */
|
2015-05-31 15:41:46 +03:00
|
|
|
void(*free)(gui_handle, void*);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* callback function pointer to finally free all allocated memory */
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
enum gui_buffer_type {
|
|
|
|
GUI_BUFFER_FIXED,
|
2015-06-04 23:17:54 +03:00
|
|
|
/* fixed size memory buffer */
|
2015-05-29 15:18:23 +03:00
|
|
|
GUI_BUFFER_DYNAMIC
|
2015-06-05 23:32:44 +03:00
|
|
|
/* dynamically growing buffer */
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
|
|
|
|
2015-06-04 23:17:54 +03:00
|
|
|
struct gui_memory {void *ptr;gui_size size;};
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_buffer {
|
|
|
|
struct gui_allocator pool;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* allocator callback for dynamic buffers */
|
2015-05-29 15:18:23 +03:00
|
|
|
enum gui_buffer_type type;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* memory type management type */
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_memory memory;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* memory and size of the current memory block */
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_float grow_factor;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* growing factor for dynamic memory management */
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_size allocated;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* total amount of memory allocated */
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_size needed;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* total amount of memory allocated if enough memory would have been present */
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_size calls;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* number of allcation calls */
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
|
|
|
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_buffer_init(struct gui_buffer*, const struct gui_allocator*,
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_size initial_size, gui_float grow_factor);
|
|
|
|
/* this function initializes a growing buffer
|
|
|
|
Input:
|
|
|
|
- allocator holding your own alloctator and memory allocation callbacks
|
|
|
|
- initial size of the buffer
|
2015-06-16 00:46:13 +03:00
|
|
|
- factor to grow the buffer by if the buffer is full
|
2015-06-04 23:17:54 +03:00
|
|
|
Output:
|
|
|
|
- dynamically growing buffer
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_buffer_init_fixed(struct gui_buffer*, void *memory, gui_size size);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function initializes a fixed size buffer
|
|
|
|
Input:
|
|
|
|
- fixed size previously allocated memory block
|
|
|
|
- size of the memory block
|
|
|
|
Output:
|
|
|
|
- fixed size buffer
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_buffer_info(struct gui_memory_status*, struct gui_buffer*);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function requests memory information from a buffer
|
|
|
|
Input:
|
|
|
|
- buffer to get the inforamtion from
|
|
|
|
Output:
|
|
|
|
- buffer memory information
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void *gui_buffer_alloc(struct gui_buffer*, gui_size size, gui_size align);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this functions allocated a aligned memory block from a buffer
|
|
|
|
Input:
|
|
|
|
- buffer to allocate memory from
|
|
|
|
- size of the requested memory block
|
|
|
|
- alignment requirement for the memory block
|
|
|
|
Output:
|
|
|
|
- memory block with given size and alignment requirement
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_buffer_reset(struct gui_buffer*);
|
2015-06-16 00:46:13 +03:00
|
|
|
/* this functions resets the buffer back into an empty state */
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_buffer_clear(struct gui_buffer*);
|
2015-06-16 00:46:13 +03:00
|
|
|
/* this functions frees all memory inside a dynamically growing buffer */
|
2015-06-05 23:32:44 +03:00
|
|
|
|
2015-06-04 23:17:54 +03:00
|
|
|
#if 0
|
|
|
|
/* Example fixed size buffer */
|
|
|
|
#define GUI_IMPLEMENTATION
|
|
|
|
#include "gui.h"
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
struct gui_buffer buffer;
|
|
|
|
void *memory = calloc(4*1024);
|
|
|
|
gui_buffer_init_fixed(&buffer, memory, 4*1024);
|
|
|
|
void *ptr = gui_buffer_alloc(&buffer, 256, 4);
|
|
|
|
gui_buffer_reset(&buffer);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
/* Example fixed size buffer */
|
|
|
|
#define GUI_IMPLEMENTATION
|
|
|
|
#include "gui.h"
|
|
|
|
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
struct gui_allocator alloc;
|
|
|
|
alloc.userdata = your_allocator;
|
|
|
|
alloc.alloc = your_allocation_callback;
|
|
|
|
alloc.realloc = your_reallocation_callback;
|
|
|
|
alloc.free = your_free_callback;
|
|
|
|
|
|
|
|
struct gui_buffer buffer;
|
|
|
|
gui_buffer_init(&buffer, &alloc, 4*1024, 2.7f);
|
|
|
|
void *ptr = gui_buffer_alloc(&buffer, 256, 4);
|
|
|
|
gui_buffer_reset(&buffer);
|
|
|
|
gui_buffer_clear(&buffer);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
2015-05-29 15:18:23 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ==============================================================
|
|
|
|
*
|
|
|
|
* Commands
|
|
|
|
*
|
|
|
|
* ===============================================================
|
|
|
|
*/
|
2015-06-04 23:17:54 +03:00
|
|
|
/* DRAW COMMAND QUEUE
|
|
|
|
----------------------------
|
2015-06-06 13:45:18 +03:00
|
|
|
The command buffer API enqueues draw calls as commands in to a buffer and
|
|
|
|
therefore abstracts over drawing routines and enables defered drawing.
|
|
|
|
The API offers a number of drawing primitives like lines, rectangles, circles,
|
|
|
|
triangles, images, text and clipping rectangles, that have to be drawn by the user.
|
|
|
|
Therefore the command buffer is the main toolkit output besides the actual widget output.
|
2015-06-04 23:17:54 +03:00
|
|
|
The actual draw command execution is done by the user and is build up in a
|
|
|
|
interpreter like fashion by iterating over all commands and executing each
|
|
|
|
command differently depending on the command type.
|
|
|
|
|
|
|
|
USAGE
|
|
|
|
----------------------------
|
|
|
|
To use the command buffer you first have to initiate the buffer either as fixed
|
|
|
|
size or growing buffer. After the initilization you can add primitives by
|
|
|
|
calling the appropriate gui_command_buffer_XXX for each primitive.
|
|
|
|
To iterate over each commands inside the buffer gui_foreach_command is
|
|
|
|
provided. Finally to reuse the buffer after the frame use the
|
|
|
|
gui_command_buffer_reset function.
|
|
|
|
|
|
|
|
command buffer function API
|
|
|
|
gui_command_buffer_init -- initializes a dynamic command buffer
|
|
|
|
gui_command_buffer_init_fixed -- initializes a static command buffer
|
|
|
|
gui_command_buffer_reset -- resets the command buffer back to an empty state
|
|
|
|
gui_command_buffer_clear -- frees all memory if the command buffer is dynamic
|
|
|
|
|
|
|
|
command queue function API
|
|
|
|
gui_command_buffer_push -- pushes and enqueues a command into the buffer
|
|
|
|
gui_command_buffer_push_scissor -- pushes a clipping rectangle into the command queue
|
|
|
|
gui_command_buffer_push_line -- pushes a line into the command queue
|
|
|
|
gui_command_buffer_push_rect -- pushes a rectange into the command queue
|
|
|
|
gui_command_buffer_push_circle -- pushes a circle into the command queue
|
|
|
|
gui_command_buffer_push_triangle-- pushes a triangle command into the queue
|
|
|
|
gui_command_buffer_push_image -- pushes a image draw command into the queue
|
|
|
|
gui_command_buffer_push_text -- pushes a text draw command into the queue
|
|
|
|
|
|
|
|
command iterator function API
|
|
|
|
gui_command_buffer_begin -- returns the first command in a queue
|
|
|
|
gui_command_buffer_next -- returns the next command in a queue
|
|
|
|
gui_foreach_command -- iterates over all commands in a queue
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* command type of every used drawing primitive */
|
2015-05-29 15:18:23 +03:00
|
|
|
enum gui_command_type {
|
|
|
|
GUI_COMMAND_NOP,
|
|
|
|
GUI_COMMAND_SCISSOR,
|
|
|
|
GUI_COMMAND_LINE,
|
|
|
|
GUI_COMMAND_RECT,
|
|
|
|
GUI_COMMAND_CIRCLE,
|
|
|
|
GUI_COMMAND_TRIANGLE,
|
|
|
|
GUI_COMMAND_TEXT,
|
|
|
|
GUI_COMMAND_IMAGE,
|
|
|
|
GUI_COMMAND_MAX
|
|
|
|
};
|
|
|
|
|
2015-06-04 23:17:54 +03:00
|
|
|
/* command base and header of every comand inside the buffer */
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_command {
|
|
|
|
enum gui_command_type type;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* the type of the current command */
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_size offset;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* offset to the next command */
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_command_scissor {
|
|
|
|
struct gui_command header;
|
|
|
|
gui_short x, y;
|
|
|
|
gui_ushort w, h;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_command_line {
|
|
|
|
struct gui_command header;
|
|
|
|
gui_short begin[2];
|
|
|
|
gui_short end[2];
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_byte color[4];
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_command_rect {
|
|
|
|
struct gui_command header;
|
2015-05-31 22:49:20 +03:00
|
|
|
gui_uint r;
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_short x, y;
|
|
|
|
gui_ushort w, h;
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_byte color[4];
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_command_circle {
|
|
|
|
struct gui_command header;
|
|
|
|
gui_short x, y;
|
|
|
|
gui_ushort w, h;
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_byte color[4];
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_command_image {
|
|
|
|
struct gui_command header;
|
|
|
|
gui_short x, y;
|
|
|
|
gui_ushort w, h;
|
2015-06-06 21:13:28 +03:00
|
|
|
struct gui_image img;
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_command_triangle {
|
|
|
|
struct gui_command header;
|
|
|
|
gui_short a[2];
|
|
|
|
gui_short b[2];
|
|
|
|
gui_short c[2];
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_byte color[4];
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_command_text {
|
|
|
|
struct gui_command header;
|
2015-05-31 15:41:46 +03:00
|
|
|
gui_handle font;
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_byte bg[4];
|
|
|
|
gui_byte fg[4];
|
2015-05-31 15:41:46 +03:00
|
|
|
gui_short x, y;
|
|
|
|
gui_ushort w, h;
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_size length;
|
|
|
|
gui_char string[1];
|
|
|
|
};
|
|
|
|
|
2015-06-03 01:58:57 +03:00
|
|
|
enum gui_command_clipping {
|
|
|
|
GUI_NOCLIP = gui_false,
|
|
|
|
GUI_CLIP = gui_true
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_command_buffer {
|
|
|
|
struct gui_buffer base;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* memory buffer */
|
2015-06-03 01:58:57 +03:00
|
|
|
struct gui_rect clip;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* current clipping rectangle */
|
2015-06-03 01:58:57 +03:00
|
|
|
gui_bool use_clipping;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* flag if the command buffer should clip commands */
|
2015-06-03 01:58:57 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
#define gui_command_buffer_init(b, a, i, g, c)\
|
2015-06-20 20:06:36 +03:00
|
|
|
{gui_buffer_init(&(b)->base, a, i, g), (b)->use_clipping=c; (b)->clip=gui_get_null_rect();}
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function initializes a growing buffer
|
|
|
|
Input:
|
|
|
|
- allocator holding your own alloctator and memory allocation callbacks
|
|
|
|
- initial size of the buffer
|
|
|
|
- factor to grow the buffer with if the buffer is full
|
|
|
|
- clipping flag for draw command clipping
|
|
|
|
Output:
|
|
|
|
- dynamically growing command buffer
|
|
|
|
*/
|
2015-06-03 01:58:57 +03:00
|
|
|
#define gui_command_buffer_init_fixed(b, m, s,c)\
|
2015-07-01 15:01:53 +03:00
|
|
|
{gui_buffer_init_fixed(&(b)->base, m ,s); (b)->use_clipping=c; \
|
|
|
|
(b)->clip=gui_get_null_rect();}
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function initializes a fixed size buffer
|
|
|
|
Input:
|
|
|
|
- memory block to fill
|
|
|
|
- size of the memory block
|
|
|
|
- clipping flag for draw command clipping
|
|
|
|
Output:
|
|
|
|
- fixed size command buffer
|
|
|
|
*/
|
|
|
|
#define gui_command_buffer_reset(b)\
|
|
|
|
gui_buffer_reset(&(b)->base)
|
|
|
|
/* this function resets the buffer back to an empty state
|
|
|
|
Input:
|
|
|
|
- buffer to reset
|
|
|
|
*/
|
|
|
|
#define gui_command_buffer_clear(b)\
|
|
|
|
gui_buffer_clear(&(b)->base)
|
|
|
|
/* this function frees the memory of a dynamic buffer
|
|
|
|
Input:
|
|
|
|
- buffer to reset
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void *gui_command_buffer_push(struct gui_command_buffer*, gui_uint type, gui_size size);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function push enqueues a command into the buffer
|
|
|
|
Input:
|
|
|
|
- buffer to push the command into
|
|
|
|
- type of the command
|
|
|
|
- amount of memory that is needed for the specified command
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_command_buffer_push_scissor(struct gui_command_buffer*, gui_float,
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_float, gui_float, gui_float);
|
|
|
|
/* this function push a clip rectangle command into the buffer
|
|
|
|
Input:
|
|
|
|
- buffer to push the clip rectangle command into
|
|
|
|
- x,y and width and height of the clip rectangle
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_command_buffer_push_line(struct gui_command_buffer*, gui_float, gui_float,
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_float, gui_float, struct gui_color);
|
|
|
|
/* this function pushes a line draw command into the buffer
|
|
|
|
Input:
|
|
|
|
- buffer to push the clip rectangle command into
|
|
|
|
- starting position of the line
|
|
|
|
- ending position of the line
|
|
|
|
- color of the line to draw
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_command_buffer_push_rect(struct gui_command_buffer *buffer, gui_float x,
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_float y, gui_float w, gui_float h,
|
|
|
|
gui_float r, struct gui_color c);
|
|
|
|
/* this function pushes a rectangle draw command into the buffer
|
|
|
|
Input:
|
|
|
|
- buffer to push the draw rectangle command into
|
|
|
|
- rectangle position
|
|
|
|
- rectangle size
|
|
|
|
- rectangle rounding
|
|
|
|
- color of the rectangle to draw
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_command_buffer_push_circle(struct gui_command_buffer*, gui_float, gui_float,
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_float, gui_float, struct gui_color);
|
|
|
|
/* this function pushes a circle draw command into the buffer
|
|
|
|
Input:
|
|
|
|
- buffer to push the circle draw command into
|
|
|
|
- x position of the top left of the circle
|
|
|
|
- y position of the top left of the circle
|
|
|
|
- rectangle diameter of the circle
|
|
|
|
- color of the circle to draw
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_command_buffer_push_triangle(struct gui_command_buffer*, gui_float, gui_float,
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_float, gui_float, gui_float, gui_float,
|
|
|
|
struct gui_color);
|
|
|
|
/* this function pushes a triangle draw command into the buffer
|
|
|
|
Input:
|
|
|
|
- buffer to push the draw triangle command into
|
|
|
|
- (x,y) coordinates of all three points
|
|
|
|
- rectangle diameter of the circle
|
|
|
|
- color of the triangle to draw
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_command_buffer_push_image(struct gui_command_buffer*, gui_float,
|
2015-06-06 21:13:28 +03:00
|
|
|
gui_float, gui_float, gui_float,
|
|
|
|
struct gui_image*);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function pushes a image draw command into the buffer
|
|
|
|
Input:
|
|
|
|
- buffer to push the draw image command into
|
|
|
|
- position of the image with x,y position
|
|
|
|
- size of the image to draw with width and height
|
|
|
|
- rectangle diameter of the circle
|
|
|
|
- color of the triangle to draw
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_command_buffer_push_text(struct gui_command_buffer*, gui_float, gui_float,
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_float, gui_float, const gui_char*, gui_size,
|
|
|
|
const struct gui_font*, struct gui_color,
|
|
|
|
struct gui_color);
|
|
|
|
/* this function pushes a text draw command into the buffer
|
|
|
|
Input:
|
|
|
|
- buffer to push the draw text command into
|
|
|
|
- top left position of the text with x,y position
|
|
|
|
- maixmal size of the text to draw with width and height
|
|
|
|
- color of the triangle to draw
|
|
|
|
*/
|
2015-06-05 16:01:15 +03:00
|
|
|
|
2015-06-04 23:17:54 +03:00
|
|
|
#define gui_ptr_add(t, p, i) ((t*)((void*)((gui_size)(p) + (i))))
|
|
|
|
#define gui_ptr_sub(t, p, i) ((t*)((void*)((gui_size)(p) - (i))))
|
2015-05-29 15:18:23 +03:00
|
|
|
#define gui_command(t, c) ((const struct gui_command_##t*)c)
|
|
|
|
#define gui_command_buffer_begin(b)\
|
2015-06-03 01:58:57 +03:00
|
|
|
((const struct gui_command*)(b)->base.memory.ptr)
|
2015-05-29 15:18:23 +03:00
|
|
|
#define gui_command_buffer_end(b)\
|
2015-06-04 23:17:54 +03:00
|
|
|
(gui_ptr_add(const struct gui_command, (b)->base.memory.ptr, (b)->base.allocated))
|
2015-05-29 15:18:23 +03:00
|
|
|
#define gui_command_buffer_next(b, c)\
|
2015-06-04 23:17:54 +03:00
|
|
|
((gui_ptr_add(const struct gui_command,c,c->offset)<gui_command_buffer_end(b))?\
|
|
|
|
gui_ptr_add(const struct gui_command,c,c->offset):NULL)
|
2015-05-29 15:18:23 +03:00
|
|
|
#define gui_foreach_command(i, b)\
|
2015-06-03 01:58:57 +03:00
|
|
|
for((i)=gui_command_buffer_begin(b); (i)!=NULL; (i)=gui_command_buffer_next(b,i))
|
2015-05-29 15:18:23 +03:00
|
|
|
|
2015-07-05 00:36:01 +03:00
|
|
|
/*
|
|
|
|
* ==============================================================
|
|
|
|
*
|
|
|
|
* Edit Buffer
|
|
|
|
*
|
|
|
|
* ===============================================================
|
|
|
|
*/
|
|
|
|
typedef struct gui_buffer gui_edit_buffer;
|
|
|
|
void gui_edit_buffer_append(gui_edit_buffer*, const char*, gui_size);
|
|
|
|
void gui_edit_buffer_insert(gui_edit_buffer*, gui_size pos, const char*, gui_size);
|
|
|
|
void gui_edit_buffer_remove(gui_edit_buffer*, gui_size);
|
|
|
|
void gui_edit_buffer_del(gui_edit_buffer*, gui_size pos, gui_size len);
|
|
|
|
char *gui_edit_buffer_at(gui_edit_buffer*, gui_size pos);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ==============================================================
|
|
|
|
*
|
|
|
|
* Edit Box
|
|
|
|
*
|
|
|
|
* ===============================================================
|
|
|
|
*/
|
|
|
|
struct gui_clipboard {
|
|
|
|
gui_handle userdata;
|
|
|
|
gui_paste_f paste;
|
|
|
|
gui_copy_f copy;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_edit_box {
|
|
|
|
gui_edit_buffer buffer;
|
|
|
|
gui_bool active;
|
|
|
|
struct gui_clipboard clip;
|
|
|
|
gui_filter filter;
|
|
|
|
};
|
|
|
|
|
|
|
|
gui_bool gui_filter_input_default(gui_long unicode);
|
|
|
|
gui_bool gui_filter_input_ascii(gui_long unicode);
|
|
|
|
gui_bool gui_filter_input_float(gui_long unicode);
|
|
|
|
gui_bool gui_filter_input_decimal(gui_long unicode);
|
|
|
|
gui_bool gui_filter_input_hex(gui_long unicode);
|
|
|
|
gui_bool gui_filter_input_oct(gui_long unicode);
|
|
|
|
gui_bool gui_filter_input_binary(gui_long unicode);
|
|
|
|
|
|
|
|
void gui_edit_box_init(struct gui_edit_box*, struct gui_allocator*, gui_size initial,
|
|
|
|
gui_float grow_fac, const struct gui_clipboard*, gui_filter);
|
|
|
|
void gui_edit_box_init_fixed(struct gui_edit_box*, void *memory, gui_size size,
|
|
|
|
const struct gui_clipboard*, gui_filter);
|
|
|
|
#define gui_edit_box_reset(b) gui_buffer_reset(&(b)->buffer)
|
|
|
|
#define gui_edit_box_clear(b) gui_buffer_clear(&(b)->buffer)
|
|
|
|
void gui_edit_box_add(struct gui_edit_box*, const char*, gui_size);
|
|
|
|
void gui_edit_box_remove(struct gui_edit_box*);
|
|
|
|
gui_char *gui_edit_box_get(struct gui_edit_box*);
|
|
|
|
gui_size gui_edit_box_len(struct gui_edit_box*);
|
2015-05-29 15:18:23 +03:00
|
|
|
/*
|
|
|
|
* ==============================================================
|
|
|
|
*
|
|
|
|
* Widgets
|
|
|
|
*
|
|
|
|
* ===============================================================
|
|
|
|
*/
|
2015-06-04 23:17:54 +03:00
|
|
|
/* WIDGETS
|
|
|
|
----------------------------
|
|
|
|
The Widget API supports a number of basic widgets like buttons, sliders or
|
|
|
|
editboxes and stores no widget state. Instead the state of each widget has to
|
|
|
|
be managed by the user.
|
|
|
|
|
|
|
|
USAGE
|
|
|
|
----------------------------
|
|
|
|
Most widgets takes an input struct, font and widget specific data and a command
|
|
|
|
buffer to push draw command into and return the updated widget state.
|
|
|
|
Important to note is that there is no actual state that is being stored inside
|
|
|
|
the toolkit so everything has to be stored byte the user.
|
|
|
|
|
|
|
|
Widget function API
|
|
|
|
gui_text -- draws a string inside a box
|
|
|
|
gui_button_text -- button widget with text content
|
|
|
|
gui_button_image -- button widget with icon content
|
|
|
|
gui_button_triangle -- button widget with triangle content
|
|
|
|
gui_toggle -- either a checkbox or radiobutton widget
|
|
|
|
gui_slider -- floating point slider widget
|
|
|
|
gui_progress -- unsigned integer progressbar widget
|
|
|
|
gui_edit -- Editbox wiget for user input
|
|
|
|
gui_edit_filtered -- Editbox with utf8 gylph filter capabilities
|
|
|
|
gui_spinner -- unsigned integer spinner widget
|
|
|
|
gui_selector -- string selector widget
|
|
|
|
gui_scroll -- scrollbar widget imeplementation
|
|
|
|
*/
|
2015-06-05 16:01:15 +03:00
|
|
|
|
2015-06-04 23:17:54 +03:00
|
|
|
/* Example */
|
|
|
|
#if 0
|
|
|
|
gui_command_buffer buffer;
|
|
|
|
void *memory = malloc(MEMORY_SIZE)
|
|
|
|
gui_buffer_init_fixed(buffer, memory, MEMORY_SIZE);
|
|
|
|
|
|
|
|
struct gui_font font = {...};
|
|
|
|
const struct gui_slider slider = {...};
|
|
|
|
const struct gui_progress progress = {...};
|
|
|
|
gui_float value = 5.0f
|
|
|
|
gui_size prog = 20;
|
|
|
|
|
|
|
|
struct gui_input input = {0};
|
|
|
|
while (1) {
|
|
|
|
gui_input_begin(&input);
|
|
|
|
/* record input */
|
|
|
|
gui_input_end(&input);
|
|
|
|
|
|
|
|
gui_command_buffer_reset(&buffer);
|
|
|
|
value = gui_slider(&buffer, 50, 50, 100, 30, 0, value, 10, 1, &slider, &input);
|
|
|
|
prog = gui_progress(&buffer, 50, 100, 100, 30, prog, 100, gui_false, &progress, &input);
|
|
|
|
|
|
|
|
const struct gui_command *cmd;
|
|
|
|
gui_foreach_command(cmd, buffer) {
|
|
|
|
/* execute draw call command */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_font {
|
2015-05-31 15:41:46 +03:00
|
|
|
gui_handle userdata;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* user provided font handle */
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_float height;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* max height of the font */
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_text_width_f width;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* font string width in pixel callback */
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
2015-05-11 13:45:22 +03:00
|
|
|
|
2015-04-08 12:54:33 +03:00
|
|
|
enum gui_text_align {
|
|
|
|
GUI_TEXT_LEFT,
|
|
|
|
GUI_TEXT_CENTERED,
|
|
|
|
GUI_TEXT_RIGHT
|
|
|
|
};
|
|
|
|
|
2015-03-13 00:53:28 +03:00
|
|
|
struct gui_text {
|
2015-04-19 23:12:37 +03:00
|
|
|
struct gui_vec2 padding;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* padding between bounds and text */
|
2015-04-15 15:37:19 +03:00
|
|
|
struct gui_color foreground;
|
2015-06-04 23:17:54 +03:00
|
|
|
/*text color */
|
2015-03-13 00:53:28 +03:00
|
|
|
struct gui_color background;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* text background color */
|
2015-03-13 22:01:31 +03:00
|
|
|
};
|
|
|
|
|
2015-03-14 19:05:30 +03:00
|
|
|
enum gui_button_behavior {
|
2015-04-10 19:35:17 +03:00
|
|
|
GUI_BUTTON_DEFAULT,
|
2015-06-16 00:46:13 +03:00
|
|
|
/* button only returns on activation */
|
2015-05-10 21:27:13 +03:00
|
|
|
GUI_BUTTON_REPEATER,
|
2015-06-04 23:17:54 +03:00
|
|
|
/* button returns as long as the button is pressed */
|
2015-05-10 21:27:13 +03:00
|
|
|
GUI_BUTTON_MAX
|
2015-03-14 19:05:30 +03:00
|
|
|
};
|
|
|
|
|
2015-03-09 22:04:45 +03:00
|
|
|
struct gui_button {
|
2015-04-15 15:37:19 +03:00
|
|
|
gui_float border;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* size of the border */
|
2015-05-31 22:49:20 +03:00
|
|
|
gui_float rounding;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* buttong rectangle rounding */
|
2015-04-19 23:12:37 +03:00
|
|
|
struct gui_vec2 padding;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* padding between bounds and content */
|
2015-03-09 22:04:45 +03:00
|
|
|
struct gui_color background;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* button color */
|
2015-03-09 22:04:45 +03:00
|
|
|
struct gui_color foreground;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* button border color */
|
2015-03-20 12:58:11 +03:00
|
|
|
struct gui_color content;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* button content color */
|
2015-03-17 16:42:49 +03:00
|
|
|
struct gui_color highlight;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* background color if mouse is over */
|
2015-03-20 12:58:11 +03:00
|
|
|
struct gui_color highlight_content;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* content color if mouse is over */
|
2015-03-20 12:58:11 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
enum gui_toggle_type {
|
|
|
|
GUI_TOGGLE_CHECK,
|
2015-06-04 23:17:54 +03:00
|
|
|
/* checkbox toggle */
|
2015-03-20 12:58:11 +03:00
|
|
|
GUI_TOGGLE_OPTION
|
2015-06-04 23:17:54 +03:00
|
|
|
/* radiobutton toggle */
|
2015-03-09 22:04:45 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_toggle {
|
2015-05-31 22:49:20 +03:00
|
|
|
gui_float rounding;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* checkbox rectangle rounding */
|
2015-04-19 23:12:37 +03:00
|
|
|
struct gui_vec2 padding;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* padding between bounds and content */
|
2015-03-09 22:04:45 +03:00
|
|
|
struct gui_color font;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* text color */
|
2015-03-09 22:04:45 +03:00
|
|
|
struct gui_color background;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* toggle background color*/
|
2015-03-09 22:04:45 +03:00
|
|
|
struct gui_color foreground;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* toggle foreground color*/
|
2015-05-02 22:18:45 +03:00
|
|
|
struct gui_color cursor;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* toggle cursor color*/
|
2015-03-09 22:04:45 +03:00
|
|
|
};
|
|
|
|
|
2015-05-23 01:11:58 +03:00
|
|
|
struct gui_progress {
|
2015-05-31 22:49:20 +03:00
|
|
|
gui_float rounding;
|
2015-06-16 00:46:13 +03:00
|
|
|
/* progressbar rectangle rounding */
|
2015-04-19 23:12:37 +03:00
|
|
|
struct gui_vec2 padding;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* padding between bounds and content */
|
2015-03-09 22:04:45 +03:00
|
|
|
struct gui_color background;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* progressbar background color */
|
2015-03-09 22:04:45 +03:00
|
|
|
struct gui_color foreground;
|
2015-06-16 00:46:13 +03:00
|
|
|
/* progressbar cursor color */
|
2015-03-09 22:04:45 +03:00
|
|
|
};
|
|
|
|
|
2015-05-23 01:11:58 +03:00
|
|
|
struct gui_slider {
|
|
|
|
struct gui_vec2 padding;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* padding between bounds and content */
|
2015-05-23 01:11:58 +03:00
|
|
|
struct gui_color bar;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* slider background bar color */
|
2015-05-23 01:11:58 +03:00
|
|
|
struct gui_color border;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* slider cursor border color */
|
2015-05-23 01:11:58 +03:00
|
|
|
struct gui_color bg;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* slider background color */
|
2015-05-23 01:11:58 +03:00
|
|
|
struct gui_color fg;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* slider cursor color */
|
2015-05-23 01:11:58 +03:00
|
|
|
};
|
|
|
|
|
2015-03-09 22:04:45 +03:00
|
|
|
struct gui_scroll {
|
2015-05-31 22:49:20 +03:00
|
|
|
gui_float rounding;
|
2015-06-16 00:46:13 +03:00
|
|
|
/* scrollbar rectangle rounding */
|
2015-03-09 22:04:45 +03:00
|
|
|
struct gui_color background;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* scrollbar background color */
|
2015-03-09 22:04:45 +03:00
|
|
|
struct gui_color foreground;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* scrollbar cursor color */
|
2015-03-16 16:02:47 +03:00
|
|
|
struct gui_color border;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* scrollbar border color */
|
2015-06-23 20:23:25 +03:00
|
|
|
gui_bool has_scrolling;
|
|
|
|
/* flag if the scrollbar can be updated by scrolling */
|
2015-03-09 22:04:45 +03:00
|
|
|
};
|
|
|
|
|
2015-03-14 19:05:30 +03:00
|
|
|
enum gui_input_filter {
|
|
|
|
GUI_INPUT_DEFAULT,
|
2015-06-16 00:46:13 +03:00
|
|
|
/* everything goes */
|
2015-05-21 18:09:22 +03:00
|
|
|
GUI_INPUT_ASCII,
|
2015-06-16 00:46:13 +03:00
|
|
|
/* ASCII characters (0-127)*/
|
2015-03-14 19:05:30 +03:00
|
|
|
GUI_INPUT_FLOAT,
|
2015-06-16 00:46:13 +03:00
|
|
|
/* only float point numbers */
|
2015-03-14 19:05:30 +03:00
|
|
|
GUI_INPUT_DEC,
|
2015-06-16 00:46:13 +03:00
|
|
|
/* only integer numbers */
|
2015-03-14 19:05:30 +03:00
|
|
|
GUI_INPUT_HEX,
|
2015-06-16 00:46:13 +03:00
|
|
|
/* only hex numbers */
|
2015-03-14 19:05:30 +03:00
|
|
|
GUI_INPUT_OCT,
|
2015-06-16 00:46:13 +03:00
|
|
|
/* only octal numbers */
|
2015-03-20 12:58:11 +03:00
|
|
|
GUI_INPUT_BIN
|
2015-06-16 00:46:13 +03:00
|
|
|
/* only binary numbers */
|
2015-03-13 22:01:31 +03:00
|
|
|
};
|
|
|
|
|
2015-05-09 20:42:31 +03:00
|
|
|
struct gui_edit {
|
2015-06-03 01:58:57 +03:00
|
|
|
gui_float border_size;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* editbox border line size */
|
2015-05-31 22:49:20 +03:00
|
|
|
gui_float rounding;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* editbox rectangle rounding */
|
2015-04-19 23:12:37 +03:00
|
|
|
struct gui_vec2 padding;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* padding between bounds and content*/
|
2015-03-16 11:51:33 +03:00
|
|
|
gui_bool show_cursor;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* flag indication if the cursor should be drawn */
|
2015-03-13 22:01:31 +03:00
|
|
|
struct gui_color background;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* editbox background */
|
2015-06-03 01:58:57 +03:00
|
|
|
struct gui_color border;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* editbox border color */
|
2015-06-03 01:58:57 +03:00
|
|
|
struct gui_color cursor;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* editbox cursor color */
|
2015-06-03 01:58:57 +03:00
|
|
|
struct gui_color text;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* editbox text color */
|
2015-03-13 22:01:31 +03:00
|
|
|
};
|
|
|
|
|
2015-05-31 16:41:09 +03:00
|
|
|
struct gui_spinner {
|
|
|
|
gui_size border_button;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* border line width */
|
2015-05-31 16:41:09 +03:00
|
|
|
struct gui_color button_color;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* spinner button background color */
|
2015-05-31 16:41:09 +03:00
|
|
|
struct gui_color button_border;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* spinner button border color */
|
2015-05-31 16:41:09 +03:00
|
|
|
struct gui_color button_triangle;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* spinner up and down button triangle color */
|
2015-05-31 16:41:09 +03:00
|
|
|
struct gui_color color;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* spinner background color */
|
2015-05-31 16:41:09 +03:00
|
|
|
struct gui_color border;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* spinner border color */
|
2015-06-03 01:58:57 +03:00
|
|
|
struct gui_color text;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* spinner text color */
|
2015-05-31 16:41:09 +03:00
|
|
|
struct gui_vec2 padding;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* spinner padding between bounds and content*/
|
2015-05-31 16:41:09 +03:00
|
|
|
gui_bool show_cursor;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* flag indicating if the cursor should be drawn */
|
2015-03-09 22:04:45 +03:00
|
|
|
};
|
|
|
|
|
2015-05-31 17:02:48 +03:00
|
|
|
struct gui_selector {
|
|
|
|
gui_size border_button;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* border line width */
|
2015-05-31 17:02:48 +03:00
|
|
|
struct gui_color button_color;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* selector button background color */
|
2015-05-31 17:02:48 +03:00
|
|
|
struct gui_color button_border;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* selector button border color */
|
2015-05-31 17:02:48 +03:00
|
|
|
struct gui_color button_triangle;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* selector button content color */
|
2015-05-31 17:02:48 +03:00
|
|
|
struct gui_color color;
|
2015-06-16 00:46:13 +03:00
|
|
|
/* selector background color */
|
2015-05-31 17:02:48 +03:00
|
|
|
struct gui_color border;
|
2015-06-16 00:46:13 +03:00
|
|
|
/* selector border color */
|
2015-05-31 17:02:48 +03:00
|
|
|
struct gui_color text;
|
2015-06-16 00:46:13 +03:00
|
|
|
/* selector text color */
|
2015-05-31 17:02:48 +03:00
|
|
|
struct gui_color text_bg;
|
2015-06-16 00:46:13 +03:00
|
|
|
/* selector text background color */
|
2015-05-31 17:02:48 +03:00
|
|
|
struct gui_vec2 padding;
|
2015-06-04 23:17:54 +03:00
|
|
|
/* padding between bounds and content*/
|
2015-05-31 17:02:48 +03:00
|
|
|
};
|
|
|
|
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_text(struct gui_command_buffer*, gui_float, gui_float, gui_float, gui_float,
|
2015-07-01 15:01:53 +03:00
|
|
|
const char *text, gui_size len, const struct gui_text*,
|
|
|
|
enum gui_text_align, const struct gui_font*);
|
2015-06-16 00:46:13 +03:00
|
|
|
/* this function executes a text widget with text alignment
|
2015-06-04 23:17:54 +03:00
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- output command buffer for drawing
|
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
2015-06-04 23:17:54 +03:00
|
|
|
- string to draw
|
|
|
|
- length of the string
|
|
|
|
- visual widget style structure describing the text
|
|
|
|
- text alignment with either left, center and right
|
|
|
|
- font structure for text drawing
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_button_text(struct gui_command_buffer*, gui_float x, gui_float y,
|
2015-07-01 15:01:53 +03:00
|
|
|
gui_float w, gui_float h, const char*,
|
|
|
|
enum gui_button_behavior, const struct gui_button*,
|
|
|
|
const struct gui_input*, const struct gui_font*);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function executes a text button widget
|
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- output command buffer for drawing
|
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
2015-06-04 23:17:54 +03:00
|
|
|
- button text
|
|
|
|
- button behavior with either repeating or transition state event
|
|
|
|
- visual widget style structure describing the button
|
|
|
|
- input structure to update the button with
|
|
|
|
- font structure for text drawing
|
|
|
|
Output:
|
|
|
|
- returns gui_true if the button was pressed gui_false otherwise
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_button_image(struct gui_command_buffer*, gui_float x, gui_float y,
|
2015-07-01 15:01:53 +03:00
|
|
|
gui_float w, gui_float h, struct gui_image img,
|
|
|
|
enum gui_button_behavior, const struct gui_button*,
|
|
|
|
const struct gui_input*);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function executes a image button widget
|
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- output command buffer for drawing
|
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
2015-06-04 23:17:54 +03:00
|
|
|
- user provided image handle which is either a pointer or a id
|
|
|
|
- button behavior with either repeating or transition state event
|
|
|
|
- visual widget style structure describing the button
|
|
|
|
- input structure to update the button with
|
|
|
|
Output:
|
|
|
|
- returns gui_true if the button was pressed gui_false otherwise
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_button_triangle(struct gui_command_buffer*, gui_float x, gui_float y,
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_float w, gui_float h, enum gui_heading,
|
|
|
|
enum gui_button_behavior, const struct gui_button*,
|
|
|
|
const struct gui_input*);
|
|
|
|
/* this function executes a triangle button widget
|
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- output command buffer for drawing
|
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
2015-06-04 23:17:54 +03:00
|
|
|
- triangle direction with either left, top, right xor bottom
|
|
|
|
- button behavior with either repeating or transition state event
|
|
|
|
- visual widget style structure describing the button
|
|
|
|
- input structure to update the button with
|
|
|
|
Output:
|
|
|
|
- returns gui_true if the button was pressed gui_false otherwise
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_button_text_triangle(struct gui_command_buffer*, gui_float x, gui_float y,
|
2015-06-06 21:13:28 +03:00
|
|
|
gui_float w, gui_float h, enum gui_heading,
|
2015-07-01 15:01:53 +03:00
|
|
|
const char*,enum gui_text_align,
|
|
|
|
enum gui_button_behavior,
|
2015-06-06 21:13:28 +03:00
|
|
|
const struct gui_button*, const struct gui_font*,
|
|
|
|
const struct gui_input*);
|
|
|
|
/* this function executes a button with text and a triangle widget
|
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- output command buffer for drawing
|
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
2015-06-06 21:13:28 +03:00
|
|
|
- triangle direction with either left, top, right xor bottom
|
|
|
|
- button text
|
|
|
|
- text alignment with either left, center and right
|
|
|
|
- button behavior with either repeating or transition state event
|
|
|
|
- visual widget style structure describing the button
|
|
|
|
- font structure for text drawing
|
|
|
|
- input structure to update the button with
|
|
|
|
Output:
|
|
|
|
- returns gui_true if the button was pressed gui_false otherwise
|
|
|
|
*/
|
|
|
|
gui_bool gui_button_text_image(struct gui_command_buffer *out, gui_float x, gui_float y,
|
|
|
|
gui_float w, gui_float h, struct gui_image img,
|
|
|
|
const char* text, enum gui_text_align align,
|
|
|
|
enum gui_button_behavior behavior,
|
|
|
|
const struct gui_button *button, const struct gui_font *f,
|
|
|
|
const struct gui_input *i);
|
|
|
|
/* this function executes a button widget with text and an icon
|
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- output command buffer for drawing
|
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
2015-06-06 21:13:28 +03:00
|
|
|
- user provided image handle which is either a pointer or a id
|
|
|
|
- button text
|
|
|
|
- text alignment with either left, center and right
|
|
|
|
- button behavior with either repeating or transition state event
|
|
|
|
- visual widget style structure describing the button
|
|
|
|
- font structure for text drawing
|
|
|
|
- input structure to update the button with
|
|
|
|
Output:
|
|
|
|
- returns gui_true if the button was pressed gui_false otherwise
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_toggle(struct gui_command_buffer*, gui_float x, gui_float y, gui_float w,
|
2015-06-08 11:55:35 +03:00
|
|
|
gui_float h, gui_bool, const char*, enum gui_toggle_type,
|
2015-07-01 15:01:53 +03:00
|
|
|
const struct gui_toggle*, const struct gui_input*,
|
|
|
|
const struct gui_font*);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function executes a toggle (checkbox, radiobutton) widget
|
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- output command buffer for drawing
|
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
2015-06-04 23:17:54 +03:00
|
|
|
- active or inactive flag describing the state of the toggle
|
|
|
|
- visual widget style structure describing the toggle
|
|
|
|
- input structure to update the toggle with
|
|
|
|
- font structure for text drawing
|
|
|
|
Output:
|
|
|
|
- returns the update state of the toggle
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_float gui_slider(struct gui_command_buffer*, gui_float x, gui_float y, gui_float,
|
2015-07-01 15:01:53 +03:00
|
|
|
gui_float h, gui_float min, gui_float val, gui_float max,
|
|
|
|
gui_float step, const struct gui_slider*, const struct gui_input*);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function executes a slider widget
|
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- output command buffer for drawing
|
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
2015-06-04 23:17:54 +03:00
|
|
|
- minimal slider value that will not be underflown
|
|
|
|
- slider value to be updated by the user
|
|
|
|
- maximal slider value that will not be overflown
|
|
|
|
- step interval the value will be updated with
|
|
|
|
- visual widget style structure describing the slider
|
|
|
|
- input structure to update the slider with
|
|
|
|
Output:
|
|
|
|
- returns the from the user input updated value
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_size gui_progress(struct gui_command_buffer*, gui_float x, gui_float y,
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_float w, gui_float h, gui_size value, gui_size max,
|
|
|
|
gui_bool modifyable, const struct gui_progress*,
|
|
|
|
const struct gui_input*);
|
|
|
|
/* this function executes a progressbar widget
|
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- output command buffer for drawing
|
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
2015-06-04 23:17:54 +03:00
|
|
|
- progressbar value to be updated by the user
|
|
|
|
- maximal progressbar value that will not be overflown
|
|
|
|
- flag if the progressbar is modifyable by the user
|
|
|
|
- visual widget style structure describing the progressbar
|
|
|
|
- input structure to update the slider with
|
|
|
|
Output:
|
|
|
|
- returns the from the user input updated value
|
|
|
|
*/
|
2015-07-05 00:36:01 +03:00
|
|
|
void gui_editbox(struct gui_command_buffer*, gui_float x, gui_float y, gui_float w,
|
|
|
|
gui_float h, struct gui_edit_box*, const struct gui_edit*,
|
|
|
|
const struct gui_input*, const struct gui_font*);
|
|
|
|
/* this function executes a editbox widget
|
|
|
|
Input:
|
|
|
|
- output command buffer for drawing
|
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
|
|
|
- edit box structure containing the state to update
|
|
|
|
- visual widget style structure describing the editbox
|
|
|
|
- input structure to update the editbox with
|
|
|
|
- font structure for text drawing
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_size gui_edit(struct gui_command_buffer*, gui_float x, gui_float y, gui_float w,
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_float h, gui_char*, gui_size, gui_size max, gui_bool*,
|
|
|
|
const struct gui_edit*, enum gui_input_filter filter,
|
|
|
|
const struct gui_input*, const struct gui_font*);
|
|
|
|
/* this function executes a editbox widget
|
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- output command buffer for drawing
|
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
2015-06-04 23:17:54 +03:00
|
|
|
- char buffer to add or remove glyphes from/to
|
|
|
|
- buffer text length in bytes
|
|
|
|
- maximal buffer size
|
|
|
|
- current state of the editbox with either active or inactive
|
|
|
|
- visual widget style structure describing the editbox
|
|
|
|
- glyph input filter type to only let specified glyph through
|
|
|
|
- input structure to update the editbox with
|
|
|
|
- font structure for text drawing
|
|
|
|
Output:
|
|
|
|
- state of the editbox with either active or inactive
|
|
|
|
- returns the size of the buffer in bytes after the modification
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_size gui_edit_filtered(struct gui_command_buffer*, gui_float x, gui_float y,
|
2015-06-04 23:37:47 +03:00
|
|
|
gui_float w, gui_float h, gui_char*, gui_size,
|
|
|
|
gui_size max, gui_bool*, const struct gui_edit*,
|
|
|
|
gui_filter filter, const struct gui_input*,
|
|
|
|
const struct gui_font*);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function executes a editbox widget
|
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- output command buffer for drawing
|
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
2015-06-04 23:17:54 +03:00
|
|
|
- char buffer to add or remove glyphes from/to
|
|
|
|
- buffer text length in bytes
|
|
|
|
- maximal buffer size
|
|
|
|
- current state of the editbox with either active or inactive
|
|
|
|
- visual widget style structure describing the editbox
|
|
|
|
- glyph input filter callback to only let specified glyph through
|
|
|
|
- input structure to update the editbox with
|
|
|
|
- font structure for text drawing
|
|
|
|
Output:
|
|
|
|
- state of the editbox with either active or inactive
|
|
|
|
- returns the size of the buffer in bytes after the modification
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_int gui_spinner(struct gui_command_buffer*, gui_float x, gui_float y, gui_float w,
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_float h, const struct gui_spinner*, gui_int min, gui_int value,
|
2015-07-01 15:01:53 +03:00
|
|
|
gui_int max, gui_int step, gui_bool *active,
|
|
|
|
const struct gui_input*, const struct gui_font*);
|
2015-06-04 23:17:54 +03:00
|
|
|
/* this function executes a spinner widget
|
|
|
|
Input:
|
|
|
|
- output command buffer for draw commands
|
2015-06-16 00:46:13 +03:00
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
2015-06-04 23:17:54 +03:00
|
|
|
- visual widget style structure describing the spinner
|
|
|
|
- minimal spinner value that will no be underflown
|
|
|
|
- spinner value that will be updated
|
|
|
|
- maximal spinner value that will no be overflown
|
|
|
|
- spinner input state with either active or inactive
|
|
|
|
- input structure to update the slider with
|
|
|
|
- font structure for text drawing
|
|
|
|
Output:
|
|
|
|
- returns the from the user input updated spinner value
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_size gui_selector(struct gui_command_buffer*, gui_float x, gui_float y,
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_float w, gui_float h, const struct gui_selector*,
|
|
|
|
const char *items[], gui_size item_count,
|
|
|
|
gui_size item_current, const struct gui_input*,
|
|
|
|
const struct gui_font*);
|
|
|
|
/* this function executes a selector widget
|
|
|
|
Input:
|
|
|
|
- output command buffer for draw commands
|
2015-06-16 00:46:13 +03:00
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
2015-06-04 23:17:54 +03:00
|
|
|
- visual widget style structure describing the selector
|
|
|
|
- selection of string array to select from
|
|
|
|
- size of the selection array
|
|
|
|
- input structure to update the slider with
|
|
|
|
- font structure for text drawing
|
|
|
|
Output:
|
|
|
|
- returns the from the user input updated spinner value
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_float gui_scroll(struct gui_command_buffer*, gui_float x, gui_float y,
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_float w, gui_float h, gui_float offset, gui_float target,
|
|
|
|
gui_float step, const struct gui_scroll*, const struct gui_input*);
|
|
|
|
/* this function executes a scrollbar widget
|
|
|
|
Input:
|
|
|
|
- output command buffer for draw commands
|
2015-06-16 00:46:13 +03:00
|
|
|
- (x,y) position
|
|
|
|
- (width, height) size
|
2015-06-04 23:17:54 +03:00
|
|
|
- scrollbar offset in source pixel
|
|
|
|
- destination pixel size
|
|
|
|
- step pixel size if the scrollbar up- or down button is pressed
|
|
|
|
- visual widget style structure describing the selector
|
|
|
|
- input structure to update the slider with
|
|
|
|
Output:
|
2015-06-04 23:37:47 +03:00
|
|
|
- returns the from the user input updated scrollbar offset in pixels
|
2015-06-04 23:17:54 +03:00
|
|
|
*/
|
2015-05-29 15:18:23 +03:00
|
|
|
/*
|
|
|
|
* ==============================================================
|
|
|
|
*
|
|
|
|
* Config
|
|
|
|
*
|
|
|
|
* ===============================================================
|
|
|
|
*/
|
2015-06-04 23:17:54 +03:00
|
|
|
/* CONFIG
|
|
|
|
----------------------------
|
2015-06-16 00:46:13 +03:00
|
|
|
The panel configuration consists of style, color and rectangle roundingo
|
|
|
|
information that is used for the general style and looks of panel.
|
|
|
|
In addition for temporary modification the configuration structure consists
|
|
|
|
of a stack for pushing and pop either color or property values.
|
2015-06-04 23:17:54 +03:00
|
|
|
|
|
|
|
USAGE
|
|
|
|
----------------------------
|
2015-06-04 23:50:22 +03:00
|
|
|
To use the configuration file you either initialize every value yourself besides
|
2015-06-04 23:37:47 +03:00
|
|
|
the internal stack which needs to be initialized to zero or use the default
|
|
|
|
configuration by calling the function gui_config_default.
|
|
|
|
To add and remove temporary configuration states the gui_config_push_xxxx
|
|
|
|
for adding and gui_config_pop_xxxx for removing either color or property values
|
|
|
|
from the stack. To reset all previously modified values the gui_config_reset_xxx
|
|
|
|
were added.
|
|
|
|
|
2015-06-04 23:17:54 +03:00
|
|
|
Configuration function API
|
|
|
|
gui_config_default -- initializes a default panel configuration
|
|
|
|
gui_config_property -- returns the property value from an id
|
|
|
|
gui_config_color -- returns the color value from an id
|
|
|
|
gui_config_push_property -- push an old property onto a interal stack and sets a new value
|
|
|
|
gui_config_push_color -- push an old color onto a internal stack and sets a new value
|
|
|
|
gui_config_pop_color -- resets an old color value from the internal stack
|
|
|
|
gui_config_pop_property -- resets an old property value from the internal stack
|
|
|
|
gui_config_reset_colors -- reverts back all temporary color changes from the config
|
|
|
|
gui_config_reset_properties -- reverts back all temporary property changes from the config
|
|
|
|
gui_config_reset -- reverts back all temporary all changes from the config
|
|
|
|
*/
|
2015-05-29 15:18:23 +03:00
|
|
|
enum gui_config_colors {
|
2015-03-08 21:19:07 +03:00
|
|
|
GUI_COLOR_TEXT,
|
|
|
|
GUI_COLOR_PANEL,
|
2015-05-07 14:41:55 +03:00
|
|
|
GUI_COLOR_HEADER,
|
2015-03-08 21:19:07 +03:00
|
|
|
GUI_COLOR_BORDER,
|
|
|
|
GUI_COLOR_BUTTON,
|
|
|
|
GUI_COLOR_BUTTON_BORDER,
|
2015-03-17 16:42:49 +03:00
|
|
|
GUI_COLOR_BUTTON_HOVER,
|
2015-04-26 23:38:55 +03:00
|
|
|
GUI_COLOR_BUTTON_TOGGLE,
|
2015-03-17 16:42:49 +03:00
|
|
|
GUI_COLOR_BUTTON_HOVER_FONT,
|
2015-03-20 12:58:11 +03:00
|
|
|
GUI_COLOR_CHECK,
|
2015-05-02 22:18:45 +03:00
|
|
|
GUI_COLOR_CHECK_BACKGROUND,
|
2015-03-20 12:58:11 +03:00
|
|
|
GUI_COLOR_CHECK_ACTIVE,
|
|
|
|
GUI_COLOR_OPTION,
|
2015-05-02 22:18:45 +03:00
|
|
|
GUI_COLOR_OPTION_BACKGROUND,
|
2015-03-20 12:58:11 +03:00
|
|
|
GUI_COLOR_OPTION_ACTIVE,
|
2015-03-08 21:19:07 +03:00
|
|
|
GUI_COLOR_SLIDER,
|
2015-05-23 01:11:58 +03:00
|
|
|
GUI_COLOR_SLIDER_BAR,
|
|
|
|
GUI_COLOR_SLIDER_BORDER,
|
2015-03-08 21:19:07 +03:00
|
|
|
GUI_COLOR_SLIDER_CURSOR,
|
|
|
|
GUI_COLOR_PROGRESS,
|
|
|
|
GUI_COLOR_PROGRESS_CURSOR,
|
2015-03-10 15:50:27 +03:00
|
|
|
GUI_COLOR_INPUT,
|
2015-05-12 16:57:53 +03:00
|
|
|
GUI_COLOR_INPUT_CURSOR,
|
2015-03-10 15:50:27 +03:00
|
|
|
GUI_COLOR_INPUT_BORDER,
|
2015-06-03 01:58:57 +03:00
|
|
|
GUI_COLOR_INPUT_TEXT,
|
2015-03-14 19:05:30 +03:00
|
|
|
GUI_COLOR_SPINNER,
|
|
|
|
GUI_COLOR_SPINNER_BORDER,
|
2015-05-24 21:32:22 +03:00
|
|
|
GUI_COLOR_SPINNER_TRIANGLE,
|
2015-06-03 01:58:57 +03:00
|
|
|
GUI_COLOR_SPINNER_TEXT,
|
2015-03-20 12:58:11 +03:00
|
|
|
GUI_COLOR_SELECTOR,
|
|
|
|
GUI_COLOR_SELECTOR_BORDER,
|
2015-05-24 21:32:22 +03:00
|
|
|
GUI_COLOR_SELECTOR_TRIANGLE,
|
2015-06-03 01:58:57 +03:00
|
|
|
GUI_COLOR_SELECTOR_TEXT,
|
2015-03-10 15:50:27 +03:00
|
|
|
GUI_COLOR_HISTO,
|
|
|
|
GUI_COLOR_HISTO_BARS,
|
|
|
|
GUI_COLOR_HISTO_NEGATIVE,
|
|
|
|
GUI_COLOR_HISTO_HIGHLIGHT,
|
|
|
|
GUI_COLOR_PLOT,
|
|
|
|
GUI_COLOR_PLOT_LINES,
|
2015-03-11 20:17:37 +03:00
|
|
|
GUI_COLOR_PLOT_HIGHLIGHT,
|
2015-03-16 11:51:33 +03:00
|
|
|
GUI_COLOR_SCROLLBAR,
|
|
|
|
GUI_COLOR_SCROLLBAR_CURSOR,
|
2015-03-16 16:02:47 +03:00
|
|
|
GUI_COLOR_SCROLLBAR_BORDER,
|
2015-05-02 22:18:45 +03:00
|
|
|
GUI_COLOR_TABLE_LINES,
|
2015-05-14 22:00:18 +03:00
|
|
|
GUI_COLOR_SHELF,
|
|
|
|
GUI_COLOR_SHELF_TEXT,
|
|
|
|
GUI_COLOR_SHELF_ACTIVE,
|
|
|
|
GUI_COLOR_SHELF_ACTIVE_TEXT,
|
2015-04-07 19:20:28 +03:00
|
|
|
GUI_COLOR_SCALER,
|
2015-06-23 17:33:49 +03:00
|
|
|
GUI_COLOR_LAYOUT_SCALER,
|
2015-03-08 21:19:07 +03:00
|
|
|
GUI_COLOR_COUNT
|
|
|
|
};
|
|
|
|
|
2015-05-31 22:49:20 +03:00
|
|
|
enum gui_config_rounding {
|
|
|
|
GUI_ROUNDING_BUTTON,
|
|
|
|
GUI_ROUNDING_CHECK,
|
|
|
|
GUI_ROUNDING_PROGRESS,
|
|
|
|
GUI_ROUNDING_INPUT,
|
|
|
|
GUI_ROUNDING_GRAPH,
|
|
|
|
GUI_ROUNDING_SCROLLBAR,
|
|
|
|
GUI_ROUNDING_MAX
|
|
|
|
};
|
|
|
|
|
2015-05-29 15:18:23 +03:00
|
|
|
enum gui_config_properties {
|
2015-05-20 18:05:28 +03:00
|
|
|
GUI_PROPERTY_ITEM_SPACING,
|
|
|
|
GUI_PROPERTY_ITEM_PADDING,
|
|
|
|
GUI_PROPERTY_PADDING,
|
|
|
|
GUI_PROPERTY_SCALER_SIZE,
|
|
|
|
GUI_PROPERTY_SCROLLBAR_WIDTH,
|
|
|
|
GUI_PROPERTY_SIZE,
|
|
|
|
GUI_PROPERTY_MAX
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_saved_property {
|
2015-05-29 15:18:23 +03:00
|
|
|
enum gui_config_properties type;
|
2015-06-04 23:50:22 +03:00
|
|
|
/* identifier of the current modified property */
|
2015-05-20 18:05:28 +03:00
|
|
|
struct gui_vec2 value;
|
2015-06-04 23:50:22 +03:00
|
|
|
/* property value that has been saveed */
|
2015-05-20 18:05:28 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_saved_color {
|
2015-05-29 15:18:23 +03:00
|
|
|
enum gui_config_colors type;
|
2015-06-04 23:50:22 +03:00
|
|
|
/* identifier of the current modified color */
|
2015-05-20 18:05:28 +03:00
|
|
|
struct gui_color value;
|
2015-06-04 23:50:22 +03:00
|
|
|
/* color value that has been saveed */
|
2015-05-20 18:05:28 +03:00
|
|
|
};
|
|
|
|
|
2015-05-31 22:49:20 +03:00
|
|
|
enum gui_config_components {
|
|
|
|
GUI_DEFAULT_COLOR = 0x01,
|
|
|
|
GUI_DEFAULT_PROPERTIES = 0x02,
|
|
|
|
GUI_DEFAULT_ROUNDING = 0x04,
|
2015-06-03 01:58:57 +03:00
|
|
|
GUI_DEFAULT_ALL = 0xFFFF
|
2015-05-31 22:49:20 +03:00
|
|
|
};
|
|
|
|
|
2015-06-04 23:17:54 +03:00
|
|
|
struct gui_config_stack {
|
|
|
|
gui_size property;
|
2015-06-04 23:50:22 +03:00
|
|
|
/* current property stack pushing index */
|
2015-06-04 23:17:54 +03:00
|
|
|
struct gui_saved_property properties[GUI_MAX_ATTRIB_STACK];
|
2015-06-04 23:50:22 +03:00
|
|
|
/* saved property stack */
|
2015-06-04 23:17:54 +03:00
|
|
|
struct gui_saved_color colors[GUI_MAX_COLOR_STACK];
|
2015-06-04 23:50:22 +03:00
|
|
|
/* saved color stack */
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_size color;
|
2015-06-04 23:50:22 +03:00
|
|
|
/* current color stack pushing index */
|
2015-06-04 23:17:54 +03:00
|
|
|
};
|
|
|
|
|
2015-03-08 21:19:07 +03:00
|
|
|
struct gui_config {
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_font font;
|
2015-06-04 23:50:22 +03:00
|
|
|
/* the from the user provided font */
|
2015-06-23 17:33:49 +03:00
|
|
|
gui_float scaler_width;
|
|
|
|
/* width of the tiled panel scaler */
|
2015-05-31 22:49:20 +03:00
|
|
|
gui_float rounding[GUI_ROUNDING_MAX];
|
2015-06-04 23:50:22 +03:00
|
|
|
/* rectangle widget rounding */
|
2015-05-20 18:05:28 +03:00
|
|
|
struct gui_vec2 properties[GUI_PROPERTY_MAX];
|
2015-06-04 23:50:22 +03:00
|
|
|
/* configuration properties to modify the panel style */
|
2015-03-08 21:19:07 +03:00
|
|
|
struct gui_color colors[GUI_COLOR_COUNT];
|
2015-06-04 23:50:22 +03:00
|
|
|
/* configuration color to modify the panel color */
|
2015-06-04 23:17:54 +03:00
|
|
|
struct gui_config_stack stack;
|
2015-06-04 23:50:22 +03:00
|
|
|
/* modification stack */
|
2015-03-05 17:37:11 +03:00
|
|
|
};
|
|
|
|
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_config_default(struct gui_config*, gui_flags, const struct gui_font*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function load the panel configuration with default values
|
|
|
|
Input:
|
|
|
|
- configuration flags indicating which part of the configuration should be loaded with default values
|
|
|
|
- user font reference structure describing the font used inside the panel
|
|
|
|
Output:
|
|
|
|
- configuration structure holding the default panel style
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
struct gui_vec2 gui_config_property(const struct gui_config*,
|
2015-06-05 16:01:15 +03:00
|
|
|
enum gui_config_properties);
|
|
|
|
/* this function accesses a configuration property over an identifier
|
|
|
|
Input:
|
|
|
|
- Configuration the get the property from
|
|
|
|
- Configuration property idenfifier describing the property to get
|
|
|
|
Output:
|
|
|
|
- Property value that has been asked for
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
struct gui_color gui_config_color(const struct gui_config*, enum gui_config_colors);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function accesses a configuration color over an identifier
|
|
|
|
Input:
|
|
|
|
- Configuration the get the color from
|
|
|
|
- Configuration color idenfifier describing the color to get
|
|
|
|
Output:
|
|
|
|
- color value that has been asked for
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_config_push_property(struct gui_config*, enum gui_config_properties,
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_float, gui_float);
|
|
|
|
/* this function temporarily changes a property in a stack like fashion to be reseted later
|
|
|
|
Input:
|
|
|
|
- Configuration structure to push the change to
|
|
|
|
- Property idenfifier to change
|
|
|
|
- first value of the property most of the time the x position
|
|
|
|
- second value of the property most of the time the y position
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_config_push_color(struct gui_config*, enum gui_config_colors,
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_byte, gui_byte, gui_byte, gui_byte);
|
|
|
|
/* this function temporarily changes a color in a stack like fashion to be reseted later
|
|
|
|
Input:
|
|
|
|
- Configuration structure to push the change to
|
|
|
|
- color idenfifier to change
|
|
|
|
- red color component
|
|
|
|
- green color component
|
|
|
|
- blue color component
|
|
|
|
- alpha color component
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_config_pop_color(struct gui_config*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function reverts back a previously pushed temporary color change
|
|
|
|
Input:
|
|
|
|
- Configuration structure to pop the change from and to
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_config_pop_property(struct gui_config*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function reverts back a previously pushed temporary property change
|
|
|
|
Input:
|
|
|
|
- Configuration structure to pop the change from and to
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_config_reset_colors(struct gui_config*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function reverts back all previously pushed temporary color changes
|
|
|
|
Input:
|
|
|
|
- Configuration structure to pop the change from and to
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_config_reset_properties(struct gui_config*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function reverts back all previously pushed temporary color changes
|
|
|
|
Input:
|
|
|
|
- Configuration structure to pop the change from and to
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_config_reset(struct gui_config*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function reverts back all previously pushed temporary color and
|
|
|
|
* property changes
|
|
|
|
Input:
|
|
|
|
- Configuration structure to pop the change from and to
|
|
|
|
*/
|
2015-05-29 15:18:23 +03:00
|
|
|
/*
|
|
|
|
* ==============================================================
|
|
|
|
*
|
|
|
|
* Panel
|
|
|
|
*
|
|
|
|
* ===============================================================
|
|
|
|
*/
|
2015-06-04 23:17:54 +03:00
|
|
|
/* PANEL
|
|
|
|
----------------------------
|
2015-06-05 16:01:15 +03:00
|
|
|
The Panel function API is based on the widget API and is almost in its
|
2015-06-06 13:45:18 +03:00
|
|
|
entirety based on positioning of groups of widgets. Almost each widget inside the
|
2015-06-05 16:01:15 +03:00
|
|
|
panel API uses the widget API for drawing and manipulation/input logic
|
|
|
|
but offers a uniform style over a single configuration structure as well as
|
|
|
|
widget group base moving, spacing and structuring. The panel references
|
|
|
|
a basic configuration file, an output commmand buffer and input structure which
|
|
|
|
need to share the same or greater life time than the panel since they are relied
|
|
|
|
on by the panel.
|
2015-06-04 23:17:54 +03:00
|
|
|
|
|
|
|
USAGE
|
|
|
|
----------------------------
|
2015-06-05 16:01:15 +03:00
|
|
|
To setup the Panel API you have to initiate the panel first with position, size
|
2015-06-06 13:45:18 +03:00
|
|
|
and behavior flags. The flags inside the panel describe the behavior of the panel
|
|
|
|
and can be set or modified directly over the public panel struture
|
2015-06-05 16:01:15 +03:00
|
|
|
or at the beginning in the initialization phase. Just like the flags the position
|
|
|
|
and size of the panel is made directly modifiable at any given time given single
|
|
|
|
threaded access while changes are only visible outside the layout buildup process.
|
|
|
|
|
|
|
|
To finally use the panel a panel layout has to be created over gui_panle_begin_xxx
|
|
|
|
which sets up the panel layout build up process. The panel layout has to be kept
|
|
|
|
valid over the course of the build process until gui_panel_end is called, which
|
2015-06-06 13:45:18 +03:00
|
|
|
makes the layout perfectly fit for either a stack object or a single instance for
|
|
|
|
every panel. The begin sequence pont of the panel layout also gives the opportunity to
|
2015-06-05 16:01:15 +03:00
|
|
|
add the panel either into a panel stack for overlapping panels or a tiled border
|
|
|
|
layout for automated window independend panel positing and sizing.
|
|
|
|
|
|
|
|
To add widgets into the panel layout a number of basic widget are provided
|
|
|
|
which can be added by calling the appropriate function inside both panel
|
|
|
|
layout sequene points gui_panel_begin and gui_panel_end. All calls outside
|
|
|
|
both sequence points are invalid and can cause undefined behavior.
|
|
|
|
|
|
|
|
Since the panel has no information about the structuring of widgets a
|
|
|
|
row layout has to be set with row height and number of columns which can
|
|
|
|
be changed and set by calling the gui_panel_row function.
|
|
|
|
IMPORTANT: !IF YOUR LAYOUT IS WRONG FIRST CHECK IF YOU CALLED gui_panel_row CORRECTLY XOR AT ALL!
|
|
|
|
|
2015-06-04 23:17:54 +03:00
|
|
|
Panel function API
|
|
|
|
gui_panel_init -- initializes the panel with position, size and flags
|
|
|
|
gui_panel_begin -- begin sequence point in the panel layout build up process
|
|
|
|
gui_panel_begin_stacked -- extends gui_panel_begin by adding the panel into a panel stack
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_panel_begin_tiled -- extends gui_panel_begin by adding the panel into a tiled layout
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_panel_row -- defines the current row layout with row height and number of columns
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_panel_widget -- base function for all widgets to allocate space on the panel
|
|
|
|
gui_panel_spacing -- create a column seperator and is basically an empty widget
|
2015-06-04 23:17:54 +03:00
|
|
|
gui_panel_text -- text widget for printing text with length
|
|
|
|
gui_panel_text_colored -- colored text widget for printing colored text width length
|
|
|
|
gui_panel_label -- text widget for printing zero terminated strings
|
|
|
|
gui_panel_label_colored -- text wicget for printing colored zero terminiated strings
|
|
|
|
gui_panel_check -- add a checkbox widget with either active or inactive state
|
|
|
|
gui_panel_option -- radiobutton widget with either active or inactive state
|
|
|
|
gui_panel_option_group -- radiobutton group with automates the process of having only one active
|
|
|
|
gui_panel_button_text -- button widget with text content
|
|
|
|
gui_panel_button_color -- colored button widget without content
|
|
|
|
gui_panel_button_triangle --button with triangle pointing either up-/down-/left- or right
|
|
|
|
gui_panel_button_image -- button widget width icon content
|
|
|
|
gui_panel_button_toggle -- toggle button with either active or inactive state
|
|
|
|
gui_panel_slider -- slider widget with min and max value as well as stepping range
|
|
|
|
gui_panel_progress -- either modifyable or static progressbar
|
|
|
|
gui_panel_edit -- edit textbox widget for text input
|
|
|
|
gui_panel_edit_filtered -- edit textbox widget for text input with filter input
|
|
|
|
gui_panel_spinner -- spinner widget with either keyboard or mouse modification
|
|
|
|
gui_panel_selector -- selector widget for combobox like selection of types
|
|
|
|
gui_panel_graph_begin -- immediate mode graph building begin sequence point
|
|
|
|
gui_panel_graph_push -- push a value into a graph
|
|
|
|
gui_panel_graph_end -- immediate mode graph building end sequence point
|
|
|
|
gui_panel_graph -- retained mode graph with array of values
|
|
|
|
gui_panel_graph_ex -- ratained mode graph with getter callback
|
|
|
|
gui_panel_end -- end squeunce point which finializes the panel build up
|
|
|
|
*/
|
2015-06-05 16:01:15 +03:00
|
|
|
#if 0
|
|
|
|
#define GUI_IMPLEMENTATION
|
|
|
|
#include "gui.h"
|
|
|
|
|
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
/* allocate memory to hold the draw commands */
|
|
|
|
gui_command_buffer buffer;
|
|
|
|
void *memory = malloc(MEMORY_SIZE)
|
|
|
|
gui_command_buffer_init_fixed(buffer, memory, MEMORY_SIZE);
|
|
|
|
|
|
|
|
/* setup configuration */
|
|
|
|
struct gui_config config;
|
|
|
|
struct gui_font font = {...};
|
|
|
|
gui_config_default(&config, GUI_DEFAULT_ALL, &font);
|
|
|
|
|
|
|
|
/* initialize panel */
|
|
|
|
struct gui_panel panel;
|
|
|
|
gui_panel_init(&panel, 50, 50, 220, 170,
|
|
|
|
GUI_PANEL_BORDER|GUI_PANEL_MOVEABLE|
|
|
|
|
GUI_PANEL_CLOSEABLE|GUI_PANEL_SCALEABLE|
|
|
|
|
GUI_PANEL_MINIMIZABLE, &config, &buffer);
|
|
|
|
|
|
|
|
struct gui_input input = {0};
|
|
|
|
while (1) {
|
|
|
|
gui_input_begin(&input);
|
|
|
|
/* record input */
|
|
|
|
gui_input_end(&input);
|
|
|
|
|
|
|
|
/* GUI */
|
|
|
|
struct gui_panel_layout layout;
|
|
|
|
gui_panel_begin(&layout, &panel, "Demo", &input);
|
|
|
|
gui_panel_row(&layout, 30, 1);
|
|
|
|
if (gui_panel_button_text(&layout, "button", GUI_BUTTON_DEFAULT)) {
|
|
|
|
/* event handling */
|
|
|
|
}
|
|
|
|
gui_panel_row(&layout, 30, 2);
|
|
|
|
if (gui_panel_option(&layout, "easy", option == 0)) option = 0;
|
|
|
|
if (gui_panel_option(&layout, "hard", option == 1)) option = 1;
|
|
|
|
gui_panel_label(&layout, "input:", GUI_TEXT_LEFT);
|
|
|
|
len = gui_panel_edit(&layout, buffer, len, 256, &active, GUI_INPUT_DEFAULT);
|
|
|
|
gui_panel_end(&layout, &panel);
|
|
|
|
|
|
|
|
/* draw */
|
|
|
|
const struct gui_command *cmd;
|
|
|
|
gui_foreach_command(cmd, buffer) {
|
|
|
|
/* execute draw call command */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-05-29 15:18:23 +03:00
|
|
|
enum gui_table_lines {
|
|
|
|
GUI_TABLE_HHEADER = 0x01,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* Horizontal table header lines */
|
2015-05-29 15:18:23 +03:00
|
|
|
GUI_TABLE_VHEADER = 0x02,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* Vertical table header lines */
|
2015-05-29 15:18:23 +03:00
|
|
|
GUI_TABLE_HBODY = 0x04,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* Horizontal table body lines */
|
2015-05-29 15:18:23 +03:00
|
|
|
GUI_TABLE_VBODY = 0x08
|
2015-06-05 16:01:15 +03:00
|
|
|
/* Vertical table body lines */
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
2015-05-20 18:05:28 +03:00
|
|
|
|
2015-05-31 16:41:09 +03:00
|
|
|
enum gui_graph_type {
|
|
|
|
GUI_GRAPH_LINES,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* Line graph with each data point being connected with its previous and next node */
|
2015-05-31 16:41:09 +03:00
|
|
|
GUI_GRAPH_COLUMN,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* Column graph/Histogram with value represented as bars */
|
2015-05-31 16:41:09 +03:00
|
|
|
GUI_GRAPH_MAX
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_graph {
|
|
|
|
gui_bool valid;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* graph valid flag to make sure that the graph is visible */
|
2015-05-31 16:41:09 +03:00
|
|
|
enum gui_graph_type type;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* graph type with either line or column graph */
|
2015-05-31 16:41:09 +03:00
|
|
|
gui_float x, y;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* graph canvas space position */
|
2015-05-31 16:41:09 +03:00
|
|
|
gui_float w, h;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* graph canvas space size */
|
2015-05-31 16:41:09 +03:00
|
|
|
gui_float min, max;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* min and max value for correct scaling of values */
|
2015-05-31 16:41:09 +03:00
|
|
|
struct gui_vec2 last;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* last line graph point to connect to. Only used by the line graph */
|
2015-05-31 16:41:09 +03:00
|
|
|
gui_size index;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* current graph value index*/
|
2015-05-31 16:41:09 +03:00
|
|
|
gui_size count;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* number of values inside the graph */
|
2015-05-31 16:41:09 +03:00
|
|
|
};
|
|
|
|
|
2015-05-13 15:47:11 +03:00
|
|
|
enum gui_panel_tab {
|
|
|
|
GUI_MAXIMIZED = gui_false,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* Flag indicating that the panel tab is open */
|
2015-05-13 15:47:11 +03:00
|
|
|
GUI_MINIMIZED = gui_true
|
2015-06-05 16:01:15 +03:00
|
|
|
/* Flag indicating that the panel tab is closed */
|
2015-05-13 15:47:11 +03:00
|
|
|
};
|
|
|
|
|
2015-03-10 15:50:27 +03:00
|
|
|
enum gui_panel_flags {
|
2015-04-07 19:47:32 +03:00
|
|
|
GUI_PANEL_HIDDEN = 0x01,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* Hiddes the panel and stops any panel interaction and drawing can be set
|
|
|
|
* by user input or by closing the panel */
|
2015-04-03 19:59:24 +03:00
|
|
|
GUI_PANEL_BORDER = 0x02,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* Draws a border around the panel to visually seperate the panel from the
|
|
|
|
* background */
|
2015-05-09 18:44:27 +03:00
|
|
|
GUI_PANEL_MINIMIZABLE = 0x04,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* Enables the panel to be minimized/collapsed and adds a minimizing icon
|
|
|
|
* in the panel header to be clicked by GUI user */
|
2015-05-09 18:44:27 +03:00
|
|
|
GUI_PANEL_CLOSEABLE = 0x08,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* Enables the panel to be closed, hidden and made non interactive for the
|
2015-06-16 00:46:13 +03:00
|
|
|
* user by adding a closing icon in the panel header */
|
2015-04-07 19:47:32 +03:00
|
|
|
GUI_PANEL_MOVEABLE = 0x10,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* The moveable flag inidicates that a panel can be move by user input by
|
|
|
|
* dragging the panel header */
|
2015-04-07 19:47:32 +03:00
|
|
|
GUI_PANEL_SCALEABLE = 0x20,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* The scaleable flag indicates that a panel can be scaled by user input
|
|
|
|
* by dragging a scaler icon at the button of the panel */
|
2015-05-17 14:38:37 +03:00
|
|
|
GUI_PANEL_NO_HEADER = 0x40,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* To remove the header from the panel and invalidate all panel header flags
|
|
|
|
* the NO HEADER flags was added */
|
2015-05-17 14:38:37 +03:00
|
|
|
GUI_PANEL_BORDER_HEADER = 0x80,
|
2015-06-16 00:46:13 +03:00
|
|
|
/* Draws a border inside the panel for the panel header seperating the body
|
2015-06-05 16:01:15 +03:00
|
|
|
* and header of the panel */
|
2015-05-17 14:38:37 +03:00
|
|
|
GUI_PANEL_ACTIVE = 0x100,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* INTERNAL ONLY!: marks the panel as active, used by the panel stack */
|
2015-05-17 14:38:37 +03:00
|
|
|
GUI_PANEL_SCROLLBAR = 0x200,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* INTERNAL ONLY!: adds a scrollbar to the panel which enables fixed size
|
|
|
|
* panels with unlimited amount of space to fill */
|
2015-06-23 17:33:49 +03:00
|
|
|
GUI_PANEL_TAB = 0x400,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* INTERNAL ONLY!: Marks the panel as an subpanel of another panel(Groups/Tabs/Shelf)*/
|
2015-06-23 17:33:49 +03:00
|
|
|
GUI_PANEL_DO_NOT_RESET = 0x800
|
|
|
|
/* INTERNAL ONLY!: requires that the panel does not resets the command buffer */
|
2015-03-23 19:18:18 +03:00
|
|
|
};
|
|
|
|
|
2015-03-05 17:37:11 +03:00
|
|
|
struct gui_panel {
|
2015-03-11 16:00:59 +03:00
|
|
|
gui_float x, y;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* position in the os window */
|
2015-04-19 23:12:37 +03:00
|
|
|
gui_float w, h;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* size with width and height of the panel */
|
2015-04-25 16:30:51 +03:00
|
|
|
gui_flags flags;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* panel flags modifing its behavior */
|
2015-04-25 16:30:51 +03:00
|
|
|
gui_float offset;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* panel scrollbar offset in pixel */
|
2015-04-25 16:30:51 +03:00
|
|
|
gui_bool minimized;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* flag indicating if the panel is collapsed */
|
2015-04-25 16:30:51 +03:00
|
|
|
const struct gui_config *config;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* configuration reference describing the panel style */
|
2015-06-03 01:58:57 +03:00
|
|
|
struct gui_command_buffer *buffer;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* output command buffer queuing all drawing calls */
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_panel* next;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* next panel pointer for the panel stack*/
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_panel* prev;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* prev panel pointer for the panel stack*/
|
2015-05-07 16:52:35 +03:00
|
|
|
};
|
|
|
|
|
2015-06-09 18:05:05 +03:00
|
|
|
#define GUI_UNDEFINED (-1.0f)
|
|
|
|
struct gui_panel_row_layout {
|
|
|
|
gui_float height;
|
|
|
|
/* height of the current row */
|
|
|
|
gui_size columns;
|
|
|
|
/* number of columns in the current row */
|
|
|
|
const gui_float *ratio;
|
|
|
|
/* row widget width ratio */
|
|
|
|
gui_float item_ratio;
|
|
|
|
/* current with of very item */
|
|
|
|
};
|
|
|
|
|
2015-04-25 16:30:51 +03:00
|
|
|
struct gui_panel_layout {
|
|
|
|
gui_float x, y, w, h;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* position and size of the panel in the os window */
|
2015-04-25 16:30:51 +03:00
|
|
|
gui_float offset;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* panel scrollbar offset */
|
2015-05-02 22:18:45 +03:00
|
|
|
gui_bool is_table;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* flag indicating if the panel is currently creating a table */
|
2015-05-02 22:18:45 +03:00
|
|
|
gui_flags tbl_flags;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* flags describing the line drawing for every row in the table */
|
2015-04-25 16:30:51 +03:00
|
|
|
gui_bool valid;
|
2015-06-16 00:46:13 +03:00
|
|
|
/* flag inidicating if the panel is visible */
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_float at_x, at_y;
|
|
|
|
/* index position of the current widget row and column */
|
2015-04-25 16:30:51 +03:00
|
|
|
gui_float width, height;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* size of the actual useable space inside the panel */
|
2015-03-16 11:51:33 +03:00
|
|
|
gui_float header_height;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* height of the panel header space */
|
2015-06-09 18:05:05 +03:00
|
|
|
gui_size index;
|
|
|
|
/* index of the current widget in the current panel row */
|
|
|
|
struct gui_panel_row_layout row;
|
|
|
|
/* currently used panel row layout */
|
2015-04-19 23:12:37 +03:00
|
|
|
struct gui_rect clip;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* panel clipping rect needed by scrolling */
|
2015-03-09 22:04:45 +03:00
|
|
|
const struct gui_config *config;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* configuration data describing the visual style of the panel */
|
2015-04-25 16:30:51 +03:00
|
|
|
const struct gui_input *input;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* current input state for updating the panel and all its widgets */
|
2015-06-03 01:58:57 +03:00
|
|
|
struct gui_command_buffer *buffer;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* command draw call output command buffer */
|
2015-05-16 13:26:39 +03:00
|
|
|
};
|
|
|
|
|
2015-07-02 14:08:44 +03:00
|
|
|
|
2015-05-31 15:41:46 +03:00
|
|
|
struct gui_layout;
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_init(struct gui_panel*, gui_float x, gui_float y, gui_float w,
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_float h, gui_flags, struct gui_command_buffer*,
|
|
|
|
const struct gui_config*);
|
|
|
|
/* this function initilizes and setups the panel
|
|
|
|
Input:
|
2015-06-16 00:46:13 +03:00
|
|
|
- bounds of the panel with x,y position and width and height
|
2015-06-05 16:01:15 +03:00
|
|
|
- panel flags for modified panel behavior
|
|
|
|
- reference to a output command buffer to push draw calls to
|
|
|
|
- configuration file containing the style, color and font for the panel
|
|
|
|
Output:
|
|
|
|
- a newly initialized panel
|
|
|
|
*/
|
2015-07-02 14:08:44 +03:00
|
|
|
void gui_panel_add_flag(struct gui_panel*, gui_flags);
|
|
|
|
/* this function adds panel flags to the panel
|
|
|
|
Input:
|
|
|
|
- panel flags to add the panel
|
|
|
|
*/
|
|
|
|
void gui_panel_remove_flag(struct gui_panel*, gui_flags);
|
|
|
|
/* this function removes panel flags from the panel
|
|
|
|
Input:
|
|
|
|
- panel flags to remove from the panel
|
|
|
|
*/
|
|
|
|
gui_bool gui_panel_has_flag(struct gui_panel*, gui_flags);
|
|
|
|
/* this function checks if a panel has given flag(s)
|
|
|
|
Input:
|
|
|
|
- panel flags to check for
|
|
|
|
*/
|
2015-07-02 14:41:52 +03:00
|
|
|
gui_bool gui_panel_is_minimized(struct gui_panel*);
|
|
|
|
/* this function checks if the panel is minimized */
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_panel_begin(struct gui_panel_layout *layout, struct gui_panel*,
|
2015-06-05 16:01:15 +03:00
|
|
|
const char *title, const struct gui_input*);
|
|
|
|
/* this function begins the panel build up process
|
|
|
|
Input:
|
|
|
|
- title of the panel visible in th header
|
|
|
|
- input structure holding all user generated state changes
|
|
|
|
Output:
|
|
|
|
- panel layout to fill up with widgets
|
|
|
|
*/
|
|
|
|
struct gui_stack;
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_panel_begin_stacked(struct gui_panel_layout*, struct gui_panel*,
|
2015-06-05 16:01:15 +03:00
|
|
|
struct gui_stack*, const char*,
|
|
|
|
const struct gui_input*);
|
|
|
|
/* this function begins the panel build up process and push the panel into a panel stack
|
|
|
|
Input:
|
|
|
|
- panel stack to push the panel into
|
|
|
|
- title of the panel visible in th header
|
|
|
|
- input structure holding all user generated state changes
|
|
|
|
Output:
|
|
|
|
- panel layout to fill up with widgets
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_panel_begin_tiled(struct gui_panel_layout*, struct gui_panel*,
|
2015-06-05 16:01:15 +03:00
|
|
|
struct gui_layout*, gui_uint slot, gui_size index,
|
|
|
|
const char*, const struct gui_input*);
|
2015-06-09 18:05:05 +03:00
|
|
|
/* this function begins the panel build up process and push the panel into a tiled
|
|
|
|
* layout container
|
2015-06-05 16:01:15 +03:00
|
|
|
Input:
|
|
|
|
- tiled layout container to push the panel into
|
|
|
|
- slot inside the panel with either top,button,center,left or right position
|
|
|
|
- index inside the slot to position the panel into
|
|
|
|
- title of the panel visible in th header
|
|
|
|
- input structure holding all user generated state changes
|
|
|
|
Output:
|
|
|
|
- panel layout to fill up with widgets
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_row(struct gui_panel_layout*, gui_float height, gui_size cols);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function set the current panel row layout
|
|
|
|
Input:
|
|
|
|
- panel row layout height in pixel
|
|
|
|
- panel row layout column count
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_row_templated(struct gui_panel_layout*, gui_float height,
|
2015-06-09 18:05:05 +03:00
|
|
|
gui_size cols, const gui_float *ratio);
|
|
|
|
/* this function set the current panel row layout
|
|
|
|
Input:
|
|
|
|
- panel row layout height in pixel
|
|
|
|
- panel row layout column count
|
2015-06-27 12:40:39 +03:00
|
|
|
- array with percentage size values for each column
|
2015-06-09 18:05:05 +03:00
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_size gui_panel_row_columns(const struct gui_panel_layout *layout,
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_size widget_size);
|
2015-06-16 00:46:13 +03:00
|
|
|
/* this function calculates the possible number of widget with the same width in the
|
2015-06-05 16:01:15 +03:00
|
|
|
current row layout.
|
|
|
|
Input:
|
|
|
|
- size of all widgets that need to fit into the current panel row layout
|
|
|
|
Output:
|
|
|
|
- panel layout to fill up with widgets
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_panel_widget(struct gui_rect*, struct gui_panel_layout*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function represents the base of every widget and calculates the bounds
|
|
|
|
* and allocated space for a widget inside a panel.
|
|
|
|
Output:
|
|
|
|
- allocated space for a widget to draw into
|
|
|
|
- gui_true if the widget is visible and should be updated gui_false if not
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_spacing(struct gui_panel_layout*, gui_size cols);
|
2015-06-16 00:46:13 +03:00
|
|
|
/* this function creates a seperator to fill space
|
2015-06-05 16:01:15 +03:00
|
|
|
Input:
|
|
|
|
- number of columns or widget to jump over
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_text(struct gui_panel_layout*, const char*, gui_size,
|
2015-06-05 16:01:15 +03:00
|
|
|
enum gui_text_align);
|
|
|
|
/* this function creates a bounded non terminated text widget with either
|
|
|
|
left, centered or right alignment
|
|
|
|
Input:
|
|
|
|
- string pointer to text that should be drawn
|
|
|
|
- number of bytes the text is long
|
|
|
|
- text alignment with either left, centered or right alignment
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_text_colored(struct gui_panel_layout*, const char*, gui_size,
|
2015-06-05 16:01:15 +03:00
|
|
|
enum gui_text_align, struct gui_color);
|
|
|
|
/* this function creates a bounded non terminated color text widget with either
|
|
|
|
left, centered or right alignment
|
|
|
|
Input:
|
|
|
|
- string pointer to text that should be drawn
|
|
|
|
- number of bytes the text is long
|
|
|
|
- text alignment with either left, centered or right alignment
|
|
|
|
- color the text should be drawn
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_label(struct gui_panel_layout*, const char*, enum gui_text_align);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function creates a zero terminated text widget with either
|
|
|
|
left, centered or right alignment
|
|
|
|
Input:
|
|
|
|
- string pointer to text that should be drawn
|
|
|
|
- text alignment with either left, centered or right alignment
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_label_colored(struct gui_panel_layout*, const char*,
|
2015-06-05 16:01:15 +03:00
|
|
|
enum gui_text_align, struct gui_color);
|
|
|
|
/* this function creates a zero terminated colored text widget with either
|
|
|
|
left, centered or right alignment
|
|
|
|
Input:
|
|
|
|
- string pointer to text that should be drawn
|
|
|
|
- text alignment with either left, centered or right alignment
|
|
|
|
- color the label should be drawn
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_panel_check(struct gui_panel_layout*, const char*, gui_bool active);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function creates a checkbox widget with either active or inactive state
|
|
|
|
Input:
|
|
|
|
- checkbox label describing the content
|
|
|
|
- state of the checkbox with either active or inactive
|
|
|
|
Output:
|
|
|
|
- from user input updated state of the checkbox
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_panel_option(struct gui_panel_layout*, const char*, gui_bool active);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function creates a radiobutton widget with either active or inactive state
|
|
|
|
Input:
|
|
|
|
- radiobutton label describing the content
|
|
|
|
- state of the radiobutton with either active or inactive
|
|
|
|
Output:
|
|
|
|
- from user input updated state of the radiobutton
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_size gui_panel_option_group(struct gui_panel_layout*, const char**,
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_size cnt, gui_size cur);
|
|
|
|
/* this function creates a radiobutton group widget with only one active radiobutton
|
|
|
|
Input:
|
|
|
|
- radiobutton label array describing the content of each radiobutton
|
|
|
|
- number of radiobuttons
|
|
|
|
- index of the current active radiobutton
|
|
|
|
Output:
|
|
|
|
- the from user input updated index of the active radiobutton
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_panel_button_text(struct gui_panel_layout*, const char*,
|
2015-06-05 16:01:15 +03:00
|
|
|
enum gui_button_behavior);
|
|
|
|
/* this function creates a text button
|
|
|
|
Input:
|
|
|
|
- button label describing the button
|
|
|
|
- button behavior with either default or repeater behavior
|
|
|
|
Output:
|
|
|
|
- gui_true if the button was transistioned from unpressed to pressed with
|
|
|
|
default button behavior or pressed if repeater behavior.
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_panel_button_color(struct gui_panel_layout*, struct gui_color,
|
2015-06-05 16:01:15 +03:00
|
|
|
enum gui_button_behavior);
|
|
|
|
/* this function creates a colored button without content
|
|
|
|
Input:
|
|
|
|
- color the button should be drawn with
|
|
|
|
- button behavior with either default or repeater behavior
|
|
|
|
Output:
|
|
|
|
- gui_true if the button was transistioned from unpressed to pressed with
|
|
|
|
default button behavior or pressed if repeater behavior.
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_panel_button_triangle(struct gui_panel_layout*, enum gui_heading,
|
2015-06-05 16:01:15 +03:00
|
|
|
enum gui_button_behavior);
|
|
|
|
/* this function creates a button with a triangle pointing in one of four directions
|
|
|
|
Input:
|
|
|
|
- triangle direction with either up, down, left or right direction
|
|
|
|
- button behavior with either default or repeater behavior
|
|
|
|
Output:
|
|
|
|
- gui_true if the button was transistioned from unpressed to pressed with
|
|
|
|
default button behavior or pressed if repeater behavior.
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_panel_button_image(struct gui_panel_layout*, struct gui_image img,
|
2015-06-05 16:01:15 +03:00
|
|
|
enum gui_button_behavior);
|
|
|
|
/* this function creates a button with an icon as content
|
|
|
|
Input:
|
|
|
|
- icon image handle to draw into the button
|
|
|
|
- button behavior with either default or repeater behavior
|
|
|
|
Output:
|
|
|
|
- gui_true if the button was transistioned from unpressed to pressed with
|
|
|
|
default button behavior or pressed if repeater behavior.
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_panel_button_text_triangle(struct gui_panel_layout*, enum gui_heading,
|
2015-07-01 15:01:53 +03:00
|
|
|
const char*, enum gui_text_align,
|
|
|
|
enum gui_button_behavior);
|
2015-06-06 21:13:28 +03:00
|
|
|
/* this function creates a button with a triangle pointing in one of four directions and text
|
|
|
|
Input:
|
|
|
|
- triangle direction with either up, down, left or right direction
|
|
|
|
- button label describing the button
|
|
|
|
- text alignment with either left, centered or right alignment
|
|
|
|
- button behavior with either default or repeater behavior
|
|
|
|
Output:
|
|
|
|
- gui_true if the button was transistioned from unpressed to pressed with
|
|
|
|
default button behavior or pressed if repeater behavior.
|
|
|
|
*/
|
2015-07-01 15:01:53 +03:00
|
|
|
gui_bool gui_panel_button_text_image(struct gui_panel_layout *layout, struct gui_image img,
|
|
|
|
const char *text, enum gui_text_align align,
|
|
|
|
enum gui_button_behavior behavior);
|
|
|
|
/* this function creates a button with an icon and text
|
|
|
|
Input:
|
|
|
|
- image or subimage to use as an icon
|
|
|
|
- button label describing the button
|
|
|
|
- text alignment with either left, centered or right alignment
|
|
|
|
- button behavior with either default or repeater behavior
|
|
|
|
Output:
|
|
|
|
- gui_true if the button was transistioned from unpressed to pressed with
|
|
|
|
default button behavior or pressed if repeater behavior.
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_panel_button_toggle(struct gui_panel_layout*, const char*,gui_bool value);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function creates a toggle button which is either active or inactive
|
|
|
|
Input:
|
|
|
|
- label describing the toggle button
|
|
|
|
- current state of the toggle
|
|
|
|
Output:
|
|
|
|
- from user input updated toggle state
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_float gui_panel_slider(struct gui_panel_layout*, gui_float min, gui_float val,
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_float max, gui_float step);
|
|
|
|
/* this function creates a slider for value manipulation
|
|
|
|
Input:
|
|
|
|
- minimal slider value that will not be underflown
|
|
|
|
- slider value which shall be updated
|
|
|
|
- maximal slider value that will not be overflown
|
|
|
|
- step intervall to change the slider with
|
|
|
|
Output:
|
|
|
|
- the from user input updated slider value
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_size gui_panel_progress(struct gui_panel_layout*, gui_size cur, gui_size max,
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_bool modifyable);
|
|
|
|
/* this function creates an either user or program controlled progressbar
|
|
|
|
Input:
|
|
|
|
- current progressbar value
|
|
|
|
- maximal progressbar value that will not be overflown
|
|
|
|
- flag indicating if the progressbar should be changeable by user input
|
|
|
|
Output:
|
|
|
|
- the from user input updated progressbar value if modifyable progressbar
|
|
|
|
*/
|
2015-07-05 00:36:01 +03:00
|
|
|
void gui_panel_editbox(struct gui_panel_layout*, struct gui_edit_box*);
|
|
|
|
/* this function creates an editbox with copy & paste functionality and text buffering */
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_size gui_panel_edit(struct gui_panel_layout*, gui_char *buffer, gui_size len,
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_size max, gui_bool *active, enum gui_input_filter);
|
|
|
|
/* this function creates an editbox to updated/insert user text input
|
|
|
|
Input:
|
|
|
|
- buffer to fill with user input
|
|
|
|
- current length of the buffer in bytes
|
|
|
|
- maximal number of bytes the buffer can be filled with
|
|
|
|
- state of the editbox with active as currently modified by the user
|
|
|
|
- filter type to limit the glyph the user can input into the editbox
|
|
|
|
Output:
|
|
|
|
- length of the buffer after user input update
|
|
|
|
- current state of the editbox with active(gui_true) or inactive(gui_false)
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_size gui_panel_edit_filtered(struct gui_panel_layout*, gui_char *buffer,
|
2015-07-01 15:01:53 +03:00
|
|
|
gui_size len, gui_size max,
|
|
|
|
gui_bool *active, gui_filter);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function creates an editbox to updated/insert filtered user text input
|
|
|
|
Input:
|
|
|
|
- buffer to fill with user input
|
|
|
|
- current length of the buffer in bytes
|
|
|
|
- maximal number of bytes the buffer can be filled with
|
|
|
|
- state of the editbox with active as currently modified by the user
|
|
|
|
- filter callback to limit the glyphes the user can input into the editbox
|
|
|
|
Output:
|
|
|
|
- length of the buffer after user input update
|
|
|
|
- current state of the editbox with active(gui_true) or inactive(gui_false)
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_int gui_panel_spinner(struct gui_panel_layout*, gui_int min, gui_int value,
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_int max, gui_int step, gui_bool *active);
|
|
|
|
/* this function creates a spinner widget
|
|
|
|
Input:
|
|
|
|
- min value that will not be underflown
|
|
|
|
- current spinner value to be updated by user input
|
|
|
|
- max value that will not be overflown
|
|
|
|
- spinner value modificaton stepping intervall
|
|
|
|
- current state of the spinner with active as currently modfied by user input
|
|
|
|
Output:
|
|
|
|
- the from user input updated spinner value
|
|
|
|
- current state of the editbox with active(gui_true) or inactive(gui_false)
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_size gui_panel_selector(struct gui_panel_layout*, const char *items[],
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_size item_count, gui_size item_current);
|
|
|
|
/* this function creates a string selector widget
|
|
|
|
Input:
|
|
|
|
- string array contaning a selection
|
|
|
|
- number of items inside the selection array
|
|
|
|
- index of the currenetly selected item inside the array
|
|
|
|
Output:
|
|
|
|
- the from user selection selected array index of the active item
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_graph_begin(struct gui_panel_layout*, struct gui_graph*,
|
2015-06-05 16:01:15 +03:00
|
|
|
enum gui_graph_type, gui_size count,
|
|
|
|
gui_float min, gui_float max);
|
|
|
|
/* this function begins a graph building widget
|
|
|
|
Input:
|
|
|
|
- type of the graph with either lines or bars
|
|
|
|
- minimal graph value for the lower bounds of the graph
|
|
|
|
- maximal graph value for the upper bounds of the graph
|
|
|
|
Output:
|
|
|
|
- graph stack object that can be filled with values
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_panel_graph_push(struct gui_panel_layout*,struct gui_graph*,gui_float);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function pushes a value inside the pushed graph
|
|
|
|
Input:
|
|
|
|
- value data point to fill into the graph either as point or as bar
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_graph_end(struct gui_panel_layout *layout, struct gui_graph*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function pops the graph from being used
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_int gui_panel_graph(struct gui_panel_layout*, enum gui_graph_type,
|
2015-06-05 16:01:15 +03:00
|
|
|
const gui_float *values, gui_size count, gui_size offset);
|
|
|
|
/* this function create a graph with given type from an array of value
|
|
|
|
Input:
|
|
|
|
- type of the graph with either line or bar graph
|
|
|
|
- graph values in continues array form
|
|
|
|
- number of graph values
|
|
|
|
- offset into the value array from which to begin drawing
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_int gui_panel_graph_ex(struct gui_panel_layout*, enum gui_graph_type,
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_size count, gui_float(*get_value)(void*, gui_size),
|
|
|
|
void *userdata);
|
|
|
|
/* this function create a graph with given type from callback providing the
|
|
|
|
graph with values
|
|
|
|
Input:
|
|
|
|
- type of the graph with either line or bar graph
|
|
|
|
- number of values inside the graph
|
|
|
|
- callback to access the values inside your datastrucutre
|
|
|
|
- userdata to pull the graph values from
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_table_begin(struct gui_panel_layout*, gui_flags flags,
|
2015-06-05 16:01:15 +03:00
|
|
|
gui_size row_height, gui_size cols);
|
|
|
|
/* this function set the panel to a table state which enable you to create a
|
|
|
|
table with the standart panel row layout
|
|
|
|
Input:
|
|
|
|
- table row and column line seperator flags
|
|
|
|
- height of each table row
|
|
|
|
- number of columns inside the table
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_table_row(struct gui_panel_layout*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function add a row with line seperator into asa table marked table
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_table_end(struct gui_panel_layout*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function finished the table build up process and reverts the panel back
|
|
|
|
to its normal state.
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_bool gui_panel_tab_begin(struct gui_panel_layout*, struct gui_panel_layout *tab,
|
2015-06-05 16:01:15 +03:00
|
|
|
const char*, gui_bool);
|
|
|
|
/* this function adds a tab subpanel into the parent panel
|
|
|
|
Input:
|
|
|
|
- tab title to write into the header
|
|
|
|
- state of the tab with either collapsed(GUI_MINIMIZED) or open state
|
|
|
|
Output:
|
|
|
|
- tab layout to fill with widgets
|
|
|
|
- wether the tab is currently collapsed(gui_true) or open(gui_false)
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_tab_end(struct gui_panel_layout*, struct gui_panel_layout *tab);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function finishes the previously started tab and allocated the needed
|
|
|
|
tab space in the parent panel
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_group_begin(struct gui_panel_layout*, struct gui_panel_layout *tab,
|
2015-06-05 16:01:15 +03:00
|
|
|
const char*, gui_float offset);
|
|
|
|
/* this function adds a grouped subpanel into the parent panel
|
|
|
|
IMPORTANT: You need to set the height of the group with panel_row_layout
|
|
|
|
Input:
|
|
|
|
- group title to write into the header
|
|
|
|
- group scrollbar offset
|
|
|
|
Output:
|
|
|
|
- group layout to fill with widgets
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_float gui_panel_group_end(struct gui_panel_layout*, struct gui_panel_layout* tab);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function finishes the previously started group layout
|
|
|
|
Output:
|
|
|
|
- The from user input updated group scrollbar pixel offset
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_size gui_panel_shelf_begin(struct gui_panel_layout*, struct gui_panel_layout*,
|
2015-06-05 16:01:15 +03:00
|
|
|
const char *tabs[], gui_size size,
|
|
|
|
gui_size active, gui_float offset);
|
|
|
|
/* this function adds a shelf subpanel into the parent panel
|
|
|
|
IMPORTANT: You need to set the height of the shelf with panel_row_layout
|
|
|
|
Input:
|
|
|
|
- all possible selectible tabs of the shelf with names as a string array
|
|
|
|
- number of seletectible tabs
|
|
|
|
- current active tab array index
|
|
|
|
- scrollbar pixel offset for the shelf
|
|
|
|
Output:
|
|
|
|
- group layout to fill with widgets
|
|
|
|
- the from user input updated current shelf tab index
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_float gui_panel_shelf_end(struct gui_panel_layout*, struct gui_panel_layout*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function finishes the previously started shelf layout
|
|
|
|
Input:
|
|
|
|
- previously started group layout
|
|
|
|
Output:
|
|
|
|
- The from user input updated shelf scrollbar pixel offset
|
|
|
|
*/
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_panel_end(struct gui_panel_layout*, struct gui_panel*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function ends the panel layout build up process and updates the panel
|
|
|
|
*/
|
2015-05-29 15:18:23 +03:00
|
|
|
/*
|
|
|
|
* ==============================================================
|
|
|
|
*
|
|
|
|
* Stack
|
|
|
|
*
|
|
|
|
* ===============================================================
|
|
|
|
*/
|
|
|
|
struct gui_stack {
|
|
|
|
gui_size count;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* number of panels inside the stack */
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_panel *begin;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* first panel inside the panel which will be drawn first */
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_panel *end;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* currently active panel which will be drawn last */
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
|
|
|
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_stack_clear(struct gui_stack*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function clears and reset the stack back to an empty state */
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_stack_push(struct gui_stack*, struct gui_panel*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function add a panel into the stack if the panel is not already inside
|
|
|
|
* the stack */
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_stack_pop(struct gui_stack*, struct gui_panel*);
|
2015-06-05 16:01:15 +03:00
|
|
|
/* this function removes a panel from the stack */
|
2015-07-05 00:36:01 +03:00
|
|
|
#define gui_foreach_panel(i, s) for (i = (s)->begin; i != 0; i = (i)->next)
|
2015-06-05 16:01:15 +03:00
|
|
|
/* iterates over each panel inside the stack */
|
2015-05-29 15:18:23 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ==============================================================
|
|
|
|
*
|
2015-05-30 22:20:04 +03:00
|
|
|
* Layout
|
2015-05-29 15:18:23 +03:00
|
|
|
*
|
|
|
|
* ===============================================================
|
|
|
|
*/
|
2015-06-05 16:01:15 +03:00
|
|
|
/*
|
|
|
|
-----------------------------
|
|
|
|
| Top |
|
|
|
|
-----------------------------
|
|
|
|
| | | |
|
2015-06-23 15:23:33 +03:00
|
|
|
| Left | Center | Right |
|
2015-06-05 16:01:15 +03:00
|
|
|
| | | |
|
|
|
|
-----------------------------
|
|
|
|
| Bottom |
|
|
|
|
-----------------------------
|
|
|
|
*/
|
2015-05-29 15:18:23 +03:00
|
|
|
enum gui_layout_slot_index {
|
|
|
|
GUI_SLOT_TOP,
|
|
|
|
GUI_SLOT_BOTTOM,
|
|
|
|
GUI_SLOT_LEFT,
|
|
|
|
GUI_SLOT_CENTER,
|
|
|
|
GUI_SLOT_RIGHT,
|
|
|
|
GUI_SLOT_MAX
|
|
|
|
};
|
|
|
|
|
|
|
|
enum gui_layout_format {
|
|
|
|
GUI_LAYOUT_HORIZONTAL,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* panels in slots are added left to right */
|
2015-05-29 15:18:23 +03:00
|
|
|
GUI_LAYOUT_VERTICAL
|
2015-06-05 16:01:15 +03:00
|
|
|
/* panels in slots are added top to bottom */
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
2015-05-10 23:17:30 +03:00
|
|
|
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_layout_slot {
|
|
|
|
gui_size capacity;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* number of panels inside the slot */
|
2015-06-23 15:23:33 +03:00
|
|
|
gui_float value;
|
|
|
|
/* temporary storage for the layout build up process */
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_vec2 ratio;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* horizontal and vertical window ratio */
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_vec2 offset;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* position of the slot in the window */
|
2015-05-29 15:18:23 +03:00
|
|
|
enum gui_layout_format format;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* panel filling layout */
|
|
|
|
};
|
|
|
|
|
2015-06-23 17:43:16 +03:00
|
|
|
enum gui_layout_state {
|
|
|
|
GUI_LAYOUT_DEACTIVATE,
|
|
|
|
GUI_LAYOUT_ACTIVATE
|
|
|
|
};
|
|
|
|
|
2015-06-22 14:14:34 +03:00
|
|
|
enum gui_layout_flags {
|
|
|
|
GUI_LAYOUT_INACTIVE = 0x01,
|
2015-06-05 16:01:15 +03:00
|
|
|
/* tiled layout is inactive and cannot be updated by the user */
|
2015-06-22 14:14:34 +03:00
|
|
|
GUI_LAYOUT_SCALEABLE = 0x02
|
|
|
|
/* tiled layout ratio can be changed by the user */
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
2015-05-16 13:26:39 +03:00
|
|
|
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_layout {
|
2015-06-23 17:33:49 +03:00
|
|
|
gui_float scaler_width;
|
|
|
|
/* width of the scaling line between slots */
|
2015-05-29 15:18:23 +03:00
|
|
|
gui_size width, height;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* size of the layout inside the window */
|
2015-06-22 14:14:34 +03:00
|
|
|
gui_flags flags;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* flag indicating if the layout is from the user modifyable */
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_stack stack;
|
2015-06-05 16:01:15 +03:00
|
|
|
/* panel stack of all panels inside the layout */
|
2015-05-29 15:18:23 +03:00
|
|
|
struct gui_layout_slot slots[GUI_SLOT_MAX];
|
2015-06-05 16:01:15 +03:00
|
|
|
/* each slot inside the panel layout */
|
2015-05-29 15:18:23 +03:00
|
|
|
};
|
2015-05-22 16:14:26 +03:00
|
|
|
|
2015-06-23 15:23:33 +03:00
|
|
|
void gui_layout_begin(struct gui_layout*, gui_size width, gui_size height, gui_flags);
|
2015-06-22 14:14:34 +03:00
|
|
|
void gui_layout_slot(struct gui_layout*, enum gui_layout_slot_index,
|
2015-06-23 15:23:33 +03:00
|
|
|
gui_float ratio, enum gui_layout_format, gui_size panel_count);
|
|
|
|
void gui_layout_end(struct gui_layout*);
|
2015-06-23 17:43:16 +03:00
|
|
|
void gui_layout_update_size(struct gui_layout*, gui_size width, gui_size height);
|
|
|
|
void gui_layout_update_state(struct gui_layout*, gui_uint state);
|
2015-06-04 23:17:54 +03:00
|
|
|
|
2015-06-18 13:12:57 +03:00
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif /* GUI_H_ */
|