mr4th-public
/
4coder
1
Fork 0
Code Issues Releases Activity

bug fixing

master
Allen Webster 2016-02-20 16:36:16 -05:00
parent 770c48f95b
commit c8db4004a6
13 changed files with 3424 additions and 3465 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
4coder_custom.cpp
View File

@ -23,7 +23,7 @@ enum My_Maps{
HOOK_SIG(my_start){ HOOK_SIG(my_start){
exec_command(cmd_context, cmdid_open_panel_hsplit); exec_command(cmd_context, cmdid_open_panel_hsplit);
exec_command(cmd_context, cmdid_change_active_panel); exec_command(cmd_context, cmdid_change_active_panel);
exec_command(cmd_context, cmdid_open_panel_vsplit); exec_command(cmd_context, cmdid_open_panel_vsplit);
exec_command(cmd_context, cmdid_change_active_panel); exec_command(cmd_context, cmdid_change_active_panel);
} }
@ -50,9 +50,9 @@ bool str_match(const char *a, int len_a, const char *b, int len_b){
HOOK_SIG(my_file_settings){ HOOK_SIG(my_file_settings){
Buffer_Summary buffer = get_active_buffer(cmd_context); Buffer_Summary buffer = get_active_buffer(cmd_context);
int treat_as_code = 0; int treat_as_code = 0;
// NOTE(allen|a3.1): This checks buffer.file_name just in case get_active_buffer returns back // NOTE(allen|a3.1): This checks buffer.file_name just in case get_active_buffer returns back
// a null buffer (where every member is 0). // a null buffer (where every member is 0).
if (buffer.file_name && buffer.size < (16 << 20)){ if (buffer.file_name && buffer.size < (16 << 20)){
@ -63,7 +63,7 @@ HOOK_SIG(my_file_settings){
else if (str_match(extension, extension_len, literal("c"))) 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; else if (str_match(extension, extension_len, literal("hpp"))) treat_as_code = 1;
} }
push_parameter(app, cmd_context, par_lex_as_cpp_file, treat_as_code); push_parameter(app, cmd_context, par_lex_as_cpp_file, treat_as_code);
push_parameter(app, cmd_context, par_wrap_lines, !treat_as_code); push_parameter(app, cmd_context, par_wrap_lines, !treat_as_code);
push_parameter(app, cmd_context, par_key_mapid, (treat_as_code)?(my_code_map):(mapid_file)); push_parameter(app, cmd_context, par_key_mapid, (treat_as_code)?(my_code_map):(mapid_file));
@ -81,21 +81,21 @@ CUSTOM_COMMAND_SIG(open_my_files){
// cmdid_interactive_open behaves as usual. // cmdid_interactive_open behaves as usual.
push_parameter(app, cmd_context, par_name, literal("w:/4ed/data/test/basic.cpp")); push_parameter(app, cmd_context, par_name, literal("w:/4ed/data/test/basic.cpp"));
exec_command(cmd_context, cmdid_interactive_open); exec_command(cmd_context, cmdid_interactive_open);
exec_command(cmd_context, cmdid_change_active_panel); exec_command(cmd_context, cmdid_change_active_panel);
char my_file[256]; char my_file[256];
int my_file_len; int my_file_len;
my_file_len = sizeof("w:/4ed/data/test/basic.txt") - 1; my_file_len = sizeof("w:/4ed/data/test/basic.txt") - 1;
for (int i = 0; i < my_file_len; ++i){ for (int i = 0; i < my_file_len; ++i){
my_file[i] = ("w:/4ed/data/test/basic.txt")[i]; my_file[i] = ("w:/4ed/data/test/basic.txt")[i];
} }
// NOTE(allen|a3.1): null terminators are not needed for strings. // NOTE(allen|a3.1): null terminators are not needed for strings.
push_parameter(app, cmd_context, par_name, my_file, my_file_len); push_parameter(app, cmd_context, par_name, my_file, my_file_len);
exec_command(cmd_context, cmdid_interactive_open); exec_command(cmd_context, cmdid_interactive_open);
exec_command(cmd_context, cmdid_change_active_panel); exec_command(cmd_context, cmdid_change_active_panel);
} }
@ -147,20 +147,20 @@ CUSTOM_COMMAND_SIG(build_search){
push_parameter(app, cmd_context, par_cli_overlap_with_conflict, 0); push_parameter(app, cmd_context, par_cli_overlap_with_conflict, 0);
push_parameter(app, cmd_context, par_target_buffer_name, literal("*compilation*")); push_parameter(app, cmd_context, par_target_buffer_name, literal("*compilation*"));
push_parameter(app, cmd_context, par_cli_path, dir.str, dir.size); push_parameter(app, cmd_context, par_cli_path, dir.str, dir.size);
if (append(&dir, "build")){ if (append(&dir, "build")){
app->push_parameter(cmd_context, app->push_parameter(cmd_context,
dynamic_int(par_cli_command), dynamic_int(par_cli_command),
dynamic_string(dir.str, dir.size)); dynamic_string(dir.str, dir.size));
exec_command(cmd_context, cmdid_build); exec_command(cmd_context, cmdid_build);
} }
else{ else{
clear_parameters(cmd_context); clear_parameters(cmd_context);
} }
return; return;
} }
if (app->directory_cd(&dir, "..") == 0){ if (app->directory_cd(&dir, "..") == 0){
keep_going = 0; keep_going = 0;
} }
@ -187,14 +187,14 @@ CUSTOM_COMMAND_SIG(cut_line){
extern "C" GET_BINDING_DATA(get_bindings){ extern "C" GET_BINDING_DATA(get_bindings){
Bind_Helper context_actual = begin_bind_helper(data, size); Bind_Helper context_actual = begin_bind_helper(data, size);
Bind_Helper *context = &context_actual; Bind_Helper *context = &context_actual;
// NOTE(allen|a3.1): Right now hooks have no loyalties to maps, all hooks are // NOTE(allen|a3.1): Right now hooks have no loyalties to maps, all hooks are
// global and once set they always apply, regardless of what map is active. // global and once set they always apply, regardless of what map is active.
set_hook(context, hook_start, my_start); set_hook(context, hook_start, my_start);
set_hook(context, hook_open_file, my_file_settings); set_hook(context, hook_open_file, my_file_settings);
begin_map(context, mapid_global); begin_map(context, mapid_global);
bind(context, 'p', MDFR_CTRL, cmdid_open_panel_vsplit); bind(context, 'p', MDFR_CTRL, cmdid_open_panel_vsplit);
bind(context, '-', MDFR_CTRL, cmdid_open_panel_hsplit); bind(context, '-', MDFR_CTRL, cmdid_open_panel_hsplit);
bind(context, 'P', MDFR_CTRL, cmdid_close_panel); bind(context, 'P', MDFR_CTRL, cmdid_close_panel);
@ -206,18 +206,18 @@ extern "C" GET_BINDING_DATA(get_bindings){
bind(context, 'c', MDFR_ALT, cmdid_open_color_tweaker); bind(context, 'c', MDFR_ALT, cmdid_open_color_tweaker);
bind(context, 'x', MDFR_ALT, cmdid_open_menu); bind(context, 'x', MDFR_ALT, cmdid_open_menu);
bind_me(context, 'o', MDFR_ALT, open_in_other); bind_me(context, 'o', MDFR_ALT, open_in_other);
// NOTE(allen): These callbacks may not actually be useful to you, but // NOTE(allen): These callbacks may not actually be useful to you, but
// go look at them and see what they do. // go look at them and see what they do.
bind_me(context, 'M', MDFR_ALT | MDFR_CTRL, open_my_files); bind_me(context, 'M', MDFR_ALT | MDFR_CTRL, open_my_files);
bind_me(context, 'M', MDFR_ALT, build_at_launch_location); bind_me(context, 'M', MDFR_ALT, build_at_launch_location);
bind_me(context, 'm', MDFR_ALT, build_search); bind_me(context, 'm', MDFR_ALT, build_search);
end_map(context); end_map(context);
begin_map(context, my_code_map); begin_map(context, my_code_map);
// NOTE(allen|a3.1): Set this map (my_code_map == mapid_user_custom) to // NOTE(allen|a3.1): Set this map (my_code_map == mapid_user_custom) to
// inherit from mapid_file. When searching if a key is bound // 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. // in this map, if it is not found here it will then search mapid_file.
@ -228,7 +228,7 @@ extern "C" GET_BINDING_DATA(get_bindings){
// NOTE(allen|a3.1): Children can override parent's bindings. // NOTE(allen|a3.1): Children can override parent's bindings.
bind(context, codes->right, MDFR_CTRL, cmdid_seek_alphanumeric_or_camel_right); bind(context, codes->right, MDFR_CTRL, cmdid_seek_alphanumeric_or_camel_right);
bind(context, codes->left, MDFR_CTRL, cmdid_seek_alphanumeric_or_camel_left); bind(context, codes->left, MDFR_CTRL, cmdid_seek_alphanumeric_or_camel_left);
// NOTE(allen|a3.2): Specific keys can override vanilla keys, // NOTE(allen|a3.2): Specific keys can override vanilla keys,
// and write character writes whichever character corresponds // and write character writes whichever character corresponds
// to the key that triggered the command. // to the key that triggered the command.
@ -237,11 +237,11 @@ extern "C" GET_BINDING_DATA(get_bindings){
bind_me(context, ')', MDFR_NONE, write_and_auto_tab); bind_me(context, ')', MDFR_NONE, write_and_auto_tab);
bind_me(context, ']', MDFR_NONE, write_and_auto_tab); bind_me(context, ']', MDFR_NONE, write_and_auto_tab);
bind_me(context, ';', MDFR_NONE, write_and_auto_tab); bind_me(context, ';', MDFR_NONE, write_and_auto_tab);
bind(context, '\t', MDFR_NONE, cmdid_auto_tab_line_at_cursor);
bind(context, '\t', MDFR_CTRL, cmdid_auto_tab_range);
bind(context, '\t', MDFR_CTRL | MDFR_SHIFT, cmdid_write_character);
bind(context, '\t', MDFR_NONE, cmdid_word_complete);
bind(context, '\t', MDFR_CTRL, cmdid_auto_tab_range);
bind(context, '\t', MDFR_SHIFT, cmdid_auto_tab_line_at_cursor);
end_map(context); end_map(context);

2
4coder_custom.h
View File

@ -64,6 +64,7 @@ enum Command_ID{
cmdid_seek_alphanumeric_or_camel_right, cmdid_seek_alphanumeric_or_camel_right,
cmdid_search, cmdid_search,
cmdid_rsearch, cmdid_rsearch,
cmdid_word_complete,
cmdid_goto_line, cmdid_goto_line,
cmdid_set_mark, cmdid_set_mark,
cmdid_copy, cmdid_copy,
@ -96,7 +97,6 @@ enum Command_ID{
cmdid_clean_all_lines, cmdid_clean_all_lines,
cmdid_eol_dosify, cmdid_eol_dosify,
cmdid_eol_nixify, cmdid_eol_nixify,
cmdid_auto_tab,
cmdid_auto_tab_range, cmdid_auto_tab_range,
cmdid_auto_tab_line_at_cursor, cmdid_auto_tab_line_at_cursor,
cmdid_auto_tab_whole_file, cmdid_auto_tab_whole_file,

1
4coder_string.h
View File

@ -173,6 +173,7 @@ FCPP_LINK int reverse_seek_slash(String str);
FCPP_LINK int reverse_seek_slash(String str, int start_pos); FCPP_LINK int reverse_seek_slash(String str, int start_pos);
inline bool get_front_of_directory(String *dest, String dir) { return append_checked(dest, substr(dir, reverse_seek_slash(dir) + 1)); } inline bool get_front_of_directory(String *dest, String dir) { return append_checked(dest, substr(dir, reverse_seek_slash(dir) + 1)); }
inline bool get_path_of_directory(String *dest, String dir) { return append_checked(dest, substr(dir, 0, reverse_seek_slash(dir) + 1)); } inline bool get_path_of_directory(String *dest, String dir) { return append_checked(dest, substr(dir, 0, reverse_seek_slash(dir) + 1)); }
inline void truncate_to_path_of_directory(String *dir) { dir->size = reverse_seek_slash(*dir) + 1; }
FCPP_LINK bool set_last_folder(String *dir, char *folder_name); FCPP_LINK bool set_last_folder(String *dir, char *folder_name);
FCPP_LINK bool set_last_folder(String *dir, String folder_name); FCPP_LINK bool set_last_folder(String *dir, String folder_name);
FCPP_LINK String file_extension(String str); FCPP_LINK String file_extension(String str);

110
4ed.cpp
View File

@ -44,6 +44,7 @@ struct Complete_State{
Table hits; Table hits;
String_Space str; String_Space str;
i32 word_start, word_end; i32 word_start, word_end;
b32 initialized;
}; };
struct App_Vars{ struct App_Vars{
@ -487,6 +488,10 @@ COMMAND_DECL(word_complete){
if (vars->prev_command.function != command_word_complete){ if (vars->prev_command.function != command_word_complete){
do_init = 1; do_init = 1;
} }
if (complete_state->initialized == 0){
do_init = 1;
}
if (do_init){ if (do_init){
word_end = view->cursor.pos; word_end = view->cursor.pos;
@ -514,6 +519,12 @@ COMMAND_DECL(word_complete){
size = word_end - word_start; size = word_end - word_start;
if (size == 0){
complete_state->initialized = 0;
return;
}
complete_state->initialized = 1;
search_iter_init(general, &complete_state->iter, size); search_iter_init(general, &complete_state->iter, size);
buffer_stringify(buffer, word_start, word_end, complete_state->iter.word.str); buffer_stringify(buffer, word_start, word_end, complete_state->iter.word.str);
complete_state->iter.word.size = size; complete_state->iter.word.size = size;
@ -863,65 +874,6 @@ COMMAND_DECL(interactive_new){
copy(&int_view->query, "New: "); copy(&int_view->query, "New: ");
} }
#if 0
internal File_View*
app_open_file(System_Functions *system, Exchange *exchange,
App_Vars *vars, Mem_Options *mem, 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;
b32 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){
file_get_dummy(file.file);
created_file = file_create(system, mem, file.file, 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(system, exchange, new_view, panel, live_set);
File_View *file_view = file_view_init(new_view, &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(system, 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 BUFFER_EXPERIMENT_SCALPEL <= 0
if (created_file && target_file->tokens_exist &&
target_file->token_stack.tokens == 0){
file_first_lex_parallel(system, &mem->general, target_file);
}
#endif
}
return result;
}
#endif
internal void internal void
app_push_file_binding(App_Vars *vars, int sys_id, int app_id){ app_push_file_binding(App_Vars *vars, int sys_id, int app_id){
Sys_App_Binding binding; Sys_App_Binding binding;
@ -951,7 +903,7 @@ app_open_file_background(App_Vars *vars, Exchange *exchange, Working_Set *workin
result.is_new = 1; result.is_new = 1;
result.file = file.file; result.file = file.file;
file_init_strings(result.file); file_init_strings(result.file);
file_set_name(result.file, filename.str); file_set_name(working_set, result.file, filename.str);
file_set_to_loading(result.file); file_set_to_loading(result.file);
table_add(&working_set->table, result.file->name.source_path, file.index); table_add(&working_set->table, result.file->name.source_path, file.index);
@ -1311,21 +1263,6 @@ COMMAND_DECL(eol_nixify){
file->state.last_4ed_edit_time = system->time(); file->state.last_4ed_edit_time = system->time();
} }
COMMAND_DECL(auto_tab){
#if 0
ProfileMomentFunction();
REQ_FILE_VIEW(view);
REQ_FILE(file, view);
USE_LAYOUT(layout);
USE_MEM(mem);
if (file->token_stack.tokens && file->tokens_complete){
Range range = get_range(view->cursor.pos, view->mark);
view_auto_tab_tokens(mem, view, layout, range.start, range.end);
}
#endif
}
COMMAND_DECL(auto_tab_range){ COMMAND_DECL(auto_tab_range){
ProfileMomentFunction(); ProfileMomentFunction();
REQ_FILE_VIEW(view); REQ_FILE_VIEW(view);
@ -1887,7 +1824,7 @@ build(System_Functions *system, Mem_Options *mem,
} }
if (file){ if (file){
file_create_super_locked(system, mem, file, buffer_name, font_set, style->font_id); file_create_super_locked(system, mem, working_set, file, buffer_name, font_set, style->font_id);
file->settings.unimportant = 1; file->settings.unimportant = 1;
table_add(&working_set->table, file->name.source_path, index); table_add(&working_set->table, file->name.source_path, index);
@ -2246,7 +2183,6 @@ setup_file_commands(Command_Map *commands, Partition *part, Key_Codes *codes, Co
map_add(commands, 'j', MDFR_CTRL, command_to_lowercase); map_add(commands, 'j', MDFR_CTRL, command_to_lowercase);
map_add(commands, '~', MDFR_CTRL, command_clean_all_lines); map_add(commands, '~', MDFR_CTRL, command_clean_all_lines);
map_add(commands, 'f', MDFR_CTRL, command_search); map_add(commands, 'f', MDFR_CTRL, command_search);
map_add(commands, 't', MDFR_CTRL, command_word_complete);
map_add(commands, 'r', MDFR_CTRL, command_rsearch); map_add(commands, 'r', MDFR_CTRL, command_rsearch);
map_add(commands, 'g', MDFR_CTRL, command_goto_line); map_add(commands, 'g', MDFR_CTRL, command_goto_line);
@ -2257,9 +2193,9 @@ setup_file_commands(Command_Map *commands, Partition *part, Key_Codes *codes, Co
map_add(commands, ']', MDFR_NONE, compose_write_auto_tab_line); map_add(commands, ']', MDFR_NONE, compose_write_auto_tab_line);
map_add(commands, ';', MDFR_NONE, compose_write_auto_tab_line); map_add(commands, ';', MDFR_NONE, compose_write_auto_tab_line);
map_add(commands, '\t', MDFR_NONE, command_auto_tab_line_at_cursor); map_add(commands, '\t', MDFR_NONE, command_word_complete);
map_add(commands, '\t', MDFR_CTRL, command_auto_tab_range); map_add(commands, '\t', MDFR_CTRL, command_auto_tab_range);
map_add(commands, '\t', MDFR_CTRL | MDFR_SHIFT, command_write_character); map_add(commands, '\t', MDFR_SHIFT, command_auto_tab_line_at_cursor);
map_add(commands, 'K', MDFR_CTRL, command_kill_buffer); map_add(commands, 'K', MDFR_CTRL, command_kill_buffer);
map_add(commands, 'O', MDFR_CTRL, command_reopen); map_add(commands, 'O', MDFR_CTRL, command_reopen);
@ -2312,6 +2248,7 @@ setup_command_table(){
SET(seek_alphanumeric_or_camel_left); SET(seek_alphanumeric_or_camel_left);
SET(search); SET(search);
SET(rsearch); SET(rsearch);
SET(word_complete);
SET(goto_line); SET(goto_line);
SET(set_mark); SET(set_mark);
SET(copy); SET(copy);
@ -2343,7 +2280,6 @@ setup_command_table(){
SET(clean_all_lines); SET(clean_all_lines);
SET(eol_dosify); SET(eol_dosify);
SET(eol_nixify); SET(eol_nixify);
SET(auto_tab);
SET(auto_tab_range); SET(auto_tab_range);
SET(auto_tab_line_at_cursor); SET(auto_tab_line_at_cursor);
SET(auto_tab_whole_file); SET(auto_tab_whole_file);
@ -3629,7 +3565,7 @@ App_Step_Sig(app_step){
if (fview){ if (fview){
Editing_File *file = fview->file; Editing_File *file = fview->file;
if (file && !file->state.is_dummy){ if (file && !file->state.is_dummy){
i32 sys_id = file_save_and_set_names(system, exchange, mem, file, string->str); i32 sys_id = file_save_and_set_names(system, exchange, mem, working_set, file, string->str);
app_push_file_binding(vars, sys_id, get_file_id(working_set, file)); app_push_file_binding(vars, sys_id, get_file_id(working_set, file));
} }
} }
@ -3647,7 +3583,7 @@ App_Step_Sig(app_step){
case DACT_NEW: case DACT_NEW:
{ {
Get_File_Result file = working_set_get_available_file(working_set); Get_File_Result file = working_set_get_available_file(working_set);
file_create_empty(system, mem, file.file, string->str, file_create_empty(system, mem, working_set, file.file, string->str,
vars->font_set, style->font_id); vars->font_set, style->font_id);
table_add(&working_set->table, file.file->name.source_path, file.index); table_add(&working_set->table, file.file->name.source_path, file.index);
@ -3818,20 +3754,22 @@ App_Step_Sig(app_step){
Editing_File_Preload preload_settings; Editing_File_Preload preload_settings;
char *filename; char *filename;
Working_Set *working_set = &vars->working_set;
if (exchange_file_ready(exchange, binding->sys_id, &data, &size, &max)){ if (exchange_file_ready(exchange, binding->sys_id, &data, &size, &max)){
ed_file = vars->working_set.files + binding->app_id; ed_file = working_set->files + binding->app_id;
filename = exchange_file_filename(exchange, binding->sys_id); filename = exchange_file_filename(exchange, binding->sys_id);
preload_settings = ed_file->preload; preload_settings = ed_file->preload;
if (data){ if (data){
String val = make_string((char*)data, size); String val = make_string((char*)data, size);
file_create_from_string(system, &vars->mem, ed_file, filename, file_create_from_string(system, &vars->mem, working_set, ed_file, filename,
vars->font_set, vars->style.font_id, val); vars->font_set, vars->style.font_id, val);
if (ed_file->settings.tokens_exist) if (ed_file->settings.tokens_exist)
file_first_lex_parallel(system, &vars->mem.general, ed_file); file_first_lex_parallel(system, &vars->mem.general, ed_file);
} }
else{ else{
file_create_empty(system, &vars->mem, ed_file, filename, file_create_empty(system, &vars->mem, working_set, ed_file, filename,
vars->font_set, vars->style.font_id); vars->font_set, vars->style.font_id);
} }
@ -3854,7 +3792,7 @@ App_Step_Sig(app_step){
exchange_clear_file(exchange, binding->sys_id); exchange_clear_file(exchange, binding->sys_id);
} }
Editing_File *file = get_file(&vars->working_set, binding->app_id); Editing_File *file = get_file(working_set, binding->app_id);
if (file){ if (file){
file_synchronize_times(system, file, file->name.source_path.str); file_synchronize_times(system, file, file->name.source_path.str);
} }

328
4ed_command.cpp
View File

@ -1,163 +1,165 @@
/* /*
* Mr. 4th Dimention - Allen Webster * Mr. 4th Dimention - Allen Webster
* *
* 19.08.2015 * 19.08.2015
* *
* Command management functions for 4coder * Command management functions for 4coder
* *
*/ */
// TOP // TOP
#define Command_Function_Sig(name) void (name)( \ #define Command_Function_Sig(name) void (name)( \
System_Functions *system, \ System_Functions *system, \
struct Command_Data *command, \ struct Command_Data *command, \
struct Command_Binding binding) struct Command_Binding binding)
typedef Command_Function_Sig(*Command_Function); typedef Command_Function_Sig(*Command_Function);
struct Command_Binding{ struct Command_Binding{
Command_Function function; Command_Function function;
Custom_Command_Function *custom; Custom_Command_Function *custom;
i64 hash; i64 hash;
}; };
struct Command_Map{ struct Command_Map{
Command_Map *parent; Command_Map *parent;
Command_Binding vanilla_keyboard_default; Command_Binding vanilla_keyboard_default;
Command_Binding *commands; Command_Binding *commands;
i32 count, max; i32 count, max;
}; };
internal void command_null(Command_Data *command); internal void command_null(Command_Data *command);
internal i64 internal i64
map_hash(u16 event_code, u8 modifiers){ map_hash(u16 event_code, u8 modifiers){
i64 result = (event_code << 8) | modifiers; i64 result = (event_code << 8) | modifiers;
return result; return result;
} }
internal b32 internal b32
map_add(Command_Map *map, u16 event_code, u8 modifiers, map_add(Command_Map *map, u16 event_code, u8 modifiers,
Command_Function function, Custom_Command_Function *custom = 0){ Command_Function function, Custom_Command_Function *custom = 0){
Assert(map->count * 8 < map->max * 7); Assert(map->count * 8 < map->max * 7);
Command_Binding bind; Command_Binding bind;
bind.function = function; bind.function = function;
bind.custom = custom; bind.custom = custom;
bind.hash = map_hash(event_code, modifiers); bind.hash = map_hash(event_code, modifiers);
i32 max = map->max; i32 max = map->max;
i32 index = bind.hash % max; i32 index = bind.hash % max;
Command_Binding entry; Command_Binding entry;
while ((entry = map->commands[index]).function && entry.hash != -1){ while ((entry = map->commands[index]).function && entry.hash != -1){
if (entry.hash == bind.hash){ if (entry.hash == bind.hash){
return 1; return 1;
} }
index = (index + 1) % max; index = (index + 1) % max;
} }
map->commands[index] = bind; map->commands[index] = bind;
++map->count; ++map->count;
return 0; return 0;
} }
internal b32 internal b32
map_find_entry(Command_Map *map, u16 event_code, u8 modifiers, map_find_entry(Command_Map *map, u16 event_code, u8 modifiers,
i32 *index_out){ i32 *index_out){
i64 hash = map_hash(event_code, modifiers); i64 hash = map_hash(event_code, modifiers);
i32 max = map->max; i32 max = map->max;
i32 index = hash % map->max; i32 index = hash % map->max;
Command_Binding entry; Command_Binding entry;
while ((entry = map->commands[index]).function){ while ((entry = map->commands[index]).function){
if (entry.hash == hash){ if (entry.hash == hash){
*index_out = index; *index_out = index;
return 1; return 1;
} }
index = (index + 1) % max; index = (index + 1) % max;
} }
return 0; return 0;
} }
internal b32 internal b32
map_find(Command_Map *map, u16 event_code, u8 modifiers, map_find(Command_Map *map, u16 event_code, u8 modifiers,
Command_Binding *bind_out){ Command_Binding *bind_out){
b32 result; b32 result;
i32 index; i32 index;
result = map_find_entry(map, event_code, modifiers, &index); result = map_find_entry(map, event_code, modifiers, &index);
if (result){ if (result){
*bind_out = map->commands[index]; *bind_out = map->commands[index];
} }
return result; return result;
} }
internal b32 internal b32
map_drop(Command_Map *map, u16 event_code, u8 modifiers){ map_drop(Command_Map *map, u16 event_code, u8 modifiers){
b32 result; b32 result;
i32 index; i32 index;
result = map_find_entry(map, event_code, modifiers, &index); result = map_find_entry(map, event_code, modifiers, &index);
if (result){ if (result){
map->commands[index].function = 0; map->commands[index].function = 0;
map->commands[index].hash = -1; map->commands[index].hash = -1;
} }
return result; return result;
} }
internal void internal void
map_init(Command_Map *commands, Partition *part, i32 max, Command_Map *parent){ map_init(Command_Map *commands, Partition *part, i32 max, Command_Map *parent){
max = ((max < 6)?(6):(max)); max = ((max < 6)?(6):(max));
commands->parent = parent; commands->parent = parent;
commands->commands = push_array(part, Command_Binding, max); commands->commands = push_array(part, Command_Binding, max);
memset(commands->commands, 0, max*sizeof(*commands->commands)); memset(commands->commands, 0, max*sizeof(*commands->commands));
commands->vanilla_keyboard_default = {}; commands->vanilla_keyboard_default = {};
commands->max = max; commands->max = max;
commands->count = 0; commands->count = 0;
} }
internal void internal void
map_get_vanilla_keyboard_default(Command_Map *map, u8 command, map_get_vanilla_keyboard_default(Command_Map *map, u8 command,
Command_Binding *bind_out){ Command_Binding *bind_out){
if (command == MDFR_NONE){ if (command == MDFR_NONE){
*bind_out = map->vanilla_keyboard_default; *bind_out = map->vanilla_keyboard_default;
} }
} }
inline u8 inline u8
apply_shift_to_code(u8 keycode){ apply_shift_to_code(u8 keycode){
return !(keycode >= 0x20 && keycode < 0x7F && keycode != ' '); return !(keycode >= 0x20 && keycode < 0x7F && keycode != ' ');
} }
internal Command_Binding internal Command_Binding
map_extract(Command_Map *map, Key_Event_Data key){ map_extract(Command_Map *map, Key_Event_Data key){
Command_Binding bind = {}; Command_Binding bind = {};
b32 ctrl = key.modifiers[CONTROL_KEY_CONTROL]; b32 ctrl = key.modifiers[CONTROL_KEY_CONTROL];
b32 alt = key.modifiers[CONTROL_KEY_ALT]; b32 alt = key.modifiers[CONTROL_KEY_ALT];
b32 shift = key.modifiers[CONTROL_KEY_SHIFT]; b32 shift = key.modifiers[CONTROL_KEY_SHIFT];
u16 code; u16 code;
u8 command = MDFR_NONE; u8 command = MDFR_NONE;
if (key.character_no_caps_lock != 0 && //if (key.character_no_caps_lock != 0 &&
key.character_no_caps_lock != ' ') shift = 0; // key.character_no_caps_lock != ' ') shift = 0;
if (shift) command |= MDFR_SHIFT; if (shift) command |= MDFR_SHIFT;
if (ctrl) command |= MDFR_CTRL; if (ctrl) command |= MDFR_CTRL;
if (alt) command |= MDFR_ALT; if (alt) command |= MDFR_ALT;
code = key.character_no_caps_lock; code = key.character_no_caps_lock;
if (code == 0){ if (code == 0){
code = key.keycode; code = key.keycode;
map_find(map, code, command, &bind); map_find(map, code, command, &bind);
} }
else{ else{
command &= ~(MDFR_SHIFT); if (code != '\n' && code != '\t' && code != ' '){
command &= ~(MDFR_SHIFT);
map_find(map, code, command, &bind); }
if (bind.function == 0){
map_get_vanilla_keyboard_default(map, command, &bind); map_find(map, code, command, &bind);
} if (bind.function == 0){
} map_get_vanilla_keyboard_default(map, command, &bind);
}
return bind; }
}
return bind;
// BOTTOM }
// BOTTOM

106
4ed_file_view.cpp
View File

@ -1203,16 +1203,30 @@ file_init_strings(Editing_File *file){
file->name.extension = make_fixed_width_string(file->name.extension_); file->name.extension = make_fixed_width_string(file->name.extension_);
} }
inline b32
file_is_ready(Editing_File *file){
b32 result = 0;
if (file && file->state.is_loading == 0){
result = 1;
}
return(result);
}
inline void inline void
file_set_name(Editing_File *file, char *filename){ file_set_name(Working_Set *working_set, Editing_File *file, char *filename){
String f, ext; String f, ext;
Editing_File *file_ptr;
i32 i, count, file_x, original_len;
b32 hit_conflict;
Assert(file->name.live_name.str != 0); Assert(file->name.live_name.str != 0);
f = make_string_slowly(filename); f = make_string_slowly(filename);
copy_checked(&file->name.source_path, f); copy_checked(&file->name.source_path, f);
file->name.live_name.size = 0; file->name.live_name.size = 0;
get_front_of_directory(&file->name.live_name, f); get_front_of_directory(&file->name.live_name, f);
if (file->name.source_path.size == file->name.live_name.size){ if (file->name.source_path.size == file->name.live_name.size){
file->name.extension.size = 0; file->name.extension.size = 0;
} }
@ -1220,6 +1234,31 @@ file_set_name(Editing_File *file, char *filename){
ext = file_extension(f); ext = file_extension(f);
copy(&file->name.extension, ext); copy(&file->name.extension, ext);
} }
original_len = file->name.live_name.size;
count = working_set->file_index_count;
hit_conflict = 1;
file_x = 0;
while (hit_conflict){
hit_conflict = 0;
file_ptr = working_set->files;
for (i = 0; i < count; ++i, ++file_ptr){
if (file_ptr != file && !file_ptr->state.is_dummy && file_is_ready(file_ptr)){
if (match(file->name.live_name, file_ptr->name.live_name)){
++file_x;
hit_conflict = 1;
break;
}
}
}
if (hit_conflict){
file->name.live_name.size = original_len;
append(&file->name.live_name, " <");
append_int_to_str(file_x, &file->name.live_name);
append(&file->name.live_name, ">");
}
}
} }
inline void inline void
@ -1271,11 +1310,12 @@ file_save(System_Functions *system, Exchange *exchange, Mem_Options *mem,
inline b32 inline b32
file_save_and_set_names(System_Functions *system, Exchange *exchange, file_save_and_set_names(System_Functions *system, Exchange *exchange,
Mem_Options *mem, Editing_File *file, char *filename){ Mem_Options *mem, Working_Set *working_set, Editing_File *file,
char *filename){
b32 result = 0; b32 result = 0;
result = file_save(system, exchange, mem, file, filename); result = file_save(system, exchange, mem, file, filename);
if (result){ if (result){
file_set_name(file, filename); file_set_name(working_set, file, filename);
} }
return result; return result;
} }
@ -1501,9 +1541,10 @@ alloc_for_buffer(void *context, int *size){
internal void internal void
file_create_from_string(System_Functions *system, Mem_Options *mem, file_create_from_string(System_Functions *system, Mem_Options *mem,
Editing_File *file, char *filename, Working_Set *working_set, Editing_File *file, char *filename,
Font_Set *set, i16 font_id, Font_Set *set, i16 font_id,
String val, b8 super_locked = 0){ String val, b8 super_locked = 0){
General_Memory *general = &mem->general; General_Memory *general = &mem->general;
Partition *part = &mem->part; Partition *part = &mem->part;
Buffer_Init_Type init; Buffer_Init_Type init;
@ -1529,7 +1570,7 @@ file_create_from_string(System_Functions *system, Mem_Options *mem,
#endif #endif
file_init_strings(file); file_init_strings(file);
file_set_name(file, (char*)filename); file_set_name(working_set, file, (char*)filename);
file->state.font_id = font_id; file->state.font_id = font_id;
@ -1570,20 +1611,25 @@ file_create_from_string(System_Functions *system, Mem_Options *mem,
} }
internal b32 internal b32
file_create_empty(System_Functions *system, Mem_Options *mem, Editing_File *file, file_create_empty(
char *filename, Font_Set *set, i16 font_id){ System_Functions *system, Mem_Options *mem,
Working_Set *working_set, Editing_File *file,
char *filename, Font_Set *set, i16 font_id){
b32 result = 1; b32 result = 1;
String empty_str = {}; String empty_str = {};
file_create_from_string(system, mem, file, filename, set, font_id, empty_str); file_create_from_string(system, mem, working_set, file, filename, set, font_id, empty_str);
return result; return result;
} }
internal b32 internal b32
file_create_super_locked(System_Functions *system, Mem_Options *mem, Editing_File *file, file_create_super_locked(
char *filename, Font_Set *set, i16 font_id){ System_Functions *system, Mem_Options *mem,
Working_Set *working_set, Editing_File *file,
char *filename, Font_Set *set, i16 font_id){
b32 result = 1; b32 result = 1;
String empty_str = {}; String empty_str = {};
file_create_from_string(system, mem, file, filename, set, font_id, empty_str, 1); file_create_from_string(system, mem, working_set, file, filename, set, font_id, empty_str, 1);
return result; return result;
} }
@ -1671,15 +1717,6 @@ file_set_to_loading(Editing_File *file){
file->state.is_loading = 1; file->state.is_loading = 1;
} }
inline b32
file_is_ready(Editing_File *file){
b32 result = 0;
if (file && file->state.is_loading == 0){
result = 1;
}
return(result);
}
struct Shift_Information{ struct Shift_Information{
i32 start, end, amount; i32 start, end, amount;
}; };
@ -2826,14 +2863,6 @@ file_do_single_edit(System_Functions *system,
void *old_data = buffer_edit_provide_memory(&file->state.buffer, new_data, request_amount); void *old_data = buffer_edit_provide_memory(&file->state.buffer, new_data, request_amount);
if (old_data) general_memory_free(general, old_data); if (old_data) general_memory_free(general, old_data);
} }
#if BUFFER_EXPERIMENT_SCALPEL == 3
buffer_rope_check(&file->buffer, part->base + part->pos, scratch_size);
#endif
#if BUFFER_EXPERIMENT_SCALPEL == 2
buffer_mugab_check(&file->buffer);
#endif
i32 line_start = buffer_get_line_index(&file->state.buffer, start); i32 line_start = buffer_get_line_index(&file->state.buffer, start);
i32 line_end = buffer_get_line_index(&file->state.buffer, end); i32 line_end = buffer_get_line_index(&file->state.buffer, end);
@ -3544,8 +3573,8 @@ view_auto_tab_tokens(System_Functions *system,
i32 start = file->state.buffer.line_starts[line_i]; i32 start = file->state.buffer.line_starts[line_i];
i32 preferred_indentation; i32 preferred_indentation;
i32 correct_indentation; i32 correct_indentation;
bool32 all_whitespace = 0; b32 all_whitespace = 0;
bool32 all_space = 0; b32 all_space = 0;
i32 hard_start = i32 hard_start =
buffer_find_hard_start(&file->state.buffer, start, &all_whitespace, &all_space, buffer_find_hard_start(&file->state.buffer, start, &all_whitespace, &all_space,
&preferred_indentation, 4); &preferred_indentation, 4);
@ -3565,6 +3594,7 @@ view_auto_tab_tokens(System_Functions *system,
new_edit.end = hard_start; new_edit.end = hard_start;
edits[edit_count++] = new_edit; edits[edit_count++] = new_edit;
} }
Assert(edit_count <= edit_max); Assert(edit_count <= edit_max);
} }
@ -3583,6 +3613,18 @@ view_auto_tab_tokens(System_Functions *system,
view_do_white_batch_edit(system, mem, view, file, layout, spec, hist_normal); view_do_white_batch_edit(system, mem, view, file, layout, spec, hist_normal);
} }
{
b32 all_whitespace = 0;
b32 all_space = 0;
i32 preferred_indentation;
i32 start = view->cursor.pos;
i32 hard_start = buffer_find_hard_start(
&file->state.buffer, start, &all_whitespace, &all_space,
&preferred_indentation, 4);
view_cursor_move(view, hard_start);
}
end_temp_memory(temp); end_temp_memory(temp);
#endif #endif
} }

1072
4ed_layout.cpp
View File

File diff suppressed because it is too large Load Diff

1006
4ed_rendering.cpp
View File

File diff suppressed because it is too large Load Diff

508
4ed_rendering_helper.cpp
View File

@ -1,241 +1,267 @@
/* /*
* Mr. 4th Dimention - Allen Webster * Mr. 4th Dimention - Allen Webster
* *
* 12.17.2014 * 12.17.2014
* *
* Rendering layer for project codename "4ed" * Rendering layer for project codename "4ed"
* *
*/ */
// TOP // TOP
inline void inline void
draw_push_clip(Render_Target *target, i32_Rect clip_box){ draw_push_clip(Render_Target *target, i32_Rect clip_box){
target->push_clip(target, clip_box); target->push_clip(target, clip_box);
} }
inline void inline void
draw_pop_clip(Render_Target *target){ draw_pop_clip(Render_Target *target){
target->pop_clip(target); target->pop_clip(target);
} }
internal void internal void
begin_render_section(Render_Target *target, System_Functions *system){ begin_render_section(Render_Target *target, System_Functions *system){
Font_Set *font_set = &target->font_set; Font_Set *font_set = &target->font_set;
system->acquire_lock(RENDER_LOCK); system->acquire_lock(RENDER_LOCK);
font_set->used_this_frame = 0; font_set->used_this_frame = 0;
memset(font_set->font_used_flags, 0, font_set->max); memset(font_set->font_used_flags, 0, font_set->max);
target->size = 0; target->size = 0;
target->clip_top = -1; target->clip_top = -1;
i32_Rect clip; i32_Rect clip;
clip.x0 = 0; clip.x0 = 0;
clip.y0 = 0; clip.y0 = 0;
clip.x1 = target->width; clip.x1 = target->width;
clip.y1 = target->height; clip.y1 = target->height;
draw_push_clip(target, clip); draw_push_clip(target, clip);
} }
internal void internal void
end_render_section(Render_Target *target, System_Functions *system){ end_render_section(Render_Target *target, System_Functions *system){
Assert(target->clip_top == 0); Assert(target->clip_top == 0);
system->release_lock(RENDER_LOCK); system->release_lock(RENDER_LOCK);
} }
internal void internal void
draw_rectangle(Render_Target *target, i32_Rect rect, u32 color){ draw_rectangle(Render_Target *target, i32_Rect rect, u32 color){
Render_Piece_Combined piece; Render_Piece_Combined piece;
piece.header.type = piece_type_rectangle; piece.header.type = piece_type_rectangle;
piece.rectangle.rect = f32R(rect); piece.rectangle.rect = f32R(rect);
piece.rectangle.color = color; piece.rectangle.color = color;
target->push_piece(target, piece); target->push_piece(target, piece);
} }
internal void internal void
draw_rectangle(Render_Target *target, f32_Rect rect, u32 color){ draw_rectangle(Render_Target *target, f32_Rect rect, u32 color){
Render_Piece_Combined piece; Render_Piece_Combined piece;
piece.header.type = piece_type_rectangle; piece.header.type = piece_type_rectangle;
piece.rectangle.rect = rect; piece.rectangle.rect = rect;
piece.rectangle.color = color; piece.rectangle.color = color;
target->push_piece(target, piece); target->push_piece(target, piece);
} }
internal void internal void
draw_gradient_2corner_clipped(Render_Target *target, f32_Rect rect, draw_gradient_2corner_clipped(Render_Target *target, f32_Rect rect,
Vec4 left_color, Vec4 right_color){ Vec4 left_color, Vec4 right_color){
Render_Piece_Combined piece; Render_Piece_Combined piece;
piece.header.type = piece_type_gradient; piece.header.type = piece_type_gradient;
piece.gradient.rect = rect; piece.gradient.rect = rect;
piece.gradient.left_color = pack_color4(left_color); piece.gradient.left_color = pack_color4(left_color);
piece.gradient.right_color = pack_color4(right_color); piece.gradient.right_color = pack_color4(right_color);
target->push_piece(target, piece); target->push_piece(target, piece);
} }
inline void inline void
draw_gradient_2corner_clipped(Render_Target *target, f32 l, f32 t, f32 r, f32 b, draw_gradient_2corner_clipped(Render_Target *target, f32 l, f32 t, f32 r, f32 b,
Vec4 color_left, Vec4 color_right){ Vec4 color_left, Vec4 color_right){
draw_gradient_2corner_clipped(target, f32R(l,t,r,b), color_left, color_right); draw_gradient_2corner_clipped(target, f32R(l,t,r,b), color_left, color_right);
} }
internal void internal void
draw_rectangle_outline(Render_Target *target, f32_Rect rect, u32 color){ draw_rectangle_outline(Render_Target *target, f32_Rect rect, u32 color){
Render_Piece_Combined piece; Render_Piece_Combined piece;
piece.header.type = piece_type_outline; piece.header.type = piece_type_outline;
piece.rectangle.rect = rect; piece.rectangle.rect = rect;
piece.rectangle.color = color; piece.rectangle.color = color;
target->push_piece(target, piece); target->push_piece(target, piece);
} }
inline void inline void
draw_rectangle_outline(Render_Target *target, i32_Rect rect, u32 color){ draw_rectangle_outline(Render_Target *target, i32_Rect rect, u32 color){
draw_rectangle_outline(target, f32R(rect), color); draw_rectangle_outline(target, f32R(rect), color);
} }
internal void internal void
draw_margin(Render_Target *target, i32_Rect outer, i32_Rect inner, u32 color){ draw_margin(Render_Target *target, i32_Rect outer, i32_Rect inner, u32 color){
draw_rectangle(target, i32R(outer.x0, outer.y0, outer.x1, inner.y0), color); draw_rectangle(target, i32R(outer.x0, outer.y0, outer.x1, inner.y0), color);
draw_rectangle(target, i32R(outer.x0, inner.y1, outer.x1, outer.y1), color); draw_rectangle(target, i32R(outer.x0, inner.y1, outer.x1, outer.y1), color);
draw_rectangle(target, i32R(outer.x0, inner.y0, inner.x0, inner.y1), color); draw_rectangle(target, i32R(outer.x0, inner.y0, inner.x0, inner.y1), color);
draw_rectangle(target, i32R(inner.x1, inner.y0, outer.x1, inner.y1), color); draw_rectangle(target, i32R(inner.x1, inner.y0, outer.x1, inner.y1), color);
} }
inline void inline void
draw_margin(Render_Target *target, i32_Rect outer, i32 width, u32 color){ draw_margin(Render_Target *target, i32_Rect outer, i32 width, u32 color){
i32_Rect inner = get_inner_rect(outer, width); i32_Rect inner = get_inner_rect(outer, width);
draw_margin(target, outer, inner, color); draw_margin(target, outer, inner, color);
} }
inline internal i32 inline internal i32
font_predict_size(i32 pt_size){ font_predict_size(i32 pt_size){
return pt_size*pt_size*128; return pt_size*pt_size*128;
} }
internal void internal void
font_set_tabwidth(Render_Font *font, i32 tab_width){ font_set_tabwidth(Render_Font *font, i32 tab_width){
font->chardata['\t'].xadvance *= font->chardata[' '].xadvance * tab_width; font->chardata['\t'].xadvance *= font->chardata[' '].xadvance * tab_width;
} }
internal void internal void
font_draw_glyph_mono(Render_Target *target, i16 font_id, font_draw_glyph_mono(Render_Target *target, i16 font_id,
u8 character, f32 x, f32 y, f32 advance, u32 color){ u8 character, f32 x, f32 y, f32 advance, u32 color){
Render_Piece_Combined piece; Render_Piece_Combined piece;
piece.header.type = piece_type_mono_glyph; piece.header.type = piece_type_mono_glyph;
piece.glyph.pos.x = x; piece.glyph.pos.x = x;
piece.glyph.pos.y = y; piece.glyph.pos.y = y;
piece.glyph.color = color; piece.glyph.color = color;
piece.glyph.font_id = font_id; piece.glyph.font_id = font_id;
piece.glyph.character = character; piece.glyph.character = character;
target->push_piece(target, piece); target->push_piece(target, piece);
font_set_use(target->partition, &target->font_set, font_id); font_set_use(target->partition, &target->font_set, font_id);
} }
inline void inline void
font_draw_glyph_mono(Render_Target *target, i16 font_id, font_draw_glyph_mono(Render_Target *target, i16 font_id,
u8 character, f32 x, f32 y, u32 color){ u8 character, f32 x, f32 y, u32 color){
f32 advance = (f32)get_font_info(&target->font_set, font_id)->advance; f32 advance = (f32)get_font_info(&target->font_set, font_id)->advance;
font_draw_glyph_mono(target, font_id, character, x, y, advance, color); font_draw_glyph_mono(target, font_id, character, x, y, advance, color);
} }
internal void internal void
font_draw_glyph(Render_Target *target, i16 font_id, font_draw_glyph(Render_Target *target, i16 font_id,
u8 character, f32 x, f32 y, u32 color){ u8 character, f32 x, f32 y, u32 color){
Render_Piece_Combined piece; Render_Piece_Combined piece;
piece.header.type = piece_type_glyph; piece.header.type = piece_type_glyph;
piece.glyph.pos.x = x; piece.glyph.pos.x = x;
piece.glyph.pos.y = y; piece.glyph.pos.y = y;
piece.glyph.color = color; piece.glyph.color = color;
piece.glyph.font_id = font_id; piece.glyph.font_id = font_id;
piece.glyph.character = character; piece.glyph.character = character;
target->push_piece(target, piece); target->push_piece(target, piece);
font_set_use(target->partition, &target->font_set, font_id); font_set_use(target->partition, &target->font_set, font_id);
} }
inline f32 inline f32
font_get_glyph_width(Render_Target *target, i16 font_id, u16 character){ font_get_glyph_width(Render_Target *target, i16 font_id, u16 character){
Render_Font *font = get_font_info(&target->font_set, font_id)->font; Render_Font *font = get_font_info(&target->font_set, font_id)->font;
f32 result = 0.f; f32 result = 0.f;
if (font) result = font->chardata[character].xadvance; if (font) result = font->chardata[character].xadvance;
return (result); return (result);
} }
internal f32 internal f32
font_string_width(Render_Target *target, i16 font_id, char *str){ font_string_width(Render_Target *target, i16 font_id, char *str){
f32 x = 0; f32 x = 0;
for (i32 i = 0; str[i]; ++i){ for (i32 i = 0; str[i]; ++i){
x += font_get_glyph_width(target, font_id, str[i]); u8 c = str[i];
} // TODO(allen): Someday let's not punt on the the unicode rendering
return x; c = c % 128;
} x += font_get_glyph_width(target, font_id, c);
}
internal i32 return x;
draw_string(Render_Target *target, i16 font_id, }
char *str, i32 x_, i32 y, u32 color){
real32 x = (real32)x_; internal f32
for (i32 i = 0; str[i]; ++i){ font_string_width(Render_Target *target, i16 font_id, String str){
char c = str[i]; f32 x = 0;
font_draw_glyph(target, font_id, c, x, (f32)y, color); for (i32 i = 0; i < str.size; ++i){
x += font_get_glyph_width(target, font_id, c); u8 c = str.str[i];
} // TODO(allen): Someday let's not punt on the the unicode rendering
return CEIL32(x); c = c % 128;
} x += font_get_glyph_width(target, font_id, c);
}
internal f32 return x;
draw_string_mono(Render_Target *target, i16 font_id, }
char *str, f32 x, f32 y, f32 advance, u32 color){
for (i32 i = 0; str[i]; ++i){ internal i32
font_draw_glyph_mono(target, font_id, str[i], draw_string(Render_Target *target, i16 font_id,
x, y, advance, color); char *str, i32 x_, i32 y, u32 color){
x += advance; real32 x = (real32)x_;
} for (i32 i = 0; str[i]; ++i){
return x; u8 c = str[i];
} // TODO(allen): Someday let's not punt on the the unicode rendering
c = c % 128;
internal i32 font_draw_glyph(target, font_id, c, x, (f32)y, color);
draw_string(Render_Target *target, i16 font_id, x += font_get_glyph_width(target, font_id, c);
String str, i32 x_, i32 y, u32 color){ }
f32 x = (f32)x_; return CEIL32(x);
for (i32 i = 0; i < str.size; ++i){ }
char c = str.str[i];
font_draw_glyph(target, font_id, c, internal f32
x, (f32)y, color); draw_string_mono(Render_Target *target, i16 font_id,
x += font_get_glyph_width(target, font_id, c); char *str, f32 x, f32 y, f32 advance, u32 color){
} for (i32 i = 0; str[i]; ++i){
return CEIL32(x); u8 c = str[i];
} // TODO(allen): Someday let's not punt on the the unicode rendering
c = c % 128;
internal f32 font_draw_glyph_mono(target, font_id, c, x, y, advance, color);
draw_string_mono(Render_Target *target, i16 font_id, x += advance;
String str, f32 x, f32 y, f32 advance, u32 color){ }
for (i32 i = 0; i < str.size; ++i){ return x;
font_draw_glyph_mono(target, font_id, }
str.str[i], x, y, advance, color);
x += advance; internal i32
} draw_string(Render_Target *target, i16 font_id,
return x; String str, i32 x_, i32 y, u32 color){
} f32 x = (f32)x_;
for (i32 i = 0; i < str.size; ++i){
internal f32 u8 c = str.str[i];
font_get_max_width(Font_Set *font_set, i16 font_id, char *characters){ // TODO(allen): Someday let's not punt on the the unicode rendering
Render_Font *font = get_font_info(font_set, font_id)->font; c = c % 128;
f32 cx, x = 0; font_draw_glyph(target, font_id, c,
if (font){ x, (f32)y, color);
stbtt_packedchar *chardata = font->chardata; x += font_get_glyph_width(target, font_id, c);
for (i32 i = 0; characters[i]; ++i){ }
cx = chardata[characters[i]].xadvance; return CEIL32(x);
if (x < cx) x = cx; }
}
} internal f32
return x; draw_string_mono(Render_Target *target, i16 font_id,
} String str, f32 x, f32 y, f32 advance, u32 color){
for (i32 i = 0; i < str.size; ++i){
internal f32 u8 c = str.str[i];
font_get_string_width(Render_Target *target, i16 font_id, String string){ // TODO(allen): Someday let's not punt on the the unicode rendering
f32 result = 0; c = c % 128;
for (i32 i = 0; i < string.size; ++i){ font_draw_glyph_mono(target, font_id, c, x, y, advance, color);
font_get_glyph_width(target, font_id, string.str[i]); x += advance;
} }
return result; return x;
} }
// BOTTOM internal f32
font_get_max_width(Font_Set *font_set, i16 font_id, char *characters){
Render_Font *font = get_font_info(font_set, font_id)->font;
f32 cx, x = 0;
if (font){
stbtt_packedchar *chardata = font->chardata;
for (i32 i = 0; characters[i]; ++i){
cx = chardata[characters[i]].xadvance;
if (x < cx) x = cx;
}
}
return x;
}
internal f32
font_get_string_width(Render_Target *target, i16 font_id, String string){
f32 result = 0;
for (i32 i = 0; i < string.size; ++i){
u8 c = string.str[i];
// TODO(allen): Someday let's not punt on the the unicode rendering
c = c % 128;
font_get_glyph_width(target, font_id, c);
}
return result;
}
// BOTTOM

94
linux_4ed.cpp
View File

@ -1061,100 +1061,6 @@ main(int argc, char **argv)
}break; }break;
} }
#if 0
if((Event.xcookie.type == GenericEvent) &&
(Event.xcookie.extension == XInput2OpCode) &&
XGetEventData(linuxvars.XDisplay, &Event.xcookie))
{
switch(Event.xcookie.evtype)
{
case XI_Motion:
{
Window root_return, child_return;
int root_x_return, root_y_return;
int MouseX, MouseY;
unsigned int mask_return;
XQueryPointer(linuxvars.XDisplay,
linuxvars.XWindow,
&root_return, &child_return,
&root_x_return, &root_y_return,
&MouseX, &MouseY,
&mask_return);
} break;
case XI_ButtonPress:
case XI_ButtonRelease:
{
b32 Down = (Event.xcookie.evtype == XI_ButtonPress);
XIDeviceEvent *DevEvent = (XIDeviceEvent *)Event.xcookie.data;
int Button = DevEvent->detail;
} break;
case XI_KeyPress:
case XI_KeyRelease:
{
b32 Down = (Event.xcookie.evtype == XI_KeyPress);
XIDeviceEvent *DevEvent = (XIDeviceEvent *)Event.xcookie.data;
int keycode = DevEvent->detail;
if (Down){
printf("Keycode %d\n", keycode);
// NOTE(allen): Thanks to eisbehr for providing the code
// for initializing an XKeyPressedEvent struct for use in
// Xmb8LookupString
XKeyPressedEvent eventBase = {};
eventBase.type = KeyPress;
eventBase.serial = 0xF00D;
eventBase.send_event = 1; // at least admit that this isn't a genuine event
eventBase.display = DevEvent->display;
eventBase.window = DevEvent->event;
eventBase.root = DevEvent->root;
eventBase.subwindow = 0;
eventBase.time = {}; // Let's hope we don't need a real time.
eventBase.x = 0;
eventBase.y = 0;
eventBase.x_root = 0;
eventBase.y_root = 0;
eventBase.state = 0; // state of modifiers
// Button1Mask, Button2Mask, Button3Mask, Button4Mask, Button5Mask,
// ShiftMask, LockMask, ControlMask,
// Mod1Mask, Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask.
//eventBase.keycode = 10;//minKeyCode;
eventBase.same_screen = 1;
eventBase.keycode = keycode;
char lookup_buffer[32];
Status status;
i32 size;
KeySym keysym;
size = XmbLookupString(linuxvars.xic, &eventBase,
lookup_buffer, sizeof(lookup_buffer),
&keysym, &status);
if (status == XBufferOverflow){
printf("Buffer overflow %d\n", size);
}
else if (status == XLookupNone){
printf("nothing branch\n");
}
else if (status == XLookupChars || status == XLookupBoth){
printf("keysym %lu translation: %.*s\n", keysym, size, lookup_buffer);
}
else{
printf("unknown branch %d\n", status);
}
break;
}
} break;
}
XFreeEventData(linuxvars.XDisplay, &Event.xcookie);
}
#endif
} }
b32 redraw = 1; b32 redraw = 1;

2
system_shared.h
View File

@ -37,12 +37,14 @@ struct Font_Load_System{
#define Sys_File_Can_Be_Made(name) b32 name(char *filename) #define Sys_File_Can_Be_Made(name) b32 name(char *filename)
#define Sys_Load_File_Sig(name) Data name(char *filename) #define Sys_Load_File_Sig(name) Data name(char *filename)
#define Sys_Save_File_Sig(name) b32 name(char *filename, char *data, i32 size) #define Sys_Save_File_Sig(name) b32 name(char *filename, char *data, i32 size)
#define Sys_To_Binary_Path(name) b32 name(String *out_filename, char *filename)
internal Sys_Get_Memory_Sig(system_get_memory_); internal Sys_Get_Memory_Sig(system_get_memory_);
internal Sys_Free_Memory_Sig(system_free_memory); internal Sys_Free_Memory_Sig(system_free_memory);
internal Sys_File_Can_Be_Made(system_file_can_be_made); internal Sys_File_Can_Be_Made(system_file_can_be_made);
internal Sys_Load_File_Sig(system_load_file); internal Sys_Load_File_Sig(system_load_file);
internal Sys_Save_File_Sig(system_save_file); internal Sys_Save_File_Sig(system_save_file);
internal Sys_To_Binary_Path(system_to_binary_path);
#define system_get_memory(size) system_get_memory_((size), __LINE__, __FILE__) #define system_get_memory(size) system_get_memory_((size), __LINE__, __FILE__)

BIN
vc120.pdb
View File

Binary file not shown.

3606
win32_4ed.cpp
View File

File diff suppressed because it is too large Load Diff