From 6918ae0be46e84afaf61a0e6e244891c2fdd5c10 Mon Sep 17 00:00:00 2001 From: Allen Webster Date: Fri, 16 Oct 2015 16:31:04 -0400 Subject: [PATCH] separating golden_array --- 4coder_custom.cpp | 188 +++++++-- 4coder_custom.h | 232 ++++++++--- 4coder_custom_vim.cpp | 135 ------ 4coder_helper.h | 109 ++--- 4ed.cpp | 733 +++++++++++++++++++++++++-------- 4ed.h | 21 +- 4ed_color_view.cpp | 82 +--- 4ed_command.cpp | 11 +- 4ed_file_view.cpp | 630 ++++++++++++++++------------ 4ed_rendering.cpp | 9 + buffer/4coder_golden_array.cpp | 118 ++++++ win32_4ed.cpp | 4 - 12 files changed, 1439 insertions(+), 833 deletions(-) delete mode 100644 4coder_custom_vim.cpp create mode 100644 buffer/4coder_golden_array.cpp diff --git a/4coder_custom.cpp b/4coder_custom.cpp index 923f15d2..8dbddd71 100644 --- a/4coder_custom.cpp +++ b/4coder_custom.cpp @@ -3,59 +3,148 @@ */ // NOTE(allen): NEW THINGS TO LOOK FOR: -// MAPID_USER_CUSTOM - define maps other than the built in GLOBAL/FILE maps -// inherit_map +// mapid_user_custom - define maps other than the built in global and file maps +// +// inherit_map - override bindings or add new bindings in a new map with another +// +// set_hook - if you were using start_hook, it is still available if you use set_hook +// +// push_parameter - see description of parameter stack immediately below +// clear_parameters +// exec_command_keep_stack +// +// THE PARAMETER STACK: +// In this version I have introduced a parameter stack. +// Calls to commands through exec_command can now be parameterized +// by first pushing parameters onto that stack. This is achieved through +// the push_parameter. If you look at the signature for the function it +// uses a "Dynamic" struct, but 4coder_helper.h has overrides that accept +// ints or strings. The helper functions also take care of copying the +// strings inline into the stack so that you don't have to maintain your copy. +// +// If you'd like to optimize out the extra copy it will work, just use the +// main app.push_parameter and keep the memory of the string alive until +// the stack is cleared. +// +// A call to exec_command executes the command with the current stack, +// then clears the stack. To keep the stack use exec_command_keep_stack. +// +// If you would like to allocate your own memory, you can tie your memory +// to the parameter stack by calling push_memory which takes a cmd_context and len. +// It will return a char* to your memory block. Until you call clear_parameters +// or exec_command the memory will remain on the stack for you to use. Memory +// chunks on the stack are ignored by commands that use parameters, so your memory +// will not influence the behavior of any commands. // -// get_settings #include "4coder_custom.h" #include "4coder_helper.h" -#define exec_command app.exec_command -#define fulfill_interaction app.fulfill_interaction +#define exec_command_keep_stack app.exec_command_keep_stack +#define clear_parameters app.clear_parameters +#define get_active_buffer app.get_active_buffer -extern "C" START_HOOK_SIG(start_hook){ +#define exec_command(cmd_context, id) \ + exec_command_keep_stack(cmd_context, id); \ + clear_parameters(cmd_context) +#define push_parameter(cmd_context, ...) push_parameter_helper(cmd_context, app, __VA_ARGS__) +#define push_memory(cmd_context, len) app.push_memory(cmd_context, len) + +#define literal(s) s, (sizeof(s)-1) + +// NOTE(allen): All of your custom ids should be >= mapid_user_custom. +// I recommend enumerating your own map ids as shown here. +enum My_Maps{ + my_code_map = mapid_user_custom, +}; + +HOOK_SIG(my_start){ exec_command(cmd_context, cmdid_open_panel_vsplit); exec_command(cmd_context, cmdid_change_active_panel); } +CUSTOM_COMMAND_SIG(open_my_files){ + // NOTE(allen): The command cmdid_interactive_open has is now able to + // open a file specified on the parameter stack. If the file does not + // exist cmdid_interactive_open behaves as usual. + push_parameter(cmd_context, par_name, literal("w:/4ed/data/test/basic.cpp")); + exec_command(cmd_context, cmdid_interactive_open); + + exec_command(cmd_context, cmdid_change_active_panel); + + char my_file[256]; + int my_file_len; + + my_file_len = sizeof("w:/4ed/data/test/basic.txt") - 1; + for (int i = 0; i < my_file_len; ++i){ + my_file[i] = ("w:/4ed/data/test/basic.txt")[i]; + } + + // NOTE(allen): null terminators are not needed for strings. + push_parameter(cmd_context, par_name, my_file, my_file_len); + exec_command(cmd_context, cmdid_interactive_open); + + exec_command(cmd_context, cmdid_change_active_panel); +} + +char *get_extension(const char *filename, int len, int *extension_len){ + char *c = (char*)(filename + len - 1); + char *end = c; + while (*c != '.' && c > filename) --c; + *extension_len = (int)(end - c); + return c+1; +} + +bool str_match(const char *a, int len_a, const char *b, int len_b){ + bool result = 0; + if (len_a == len_b){ + char *end = (char*)(a + len_a); + while (a < end && *a == *b){ + ++a; ++b; + } + if (a == end) result = 1; + } + return result; +} + +HOOK_SIG(my_file_settings){ + Buffer_Summary buffer = get_active_buffer(cmd_context); + + int treat_as_code = 0; + + // NOTE(allen): This checks buffer.file_name just in case get_active_buffer returns back + // a null buffer (where every member is 0). + if (buffer.file_name && buffer.size < (16 << 20)){ + int extension_len; + char *extension = get_extension(buffer.file_name, buffer.file_name_len, &extension_len); + if (str_match(extension, extension_len, literal("cpp"))) treat_as_code = 1; + else if (str_match(extension, extension_len, literal("h"))) treat_as_code = 1; + else if (str_match(extension, extension_len, literal("c"))) treat_as_code = 1; + else if (str_match(extension, extension_len, literal("hpp"))) treat_as_code = 1; + } + + push_parameter(cmd_context, par_lex_as_cpp_file, treat_as_code); + push_parameter(cmd_context, par_wrap_lines, !treat_as_code); + push_parameter(cmd_context, par_key_mapid, (treat_as_code)?(my_code_map):(mapid_file)); + push_parameter(cmd_context, par_end_line_mode, EOL_USE_CRLF); + exec_command(cmd_context, cmdid_set_settings); +} + CUSTOM_COMMAND_SIG(open_in_other){ exec_command(cmd_context, cmdid_change_active_panel); exec_command(cmd_context, cmdid_interactive_open); } -extern "C" GET_BINDING_DATA(get_binding){ +extern "C" GET_BINDING_DATA(get_bindings){ Bind_Helper context_actual = begin_bind_helper(data, size); Bind_Helper *context = &context_actual; - begin_settings_group(context); + // NOTE(allen): Right now hooks have no loyalties to maps, all hooks are + // global and once set they always apply. + set_hook(context, hook_start, my_start); + set_hook(context, hook_open_file, my_file_settings); - use_when(context, when_default, 1); - - set(context, set_lex_as_cpp_file, 0); - set(context, set_wrap_lines, 1); - set(context, set_key_mapid, MAPID_FILE); - - // NOTE(allen): options include EOL_USE_CRLF, EOL_USE_CR_USE_LF, EOL_SHOW_CR_USE_LF - // EOL_USE_CRLF - treats a crlf and lf as newline markers, renders lone cr as special character "\r" - // EOL_USE_CR_USE_LF - treats both as separate newline markers - // EOL_SHOW_CR_USE_LF - treats lf as newline marker, renders cr as special character "\r" - set(context, set_end_line_mode, EOL_USE_CRLF); - - end_group(context); - - - begin_settings_group(context); - - use_when(context, when_extension, "cpp"); - use_when(context, when_extension, "hpp"); - use_when(context, when_extension, "c"); - use_when(context, when_extension, "h"); - - set(context, set_lex_as_cpp_file, 1); - set(context, set_key_mapid, MAPID_USER_CUSTOM + 0); - - begin_map(context, MAPID_GLOBAL); + begin_map(context, mapid_global); bind(context, 'p', MDFR_CTRL, cmdid_open_panel_vsplit); bind(context, '-', MDFR_CTRL, cmdid_open_panel_hsplit); @@ -68,19 +157,22 @@ extern "C" GET_BINDING_DATA(get_binding){ bind(context, 'c', MDFR_ALT, cmdid_open_color_tweaker); bind(context, 'x', MDFR_ALT, cmdid_open_menu); bind_me(context, 'o', MDFR_ALT, open_in_other); + // NOTE(allen): Go look at open_my_files, that's the only point of this being here. + bind_me(context, 'M', MDFR_ALT | MDFR_CTRL, open_my_files); end_map(context); - - begin_map(context, MAPID_USER_CUSTOM + 0); - - // NOTE(allen): Set this map (MAPID_USER_CUSTOM + 0) to - // inherit from MAPID_FILE. When searching if a key is bound - // in this map, if it is not found here it will then search MAPID_FILE. + + begin_map(context, my_code_map); + + // NOTE(allen): Set this map (my_code_map == mapid_user_custom) to + // inherit from mapid_file. When searching if a key is bound + // in this map, if it is not found here it will then search mapid_file. // - // If this is not set, it defaults to MAPID_GLOBAL. - inherit_map(context, MAPID_FILE); - + // If this is not set, it defaults to mapid_global. + inherit_map(context, mapid_file); + + // NOTE(allen): This demonstrates that children can override parent's bindings. bind(context, codes->right, MDFR_CTRL, cmdid_seek_alphanumeric_or_camel_right); bind(context, codes->left, MDFR_CTRL, cmdid_seek_alphanumeric_or_camel_left); @@ -90,7 +182,7 @@ extern "C" GET_BINDING_DATA(get_binding){ end_map(context); - begin_map(context, MAPID_FILE); + begin_map(context, mapid_file); // NOTE(allen): Binding this essentially binds all key combos that // would normally insert a character into a buffer. @@ -121,15 +213,21 @@ extern "C" GET_BINDING_DATA(get_binding){ bind(context, 'x', MDFR_CTRL, cmdid_cut); bind(context, 'v', MDFR_CTRL, cmdid_paste); bind(context, 'V', MDFR_CTRL, cmdid_paste_next); + bind(context, 'Z', MDFR_CTRL, cmdid_timeline_scrub); bind(context, 'z', MDFR_CTRL, cmdid_undo); bind(context, 'y', MDFR_CTRL, cmdid_redo); + bind(context, codes->left, MDFR_ALT, cmdid_increase_rewind_speed); + bind(context, codes->right, MDFR_ALT, cmdid_increase_fastforward_speed); + bind(context, codes->down, MDFR_ALT, cmdid_stop_rewind_fastforward); + bind(context, 'h', MDFR_CTRL, cmdid_history_backward); + bind(context, 'H', MDFR_CTRL, cmdid_history_forward); bind(context, 'd', MDFR_CTRL, cmdid_delete_chunk); bind(context, 'l', MDFR_CTRL, cmdid_toggle_line_wrap); bind(context, 'L', MDFR_CTRL, cmdid_toggle_endline_mode); bind(context, 'u', MDFR_CTRL, cmdid_to_uppercase); bind(context, 'j', MDFR_CTRL, cmdid_to_lowercase); bind(context, '?', MDFR_CTRL, cmdid_toggle_show_whitespace); - + // NOTE(allen): These whitespace manipulators are not currently functional bind(context, '`', MDFR_CTRL, cmdid_clean_line); bind(context, '~', MDFR_CTRL, cmdid_clean_all_lines); diff --git a/4coder_custom.h b/4coder_custom.h index d26117a9..8af73613 100644 --- a/4coder_custom.h +++ b/4coder_custom.h @@ -70,8 +70,14 @@ enum Command_ID{ cmdid_paste, cmdid_paste_next, cmdid_delete_chunk, + cmdid_timeline_scrub, cmdid_undo, cmdid_redo, + cmdid_increase_rewind_speed, + cmdid_increase_fastforward_speed, + cmdid_stop_rewind_fastforward, + cmdid_history_backward, + cmdid_history_forward, cmdid_interactive_new, cmdid_interactive_open, cmdid_reopen, @@ -108,106 +114,202 @@ enum Command_ID{ cmdid_close_minor_view, cmdid_cursor_mark_swap, cmdid_open_menu, + cmdid_set_settings, // cmdid_count }; +enum Param_ID{ + par_name, + par_lex_as_cpp_file, + par_wrap_lines, + par_key_mapid, + par_end_line_mode, + // never below this + par_type_count +}; + +enum Hook_ID{ + hook_start, + hook_open_file, + // never below this + hook_type_count +}; + +enum Dynamic_Type{ + dynamic_type_int, + dynamic_type_string, + // never below this + dynamic_type_count +}; + +struct Dynamic{ + int type; + union{ + struct{ + int str_len; + char *str_value; + }; + int int_value; + }; +}; + +inline Dynamic +dynamic_int(int x){ + Dynamic result; + result.type = dynamic_type_int; + result.int_value = x; + return result; +} + +inline Dynamic +dynamic_string(const char *string, int len){ + Dynamic result; + result.type = dynamic_type_string; + result.str_len = len; + result.str_value = (char*)(string); + return result; +} + +inline int +dynamic_to_int(Dynamic *dynamic){ + int result = 0; + if (dynamic->type == dynamic_type_int){ + result = dynamic->int_value; + } + return result; +} + +inline char* +dynamic_to_string(Dynamic *dynamic, int *len){ + char *result = 0; + if (dynamic->type == dynamic_type_string){ + result = dynamic->str_value; + *len = dynamic->str_len; + } + return result; +} + +inline int +dynamic_to_bool(Dynamic *dynamic){ + int result = 0; + if (dynamic->type == dynamic_type_int){ + result = (dynamic->int_value != 0); + } + else{ + result = 1; + } + return result; +} + struct Extra_Font{ char file_name[256]; char font_name[24]; int size; }; -#define GET_BINDING_DATA(name) int name(void *data, int size, Key_Codes *codes) -#define SET_EXTRA_FONT_SIG(name) void name(Extra_Font *font_out) -#define CUSTOM_COMMAND_SIG(name) void name(void *cmd_context, struct Application_Links app) -#define START_HOOK_SIG(name) void name(void *cmd_context, struct Application_Links app) - -extern "C"{ - typedef CUSTOM_COMMAND_SIG(Custom_Command_Function); - typedef GET_BINDING_DATA(Get_Binding_Data_Function); - typedef SET_EXTRA_FONT_SIG(Set_Extra_Font_Function); - typedef START_HOOK_SIG(Start_Hook_Function); -} - -#define EXECUTE_COMMAND_SIG(name) void name(void *cmd_context, int command_id) -#define FULFILL_INTERACTION_SIG(name) void name(void *cmd_context, char *data, bool full_set) - -extern "C"{ - typedef EXECUTE_COMMAND_SIG(Exec_Command_Function); - typedef FULFILL_INTERACTION_SIG(Fulfill_Interaction_Function); -} - -struct Application_Links{ - Exec_Command_Function *exec_command; - Fulfill_Interaction_Function *fulfill_interaction; -}; - -enum Settings_Unit_Type{ - SUNIT_HEADER, - SUNIT_GROUP, - SUNIT_USE_CLAUSE, - SUNIT_USE_CLAUSE_STRING, - SUNIT_SETTING -}; - -enum Setting_ID{ - set_lex_as_cpp_file, - set_wrap_lines, - set_key_mapid, - set_end_line_mode -}; - -enum Setting_When_Type{ - when_default, - when_extension -}; - -enum End_Of_Line_Options{ +enum EOL_Option{ EOL_USE_CRLF, EOL_USE_CR_USE_LF, EOL_SHOW_CR_USE_LF }; +struct Buffer_Summary{ + // NOTE(allen): None of these members nor any of the data pointed to + // by these members should be modified. + int file_id; + + int size; + const char *data; + + int file_name_len; + int buffer_name_len; + const char *file_name; + const char *buffer_name; + + int file_cursor_pos; + + EOL_Option eol_mode; + int is_lexed; + + int map_id; +}; + +#define GET_BINDING_DATA(name) int name(void *data, int size, Key_Codes *codes) +#define SET_EXTRA_FONT_SIG(name) void name(Extra_Font *font_out) +#define CUSTOM_COMMAND_SIG(name) void name(void *cmd_context, struct Application_Links app) +#define HOOK_SIG(name) void name(void *cmd_context, struct Application_Links app) + +extern "C"{ + typedef CUSTOM_COMMAND_SIG(Custom_Command_Function); + typedef GET_BINDING_DATA(Get_Binding_Data_Function); + typedef SET_EXTRA_FONT_SIG(Set_Extra_Font_Function); + typedef HOOK_SIG(Hook_Function); +} + +#define PUSH_PARAMETER_SIG(name) void name(void *cmd_context, Dynamic param, Dynamic value) +#define PUSH_MEMORY_SIG(name) char* name(void *cmd_context, int len) +#define EXECUTE_COMMAND_SIG(name) void name(void *cmd_context, int command_id) +#define CLEAR_PARAMETERS_SIG(name) void name(void *cmd_context) +#define GET_ACTIVE_BUFFER_SIG(name) Buffer_Summary name(void *cmd_context) + +extern "C"{ + typedef EXECUTE_COMMAND_SIG(Exec_Command_Function); + typedef PUSH_PARAMETER_SIG(Push_Parameter_Function); + typedef PUSH_MEMORY_SIG(Push_Memory_Function); + typedef CLEAR_PARAMETERS_SIG(Clear_Parameters_Function); + typedef GET_ACTIVE_BUFFER_SIG(Get_Active_Buffer_Function); +} + +struct Application_Links{ + Exec_Command_Function *exec_command_keep_stack; + Push_Parameter_Function *push_parameter; + Push_Memory_Function *push_memory; + Clear_Parameters_Function *clear_parameters; + Get_Active_Buffer_Function *get_active_buffer; +}; + +// NOTE(allen): definitions for the buffer that communicates to 4ed.exe + enum Binding_Unit_Type{ - UNIT_HEADER, - UNIT_MAP_BEGIN, - UNIT_BINDING, - UNIT_CALLBACK, - UNIT_INHERIT, - UNIT_SETTINGS_BEGIN, - UNIT_USE_CLAUSE, - UNIT_USE_CLAUSE_STRING, - UNIT_SETTING + unit_header, + unit_map_begin, + unit_binding, + unit_callback, + unit_inherit, + unit_hook }; enum Map_ID{ - MAPID_GLOBAL, - MAPID_FILE, - MAPID_USER_CUSTOM + mapid_global, + mapid_file, + // NOTE(allen): mapid_nomap will remain empty even if you attempt to fill it + // it is for setting a map's parent to nothing + mapid_nomap, + mapid_user_custom = 100 }; struct Binding_Unit{ Binding_Unit_Type type; union{ - struct{ int total_size; int map_count; int group_count; int error; } header; + struct{ int total_size; int user_map_count; int error; } header; struct{ int mapid; int bind_count; } map_begin; struct{ int mapid; } map_inherit; struct{ - int command_id; short code; unsigned char modifiers; + int command_id; } binding; struct{ - Custom_Command_Function *func; short code; unsigned char modifiers; + Custom_Command_Function *func; } callback; - - struct{ int clause_type; int value; } use_clause; - struct{ int clause_type; int len; char *value; } use_clause_string; - struct{ int setting_id; int value; } setting; + struct{ + int hook_id; + Custom_Command_Function *func; + } hook; }; }; diff --git a/4coder_custom_vim.cpp b/4coder_custom_vim.cpp deleted file mode 100644 index 81a0348d..00000000 --- a/4coder_custom_vim.cpp +++ /dev/null @@ -1,135 +0,0 @@ -/* - * This is an example of how vim-keys might start - * to work in 4coder, through the customization API. - */ - -#include "4coder_custom.h" -#include "4coder_helper.h" - -#define exec_command app.exec_command -#define fulfill_interaction app.fulfill_interaction - -extern "C" START_HOOK_SIG(start_hook){ - exec_command(cmd_context, cmdid_open_panel_vsplit); - exec_command(cmd_context, cmdid_change_active_panel); -} - - -extern "C" GET_BINDING_DATA(get_binding){ - Bind_Helper context_actual = begin_bind_helper(data, size); - Bind_Helper *context = &context_actual; - - begin_settings_group(context); - - use_when(context, when_default, 1); - - set(context, set_lex_as_cpp_file, 0); - set(context, set_wrap_lines, 1); - set(context, set_key_mapid, MAPID_FILE); - - // NOTE(allen): options include EOL_USE_CRLF, EOL_USE_CR_USE_LF, EOL_SHOW_CR_USE_LF - // EOL_USE_CRLF - treats a crlf and lf as newline markers, renders lone cr as special character "\r" - // EOL_USE_CR_USE_LF - treats both as separate newline markers - // EOL_SHOW_CR_USE_LF - treats lf as newline marker, renders cr as special character "\r" - set(context, set_end_line_mode, EOL_USE_CRLF); - - end_group(context); - - - begin_settings_group(context); - - use_when(context, when_extension, "cpp"); - use_when(context, when_extension, "hpp"); - use_when(context, when_extension, "c"); - use_when(context, when_extension, "h"); - - set(context, set_lex_as_cpp_file, 1); - set(context, set_key_mapid, MAPID_USER_CUSTOM + 0); - - begin_map(context, MAPID_GLOBAL); - - bind(context, 'p', MDFR_CTRL, cmdid_open_panel_vsplit); - bind(context, '-', MDFR_CTRL, cmdid_open_panel_hsplit); - bind(context, 'P', MDFR_CTRL, cmdid_close_panel); - bind(context, 'n', MDFR_CTRL, cmdid_interactive_new); - bind(context, 'o', MDFR_CTRL, cmdid_interactive_open); - bind(context, ',', MDFR_CTRL, cmdid_change_active_panel); - bind(context, 'k', MDFR_CTRL, cmdid_interactive_kill_buffer); - bind(context, 'i', MDFR_CTRL, cmdid_interactive_switch_buffer); - bind(context, 'c', MDFR_ALT, cmdid_open_color_tweaker); - bind(context, 'x', MDFR_ALT, cmdid_open_menu); - bind_me(context, 'o', MDFR_ALT, open_in_other); - - end_map(context); - - - begin_map(context, MAPID_USER_CUSTOM + 0); - inherit_map(context, MAPID_FILE); - end_map(context); - - int sub_id; - begin_map(context, MAPID_FILE); - - sub_id = begin_sub_map(context); - { - bind_vanilla_keys(context, cmdid_write_character); - - bind(context, codes->left, MDFR_NONE, cmdid_move_left); - bind(context, codes->right, MDFR_NONE, cmdid_move_right); - bind(context, codes->del, MDFR_NONE, cmdid_delete); - bind(context, codes->back, MDFR_NONE, cmdid_backspace); - bind(context, codes->up, MDFR_NONE, cmdid_move_up); - bind(context, codes->down, MDFR_NONE, cmdid_move_down); - bind(context, codes->end, MDFR_NONE, cmdid_seek_end_of_line); - bind(context, codes->home, MDFR_NONE, cmdid_seek_beginning_of_line); - bind(context, codes->page_up, MDFR_NONE, cmdid_page_up); - bind(context, codes->page_down, MDFR_NONE, cmdid_page_down); - } - end_sub_map(context); - - bind_params(context, 'i', MDFR_NONE, cmdid_use_sub_map); - fill_param(context, "sub_id", sub_id); - end_params(context); - - bind_multi(context, 'a', MDFR_NONE); - { - bind(context, 'a', MDFR_NONE, cmdid_move_left); - bind_params(context, 'a', MDFR_NONE, cmdid_use_sub_map); - fill_param(context, "sub_id", sub_id); - end_params(context); - } - end_multi(context); - - bind(context, 'b', cmdid_seek_alphanumeric_left); - bind(context, 'w', cmdid_seek_alphanumeric_right); - bind(context, 'e', cmdid_seek_white_or_token_right); - - // ???? this seems a bit off - bind_compound(context, 'g'); - { - bind(context, 'e', cmdid_seek_white_or_token_left); - } - end_compound(context); - - end_map(context); - end_bind_helper(context); - - return context->write_total; -} - -inline void -strset_(char *dst, char *src){ - do{ - *dst++ = *src++; - }while (*src); -} - -#define strset(d,s) if (sizeof(s) <= sizeof(d)) strset_(d,s) - -extern "C" SET_EXTRA_FONT_SIG(set_extra_font){ - strset(font_out->file_name, "liberation-mono.ttf"); - strset(font_out->font_name, "BIG"); - font_out->size = 25; -} - - diff --git a/4coder_helper.h b/4coder_helper.h index be5c3ac0..9e502b16 100644 --- a/4coder_helper.h +++ b/4coder_helper.h @@ -14,15 +14,8 @@ struct Bind_Helper{ #define BH_ERR_MISSING_BEGIN 2 #define BH_ERR_OUT_OF_MEMORY 3 -inline int -seek_null(char *str){ - char *start = str; - while (*str) ++str; - return (int)(str - start); -} - inline void -copy(char *dest, char *src, int len){ +copy(char *dest, const char *src, int len){ for (int i = 0; i < len; ++i){ *dest++ = *src++; } @@ -73,11 +66,10 @@ begin_bind_helper(void *data, int size){ result.end = result.start + size / sizeof(*result.cursor); Binding_Unit unit; - unit.type = UNIT_HEADER; + unit.type = unit_header; unit.header.total_size = sizeof(*result.header); result.header = write_unit(&result, unit); - result.header->header.map_count = 0; - result.header->header.group_count = 0; + result.header->header.user_map_count = 0; return result; } @@ -85,10 +77,10 @@ begin_bind_helper(void *data, int size){ inline void begin_map(Bind_Helper *helper, int mapid){ if (helper->group != 0 && helper->error == 0) helper->error = BH_ERR_MISSING_END; - if (!helper->error) ++helper->header->header.map_count; + if (!helper->error && mapid >= mapid_user_custom) ++helper->header->header.user_map_count; Binding_Unit unit; - unit.type = UNIT_MAP_BEGIN; + unit.type = unit_map_begin; unit.map_begin.mapid = mapid; helper->group = write_unit(helper, unit); helper->group->map_begin.bind_count = 0; @@ -106,7 +98,7 @@ bind(Bind_Helper *helper, short code, unsigned char modifiers, int cmdid){ if (!helper->error) ++helper->group->map_begin.bind_count; Binding_Unit unit; - unit.type = UNIT_BINDING; + unit.type = unit_binding; unit.binding.command_id = cmdid; unit.binding.code = code; unit.binding.modifiers = modifiers; @@ -120,7 +112,7 @@ bind_me(Bind_Helper *helper, short code, unsigned char modifiers, Custom_Command if (!helper->error) ++helper->group->map_begin.bind_count; Binding_Unit unit; - unit.type = UNIT_CALLBACK; + unit.type = unit_callback; unit.callback.func = func; unit.callback.code = code; unit.callback.modifiers = modifiers; @@ -141,14 +133,25 @@ bind_me_vanilla_keys(Bind_Helper *helper, Custom_Command_Function *func){ inline void inherit_map(Bind_Helper *helper, int mapid){ if (helper->group == 0 && helper->error == 0) helper->error = BH_ERR_MISSING_BEGIN; + if (!helper->error && mapid >= mapid_user_custom) ++helper->header->header.user_map_count; Binding_Unit unit; - unit.type = UNIT_INHERIT; + unit.type = unit_inherit; unit.map_inherit.mapid = mapid; write_unit(helper, unit); } +inline void +set_hook(Bind_Helper *helper, int hook_id, Custom_Command_Function *func){ + Binding_Unit unit; + unit.type = unit_hook; + unit.hook.hook_id = hook_id; + unit.hook.func = func; + + write_unit(helper, unit); +} + inline void end_bind_helper(Bind_Helper *helper){ if (helper->header){ @@ -157,72 +160,32 @@ end_bind_helper(Bind_Helper *helper){ } } +// NOTE(allen): Useful functions and overloads on app links inline void -begin_settings_group(Bind_Helper *helper){ - if (helper->group != 0 && helper->error == 0) helper->error = BH_ERR_MISSING_END; - if (!helper->error) ++helper->header->header.group_count; - - Binding_Unit unit; - unit.type = UNIT_SETTINGS_BEGIN; - helper->group = write_unit(helper, unit); +push_parameter_helper(void *cmd_context, Application_Links app, int param, int value){ + app.push_parameter(cmd_context, dynamic_int(param), dynamic_int(value)); } inline void -end_group(Bind_Helper *helper){ - if (helper->group == 0 && helper->error == 0) helper->error = BH_ERR_MISSING_BEGIN; - helper->group = 0; +push_parameter_helper(void *cmd_context, Application_Links app, int param, const char *value, int value_len){ + char *value_copy = app.push_memory(cmd_context, value_len); + copy(value_copy, value, value_len); + app.push_parameter(cmd_context, dynamic_int(param), dynamic_string(value_copy, value_len)); } inline void -use_when(Bind_Helper *helper, int clause_type, int value){ - if (helper->group == 0 && helper->error == 0) helper->error = BH_ERR_MISSING_BEGIN; - - Binding_Unit unit; - unit.type = UNIT_USE_CLAUSE; - unit.use_clause.clause_type = clause_type; - unit.use_clause.value = value; - write_unit(helper, unit); +push_parameter_helper(void *cmd_context, Application_Links app, const char *param, int param_len, int value){ + char *param_copy = app.push_memory(cmd_context, param_len); + copy(param_copy, param, param_len); + app.push_parameter(cmd_context, dynamic_string(param_copy, param_len), dynamic_int(value)); } inline void -use_when(Bind_Helper *helper, int clause_type, char *value){ - if (helper->group == 0 && helper->error == 0) helper->error = BH_ERR_MISSING_BEGIN; - - Binding_Unit unit; - unit.type = UNIT_USE_CLAUSE; - unit.use_clause_string.clause_type = clause_type; - unit.use_clause_string.len = seek_null(value); - Binding_Unit *u = write_unit(helper, unit); - u->use_clause_string.value = write_inline_string(helper, value, unit.use_clause_string.len); -} - -inline void -use_when(Bind_Helper *helper, int clause_type, char *value, int len){ - if (helper->group == 0 && helper->error == 0) helper->error = BH_ERR_MISSING_BEGIN; - - Binding_Unit unit; - unit.type = UNIT_USE_CLAUSE; - unit.use_clause_string.clause_type = clause_type; - unit.use_clause_string.len = len; - unit.use_clause_string.value = value; - write_unit(helper, unit); -} - -inline void -set(Bind_Helper *helper, int setting_id, int value){ - if (helper->group == 0 && helper->error == 0) helper->error = BH_ERR_MISSING_BEGIN; - - Binding_Unit unit; - unit.type = UNIT_SETTING; - unit.setting.setting_id = setting_id; - unit.setting.value = value; - write_unit(helper, unit); -} - -inline void -end_settings_helper(Bind_Helper *helper){ - if (helper->header){ - helper->header->header.error = helper->error; - } +push_parameter_helper(void *cmd_context, Application_Links app, const char *param, int param_len, const char *value, int value_len){ + char *param_copy = app.push_memory(cmd_context, param_len); + char *value_copy = app.push_memory(cmd_context, value_len); + copy(param_copy, param, param_len); + copy(value_copy, value, value_len); + app.push_parameter(cmd_context, dynamic_string(param_copy, param_len), dynamic_string(value_copy, value_len)); } diff --git a/4ed.cpp b/4ed.cpp index a9fe27f7..1c3c5db6 100644 --- a/4ed.cpp +++ b/4ed.cpp @@ -103,6 +103,11 @@ struct App_Vars{ #if FRED_INTERNAL Command_Map map_debug; #endif + Command_Map *user_maps; + i32 *map_id_table; + i32 user_map_count; + + Custom_Command_Function *hooks[hook_type_count]; Font_Set fonts; @@ -132,6 +137,48 @@ struct App_Vars{ Panel *prev_mouse_panel; }; +internal i32 +app_get_or_add_map_index(App_Vars *vars, i32 mapid){ + i32 result; + i32 user_map_count = vars->user_map_count; + i32 *map_id_table = vars->map_id_table; + for (result = 0; result < user_map_count; ++result){ + if (map_id_table[result] == mapid) break; + if (map_id_table[result] == 0){ + map_id_table[result] = mapid; + break; + } + } + return result; +} + +internal i32 +app_get_map_index(App_Vars *vars, i32 mapid){ + i32 result; + i32 user_map_count = vars->user_map_count; + i32 *map_id_table = vars->map_id_table; + for (result = 0; result < user_map_count; ++result){ + if (map_id_table[result] == mapid) break; + if (map_id_table[result] == 0){ + result = user_map_count; + break; + } + } + return result; +} + +internal Command_Map* +app_get_map(App_Vars *vars, i32 mapid){ + Command_Map *map = 0; + if (mapid >= mapid_user_custom) + map = vars->user_maps + mapid - mapid_user_custom; + else if (mapid == mapid_global) + map = &vars->map_top; + else if (mapid == mapid_file) + map = &vars->map_file; + return map; +} + // Commands globalvar Application_Links app_links; @@ -148,7 +195,7 @@ globalvar Application_Links app_links; #define REQ_VIEW(n) View *n = command->view; if (!n) return #define REQ_FILE_VIEW(n) File_View *n = view_to_file_view(command->view); if (!n) return -#define REQ_FILE(n,v) Editing_File *n = (v)->file; if (!n || !n->data || n->is_dummy) return +#define REQ_FILE(n,v) Editing_File *n = (v)->file; if (!n || !n->buffer.data || n->is_dummy) return #define REQ_COLOR_VIEW(n) Color_View *n = view_to_color_view(command->view); if (!n) return #define REQ_DBG_VIEW(n) Debug_View *n = view_to_debug_view(command->view); if (!n) return @@ -167,8 +214,51 @@ struct Command_Data{ i32 screen_width, screen_height; Key_Single key; + + Partition part; }; +struct Command_Parameter{ + i32 type; + union{ + struct{ + Dynamic param; + Dynamic value; + } param; + struct{ + i32 len; + char *str; + } inline_string; + }; +}; + +inline Command_Parameter* +param_next(Command_Parameter *param, Command_Parameter *end){ + Command_Parameter *result = param; + if (result->type == 0){ + ++result; + } + while (result->type != 0 && result < end){ + i32 len = result->inline_string.len; + len += sizeof(*result) - 1; + len -= (len % sizeof(*result)); + result = (Command_Parameter*)((char*)result + len + sizeof(*result)); + } + return result; +} + +inline Command_Parameter* +param_stack_first(Partition *part, Command_Parameter *end){ + Command_Parameter *result = (Command_Parameter*)part->base; + if (result->type != 0) result = param_next(result, end); + return result; +} + +inline Command_Parameter* +param_stack_end(Partition *part){ + return (Command_Parameter*)((char*)part->base + part->pos); +} + COMMAND_DECL(null){ AllowLocal(command); } @@ -183,7 +273,7 @@ COMMAND_DECL(write_character){ u8 character = (u8)command->key.key.character; char str_space[2]; String string = make_string(str_space, 2); - if (character == '\n' && file->endline_mode == ENDLINE_RN_COMBINED){ + if (character == '\n' && file->endline_mode == EOL_USE_CRLF){ str_space[0] = '\r'; str_space[1] = '\n'; string.size = 2; @@ -232,7 +322,7 @@ COMMAND_DECL(seek_whitespace_right){ REQ_FILE(file, view); i32 pos = seek_whitespace_right( - file->data, file->size, view->cursor.pos); + (u8*)file->buffer.data, file->buffer.size, view->cursor.pos); view_cursor_move(view, pos); } @@ -243,7 +333,7 @@ COMMAND_DECL(seek_whitespace_left){ REQ_FILE(file, view); i32 pos = seek_whitespace_left( - file->data, view->cursor.pos); + (u8*)file->buffer.data, view->cursor.pos); view_cursor_move(view, pos); } @@ -253,7 +343,7 @@ COMMAND_DECL(seek_whitespace_up){ REQ_FILE_VIEW(view); REQ_FILE(file, view); - u8* data = file->data; + char* data = file->buffer.data; u32 pos = view->cursor.pos; while (pos > 0 && char_is_whitespace(data[pos])){ --pos; @@ -281,8 +371,8 @@ COMMAND_DECL(seek_whitespace_up){ ++pos; } - if (file->endline_mode == ENDLINE_RN_COMBINED){ - pos = pos_adjust_to_self(pos, data, file->size); + if (file->endline_mode == EOL_USE_CRLF){ + pos = pos_adjust_to_self(pos, (u8*)data, file->buffer.size); } view_cursor_move(view, pos); @@ -293,8 +383,8 @@ COMMAND_DECL(seek_whitespace_down){ REQ_FILE_VIEW(view); REQ_FILE(file, view); - i32 size = file->size; - u8* data = file->data; + i32 size = file->buffer.size; + char* data = file->buffer.data; i32 pos = view->cursor.pos; while (pos < size && char_is_whitespace(data[pos])){ ++pos; @@ -387,11 +477,11 @@ COMMAND_DECL(seek_white_or_token_right){ REQ_FILE(file, view); i32 token_pos, white_pos; - token_pos = file->size; + token_pos = file->buffer.size; if (file->tokens_complete){ token_pos = seek_token_right(&file->token_stack, view->cursor.pos); } - white_pos = seek_whitespace_right(file->data, file->size, view->cursor.pos); + white_pos = seek_whitespace_right((u8*)file->buffer.data, file->buffer.size, view->cursor.pos); view_cursor_move(view, Min(token_pos, white_pos)); } @@ -401,11 +491,11 @@ COMMAND_DECL(seek_white_or_token_left){ REQ_FILE(file, view); i32 token_pos, white_pos; - token_pos = file->size; + token_pos = file->buffer.size; if (file->tokens_complete){ token_pos = seek_token_left(&file->token_stack, view->cursor.pos); } - white_pos = seek_whitespace_left(file->data, view->cursor.pos); + white_pos = seek_whitespace_left((u8*)file->buffer.data, view->cursor.pos); view_cursor_move(view, Max(token_pos, white_pos)); } @@ -439,7 +529,7 @@ COMMAND_DECL(seek_alphanumeric_right){ REQ_FILE(file, view); i32 pos = seek_alphanumeric_right( - file->data, file->size, view->cursor.pos); + (u8*)file->buffer.data, file->buffer.size, view->cursor.pos); view_cursor_move(view, pos); } @@ -449,7 +539,7 @@ COMMAND_DECL(seek_alphanumeric_left){ REQ_FILE(file, view); i32 pos = seek_alphanumeric_left( - file->data, view->cursor.pos); + (u8*)file->buffer.data, view->cursor.pos); view_cursor_move(view, pos); } @@ -458,11 +548,11 @@ COMMAND_DECL(seek_alphanumeric_or_camel_right){ REQ_FILE_VIEW(view); REQ_FILE(file, view); - u8 *data = file->data; + char *data = file->buffer.data; i32 an_pos, camel_pos; an_pos = seek_alphanumeric_right( - file->data, file->size, view->cursor.pos); + (u8*)file->buffer.data, file->buffer.size, view->cursor.pos); u8 curr_char; u8 prev_char = data[view->cursor.pos + 1]; @@ -482,7 +572,7 @@ COMMAND_DECL(seek_alphanumeric_or_camel_left){ REQ_FILE_VIEW(view); REQ_FILE(file, view); - u8 *data = file->data; + u8 *data = (u8*)file->buffer.data; i32 an_pos, camel_pos; an_pos = seek_alphanumeric_left( @@ -554,7 +644,7 @@ COMMAND_DECL(copy){ Range range = get_range(view->cursor.pos, view->mark); if (range.start < range.end){ - u8 *data = file->data; + u8 *data = (u8*)file->buffer.data; clipboard_copy(&mem->general, working_set, data, range); } } @@ -569,14 +659,14 @@ COMMAND_DECL(cut){ Range range = get_range(view->cursor.pos, view->mark); if (range.start < range.end){ - u8 *data = file->data; + u8 *data = (u8*)file->buffer.data; i32 next_cursor_pos = range.start; clipboard_copy(&mem->general, working_set, data, range); view_replace_range(mem, view, layout, range.start, range.end, 0, 0, next_cursor_pos); view->mark = pos_universal_fix(range.start, - file->data, file->size, + (u8*)file->buffer.data, file->buffer.size, file->endline_mode); view_measure_wraps(&mem->general, view); view_cursor_move(view, next_cursor_pos); @@ -602,7 +692,7 @@ COMMAND_DECL(paste){ view_cursor_move(view, next_cursor_pos); view->mark = pos_universal_fix(pos_left, - file->data, file->size, + (u8*)file->buffer.data, file->buffer.size, file->endline_mode); Editing_Layout *layout = command->layout; @@ -639,7 +729,7 @@ COMMAND_DECL(paste_next){ view_cursor_move(view, next_cursor_pos); view->mark = pos_universal_fix(range.start, - file->data, file->size, + (u8*)file->buffer.data, file->buffer.size, file->endline_mode); Editing_Layout *layout = command->layout; @@ -674,17 +764,19 @@ COMMAND_DECL(delete_chunk){ view_measure_wraps(&mem->general, view); view_cursor_move(view, next_cursor_pos); view->mark = pos_universal_fix(range.start, - file->data, file->size, + (u8*)file->buffer.data, file->buffer.size, file->endline_mode); } } -COMMAND_DECL(undo_scrub){ +COMMAND_DECL(timeline_scrub){ ProfileMomentFunction(); REQ_FILE_VIEW(view); REQ_FILE(file, view); - view_set_widget(view, FWIDG_UNDOING); + view_set_widget(view, FWIDG_TIMELINES); + view->widget.timeline.undo_line = 1; + view->widget.timeline.history_line = 1; } COMMAND_DECL(undo){ @@ -731,21 +823,13 @@ COMMAND_DECL(increase_fastforward_speed){ view->rewind_speed = -neg_rewind_speed * 0.25f; } -COMMAND_DECL(stop_rewind_and_fastforward){ +COMMAND_DECL(stop_rewind_fastforward){ ProfileMomentFunction(); REQ_FILE_VIEW(view); view->rewind_speed = 0; } -COMMAND_DECL(history_scrub){ - ProfileMomentFunction(); - REQ_FILE_VIEW(view); - REQ_FILE(file, view); - - view_set_widget(view, FWIDG_RESTORING); -} - COMMAND_DECL(history_backward){ ProfileMomentFunction(); REQ_FILE_VIEW(view); @@ -788,6 +872,60 @@ COMMAND_DECL(interactive_new){ copy(&int_view->query, "New: "); } +internal File_View* +app_open_file(App_Vars *vars, General_Memory *general, Panel *panel, + Working_Set *working_set, String *string, Style *style, + Live_Views *live_set, Command_Data *command_data){ + File_View *result = 0; + Editing_File *target_file = 0; + bool32 created_file = 0; + + target_file = working_set_contains(working_set, *string); + if (!target_file){ + Get_File_Result file = working_set_get_available_file(working_set); + if (file.file){ + buffer_get_dummy(file.file); + created_file = buffer_create(general, file.file, (u8*)string->str, style->font); + table_add(&working_set->table, file.file->source_path, file.index); + if (created_file){ + target_file = file.file; + } + } + } + + if (target_file){ + View *new_view = live_set_alloc_view(live_set, &vars->mem); + + view_replace_major(new_view, panel, live_set); + + File_View *file_view = file_view_init(new_view, &vars->delay, &vars->layout); + result = file_view; + + View *old_view = command_data->view; + command_data->view = new_view; + + Partition old_part = command_data->part; + Temp_Memory temp = begin_temp_memory(&vars->mem.part); + command_data->part = partition_sub_part(&vars->mem.part, 16 << 10); + + view_set_file(file_view, target_file, style, + vars->hooks[hook_open_file], command_data, app_links); + + command_data->part = old_part; + end_temp_memory(temp); + + command_data->view = old_view; + + new_view->map = app_get_map(vars, target_file->base_map_id); + + if (created_file && target_file->tokens_exist) + buffer_first_lex_parallel(general, target_file); + } + + return result; +} + + COMMAND_DECL(interactive_open){ ProfileMomentFunction(); USE_VARS(vars); @@ -798,16 +936,41 @@ COMMAND_DECL(interactive_open){ USE_STYLE(style); USE_DELAY(delay); - View *new_view = live_set_alloc_view(live_set, mem); - view_replace_minor(new_view, panel, live_set); + char *filename = 0; + int filename_len = 0; - new_view->map = &vars->map_ui; - Interactive_View *int_view = - interactive_view_init(new_view, &vars->hot_directory, style, - working_set, delay); - int_view->interaction = INTV_SYS_FILE_LIST; - int_view->action = INTV_OPEN; - copy(&int_view->query, "Open: "); + Command_Parameter *end = param_stack_end(&command->part); + Command_Parameter *param = param_stack_first(&command->part, end); + for (; param < end; param = param_next(param, end)){ + if (param->param.param.type == dynamic_type_int && + param->param.param.int_value == par_name && + param->param.value.type == dynamic_type_string){ + filename = param->param.value.str_value; + filename_len = param->param.value.str_len; + break; + } + } + + bool32 made_file = 0; + + if (filename){ + String string = make_string(filename, filename_len); + if (app_open_file(vars, &mem->general, panel, working_set, + &string, style, live_set, command)) made_file = 1; + } + + if (!made_file){ + View *new_view = live_set_alloc_view(live_set, mem); + view_replace_minor(new_view, panel, live_set); + + new_view->map = &vars->map_ui; + Interactive_View *int_view = + interactive_view_init(new_view, &vars->hot_directory, style, + working_set, delay); + int_view->interaction = INTV_SYS_FILE_LIST; + int_view->action = INTV_OPEN; + copy(&int_view->query, "Open: "); + } } // TODO(allen): Improvements to reopen @@ -821,6 +984,7 @@ COMMAND_DECL(reopen){ USE_STYLE(style); USE_LAYOUT(layout); USE_MEM(mem); + USE_VARS(vars); Editing_File temp_file; if (buffer_create(&mem->general, &temp_file, (u8*)make_c_str(file->source_path), style->font)){ @@ -831,14 +995,24 @@ COMMAND_DECL(reopen){ if (file->tokens_exist) buffer_first_lex_parallel(&mem->general, file); + Partition old_part = command->part; + Temp_Memory temp = begin_temp_memory(&vars->mem.part); + command->part = partition_sub_part(&vars->mem.part, 16 << 10); + + view_set_file(view, file, style, + vars->hooks[hook_open_file], command, app_links); + + command->part = old_part; + end_temp_memory(temp); + i32 panel_count = layout->panel_count; Panel *panels = layout->panels; for (i32 i = 0; i < panel_count; ++i){ Panel *current_panel = panels + i; View *current_view_ = current_panel->view; File_View *current_view = view_to_file_view(current_view_); - if (current_view && current_view->file == file){ - view_set_file(current_view, current_view->file, style); + if (current_view && current_view != view && current_view->file == file){ + view_set_file(current_view, current_view->file, style, 0, command, app_links); } } } @@ -851,7 +1025,7 @@ COMMAND_DECL(save){ String *file_path = &file->source_path; if (file_path->size > 0){ - buffer_save(file, (u8*)file_path->str); + file_save(file, (u8*)file_path->str); } } @@ -967,27 +1141,27 @@ COMMAND_DECL(toggle_endline_mode){ USE_MEM(mem); switch (file->endline_mode){ - case ENDLINE_RN_COMBINED: + case EOL_USE_CRLF: { - file->endline_mode = ENDLINE_RN_SEPARATE; + file->endline_mode = EOL_USE_CR_USE_LF; }break; - case ENDLINE_RN_SEPARATE: + case EOL_USE_CR_USE_LF: { - file->endline_mode = ENDLINE_RN_SHOWALLR; + file->endline_mode = EOL_SHOW_CR_USE_LF; }break; - case ENDLINE_RN_SHOWALLR: + case EOL_SHOW_CR_USE_LF: { - view->cursor.pos = pos_adjust_to_self(view->cursor.pos, view->file->data, - view->file->size); - file->endline_mode = ENDLINE_RN_COMBINED; + view->cursor.pos = pos_adjust_to_self(view->cursor.pos, (u8*)view->file->buffer.data, + view->file->buffer.size); + file->endline_mode = EOL_USE_CRLF; }break; } view->cursor = view_compute_cursor_from_pos(view, view->cursor.pos); - buffer_measure_starts(&mem->general, view->file); + file_measure_starts(&mem->general, view->file); } COMMAND_DECL(toggle_show_whitespace){ @@ -1018,11 +1192,19 @@ COMMAND_DECL(to_uppercase){ Range range = get_range(view->cursor.pos, view->mark); if (range.start < range.end){ + Edit_Spec spec = {}; + spec.type = ED_NORMAL; + spec.start = range.start; + spec.end = range.end; + spec.str_len = range.end - range.start; + spec.next_cursor_pos = view->cursor.pos; + view_pre_replace_range(mem, file, spec); + if (file->still_lexing){ system_cancel_job(BACKGROUND_THREADS, file->lex_job); } - u8 *data = file->data; + u8 *data = (u8*)file->buffer.data; for (i32 i = range.start; i < range.end; ++i){ if (data[i] >= 'a' && data[i] <= 'z'){ data[i] += (u8)('A' - 'a'); @@ -1043,11 +1225,19 @@ COMMAND_DECL(to_lowercase){ Range range = get_range(view->cursor.pos, view->mark); if (range.start < range.end){ + Edit_Spec spec = {}; + spec.type = ED_NORMAL; + spec.start = range.start; + spec.end = range.end; + spec.str_len = range.end - range.start; + spec.next_cursor_pos = view->cursor.pos; + view_pre_replace_range(mem, file, spec); + if (file->still_lexing){ system_cancel_job(BACKGROUND_THREADS, file->lex_job); } - u8 *data = file->data; + u8 *data = (u8*)file->buffer.data; for (i32 i = range.start; i < range.end; ++i){ if (data[i] >= 'A' && data[i] <= 'Z'){ data[i] -= (u8)('A' - 'a'); @@ -1312,12 +1502,12 @@ COMMAND_DECL(move_left){ REQ_FILE_VIEW(view); REQ_FILE(file, view); - u8 *data = file->data; + u8 *data = (u8*)file->buffer.data; i32 pos = view->cursor.pos; if (pos > 0){ --pos; - if (file->endline_mode == ENDLINE_RN_COMBINED){ - pos = pos_adjust_to_self(pos, data, file->size); + if (file->endline_mode == EOL_USE_CRLF){ + pos = pos_adjust_to_self(pos, data, file->buffer.size); } } @@ -1329,11 +1519,11 @@ COMMAND_DECL(move_right){ REQ_FILE_VIEW(view); REQ_FILE(file, view); - i32 size = file->size; - u8* data = file->data; + i32 size = file->buffer.size; + u8* data = (u8*)file->buffer.data; i32 pos = view->cursor.pos; if (pos < size){ - if (file->endline_mode == ENDLINE_RN_COMBINED){ + if (file->endline_mode == EOL_USE_CRLF){ pos = pos_adjust_to_right(pos, data, size); ++pos; } @@ -1353,11 +1543,11 @@ COMMAND_DECL(delete){ USE_MEM(mem); i32 cursor_pos = view->cursor.pos; - u8 *data = file->data; - if (file->size > 0 && cursor_pos < file->size){ + u8 *data = (u8*)file->buffer.data; + if (file->buffer.size > 0 && cursor_pos < file->buffer.size){ i32 start, end; start = cursor_pos; - if (file->endline_mode == ENDLINE_RN_COMBINED && + if (file->endline_mode == EOL_USE_CRLF && data[cursor_pos] == '\r' && data[cursor_pos+1] == '\n'){ end = cursor_pos+2; } @@ -1383,12 +1573,12 @@ COMMAND_DECL(backspace){ USE_MEM(mem); i32 cursor_pos = view->cursor.pos; - u8 *data = file->data; - if (cursor_pos > 0 && cursor_pos <= (i32)file->size){ + u8 *data = (u8*)file->buffer.data; + if (cursor_pos > 0 && cursor_pos <= (i32)file->buffer.size){ i32 start, end; end = cursor_pos; - if (file->endline_mode == ENDLINE_RN_COMBINED && + if (file->endline_mode == EOL_USE_CRLF && cursor_pos > 1 && data[cursor_pos-1] == '\n' && data[cursor_pos-2] == '\r'){ @@ -1585,42 +1775,81 @@ COMMAND_DECL(cursor_mark_swap){ view->mark = pos; } -internal bool32 -fulfill_interaction_intview(Command_Data *command, char *data, bool32 full_set){ - bool32 result = 0; - Panel *panel = command->panel; - View *view = panel->view; - Interactive_View *int_view = view_to_interactive_view(view); - if (int_view){ - result = 1; - - String *dest = 0; - switch (int_view->interaction){ - case INTV_SYS_FILE_LIST: - dest = &int_view->hot_directory->string; - break; - case INTV_LIVE_FILE_LIST: - dest = &int_view->dest; - break; - } - if (full_set) dest->size = 0; - append(dest, data); - - interactive_view_complete(int_view); - } - - return result; -} - COMMAND_DECL(user_callback){ ProfileMomentFunction(); if (binding.custom) binding.custom(command, app_links); } +COMMAND_DECL(set_settings){ + ProfileMomentFunction(); + REQ_FILE_VIEW(view); + REQ_FILE(file, view); + USE_VARS(vars); + USE_MEM(mem); + + Command_Parameter *end = param_stack_end(&command->part); + Command_Parameter *param = param_stack_first(&command->part, end); + for (; param < end; param = param_next(param, end)){ + int p = dynamic_to_int(¶m->param.param); + switch (p){ + case par_lex_as_cpp_file: + { + int v = dynamic_to_bool(¶m->param.value); + if (file->tokens_exist){ + if (!v) buffer_kill_tokens(&mem->general, file); + } + else{ + if (v) buffer_first_lex_parallel(&mem->general, file); + } + }break; + + case par_wrap_lines: + { + int v = dynamic_to_bool(¶m->param.value); + if (view->unwrapped_lines){ + if (v){ + Relative_Scrolling scrolling = view_get_relative_scrolling(view); + view->unwrapped_lines = 0; + view->target_x = 0; + view->cursor = + view_compute_cursor_from_pos(view, view->cursor.pos); + view_set_relative_scrolling(view, scrolling); + } + } + else{ + if (!v){ + Relative_Scrolling scrolling = view_get_relative_scrolling(view); + view->unwrapped_lines = 1; + view->cursor = + view_compute_cursor_from_pos(view, view->cursor.pos); + view_set_relative_scrolling(view, scrolling); + } + } + }break; + + case par_key_mapid: + { + int v = dynamic_to_int(¶m->param.value); + Command_Map *map = 0; + if (v == mapid_global) map = &vars->map_top; + else if (v == mapid_file) map = &vars->map_file; + else if (v >= mapid_user_custom){ + int index = app_get_map_index(vars, v); + if (index < vars->user_map_count) map = vars->user_maps + index; + else map = 0; + } + }break; + + case par_end_line_mode: + break; + } + } +} + globalvar Command_Function command_table[cmdid_count]; extern "C"{ - EXECUTE_COMMAND_SIG(execute_command_from_id){ + EXECUTE_COMMAND_SIG(external_exec_command_keep_stack){ Command_Data *cmd = (Command_Data*)cmd_context; Command_Function function = command_table[command_id]; Command_Binding binding; @@ -1641,27 +1870,79 @@ extern "C"{ command_data.screen_width = cmd->screen_width; command_data.screen_height = cmd->screen_height; command_data.key = cmd->key; + command_data.part = cmd->part; *cmd = command_data; } - FULFILL_INTERACTION_SIG(fulfill_interaction_external){ + PUSH_PARAMETER_SIG(external_push_parameter){ Command_Data *cmd = (Command_Data*)cmd_context; - bool32 handled = 0; - handled = fulfill_interaction_intview(cmd, data, full_set); + Partition *part = &cmd->part; + Command_Parameter *cmd_param = push_struct(part, Command_Parameter); + cmd_param->type = 0; + cmd_param->param.param = param; + cmd_param->param.value = value; + } + + PUSH_MEMORY_SIG(external_push_memory){ + Command_Data *cmd = (Command_Data*)cmd_context; + Partition *part = &cmd->part; + Command_Parameter *base = push_struct(part, Command_Parameter); + char *result = push_array(part, char, len); + int full_len = len + sizeof(Command_Parameter) - 1; + full_len -= (full_len % sizeof(Command_Parameter)); + part->pos += full_len - len; + base->type = 1; + base->inline_string.str = result; + base->inline_string.len = len; + return result; + } + + CLEAR_PARAMETERS_SIG(external_clear_parameters){ + Command_Data *cmd = (Command_Data*)cmd_context; + cmd->part.pos = 0; + } + + GET_ACTIVE_BUFFER_SIG(external_get_active_buffer){ + Command_Data *cmd = (Command_Data*)cmd_context; + Buffer_Summary buffer = {}; + + File_View *view = view_to_file_view(cmd->view); + if (view){ + Editing_File *file = view->file; + if (file && !file->is_dummy){ + Working_Set *working_set = cmd->working_set; + buffer.file_id = (int)(file - working_set->files); + buffer.size = file->buffer.size; + buffer.data = (const char*)file->buffer.data; + buffer.file_name_len = file->source_path.size; + buffer.buffer_name_len = file->live_name.size; + buffer.file_name = file->source_path.str; + buffer.buffer_name = file->live_name.str; + buffer.file_cursor_pos = file->cursor_pos; + buffer.eol_mode = file->endline_mode; + buffer.is_lexed = file->tokens_exist; + buffer.map_id = file->base_map_id; + } + } + + return buffer; } } inline void app_links_init(){ - app_links.exec_command = execute_command_from_id; - app_links.fulfill_interaction = fulfill_interaction_external; + app_links.exec_command_keep_stack = external_exec_command_keep_stack; + app_links.push_parameter = external_push_parameter; + app_links.push_memory = external_push_memory; + app_links.clear_parameters = external_clear_parameters; + app_links.get_active_buffer = external_get_active_buffer; } #if FRED_INTERNAL internal void -setup_debug_commands(Command_Map *commands, Key_Codes *codes){ - map_init(commands); +setup_debug_commands(Command_Map *commands, Partition *part, Key_Codes *codes, Command_Map *parent){ + map_init(commands, part, 6, parent); map_add(commands, 'm', MDFR_NONE, command_debug_memory); map_add(commands, 'o', MDFR_NONE, command_debug_os_events); @@ -1670,8 +1951,8 @@ setup_debug_commands(Command_Map *commands, Key_Codes *codes){ #endif internal void -setup_ui_commands(Command_Map *commands, Key_Codes *codes){ - map_init(commands); +setup_ui_commands(Command_Map *commands, Partition *part, Key_Codes *codes, Command_Map *parent){ + map_init(commands, part, 12, parent); commands->vanilla_keyboard_default.function = command_null; @@ -1684,8 +1965,8 @@ setup_ui_commands(Command_Map *commands, Key_Codes *codes){ } internal void -setup_file_commands(Command_Map *commands, Key_Codes *codes){ - map_init(commands); +setup_file_commands(Command_Map *commands, Partition *part, Key_Codes *codes, Command_Map *parent){ + map_init(commands, part, 101, parent); commands->vanilla_keyboard_default.function = command_write_character; @@ -1713,13 +1994,12 @@ setup_file_commands(Command_Map *commands, Key_Codes *codes){ map_add(commands, 'V', MDFR_CTRL, command_paste_next); map_add(commands, 'z', MDFR_CTRL, command_undo); map_add(commands, 'y', MDFR_CTRL, command_redo); - map_add(commands, 'Z', MDFR_CTRL, command_undo_scrub); + map_add(commands, 'Z', MDFR_CTRL, command_timeline_scrub); map_add(commands, codes->left, MDFR_ALT, command_increase_rewind_speed); map_add(commands, codes->right, MDFR_ALT, command_increase_fastforward_speed); - map_add(commands, codes->down, MDFR_ALT, command_stop_rewind_and_fastforward); + map_add(commands, codes->down, MDFR_ALT, command_stop_rewind_fastforward); map_add(commands, 'h', MDFR_CTRL, command_history_backward); map_add(commands, 'H', MDFR_CTRL, command_history_forward); - map_add(commands, 'J', MDFR_CTRL, command_history_scrub); map_add(commands, 'd', MDFR_CTRL, command_delete_chunk); map_add(commands, 'l', MDFR_CTRL, command_toggle_line_wrap); map_add(commands, 'L', MDFR_CTRL, command_toggle_endline_mode); @@ -1744,8 +2024,8 @@ setup_file_commands(Command_Map *commands, Key_Codes *codes){ } internal void -setup_top_commands(Command_Map *commands, Key_Codes *codes){ - map_init(commands); +setup_top_commands(Command_Map *commands, Partition *part, Key_Codes *codes, Command_Map *parent){ + map_init(commands, part, 51, parent); #if FRED_INTERNAL map_add(commands, 'd', MDFR_ALT, command_open_debug_view); @@ -1807,8 +2087,14 @@ setup_command_table(){ SET(paste); SET(paste_next); SET(delete_chunk); + SET(timeline_scrub); SET(undo); SET(redo); + SET(increase_rewind_speed); + SET(increase_fastforward_speed); + SET(stop_rewind_fastforward); + SET(history_backward); + SET(history_forward); SET(interactive_new); SET(interactive_open); SET(reopen); @@ -1845,6 +2131,7 @@ setup_command_table(){ SET(close_minor_view); SET(cursor_mark_swap); SET(open_menu); + SET(set_settings); #undef SET } @@ -2168,6 +2455,51 @@ app_load_font(Font *font, char *filename, i32 size, void *memory, return font->loaded; } +char *_4coder_get_extension(const char *filename, int len, int *extension_len){ + char *c = (char*)(filename + len - 1); + char *end = c; + while (*c != '.' && c > filename) --c; + *extension_len = (int)(end - c); + return c+1; +} + +bool _4coder_str_match(const char *a, int len_a, const char *b, int len_b){ + bool result = 0; + if (len_a == len_b){ + char *end = (char*)(a + len_a); + while (a < end && *a == *b){ + ++a; ++b; + } + if (a == end) result = 1; + } + return result; +} + +#define literal(s) s, (sizeof(s) - 1) + +HOOK_SIG(default_open_file_hook){ + Buffer_Summary buffer = app.get_active_buffer(cmd_context); + + int treat_as_code = 0; + + if (buffer.file_name && buffer.size < (16 << 20)){ + int extension_len; + char *extension = _4coder_get_extension(buffer.file_name, buffer.file_name_len, &extension_len); + if (_4coder_str_match(extension, extension_len, literal("cpp"))) treat_as_code = 1; + else if (_4coder_str_match(extension, extension_len, literal("h"))) treat_as_code = 1; + else if (_4coder_str_match(extension, extension_len, literal("c"))) treat_as_code = 1; + else if (_4coder_str_match(extension, extension_len, literal("hpp"))) treat_as_code = 1; + } + + app.push_parameter(cmd_context, dynamic_int(par_lex_as_cpp_file), dynamic_int(treat_as_code)); + app.push_parameter(cmd_context, dynamic_int(par_wrap_lines), dynamic_int(!treat_as_code)); + app.push_parameter(cmd_context, dynamic_int(par_key_mapid), dynamic_int(mapid_file)); + app.push_parameter(cmd_context, dynamic_int(par_end_line_mode), dynamic_int(EOL_USE_CRLF)); + + app.exec_command_keep_stack(cmd_context, cmdid_set_settings); + app.clear_parameters(cmd_context); +} + internal bool32 app_init(Thread_Context *thread, Application_Memory *memory, Key_Codes *loose_codes, Clipboard_Contents clipboard){ @@ -2229,42 +2561,77 @@ app_init(Thread_Context *thread, Application_Memory *memory, vars->live_set.free_view = (View*)views_; setup_command_table(); - + + Command_Map *global = &vars->map_top; if (TEMP.get_bindings){ i32 size = partition_remaining(partition); void *data = partition_current(partition); - + + // TODO(allen): Use a giant bubble of general memory for this. + // So that it doesn't interfere with the command maps as they allocate + // their own memory. i32 wanted_size = TEMP.get_bindings(data, size, loose_codes); bool32 did_top = 0; bool32 did_file = 0; - if (wanted_size <= size){ + partition_allocate(partition, wanted_size); + Binding_Unit *unit = (Binding_Unit*)data; - if (unit->type == UNIT_HEADER && unit->header.error == 0){ + if (unit->type == unit_header && unit->header.error == 0){ Binding_Unit *end = unit + unit->header.total_size; + i32 user_map_count = unit->header.user_map_count; + + vars->map_id_table = + push_array(&vars->mem.part, i32, user_map_count); + + vars->user_maps = + push_array(&vars->mem.part, Command_Map, user_map_count); + + vars->user_map_count = user_map_count; + Command_Map *mapptr = 0; - int mapid = -1; for (++unit; unit < end; ++unit){ switch (unit->type){ - case UNIT_MAP_BEGIN: + case unit_map_begin: { - mapid = unit->map_begin.mapid; - if (mapid == MAPID_GLOBAL){ + int table_max = unit->map_begin.bind_count * 3 / 2; + int mapid = unit->map_begin.mapid; + if (mapid == mapid_global){ mapptr = &vars->map_top; - map_init(mapptr); + map_init(mapptr, &vars->mem.part, table_max, global); did_top = 1; } - else if (mapid == MAPID_FILE){ + else if (mapid == mapid_file){ mapptr = &vars->map_file; - map_init(mapptr); + map_init(mapptr, &vars->mem.part, table_max, global); did_file = 1; } + else if (mapid >= mapid_user_custom){ + i32 index = app_get_or_add_map_index(vars, mapid); + Assert(index < user_map_count); + mapptr = vars->user_maps + index; + map_init(mapptr, &vars->mem.part, table_max, global); + } else mapptr = 0; }break; - - case UNIT_BINDING: + + case unit_inherit: + if (mapptr){ + Command_Map *parent = 0; + int mapid = unit->map_inherit.mapid; + if (mapid == mapid_global) parent = &vars->map_top; + else if (mapid == mapid_file) parent = &vars->map_file; + else if (mapid >= mapid_user_custom){ + i32 index = app_get_or_add_map_index(vars, mapid); + if (index < user_map_count) parent = vars->user_maps + index; + else parent = 0; + } + mapptr->parent = parent; + }break; + + case unit_binding: if (mapptr){ Command_Function func = 0; if (unit->binding.command_id >= 0 && unit->binding.command_id < cmdid_count) @@ -2280,7 +2647,7 @@ app_init(Thread_Context *thread, Application_Memory *memory, } break; - case UNIT_CALLBACK: + case unit_callback: if (mapptr){ Command_Function func = command_user_callback; Custom_Command_Function *custom = unit->callback.func; @@ -2295,24 +2662,36 @@ app_init(Thread_Context *thread, Application_Memory *memory, } } break; + + case unit_hook: + { + int hook_id = unit->hook.hook_id; + if (hook_id >= 0 && hook_id < hook_type_count){ + vars->hooks[hook_id] = unit->hook.func; + } + }break; } } } } - if (!did_top) setup_top_commands(&vars->map_top, loose_codes); - if (!did_file) setup_file_commands(&vars->map_file, loose_codes); + if (!did_top) setup_top_commands(&vars->map_top, &vars->mem.part, loose_codes, global); + if (!did_file) setup_file_commands(&vars->map_file, &vars->mem.part, loose_codes, global); } else{ - setup_top_commands(&vars->map_top, loose_codes); - setup_file_commands(&vars->map_file, loose_codes); + setup_top_commands(&vars->map_top, &vars->mem.part, loose_codes, global); + setup_file_commands(&vars->map_file, &vars->mem.part, loose_codes, global); } - setup_ui_commands(&vars->map_ui, loose_codes); + setup_ui_commands(&vars->map_ui, &vars->mem.part, loose_codes, global); #if FRED_INTERNAL - setup_debug_commands(&vars->map_debug, loose_codes); + setup_debug_commands(&vars->map_debug, &vars->mem.part, loose_codes, global); #endif + if (vars->hooks[hook_open_file] == 0){ + vars->hooks[hook_open_file] = default_open_file_hook; + } + if (!font_init()) return 0; vars->fonts.max = 6; @@ -2732,22 +3111,45 @@ app_step(Thread_Context *thread, Key_Codes *codes, command_data.screen_width = target->width; command_data.screen_height = target->height; - if (first_step && TEMP.start_hook){ - TEMP.start_hook(&command_data, app_links); + Temp_Memory param_stack_temp = begin_temp_memory(&vars->mem.part); + command_data.part = partition_sub_part(&vars->mem.part, 16 << 10); + + if (first_step && vars->hooks[hook_start]){ + vars->hooks[hook_start](&command_data, app_links); + command_data.part.pos = 0; } // NOTE(allen): command input to active view for (i32 key_i = 0; key_i < key_data.count; ++key_i){ Command_Binding cmd = {}; - Command_Map *override_map = 0; + Command_Map *map = 0; View *view = active_panel->view; Key_Single key = get_single_key(&key_data, key_i); command_data.key = key; - if (view) override_map = view->map; - if (override_map) cmd = map_extract(override_map, key); - if (cmd.function == 0) cmd = map_extract(&vars->map_top, key); + Command_Map *visited_maps[16] = {}; + i32 visited_top = 0; + + if (view) map = view->map; + if (map == 0) map = &vars->map_top; + while (map){ + cmd = map_extract(map, key); + if (cmd.function == 0){ + if (visited_top < ArrayCount(visited_maps)){ + visited_maps[visited_top++] = map; + map = map->parent; + for (i32 i = 0; i < visited_top; ++i){ + if (map == visited_maps[i]){ + map = 0; + break; + } + } + } + else map = 0; + } + else map = 0; + } switch (vars->state){ case APP_STATE_EDIT: @@ -2835,33 +3237,8 @@ app_step(Thread_Context *thread, Key_Codes *codes, switch (act->type){ case DACT_OPEN: { - Editing_File *target_file = 0; - bool32 created_file = 0; - - target_file = working_set_contains(working_set, *string); - if (!target_file){ - Get_File_Result file = working_set_get_available_file(working_set); - if (file.file){ - buffer_get_dummy(file.file); - created_file = buffer_create(general, file.file, (u8*)string->str, style->font); - table_add(&working_set->table, file.file->source_path, file.index); - if (created_file){ - target_file = file.file; - } - } - } - - if (target_file){ - View *new_view = live_set_alloc_view(live_set, &vars->mem); - - new_view->map = &vars->map_file; - view_replace_major(new_view, panel, live_set); - - File_View *file_view = file_view_init(new_view, &vars->delay, &vars->layout); - view_set_file(file_view, target_file, style); - if (created_file && target_file->tokens_exist) - buffer_first_lex_parallel(general, target_file); - } + command_data.view = (View*) + app_open_file(vars, general,panel, working_set, string, style, live_set, &command_data); }break; case DACT_SAVE_AS: @@ -2873,7 +3250,7 @@ app_step(Thread_Context *thread, Key_Codes *codes, if (fview){ Editing_File *file = fview->file; if (file && !file->is_dummy){ - buffer_save_and_set_names(file, (u8*)string->str); + file_save_and_set_names(file, (u8*)string->str); } } }break; @@ -2882,7 +3259,7 @@ app_step(Thread_Context *thread, Key_Codes *codes, { Editing_File *file = working_set_lookup_file(working_set, *string); if (file && !file->is_dummy){ - buffer_save(file, (u8*)file->source_path.str); + file_save(file, (u8*)file->source_path.str); } }break; @@ -2894,10 +3271,12 @@ app_step(Thread_Context *thread, Key_Codes *codes, View *new_view = live_set_alloc_view(live_set, mem); view_replace_major(new_view, panel, live_set); - new_view->map = &vars->map_file; File_View *file_view = file_view_init(new_view, &vars->delay, &vars->layout); - view_set_file(file_view, file.file, style); + command_data.view = (View*)file_view; + view_set_file(file_view, file.file, style, + vars->hooks[hook_open_file], &command_data, app_links); + new_view->map = app_get_map(vars, file.file->base_map_id); if (file.file->tokens_exist) buffer_first_lex_parallel(general, file.file); }break; @@ -2907,10 +3286,12 @@ app_step(Thread_Context *thread, Key_Codes *codes, if (file){ View *new_view = live_set_alloc_view(live_set, mem); view_replace_major(new_view, panel, live_set); - new_view->map = &vars->map_file; - + File_View *file_view = file_view_init(new_view, &vars->delay, &vars->layout); - view_set_file(file_view, file, style); + command_data.view = (View*)file_view; + view_set_file(file_view, file, style, + vars->hooks[hook_open_file], &command_data, app_links); + new_view->map = app_get_map(vars, file->base_map_id); } }break; @@ -2975,6 +3356,8 @@ app_step(Thread_Context *thread, Key_Codes *codes, } ProfileEnd(delayed_actions); + end_temp_memory(param_stack_temp); + ProfileStart(resize); // NOTE(allen): send resize messages to panels that have changed size { @@ -3007,7 +3390,7 @@ app_step(Thread_Context *thread, Key_Codes *codes, Editing_File *file = vars->working_set.files; for (i32 i = vars->working_set.file_index_count; i > 0; --i, ++file){ - if (file->data && !file->is_dummy){ + if (file->buffer.data && !file->is_dummy){ buffer_measure_widths(&vars->mem.general, file, vars->style.font); } } diff --git a/4ed.h b/4ed.h index 8a3b4382..f3ed376a 100644 --- a/4ed.h +++ b/4ed.h @@ -3,7 +3,7 @@ * * 12.12.2014 * - * Win32 Layer for project codename "4ed" + * Application Layer for project codename "4ed" * */ @@ -15,7 +15,7 @@ struct Partition{ i32 pos, max; }; -internal Partition +inline Partition partition_open(void *memory, i32 size){ Partition partition; partition.base = (u8*)memory;; @@ -24,16 +24,21 @@ partition_open(void *memory, i32 size){ return partition; } -internal void* +inline void* partition_allocate(Partition *data, i32 size){ void *ret = 0; - if (size > 0 && data->pos + size < data->max){ + if (size > 0 && data->pos + size <= data->max){ ret = data->base + data->pos; data->pos += size; } return ret; } +inline void +partition_align(Partition *data, u32 boundary){ + data->pos = (data->pos + (boundary - 1)) & (~boundary); +} + inline void* partition_current(Partition *data){ return data->base + data->pos; @@ -44,6 +49,14 @@ partition_remaining(Partition *data){ return data->max - data->pos; } +inline Partition +partition_sub_part(Partition *data, i32 size){ + Partition result = {}; + void *d = partition_allocate(data, size); + if (d) result = partition_open(d, size); + return result; +} + #define push_struct(part, T) (T*)partition_allocate(part, sizeof(T)) #define push_array(part, T, size) (T*)partition_allocate(part, sizeof(T)*(size)) #define push_block(part, size) partition_allocate(part, size) diff --git a/4ed_color_view.cpp b/4ed_color_view.cpp index 7c002712..09f7c734 100644 --- a/4ed_color_view.cpp +++ b/4ed_color_view.cpp @@ -123,15 +123,6 @@ view_to_color_view(View *view){ return (Color_View*)view; } -internal real32 -font_string_width(Font *font, char *str){ - real32 x = 0; - for (i32 i = 0; str[i]; ++i){ - x += font_get_glyph_width(font, str[i]); - } - return x; -} - internal void draw_gradient_slider(Render_Target *target, Vec4 base, i32 channel, i32 steps, real32 top, real32_Rect slider, bool32 hsla){ @@ -213,51 +204,6 @@ do_label(UI_State *state, UI_Layout *layout, char *text, real32 height = 2.f){ } } -internal bool32 -do_button(i32 id, UI_State *state, UI_Layout *layout, char *text, - bool32 is_toggle = 0, bool32 on = 0){ - bool32 result = 0; - Font *font = state->font; - i32 character_h = font->height; - - i32_Rect btn_rect = layout_rect(layout, character_h * 2); - btn_rect = get_inner_rect(btn_rect, 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(font, 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, 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 void do_scroll_bar(UI_State *state, i32_Rect rect){ i32 id = 1; @@ -1051,7 +997,7 @@ step_draw_adjusting(Color_View *color_view, i32_Rect rect, View_Message message, ui.layout.rect.x1 -= 20; if (!ui.state.input_stage) draw_push_clip(target, ui.layout.rect); - if (do_button(-1, &ui.state, &ui.layout, "Back to Library")){ + if (do_button(-1, &ui.state, &ui.layout, "Back to Library", 2)){ color_view->mode = CV_MODE_LIBRARY; ui.state.view_y = 0; } @@ -1174,7 +1120,7 @@ update_highlighting(Color_View *color_view){ Editing_File *file = file_view->file; i32 pos = view_get_cursor_pos(file_view); - char c = file->data[pos]; + char c = file->buffer.data[pos]; if (c == '\r'){ color_view->highlight.ids[0] = @@ -1607,19 +1553,19 @@ step_draw_library(Color_View *color_view, i32_Rect rect, View_Message message, begin_row(&ui.layout, 3); if (ui.state.style->name.size >= 1){ - if (do_button(-2, &ui.state, &ui.layout, "Save")){ + if (do_button(-2, &ui.state, &ui.layout, "Save", 2)){ style_library_add(ui.styles, ui.state.style); } } else{ - do_button(-2, &ui.state, &ui.layout, "~Need's Name~"); + do_button(-2, &ui.state, &ui.layout, "~Need's Name~", 2); } - if (do_button(-3, &ui.state, &ui.layout, "Import")){ + if (do_button(-3, &ui.state, &ui.layout, "Import", 2)){ color_view->mode = CV_MODE_IMPORT_FILE; hot_directory_clean_end(color_view->hot_directory); hot_directory_reload(color_view->hot_directory, color_view->working_set); } - if (do_button(-4, &ui.state, &ui.layout, "Export")){ + if (do_button(-4, &ui.state, &ui.layout, "Export", 2)){ color_view->mode = CV_MODE_EXPORT; hot_directory_clean_end(color_view->hot_directory); hot_directory_reload(color_view->hot_directory, color_view->working_set); @@ -1647,10 +1593,10 @@ step_draw_library(Color_View *color_view, i32_Rect rect, View_Message message, do_label(&ui.state, &ui.layout, "Import Which File?"); begin_row(&ui.layout, 2); - if (do_button(-2, &ui.state, &ui.layout, "*.p4c only", 1, color_view->p4c_only)){ + if (do_button(-2, &ui.state, &ui.layout, "*.p4c only", 2, 1, color_view->p4c_only)){ color_view->p4c_only = !color_view->p4c_only; } - if (do_button(-3, &ui.state, &ui.layout, "Cancel")){ + if (do_button(-3, &ui.state, &ui.layout, "Cancel", 2)){ color_view->mode = CV_MODE_LIBRARY; } @@ -1689,10 +1635,10 @@ step_draw_library(Color_View *color_view, i32_Rect rect, View_Message message, do_label(&ui.state, &ui.layout, "Export File Name?"); begin_row(&ui.layout, 2); - if (do_button(-2, &ui.state, &ui.layout, "Finish Export")){ + if (do_button(-2, &ui.state, &ui.layout, "Finish Export", 2)){ file_selected = 1; } - if (do_button(-3, &ui.state, &ui.layout, "Cancel")){ + if (do_button(-3, &ui.state, &ui.layout, "Cancel", 2)){ color_view->mode = CV_MODE_LIBRARY; } @@ -1740,14 +1686,14 @@ step_draw_library(Color_View *color_view, i32_Rect rect, View_Message message, do_label(&ui.state, &ui.layout, "Pack"); begin_row(&ui.layout, 2); - if (do_button(-2, &ui.state, &ui.layout, "Finish Import")){ + if (do_button(-2, &ui.state, &ui.layout, "Finish Import", 2)){ Style *style = styles; for (i32 i = 0; i < style_count; ++i, ++style){ if (import_check[i]) style_library_add(ui.styles, style); } color_view->mode = CV_MODE_LIBRARY; } - if (do_button(-3, &ui.state, &ui.layout, "Cancel")){ + if (do_button(-3, &ui.state, &ui.layout, "Cancel", 2)){ color_view->mode = CV_MODE_LIBRARY; } @@ -1767,10 +1713,10 @@ step_draw_library(Color_View *color_view, i32_Rect rect, View_Message message, do_label(&ui.state, &ui.layout, "Export Which Themes?"); begin_row(&ui.layout, 2); - if (do_button(-2, &ui.state, &ui.layout, "Export")){ + if (do_button(-2, &ui.state, &ui.layout, "Export", 2)){ color_view->mode = CV_MODE_EXPORT_FILE; } - if (do_button(-3, &ui.state, &ui.layout, "Cancel")){ + if (do_button(-3, &ui.state, &ui.layout, "Cancel", 2)){ color_view->mode = CV_MODE_LIBRARY; } diff --git a/4ed_command.cpp b/4ed_command.cpp index cf7f0eff..8a1c050b 100644 --- a/4ed_command.cpp +++ b/4ed_command.cpp @@ -18,8 +18,9 @@ struct Command_Binding{ }; struct Command_Map{ + Command_Map *parent; Command_Binding vanilla_keyboard_default; - Command_Binding commands[101]; + Command_Binding *commands; i32 count, max; }; @@ -93,10 +94,12 @@ map_drop(Command_Map *map, u16 event_code, u8 modifiers){ } internal void -map_init(Command_Map *commands){ +map_init(Command_Map *commands, Partition *part, i32 max, Command_Map *parent){ + commands->parent = parent; + commands->commands = push_array(part, Command_Binding, max); + memset(commands->commands, 0, max*sizeof(*commands->commands)); commands->vanilla_keyboard_default = {}; - memset(commands->commands, 0, sizeof(commands->commands)); - commands->max = ArrayCount(commands->commands); + commands->max = max; commands->count = 0; } diff --git a/4ed_file_view.cpp b/4ed_file_view.cpp index 758eeb95..12173fec 100644 --- a/4ed_file_view.cpp +++ b/4ed_file_view.cpp @@ -9,11 +9,25 @@ // TOP -enum Endline_Mode{ - ENDLINE_RN_COMBINED, - ENDLINE_RN_SEPARATE, - ENDLINE_RN_SHOWALLR -}; +#define GOLDEN_ARRAY 0 +#define ROPES 1 +#define GAP_BUFFER 2 +#define MULTI_GAP_BUFFER 3 +#define SCOPING_BUFFER 4 + +#define USE_BUFFER_TYPE GOLDEN_ARRAY + +#if USE_BUFFER_TYPE == GOLDEN_ARRAY +#include "buffer/4coder_golden_array.cpp" +#elif USE_BUFFER_TYPE == ROPES +#include "buffer/4coder_ropes.cpp" +#elif USE_BUFFER_TYPE == GAP_BUFFER +#include "buffer/4coder_gap_buffer.cpp" +#elif USE_BUFFER_TYPE == MULTI_GAP_BUFFER +#include "buffer/4coder_multi_gap_buffer.cpp" +#elif USE_BUFFER_TYPE == SCOPING_BUFFER +#include "buffer/4coder_scoping_buffer.cpp" +#endif struct Range{ i32 start, end; @@ -51,12 +65,11 @@ struct Undo_Data{ Edit_Step *history; i32 edit_history, edit_history_max; i32 edit_history_cursor; - i32 pending_block; + i32 current_block_normal; }; struct Editing_File{ - i32 size, max_size; - u8 *data; + Buffer buffer; Undo_Data undo; @@ -67,7 +80,7 @@ struct Editing_File{ i32 width_count, width_max; real32 *line_width; - Endline_Mode endline_mode; + EOL_Option endline_mode; i32 cursor_pos; bool32 is_dummy; @@ -83,6 +96,7 @@ struct Editing_File{ bool32 tokens_exist; bool32 still_lexing; u32 lex_job; + i32 base_map_id; u64 last_4ed_write_time; u64 last_4ed_edit_time; @@ -989,16 +1003,19 @@ enum File_View_Widget_Type{ FWIDG_NONE, FWIDG_SEARCH, FWIDG_GOTO_LINE, - FWIDG_UNDOING, - FWIDG_RESTORING, + FWIDG_TIMELINES, // never below this FWIDG_TYPE_COUNT }; struct File_View_Widget{ + UI_State state; File_View_Widget_Type type; i32 height; - UI_State state; + struct{ + bool32 undo_line; + bool32 history_line; + } timeline; }; struct File_View{ @@ -1087,26 +1104,26 @@ pos_adjust_to_self(i32 pos, u8 *data, i32 size){ } inline i32 -pos_universal_fix(i32 pos, u8 *data, i32 size, Endline_Mode mode){ - if (mode == ENDLINE_RN_COMBINED) +pos_universal_fix(i32 pos, u8 *data, i32 size, EOL_Option mode){ + if (mode == EOL_USE_CRLF) pos = pos_adjust_to_self(pos, data, size); return pos; } inline i32 -starts_new_line(u8 character, Endline_Mode mode){ - return (character == '\n' || (mode == ENDLINE_RN_SEPARATE && character == '\r')); +starts_new_line(u8 character, EOL_Option mode){ + return (character == '\n' || (mode == EOL_USE_CR_USE_LF && character == '\r')); } inline void -buffer_init_strings(Editing_File *file){ +file_init_strings(Editing_File *file){ file->source_path = make_fixed_width_string(file->source_path_); file->live_name = make_fixed_width_string(file->live_name_); file->extension = make_fixed_width_string(file->extension_); } inline void -buffer_set_name(Editing_File *file, u8 *filename){ +file_set_name(Editing_File *file, u8 *filename){ String f, ext; f = make_string_slowly((char*)filename); copy_checked(&file->source_path, f); @@ -1117,7 +1134,7 @@ buffer_set_name(Editing_File *file, u8 *filename){ } inline void -buffer_synchronize_times(Editing_File *file, u8 *filename){ +file_synchronize_times(Editing_File *file, u8 *filename){ Time_Stamp stamp = system_file_time_stamp(filename); if (stamp.success){ file->last_4ed_write_time = stamp.time; @@ -1127,55 +1144,48 @@ buffer_synchronize_times(Editing_File *file, u8 *filename){ } inline bool32 -buffer_save(Editing_File *file, u8 *filename){ - bool32 result; - result = system_save_file(filename, file->data, file->size); - buffer_synchronize_times(file, filename); +file_save(Editing_File *file, u8 *filename){ + bool32 result = 0; + i32 do_once = 0; + for (Buffer_Save_Loop loop = buffer_save_loop(&file->buffer); + buffer_save_good(&loop); + buffer_save_next(&loop)){ + Assert(do_once == 0); + result = system_save_file(filename, loop.data, loop.size); + ++do_once; + } + file_synchronize_times(file, filename); return result; } inline bool32 -buffer_save_and_set_names(Editing_File *file, u8 *filename){ +file_save_and_set_names(Editing_File *file, u8 *filename){ bool32 result = 0; - if (buffer_save(file, filename)){ + if (file_save(file, filename)){ result = 1; - buffer_set_name(file, filename); + file_set_name(file, filename); } return result; } -internal i32 -buffer_count_newlines(Editing_File *file, i32 start, i32 end){ +inline i32 +file_count_newlines(Editing_File *file, i32 start, i32 end){ i32 count = 0; - - u8 *data = file->data; - Endline_Mode end_mode = file->endline_mode; - - for (i32 i = start; i < end; ++i){ - bool32 new_line = 0; - switch(data[i]){ - case '\n': - { - new_line = 1; - }break; - case '\r': - { - if (end_mode == ENDLINE_RN_SEPARATE){ - new_line = 1; - } - }break; - } - count += new_line; + switch (file->endline_mode){ + case EOL_USE_CRLF: + case EOL_SHOW_CR_USE_LF: + count = buffer_count_newlines(&file->buffer, start, end, 0, 1); break; + case EOL_USE_CR_USE_LF: + count = buffer_count_newlines(&file->buffer, start, end, 1, 1); break; } - return count; } internal bool32 -buffer_check_newline(Endline_Mode end_mode, u8 character){ +file_check_newline(EOL_Option end_mode, u8 character){ bool32 result = 0; if (character == '\n' || - (end_mode == ENDLINE_RN_SEPARATE && character == '\r')){ + (end_mode == EOL_USE_CR_USE_LF && character == '\r')){ result = 1; } return result; @@ -1200,15 +1210,16 @@ enum File_Bubble_Type{ #define GROW_SUCCESS 2 internal i32 -buffer_grow_starts_as_needed(General_Memory *general, Editing_File *file, i32 additional_lines){ +file_grow_starts_as_needed(General_Memory *general, Editing_File *file, i32 additional_lines){ bool32 result = GROW_NOT_NEEDED; i32 max = file->line_max; i32 count = file->line_count; i32 target_lines = count + additional_lines; if (target_lines > max){ max <<= 1; - i32 *new_lines = (i32*)general_memory_reallocate(general, file->line_starts, - sizeof(i32)*count, sizeof(i32)*max, BUBBLE_STARTS); + i32 *new_lines = (i32*) + general_memory_reallocate(general, file->line_starts, + sizeof(i32)*count, sizeof(i32)*max, BUBBLE_STARTS); if (new_lines){ file->line_starts = new_lines; file->line_max = max; @@ -1222,36 +1233,37 @@ buffer_grow_starts_as_needed(General_Memory *general, Editing_File *file, i32 ad } internal void -buffer_measure_starts(General_Memory *general, Editing_File *file){ +file_measure_starts(General_Memory *general, Editing_File *file){ ProfileMomentFunction(); if (!file->line_starts){ i32 max = file->line_max = Kbytes(1); file->line_starts = (i32*)general_memory_allocate(general, max*sizeof(i32), BUBBLE_STARTS); + TentativeAssert(file->line_starts); // TODO(allen): when unable to allocate? } - Endline_Mode mode = file->endline_mode; - i32 size = file->size; - u8 *data = file->data; - - file->line_count = 0; - i32 start = 0; - for (i32 i = 0; i < size; ++i){ - if (buffer_check_newline(mode, data[i])){ - // TODO(allen): when unable to grow? - buffer_grow_starts_as_needed(general, file, 1); - file->line_starts[file->line_count++] = start; - start = i + 1; - } + // TODO(allen): handle endline modes + Buffer_Measure_Starts state = {}; + while (buffer_measure_starts_(&state, &file->buffer, file->line_starts, file->line_max, 0, 1)){ + i32 max = file->line_max; + i32 count = state.count; + i32 target_lines = count + 1; + + max = (target_lines << 1); + i32 *new_lines = (i32*) + general_memory_reallocate(general, file->line_starts, + sizeof(i32)*count, sizeof(i32)*max, BUBBLE_STARTS); + + // TODO(allen): when unable to grow? + TentativeAssert(new_lines); + file->line_starts = new_lines; + file->line_max = max; } - - // TODO(allen): when unable to grow? - buffer_grow_starts_as_needed(general, file, 1); - file->line_starts[file->line_count++] = start; + file->line_count = state.count; } internal real32 -measure_character(Font *font, Endline_Mode end_mode, bool32 *new_line, +measure_character(Font *font, EOL_Option end_mode, bool32 *new_line, u8 character, u8 next){ real32 width = 0; switch (character){ @@ -1270,7 +1282,7 @@ measure_character(Font *font, Endline_Mode end_mode, bool32 *new_line, case '\r': { switch (end_mode){ - case ENDLINE_RN_COMBINED: + case EOL_USE_CRLF: { if (next == '\n'){ // DO NOTHING @@ -1281,13 +1293,13 @@ measure_character(Font *font, Endline_Mode end_mode, bool32 *new_line, } }break; - case ENDLINE_RN_SEPARATE: + case EOL_USE_CR_USE_LF: { width = font->chardata[character].xadvance; *new_line = 1; }break; - case ENDLINE_RN_SHOWALLR: + case EOL_SHOW_CR_USE_LF: { width = font->chardata['\\'].xadvance; width += font->chardata['r'].xadvance; @@ -1320,9 +1332,9 @@ buffer_measure_widths(General_Memory *general, Editing_File *file, Font *font){ file->width_max = new_max; } - Endline_Mode mode = file->endline_mode; - i32 size = file->size; - u8 *data = file->data; + EOL_Option mode = file->endline_mode; + i32 size = file->buffer.size; + char *data = file->buffer.data; real32 *line_widths = file->line_width; // TODO(allen): Does this help at all with widths??? @@ -1352,7 +1364,7 @@ buffer_remeasure_starts(General_Memory *general, Editing_File *file, i32 character_shift){ ProfileMomentFunction(); Assert(file->line_starts); - buffer_grow_starts_as_needed(general, file, line_shift); + file_grow_starts_as_needed(general, file, line_shift); i32 *lines = file->line_starts; if (line_shift != 0){ @@ -1369,12 +1381,12 @@ buffer_remeasure_starts(General_Memory *general, Editing_File *file, } } - i32 size = file->size; - u8 *data = file->data; + i32 size = file->buffer.size; + char *data = file->buffer.data; i32 char_i = lines[line_start]; i32 line_i = line_start; - Endline_Mode end_mode = file->endline_mode; + EOL_Option end_mode = file->endline_mode; i32 start = char_i; for (; char_i <= size; ++char_i){ @@ -1386,7 +1398,7 @@ buffer_remeasure_starts(General_Memory *general, Editing_File *file, character = data[char_i]; } - if (buffer_check_newline(end_mode, character)){ + if (file_check_newline(end_mode, character)){ if (line_i > line_end && start == lines[line_i]){ break; } @@ -1502,18 +1514,20 @@ buffer_create_from_string(General_Memory *general, Editing_File *file, u8 *filen Assert(data); *file = {}; - file->data = data; - file->size = val.size; - file->max_size = request_size; + file->buffer.data = (char*)data; + file->buffer.size = val.size; + file->buffer.max = request_size; if (val.size > 0) memcpy(data, val.str, val.size); data[val.size] = 0; - buffer_synchronize_times(file, filename); - buffer_init_strings(file); - buffer_set_name(file, filename); + file_synchronize_times(file, filename); + file_init_strings(file); + file_set_name(file, filename); - buffer_measure_starts(general, file); + file->base_map_id = mapid_file; + + file_measure_starts(general, file); buffer_measure_widths(general, file, font); file->font = font; @@ -1533,11 +1547,7 @@ buffer_create_from_string(General_Memory *general, Editing_File *file, u8 *filen file->undo.history_block_count = 1; file->undo.history_head_block = 0; - file->undo.pending_block = 0; - - if (!match(file->extension, make_lit_string("txt"))){ - file->tokens_exist = 1; - } + file->undo.current_block_normal = 1; } internal bool32 @@ -1598,7 +1608,7 @@ buffer_close(General_Memory *general, Editing_File *file){ if (file->token_stack.tokens){ general_memory_free(general, file->token_stack.tokens); } - general_memory_free(general, file->data); + general_memory_free(general, file->buffer.data); general_memory_free(general, file->line_starts); general_memory_free(general, file->line_width); } @@ -1606,7 +1616,7 @@ buffer_close(General_Memory *general, Editing_File *file){ internal void buffer_get_dummy(Editing_File *buffer){ *buffer = {}; - buffer->data = (u8*)&buffer->size; + buffer->buffer.data = (char*)&buffer->buffer.size; buffer->is_dummy = 1; } @@ -1620,8 +1630,8 @@ JOB_CALLBACK(job_full_lex){ General_Memory *general = (General_Memory*)data[1]; Cpp_File cpp_file; - cpp_file.data = (char*)file->data; - cpp_file.size = file->size; + cpp_file.data = file->buffer.data; + cpp_file.size = file->buffer.size; Cpp_Token_Stack tokens; tokens.tokens = (Cpp_Token*)memory->data; @@ -1719,8 +1729,8 @@ buffer_relex_parallel(Mem_Options *mem, Editing_File *file, bool32 inline_lex = !file->still_lexing; if (inline_lex){ Cpp_File cpp_file; - cpp_file.data = (char*)file->data; - cpp_file.size = file->size; + cpp_file.data = file->buffer.data; + cpp_file.size = file->buffer.size; Cpp_Token_Stack *stack = &file->token_stack; @@ -1795,14 +1805,15 @@ buffer_relex_parallel(Mem_Options *mem, Editing_File *file, internal bool32 buffer_grow_as_needed(General_Memory *general, Editing_File *file, i32 additional_size){ bool32 result = 1; - i32 target_size = file->size + additional_size + 1; - if (target_size >= file->max_size){ + i32 target_size = file->buffer.size + additional_size + 1; + if (target_size >= file->buffer.max){ i32 request_size = LargeRoundUp(target_size*2, Kbytes(256)); - u8 *new_data = (u8*)general_memory_reallocate(general, file->data, file->size, request_size, BUBBLE_BUFFER); + char *new_data = (char*) + general_memory_reallocate(general, file->buffer.data, file->buffer.size, request_size, BUBBLE_BUFFER); if (new_data){ - new_data[file->size] = 0; - file->data = new_data; - file->max_size = request_size; + new_data[file->buffer.size] = 0; + file->buffer.data = new_data; + file->buffer.max = request_size; } else{ result = 0; @@ -1880,7 +1891,7 @@ internal Edit_Step* buffer_post_undo(General_Memory *general, Editing_File *file, i32 start, i32 end, i32 str_len, bool32 do_merge, bool32 can_merge, bool32 clear_redo, i32 pre_pos = -1, i32 post_pos = -1){ - String replaced = make_string((char*)file->data + start, end - start); + String replaced = make_string(file->buffer.data + start, end - start); if (clear_redo){ file->undo.str_redo = file->undo.str_max; @@ -1941,7 +1952,7 @@ buffer_unpost_undo(Editing_File *file){ internal void buffer_post_redo(General_Memory *general, Editing_File *file, i32 start, i32 end, i32 str_len, i32 pre_pos, i32 post_pos){ - String replaced = make_string((char*)file->data + start, end - start); + String replaced = make_string((char*)file->buffer.data + start, end - start); if (file->undo.str_redo - replaced.size < file->undo.str_size) buffer_grow_undo_string(general, file, replaced.size); @@ -1982,7 +1993,9 @@ buffer_post_history_block(Editing_File *file, i32 pos){ inline void buffer_unpost_history_block(Editing_File *file){ Assert(file->undo.history_block_count > 1); - + --file->undo.history_block_count; + Edit_Step *old_head = file->undo.history + file->undo.history_head_block; + file->undo.history_head_block = old_head->prev_block; } internal Edit_Step* @@ -1990,7 +2003,7 @@ buffer_post_history(General_Memory *general, Editing_File *file, i32 start, i32 end, i32 str_len, bool32 do_merge, bool32 can_merge, Edit_Type reverse_type, i32 pre_pos = -1, i32 post_pos = -1){ - String replaced = make_string((char*)file->data + start, end - start); + String replaced = make_string(file->buffer.data + start, end - start); if (file->undo.str_history_max < file->undo.str_history + replaced.size) buffer_grow_history_string(general, file, replaced.size); @@ -2041,13 +2054,13 @@ buffer_text_replace(General_Memory *general, Editing_File *file, i32 shift_amount = (str_len - (end - start)); buffer_grow_as_needed(general, file, shift_amount); - Assert(shift_amount + file->size + 1 <= file->max_size); + Assert(shift_amount + file->buffer.size + 1 <= file->buffer.max); - i32 size = file->size; - u8 *data = (u8*)file->data; + i32 size = file->buffer.size; + char *data = (char*)file->buffer.data; memmove(data + end + shift_amount, data + end, size - end); - file->size += shift_amount; - file->data[file->size] = 0; + file->buffer.size += shift_amount; + file->buffer.data[file->buffer.size] = 0; memcpy(data + start, str, str_len); @@ -2074,7 +2087,7 @@ buffer_replace_range(Mem_Options *mem, Editing_File *file, i32 line_start = buffer_get_line_index(file, start); i32 line_end = buffer_get_line_index(file, end); i32 replaced_line_count = line_end - line_start; - i32 new_line_count = buffer_count_newlines(file, start, start+str_len); + i32 new_line_count = file_count_newlines(file, start, start+str_len); i32 line_shift = new_line_count - replaced_line_count; buffer_remeasure_starts(general, file, line_start, line_end, line_shift, shift_amount); @@ -2089,23 +2102,6 @@ buffer_replace_range(Mem_Options *mem, Editing_File *file, return shift; } -#if 0 -inline internal void -buffer_delete(Mem_Options *mem, Editing_File *file, i32 pos){ - buffer_replace_range(mem, file, pos, pos+1, 0, 0); -} - -inline internal void -buffer_delete_range(Mem_Options *mem, Editing_File *file, i32 smaller, i32 larger){ - buffer_replace_range(mem, file, smaller, larger, 0, 0); -} - -inline internal void -buffer_delete_range(Mem_Options *mem, Editing_File *file, Range range){ - buffer_replace_range(mem, file, range.smaller, range.larger, 0, 0); -} -#endif - enum Endline_Convert_Type{ ENDLINE_RN, ENDLINE_N, @@ -2175,7 +2171,7 @@ seek_line_char(i32 line, i32 character){ internal View_Cursor_Data view_cursor_seek(u8 *data, i32 size, Panel_Seek seek, - Endline_Mode endline_mode, + EOL_Option endline_mode, real32 max_width, Font *font, View_Cursor_Data hint = {}){ View_Cursor_Data cursor = hint; @@ -2191,17 +2187,17 @@ view_cursor_seek(u8 *data, i32 size, Panel_Seek seek, case '\r': { switch (endline_mode){ - case ENDLINE_RN_COMBINED: + case EOL_USE_CRLF: { if (next_c != '\n'){ do_slashr = 1; } }break; - case ENDLINE_RN_SEPARATE: + case EOL_USE_CR_USE_LF: { do_newline = 1; }break; - case ENDLINE_RN_SHOWALLR: + case EOL_SHOW_CR_USE_LF: { do_slashr = 1; }break; @@ -2303,7 +2299,7 @@ view_cursor_seek(u8 *data, i32 size, Panel_Seek seek, } } - if (endline_mode == ENDLINE_RN_COMBINED){ + if (endline_mode == EOL_USE_CRLF){ cursor.pos = pos_adjust_to_self(cursor.pos, data, size); } @@ -2332,7 +2328,7 @@ view_compute_cursor_from_pos(File_View *view, i32 pos){ hint.wrapped_x = 0; real32 max_width = view_compute_width(view); - result = view_cursor_seek(file->data, file->size, seek_pos(pos), + result = view_cursor_seek((u8*)file->buffer.data, file->buffer.size, seek_pos(pos), file->endline_mode, max_width, font, hint); return result; @@ -2348,6 +2344,7 @@ view_compute_cursor_from_unwrapped_xy(File_View *view, real32 seek_x, real32 see i32 line_index = FLOOR32(seek_y / font->height); if (line_index >= file->line_count) line_index = file->line_count - 1; + if (line_index < 0) line_index = 0; View_Cursor_Data hint; hint.pos = file->line_starts[line_index]; @@ -2359,7 +2356,7 @@ view_compute_cursor_from_unwrapped_xy(File_View *view, real32 seek_x, real32 see hint.wrapped_x = 0; real32 max_width = view_compute_width(view); - result = view_cursor_seek(file->data, file->size, + result = view_cursor_seek((u8*)file->buffer.data, file->buffer.size, seek_unwrapped_xy(seek_x, seek_y, round_down), file->endline_mode, max_width, font, hint); @@ -2411,7 +2408,7 @@ view_compute_cursor_from_wrapped_xy(File_View *view, real32 seek_x, real32 seek_ real32 max_width = view_compute_width(view); - result = view_cursor_seek(file->data, file->size, + result = view_cursor_seek((u8*)file->buffer.data, file->buffer.size, seek_wrapped_xy(seek_x, seek_y, round_down), file->endline_mode, max_width, font, hint); @@ -2488,7 +2485,8 @@ view_get_cursor_y(File_View *view){ } internal void -view_set_file(File_View *view, Editing_File *file, Style *style){ +view_set_file(File_View *view, Editing_File *file, Style *style, + Custom_Command_Function *open_hook, void *cmd_context, Application_Links app){ Panel *panel = view->view_base.panel; view->file = file; @@ -2531,6 +2529,8 @@ view_set_file(File_View *view, Editing_File *file, Style *style){ view->vel_y = 1.f; view->vel_x = 1.f; + + if (open_hook) open_hook(cmd_context, app); } struct Relative_Scrolling{ @@ -2603,8 +2603,7 @@ view_widget_height(File_View *view, Font *font){ case FWIDG_NONE: break; case FWIDG_SEARCH: result = font->height + 2; break; case FWIDG_GOTO_LINE: result = font->height + 2; break; - case FWIDG_UNDOING: result = font->height*2; break; - case FWIDG_RESTORING: result = font->height*2; break; + case FWIDG_TIMELINES: result = view->widget.height; break; } return result; } @@ -2633,8 +2632,7 @@ struct Edit_Spec{ }; internal void -view_pre_replace_range(Mem_Options *mem, File_View *view, Editing_File *file, - Editing_Layout *layout, Edit_Spec spec){ +view_pre_replace_range(Mem_Options *mem, Editing_File *file, Edit_Spec spec){ General_Memory *general = &mem->general; bool32 can_merge = 0, do_merge = 0; @@ -2664,39 +2662,72 @@ view_pre_replace_range(Mem_Options *mem, File_View *view, Editing_File *file, buffer_unpost_undo(file); + bool32 restore_redos = 0; + Edit_Step *redo_end = 0; + if (spec.in_history == 1 && file->undo.edit_history_cursor > 0){ - Edit_Step *redo_end = file->undo.history + (file->undo.edit_history_cursor - 1); + restore_redos = 1; + redo_end = file->undo.history + (file->undo.edit_history_cursor - 1); + } + else if (spec.in_history == 2 && file->undo.edit_history > 0){ + restore_redos = 1; + redo_end = file->undo.history + (file->undo.edit_history - 1); + } + + if (restore_redos){ Edit_Step *redo_start = redo_end; - while (redo_start->reverse_type == ED_REDO) --redo_start; + i32 steps_of_redo = 0; + i32 undo_count = 0; + while (redo_start->reverse_type == ED_REDO || redo_start->reverse_type == ED_UNDO){ + if (redo_start->reverse_type == ED_REDO){ + if (undo_count > 0) --undo_count; + else ++steps_of_redo; + } + else{ + ++undo_count; + } + --redo_start; + } ++redo_start; ++redo_end; if (redo_start < redo_end){ - i32 steps_of_redo = (i32)(redo_end - redo_start); - u8 *str_dest_base = file->undo.strings; u8 *str_src = file->undo.history_strings + redo_start->str_start; i32 str_redo_pos = file->undo.str_redo; Edit_Step *edit_dest = file->undo.edits + file->undo.edit_redo; - Edit_Step *edit_src = redo_start; + Edit_Step *edit_src = redo_end-1; - for (i32 i = 0; i < steps_of_redo; ++i){ - --edit_dest; - edit_dest->range = edit_src->range; - edit_dest->pre_pos = edit_src->pre_pos; - edit_dest->post_pos = edit_src->post_pos; - edit_dest->can_merge = edit_src->can_merge; - edit_dest->reverse_type = edit_src->reverse_type; - - edit_dest->str_len = edit_src->str_len; - str_redo_pos -= edit_dest->str_len; - edit_dest->str_start = str_redo_pos; - - memcpy(str_dest_base + str_redo_pos, str_src, edit_dest->str_len); + i32 undo_count = 0; + for (i32 i = 0; i < steps_of_redo;){ + if (edit_src->reverse_type == ED_REDO){ + if (undo_count > 0){ + --undo_count; + } + else{ + ++i; + --edit_dest; + edit_dest->range = edit_src->range; + edit_dest->pre_pos = edit_src->pre_pos; + edit_dest->post_pos = edit_src->post_pos; + edit_dest->can_merge = edit_src->can_merge; + edit_dest->reverse_type = edit_src->reverse_type; + + edit_dest->str_len = edit_src->str_len; + str_redo_pos -= edit_dest->str_len; + edit_dest->str_start = str_redo_pos; + + memcpy(str_dest_base + str_redo_pos, str_src, edit_dest->str_len); + } + } + else{ + ++undo_count; + } str_src += edit_dest->str_len; - ++edit_src; + --edit_src; } + Assert(undo_count == 0); file->undo.str_redo = str_redo_pos; file->undo.edit_redo -= steps_of_redo; @@ -2717,6 +2748,7 @@ view_pre_replace_range(Mem_Options *mem, File_View *view, Editing_File *file, case ED_REDO: { + if (spec.str_len == 1 && char_is_alpha_numeric(*spec.str)) can_merge = 1; if (spec.str_len == 1 && (can_merge || char_is_whitespace(*spec.str))) do_merge = 1; @@ -2730,23 +2762,23 @@ view_pre_replace_range(Mem_Options *mem, File_View *view, Editing_File *file, } if (spec.in_history != 2){ - if (spec.type == ED_UNDO){ - if (!file->undo.pending_block){ - file->undo.pending_block = file->undo.edit_history - 1; - buffer_post_history_block(file, file->undo.pending_block); + if (spec.type == ED_UNDO || spec.type == ED_REDO){ + if (file->undo.current_block_normal){ + buffer_post_history_block(file, file->undo.edit_history - 1); + file->undo.current_block_normal = 0; } } else{ - if (file->undo.pending_block){ + if (!file->undo.current_block_normal){ buffer_post_history_block(file, file->undo.edit_history - 1); - file->undo.pending_block = 0; + file->undo.current_block_normal = 1; } } } else{ - if (file->undo.pending_block == file->undo.edit_history){ + if (file->undo.history_head_block == file->undo.edit_history){ buffer_unpost_history_block(file); - file->undo.pending_block = 0; + file->undo.current_block_normal = !file->undo.current_block_normal; } } @@ -2755,26 +2787,27 @@ view_pre_replace_range(Mem_Options *mem, File_View *view, Editing_File *file, internal void view_post_replace_range(Mem_Options *mem, File_View *view, Editing_File *file, - Editing_Layout *layout, Edit_Spec spec){ + Editing_Layout *layout, Shift_Information shift){ Panel *current_panel = layout->panels; + General_Memory *general = &mem->general; i32 panel_count = layout->panel_count; for (i32 i = 0; i < panel_count; ++i, ++current_panel){ File_View *current_view = view_to_file_view(current_panel->view); if (current_view && current_view->file == file){ - view_measure_wraps(&mem->general, current_view); + view_measure_wraps(general, current_view); if (current_view != view){ - if (current_view->cursor.pos >= spec.end){ + if (current_view->cursor.pos >= shift.end){ view_cursor_move(current_view, current_view->cursor.pos+shift.amount); } - else if (current_view->cursor.pos > spec.start){ - view_cursor_move(current_view, spec.start); + else if (current_view->cursor.pos > shift.start){ + view_cursor_move(current_view, shift.start); } - if (current_view->mark >= spec.end){ + if (current_view->mark >= shift.end){ current_view->mark += shift.amount; } - else if (current_view->mark > spec.start){ - current_view->mark += spec.start; + else if (current_view->mark > shift.start){ + current_view->mark += shift.start; } current_view->preferred_x = view_get_cursor_x(current_view); } @@ -2786,19 +2819,10 @@ internal void view_replace_range(Mem_Options *mem, File_View *view, Editing_File *file, Editing_Layout *layout, Edit_Spec spec){ Assert(file); - - view_pre_replace_range(mem, view, file, layout, spec); - - Shift_Information shift; - if (!spec.skip_text_replace){ - shift = - buffer_replace_range(mem, file, spec.start, spec.end, spec.str, spec.str_len); - } - else{ - shift = spec.override_replace; - } - - view_post_replace_range(mem, view, file, layout, spec, shift); + view_pre_replace_range(mem, file, spec); + Shift_Information shift = + buffer_replace_range(mem, file, spec.start, spec.end, spec.str, spec.str_len); + view_post_replace_range(mem, view, file, layout, shift); } inline void @@ -2827,7 +2851,6 @@ view_range_undo(Mem_Options *mem, File_View *view, Editing_Layout *layout, spec.str_len = step.str_len; spec.pre_pos = step.pre_pos; spec.post_pos = step.post_pos; - spec.in_history = 0; view_replace_range(mem, view, file, layout, spec); } @@ -2844,7 +2867,6 @@ view_range_redo(Mem_Options *mem, File_View *view, Editing_Layout *layout, spec.str_len = step.str_len; spec.pre_pos = step.pre_pos; spec.post_pos = step.post_pos; - spec.in_history = 0; view_replace_range(mem, view, file, layout, spec); } @@ -2852,13 +2874,13 @@ view_range_redo(Mem_Options *mem, File_View *view, Editing_Layout *layout, internal i32 view_find_end_of_line(File_View *view, i32 pos){ Editing_File *file = view->file; - u8 *data = (u8*)file->data; - while (pos < file->size && + char *data = file->buffer.data; + while (pos < file->buffer.size && !starts_new_line(data[pos], file->endline_mode)){ ++pos; } - if (pos >= file->size){ - pos = file->size; + if (pos >= file->buffer.size){ + pos = file->buffer.size; } return pos; } @@ -2866,7 +2888,7 @@ view_find_end_of_line(File_View *view, i32 pos){ internal i32 view_find_beginning_of_line(File_View *view, i32 pos){ Editing_File *file = view->file; - u8 *data = (u8*)file->data; + char *data = file->buffer.data; if (pos > 0){ --pos; while (pos > 0 && !starts_new_line(data[pos], file->endline_mode)){ @@ -2882,12 +2904,12 @@ view_find_beginning_of_line(File_View *view, i32 pos){ internal i32 view_find_beginning_of_next_line(File_View *view, i32 pos){ Editing_File *file = view->file; - u8 *data = (u8*)file->data; - while (pos < file->size && + char *data = file->buffer.data; + while (pos < file->buffer.size && !starts_new_line(data[pos], file->endline_mode)){ ++pos; } - if (pos < file->size){ + if (pos < file->buffer.size){ ++pos; } return pos; @@ -3103,9 +3125,9 @@ buffer_find_hard_start(Editing_File *file, i32 line_start){ Line_Hard_Start result = {}; result.line_is_blank = 1; - u8 *data = file->data; + char *data = file->buffer.data; - for (i32 scan = line_start; scan < file->size; ++scan){ + for (i32 scan = line_start; scan < file->buffer.size; ++scan){ if (data[scan] == '\n'){ if (scan > 0 && data[scan-1] == '\r'){ scan -= 1; @@ -3636,19 +3658,68 @@ remeasure_file_view(View *view_, i32_Rect rect){ view_set_relative_scrolling(view, relative); } +internal bool32 +do_button(i32 id, UI_State *state, UI_Layout *layout, char *text, i32 height_mult, + bool32 is_toggle = 0, bool32 on = 0){ + bool32 result = 0; + Font *font = state->font; + i32 character_h = font->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(font, 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, 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 bool32 do_undo_slider(Widget_ID wid, UI_State *state, UI_Layout *layout, i32 max, i32 v, Undo_Data *undo, i32 *out){ bool32 result = 0; Font *font = state->font; i32 character_h = font->height; - i32_Rect containing_rect = layout_rect(layout, character_h * 2); - + 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 + (character_h/2) - 1; - click_rect.y1 = containing_rect.y1 - DIVCEIL32(character_h, 2) + 1; + click_rect.y0 = containing_rect.y0 + 2; + click_rect.y1 = containing_rect.y1 - 2; if (state->input_stage){ real32 l; @@ -3667,8 +3738,8 @@ do_undo_slider(Widget_ID wid, UI_State *state, UI_Layout *layout, i32 max, i32 v 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 = containing_rect.y0 + character_h - 1; - i32 bar_bottom = containing_rect.y1 - character_h + 1; + 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; @@ -3711,19 +3782,19 @@ do_undo_slider(Widget_ID wid, UI_State *state, UI_Layout *layout, i32 max, i32 v } } 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; i32 block_count = undo->history_block_count; Edit_Step *step = history; for (i32 i = 0; i < block_count; ++i){ u32 color; - if (step->reverse_type == ED_REDO) color = ui_style.pop1; + if (step->reverse_type == ED_REDO || + step->reverse_type == ED_UNDO) color = ui_style.pop1; else color = ui_style.dim; real32 L; @@ -3733,11 +3804,14 @@ do_undo_slider(Widget_ID wid, UI_State *state, UI_Layout *layout, i32 max, i32 v 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; } } @@ -3753,6 +3827,8 @@ do_undo_slider(Widget_ID wid, UI_State *state, UI_Layout *layout, i32 max, i32 v for (i32 i = 0; i <= max; ++i){ if (i != max){ if (history[i].reverse_type == ED_REDO) color = ui_style.pop1; + else if (history[i].reverse_type == ED_UNDO || + history[i].reverse_type == ED_NORMAL) color = ui_style.pop2; else color = ui_style.dim; } draw_rectangle(target, tick, color); @@ -3765,8 +3841,8 @@ do_undo_slider(Widget_ID wid, UI_State *state, UI_Layout *layout, i32 max, i32 v i32_Rect slider_handle; slider_handle.x0 = x - 2; slider_handle.x1 = x + 2; - slider_handle.y0 = bar_top - (character_h/2); - slider_handle.y1 = bar_bottom + (character_h/2); + slider_handle.y0 = click_rect.y0; + slider_handle.y1 = click_rect.y1; draw_rectangle(target, slider_handle, ui_style.bright); } @@ -3989,8 +4065,7 @@ step_file_view(Thread_Context *thread, View *view_, i32_Rect rect, total_count = undo_count + redo_count; switch (view->widget.type){ - case FWIDG_UNDOING: - case FWIDG_RESTORING: + case FWIDG_TIMELINES: { i32_Rect widg_rect = view_widget_rect(view, font); @@ -4001,37 +4076,62 @@ step_file_view(Thread_Context *thread, View *view_, i32_Rect rect, UI_Layout layout; begin_layout(&layout, widg_rect); - Widget_ID wid = make_id(&state, 1); - - if (view->widget.type == FWIDG_UNDOING){ - i32 new_count; - if (do_undo_slider(wid, &state, &layout, total_count, undo_count, 0, &new_count)){ - view->rewind_speed = 0; - view->rewind_amount = 0; - - for (i32 i = 0; i < scrub_max && new_count < undo_count; ++i){ - view_undo(view_->mem, view->layout, view); - --undo_count; - } - for (i32 i = 0; i < scrub_max && new_count > undo_count; ++i){ - view_redo(view_->mem, view->layout, view); - ++undo_count; + if (view->widget.timeline.undo_line){ + if (do_button(1, &state, &layout, "- Undo", 1)){ + view->widget.timeline.undo_line = 0; + } + + if (view->widget.timeline.undo_line){ + Widget_ID wid = make_id(&state, 2); + i32 new_count; + if (do_undo_slider(wid, &state, &layout, total_count, undo_count, 0, &new_count)){ + view->rewind_speed = 0; + view->rewind_amount = 0; + + for (i32 i = 0; i < scrub_max && new_count < undo_count; ++i){ + view_undo(view_->mem, view->layout, view); + --undo_count; + } + for (i32 i = 0; i < scrub_max && new_count > undo_count; ++i){ + view_redo(view_->mem, view->layout, view); + ++undo_count; + } } } } else{ - i32 new_count; - i32 mid = ((file->undo.edit_history + file->undo.edit_history_cursor) >> 1); - i32 count = file->undo.edit_history_cursor; - if (do_undo_slider(wid, &state, &layout, mid, count, &file->undo, &new_count)){ - for (i32 i = 0; i < scrub_max && new_count < count; ++i){ - view_history_step(view_->mem, view->layout, view, 1); - } - for (i32 i = 0; i < scrub_max && new_count > count; ++i){ - view_history_step(view_->mem, view->layout, view, 2); + if (do_button(1, &state, &layout, "+ Undo", 1)){ + view->widget.timeline.undo_line = 1; + } + } + + if (view->widget.timeline.history_line){ + if (do_button(3, &state, &layout, "- History", 1)){ + view->widget.timeline.history_line = 0; + } + + Widget_ID wid = make_id(&state, 4); + if (view->widget.timeline.history_line){ + i32 new_count; + i32 mid = ((file->undo.edit_history + file->undo.edit_history_cursor) >> 1); + i32 count = file->undo.edit_history_cursor; + if (do_undo_slider(wid, &state, &layout, mid, count, &file->undo, &new_count)){ + for (i32 i = 0; i < scrub_max && new_count < count; ++i){ + view_history_step(view_->mem, view->layout, view, 1); + } + for (i32 i = 0; i < scrub_max && new_count > count; ++i){ + view_history_step(view_->mem, view->layout, view, 2); + } } } } + else{ + if (do_button(3, &state, &layout, "+ History", 1)){ + view->widget.timeline.history_line = 1; + } + } + + view->widget.height = layout.y - widg_rect.y0; if (ui_finish_frame(&view->widget.state, &state, &layout, widg_rect, 0, 0)){ result = 1; @@ -4101,10 +4201,10 @@ draw_file_view(Thread_Context *thread, View *view_, i32_Rect rect, bool32 is_act i32 max_x = rect.x1 - rect.x0; i32 max_y = rect.y1 - rect.y0 + font->height; - Assert(file && file->data && !file->is_dummy); + Assert(file && file->buffer.data && !file->is_dummy); - i32 size = (i32)file->size; - u8 *data = (u8*)file->data; + i32 size = (i32)file->buffer.size; + u8 *data = (u8*)file->buffer.data; View_Cursor_Data start_cursor; start_cursor = view_compute_cursor_from_xy(view, 0, view->scroll_y); @@ -4209,7 +4309,7 @@ draw_file_view(Thread_Context *thread, View *view_, i32_Rect rect, bool32 is_act } if (highlight_color != 0){ - if (file->endline_mode == ENDLINE_RN_COMBINED && + if (file->endline_mode == EOL_USE_CRLF && to_render == '\r' && next_to_render == '\n'){ // DO NOTHING // NOTE(allen): relevant durring whitespace highlighting @@ -4259,20 +4359,20 @@ draw_file_view(Thread_Context *thread, View *view_, i32_Rect rect, bool32 is_act if (to_render == '\r'){ bool32 show_slashr = 0; switch (file->endline_mode){ - case ENDLINE_RN_COMBINED: + case EOL_USE_CRLF: { if (next_to_render != '\n'){ show_slashr = 1; } }break; - case ENDLINE_RN_SEPARATE: + case EOL_USE_CR_USE_LF: { pos_x = 0; pos_y += font->height; }break; - case ENDLINE_RN_SHOWALLR: + case EOL_SHOW_CR_USE_LF: { show_slashr = 1; }break; @@ -4338,11 +4438,12 @@ draw_file_view(Thread_Context *thread, View *view_, i32_Rect rect, bool32 is_act begin_layout(&layout, widg_rect); switch (view->widget.type){ - case FWIDG_UNDOING: - case FWIDG_RESTORING: + case FWIDG_TIMELINES: { - Widget_ID wid = make_id(&state, 1); - if (view->widget.type == FWIDG_UNDOING){ + if (view->widget.timeline.undo_line){ + do_button(1, &state, &layout, "- Undo", 1); + + Widget_ID wid = make_id(&state, 2); i32 undo_count, redo_count, total_count; undo_count = file->undo.edit_count; redo_count = file->undo.edit_max - file->undo.edit_redo; @@ -4350,10 +4451,20 @@ draw_file_view(Thread_Context *thread, View *view_, i32_Rect rect, bool32 is_act do_undo_slider(wid, &state, &layout, total_count, undo_count, 0, 0); } else{ + do_button(1, &state, &layout, "+ Undo", 1); + } + + if (view->widget.timeline.history_line){ + do_button(3, &state, &layout, "- History", 1); + + Widget_ID wid = make_id(&state, 4); i32 new_count; i32 mid = ((file->undo.edit_history + file->undo.edit_history_cursor) >> 1); do_undo_slider(wid, &state, &layout, mid, file->undo.edit_history_cursor, &file->undo, &new_count); } + else{ + do_button(3, &state, &layout, "+ History", 1); + } }break; case FWIDG_SEARCH: @@ -4450,8 +4561,7 @@ HANDLE_COMMAND_SIG(handle_command_file_view){ switch (file_view->widget.type){ case FWIDG_NONE: - case FWIDG_UNDOING: - case FWIDG_RESTORING: + case FWIDG_TIMELINES: { file_view->next_mode = {}; if (binding.function) binding.function(command, binding); @@ -4496,7 +4606,7 @@ HANDLE_COMMAND_SIG(handle_command_file_view){ } } - String file_string = make_string((char*)file->data, file->size); + String file_string = make_string(file->buffer.data, file->buffer.size); i32 pos; if (file_view->isearch.reverse){ if (result.hit_backspace){ @@ -4526,12 +4636,12 @@ HANDLE_COMMAND_SIG(handle_command_file_view){ } else{ pos = find_substr(file_string, start_pos + 1, *string); - if (pos < file->size){ + if (pos < file->buffer.size){ if (step_forward){ file_view->isearch.pos = pos; start_pos = pos; pos = find_substr(file_string, start_pos + 1, *string); - if (pos == file->size){ + if (pos == file->buffer.size){ pos = start_pos; } } diff --git a/4ed_rendering.cpp b/4ed_rendering.cpp index 4fd93310..29d77e2c 100644 --- a/4ed_rendering.cpp +++ b/4ed_rendering.cpp @@ -825,6 +825,15 @@ font_get_glyph_width(Font *font, u16 character){ return font->chardata[character].xadvance; } +internal real32 +font_string_width(Font *font, char *str){ + real32 x = 0; + for (i32 i = 0; str[i]; ++i){ + x += font_get_glyph_width(font, str[i]); + } + return x; +} + internal i32 draw_string(Render_Target *target, Font *font, char *str, i32 x_, i32 y, u32 color){ diff --git a/buffer/4coder_golden_array.cpp b/buffer/4coder_golden_array.cpp new file mode 100644 index 00000000..52c342bd --- /dev/null +++ b/buffer/4coder_golden_array.cpp @@ -0,0 +1,118 @@ +/* + * Mr. 4th Dimention - Allen Webster + * Four Tech + * + * 16.10.2015 + * + * Buffer data object + * type - Golden Array + * + */ + +#define inline_4tech inline +#define internal_4tech static + +typedef struct{ + char *data; + int size, max; +} Buffer; + +typedef struct{ + Buffer *buffer; + char *data; + int size; +} Buffer_Save_Loop; + +inline_4tech Buffer_Save_Loop +buffer_save_loop(Buffer *buffer){ + Buffer_Save_Loop result; + result.buffer = buffer; + result.data = buffer->data; + result.size = buffer->size; + return(result); +} + +inline_4tech int +buffer_save_good(Buffer_Save_Loop *loop){ + int result; + result = (loop->buffer != 0); + return(result); +} + +inline_4tech void +buffer_save_next(Buffer_Save_Loop *loop){ + loop->buffer = 0; +} + +internal_4tech int +buffer_count_newlines(Buffer *buffer, int start, int end, int CR, int LF){ + int new_line, count; + char *data; + int i; + + data = buffer->data; + new_line = 0; + count = 0; + + for (i = start; i < end; ++i){ + switch(data[i]){ + case '\n': new_line = LF; break; + case '\r': new_line = CR; break; + default: new_line = 0; break; + } + count += new_line; + } + + return (count); +} + +typedef struct{ + int i; + int count; + int start; +} Buffer_Measure_Starts; + +internal_4tech int +buffer_measure_starts_(Buffer_Measure_Starts *state, Buffer *buffer, int *starts, int max, int CR, int LF){ + char *data; + int size; + int start, count, i, new_line; + int result; + + data = buffer->data; + size = buffer->size; + + result = 0; + start = state->start; + count = state->count; + + for (i = state->i; i < size; ++i){ + switch (data[i]){ + case '\n': new_line = LF; break; + case '\r': new_line = CR; break; + default: new_line = 0; break; + } + + if (new_line){ + if (count == max){ + result = 1; + break; + } + + starts[count++] = start; + start = i + 1; + } + } + + if (i == size){ + if (count == max) result = 1; + else starts[count++] = start; + } + + state->i = i; + state->count = count; + state->start = start; + + return (result); +} + diff --git a/win32_4ed.cpp b/win32_4ed.cpp index 9c8cce70..9af60e83 100644 --- a/win32_4ed.cpp +++ b/win32_4ed.cpp @@ -72,7 +72,6 @@ struct TEMP_BACKDOOR{ Get_Binding_Data_Function *get_bindings; Set_Extra_Font_Function *set_extra_font; - Start_Hook_Function *start_hook; } TEMP; #if FRED_INTERNAL @@ -931,9 +930,6 @@ WinMain(HINSTANCE hInstance, TEMP.set_extra_font = (Set_Extra_Font_Function*) GetProcAddress(win32vars.custom, "set_extra_font"); - - TEMP.start_hook = (Start_Hook_Function*) - GetProcAddress(win32vars.custom, "start_hook"); } #endif