2 |
15 |
16 |
--------------------------------------------------------------------------------
/screenshot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/milgra/sov/19809ae535f8417098020f86ceefa25dbd3c5a90/screenshot.png
--------------------------------------------------------------------------------
/src/kinetic_ui/egl/ku_gl_atlas.c:
--------------------------------------------------------------------------------
1 | #ifndef _ku_gl_atlas_h
2 | #define _ku_gl_atlas_h
3 |
4 | #include "mt_map.c"
5 | #include "mt_matrix_4d.c"
6 | #include "mt_vector_4d.c"
7 |
8 | typedef struct _ku_gl_atlas_coords_t ku_gl_atlas_coords_t;
9 | struct _ku_gl_atlas_coords_t
10 | {
11 | float ltx;
12 | float lty;
13 | float rbx;
14 | float rby;
15 | int x;
16 | int y;
17 | int w;
18 | int h;
19 | };
20 |
21 | typedef struct _ku_gl_atlas_t ku_gl_atlas_t;
22 | struct _ku_gl_atlas_t
23 | {
24 | mt_map_t* coords;
25 | char* blocks;
26 | char is_full;
27 | int width;
28 | int height;
29 | int cols;
30 | int rows;
31 | };
32 |
33 | ku_gl_atlas_t* ku_gl_atlas_new(int w, int h);
34 | void ku_gl_atlas_del(void* p);
35 | char ku_gl_atlas_has(ku_gl_atlas_t* tm, char* id);
36 | ku_gl_atlas_coords_t ku_gl_atlas_get(ku_gl_atlas_t* tm, char* id);
37 | int ku_gl_atlas_put(ku_gl_atlas_t* tm, char* id, int w, int h);
38 |
39 | #endif
40 |
41 | #if __INCLUDE_LEVEL__ == 0
42 |
43 | #include "mt_memory.c"
44 | #include
45 |
46 | void ku_gl_atlas_desc(void* p, int level)
47 | {
48 | ku_gl_atlas_t* tm = p;
49 | printf("tm w %i h %i", tm->width, tm->height);
50 | }
51 |
52 | void ku_gl_atlas_desc_blocks(void* p, int level)
53 | {
54 | printf("tm blocks\n");
55 | }
56 |
57 | ku_gl_atlas_t* ku_gl_atlas_new(int w, int h)
58 | {
59 | int cols = w / 32;
60 | int rows = h / 32;
61 |
62 | ku_gl_atlas_t* tm = CAL(sizeof(ku_gl_atlas_t), ku_gl_atlas_del, ku_gl_atlas_desc);
63 | tm->coords = mt_map_new();
64 | tm->blocks = CAL(sizeof(char) * cols * rows, NULL, ku_gl_atlas_desc_blocks);
65 | tm->width = w;
66 | tm->height = h;
67 | tm->cols = cols;
68 | tm->rows = rows;
69 |
70 | return tm;
71 | }
72 |
73 | void ku_gl_atlas_del(void* p)
74 | {
75 | ku_gl_atlas_t* tm = (ku_gl_atlas_t*) p;
76 | REL(tm->coords);
77 | REL(tm->blocks);
78 | }
79 |
80 | char ku_gl_atlas_has(ku_gl_atlas_t* tm, char* id)
81 | {
82 | v4_t* coords = mt_map_get(tm->coords, id);
83 | if (coords) return 1;
84 | return 0;
85 | }
86 |
87 | ku_gl_atlas_coords_t ku_gl_atlas_get(ku_gl_atlas_t* tm, char* id)
88 | {
89 | ku_gl_atlas_coords_t* coords = mt_map_get(tm->coords, id);
90 | if (coords) return *coords;
91 | return (ku_gl_atlas_coords_t){0};
92 | }
93 |
94 | int ku_gl_atlas_put(ku_gl_atlas_t* tm, char* id, int w, int h)
95 | {
96 | if (w > tm->width || h > tm->height) return -1; // too big bitmap
97 |
98 | // get size of incoming rect
99 | int sx = ceil((float) w / 32.0);
100 | int sy = ceil((float) h / 32.0);
101 |
102 | int r = 0; // row
103 | int c = 0; // col
104 | int s = 0; // success
105 |
106 | for (r = 0; r < tm->rows; r++)
107 | {
108 | for (c = 0; c < tm->cols; c++)
109 | {
110 | int i = r * tm->cols + c;
111 |
112 | // if block is free, check if width and height of new rect fits
113 |
114 | if (tm->blocks[i] == 0)
115 | {
116 | s = 1; // assume success
117 | if (c + sx < tm->cols)
118 | {
119 | for (int tc = c; tc < c + sx; tc++)
120 | {
121 | int ti = r * tm->cols + tc; // test index
122 | if (tm->blocks[ti] == 1)
123 | {
124 | s = 0; // if block is occupied test is failed
125 | break;
126 | }
127 | }
128 | }
129 | else
130 | s = 0; // doesn't fit
131 |
132 | if (r + sy < tm->rows && s == 1)
133 | {
134 | for (int tr = r; tr < r + sy; tr++)
135 | {
136 | int ti = tr * tm->cols + c; // test index
137 | if (tm->blocks[ti] == 1)
138 | {
139 | s = 0; // if block is occupied test is failed
140 | break;
141 | }
142 | }
143 | }
144 | else
145 | s = 0; // doesn't fit
146 | }
147 | if (s == 1) break;
148 | }
149 | if (s == 1) break;
150 | }
151 |
152 | if (s == 1)
153 | {
154 | // flip blocks to occupied
155 | for (int nr = r; nr < r + sy; nr++)
156 | {
157 | for (int nc = c; nc < c + sx; nc++)
158 | {
159 | int ni = nr * tm->cols + nc;
160 | tm->blocks[ni] = 1;
161 | }
162 | }
163 |
164 | int ncx = c * 32;
165 | int ncy = r * 32;
166 | int rbx = ncx + w;
167 | int rby = ncy + h;
168 |
169 | ku_gl_atlas_coords_t* coords = HEAP(
170 | ((ku_gl_atlas_coords_t){
171 | .ltx = (float) ncx / (float) tm->width,
172 | .lty = (float) ncy / (float) tm->height,
173 | .rbx = (float) rbx / (float) tm->width,
174 | .rby = (float) rby / (float) tm->height,
175 | .x = ncx,
176 | .y = ncy,
177 | .w = w,
178 | .h = h}));
179 |
180 | MPUTR(tm->coords, id, coords);
181 | }
182 | else
183 | return -2; // texmap is full
184 |
185 | return 0; // success
186 | }
187 |
188 | #endif
189 |
--------------------------------------------------------------------------------
/src/kinetic_ui/egl/ku_gl_floatbuffer.c:
--------------------------------------------------------------------------------
1 | #ifndef ku_floatbuffer_h
2 | #define ku_floatbuffer_h
3 |
4 | #include "mt_memory.c"
5 | #include
6 | #include
7 |
8 | typedef struct ku_floatbuffer_t ku_floatbuffer_t;
9 | struct ku_floatbuffer_t
10 | {
11 | GLfloat* data;
12 | size_t pos;
13 | size_t cap;
14 | char changed;
15 | };
16 |
17 | ku_floatbuffer_t* ku_floatbuffer_new(void);
18 | void ku_floatbuffer_del(void* fb);
19 | void ku_floatbuffer_reset(ku_floatbuffer_t* fb);
20 | void ku_floatbuffer_add(ku_floatbuffer_t* fb, GLfloat* data, size_t count);
21 |
22 | #endif
23 |
24 | #if __INCLUDE_LEVEL__ == 0
25 |
26 | void ku_floatbuffer_desc(void* p, int level)
27 | {
28 | printf("fb");
29 | }
30 |
31 | void ku_floatbuffer_desc_data(void* p, int level)
32 | {
33 | printf("fb data");
34 | }
35 |
36 | ku_floatbuffer_t* ku_floatbuffer_new()
37 | {
38 | ku_floatbuffer_t* fb = CAL(sizeof(ku_floatbuffer_t), ku_floatbuffer_del, ku_floatbuffer_desc);
39 | fb->data = CAL(sizeof(GLfloat) * 10, NULL, ku_floatbuffer_desc_data);
40 | fb->pos = 0;
41 | fb->cap = 10;
42 |
43 | return fb;
44 | }
45 |
46 | void ku_floatbuffer_del(void* pointer)
47 | {
48 | ku_floatbuffer_t* fb = pointer;
49 | REL(fb->data);
50 | }
51 |
52 | void ku_floatbuffer_reset(ku_floatbuffer_t* fb)
53 | {
54 | fb->pos = 0;
55 | }
56 |
57 | void ku_floatbuffer_expand(ku_floatbuffer_t* fb)
58 | {
59 | assert(fb->cap < SIZE_MAX / 2);
60 | fb->cap *= 2;
61 | fb->data = mt_memory_realloc(fb->data, sizeof(void*) * fb->cap);
62 | }
63 |
64 | void ku_floatbuffer_add(ku_floatbuffer_t* fb, GLfloat* data, size_t count)
65 | {
66 | while (fb->pos + count >= fb->cap) ku_floatbuffer_expand(fb);
67 | memcpy(fb->data + fb->pos, data, sizeof(GLfloat) * count);
68 | fb->pos += count;
69 | fb->changed = 1;
70 | }
71 |
72 | #endif
73 |
--------------------------------------------------------------------------------
/src/kinetic_ui/egl/ku_gl_shader.c:
--------------------------------------------------------------------------------
1 | #ifndef ku_gl_shader_h
2 | #define ku_gl_shader_h
3 |
4 | #include
5 |
6 | typedef struct _glsha_t
7 | {
8 | GLuint name;
9 | GLint uni_loc[13];
10 | } glsha_t;
11 |
12 | glsha_t ku_gl_shader_create(
13 | const char* vertex_source,
14 | const char* fragment_source,
15 | int attribute_locations_length,
16 | const char** attribute_structure,
17 | int uniform_locations_length,
18 | const char** uniform_structure);
19 |
20 | #endif
21 |
22 | #if __INCLUDE_LEVEL__ == 0
23 |
24 | #include
25 |
26 | GLuint ku_gl_shader_compile(GLenum type, const GLchar* source)
27 | {
28 | GLint status, logLength, realLength;
29 | GLuint shader = 0;
30 |
31 | status = 0;
32 | shader = glCreateShader(type);
33 |
34 | if (shader > 0)
35 | {
36 | glShaderSource(shader, 1, &source, NULL);
37 | glCompileShader(shader);
38 | glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);
39 |
40 | if (logLength > 0)
41 | {
42 | GLchar log[logLength];
43 |
44 | glGetShaderInfoLog(shader, logLength, &realLength, log);
45 |
46 | printf("Shader compile log: %s\n", log);
47 | }
48 |
49 | glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
50 |
51 | if (status != GL_TRUE)
52 | return 0;
53 | }
54 | else
55 | printf("Cannot create shader\n");
56 |
57 | return shader;
58 | }
59 |
60 | int ku_gl_shader_link(GLuint program)
61 | {
62 | GLint status, logLength, realLength;
63 |
64 | glLinkProgram(program);
65 | glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
66 |
67 | if (logLength > 0)
68 | {
69 | GLchar log[logLength];
70 | glGetProgramInfoLog(program, logLength, &realLength, log);
71 | printf("Program link log : %i %s\n", realLength, log);
72 | }
73 |
74 | glGetProgramiv(program, GL_LINK_STATUS, &status);
75 | if (status == GL_TRUE)
76 | return 1;
77 | return 0;
78 | }
79 |
80 | glsha_t ku_gl_shader_create(
81 | const char* vertex_source,
82 | const char* fragment_source,
83 | int attribute_locations_length,
84 | const char** attribute_structure,
85 | int uniform_locations_length,
86 | const char** uniform_structure)
87 | {
88 | glsha_t sh = {0};
89 |
90 | sh.name = glCreateProgram();
91 |
92 | GLuint vertex_shader = ku_gl_shader_compile(GL_VERTEX_SHADER, vertex_source);
93 | if (vertex_shader == 0) printf("Failed to compile vertex shader : %s\n", vertex_source);
94 |
95 | GLuint fragment_shader = ku_gl_shader_compile(GL_FRAGMENT_SHADER, fragment_source);
96 | if (fragment_shader == 0) printf("Failed to compile fragment shader : %s\n", fragment_source);
97 |
98 | glAttachShader(sh.name, vertex_shader);
99 | glAttachShader(sh.name, fragment_shader);
100 |
101 | for (int index = 0; index < attribute_locations_length; index++)
102 | {
103 | const GLchar* name = attribute_structure[index];
104 | glBindAttribLocation(sh.name, index, name);
105 | }
106 |
107 | int success = ku_gl_shader_link(sh.name);
108 |
109 | if (success == 1)
110 | {
111 | for (int index = 0; index < uniform_locations_length; index++)
112 | {
113 | const GLchar* name = uniform_structure[index];
114 | GLint location = glGetUniformLocation(sh.name, name);
115 | sh.uni_loc[index] = location;
116 | }
117 | }
118 | else
119 | printf("Failed to link shader program\n");
120 |
121 | if (vertex_shader > 0)
122 | {
123 | glDetachShader(sh.name, vertex_shader);
124 | glDeleteShader(vertex_shader);
125 | }
126 |
127 | if (fragment_shader > 0)
128 | {
129 | glDetachShader(sh.name, fragment_shader);
130 | glDeleteShader(fragment_shader);
131 | }
132 |
133 | return sh;
134 | }
135 |
136 | #endif
137 |
--------------------------------------------------------------------------------
/src/kinetic_ui/handler/vh_button.c:
--------------------------------------------------------------------------------
1 | #ifndef vh_button_h
2 | #define vh_button_h
3 |
4 | #include "ku_view.c"
5 |
6 | typedef enum _vh_button_type_t
7 | {
8 | VH_BUTTON_NORMAL,
9 | VH_BUTTON_TOGGLE
10 | } vh_button_type_t;
11 |
12 | typedef enum _vh_button_state_t
13 | {
14 | VH_BUTTON_UP,
15 | VH_BUTTON_DOWN
16 | } vh_button_state_t;
17 |
18 | typedef struct _vh_button_t vh_button_t;
19 |
20 | enum vh_button_event_id
21 | {
22 | VH_BUTTON_EVENT
23 | };
24 |
25 | typedef struct _vh_button_event_t
26 | {
27 | enum vh_button_event_id id;
28 | vh_button_t* vh;
29 | ku_view_t* view;
30 | ku_event_t ev;
31 | } vh_button_event_t;
32 |
33 | struct _vh_button_t
34 | {
35 | void (*on_event)(vh_button_event_t);
36 | vh_button_type_t type;
37 | vh_button_state_t state;
38 |
39 | ku_view_t* offview;
40 | ku_view_t* onview;
41 | char enabled;
42 | };
43 |
44 | void vh_button_add(ku_view_t* view, vh_button_type_t type, void (*on_event)(vh_button_event_t));
45 | void vh_button_set_state(ku_view_t* view, vh_button_state_t state);
46 | void vh_button_set_enabled(ku_view_t* view, int flag);
47 |
48 | #endif
49 |
50 | #if __INCLUDE_LEVEL__ == 0
51 |
52 | #include "vh_anim.c"
53 |
54 | void vh_button_on_anim(vh_anim_event_t event)
55 | {
56 | ku_view_t* btnview = (ku_view_t*) event.userdata;
57 | vh_button_t* vh = btnview->evt_han_data;
58 |
59 | // if offview alpha is 0 and state is released
60 |
61 | if (vh->type == VH_BUTTON_NORMAL)
62 | {
63 | if (vh->offview->texture.alpha < 0.0001 && event.view == vh->offview)
64 | {
65 | vh_anim_alpha(vh->offview, 0.0, 1.0, 10, AT_LINEAR);
66 | }
67 | }
68 | }
69 |
70 | int vh_button_evt(ku_view_t* view, ku_event_t ev)
71 | {
72 | vh_button_t* vh = view->evt_han_data;
73 |
74 | if (vh->enabled)
75 | {
76 | if (ev.type == KU_EVENT_MOUSE_DOWN)
77 | {
78 | if (vh->type == VH_BUTTON_NORMAL)
79 | {
80 | vh->state = VH_BUTTON_DOWN;
81 |
82 | if (vh->offview)
83 | vh_anim_alpha(vh->offview, 1.0, 0.0, 10, AT_LINEAR);
84 | if (vh->onview)
85 | vh_anim_alpha(vh->onview, 0.0, 1.0, 10, AT_LINEAR);
86 | }
87 | }
88 | else if (ev.type == KU_EVENT_MOUSE_UP)
89 | {
90 | if (vh->type == VH_BUTTON_TOGGLE)
91 | {
92 | if (vh->state == VH_BUTTON_UP)
93 | {
94 | vh->state = VH_BUTTON_DOWN;
95 | if (vh->offview)
96 | vh_anim_alpha(vh->offview, 1.0, 0.0, 10, AT_LINEAR);
97 | if (vh->onview)
98 | vh_anim_alpha(vh->onview, 0.0, 1.0, 10, AT_LINEAR);
99 | }
100 | else
101 | {
102 | vh->state = VH_BUTTON_UP;
103 | if (vh->offview)
104 | vh_anim_alpha(vh->offview, 0.0, 1.0, 10, AT_LINEAR);
105 | if (vh->onview)
106 | vh_anim_alpha(vh->onview, 1.0, 0.0, 10, AT_LINEAR);
107 | }
108 |
109 | vh_button_event_t event = {.id = VH_BUTTON_EVENT, .view = view, .vh = vh, .ev = ev};
110 | if (vh->on_event)
111 | (*vh->on_event)(event);
112 | }
113 | else
114 | {
115 | vh->state = VH_BUTTON_UP;
116 |
117 | vh_button_event_t event = {.id = VH_BUTTON_EVENT, .view = view, .vh = vh, .ev = ev};
118 | if (vh->on_event)
119 | (*vh->on_event)(event);
120 |
121 | /* if (vh->offview) vh_anim_alpha(vh->offview, 1.0, 0.0, 10, AT_LINEAR); */
122 | /* if (vh->onview) vh_anim_alpha(vh->onview, 0.0, 1.0, 10, AT_LINEAR); */
123 | }
124 | }
125 | }
126 |
127 | return 0;
128 | }
129 |
130 | void vh_button_set_state(ku_view_t* view, vh_button_state_t state)
131 | {
132 | vh_button_t* vh = view->evt_han_data;
133 |
134 | if (vh->enabled)
135 | {
136 | vh->state = state;
137 |
138 | if (state)
139 | {
140 | if (vh->offview)
141 | vh_anim_alpha(vh->offview, 1.0, 0.0, 10, AT_LINEAR);
142 | if (vh->onview)
143 | vh_anim_alpha(vh->onview, 0.0, 1.0, 10, AT_LINEAR);
144 | }
145 | else
146 | {
147 | if (vh->offview)
148 | vh_anim_alpha(vh->offview, 0.0, 1.0, 10, AT_LINEAR);
149 | if (vh->onview)
150 | vh_anim_alpha(vh->onview, 1.0, 0.0, 10, AT_LINEAR);
151 | }
152 | }
153 | }
154 |
155 | void vh_button_del(void* p)
156 | {
157 | /* vh_button_t* vh = p; */
158 | }
159 |
160 | void vh_button_desc(void* p, int level)
161 | {
162 | printf("vh_button");
163 | }
164 |
165 | void vh_button_add(ku_view_t* view, vh_button_type_t type, void (*on_event)(vh_button_event_t))
166 | {
167 | assert(view->evt_han == NULL && view->evt_han_data == NULL);
168 |
169 | vh_button_t* vh = CAL(sizeof(vh_button_t), vh_button_del, vh_button_desc);
170 | vh->on_event = on_event;
171 | vh->type = type;
172 | vh->state = VH_BUTTON_UP;
173 | vh->enabled = 1;
174 |
175 | if (view->views->length > 0)
176 | {
177 | vh->offview = view->views->data[0];
178 | vh_anim_add(vh->offview, vh_button_on_anim, view);
179 | }
180 | if (view->views->length > 1)
181 | {
182 | vh->type = VH_BUTTON_TOGGLE;
183 | vh->onview = view->views->data[1];
184 | vh_anim_add(vh->onview, vh_button_on_anim, view);
185 | }
186 |
187 | if (vh->offview)
188 | ku_view_set_texture_alpha(vh->offview, 1.0, 0);
189 | if (vh->onview)
190 | ku_view_set_texture_alpha(vh->onview, 0.0, 0);
191 |
192 | view->evt_han = vh_button_evt;
193 | view->evt_han_data = vh;
194 | }
195 |
196 | void vh_button_set_enabled(ku_view_t* view, int flag)
197 | {
198 | vh_button_t* vh = view->evt_han_data;
199 |
200 | if (flag)
201 | {
202 | if (vh->enabled == 0 && vh->offview)
203 | vh_anim_alpha(vh->offview, 0.3, 1.0, 10, AT_LINEAR);
204 | }
205 | else
206 | {
207 | if (vh->enabled == 1 && vh->offview)
208 | vh_anim_alpha(vh->offview, 1.0, 0.3, 10, AT_LINEAR);
209 | }
210 |
211 | vh->enabled = flag;
212 | }
213 |
214 | #endif
215 |
--------------------------------------------------------------------------------
/src/kinetic_ui/handler/vh_cv_body.c:
--------------------------------------------------------------------------------
1 | /* content view body */
2 |
3 | #ifndef vh_cv_body_h
4 | #define vh_cv_body_h
5 |
6 | #include "ku_view.c"
7 |
8 | typedef struct _vh_cv_body_t
9 | {
10 | void* userdata;
11 |
12 | ku_view_t* content;
13 | float cw; // content width
14 | float ch; // content height
15 | float px;
16 | float py;
17 | float zoom;
18 | } vh_cv_body_t;
19 |
20 | void vh_cv_body_attach(
21 | ku_view_t* view,
22 | void* userdata);
23 |
24 | void vh_cv_body_set_content_size(
25 | ku_view_t* view,
26 | int cw,
27 | int ch);
28 |
29 | void vh_cv_body_move(
30 | ku_view_t* view,
31 | float dx,
32 | float dy);
33 |
34 | void vh_cv_body_zoom(
35 | ku_view_t* view,
36 | float s,
37 | int x,
38 | int y);
39 |
40 | void vh_cv_body_reset(
41 | ku_view_t* view);
42 |
43 | void vh_cv_body_hjump(
44 | ku_view_t* view,
45 | float dx);
46 |
47 | void vh_cv_body_vjump(
48 | ku_view_t* view,
49 | int topindex);
50 |
51 | #endif
52 |
53 | #if __INCLUDE_LEVEL__ == 0
54 |
55 | #include "tg_scaledimg.c"
56 |
57 | void vh_cv_body_del(void* p)
58 | {
59 | }
60 |
61 | void vh_cv_body_desc(void* p, int level)
62 | {
63 | printf("vh_cv_body");
64 | }
65 |
66 | void vh_cv_body_attach(
67 | ku_view_t* view,
68 | void* userdata)
69 | {
70 | assert(view->evt_han == NULL && view->evt_han_data == NULL);
71 |
72 | vh_cv_body_t* vh = CAL(sizeof(vh_cv_body_t), vh_cv_body_del, vh_cv_body_desc);
73 | vh->userdata = userdata;
74 | vh->content = view->views->data[0];
75 | vh->zoom = 1.0;
76 |
77 | vh->cw = 1;
78 | vh->ch = 1;
79 |
80 | view->evt_han_data = vh;
81 | }
82 |
83 | void vh_cv_body_set_content_size(
84 | ku_view_t* view,
85 | int cw,
86 | int ch)
87 | {
88 | vh_cv_body_t* vh = view->evt_han_data;
89 |
90 | vh->cw = cw;
91 | vh->ch = ch;
92 |
93 | ku_rect_t lf = view->frame.local; // local frame
94 |
95 | float cr = (float) ch / (float) cw; // content aspect ratio
96 |
97 | /* fit width first */
98 |
99 | float nw = lf.w;
100 | float nh = nw * cr;
101 |
102 | vh->zoom = (float) nw / cw;
103 |
104 | if (nh > lf.h)
105 | {
106 | cr = lf.h / nh;
107 |
108 | nh = lf.h;
109 | nw *= cr;
110 | vh->zoom = (float) nh / ch;
111 | }
112 |
113 | ku_rect_t frame = vh->content->frame.local;
114 | frame.x = (lf.w - nw) / 2.0;
115 | frame.y = (lf.h - nh) / 2.0;
116 | frame.w = nw;
117 | frame.h = nh;
118 |
119 | ku_view_set_frame(vh->content, frame);
120 |
121 | tg_scaledimg_set_content_size(vh->content, cw, ch);
122 | tg_scaledimg_gen(vh->content);
123 | }
124 |
125 | void vh_cv_body_move(
126 | ku_view_t* view,
127 | float dx,
128 | float dy)
129 | {
130 | vh_cv_body_t* vh = view->evt_han_data;
131 |
132 | ku_rect_t frame = vh->content->frame.local;
133 | frame.x += dx;
134 | frame.y += dy;
135 | ku_view_set_frame(vh->content, frame);
136 | }
137 |
138 | void vh_cv_body_zoom(
139 | ku_view_t* view,
140 | float z,
141 | int x,
142 | int y)
143 | {
144 | vh_cv_body_t* vh = view->evt_han_data;
145 |
146 | ku_rect_t gf = vh->content->frame.global;
147 | ku_rect_t lf = vh->content->frame.local;
148 |
149 | /* partial width and height from mouse position */
150 |
151 | float pw = (float) x - gf.x;
152 | float ph = (float) y - gf.y;
153 |
154 | /* ratios */
155 |
156 | float rw = pw / gf.w;
157 | float rh = ph / gf.h;
158 |
159 | vh->zoom = z;
160 | if (vh->zoom < 0.001)
161 | vh->zoom = 0.001;
162 |
163 | float nw = vh->cw * vh->zoom;
164 | float nh = vh->ch * vh->zoom;
165 |
166 | lf.x = (float) x - rw * nw - view->frame.global.x;
167 | lf.y = (float) y - rh * nh - view->frame.global.y;
168 | lf.w = nw;
169 | lf.h = nh;
170 |
171 | ku_view_set_frame(vh->content, lf);
172 | tg_scaledimg_gen(vh->content);
173 | }
174 |
175 | void vh_cv_body_reset(
176 | ku_view_t* view)
177 | {
178 | }
179 |
180 | void vh_cv_body_hjump(
181 | ku_view_t* view,
182 | float x)
183 | {
184 | }
185 |
186 | void vh_cv_body_vjump(
187 | ku_view_t* view,
188 | int topindex)
189 | {
190 | }
191 |
192 | #endif
193 |
--------------------------------------------------------------------------------
/src/kinetic_ui/handler/vh_cv_scrl.c:
--------------------------------------------------------------------------------
1 | #ifndef vh_cv_scrl_h
2 | #define vh_cv_scrl_h
3 |
4 | #include "ku_view.c"
5 | #include "vh_cv_body.c"
6 |
7 | typedef struct _vh_cv_scrl_t
8 | {
9 | ku_view_t* tbody_view;
10 | ku_view_t* vert_v;
11 | ku_view_t* hori_v;
12 | int state; // 0 scroll 1 open 2 close
13 | int steps;
14 | size_t item_cnt;
15 | void* userdata;
16 | } vh_cv_scrl_t;
17 |
18 | void vh_cv_scrl_attach(
19 | ku_view_t* view,
20 | ku_view_t* tbody_view,
21 | void* userdata);
22 |
23 | void vh_cv_scrl_update(ku_view_t* view);
24 | void vh_cv_scrl_show(ku_view_t* view);
25 | void vh_cv_scrl_hide(ku_view_t* view);
26 | void vh_cv_scrl_set_item_count(ku_view_t* view, size_t count);
27 | void vh_cv_scrl_scroll_v(ku_view_t* view, int y);
28 | void vh_cv_scrl_scroll_h(ku_view_t* view, int x);
29 |
30 | #endif
31 |
32 | #if __INCLUDE_LEVEL__ == 0
33 |
34 | void vh_cv_scrl_del(void* p)
35 | {
36 | vh_cv_scrl_t* vh = p;
37 | REL(vh->vert_v);
38 | REL(vh->hori_v);
39 | }
40 |
41 | void vh_cv_scrl_desc(void* p, int level)
42 | {
43 | printf("vh_cv_scrl");
44 | }
45 |
46 | void vh_cv_scrl_attach(
47 | ku_view_t* view,
48 | ku_view_t* tbody_view,
49 | void* userdata)
50 | {
51 | vh_cv_scrl_t* vh = CAL(sizeof(vh_cv_scrl_t), vh_cv_scrl_del, vh_cv_scrl_desc);
52 | vh->userdata = userdata;
53 | vh->tbody_view = tbody_view;
54 |
55 | assert(view->views->length > 1);
56 |
57 | vh->vert_v = RET(view->views->data[0]);
58 | vh->hori_v = RET(view->views->data[1]);
59 |
60 | ku_view_set_texture_alpha(vh->hori_v, 0.0, 0);
61 | ku_view_set_texture_alpha(vh->vert_v, 0.0, 0);
62 |
63 | view->evt_han_data = vh;
64 | }
65 |
66 | void vh_cv_scrl_set_item_count(ku_view_t* view, size_t count)
67 | {
68 | vh_cv_scrl_t* vh = view->evt_han_data;
69 |
70 | vh->item_cnt = count;
71 | }
72 |
73 | void vh_cv_scrl_update(ku_view_t* view)
74 | {
75 | vh_cv_scrl_t* vh = view->evt_han_data;
76 | vh_cv_body_t* bvh = vh->tbody_view->evt_han_data;
77 |
78 | ku_rect_t vf = view->frame.local;
79 | ku_rect_t cf = bvh->content->frame.local;
80 |
81 | float pratio = -cf.y / cf.h;
82 | float sratio = cf.h / vf.h;
83 |
84 | if (sratio > 1.0)
85 | {
86 | float hth = (vf.h - vh->hori_v->frame.local.h) * (1 / sratio);
87 | float pos = (vf.h - vh->hori_v->frame.local.h) * pratio;
88 |
89 | if (vh->state == 2)
90 | {
91 | pos += hth / 2.0;
92 | hth = 1.0;
93 | }
94 |
95 | ku_rect_t frame = vh->vert_v->frame.local;
96 | frame.h += (hth - frame.h) / 2.0;
97 | frame.y += (pos - frame.y) / 2.0;
98 |
99 | ku_view_set_frame(vh->vert_v, frame);
100 | }
101 |
102 | pratio = -cf.x / cf.w;
103 | sratio = cf.w / vf.w;
104 |
105 | if (sratio > 1.0)
106 | {
107 | float wth = (vf.w - vh->vert_v->frame.local.w) * (1 / sratio);
108 | float pos = (vf.w - vh->vert_v->frame.local.w) * pratio;
109 |
110 | if (vh->state == 2)
111 | {
112 | pos += wth / 2.0;
113 | wth = 1.0;
114 | }
115 |
116 | ku_rect_t frame = vh->hori_v->frame.local;
117 | frame.w += (wth - frame.w) / 2.0;
118 | frame.x += (pos - frame.x) / 2.0;
119 |
120 | ku_view_set_frame(vh->hori_v, frame);
121 | }
122 |
123 | if (vh->state > 0)
124 | {
125 | vh->steps += 1;
126 | if (vh->steps == 5)
127 | {
128 | if (vh->state == 2)
129 | {
130 | ku_view_set_texture_alpha(vh->hori_v, 0.0, 0);
131 | ku_view_set_texture_alpha(vh->vert_v, 0.0, 0);
132 | }
133 | vh->state = 0;
134 | }
135 | }
136 | }
137 |
138 | void vh_cv_scrl_show(ku_view_t* view)
139 | {
140 | vh_cv_scrl_t* vh = view->evt_han_data;
141 |
142 | vh->state = 1;
143 | vh->steps = 0;
144 | ku_view_set_texture_alpha(vh->hori_v, 1.0, 0);
145 | ku_view_set_texture_alpha(vh->vert_v, 1.0, 0);
146 | }
147 |
148 | void vh_cv_scrl_hide(ku_view_t* view)
149 | {
150 | vh_cv_scrl_t* vh = view->evt_han_data;
151 | vh->state = 2;
152 | vh->steps = 0;
153 | }
154 |
155 | void vh_cv_scrl_scroll_v(ku_view_t* view, int y)
156 | {
157 | /* vh_cv_scrl_t* vh = view->evt_han_data; */
158 | /* vh_cv_body_t* bvh = vh->tbody_view->evt_han_data; */
159 |
160 | /* if (bvh->items->length > 0 && vh->item_cnt > 0) */
161 | /* { */
162 | /* // int vert_pos = bvh->top_index; */
163 | /* int vert_vis = bvh->bot_index - bvh->top_index; */
164 | /* int vert_max = vh->item_cnt; */
165 |
166 | /* if (vert_max > 1) */
167 | /* { */
168 | /* float sratio = (float) vert_vis / (float) vert_max; */
169 | /* float height = (view->frame.local.h - view->frame.local.h * sratio); */
170 | /* float pratio = (float) y / height; */
171 |
172 | /* if (pratio < 0.0) pratio = 0.0; */
173 | /* if (pratio > 1.0) pratio = 1.0; */
174 | /* int topindex = pratio * (vert_max - vert_vis); */
175 |
176 | /* vh_cv_body_vjump(vh->tbody_view, topindex); */
177 |
178 | /* ku_rect_t frame = vh->vert_v->frame.local; */
179 | /* frame.h = view->frame.local.h * sratio; */
180 | /* frame.y = y; */
181 |
182 | /* ku_view_set_frame(vh->vert_v, frame); */
183 | /* } */
184 | /* } */
185 | }
186 |
187 | void vh_cv_scrl_scroll_h(ku_view_t* view, int x)
188 | {
189 | /* vh_cv_scrl_t* vh = view->evt_han_data; */
190 | /* vh_cv_body_t* bvh = vh->tbody_view->evt_han_data; */
191 |
192 | /* if (bvh->items->length > 0 && vh->item_cnt > 0) */
193 | /* { */
194 | /* ku_view_t* head = bvh->items->data[0]; */
195 |
196 | /* // float hori_pos = -head->frame.local.x; */
197 | /* float hori_vis = view->frame.local.w; */
198 | /* float hori_max = head->frame.local.w; */
199 |
200 | /* if (hori_max > 1.0) */
201 | /* { */
202 | /* float sratio = (float) hori_vis / (float) hori_max; */
203 | /* float width = (view->frame.local.w - view->frame.local.w * sratio); */
204 | /* float pratio = (float) x / width; */
205 |
206 | /* if (pratio < 0.0) pratio = 0.0; */
207 | /* if (pratio > 1.0) pratio = 1.0; */
208 | /* float dx = pratio * (hori_max - hori_vis); */
209 |
210 | /* vh_cv_body_hjump(vh->tbody_view, -dx); */
211 | /* vh_cv_head_jump(vh->thead_view, -dx); */
212 |
213 | /* ku_rect_t frame = vh->hori_v->frame.local; */
214 | /* frame.w = view->frame.local.w * sratio; */
215 | /* frame.x = x; */
216 |
217 | /* ku_view_set_frame(vh->hori_v, frame); */
218 | /* } */
219 | /* } */
220 | }
221 |
222 | #endif
223 |
--------------------------------------------------------------------------------
/src/kinetic_ui/handler/vh_drag.c:
--------------------------------------------------------------------------------
1 | #ifndef vh_drag_h
2 | #define vh_drag_h
3 |
4 | #include "ku_event.c"
5 | #include "ku_view.c"
6 |
7 | enum vh_drag_event_id
8 | {
9 | VH_DRAG_MOVE,
10 | VH_DRAG_DROP
11 | };
12 |
13 | typedef struct _vh_drag_t vh_drag_t;
14 |
15 | typedef struct _vh_drag_event_t
16 | {
17 | enum vh_drag_event_id id;
18 | vh_drag_t* vh;
19 | ku_view_t* view;
20 | ku_view_t* dragged_view;
21 | } vh_drag_event_t;
22 |
23 | struct _vh_drag_t
24 | {
25 | void (*on_event)(vh_drag_event_t);
26 | ku_view_t* dragged_view;
27 | };
28 |
29 | void vh_drag_attach(ku_view_t* view, void (*on_event)(vh_drag_event_t));
30 | void vh_drag_drag(ku_view_t* view, ku_view_t* item);
31 |
32 | #endif
33 |
34 | #if __INCLUDE_LEVEL__ == 0
35 |
36 | int vh_drag_evt(ku_view_t* view, ku_event_t ev)
37 | {
38 | if (ev.type == KU_EVENT_MOUSE_MOVE && ev.drag)
39 | {
40 | vh_drag_t* vh = view->evt_han_data;
41 |
42 | if (vh->dragged_view)
43 | {
44 | ku_rect_t frame = vh->dragged_view->frame.local;
45 | frame.x = ev.x - frame.w / 2;
46 | frame.y = ev.y - frame.h / 2;
47 | ku_view_set_frame(vh->dragged_view, frame);
48 |
49 | vh_drag_event_t event = {.id = VH_DRAG_MOVE, .vh = vh, .view = view, .dragged_view = vh->dragged_view};
50 | if (vh->on_event)
51 | (*vh->on_event)(event);
52 | }
53 | }
54 | if (ev.type == KU_EVENT_MOUSE_UP && ev.drag)
55 | {
56 | vh_drag_t* vh = view->evt_han_data;
57 |
58 | if (vh->dragged_view)
59 | {
60 | vh_drag_event_t event = {.id = VH_DRAG_DROP, .vh = vh, .view = view, .dragged_view = vh->dragged_view};
61 | if (vh->on_event)
62 | (*vh->on_event)(event);
63 |
64 | REL(vh->dragged_view);
65 | vh->dragged_view = NULL;
66 | }
67 | }
68 |
69 | return 1;
70 | }
71 |
72 | void vh_drag_del(void* p)
73 | {
74 | vh_drag_t* vh = p;
75 |
76 | if (vh->dragged_view) REL(vh->dragged_view);
77 | }
78 |
79 | void vh_drag_desc(void* p, int level)
80 | {
81 | }
82 |
83 | void vh_drag_attach(ku_view_t* view, void (*on_event)(vh_drag_event_t))
84 | {
85 | assert(view->evt_han == NULL && view->evt_han_data == NULL);
86 |
87 | vh_drag_t* vh = CAL(sizeof(vh_drag_t), vh_drag_del, vh_drag_desc);
88 | vh->on_event = on_event;
89 |
90 | view->evt_han_data = vh;
91 | view->evt_han = vh_drag_evt;
92 | }
93 |
94 | void vh_drag_drag(ku_view_t* view, ku_view_t* item)
95 | {
96 | vh_drag_t* vh = view->evt_han_data;
97 |
98 | if (vh->dragged_view)
99 | {
100 | REL(vh->dragged_view);
101 | vh->dragged_view = NULL;
102 | }
103 | if (item)
104 | {
105 | vh->dragged_view = RET(item);
106 | }
107 | }
108 |
109 | #endif
110 |
--------------------------------------------------------------------------------
/src/kinetic_ui/handler/vh_key.c:
--------------------------------------------------------------------------------
1 | #ifndef vh_key_h
2 | #define vh_key_h
3 |
4 | #include "ku_view.c"
5 |
6 | typedef struct _vh_key_t vh_key_t;
7 |
8 | typedef struct _vh_key_event_t
9 | {
10 | ku_event_t ev;
11 | vh_key_t* vh;
12 | ku_view_t* view;
13 | } vh_key_event_t;
14 |
15 | struct _vh_key_t
16 | {
17 | void (*on_event)(vh_key_event_t event);
18 | };
19 |
20 | void vh_key_add(ku_view_t* view, void (*on_event)(vh_key_event_t));
21 |
22 | #endif
23 |
24 | #if __INCLUDE_LEVEL__ == 0
25 |
26 | int vh_key_evt(ku_view_t* view, ku_event_t ev)
27 | {
28 | if (ev.type == KU_EVENT_KEY_DOWN)
29 | {
30 | vh_key_t* vh = view->evt_han_data;
31 | vh_key_event_t event = {.ev = ev, .vh = vh, .view = view};
32 | if (vh->on_event)
33 | (*vh->on_event)(event);
34 | }
35 |
36 | return 0;
37 | }
38 |
39 | void vh_key_del(void* p)
40 | {
41 | }
42 |
43 | void vh_key_desc(void* p, int level)
44 | {
45 | printf("vh_key");
46 | }
47 |
48 | void vh_key_add(ku_view_t* view, void (*on_event)(vh_key_event_t))
49 | {
50 | assert(view->evt_han == NULL && view->evt_han_data == NULL);
51 |
52 | vh_key_t* vh = CAL(sizeof(vh_key_t), vh_key_del, vh_key_desc);
53 | vh->on_event = on_event;
54 |
55 | view->evt_han_data = vh;
56 | view->evt_han = vh_key_evt;
57 | }
58 |
59 | #endif
60 |
--------------------------------------------------------------------------------
/src/kinetic_ui/handler/vh_knob.c:
--------------------------------------------------------------------------------
1 | #ifndef vh_knob_h
2 | #define vh_knob_h
3 |
4 | #include "ku_view.c"
5 |
6 | void vh_knob_add(ku_view_t* view, void (*ratio_changed)(ku_view_t* view, float ratio));
7 |
8 | #endif
9 |
10 | #if __INCLUDE_LEVEL__ == 0
11 |
12 | #include "ku_draw.c"
13 | #include "tg_knob.c"
14 | #include
15 |
16 | typedef struct _vh_knob_t
17 | {
18 | float angle;
19 | char* id;
20 |
21 | void (*ratio_changed)(ku_view_t* view, float ratio);
22 | } vh_knob_t;
23 |
24 | int vh_knob_evt(ku_view_t* view, ku_event_t ev)
25 | {
26 | if (ev.type == KU_EVENT_MOUSE_DOWN || (ev.type == KU_EVENT_MOUSE_MOVE && ev.drag))
27 | {
28 | vh_knob_t* vh = view->evt_han_data;
29 |
30 | float dx = ev.x - (view->frame.global.x + view->frame.global.w / 2.0);
31 | float dy = ev.y - (view->frame.global.y + view->frame.global.h / 2.0);
32 | float angle = atan2(dy, dx);
33 | float r = sqrt(dx * dx + dy * dy);
34 |
35 | if (angle < 0)
36 | angle += 6.28;
37 |
38 | if (r < view->frame.global.w / 2.0)
39 | {
40 | tg_knob_set_angle(view, angle);
41 | (*vh->ratio_changed)(view, angle);
42 | }
43 | }
44 | else if (ev.type == KU_EVENT_SCROLL)
45 | {
46 | vh_knob_t* vh = view->evt_han_data;
47 | tg_knob_t* tg = view->tex_gen_data;
48 |
49 | float angle = tg->angle - ev.dy / 50.0;
50 |
51 | if (angle < 0)
52 | angle += 6.28;
53 |
54 | if (tg->angle < 3 * 3.14 / 2 && tg->angle > 3.14 && angle > 3 * 3.14 / 2)
55 | angle = tg->angle;
56 | if (tg->angle > 3 * 3.14 / 2 && tg->angle < 2 * 3.14 && angle < 3 * 3.14 / 2)
57 | angle = tg->angle;
58 |
59 | if (angle > 6.28)
60 | angle -= 6.28;
61 | tg_knob_set_angle(view, angle);
62 | (*vh->ratio_changed)(view, angle);
63 | }
64 |
65 | return 1;
66 | }
67 |
68 | void vh_knob_desc(void* p, int level)
69 | {
70 | printf("vh_knob");
71 | }
72 |
73 | void vh_knob_add(ku_view_t* view, void (*ratio_changed)(ku_view_t* view, float ratio))
74 | {
75 | assert(view->evt_han == NULL && view->evt_han_data == NULL);
76 |
77 | vh_knob_t* vh = CAL(sizeof(vh_knob_t), NULL, vh_knob_desc);
78 |
79 | vh->ratio_changed = ratio_changed;
80 |
81 | view->evt_han_data = vh;
82 | view->evt_han = vh_knob_evt;
83 | }
84 |
85 | #endif
86 |
--------------------------------------------------------------------------------
/src/kinetic_ui/handler/vh_roll.c:
--------------------------------------------------------------------------------
1 | #ifndef vh_roll_h
2 | #define vh_roll_h
3 |
4 | #include "ku_event.c"
5 | #include "ku_view.c"
6 |
7 | enum vh_roll_event_id
8 | {
9 | VH_ROLL_IN,
10 | VH_ROLL_OUT
11 | };
12 |
13 | typedef struct _vh_roll_t vh_roll_t;
14 |
15 | typedef struct _vh_roll_event_t
16 | {
17 | enum vh_roll_event_id id;
18 | vh_roll_t* vh;
19 | ku_view_t* view;
20 | } vh_roll_event_t;
21 |
22 | struct _vh_roll_t
23 | {
24 | char active;
25 | void (*on_event)(vh_roll_event_t);
26 | };
27 |
28 | void vh_roll_add(ku_view_t* view, void (*on_event)(vh_roll_event_t));
29 |
30 | #endif
31 |
32 | #if __INCLUDE_LEVEL__ == 0
33 |
34 | int vh_roll_evt(ku_view_t* view, ku_event_t ev)
35 | {
36 | if (ev.type == KU_EVENT_MOUSE_MOVE)
37 | {
38 | vh_roll_t* vh = view->evt_han_data;
39 | ku_rect_t frame = view->frame.global;
40 |
41 | if (!vh->active)
42 | {
43 | if (ev.x >= frame.x &&
44 | ev.x <= frame.x + frame.w &&
45 | ev.y >= frame.y &&
46 | ev.y <= frame.y + frame.h)
47 | {
48 | vh->active = 1;
49 |
50 | vh_roll_event_t event = {.id = VH_ROLL_IN, .view = view, .vh = vh};
51 | if (vh->on_event)
52 | (*vh->on_event)(event);
53 | }
54 | }
55 | }
56 | else if (ev.type == KU_EVENT_MOUSE_MOVE_OUT)
57 | {
58 | vh_roll_t* vh = view->evt_han_data;
59 | ku_rect_t frame = view->frame.global;
60 |
61 | if (vh->active)
62 | {
63 | if (ev.x < frame.x ||
64 | ev.x > frame.x + frame.w ||
65 | ev.y < frame.y ||
66 | ev.y > frame.y + frame.h)
67 | {
68 | vh->active = 0;
69 | vh_roll_event_t event = {.id = VH_ROLL_OUT, .view = view, .vh = vh};
70 | if (vh->on_event)
71 | (*vh->on_event)(event);
72 | }
73 | }
74 | }
75 |
76 | return 1;
77 | }
78 |
79 | void vh_roll_del(void* p)
80 | {
81 | }
82 |
83 | void vh_roll_desc(void* p, int level)
84 | {
85 | printf("vh_roll");
86 | }
87 |
88 | void vh_roll_add(ku_view_t* view, void (*on_event)(vh_roll_event_t))
89 | {
90 | assert(view->evt_han == NULL && view->evt_han_data == NULL);
91 |
92 | vh_roll_t* vh = CAL(sizeof(vh_roll_t), vh_roll_del, vh_roll_desc);
93 | vh->on_event = on_event;
94 |
95 | view->evt_han_data = vh;
96 | view->evt_han = vh_roll_evt;
97 | }
98 |
99 | #endif
100 |
--------------------------------------------------------------------------------
/src/kinetic_ui/handler/vh_slider.c:
--------------------------------------------------------------------------------
1 | #ifndef vh_slider_h
2 | #define vh_slider_h
3 |
4 | #include "ku_view.c"
5 |
6 | typedef struct _vh_slider_t vh_slider_t;
7 |
8 | typedef struct _vh_slider_event_t
9 | {
10 | vh_slider_t* vh;
11 | ku_view_t* view;
12 | float ratio;
13 | } vh_slider_event_t;
14 |
15 | struct _vh_slider_t
16 | {
17 | float ratio;
18 | char enabled;
19 | void (*on_event)(vh_slider_event_t);
20 | };
21 |
22 | void vh_slider_add(ku_view_t* view, void (*on_event)(vh_slider_event_t));
23 | void vh_slider_set(ku_view_t* view, float ratio);
24 | float vh_slider_get_ratio(ku_view_t* view);
25 | void vh_slider_set_enabled(ku_view_t* view, int flag);
26 |
27 | #endif
28 |
29 | #if __INCLUDE_LEVEL__ == 0
30 |
31 | #include "vh_anim.c"
32 | #include
33 |
34 | int vh_slider_evt(ku_view_t* view, ku_event_t ev)
35 | {
36 | vh_slider_t* vh = view->evt_han_data;
37 |
38 | if (vh->enabled)
39 | {
40 | if (ev.type == KU_EVENT_MOUSE_DOWN || (ev.type == KU_EVENT_MOUSE_MOVE && ev.drag))
41 | {
42 | float dx = ev.x - view->frame.global.x;
43 | vh->ratio = dx / view->frame.global.w;
44 |
45 | ku_view_t* bar = view->views->data[0];
46 | ku_rect_t frame = bar->frame.local;
47 | frame.w = dx;
48 | ku_view_set_frame(bar, frame);
49 |
50 | vh_slider_event_t event = {.view = view, .ratio = vh->ratio, .vh = vh};
51 | if (vh->on_event)
52 | (*vh->on_event)(event);
53 | }
54 | else if (ev.type == KU_EVENT_SCROLL)
55 | {
56 | float ratio = vh->ratio - ev.dx / 50.0;
57 |
58 | if (ratio < 0)
59 | ratio = 0;
60 | if (ratio > 1)
61 | ratio = 1;
62 |
63 | vh->ratio = ratio;
64 | ku_view_t* bar = view->views->data[0];
65 | ku_rect_t frame = bar->frame.local;
66 | frame.w = view->frame.global.w * vh->ratio;
67 | ku_view_set_frame(bar, frame);
68 |
69 | vh_slider_event_t event = {.view = view, .ratio = vh->ratio, .vh = vh};
70 | if (vh->on_event)
71 | (*vh->on_event)(event);
72 | }
73 | }
74 |
75 | return 0;
76 | }
77 |
78 | void vh_slider_set(ku_view_t* view, float ratio)
79 | {
80 | vh_slider_t* vh = view->evt_han_data;
81 | vh->ratio = ratio;
82 | ku_view_t* bar = view->views->data[0];
83 | ku_rect_t frame = bar->frame.local;
84 | frame.w = view->frame.global.w * vh->ratio;
85 | ku_view_set_frame(bar, frame);
86 | }
87 |
88 | float vh_slider_get_ratio(ku_view_t* view)
89 | {
90 | vh_slider_t* vh = view->evt_han_data;
91 | return vh->ratio;
92 | }
93 |
94 | void vh_slider_desc(void* p, int level)
95 | {
96 | printf("vh_slider");
97 | }
98 |
99 | void vh_slider_del(void* p)
100 | {
101 | }
102 |
103 | void vh_slider_add(ku_view_t* view, void (*on_event)(vh_slider_event_t))
104 | {
105 | assert(view->evt_han == NULL && view->evt_han_data == NULL);
106 |
107 | vh_slider_t* vh = CAL(sizeof(vh_slider_t), vh_slider_del, vh_slider_desc);
108 | vh->on_event = on_event;
109 | vh->enabled = 1;
110 |
111 | view->evt_han_data = vh;
112 | view->evt_han = vh_slider_evt;
113 |
114 | ku_view_t* bar = view->views->data[0];
115 | vh_anim_add(bar, NULL, NULL);
116 | }
117 |
118 | void vh_slider_set_enabled(ku_view_t* view, int flag)
119 | {
120 | vh_slider_t* vh = view->evt_han_data;
121 |
122 | if (flag)
123 | {
124 | if (vh->enabled == 0)
125 | {
126 | ku_view_t* bar = view->views->data[0];
127 | vh_anim_alpha(bar, 0.3, 1.0, 10, AT_LINEAR);
128 | }
129 | }
130 | else
131 | {
132 | if (vh->enabled == 1)
133 | {
134 | ku_view_t* bar = view->views->data[0];
135 | vh_anim_alpha(bar, 1.0, 0.3, 10, AT_LINEAR);
136 | }
137 | }
138 |
139 | vh->enabled = flag;
140 | }
141 |
142 | #endif
143 |
--------------------------------------------------------------------------------
/src/kinetic_ui/handler/vh_touch.c:
--------------------------------------------------------------------------------
1 | #ifndef vh_touch_h
2 | #define vh_touch_h
3 |
4 | #include "ku_view.c"
5 |
6 | typedef struct _vh_touch_t vh_touch_t;
7 |
8 | enum vh_touch_event_id
9 | {
10 | VH_TOUCH_EVENT
11 | };
12 |
13 | typedef struct _vh_touch_event_t
14 | {
15 | enum vh_touch_event_id id;
16 | vh_touch_t* vh;
17 | ku_view_t* view;
18 | } vh_touch_event_t;
19 |
20 | struct _vh_touch_t
21 | {
22 | void (*on_event)(vh_touch_event_t);
23 | };
24 |
25 | void vh_touch_add(ku_view_t* view, void (*on_event)(vh_touch_event_t));
26 |
27 | #endif
28 |
29 | #if __INCLUDE_LEVEL__ == 0
30 |
31 | #include "ku_event.c"
32 |
33 | int vh_touch_evt(ku_view_t* view, ku_event_t ev)
34 | {
35 | if (ev.type == KU_EVENT_MOUSE_DOWN)
36 | {
37 | vh_touch_t* vh = view->evt_han_data;
38 | vh_touch_event_t event = {.id = VH_TOUCH_EVENT, .vh = vh, .view = view};
39 | if (vh->on_event)
40 | (*vh->on_event)(event);
41 | }
42 |
43 | return 0;
44 | }
45 |
46 | void vh_touch_del(void* p)
47 | {
48 | /* vh_touch_t* vh = p; */
49 | }
50 |
51 | void vh_touch_desc(void* p, int level)
52 | {
53 | printf("vh_touch");
54 | }
55 |
56 | void vh_touch_add(ku_view_t* view, void (*on_event)(vh_touch_event_t))
57 | {
58 | assert(view->evt_han == NULL && view->evt_han_data == NULL);
59 |
60 | vh_touch_t* vh = CAL(sizeof(vh_touch_t), vh_touch_del, vh_touch_desc);
61 | vh->on_event = on_event;
62 |
63 | view->evt_han = vh_touch_evt;
64 | view->evt_han_data = vh;
65 | }
66 |
67 | #endif
68 |
--------------------------------------------------------------------------------
/src/kinetic_ui/ku_css.c:
--------------------------------------------------------------------------------
1 | /*
2 | Kinetic UI CSS parser
3 | Does pretty dumb parsing, error handling should be improved
4 | */
5 |
6 | #ifndef ku_css_h
7 | #define ku_css_h
8 |
9 | /* TODO write tests */
10 |
11 | #include "mt_log.c"
12 | #include "mt_map.c"
13 | #include "mt_string.c"
14 | #include "mt_vector.c"
15 | #include
16 | #include
17 | #include
18 |
19 | typedef struct _css_range_t
20 | {
21 | uint32_t pos;
22 | uint32_t len;
23 | } css_range_t;
24 |
25 | typedef struct _prop_t
26 | {
27 | css_range_t class;
28 | css_range_t key;
29 | css_range_t value;
30 | } prop_t;
31 |
32 | mt_map_t* ku_css_new(char* path);
33 |
34 | #endif
35 |
36 | #if __INCLUDE_LEVEL__ == 0
37 |
38 | #include "mt_string_ext.c"
39 |
40 | uint32_t ku_css_count_props(char* css)
41 | {
42 | int t = 0; // tag index
43 | char* c = css;
44 | while (*c)
45 | {
46 | if (*c == ':')
47 | t++;
48 | c++;
49 | }
50 | return t;
51 | }
52 |
53 | void ku_css_analyze_classes(char* css, prop_t* props)
54 | {
55 | int start = -1;
56 | // char in_l = 0; // in line
57 | uint32_t index = 0;
58 | css_range_t class = {0};
59 | int in_str = 0;
60 | char* c = css;
61 | while (*c)
62 | {
63 | if (*c == '}' || *c == ' ' || *c == '\r' || *c == '\n')
64 | {
65 | if (c - css - 1 == start) start = c - css; // skip starting empty chars
66 | }
67 | else if (*c == '"') // class name
68 | {
69 | in_str = 1 - in_str;
70 | }
71 | else if (*c == '{') // class name
72 | {
73 | class.pos = start + 1;
74 | class.len = c - css - start - 2;
75 | while (*(css + class.pos + class.len) == ' ') class.len--;
76 | class.len++;
77 | start = c - css;
78 | }
79 | else if (*c == ':' && !in_str) // property name
80 | {
81 | props[index].class = class;
82 | props[index].key.pos = start + 1;
83 | props[index].key.len = c - css - start - 1;
84 | start = c - css;
85 | }
86 | else if (*c == ';') // value name
87 | {
88 | props[index].class = class;
89 | props[index].value.pos = start + 1;
90 | props[index].value.len = c - css - start - 1;
91 |
92 | start = c - css;
93 | index++;
94 | }
95 |
96 | c++;
97 | }
98 | }
99 |
100 | void ku_css_prop_desc(void* p, int level)
101 | {
102 | printf("html prop_t");
103 | }
104 |
105 | prop_t* ku_css_new_parse(char* css)
106 | {
107 | uint32_t cnt = ku_css_count_props(css);
108 | prop_t* props = CAL(sizeof(prop_t) * (cnt + 1), NULL, ku_css_prop_desc); // REL 1
109 |
110 | ku_css_analyze_classes(css, props);
111 |
112 | for (uint32_t i = 0; i < cnt; i++)
113 | {
114 | // prop_t p = props[i];
115 | // printf("extracted prop %.*s %.*s %.*s\n", p.class.len, css + p.class.pos, p.key.len, css + p.key.pos, p.value.len, css + p.value.pos);
116 | }
117 |
118 | return props;
119 | }
120 |
121 | mt_map_t* ku_css_new(char* filepath)
122 | {
123 | mt_map_t* styles = MNEW(); // REL 2
124 | char* css = mt_string_new_file(filepath); // REL 0
125 |
126 | if (css)
127 | {
128 | prop_t* view_styles = ku_css_new_parse(css); // REL 1
129 | prop_t* props = view_styles;
130 |
131 | while ((*props).class.len > 0)
132 | {
133 | prop_t t = *props;
134 | char* cls = CAL(sizeof(char) * t.class.len + 1, NULL, mt_string_describe); // REL 3
135 | char* key = CAL(sizeof(char) * t.key.len + 1, NULL, mt_string_describe); // REL 4
136 | char* val = CAL(sizeof(char) * t.value.len + 1, NULL, mt_string_describe); // REL 5
137 |
138 | memcpy(cls, css + t.class.pos, t.class.len);
139 | memcpy(key, css + t.key.pos, t.key.len);
140 | memcpy(val, css + t.value.pos, t.value.len);
141 |
142 | mt_map_t* style = MGET(styles, cls);
143 | if (style == NULL)
144 | {
145 | style = MNEW(); // REL 6
146 | MPUT(styles, cls, style);
147 | REL(style); // REL 6
148 | }
149 | MPUT(style, key, val);
150 | props += 1;
151 | REL(cls); // REL 3
152 | REL(key); // REL 4
153 | REL(val); // REL 5
154 | }
155 |
156 | REL(view_styles);
157 | REL(css);
158 | }
159 | else mt_log_error("Empty CSS descriptor");
160 |
161 | return styles;
162 | }
163 |
164 | #endif
165 |
--------------------------------------------------------------------------------
/src/kinetic_ui/ku_event.c:
--------------------------------------------------------------------------------
1 | #ifndef ku_event_h
2 | #define ku_event_h
3 |
4 | #include
5 | #include
6 | #include
7 |
8 | enum evtype
9 | {
10 | KU_EVENT_EMPTY,
11 | KU_EVENT_FRAME,
12 | KU_EVENT_TIME,
13 | KU_EVENT_RESIZE,
14 | KU_EVENT_MOUSE_MOVE,
15 | KU_EVENT_MOUSE_DOWN,
16 | KU_EVENT_MOUSE_UP,
17 | KU_EVENT_MOUSE_MOVE_OUT,
18 | KU_EVENT_MOUSE_DOWN_OUT,
19 | KU_EVENT_MOUSE_UP_OUT,
20 | KU_EVENT_SCROLL,
21 | KU_EVENT_SCROLL_X_END,
22 | KU_EVENT_SCROLL_Y_END,
23 | KU_EVENT_KEY_DOWN,
24 | KU_EVENT_KEY_UP,
25 | KU_EVENT_TEXT,
26 | KU_EVENT_WINDOW_SHOWN,
27 | KU_EVENT_PINCH,
28 | KU_EVENT_HOLD_START,
29 | KU_EVENT_HOLD_END,
30 | KU_EVENT_STDIN,
31 | KU_EVENT_FOCUS,
32 | KU_EVENT_UNFOCUS,
33 | };
34 |
35 | typedef struct _ku_event_t
36 | {
37 | int type;
38 |
39 | /* poiniter properties */
40 |
41 | int x; // mouse coord x
42 | int y; // mouse coord y
43 |
44 | /* resize */
45 |
46 | int w; // resize width
47 | int h; // resize height
48 |
49 | /* scroll */
50 |
51 | float dx; // scroll x
52 | float dy; // scroll y
53 |
54 | /* pinch */
55 |
56 | float ratio; // pinch ratio
57 |
58 | /* mouse */
59 |
60 | int drag; // mouse drag
61 | int dclick; // double click
62 | int button; // mouse button id
63 |
64 | /* time */
65 |
66 | uint32_t time; // milliseconds since start
67 | struct timespec time_unix; // unix timestamp
68 | float time_frame; // elapsed time since last frame
69 | uint32_t frame; // actual frame count
70 |
71 | /* keyboard */
72 |
73 | uint32_t keycode;
74 | int repeat; // key event is coming from repeat
75 |
76 | int ctrl_down; // modifiers
77 | int shift_down; // modifiers
78 |
79 | char text[8];
80 |
81 | /* window */
82 |
83 | void* window;
84 |
85 | } ku_event_t;
86 |
87 | void ku_event_write(FILE* file, ku_event_t ev);
88 | ku_event_t ku_event_read(FILE* file);
89 |
90 | #endif
91 |
92 | #if __INCLUDE_LEVEL__ == 0
93 |
94 | #include "mt_log.c"
95 |
96 | /* frame type x y w h dx dy ratio drag dclick button time time_frame keycode repeat ctrl_down shift_down text */
97 | char* ku_print_format = "%i %i %i %i %i %i %f %f %f %i %i %i %u %f %u %i %i %i '%s'\n";
98 | char* ku_scan_format = "%i %i %i %i %i %i %f %f %f %i %i %i %u %f %u %i %i %i '%[^']'\n";
99 |
100 | void ku_event_write(FILE* file, ku_event_t ev)
101 | {
102 | fprintf(
103 | file,
104 | ku_print_format,
105 | ev.frame,
106 | ev.type,
107 | ev.x,
108 | ev.y,
109 | ev.w,
110 | ev.h,
111 | ev.dx,
112 | ev.dy,
113 | ev.ratio,
114 | ev.drag,
115 | ev.dclick,
116 | ev.button,
117 | ev.time,
118 | ev.time_frame,
119 | ev.keycode,
120 | ev.repeat,
121 | ev.ctrl_down,
122 | ev.shift_down,
123 | ev.text[0] == '\0' ? "T" : ev.text);
124 | }
125 |
126 | ku_event_t ku_event_read(FILE* file)
127 | {
128 | ku_event_t ev = {0};
129 | int res = fscanf(
130 | file,
131 | ku_scan_format,
132 | &ev.frame,
133 | &ev.type,
134 | &ev.x,
135 | &ev.y,
136 | &ev.w,
137 | &ev.h,
138 | &ev.dx,
139 | &ev.dy,
140 | &ev.ratio,
141 | &ev.drag,
142 | &ev.dclick,
143 | &ev.button,
144 | &ev.time,
145 | &ev.time_frame,
146 | &ev.keycode,
147 | &ev.repeat,
148 | &ev.ctrl_down,
149 | &ev.shift_down,
150 | &ev.text);
151 |
152 | if (res < 0)
153 | mt_log_error("Couldn't scanf file");
154 |
155 | return ev;
156 | }
157 |
158 | #endif
159 |
--------------------------------------------------------------------------------
/src/kinetic_ui/ku_fontconfig.c:
--------------------------------------------------------------------------------
1 | #ifndef ku_fontconfig_h
2 | #define ku_fontconfig_h
3 |
4 | char* ku_fontconfig_path(char* face_desc);
5 | void ku_fontconfig_delete();
6 |
7 | #endif
8 |
9 | #if __INCLUDE_LEVEL__ == 0
10 |
11 | #include
12 | #ifdef __linux__
13 | #include
14 | #endif
15 |
16 | // #define _POSIX_C_SOURCE 200112L
17 | #include "mt_map.c"
18 | #include "mt_memory.c"
19 | #include "mt_string.c"
20 | #include
21 | #include
22 |
23 | mt_map_t* ku_fontconfig_cache = NULL;
24 |
25 | char* ku_fontconfig_path(char* face_desc)
26 | {
27 | char* filename = NULL;
28 | if (face_desc)
29 | {
30 | if (ku_fontconfig_cache == NULL)
31 | ku_fontconfig_cache = MNEW();
32 | filename = MGET(ku_fontconfig_cache, face_desc);
33 |
34 | if (filename == NULL)
35 | {
36 | char buff[PATH_MAX];
37 | filename = mt_string_new_cstring(""); // REL 0
38 | char* command = mt_string_new_format(80, "fc-match \"%s\" --format=%%{file}", face_desc); // REL 1
39 | FILE* pipe = popen(command, "r"); // CLOSE 0
40 | while (fgets(buff, sizeof(buff), pipe) != NULL) filename = mt_string_append(filename, buff);
41 | pclose(pipe); // CLOSE 0
42 | REL(command); // REL 1
43 |
44 | MPUTR(ku_fontconfig_cache, face_desc, filename);
45 | }
46 | }
47 | return filename;
48 | }
49 |
50 | void ku_fontconfig_delete()
51 | {
52 | if (ku_fontconfig_cache) REL(ku_fontconfig_cache);
53 | ku_fontconfig_cache = NULL;
54 | }
55 |
56 | #endif
57 |
--------------------------------------------------------------------------------
/src/kinetic_ui/ku_gen_html.c:
--------------------------------------------------------------------------------
1 | #ifndef ku_gen_html_h
2 | #define ku_gen_html_h
3 |
4 | #include "mt_vector.c"
5 |
6 | void ku_gen_html_parse(char* htmlpath, mt_vector_t* views);
7 |
8 | #endif
9 |
10 | #if __INCLUDE_LEVEL__ == 0
11 |
12 | #include "ku_html.c"
13 | #include "ku_view.c"
14 | #include "mt_log.c"
15 | #include "mt_string_ext.c"
16 |
17 | void ku_gen_html_parse(char* htmlpath, mt_vector_t* views)
18 | {
19 | char* html = mt_string_new_file(htmlpath); // REL 0
20 |
21 | if (html != NULL)
22 | {
23 | tag_t* tags = ku_html_new(html); // REL 1
24 | tag_t* head = tags;
25 |
26 | while ((*tags).len > 0)
27 | {
28 | tag_t t = *tags;
29 | if (t.id.len > 0)
30 | {
31 | // extract id
32 | char* id = CAL(sizeof(char) * t.id.len + 1, NULL, mt_string_describe); // REL 0
33 | memcpy(id, html + t.id.pos + 1, t.id.len);
34 | ku_view_t* view = ku_view_new(id, (ku_rect_t){0}); // REL 1
35 |
36 | if (t.level > 0)
37 | {
38 | // add to parent
39 | ku_view_t* parent = views->data[t.parent];
40 | ku_view_add_subview(parent, view);
41 | }
42 |
43 | if (t.class.len > 0)
44 | {
45 | // store css classes
46 | char* class = CAL(sizeof(char) * t.class.len + 1, NULL, mt_string_describe); // REL 0
47 | memcpy(class, html + t.class.pos + 1, t.class.len);
48 | ku_view_set_class(view, class);
49 | REL(class);
50 | }
51 |
52 | if (t.type.len > 0)
53 | {
54 | // store html stype
55 | char* type = CAL(sizeof(char) * t.type.len + 1, NULL, mt_string_describe); // REL 2
56 | memcpy(type, html + t.type.pos + 1, t.type.len);
57 | ku_view_set_type(view, type);
58 | REL(type); // REL 2
59 | }
60 |
61 | if (t.text.len > 0)
62 | {
63 | // store html stype
64 | char* text = CAL(sizeof(char) * t.text.len + 1, NULL, mt_string_describe); // REL 2
65 | memcpy(text, html + t.text.pos + 1, t.text.len);
66 | ku_view_set_text(view, text);
67 | REL(text); // REL 2
68 | }
69 |
70 | if (t.script.len > 0)
71 | {
72 | // store html stype
73 | char* script = CAL(sizeof(char) * t.script.len + 1, NULL, mt_string_describe); // REL 2
74 | memcpy(script, html + t.script.pos + 1, t.script.len);
75 | ku_view_set_script(view, script);
76 | REL(script); // REL 2
77 | }
78 |
79 | VADD(views, view);
80 |
81 | REL(id); // REL 0
82 | REL(view); // REL 1
83 | }
84 | else
85 | {
86 | static int divcnt = 0;
87 | char* divid = mt_string_new_format(10, "div%i", divcnt++);
88 | // idless view, probably