/* * Mr. 4th Dimention - Allen Webster * * 20.02.2016 * * GUI system for 4coder * */ // TOP struct Query_Slot{ Query_Slot *next; Query_Bar *query_bar; }; struct Query_Set{ Query_Slot slots[8]; Query_Slot *free_slot; Query_Slot *used_slot; }; internal void init_query_set(Query_Set *set){ Query_Slot *slot = set->slots; int i; set->free_slot = slot; set->used_slot = 0; for (i = 0; i+1 < ArrayCount(set->slots); ++i, ++slot){ slot->next = slot + 1; } } internal Query_Slot* alloc_query_slot(Query_Set *set){ Query_Slot *slot = set->free_slot; if (slot != 0){ set->free_slot = slot->next; slot->next = set->used_slot; set->used_slot = slot; } return(slot); } internal void free_query_slot(Query_Set *set, Query_Bar *match_bar){ Query_Slot *slot = 0, *prev = 0; for (slot = set->used_slot; slot != 0; slot = slot->next){ if (slot->query_bar == match_bar) break; prev = slot; } if (slot){ if (prev){ prev->next = slot->next; } else{ set->used_slot = slot->next; } slot->next = set->free_slot; set->free_slot = slot; } } struct Single_Line_Input_Step{ b8 hit_newline; b8 hit_ctrl_newline; b8 hit_a_character; b8 hit_backspace; b8 hit_esc; b8 made_a_change; b8 did_command; b8 no_file_match; }; enum Single_Line_Input_Type{ SINGLE_LINE_STRING, SINGLE_LINE_FILE }; struct Single_Line_Mode{ Single_Line_Input_Type type; String *string; Hot_Directory *hot_directory; b32 fast_folder_select; b32 try_to_match; b32 case_sensitive; }; internal Single_Line_Input_Step app_single_line_input_core(System_Functions *system, Working_Set *working_set, Key_Event_Data key, Single_Line_Mode mode){ Single_Line_Input_Step result = {}; if (key.keycode == key_back){ result.hit_backspace = 1; if (mode.string->size > 0){ result.made_a_change = 1; --mode.string->size; switch (mode.type){ case SINGLE_LINE_STRING: mode.string->str[mode.string->size] = 0; break; case SINGLE_LINE_FILE: { char end_character = mode.string->str[mode.string->size]; if (char_is_slash(end_character)){ mode.string->size = reverse_seek_slash(*mode.string) + 1; mode.string->str[mode.string->size] = 0; hot_directory_set(system, mode.hot_directory, *mode.string, working_set); } else{ mode.string->str[mode.string->size] = 0; } }break; } } } else if (key.character == '\n' || key.character == '\t'){ result.made_a_change = 1; if (key.modifiers[MDFR_CONTROL_INDEX] || key.modifiers[MDFR_ALT_INDEX]){ result.hit_ctrl_newline = 1; } else{ result.hit_newline = 1; if (mode.fast_folder_select){ Hot_Directory_Match match; char front_name_space[256]; String front_name = make_fixed_width_string(front_name_space); get_front_of_directory(&front_name, *mode.string); match = hot_directory_first_match(mode.hot_directory, front_name, 1, 1, mode.case_sensitive); if (mode.try_to_match && !match.filename.str){ match = hot_directory_first_match(mode.hot_directory, front_name, 1, 0, mode.case_sensitive); } if (match.filename.str){ if (match.is_folder){ set_last_folder(mode.string, match.filename, mode.hot_directory->slash); hot_directory_set(system, mode.hot_directory, *mode.string, working_set); result.hit_newline = 0; } else{ if (mode.try_to_match){ mode.string->size = reverse_seek_slash(*mode.string) + 1; append(mode.string, match.filename); } } } else{ if (mode.try_to_match){ result.no_file_match = 1; } } } } } else if (key.keycode == key_esc){ result.hit_esc = 1; result.made_a_change = 1; } else if (key.character){ result.hit_a_character = 1; if (!key.modifiers[MDFR_CONTROL_INDEX] && !key.modifiers[MDFR_ALT_INDEX]){ if (mode.string->size+1 < mode.string->memory_size){ u8 new_character = (u8)key.character; mode.string->str[mode.string->size] = new_character; mode.string->size++; mode.string->str[mode.string->size] = 0; if (mode.type == SINGLE_LINE_FILE && char_is_slash(new_character)){ hot_directory_set(system, mode.hot_directory, *mode.string, working_set); } result.made_a_change = 1; } } else{ result.did_command = 1; result.made_a_change = 1; } } return result; } inline Single_Line_Input_Step app_single_line_input_step(System_Functions *system, Key_Event_Data key, String *string){ Single_Line_Mode mode = {}; mode.type = SINGLE_LINE_STRING; mode.string = string; return app_single_line_input_core(system, 0, key, mode); } inline Single_Line_Input_Step app_single_file_input_step(System_Functions *system, Working_Set *working_set, Key_Event_Data key, String *string, Hot_Directory *hot_directory, b32 fast_folder_select, b32 try_to_match, b32 case_sensitive){ Single_Line_Mode mode = {}; mode.type = SINGLE_LINE_FILE; mode.string = string; mode.hot_directory = hot_directory; mode.fast_folder_select = fast_folder_select; mode.try_to_match = try_to_match; mode.case_sensitive = case_sensitive; return app_single_line_input_core(system, working_set, key, mode); } inline Single_Line_Input_Step app_single_number_input_step(System_Functions *system, Key_Event_Data key, String *string){ Single_Line_Input_Step result = {}; Single_Line_Mode mode = {}; mode.type = SINGLE_LINE_STRING; mode.string = string; char c = (char)key.character; if (c == 0 || c == '\n' || char_is_numeric(c)) result = app_single_line_input_core(system, 0, key, mode); return result; } struct Widget_ID{ i32 id; i32 sub_id0; i32 sub_id1; i32 sub_id2; }; inline b32 widget_match(Widget_ID s1, Widget_ID s2){ return (s1.id == s2.id && s1.sub_id0 == s2.sub_id0 && s1.sub_id1 == s2.sub_id1 && s1.sub_id2 == s2.sub_id2); } struct UI_State{ Render_Target *target; Style *style; Font_Set *font_set; Mouse_State *mouse; Key_Summary *keys; Working_Set *working_set; i16 font_id; Widget_ID selected, hover, hot; b32 activate_me; b32 redraw; b32 input_stage; i32 sub_id1_change; f32 height, view_y; }; inline Widget_ID make_id(UI_State *state, i32 id){ Widget_ID r = state->selected; r.id = id; return r; } inline Widget_ID make_sub0(UI_State *state, i32 id){ Widget_ID r = state->selected; r.sub_id0 = id; return r; } inline Widget_ID make_sub1(UI_State *state, i32 id){ Widget_ID r = state->selected; r.sub_id1 = id; return r; } inline Widget_ID make_sub2(UI_State *state, i32 id){ Widget_ID r = state->selected; r.sub_id2 = id; return r; } inline b32 is_selected(UI_State *state, Widget_ID id){ return widget_match(state->selected, id); } inline b32 is_hot(UI_State *state, Widget_ID id){ return widget_match(state->hot, id); } inline b32 is_hover(UI_State *state, Widget_ID id){ return widget_match(state->hover, id); } struct UI_Layout{ i32 row_count; i32 row_item_width; i32 row_max_item_height; i32_Rect rect; i32 x, y; }; struct UI_Layout_Restore{ UI_Layout layout; UI_Layout *dest; }; inline void begin_layout(UI_Layout *layout, i32_Rect rect){ layout->rect = rect; layout->x = rect.x0; layout->y = rect.y0; layout->row_count = 0; layout->row_max_item_height = 0; } inline void begin_row(UI_Layout *layout, i32 count){ layout->row_count = count; layout->row_item_width = (layout->rect.x1 - layout->x) / count; } inline i32_Rect layout_rect(UI_Layout *layout, i32 height){ i32_Rect rect; rect.x0 = layout->x; rect.y0 = layout->y; rect.x1 = rect.x0; rect.y1 = rect.y0 + height; if (layout->row_count > 0){ --layout->row_count; rect.x1 = rect.x0 + layout->row_item_width; layout->x += layout->row_item_width; layout->row_max_item_height = Max(height, layout->row_max_item_height); } if (layout->row_count == 0){ rect.x1 = layout->rect.x1; layout->row_max_item_height = Max(height, layout->row_max_item_height); layout->y += layout->row_max_item_height; layout->x = layout->rect.x0; layout->row_max_item_height = 0; } return rect; } inline UI_Layout_Restore begin_sub_layout(UI_Layout *layout, i32_Rect area){ UI_Layout_Restore restore; restore.layout = *layout; restore.dest = layout; begin_layout(layout, area); return restore; } inline void end_sub_layout(UI_Layout_Restore restore){ *restore.dest = restore.layout; } struct UI_Style{ u32 dark, dim, bright; u32 base, pop1, pop2; }; internal UI_Style get_ui_style(Style *style){ UI_Style ui_style; ui_style.dark = style->main.back_color; ui_style.dim = style->main.margin_color; ui_style.bright = style->main.margin_active_color; ui_style.base = style->main.default_color; ui_style.pop1 = style->main.file_info_style.pop1_color; ui_style.pop2 = style->main.file_info_style.pop2_color; return ui_style; } internal UI_Style get_ui_style_upper(Style *style){ UI_Style ui_style; ui_style.dark = style->main.margin_color; ui_style.dim = style->main.margin_hover_color; ui_style.bright = style->main.margin_active_color; ui_style.base = style->main.default_color; ui_style.pop1 = style->main.file_info_style.pop1_color; ui_style.pop2 = style->main.file_info_style.pop2_color; return ui_style; } inline void get_colors(UI_State *state, u32 *back, u32 *fore, Widget_ID wid, UI_Style style){ bool32 hover = is_hover(state, wid); bool32 hot = is_hot(state, wid); i32 level = hot + hover; switch (level){ case 2: *back = style.bright; *fore = style.dark; break; case 1: *back = style.dim; *fore = style.bright; break; case 0: *back = style.dark; *fore = style.bright; break; } } inline void get_pop_color(UI_State *state, u32 *pop, Widget_ID wid, UI_Style style){ bool32 hover = is_hover(state, wid); bool32 hot = is_hot(state, wid); i32 level = hot + hover; switch (level){ case 2: *pop = style.pop1; break; case 1: *pop = style.pop1; break; case 0: *pop = style.pop1; break; } } internal UI_State ui_state_init(UI_State *state_in, Render_Target *target, Input_Summary *user_input, Style *style, i16 font_id, Font_Set *font_set, Working_Set *working_set, b32 input_stage){ UI_State state = {}; state.target = target; state.style = style; state.font_set = font_set; state.font_id = font_id; state.working_set = working_set; if (user_input){ state.mouse = &user_input->mouse; state.keys = &user_input->keys; } state.selected = state_in->selected; state.hot = state_in->hot; if (input_stage) state.hover = {}; else state.hover = state_in->hover; state.redraw = 0; state.activate_me = 0; state.input_stage = input_stage; state.height = state_in->height; state.view_y = state_in->view_y; return state; } inline b32 ui_state_match(UI_State a, UI_State b){ return (widget_match(a.selected, b.selected) && widget_match(a.hot, b.hot) && widget_match(a.hover, b.hover)); } internal b32 ui_finish_frame(UI_State *persist_state, UI_State *state, UI_Layout *layout, i32_Rect rect, b32 do_wheel, b32 *did_activation){ b32 result = 0; f32 h = layout->y + persist_state->view_y - rect.y0; f32 max_y = h - (rect.y1 - rect.y0); persist_state->height = h; persist_state->view_y = state->view_y; if (state->input_stage){ Mouse_State *mouse = state->mouse; Font_Set *font_set = state->font_set; if (mouse->wheel != 0 && do_wheel){ i32 height = get_font_info(font_set, state->font_id)->height; persist_state->view_y += mouse->wheel*height; result = 1; } if (mouse->release_l && widget_match(state->hot, state->hover)){ if (did_activation) *did_activation = 1; if (state->activate_me){ state->selected = state->hot; } } if (!mouse->l && !mouse->r){ state->hot = {}; } if (!ui_state_match(*persist_state, *state) || state->redraw){ result = 1; } *persist_state = *state; } if (persist_state->view_y >= max_y) persist_state->view_y = max_y; if (persist_state->view_y < 0) persist_state->view_y = 0; return result; } internal b32 ui_do_button_input(UI_State *state, i32_Rect rect, Widget_ID id, bool32 activate, bool32 *right = 0){ b32 result = 0; Mouse_State *mouse = state->mouse; b32 hover = hit_check(mouse->x, mouse->y, rect); if (hover){ state->hover = id; if (activate) state->activate_me = 1; if (mouse->press_l || (mouse->press_r && right)) state->hot = id; if (mouse->l && mouse->r) state->hot = {}; } bool32 is_match = is_hot(state, id); if (mouse->release_l && is_match){ if (hover) result = 1; state->redraw = 1; } if (right && mouse->release_r && is_match){ if (hover) *right = 1; state->redraw = 1; } return result; } internal bool32 ui_do_subdivided_button_input(UI_State *state, i32_Rect rect, i32 parts, Widget_ID id, bool32 activate, i32 *indx_out, bool32 *right = 0){ bool32 result = 0; real32 x0, x1; i32_Rect sub_rect; Widget_ID sub_widg = id; real32 sub_width = (rect.x1 - rect.x0) / (real32)parts; sub_rect.y0 = rect.y0; sub_rect.y1 = rect.y1; x1 = (real32)rect.x0; for (i32 i = 0; i < parts; ++i){ x0 = x1; x1 = x1 + sub_width; sub_rect.x0 = TRUNC32(x0); sub_rect.x1 = TRUNC32(x1); sub_widg.sub_id2 = i; if (ui_do_button_input(state, sub_rect, sub_widg, activate, right)){ *indx_out = i; break; } } return result; } internal real32 ui_do_vscroll_input(UI_State *state, i32_Rect top, i32_Rect bottom, i32_Rect slider, Widget_ID id, real32 val, real32 step_amount, real32 smin, real32 smax, real32 vmin, real32 vmax){ Mouse_State *mouse = state->mouse; i32 mx = mouse->x; i32 my = mouse->y; if (hit_check(mx, my, top)){ state->hover = id; state->hover.sub_id2 = 1; } if (hit_check(mx, my, bottom)){ state->hover = id; state->hover.sub_id2 = 2; } if (hit_check(mx, my, slider)){ state->hover = id; state->hover.sub_id2 = 3; } if (mouse->press_l) state->hot = state->hover; if (id.id == state->hot.id){ if (mouse->release_l){ Widget_ID wid1, wid2; wid1 = wid2 = id; wid1.sub_id2 = 1; wid2.sub_id2 = 2; if (state->hot.sub_id2 == 1 && is_hover(state, wid1)) val -= step_amount; if (state->hot.sub_id2 == 2 && is_hover(state, wid2)) val += step_amount; state->redraw = 1; } if (state->hot.sub_id2 == 3){ f32 S, L; S = (f32)mouse->y - (slider.y1 - slider.y0) / 2; if (S < smin) S = smin; if (S > smax) S = smax; L = unlerp(smin, S, smax); val = lerp(vmin, L, vmax); state->redraw = 1; } } return val; } internal b32 ui_do_text_field_input(UI_State *state, String *str){ b32 result = 0; Key_Summary *keys = state->keys; for (i32 key_i = 0; key_i < keys->count; ++key_i){ Key_Event_Data key = get_single_key(keys, key_i); char c = (char)key.character; if (char_is_basic(c) && str->size < str->memory_size-1){ str->str[str->size++] = c; str->str[str->size] = 0; } else if (c == '\n'){ result = 1; } else if (key.keycode == key_back && str->size > 0){ str->str[--str->size] = 0; } } return result; } internal b32 ui_do_file_field_input(System_Functions *system, UI_State *state, Hot_Directory *hot_dir, b32 try_to_match, b32 case_sensitive){ Key_Event_Data key; Single_Line_Input_Step step; String *str = &hot_dir->string; Key_Summary *keys = state->keys; i32 key_i; b32 result = 0; terminate_with_null(str); for (key_i = 0; key_i < keys->count; ++key_i){ key = get_single_key(keys, key_i); step = app_single_file_input_step(system, state->working_set, key, str, hot_dir, 1, try_to_match, case_sensitive); if ((step.hit_newline || step.hit_ctrl_newline) && !step.no_file_match) result = 1; } return result; } internal b32 ui_do_line_field_input(System_Functions *system, UI_State *state, String *string){ b32 result = 0; Key_Summary *keys = state->keys; for (i32 key_i = 0; key_i < keys->count; ++key_i){ Key_Event_Data key = get_single_key(keys, key_i); terminate_with_null(string); Single_Line_Input_Step step = app_single_line_input_step(system, key, string); if (step.hit_newline || step.hit_ctrl_newline) result = 1; } return result; } internal b32 ui_do_slider_input(UI_State *state, i32_Rect rect, Widget_ID wid, real32 min, real32 max, real32 *v){ b32 result = 0; ui_do_button_input(state, rect, wid, 0); Mouse_State *mouse = state->mouse; if (is_hot(state, wid)){ result = 1; *v = unlerp(min, (f32)mouse->x, max); state->redraw = 1; } return result; } internal bool32 do_text_field(Widget_ID wid, UI_State *state, UI_Layout *layout, String prompt, String dest){ b32 result = 0; i32 character_h = get_font_info(state->font_set, state->font_id)->height; i32_Rect rect = layout_rect(layout, character_h); if (state->input_stage){ ui_do_button_input(state, rect, wid, 1); if (is_selected(state, wid)){ if (ui_do_text_field_input(state, &dest)){ result = 1; } } } else{ Render_Target *target = state->target; UI_Style ui_style = get_ui_style_upper(state->style); u32 back, fore, prompt_pop; get_colors(state, &back, &fore, wid, ui_style); get_pop_color(state, &prompt_pop, wid, ui_style); draw_rectangle(target, rect, back); i32 x = draw_string(target, state->font_id, prompt, rect.x0, rect.y0 + 1, prompt_pop); draw_string(target, state->font_id, dest, x, rect.y0 + 1, ui_style.base); } return result; } internal b32 do_button(i32 id, UI_State *state, UI_Layout *layout, char *text, i32 height_mult, b32 is_toggle = 0, b32 on = 0){ b32 result = 0; i16 font_id = state->font_id; i32 character_h = get_font_info(state->font_set, font_id)->height; i32_Rect btn_rect = layout_rect(layout, character_h * height_mult); if (height_mult > 1) btn_rect = get_inner_rect(btn_rect, 2); else{ btn_rect.x0 += 2; btn_rect.x1 -= 2; } Widget_ID wid = make_id(state, id); if (state->input_stage){ if (ui_do_button_input(state, btn_rect, wid, 0)){ result = 1; } } else{ Render_Target *target = state->target; UI_Style ui_style = get_ui_style(state->style); u32 back, fore, outline; outline = ui_style.bright; get_colors(state, &back, &fore, wid, ui_style); draw_rectangle(target, btn_rect, back); draw_rectangle_outline(target, btn_rect, outline); real32 text_width = font_string_width(target, font_id, text); i32 box_width = btn_rect.x1 - btn_rect.x0; i32 box_height = btn_rect.y1 - btn_rect.y0; i32 x_pos = TRUNC32(btn_rect.x0 + (box_width - text_width)*.5f); draw_string(target, font_id, text, x_pos, btn_rect.y0 + (box_height - character_h) / 2, fore); if (is_toggle){ i32_Rect on_box = get_inner_rect(btn_rect, character_h/2); on_box.x1 = on_box.x0 + (on_box.y1 - on_box.y0); if (on) draw_rectangle(target, on_box, fore); else draw_rectangle(target, on_box, back); draw_rectangle_outline(target, on_box, fore); } } return result; } internal b32 do_undo_slider(Widget_ID wid, UI_State *state, UI_Layout *layout, i32 max, i32 v, Undo_Data *undo, i32 *out){ b32 result = 0; i16 font_id = state->font_id; i32 character_h = get_font_info(state->font_set, font_id)->height; i32_Rect containing_rect = layout_rect(layout, character_h); i32_Rect click_rect; click_rect.x0 = containing_rect.x0 + character_h - 1; click_rect.x1 = containing_rect.x1 - character_h + 1; click_rect.y0 = containing_rect.y0 + 2; click_rect.y1 = containing_rect.y1 - 2; if (state->input_stage){ real32 l; if (ui_do_slider_input(state, click_rect, wid, (real32)click_rect.x0, (real32)click_rect.x1, &l)){ real32 v_new = lerp(0.f, l, (real32)max); v = ROUND32(v_new); result = 1; if (out) *out = v; } } else{ Render_Target *target = state->target; if (max > 0){ UI_Style ui_style = get_ui_style_upper(state->style); real32 L = unlerp(0.f, (real32)v, (real32)max); i32 x = FLOOR32(lerp((real32)click_rect.x0, L, (real32)click_rect.x1)); i32 bar_top = ((click_rect.y0 + click_rect.y1) >> 1) - 1; i32 bar_bottom = bar_top + 2; bool32 show_bar = 1; real32 tick_step = (click_rect.x1 - click_rect.x0) / (real32)max; bool32 show_ticks = 1; if (tick_step <= 5.f) show_ticks = 0; if (undo == 0){ if (show_bar){ i32_Rect slider_rect; slider_rect.x0 = click_rect.x0; slider_rect.x1 = x; slider_rect.y0 = bar_top; slider_rect.y1 = bar_bottom; draw_rectangle(target, slider_rect, ui_style.dim); slider_rect.x0 = x; slider_rect.x1 = click_rect.x1; draw_rectangle(target, slider_rect, ui_style.pop1); } if (show_ticks){ f32_Rect tick; tick.x0 = (real32)click_rect.x0 - 1; tick.x1 = (real32)click_rect.x0 + 1; tick.y0 = (real32)bar_top - 3; tick.y1 = (real32)bar_bottom + 3; for (i32 i = 0; i < v; ++i){ draw_rectangle(target, tick, ui_style.dim); tick.x0 += tick_step; tick.x1 += tick_step; } for (i32 i = v; i <= max; ++i){ draw_rectangle(target, tick, ui_style.pop1); tick.x0 += tick_step; tick.x1 += tick_step; } } } else{ if (show_bar){ i32_Rect slider_rect; slider_rect.x0 = click_rect.x0; slider_rect.y0 = bar_top; slider_rect.y1 = bar_bottom; Edit_Step *history = undo->history.edits; i32 block_count = undo->history_block_count; Edit_Step *step = history; for (i32 i = 0; i < block_count; ++i){ u32 color; if (step->type == ED_REDO || step->type == ED_UNDO) color = ui_style.pop1; else color = ui_style.dim; real32 L; if (i + 1 == block_count){ L = 1.f; }else{ step = history + step->next_block; L = unlerp(0.f, (real32)(step - history), (real32)max); } if (L > 1.f) L = 1.f; i32 x = FLOOR32(lerp((real32)click_rect.x0, L, (real32)click_rect.x1)); slider_rect.x1 = x; draw_rectangle(target, slider_rect, color); slider_rect.x0 = slider_rect.x1; if (L == 1.f) break; } } if (show_ticks){ f32_Rect tick; tick.x0 = (real32)click_rect.x0 - 1; tick.x1 = (real32)click_rect.x0 + 1; tick.y0 = (real32)bar_top - 3; tick.y1 = (real32)bar_bottom + 3; Edit_Step *history = undo->history.edits; u32 color = ui_style.dim; for (i32 i = 0; i <= max; ++i){ if (i != max){ if (history[i].type == ED_REDO) color = ui_style.pop1; else if (history[i].type == ED_UNDO || history[i].type == ED_NORMAL) color = ui_style.pop2; else color = ui_style.dim; } draw_rectangle(target, tick, color); tick.x0 += tick_step; tick.x1 += tick_step; } } } i32_Rect slider_handle; slider_handle.x0 = x - 2; slider_handle.x1 = x + 2; slider_handle.y0 = click_rect.y0; slider_handle.y1 = click_rect.y1; draw_rectangle(target, slider_handle, ui_style.bright); } } return result; } internal void do_label(UI_State *state, UI_Layout *layout, char *text, int text_size, f32 height = 2.f){ Style *style = state->style; i16 font_id = state->font_id; i32 line_height = get_font_info(state->font_set, font_id)->height; i32_Rect label = layout_rect(layout, FLOOR32(line_height * height)); if (!state->input_stage){ Render_Target *target = state->target; u32 back = style->main.margin_color; u32 fore = style->main.default_color; draw_rectangle(target, label, back); i32 height = label.y1 - label.y0; String textstr = make_string(text, text_size); draw_string(target, font_id, textstr, label.x0, label.y0 + (height - line_height)/2, fore); } } inline void do_label(UI_State *state, UI_Layout *layout, String text, f32 height = 2.f){ do_label(state, layout, text.str, text.size, height); } internal void do_scroll_bar(UI_State *state, i32_Rect rect){ i32 id = 1; i32 w = (rect.x1 - rect.x0); i32 h = (rect.y1 - rect.y0); i32_Rect top_arrow, bottom_arrow; top_arrow.x0 = rect.x0; top_arrow.x1 = rect.x1; top_arrow.y0 = rect.y0; top_arrow.y1 = top_arrow.y0 + w; bottom_arrow.x0 = rect.x0; bottom_arrow.x1 = rect.x1; bottom_arrow.y1 = rect.y1; bottom_arrow.y0 = bottom_arrow.y1 - w; f32 space_h = (f32)(bottom_arrow.y0 - top_arrow.y1); if (space_h <= w) return; i32 slider_h = w; f32 view_hmin = 0; f32 view_hmax = state->height - h; f32 L = unlerp(view_hmin, state->view_y, view_hmax); f32 slider_hmin = (f32)top_arrow.y1; f32 slider_hmax = (f32)bottom_arrow.y0 - slider_h; f32 S = lerp(slider_hmin, L, slider_hmax); i32_Rect slider; slider.x0 = rect.x0; slider.x1 = rect.x1; slider.y0 = FLOOR32(S); slider.y1 = slider.y0 + slider_h; Widget_ID wid = make_id(state, id); if (state->input_stage){ state->view_y = ui_do_vscroll_input(state, top_arrow, bottom_arrow, slider, wid, state->view_y, (f32)(get_font_info(state->font_set, state->font_id)->height), slider_hmin, slider_hmax, view_hmin, view_hmax); } else{ Render_Target *target = state->target; f32 x0, y0, x1, y1, x2, y2; f32 w_1_2 = w*.5f; f32 w_1_3 = w*.333333f; f32 w_2_3 = w*.666667f; UI_Style ui_style = get_ui_style(state->style); u32 outline, back, fore; outline = ui_style.bright; wid.sub_id2 = 0; x0 = (w_1_2 + top_arrow.x0); x1 = (w_1_3 + top_arrow.x0); x2 = (w_2_3 + top_arrow.x0); ++wid.sub_id2; y0 = (w_1_3 + top_arrow.y0); y1 = (w_2_3 + top_arrow.y0); y2 = (w_2_3 + top_arrow.y0); get_colors(state, &back, &fore, wid, ui_style); draw_rectangle(target, top_arrow, back); draw_rectangle_outline(target, top_arrow, outline); ++wid.sub_id2; y0 = (w_2_3 + bottom_arrow.y0); y1 = (w_1_3 + bottom_arrow.y0); y2 = (w_1_3 + bottom_arrow.y0); get_colors(state, &back, &fore, wid, ui_style); draw_rectangle(target, bottom_arrow, back); draw_rectangle_outline(target, bottom_arrow, outline); ++wid.sub_id2; get_colors(state, &back, &fore, wid, ui_style); draw_rectangle(target, slider, back); draw_rectangle_outline(target, slider, outline); draw_rectangle_outline(target, rect, outline); } } internal void draw_gradient_slider(Render_Target *target, Vec4 base, i32 channel, i32 steps, f32 top, f32_Rect slider, b32 hsla){ Vec4 low, high; f32 *lowv, *highv; f32 x; f32 next_x; f32 x_step; f32 v_step; f32 m; x = (real32)slider.x0; x_step = (real32)(slider.x1 - slider.x0) / steps; v_step = top / steps; m = 1.f / top; lowv = &low.v[channel]; highv = &high.v[channel]; if (hsla){ for (i32 i = 0; i < steps; ++i){ low = high = base; *lowv = (i * v_step); *highv = *lowv + v_step; *lowv *= m; *highv *= m; low = hsla_to_rgba(low); high = hsla_to_rgba(high); next_x = x + x_step; draw_gradient_2corner_clipped( target, x, slider.y0, next_x, slider.y1, low, high); x = next_x; } } else{ for (i32 i = 0; i < steps; ++i){ low = high = base; *lowv = (i * v_step); *highv = *lowv + v_step; *lowv *= m; *highv *= m; next_x = x + x_step; draw_gradient_2corner_clipped( target, x, slider.y0, next_x, slider.y1, low, high); x = next_x; } } } inline void draw_hsl_slider(Render_Target *target, Vec4 base, i32 channel, i32 steps, f32 top, f32_Rect slider){ draw_gradient_slider(target, base, channel, steps, top, slider, 1); } inline void draw_rgb_slider(Render_Target *target, Vec4 base, i32 channel, i32 steps, f32 top, f32_Rect slider){ draw_gradient_slider(target, base, channel, steps, top, slider, 0); } internal b32 do_main_file_box(System_Functions *system, UI_State *state, UI_Layout *layout, Hot_Directory *hot_directory, b32 try_to_match, b32 case_sensitive, char *end){ b32 result = 0; Style *style = state->style; String *string = &hot_directory->string; i16 font_id = state->font_id; i32 line_height = get_font_info(state->font_set, font_id)->height; i32_Rect box = layout_rect(layout, line_height + 2); if (state->input_stage){ if (ui_do_file_field_input(system, state, hot_directory, try_to_match, case_sensitive)){ result = 1; } } else{ Render_Target *target = state->target; u32 back = style->main.margin_color; u32 fore = style->main.default_color; u32 special = style->main.special_character_color; draw_rectangle(target, box, back); i32 x = box.x0; x = draw_string(target, font_id, string->str, x, box.y0, fore); if (end) draw_string(target, font_id, end, x, box.y0, special); } layout->y = box.y1; return result; } internal b32 do_main_string_box(System_Functions *system, UI_State *state, UI_Layout *layout, String *string){ b32 result = 0; Style *style = state->style; i16 font_id = state->font_id; i32 line_height = get_font_info(state->font_set, font_id)->height; i32_Rect box = layout_rect(layout, line_height + 2); if (state->input_stage){ if (ui_do_line_field_input(system, state, string)){ result = 1; } } else{ Render_Target *target = state->target; u32 back = style->main.margin_color; u32 fore = style->main.default_color; draw_rectangle(target, box, back); i32 x = box.x0; x = draw_string(target, font_id, string->str, x, box.y0, fore); } layout->y = box.y1; return result; } internal b32 do_list_option(i32 id, UI_State *state, UI_Layout *layout, String text){ b32 result = 0; Style *style = state->style; i16 font_id = state->font_id; i32 character_h = get_font_info(state->font_set, font_id)->height; i32_Rect box = layout_rect(layout, character_h*2); Widget_ID wid = make_id(state, id); if (state->input_stage){ if (ui_do_button_input(state, box, wid, 0)){ result = 1; } } else{ Render_Target *target = state->target; i32_Rect inner = get_inner_rect(box, 3); u32 back, outline, fore, pop; back = style->main.back_color; fore = style->main.default_color; pop = style->main.file_info_style.pop2_color; if (is_hover(state, wid)) outline = style->main.margin_active_color; else outline = style->main.margin_color; draw_rectangle(target, inner, back); i32 x = inner.x0, y = box.y0 + character_h/2; x = draw_string(target, font_id, text, x, y, fore); draw_margin(target, box, inner, outline); } layout->y = box.y1; return result; } internal b32 do_checkbox_list_option(i32 id, UI_State *state, UI_Layout *layout, String text, b32 is_on){ b32 result = 0; Style *style = state->style; i16 font_id = state->font_id; i32 character_h = get_font_info(state->font_set, font_id)->height; i32_Rect box = layout_rect(layout, character_h*2); Widget_ID wid = make_id(state, id); if (state->input_stage){ if (ui_do_button_input(state, box, wid, 0)){ result = 1; } } else{ Render_Target *target = state->target; i32_Rect inner = get_inner_rect(box, 3); u32 back, outline, fore, pop, box_color; back = style->main.back_color; fore = style->main.default_color; pop = style->main.file_info_style.pop2_color; if (is_hover(state, wid)) outline = style->main.margin_active_color; else outline = style->main.margin_color; box_color = style->main.margin_active_color; draw_rectangle(target, inner, back); i32_Rect square; square = get_inner_rect(inner, character_h/3); square.x1 = square.x0 + (square.y1 - square.y0); if (is_on) draw_rectangle(target, square, box_color); else draw_margin(target, square, 1, box_color); i32 x = square.x1 + 3; i32 y = box.y0 + character_h/2; x = draw_string(target, font_id, text, x, y, fore); draw_margin(target, box, inner, outline); } layout->y = box.y1; return result; } internal b32 do_file_option(i32 id, UI_State *state, UI_Layout *layout, String filename, b32 is_folder, String extra, char slash){ b32 result = 0; Style *style = state->style; i16 font_id = state->font_id; i32 character_h = get_font_info(state->font_set, font_id)->height; char slash_buf[2] = { slash, 0 }; i32_Rect box = layout_rect(layout, character_h*2); Widget_ID wid = make_id(state, id); if (state->input_stage){ if (ui_do_button_input(state, box, wid, 0)){ result = 1; } } else{ Render_Target *target = state->target; i32_Rect inner = get_inner_rect(box, 3); u32 back, outline, fore, pop; back = style->main.back_color; fore = style->main.default_color; pop = style->main.file_info_style.pop2_color; if (is_hover(state, wid)) outline = style->main.margin_active_color; else outline = style->main.margin_color; draw_rectangle(target, inner, back); i32 x = inner.x0, y = box.y0 + character_h/2; x = draw_string(target, font_id, filename, x, y, fore); if (is_folder) x = draw_string(target, font_id, slash_buf, x, y, fore); draw_string(target, font_id, extra, x, y, pop); draw_margin(target, box, inner, outline); } layout->y = box.y1; return result; } internal b32 do_file_list_box(System_Functions *system, UI_State *state, UI_Layout *layout, Hot_Directory *hot_dir, b32 has_filter, b32 try_to_match, b32 case_sensitive, b32 *new_dir, b32 *selected, char *end){ b32 result = 0; File_List *files = &hot_dir->file_list; if (do_main_file_box(system, state, layout, hot_dir, try_to_match, case_sensitive, end)){ *selected = 1; terminate_with_null(&hot_dir->string); } else{ persist String p4c_extension = make_lit_string("p4c"); persist String message_loaded = make_lit_string(" LOADED"); persist String message_unsaved = make_lit_string(" LOADED *"); persist String message_unsynced = make_lit_string(" LOADED !"); persist String message_nothing = {}; char front_name_space[256]; String front_name = make_fixed_width_string(front_name_space); get_front_of_directory(&front_name, hot_dir->string); Absolutes absolutes; get_absolutes(front_name, &absolutes, 1, 1); char full_path_[256]; String full_path = make_fixed_width_string(full_path_); get_path_of_directory(&full_path, hot_dir->string); i32 restore_size = full_path.size; i32 i; File_Info *info, *end; end = files->infos + files->count; for (info = files->infos, i = 0; info != end; ++info, ++i){ String filename = info->filename; append(&full_path, filename); terminate_with_null(&full_path); Editing_File *file = working_set_contains(state->working_set, full_path); full_path.size = restore_size; b8 is_folder = (info->folder != 0); b8 ext_match = (match(file_extension(filename), p4c_extension) != 0); b8 name_match = (filename_match(front_name, &absolutes, filename, case_sensitive) != 0); b8 is_loaded = (file != 0 && file_is_ready(file)); String message = message_nothing; if (is_loaded){ switch (buffer_get_sync(file)){ case SYNC_GOOD: message = message_loaded; break; case SYNC_BEHIND_OS: message = message_unsynced; break; case SYNC_UNSAVED: message = message_unsaved; break; } } if ((is_folder || !has_filter || ext_match) && name_match){ if (do_file_option(100+i, state, layout, filename, is_folder, message, system->slash)){ result = 1; hot_directory_clean_end(hot_dir); append(&hot_dir->string, filename); if (is_folder){ *new_dir = 1; append(&hot_dir->string, system->slash); } else{ *selected = 1; } terminate_with_null(&hot_dir->string); } } } } return result; } internal b32 do_live_file_list_box(System_Functions *system, UI_State *state, UI_Layout *layout, Working_Set *working_set, String *string, b32 *selected){ b32 result = 0; if (do_main_string_box(system, state, layout, string)){ *selected = 1; terminate_with_null(string); } else{ persist String message_unsaved = make_lit_string(" *"); persist String message_unsynced = make_lit_string(" !"); persist String message_nothing = {}; Absolutes absolutes; get_absolutes(*string, &absolutes, 1, 1); Editing_File *file; File_Node *node, *used_nodes; i32 i = 0; used_nodes = &working_set->used_sentinel; for (dll_items(node, used_nodes)){ file = (Editing_File*)node; Assert(!file->state.is_dummy); String message = message_nothing; switch (buffer_get_sync(file)){ case SYNC_BEHIND_OS: message = message_unsynced; break; case SYNC_UNSAVED: message = message_unsaved; break; } if (filename_match(*string, &absolutes, file->name.live_name, 1)){ if (do_file_option(100+i, state, layout, file->name.live_name, 0, message, system->slash)){ result = 1; *selected = 1; copy(string, file->name.source_path); terminate_with_null(string); } } ++i; } } return result; } struct Super_Color{ Vec4 hsla; Vec4 rgba; u32 *out; }; internal Super_Color super_color_create(u32 packed){ Super_Color result = {}; result.rgba = unpack_color4(packed); result.hsla = rgba_to_hsla(result.rgba); return result; } internal void super_color_post_hsla(Super_Color *color, Vec4 hsla){ color->hsla = hsla; if (hsla.h == 1.f) hsla.h = 0.f; color->rgba = hsla_to_rgba(hsla); *color->out = pack_color4(color->rgba); } internal void super_color_post_rgba(Super_Color *color, Vec4 rgba){ color->rgba = rgba; color->hsla = rgba_to_hsla(rgba); *color->out = pack_color4(rgba); } internal void super_color_post_packed(Super_Color *color, u32 packed){ color->rgba = unpack_color4(packed); color->hsla = rgba_to_hsla(color->rgba); *color->out = packed; } u32 super_color_clear_masks[] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; u32 super_color_shifts[] = {16, 8, 0}; internal u32 super_color_post_byte(Super_Color *color, i32 channel, u8 byte){ u32 packed = *color->out; packed &= super_color_clear_masks[channel]; packed |= (byte << super_color_shifts[channel]); super_color_post_packed(color, packed); return packed; } struct Color_Highlight{ i32 ids[4]; }; struct Library_UI{ UI_State *state; UI_Layout *layout; Font_Set *fonts; Style_Library *styles; Hot_Directory *hot_directory; }; struct Color_UI{ UI_State *state; UI_Layout *layout; Font_Set *fonts; Style_Font *global_font; f32 hex_advance; u32 *palette; i32 palette_size; Color_Highlight highlight; Super_Color color; b32 has_hover_color; Super_Color hover_color; }; enum Channel_Field_Type{ CF_DEC, CF_HEX }; internal void do_single_slider(i32 sub_id, Color_UI *ui, i32 channel, b32 is_rgba, i32 grad_steps, f32 top, f32_Rect slider, f32 v_handle, i32_Rect rect){ f32_Rect click_box = slider; click_box.y0 -= v_handle; if (ui->state->input_stage){ real32 v; if (ui_do_slider_input(ui->state, i32R(click_box), make_sub1(ui->state, sub_id), slider.x0, slider.x1, &v)){ Vec4 new_color; if (is_rgba) new_color = ui->color.rgba; else new_color = ui->color.hsla; new_color.v[channel] = clamp(0.f, v, 1.f); if (is_rgba) super_color_post_rgba(&ui->color, new_color); else super_color_post_hsla(&ui->color, new_color); } } else{ Render_Target *target = ui->state->target; Vec4 color; real32 x; if (is_rgba){ color = ui->color.rgba; draw_rgb_slider(target, V4(0,0,0,1.f), channel, 10, 100.f, slider); } else{ i32 steps; real32 top; if (channel == 0){ steps = 45; top = 360.f; } else{ steps = 10; top = 100.f; } color = ui->color.hsla; draw_hsl_slider(target, color, channel, steps, top, slider); } x = lerp(slider.x0, color.v[channel], slider.x1); draw_rectangle( target, f32R(x, slider.y0, x + 1, slider.y1), 0xff000000); draw_rectangle( target, f32R(x-2, click_box.y0, x+3, slider.y0-4), 0xff777777); } } internal void do_hsl_sliders(Color_UI *ui, i32_Rect rect){ real32 bar_width = (real32)(rect.x1 - rect.x0 - 20); if (bar_width > 45){ f32_Rect slider; real32 y; i32 sub_id; real32 v_full_space = 30.f; real32 v_half_space = 15.f; real32 v_quarter_space = 12.f; real32 v_handle = 9.f; slider.x0 = rect.x0 + 10.f; slider.x1 = slider.x0 + bar_width; sub_id = 0; i32 step_count[] = {45, 10, 10}; real32 tops[] = {360.f, 100.f, 100.f}; y = rect.y0 + v_quarter_space; for (i32 i = 0; i < 3; ++i){ ++sub_id; slider.y0 = y; slider.y1 = slider.y0 + v_half_space; do_single_slider(sub_id, ui, i, 0, step_count[i], tops[i], slider, v_handle, rect); y += v_full_space; } } } internal void fill_buffer_color_channel(char *buffer, u8 x, Channel_Field_Type ftype){ if (ftype == CF_DEC){ u8 x0; x0 = x / 10; buffer[2] = (x - (10*x0)) + '0'; x = x0; x0 = x / 10; buffer[1] = (x - (10*x0)) + '0'; x = x0; x0 = x / 10; buffer[0] = (x - (10*x0)) + '0'; } else{ u8 n; n = x & 0xF; buffer[1] = int_to_hexchar(n); x >>= 4; n = x & 0xF; buffer[0] = int_to_hexchar(n); } } internal b32 do_channel_field(i32 sub_id, Color_UI *ui, u8 *channel, Channel_Field_Type ftype, i32 y, u32 color, u32 back, i32 x0, i32 x1){ b32 result = 0; i16 font_id = ui->state->font_id; i32 line_height = get_font_info(ui->state->font_set, font_id)->height; i32_Rect hit_region; hit_region.x0 = x0; hit_region.x1 = x1; hit_region.y0 = y; hit_region.y1 = y + line_height; i32 digit_count; if (ftype == CF_DEC) digit_count = 3; else digit_count = 2; Render_Target *target = ui->state->target; if (ui->state->input_stage){ i32 indx; ui_do_subdivided_button_input(ui->state, hit_region, digit_count, make_sub1(ui->state, sub_id), 1, &indx); } else{ if (ui->state->hover.sub_id1 == sub_id && ui->state->selected.sub_id1 != sub_id){ draw_rectangle(target, hit_region, back); } } char string_buffer[4]; string_buffer[digit_count] = 0; fill_buffer_color_channel(string_buffer, *channel, ftype); if (ui->state->selected.sub_id1 == sub_id){ i32 indx = ui->state->selected.sub_id2; if (ui->state->input_stage){ Key_Summary *keys = ui->state->keys; for (i32 key_i = 0; key_i < keys->count; ++key_i){ Key_Event_Data key = get_single_key(keys, key_i); if (key.keycode == key_right){ ++indx; if (indx > digit_count-1) indx = 0; } if (key.keycode == key_left){ --indx; if (indx < 0) indx = digit_count-1; } i32 new_value = *channel; if (key.keycode == key_up || key.keycode == key_down){ i32 place = digit_count-1-indx; i32 base = (ftype == CF_DEC)?10:0x10; i32 step_amount = 1; while (place > 0){ step_amount *= base; --place; } if (key.keycode == key_down){ step_amount = 0 - step_amount; } new_value += step_amount; } u8 c = (u8)key.character; bool32 is_good = (ftype == CF_DEC)?char_is_numeric(c):char_is_hex(c); if (is_good){ string_buffer[indx] = c; if (ftype == CF_DEC) new_value = str_to_int(make_string(string_buffer, 3)); else new_value = hexstr_to_int(make_string(string_buffer, 2)); ++indx; if (indx > digit_count-1) indx = 0; } if (c == '\n'){ switch (sub_id){ case 1: case 2: case 4: case 5: ui->state->sub_id1_change = sub_id + 3; break; case 7: case 8: ui->state->sub_id1_change = sub_id - 6; break; } } if (new_value != *channel){ if (new_value > 255){ *channel = 255; } else if (new_value < 0){ *channel = 0; } else{ *channel = (u8)new_value; } fill_buffer_color_channel(string_buffer, *channel, ftype); result = 1; } ui->state->selected.sub_id2 = indx; } } else{ f32_Rect r = f32R(hit_region); r.x0 += indx*ui->hex_advance+1; r.x1 = r.x0+ui->hex_advance+1; draw_rectangle(target, r, back); } } if (!ui->state->input_stage) draw_string_mono(target, font_id, string_buffer, (real32)x0 + 1, (real32)y, ui->hex_advance, color); return result; } internal void do_rgb_sliders(Color_UI *ui, i32_Rect rect){ i32 dec_x0, dec_x1; dec_x0 = rect.x0 + 10; dec_x1 = TRUNC32(dec_x0 + ui->hex_advance*3 + 2); i32 hex_x0, hex_x1; hex_x0 = dec_x1 + 10; hex_x1 = TRUNC32(hex_x0 + ui->hex_advance*2 + 2); rect.x0 = hex_x1; real32 bar_width = (real32)(rect.x1 - rect.x0 - 20); f32_Rect slider; f32 y; i32 sub_id; u8 channel; real32 v_full_space = 30.f; real32 v_half_space = 15.f; real32 v_quarter_space = 12.f; real32 v_handle = 9.f; u32 packed_color = *ui->color.out; y = rect.y0 + v_quarter_space; slider.x0 = rect.x0 + 10.f; slider.x1 = slider.x0 + bar_width; sub_id = 0; persist i32 shifts[3] = { 16, 8, 0 }; persist u32 fore_colors[3] = { 0xFFFF0000, 0xFF00FF00, 0xFF1919FF }; persist u32 back_colors[3] = { 0xFF222222, 0xFF222222, 0xFF131313 }; for (i32 i = 0; i < 3; ++i){ i32 shift = shifts[i]; u32 fore = fore_colors[i]; u32 back = back_colors[i]; ++sub_id; channel = (packed_color >> shift) & 0xFF; if (do_channel_field(sub_id, ui, &channel, CF_DEC, (i32)y, fore, back, dec_x0, dec_x1)) super_color_post_byte(&ui->color, i, channel); ++sub_id; channel = (packed_color >> shift) & 0xFF; if (do_channel_field(sub_id, ui, &channel, CF_HEX, (i32)y, fore, back, hex_x0, hex_x1)) super_color_post_byte(&ui->color, i, channel); ++sub_id; slider.y0 = y; slider.y1 = slider.y0 + v_half_space; if (bar_width > 45.f) do_single_slider(sub_id, ui, i, 1, 10, 100.f, slider, v_handle, rect); y += v_full_space; } } struct Blob_Layout{ i32_Rect rect; i32 x, y; i32 size, space; }; internal void begin_layout(Blob_Layout *layout, i32_Rect rect){ layout->rect = rect; layout->x = rect.x0 + 10; layout->y = rect.y0; layout->size = 20; layout->space = 5; } internal void do_blob(Color_UI *ui, Blob_Layout *layout, u32 color, bool32 *set_me, i32 sub_id){ i32_Rect rect = layout->rect; f32_Rect blob; blob.x0 = (real32)layout->x; blob.y0 = (real32)layout->y; blob.x1 = blob.x0 + layout->size; blob.y1 = blob.y0 + layout->size; layout->y += layout->size + layout->space; if (layout->y + layout->size + layout->space*2 > rect.y1){ layout->y = rect.y0; layout->x += layout->size + layout->space; } if (ui->state->input_stage){ bool32 right = 0; if (ui_do_button_input(ui->state, i32R(blob), make_sub1(ui->state, sub_id), 0, &right)){ super_color_post_packed(&ui->color, color); } else if (right) *set_me = 1; } else{ Render_Target *target = ui->state->target; draw_rectangle(target, blob, color); persist u32 silver = 0xFFa0a0a0; draw_rectangle_outline(target, blob, silver); } } inline void do_blob(Color_UI *ui, Blob_Layout *layout, u32 *color, bool32 *set_me){ i32 sub_id = (i32)((char*)color - (char*)ui->state->style); do_blob(ui, layout, *color, set_me, sub_id); } internal void do_v_divide(Color_UI *ui, Blob_Layout *layout, i32 width){ i32_Rect rect = layout->rect; if (layout->y > rect.y0){ layout->x += layout->size + layout->space; } layout->x += width; layout->y = rect.y0; } internal void do_palette(Color_UI *ui, i32_Rect rect){ Style *style = ui->state->style; Blob_Layout layout; begin_layout(&layout, rect); bool32 set_me; do_blob(ui, &layout, &style->main.back_color, &set_me); do_blob(ui, &layout, &style->main.margin_color, &set_me); do_blob(ui, &layout, &style->main.margin_active_color, &set_me); do_blob(ui, &layout, &style->main.cursor_color, &set_me); do_blob(ui, &layout, &style->main.at_cursor_color, &set_me); do_blob(ui, &layout, &style->main.mark_color, &set_me); do_blob(ui, &layout, &style->main.highlight_color, &set_me); do_blob(ui, &layout, &style->main.at_highlight_color, &set_me); do_blob(ui, &layout, &style->main.default_color, &set_me); do_blob(ui, &layout, &style->main.comment_color, &set_me); do_blob(ui, &layout, &style->main.keyword_color, &set_me); do_blob(ui, &layout, &style->main.str_constant_color, &set_me); do_blob(ui, &layout, &style->main.char_constant_color, &set_me); do_blob(ui, &layout, &style->main.int_constant_color, &set_me); do_blob(ui, &layout, &style->main.float_constant_color, &set_me); do_blob(ui, &layout, &style->main.bool_constant_color, &set_me); do_blob(ui, &layout, &style->main.include_color, &set_me); do_blob(ui, &layout, &style->main.preproc_color, &set_me); do_blob(ui, &layout, &style->main.special_character_color, &set_me); do_blob(ui, &layout, &style->main.highlight_junk_color, &set_me); do_blob(ui, &layout, &style->main.highlight_white_color, &set_me); do_blob(ui, &layout, &style->main.paste_color, &set_me); do_blob(ui, &layout, &style->main.file_info_style.bar_color, &set_me); do_blob(ui, &layout, &style->main.file_info_style.base_color, &set_me); do_blob(ui, &layout, &style->main.file_info_style.pop1_color, &set_me); do_blob(ui, &layout, &style->main.file_info_style.pop2_color, &set_me); do_v_divide(ui, &layout, 20); if (!ui->state->input_stage){ Render_Target *target = ui->state->target; draw_string(target, ui->state->font_id, "Global Palette: right click to save color", layout.x, layout.rect.y0, style->main.default_color); } layout.rect.y0 += layout.size + layout.space; layout.y = layout.rect.y0; i32 palette_size = ui->palette_size + 1000; u32 *color = ui->palette; for (i32 i = 1000; i < palette_size; ++i, ++color){ set_me = 0; do_blob(ui, &layout, *color, &set_me, i); if (set_me){ *color = *ui->color.out; ui->state->redraw = 1; } } } internal void do_sub_button(i32 id, Color_UI *ui, char *text){ i16 font_id = ui->state->font_id; i32 line_height = get_font_info(ui->state->font_set, font_id)->height; i32_Rect rect = layout_rect(ui->layout, line_height + 2); if (ui->state->input_stage){ ui_do_button_input(ui->state, rect, make_sub0(ui->state, id), 1); } else{ Render_Target *target = ui->state->target; u32 back_color, text_color; text_color = 0xFFDDDDDD; if (ui->state->selected.sub_id0 == id){ back_color = 0xFF444444; } else if (ui->state->hover.sub_id0 == id){ back_color = 0xFF222222; } else{ back_color = 0xFF111111; } draw_rectangle(target, rect, back_color); draw_string(target, font_id, text, rect.x0, rect.y0 + 1, text_color); } } internal void do_color_adjuster(Color_UI *ui, u32 *color, u32 text_color, u32 back_color, char *name){ i32 id = raw_ptr_dif(color, ui->state->style); i16 font_id = ui->state->font_id; i32 character_h = get_font_info(ui->state->font_set, font_id)->height; u32 text = 0, back = 0; i32_Rect bar = layout_rect(ui->layout, character_h); if (ui->state->input_stage){ if (ui_do_button_input(ui->state, bar, make_id(ui->state, id), 1)){ ui->has_hover_color = 1; ui->hover_color = super_color_create(*color); } } else{ Render_Target *target = ui->state->target; u32 text_hover = 0xFF101010; u32 back_hover = 0xFF999999; if (ui->state->selected.id != id && ui->state->hover.id == id){ text = text_hover; back = back_hover; } else{ text = text_color; back = back_color; } draw_rectangle(target, bar, back); i32 end_pos = draw_string(target, font_id, name, bar.x0, bar.y0, text); real32 x_spacing = ui->hex_advance; i32_Rect temp_rect = bar; temp_rect.x0 = temp_rect.x1 - CEIL32(x_spacing * 9.f); if (temp_rect.x0 >= end_pos + x_spacing){ u32 n = *color; char full_hex_string[] = "0x000000"; for (i32 i = 7; i >= 2; --i){ i32 m = (n & 0xF); n >>= 4; full_hex_string[i] = int_to_hexchar(m); } draw_string_mono(target, font_id, full_hex_string, (f32)temp_rect.x0, (f32)bar.y0, x_spacing, text); } for (i32 i = 0; i < ArrayCount(ui->highlight.ids); ++i){ if (ui->highlight.ids[i] == id){ draw_rectangle_outline(target, f32R(bar), text_color); break; } } } if (ui->state->selected.id == id){ Render_Target *target = ui->state->target; i32_Rect expanded = layout_rect(ui->layout, 115 + (character_h + 2)); UI_Layout_Restore restore = begin_sub_layout(ui->layout, expanded); ui->color.out = color; if (ui->state->input_stage){ if (ui->state->selected.sub_id0 == 0){ ui->state->selected.sub_id0 = 1; } } else{ draw_rectangle(target, expanded, 0xff000000); } begin_row(ui->layout, 3); do_sub_button(1, ui, "HSL"); do_sub_button(2, ui, "RGB"); do_sub_button(3, ui, "Palette"); i32_Rect sub_rect; sub_rect = expanded; sub_rect.y0 += 10 + character_h; switch (ui->state->selected.sub_id0){ case 1: do_hsl_sliders(ui, sub_rect); break; case 2: do_rgb_sliders(ui, sub_rect); break; case 3: do_palette(ui, sub_rect); break; } end_sub_layout(restore); } } internal void do_style_name(Color_UI *ui){ i32 id = -3; i16 font_id = ui->state->font_id; i32 line_height = get_font_info(ui->state->font_set, font_id)->height; i32_Rect srect = layout_rect(ui->layout, line_height); Widget_ID wid = make_id(ui->state, id); b32 selected = is_selected(ui->state, wid); if (ui->state->input_stage){ if (!selected){ ui_do_button_input(ui->state, srect, wid, 1); } else{ Style *style = ui->state->style; if (ui_do_text_field_input(ui->state, &style->name)){ ui->state->selected = {}; } } } else{ Render_Target *target = ui->state->target; Style *style = ui->state->style; u32 back, fore_text, fore_label; if (selected){ back = 0xFF000000; fore_label = 0xFF808080; fore_text = 0xFFFFFFFF; } else if (is_hover(ui->state, wid)){ back = 0xFF999999; fore_text = fore_label = 0xFF101010; } else{ back = style->main.back_color; fore_text = fore_label = style->main.default_color; } draw_rectangle(target, srect, back); i32 x = srect.x0; x = draw_string(target, font_id, "NAME: ", x, srect.y0, fore_label); x = draw_string(target, font_id, style->name.str, x, srect.y0, fore_text); } } internal b32 do_font_option(Color_UI *ui, i16 font_id){ b32 result = 0; Font_Info *info = get_font_info(ui->state->font_set, font_id); i32 sub_id = (i32)(i64)(info); i32_Rect orect = layout_rect(ui->layout, info->height); Widget_ID wid = make_sub0(ui->state, sub_id); if (ui->state->input_stage){ if (ui_do_button_input(ui->state, orect, wid, 0)){ result = 1; } } else{ Render_Target *target = ui->state->target; u32 back, fore; if (is_hover(ui->state, wid)){ back = 0xFF999999; fore = 0xFF101010; } else{ back = 0xFF000000; fore = 0xFFFFFFFF; } draw_rectangle(target, orect, back); i32 x = orect.x0; x = draw_string(target, font_id, "->", x, orect.y0, fore); draw_string(target, font_id, info->name.str, x, orect.y0, fore); } return result; } internal void do_font_switch(Color_UI *ui){ i32 id = -2; Render_Target *target = ui->state->target; Font_Set *font_set = ui->state->font_set; i16 font_id = ui->state->font_id; Font_Info *info = get_font_info(font_set, font_id); i32 character_h = info->height; i32_Rect srect = layout_rect(ui->layout, character_h); Widget_ID wid = make_id(ui->state, id); if (ui->state->input_stage){ ui_do_button_input(ui->state, srect, wid, 1); } else{ Style *style = ui->state->style; u32 back, fore; if (is_hover(ui->state, wid) && !is_selected(ui->state, wid)){ back = 0xFF999999; fore = 0xFF101010; } else{ back = style->main.back_color; fore = style->main.default_color; } draw_rectangle(target, srect, back); i32 x = srect.x0; x = draw_string(target, font_id, "FONT: ", x, srect.y0, fore); x = draw_string(target, font_id, info->name.str, x, srect.y0, fore); } if (is_selected(ui->state, wid)){ srect = layout_rect(ui->layout, character_h/2); if (!ui->state->input_stage) draw_rectangle(target, srect, 0xFF000000); i32 count = font_set->count + 1; for (i16 i = 1; i < count; ++i){ if (i == font_id) continue; if (do_font_option(ui, i)){ ui->global_font->font_id = i; ui->global_font->font_changed = 1; } } srect = layout_rect(ui->layout, character_h/2); if (!ui->state->input_stage) draw_rectangle(target, srect, 0xFF000000); } } internal b32 do_style_preview(Library_UI *ui, Style *style, i32 toggle = -1){ b32 result = 0; i32 id; if (style == ui->state->style) id = 2; else id = raw_ptr_dif(style, ui->styles->styles) + 100; i16 font_id = ui->state->font_id; Font_Info *info = get_font_info(ui->state->font_set, font_id); i32_Rect prect = layout_rect(ui->layout, info->height*3 + 6); Widget_ID wid = make_id(ui->state, id); if (ui->state->input_stage){ if (ui_do_button_input(ui->state, prect, wid, 0)){ result = 1; } } else{ Render_Target *target = ui->state->target; u32 margin_color = style->main.margin_color; if (is_hover(ui->state, wid)){ margin_color = style->main.margin_active_color; } i32_Rect inner; if (toggle != -1){ i32_Rect toggle_box = prect; toggle_box.x1 = toggle_box.x0 + info->height*2 + 6; prect.x0 = toggle_box.x1; inner = get_inner_rect(toggle_box, 3); draw_margin(target, toggle_box, inner, margin_color); draw_rectangle(target, inner, style->main.back_color); i32 d; d = info->height/2; i32_Rect b; b.x0 = (inner.x1 + inner.x0)/2 - d; b.y0 = (inner.y1 + inner.y0)/2 - d; b.x1 = b.x0 + info->height; b.y1 = b.y0 + info->height; if (toggle) draw_rectangle(target, b, margin_color); else draw_rectangle_outline(target, b, margin_color); } inner = get_inner_rect(prect, 3); draw_margin(target, prect, inner, margin_color); draw_rectangle(target, inner, style->main.back_color); i32 text_y = inner.y0; i32 text_x = inner.x0; text_x = draw_string(target, font_id, style->name.str, text_x, text_y, style->main.default_color); i32 font_x = (i32)(inner.x1 - font_string_width(target, font_id, info->name.str)); if (font_x > text_x + 10) draw_string(target, font_id, info->name.str, font_x, text_y, style->main.default_color); text_x = inner.x0; text_y += info->height; text_x = draw_string(target, font_id, "if ", text_x, text_y, style->main.keyword_color); text_x = draw_string(target, font_id, "(x < ", text_x, text_y, style->main.default_color); text_x = draw_string(target, font_id, "0", text_x, text_y, style->main.int_constant_color); text_x = draw_string(target, font_id, ") { x = ", text_x, text_y, style->main.default_color); text_x = draw_string(target, font_id, "0", text_x, text_y, style->main.int_constant_color); text_x = draw_string(target, font_id, "; } ", text_x, text_y, style->main.default_color); text_x = draw_string(target, font_id, "// comment", text_x, text_y, style->main.comment_color); text_x = inner.x0; text_y += info->height; text_x = draw_string(target, font_id, "[] () {}; * -> +-/ <>= ! && || % ^", text_x, text_y, style->main.default_color); } ui->layout->y = prect.y1; return result; } // BOTTOM