4coder-non-source/test_data/lots_of_files/4ed_file_view.cpp

4165 lines
134 KiB
C++
Raw Normal View History

2023-09-30 01:17:40 +00:00
/*
* Mr. 4th Dimention - Allen Webster
*
* 19.08.2015
*
* File editing view for 4coder
*
*/
// TOP
enum Interactive_Action{
IAct_Open,
IAct_Save_As,
IAct_New,
IAct_Switch,
IAct_Kill,
IAct_Sure_To_Kill
};
enum Interactive_Interaction{
IInt_Sys_File_List,
IInt_Live_File_List,
IInt_Sure_To_Kill
};
struct View_Mode{
i32 rewrite;
};
enum View_Widget_Type{
FWIDG_NONE,
FWIDG_TIMELINES,
// never below this
FWIDG_TYPE_COUNT
};
struct View_Widget{
UI_State state;
View_Widget_Type type;
i32 height_;
struct{
b32 undo_line;
b32 history_line;
} timeline;
};
enum View_UI{
VUI_None,
VUI_Theme,
VUI_Interactive,
VUI_Menu,
VUI_Config,
};
enum Color_View_Mode{
CV_Mode_Library,
CV_Mode_Import_File,
CV_Mode_Export_File,
CV_Mode_Import,
CV_Mode_Export,
CV_Mode_Import_Wait,
CV_Mode_Adjusting
};
struct View{
View *next, *prev;
b32 in_use;
i32 id;
Models *models;
Panel *panel;
Command_Map *map;
Editing_File *file;
UI_State ui_state;
View_UI showing_ui;
// interactive stuff
Interactive_Interaction interaction;
Interactive_Action action;
b32 finished;
char query_[256];
char dest_[256];
String query;
String dest;
i32 user_action;
// theme stuff
View *hot_file_view;
u32 *palette;
i32 palette_size;
Color_View_Mode color_mode;
Super_Color color;
Color_Highlight highlight;
b32 p4c_only;
Style_Library inspecting_styles;
b8 import_export_check[64];
i32 import_file_id;
// file stuff
i32 font_advance;
i32 font_height;
Full_Cursor cursor;
i32 mark;
f32 scroll_y, target_y, prev_target_y;
f32 scroll_x, target_x, prev_target_x;
f32 preferred_x;
i32 scroll_i;
f32 scroll_min_limit;
Full_Cursor temp_highlight;
i32 temp_highlight_end_pos;
b32 show_temp_highlight;
View_Mode mode, next_mode;
View_Widget widget;
Query_Set query_set;
i32 scrub_max;
b32 unwrapped_lines;
b32 show_whitespace;
b32 file_locked;
i32 line_count, line_max;
f32 *line_wrap_y;
Command_Map *map_for_file;
b32 reinit_scrolling;
};
struct View_And_ID{
View *view;
i32 id;
};
#define LockLevel_Open 0
#define LockLevel_NoWrite 1
#define LockLevel_NoUpdate 2
inline i32
view_lock_level(View *view){
i32 result = LockLevel_Open;
if (view->showing_ui != VUI_None) result = LockLevel_NoUpdate;
else if (view->file_locked ||
(view->file && view->file->settings.read_only)) result = LockLevel_NoWrite;
return(result);
}
inline f32
view_compute_width(View *view){
Panel *panel = view->panel;
return (f32)(panel->inner.x1 - panel->inner.x0);
}
inline f32
view_compute_height(View *view){
Panel *panel = view->panel;
return (f32)(panel->inner.y1 - panel->inner.y0);
}
struct View_Iter{
View *view;
Editing_File *file;
View *skip;
Panel *used_panels;
Panel *panel;
};
internal View_Iter
file_view_iter_next(View_Iter iter){
View *file_view;
for (iter.panel = iter.panel->next; iter.panel != iter.used_panels; iter.panel = iter.panel->next){
file_view = iter.panel->view;
if (file_view != iter.skip && (file_view->file == iter.file || iter.file == 0)){
iter.view = file_view;
break;
}
}
return(iter);
}
internal View_Iter
file_view_iter_init(Editing_Layout *layout, Editing_File *file, View *skip){
View_Iter result;
result.used_panels = &layout->used_sentinel;
result.panel = result.used_panels;
result.file = file;
result.skip = skip;
result = file_view_iter_next(result);
return(result);
}
internal b32
file_view_iter_good(View_Iter iter){
b32 result = (iter.panel != iter.used_panels);
return(result);
}
inline b32
starts_new_line(u8 character){
return (character == '\n');
}
inline void
file_init_strings(Editing_File *file){
file->name.source_path = make_fixed_width_string(file->name.source_path_);
file->name.live_name = make_fixed_width_string(file->name.live_name_);
file->name.extension = make_fixed_width_string(file->name.extension_);
}
inline void
file_set_name(Working_Set *working_set, Editing_File *file, char *filename){
String f, ext;
Assert(file->name.live_name.str != 0);
f = make_string_slowly(filename);
copy_checked(&file->name.source_path, f);
file->name.live_name.size = 0;
get_front_of_directory(&file->name.live_name, f);
if (file->name.source_path.size == file->name.live_name.size){
file->name.extension.size = 0;
}
else{
ext = file_extension(f);
copy(&file->name.extension, ext);
}
{
File_Node *node, *used_nodes;
Editing_File *file_ptr;
i32 file_x, original_len;
b32 hit_conflict;
used_nodes = &working_set->used_sentinel;
original_len = file->name.live_name.size;
hit_conflict = 1;
file_x = 0;
while (hit_conflict){
hit_conflict = 0;
for (dll_items(node, used_nodes)){
file_ptr = (Editing_File*)node;
if (file_ptr != file && 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
file_synchronize_times(System_Functions *system, Editing_File *file, char *filename){
u64 stamp = system->file_time_stamp(filename);
if (stamp > 0){
file->state.last_4ed_write_time = stamp;
file->state.last_4ed_edit_time = stamp;
file->state.last_sys_write_time = stamp;
}
}
internal i32
file_save(System_Functions *system, Exchange *exchange, Mem_Options *mem,
Editing_File *file, char *filename){
i32 result = 0;
i32 max, size;
b32 dos_write_mode = file->settings.dos_write_mode;
char *data;
Buffer_Type *buffer = &file->state.buffer;
if (dos_write_mode)
max = buffer_size(buffer) + buffer->line_count + 1;
else
max = buffer_size(buffer);
data = (char*)general_memory_allocate(&mem->general, max, 0);
Assert(data);
if (dos_write_mode)
size = buffer_convert_out(buffer, data, max);
else
buffer_stringify(buffer, 0, size = max, data);
result = exchange_save_file(exchange, filename, str_size(filename), (byte*)data, size, max);
if (result == 0){
general_memory_free(&mem->general, data);
}
file_synchronize_times(system, file, filename);
return(result);
}
inline b32
file_save_and_set_names(System_Functions *system, Exchange *exchange,
Mem_Options *mem, Working_Set *working_set, Editing_File *file,
char *filename){
b32 result = 0;
result = file_save(system, exchange, mem, file, filename);
if (result){
file_set_name(working_set, file, filename);
}
return result;
}
enum File_Bubble_Type{
BUBBLE_BUFFER = 1,
BUBBLE_STARTS,
BUBBLE_WIDTHS,
BUBBLE_WRAPS,
BUBBLE_TOKENS,
BUBBLE_UNDO_STRING,
BUBBLE_UNDO,
BUBBLE_UNDO_CHILDREN,
//
FILE_BUBBLE_TYPE_END,
};
#define GROW_FAILED 0
#define GROW_NOT_NEEDED 1
#define GROW_SUCCESS 2
internal i32
file_grow_starts_widths_as_needed(General_Memory *general, Buffer_Type *buffer, i32 additional_lines){
b32 result = GROW_NOT_NEEDED;
i32 max = buffer->line_max;
i32 count = buffer->line_count;
i32 target_lines = count + additional_lines;
Assert(max == buffer->widths_max);
if (target_lines > max || max == 0){
max = LargeRoundUp(target_lines + max, Kbytes(1));
f32 *new_widths = (f32*)general_memory_reallocate(
general, buffer->line_widths,
sizeof(f32)*count, sizeof(f32)*max, BUBBLE_WIDTHS);
i32 *new_lines = (i32*)general_memory_reallocate(
general, buffer->line_starts,
sizeof(i32)*count, sizeof(i32)*max, BUBBLE_STARTS);
if (new_lines){
buffer->line_starts = new_lines;
buffer->line_max = max;
}
if (new_widths){
buffer->line_widths = new_widths;
buffer->widths_max = max;
}
if (new_lines && new_widths){
result = GROW_SUCCESS;
}
else{
result = GROW_FAILED;
}
}
return(result);
}
internal void
file_measure_starts_widths(System_Functions *system, General_Memory *general,
Buffer_Type *buffer, float *advance_data){
ProfileMomentFunction();
if (!buffer->line_starts){
i32 max = buffer->line_max = Kbytes(1);
buffer->line_starts = (i32*)general_memory_allocate(general, max*sizeof(i32), BUBBLE_STARTS);
TentativeAssert(buffer->line_starts);
// TODO(allen): when unable to allocate?
}
if (!buffer->line_widths){
i32 max = buffer->widths_max = Kbytes(1);
buffer->line_widths = (f32*)general_memory_allocate(general, max*sizeof(f32), BUBBLE_STARTS);
TentativeAssert(buffer->line_starts);
// TODO(allen): when unable to allocate?
}
Buffer_Measure_Starts state = {};
while (buffer_measure_starts_widths(&state, buffer, advance_data)){
i32 count = state.count;
i32 max = buffer->line_max;
max = ((max + 1) << 1);
{
i32 *new_lines = (i32*)general_memory_reallocate(
general, buffer->line_starts, sizeof(i32)*count, sizeof(i32)*max, BUBBLE_STARTS);
// TODO(allen): when unable to grow?
TentativeAssert(new_lines);
buffer->line_starts = new_lines;
buffer->line_max = max;
}
{
f32 *new_lines = (f32*)
general_memory_reallocate(general, buffer->line_widths,
sizeof(f32)*count, sizeof(f32)*max, BUBBLE_WIDTHS);
// TODO(allen): when unable to grow?
TentativeAssert(new_lines);
buffer->line_widths = new_lines;
buffer->widths_max = max;
}
}
buffer->line_count = state.count;
buffer->widths_count = state.count;
}
struct Opaque_Font_Advance{
void *data;
int stride;
};
inline Opaque_Font_Advance
get_opaque_font_advance(Render_Font *font){
Opaque_Font_Advance result;
result.data = (char*)font->chardata + OffsetOfPtr(font->chardata, xadvance);
result.stride = sizeof(*font->chardata);
return result;
}
internal void
file_remeasure_widths_(System_Functions *system,
General_Memory *general, Buffer_Type *buffer, Render_Font *font,
i32 line_start, i32 line_end, i32 line_shift){
ProfileMomentFunction();
file_grow_starts_widths_as_needed(general, buffer, line_shift);
buffer_remeasure_widths(buffer, font->advance_data, line_start, line_end, line_shift);
}
inline i32
view_wrapped_line_span(f32 line_width, f32 max_width){
i32 line_count = CEIL32(line_width / max_width);
if (line_count == 0) line_count = 1;
return line_count;
}
internal i32
view_compute_lowest_line(View *view){
i32 lowest_line = 0;
i32 last_line = view->line_count - 1;
if (last_line > 0){
if (view->unwrapped_lines){
lowest_line = last_line;
}
else{
f32 wrap_y = view->line_wrap_y[last_line];
lowest_line = FLOOR32(wrap_y / view->font_height);
f32 max_width = view_compute_width(view);
Editing_File *file = view->file;
Assert(!file->state.is_dummy);
f32 width = file->state.buffer.line_widths[last_line];
i32 line_span = view_wrapped_line_span(width, max_width);
lowest_line += line_span - 1;
}
}
return lowest_line;
}
internal void
view_measure_wraps(System_Functions *system,
General_Memory *general, View *view){
ProfileMomentFunction();
Buffer_Type *buffer;
buffer = &view->file->state.buffer;
i32 line_count = buffer->line_count;
if (view->line_max < line_count){
i32 max = view->line_max = LargeRoundUp(line_count, Kbytes(1));
if (view->line_wrap_y){
view->line_wrap_y = (real32*)
general_memory_reallocate_nocopy(general, view->line_wrap_y, sizeof(real32)*max, BUBBLE_WRAPS);
}
else{
view->line_wrap_y = (real32*)
general_memory_allocate(general, sizeof(real32)*max, BUBBLE_WRAPS);
}
}
f32 line_height = (f32)view->font_height;
f32 max_width = view_compute_width(view);
buffer_measure_wrap_y(buffer, view->line_wrap_y, line_height, max_width);
view->line_count = line_count;
}
internal void*
alloc_for_buffer(void *context, int *size){
*size = LargeRoundUp(*size, Kbytes(4));
void *data = general_memory_allocate((General_Memory*)context, *size, BUBBLE_BUFFER);
return data;
}
internal void
file_create_from_string(System_Functions *system, Models *models,
Editing_File *file, char *filename, String val, b8 read_only = 0){
Font_Set *font_set = models->font_set;
Working_Set *working_set = &models->working_set;
General_Memory *general = &models->mem.general;
Partition *part = &models->mem.part;
Buffer_Init_Type init;
i32 page_size, scratch_size, init_success;
file->state = {};
init = buffer_begin_init(&file->state.buffer, val.str, val.size);
for (; buffer_init_need_more(&init); ){
page_size = buffer_init_page_size(&init);
page_size = LargeRoundUp(page_size, Kbytes(4));
if (page_size < Kbytes(4)) page_size = Kbytes(4);
void *data = general_memory_allocate(general, page_size, BUBBLE_BUFFER);
buffer_init_provide_page(&init, data, page_size);
}
scratch_size = partition_remaining(part);
Assert(scratch_size > 0);
init_success = buffer_end_init(&init, part->base + part->pos, scratch_size);
AllowLocal(init_success);
Assert(init_success);
if (buffer_size(&file->state.buffer) < val.size){
file->settings.dos_write_mode = 1;
}
file_init_strings(file);
file_set_name(working_set, file, (char*)filename);
file->state.font_id = models->global_font.font_id;
file_synchronize_times(system, file, filename);
Render_Font *font = get_font_info(font_set, file->state.font_id)->font;
float *advance_data = 0;
if (font) advance_data = font->advance_data;
file_measure_starts_widths(system, general, &file->state.buffer, advance_data);
file->settings.read_only = read_only;
if (!read_only){
i32 request_size = Kbytes(64);
file->state.undo.undo.max = request_size;
file->state.undo.undo.strings = (u8*)general_memory_allocate(general, request_size, BUBBLE_UNDO_STRING);
file->state.undo.undo.edit_max = request_size / sizeof(Edit_Step);
file->state.undo.undo.edits = (Edit_Step*)general_memory_allocate(general, request_size, BUBBLE_UNDO);
file->state.undo.redo.max = request_size;
file->state.undo.redo.strings = (u8*)general_memory_allocate(general, request_size, BUBBLE_UNDO_STRING);
file->state.undo.redo.edit_max = request_size / sizeof(Edit_Step);
file->state.undo.redo.edits = (Edit_Step*)general_memory_allocate(general, request_size, BUBBLE_UNDO);
file->state.undo.history.max = request_size;
file->state.undo.history.strings = (u8*)general_memory_allocate(general, request_size, BUBBLE_UNDO_STRING);
file->state.undo.history.edit_max = request_size / sizeof(Edit_Step);
file->state.undo.history.edits = (Edit_Step*)general_memory_allocate(general, request_size, BUBBLE_UNDO);
file->state.undo.children.max = request_size;
file->state.undo.children.strings = (u8*)general_memory_allocate(general, request_size, BUBBLE_UNDO_STRING);
file->state.undo.children.edit_max = request_size / sizeof(Buffer_Edit);
file->state.undo.children.edits = (Buffer_Edit*)general_memory_allocate(general, request_size, BUBBLE_UNDO);
file->state.undo.history_block_count = 1;
file->state.undo.history_head_block = 0;
file->state.undo.current_block_normal = 1;
}
}
internal b32
file_create_empty(System_Functions *system,
Models *models, Editing_File *file, char *filename){
file_create_from_string(system, models, file, filename, {});
return (1);
}
internal b32
file_create_read_only(System_Functions *system,
Models *models, Editing_File *file, char *filename){
file_create_from_string(system, models, file, filename, {}, 1);
return (1);
}
internal void
file_close(System_Functions *system, General_Memory *general, Editing_File *file){
if (file->state.still_lexing){
system->cancel_job(BACKGROUND_THREADS, file->state.lex_job);
if (file->state.swap_stack.tokens){
general_memory_free(general, file->state.swap_stack.tokens);
file->state.swap_stack.tokens = 0;
}
}
if (file->state.token_stack.tokens){
general_memory_free(general, file->state.token_stack.tokens);
}
Buffer_Type *buffer = &file->state.buffer;
if (buffer->data){
general_memory_free(general, buffer->data);
general_memory_free(general, buffer->line_starts);
general_memory_free(general, buffer->line_widths);
}
if (file->state.undo.undo.edits){
general_memory_free(general, file->state.undo.undo.strings);
general_memory_free(general, file->state.undo.undo.edits);
general_memory_free(general, file->state.undo.redo.strings);
general_memory_free(general, file->state.undo.redo.edits);
general_memory_free(general, file->state.undo.history.strings);
general_memory_free(general, file->state.undo.history.edits);
general_memory_free(general, file->state.undo.children.strings);
general_memory_free(general, file->state.undo.children.edits);
}
}
struct Shift_Information{
i32 start, end, amount;
};
internal
Job_Callback_Sig(job_full_lex){
Editing_File *file = (Editing_File*)data[0];
General_Memory *general = (General_Memory*)data[1];
Cpp_File cpp_file;
cpp_file.data = file->state.buffer.data;
cpp_file.size = file->state.buffer.size;
Cpp_Token_Stack tokens;
tokens.tokens = (Cpp_Token*)memory->data;
tokens.max_count = memory->size / sizeof(Cpp_Token);
tokens.count = 0;
Cpp_Lex_Data status;
status = cpp_lex_file_nonalloc(cpp_file, &tokens);
while (!status.complete){
system->grow_thread_memory(memory);
tokens.tokens = (Cpp_Token*)memory->data;
tokens.max_count = memory->size / sizeof(Cpp_Token);
status = cpp_lex_file_nonalloc(cpp_file, &tokens, status);
}
i32 new_max = LargeRoundUp(tokens.count+1, Kbytes(1));
system->acquire_lock(FRAME_LOCK);
{
Assert(file->state.swap_stack.tokens == 0);
file->state.swap_stack.tokens = (Cpp_Token*)
general_memory_allocate(general, new_max*sizeof(Cpp_Token), BUBBLE_TOKENS);
}
system->release_lock(FRAME_LOCK);
u8 *dest = (u8*)file->state.swap_stack.tokens;
u8 *src = (u8*)tokens.tokens;
memcpy(dest, src, tokens.count*sizeof(Cpp_Token));
system->acquire_lock(FRAME_LOCK);
{
file->state.token_stack.count = tokens.count;
file->state.token_stack.max_count = new_max;
if (file->state.token_stack.tokens)
general_memory_free(general, file->state.token_stack.tokens);
file->state.token_stack.tokens = file->state.swap_stack.tokens;
file->state.swap_stack.tokens = 0;
}
system->release_lock(FRAME_LOCK);
exchange->force_redraw = 1;
// NOTE(allen): These are outside the locked section because I don't
// think getting these out of order will cause critical bugs, and I
// want to minimize what's done in locked sections.
file->state.tokens_complete = 1;
file->state.still_lexing = 0;
}
internal void
file_kill_tokens(System_Functions *system,
General_Memory *general, Editing_File *file){
file->settings.tokens_exist = 0;
if (file->state.still_lexing){
system->cancel_job(BACKGROUND_THREADS, file->state.lex_job);
if (file->state.swap_stack.tokens){
general_memory_free(general, file->state.swap_stack.tokens);
file->state.swap_stack.tokens = 0;
}
}
if (file->state.token_stack.tokens){
general_memory_free(general, file->state.token_stack.tokens);
}
file->state.tokens_complete = 0;
file->state.token_stack = {};
}
#if BUFFER_EXPERIMENT_SCALPEL <= 0
internal void
file_first_lex_parallel(System_Functions *system,
General_Memory *general, Editing_File *file){
file->settings.tokens_exist = 1;
if (file->state.is_loading == 0 && file->state.still_lexing == 0){
Assert(file->state.token_stack.tokens == 0);
file->state.tokens_complete = 0;
file->state.still_lexing = 1;
Job_Data job;
job.callback = job_full_lex;
job.data[0] = file;
job.data[1] = general;
job.memory_request = Kbytes(64);
file->state.lex_job = system->post_job(BACKGROUND_THREADS, job);
#endif
}
}
internal void
file_relex_parallel(System_Functions *system,
Mem_Options *mem, Editing_File *file,
i32 start_i, i32 end_i, i32 amount){
General_Memory *general = &mem->general;
Partition *part = &mem->part;
if (file->state.token_stack.tokens == 0){
file_first_lex_parallel(system, general, file);
return;
}
b32 inline_lex = !file->state.still_lexing;
if (inline_lex){
Cpp_File cpp_file;
cpp_file.data = file->state.buffer.data;
cpp_file.size = file->state.buffer.size;
Cpp_Token_Stack *stack = &file->state.token_stack;
Cpp_Relex_State state =
cpp_relex_nonalloc_start(cpp_file, stack,
start_i, end_i, amount, 100);
Temp_Memory temp = begin_temp_memory(part);
i32 relex_end;
Cpp_Token_Stack relex_space;
relex_space.count = 0;
relex_space.max_count = state.space_request;
relex_space.tokens = push_array(part, Cpp_Token, relex_space.max_count);
if (cpp_relex_nonalloc_main(&state, &relex_space, &relex_end)){
inline_lex = 0;
}
else{
i32 delete_amount = relex_end - state.start_token_i;
i32 shift_amount = relex_space.count - delete_amount;
if (shift_amount != 0){
int new_count = stack->count + shift_amount;
if (new_count > stack->max_count){
int new_max = LargeRoundUp(new_count, Kbytes(1));
stack->tokens = (Cpp_Token*)
general_memory_reallocate(general, stack->tokens,
stack->count*sizeof(Cpp_Token),
new_max*sizeof(Cpp_Token), BUBBLE_TOKENS);
stack->max_count = new_max;
}
int shift_size = stack->count - relex_end;
if (shift_size > 0){
Cpp_Token *old_base = stack->tokens + relex_end;
memmove(old_base + shift_amount, old_base,
sizeof(Cpp_Token)*shift_size);
}
stack->count += shift_amount;
}
memcpy(state.stack->tokens + state.start_token_i, relex_space.tokens,
sizeof(Cpp_Token)*relex_space.count);
}
end_temp_memory(temp);
}
if (!inline_lex){
i32 end_token_i = cpp_get_end_token(&file->state.token_stack, end_i);
cpp_shift_token_starts(&file->state.token_stack, end_token_i, amount);
--end_token_i;
if (end_token_i >= 0){
Cpp_Token *token = file->state.token_stack.tokens + end_token_i;
if (token->start < end_i && token->start + token->size > end_i){
token->size += amount;
}
}
file->state.still_lexing = 1;
Job_Data job;
job.callback = job_full_lex;
job.data[0] = file;
job.data[1] = general;
job.memory_request = Kbytes(64);
file->state.lex_job = system->post_job(BACKGROUND_THREADS, job);
}
}
internal void
undo_stack_grow_string(General_Memory *general, Edit_Stack *stack, i32 extra_size){
i32 old_max = stack->max;
u8 *old_str = stack->strings;
i32 new_max = old_max*2 + extra_size;
u8 *new_str = (u8*)
general_memory_reallocate(general, old_str, old_max, new_max);
stack->strings = new_str;
stack->max = new_max;
}
internal void
undo_stack_grow_edits(General_Memory *general, Edit_Stack *stack){
i32 old_max = stack->edit_max;
Edit_Step *old_eds = stack->edits;
i32 new_max = old_max*2 + 2;
Edit_Step *new_eds = (Edit_Step*)
general_memory_reallocate(general, old_eds, old_max*sizeof(Edit_Step), new_max*sizeof(Edit_Step));
stack->edits = new_eds;
stack->edit_max = new_max;
}
internal void
child_stack_grow_string(General_Memory *general, Small_Edit_Stack *stack, i32 extra_size){
i32 old_max = stack->max;
u8 *old_str = stack->strings;
i32 new_max = old_max*2 + extra_size;
u8 *new_str = (u8*)
general_memory_reallocate(general, old_str, old_max, new_max);
stack->strings = new_str;
stack->max = new_max;
}
internal void
child_stack_grow_edits(General_Memory *general, Small_Edit_Stack *stack, i32 amount){
i32 old_max = stack->edit_max;
Buffer_Edit *old_eds = stack->edits;
i32 new_max = old_max*2 + amount;
Buffer_Edit *new_eds = (Buffer_Edit*)
general_memory_reallocate(general, old_eds, old_max*sizeof(Buffer_Edit), new_max*sizeof(Buffer_Edit));
stack->edits = new_eds;
stack->edit_max = new_max;
}
internal i32
undo_children_push(General_Memory *general, Small_Edit_Stack *children,
Buffer_Edit *edits, i32 edit_count, u8 *strings, i32 string_size){
i32 result = children->edit_count;
if (children->edit_count + edit_count > children->edit_max)
child_stack_grow_edits(general, children, edit_count);
if (children->size + string_size > children->max)
child_stack_grow_string(general, children, string_size);
memcpy(children->edits + children->edit_count, edits, edit_count*sizeof(Buffer_Edit));
memcpy(children->strings + children->size, strings, string_size);
Buffer_Edit *edit = children->edits + children->edit_count;
i32 start_pos = children->size;
for (i32 i = 0; i < edit_count; ++i, ++edit){
edit->str_start += start_pos;
}
children->edit_count += edit_count;
children->size += string_size;
return result;
}
struct Edit_Spec{
u8 *str;
Edit_Step step;
};
internal Edit_Step*
file_post_undo(General_Memory *general, Editing_File *file,
Edit_Step step, bool32 do_merge, bool32 can_merge){
if (step.type == ED_NORMAL){
file->state.undo.redo.size = 0;
file->state.undo.redo.edit_count = 0;
}
Edit_Stack *undo = &file->state.undo.undo;
Edit_Step *result = 0;
if (step.child_count == 0){
if (step.edit.end - step.edit.start + undo->size > undo->max)
undo_stack_grow_string(general, undo, step.edit.end - step.edit.start);
Buffer_Edit inv;
buffer_invert_edit(&file->state.buffer, step.edit, &inv,
(char*)undo->strings, &undo->size, undo->max);
Edit_Step inv_step = {};
inv_step.edit = inv;
inv_step.pre_pos = step.pre_pos;
inv_step.post_pos = step.post_pos;
inv_step.can_merge = (b8)can_merge;
inv_step.type = ED_UNDO;
bool32 did_merge = 0;
if (do_merge && undo->edit_count > 0){
Edit_Step prev = undo->edits[undo->edit_count-1];
if (prev.can_merge && inv_step.edit.len == 0 && prev.edit.len == 0){
if (prev.edit.end == inv_step.edit.start){
did_merge = 1;
inv_step.edit.start = prev.edit.start;
inv_step.pre_pos = prev.pre_pos;
}
}
}
if (did_merge){
result = undo->edits + (undo->edit_count-1);
*result = inv_step;
}
else{
if (undo->edit_count == undo->edit_max)
undo_stack_grow_edits(general, undo);
result = undo->edits + (undo->edit_count++);
*result = inv_step;
}
}
else{
Edit_Step inv_step = {};
inv_step.type = ED_UNDO;
inv_step.first_child = step.inverse_first_child;
inv_step.inverse_first_child = step.first_child;
inv_step.special_type = step.special_type;
inv_step.child_count = step.inverse_child_count;
inv_step.inverse_child_count = step.child_count;
if (undo->edit_count == undo->edit_max)
undo_stack_grow_edits(general, undo);
result = undo->edits + (undo->edit_count++);
*result = inv_step;
}
return result;
}
inline void
undo_stack_pop(Edit_Stack *stack){
if (stack->edit_count > 0){
Edit_Step *edit = stack->edits + (--stack->edit_count);
stack->size -= edit->edit.len;
}
}
internal void
file_post_redo(General_Memory *general, Editing_File *file, Edit_Step step){
Edit_Stack *redo = &file->state.undo.redo;
if (step.child_count == 0){
if (step.edit.end - step.edit.start + redo->size > redo->max)
undo_stack_grow_string(general, redo, step.edit.end - step.edit.start);
Buffer_Edit inv;
buffer_invert_edit(&file->state.buffer, step.edit, &inv,
(char*)redo->strings, &redo->size, redo->max);
Edit_Step inv_step = {};
inv_step.edit = inv;
inv_step.pre_pos = step.pre_pos;
inv_step.post_pos = step.post_pos;
inv_step.type = ED_REDO;
if (redo->edit_count == redo->edit_max)
undo_stack_grow_edits(general, redo);
redo->edits[redo->edit_count++] = inv_step;
}
else{
Edit_Step inv_step = {};
inv_step.type = ED_REDO;
inv_step.first_child = step.inverse_first_child;
inv_step.inverse_first_child = step.first_child;
inv_step.special_type = step.special_type;
inv_step.child_count = step.inverse_child_count;
inv_step.inverse_child_count = step.child_count;
if (redo->edit_count == redo->edit_max)
undo_stack_grow_edits(general, redo);
redo->edits[redo->edit_count++] = inv_step;
}
}
inline void
file_post_history_block(Editing_File *file, i32 pos){
Assert(file->state.undo.history_head_block < pos);
Assert(pos < file->state.undo.history.edit_count);
Edit_Step *history = file->state.undo.history.edits;
Edit_Step *step = history + file->state.undo.history_head_block;
step->next_block = pos;
step = history + pos;
step->prev_block = file->state.undo.history_head_block;
file->state.undo.history_head_block = pos;
++file->state.undo.history_block_count;
}
inline void
file_unpost_history_block(Editing_File *file){
Assert(file->state.undo.history_block_count > 1);
--file->state.undo.history_block_count;
Edit_Step *old_head = file->state.undo.history.edits + file->state.undo.history_head_block;
file->state.undo.history_head_block = old_head->prev_block;
}
internal Edit_Step*
file_post_history(General_Memory *general, Editing_File *file,
Edit_Step step, b32 do_merge, b32 can_merge){
Edit_Stack *history = &file->state.undo.history;
Edit_Step *result = 0;
persist Edit_Type reverse_types[4];
if (reverse_types[ED_UNDO] == 0){
reverse_types[ED_NORMAL] = ED_REVERSE_NORMAL;
reverse_types[ED_REVERSE_NORMAL] = ED_NORMAL;
reverse_types[ED_UNDO] = ED_REDO;
reverse_types[ED_REDO] = ED_UNDO;
}
if (step.child_count == 0){
if (step.edit.end - step.edit.start + history->size > history->max)
undo_stack_grow_string(general, history, step.edit.end - step.edit.start);
Buffer_Edit inv;
buffer_invert_edit(&file->state.buffer, step.edit, &inv,
(char*)history->strings, &history->size, history->max);
Edit_Step inv_step = {};
inv_step.edit = inv;
inv_step.pre_pos = step.pre_pos;
inv_step.post_pos = step.post_pos;
inv_step.can_merge = (b8)can_merge;
inv_step.type = reverse_types[step.type];
bool32 did_merge = 0;
if (do_merge && history->edit_count > 0){
Edit_Step prev = history->edits[history->edit_count-1];
if (prev.can_merge && inv_step.edit.len == 0 && prev.edit.len == 0){
if (prev.edit.end == inv_step.edit.start){
did_merge = 1;
inv_step.edit.start = prev.edit.start;
inv_step.pre_pos = prev.pre_pos;
}
}
}
if (did_merge){
result = history->edits + (history->edit_count-1);
}
else{
if (history->edit_count == history->edit_max)
undo_stack_grow_edits(general, history);
result = history->edits + (history->edit_count++);
}
*result = inv_step;
}
else{
Edit_Step inv_step = {};
inv_step.type = reverse_types[step.type];
inv_step.first_child = step.inverse_first_child;
inv_step.inverse_first_child = step.first_child;
inv_step.special_type = step.special_type;
inv_step.inverse_child_count = step.child_count;
inv_step.child_count = step.inverse_child_count;
if (history->edit_count == history->edit_max)
undo_stack_grow_edits(general, history);
result = history->edits + (history->edit_count++);
*result = inv_step;
}
return result;
}
inline Full_Cursor
view_compute_cursor_from_pos(View *view, i32 pos){
Editing_File *file = view->file;
Models *models = view->models;
Render_Font *font = get_font_info(models->font_set, models->global_font.font_id)->font;
Full_Cursor result = {};
if (font){
f32 max_width = view_compute_width(view);
result = buffer_cursor_from_pos(&file->state.buffer, pos, view->line_wrap_y,
max_width, (f32)view->font_height, font->advance_data);
}
return result;
}
inline Full_Cursor
view_compute_cursor_from_unwrapped_xy(View *view, f32 seek_x, f32 seek_y, b32 round_down = 0){
Editing_File *file = view->file;
Models *models = view->models;
Render_Font *font = get_font_info(models->font_set, models->global_font.font_id)->font;
Full_Cursor result = {};
if (font){
f32 max_width = view_compute_width(view);
result = buffer_cursor_from_unwrapped_xy(&file->state.buffer, seek_x, seek_y,
round_down, view->line_wrap_y,
max_width, (f32)view->font_height, font->advance_data);
}
return result;
}
internal Full_Cursor
view_compute_cursor_from_wrapped_xy(View *view, f32 seek_x, f32 seek_y, b32 round_down = 0){
Editing_File *file = view->file;
Models *models = view->models;
Render_Font *font = get_font_info(models->font_set, models->global_font.font_id)->font;
Full_Cursor result = {};
if (font){
f32 max_width = view_compute_width(view);
result = buffer_cursor_from_wrapped_xy(&file->state.buffer, seek_x, seek_y,
round_down, view->line_wrap_y,
max_width, (f32)view->font_height, font->advance_data);
}
return (result);
}
internal Full_Cursor
view_compute_cursor_from_line_pos(View *view, i32 line, i32 pos){
Editing_File *file = view->file;
Models *models = view->models;
Render_Font *font = get_font_info(models->font_set, models->global_font.font_id)->font;
Full_Cursor result = {};
if (font){
f32 max_width = view_compute_width(view);
result = buffer_cursor_from_line_character(&file->state.buffer, line, pos,
view->line_wrap_y, max_width, (f32)view->font_height, font->advance_data);
}
return (result);
}
inline Full_Cursor
view_compute_cursor(View *view, Buffer_Seek seek){
Full_Cursor result = {};
switch(seek.type){
case buffer_seek_pos:
result = view_compute_cursor_from_pos(view, seek.pos);
break;
case buffer_seek_wrapped_xy:
result = view_compute_cursor_from_wrapped_xy(view, seek.x, seek.y);
break;
case buffer_seek_unwrapped_xy:
result = view_compute_cursor_from_unwrapped_xy(view, seek.x, seek.y);
break;
case buffer_seek_line_char:
result = view_compute_cursor_from_line_pos(view, seek.line, seek.character);
break;
}
return (result);
}
inline Full_Cursor
view_compute_cursor_from_xy(View *view, f32 seek_x, f32 seek_y){
Full_Cursor result;
if (view->unwrapped_lines) result = view_compute_cursor_from_unwrapped_xy(view, seek_x, seek_y);
else result = view_compute_cursor_from_wrapped_xy(view, seek_x, seek_y);
return result;
}
inline void
view_set_temp_highlight(View *view, i32 pos, i32 end_pos){
view->temp_highlight = view_compute_cursor_from_pos(view, pos);
view->temp_highlight_end_pos = end_pos;
view->show_temp_highlight = 1;
}
inline i32
view_get_cursor_pos(View *view){
i32 result;
if (view->show_temp_highlight){
result = view->temp_highlight.pos;
}
else{
result = view->cursor.pos;
}
return result;
}
inline f32
view_get_cursor_x(View *view){
f32 result;
Full_Cursor *cursor;
if (view->show_temp_highlight){
cursor = &view->temp_highlight;
}
else{
cursor = &view->cursor;
}
if (view->unwrapped_lines){
result = cursor->unwrapped_x;
}
else{
result = cursor->wrapped_x;
}
return result;
}
inline f32
view_get_cursor_y(View *view){
Full_Cursor *cursor;
f32 result;
if (view->show_temp_highlight) cursor = &view->temp_highlight;
else cursor = &view->cursor;
if (view->unwrapped_lines) result = cursor->unwrapped_y;
else result = cursor->wrapped_y;
return result;
}
internal void
view_set_file(
// NOTE(allen): These parameters are always meaningful
View *view, Editing_File *file, Models *models,
// NOTE(allen): Necessary when file != 0
System_Functions *system, Hook_Function *open_hook, Application_Links *app,
// other
b32 set_vui = 1){
Font_Info *fnt_info;
// TODO(allen): This belongs somewhere else.
fnt_info = get_font_info(models->font_set, models->global_font.font_id);
view->font_advance = fnt_info->advance;
view->font_height = fnt_info->height;
// NOTE(allen): Stuff that doesn't assume file exists.
view->file = file;
view->cursor = {};
// NOTE(allen): Stuff that does assume file exists.
if (file){
//view->locked = file->settings.super_locked;
view->unwrapped_lines = file->settings.unwrapped_lines;
if (file_is_ready(file)){
view_measure_wraps(system, &models->mem.general, view);
view->cursor = view_compute_cursor_from_pos(view, file->state.cursor_pos);
view->reinit_scrolling = 1;
}
}
// TODO(allen): Bypass all this nonsense, it's a hack! Hooks need parameters!
// Just accept it and pass the file to the open hook when it is loaded.
if (file){
if (open_hook && file->settings.is_initialized == 0){
models->buffer_param_indices[models->buffer_param_count++] = (i32)(file - models->working_set.files);
open_hook(app);
models->buffer_param_count = 0;
file->settings.is_initialized = 1;
}
}
if (set_vui){
// TODO(allen): Fix this! There should be a way to easily separate setting a file,
// and switching to file mode, so that they don't cross over eachother like this.
view->ui_state = {};
view->showing_ui = VUI_None;
}
}
struct Relative_Scrolling{
f32 scroll_x, scroll_y;
f32 target_x, target_y;
f32 scroll_min_limit;
};
internal Relative_Scrolling
view_get_relative_scrolling(View *view){
Relative_Scrolling result;
f32 cursor_y;
cursor_y = view_get_cursor_y(view);
result.scroll_y = cursor_y - view->scroll_y;
result.target_y = cursor_y - view->target_y;
result.scroll_min_limit = view->scroll_min_limit;
return result;
}
internal void
view_set_relative_scrolling(View *view, Relative_Scrolling scrolling){
f32 cursor_y;
cursor_y = view_get_cursor_y(view);
view->scroll_y = cursor_y - scrolling.scroll_y;
view->target_y = cursor_y - scrolling.target_y;
if (view->target_y < scrolling.scroll_min_limit) view->target_y = scrolling.scroll_min_limit;
}
inline void
view_cursor_move(View *view, Full_Cursor cursor){
view->cursor = cursor;
view->preferred_x = view_get_cursor_x(view);
view->file->state.cursor_pos = view->cursor.pos;
view->show_temp_highlight = 0;
}
inline void
view_cursor_move(View *view, i32 pos){
Full_Cursor cursor = view_compute_cursor_from_pos(view, pos);
view_cursor_move(view, cursor);
}
inline void
view_cursor_move(View *view, f32 x, f32 y, b32 round_down = 0){
Full_Cursor cursor;
if (view->unwrapped_lines){
cursor = view_compute_cursor_from_unwrapped_xy(view, x, y, round_down);
}
else{
cursor = view_compute_cursor_from_wrapped_xy(view, x, y, round_down);
}
view_cursor_move(view, cursor);
}
inline void
view_cursor_move(View *view, i32 line, i32 pos){
Full_Cursor cursor = view_compute_cursor_from_line_pos(view, line, pos);
view_cursor_move(view, cursor);
}
inline void
view_set_widget(View *view, View_Widget_Type type){
view->widget.type = type;
}
inline i32_Rect
view_widget_rect(View *view, i32 font_height){
Panel *panel = view->panel;
i32_Rect result = panel->inner;
if (view->file){
result.y0 = result.y0 + font_height + 2;
}
return(result);
}
enum History_Mode{
hist_normal,
hist_backward,
hist_forward
};
internal void
file_update_history_before_edit(Mem_Options *mem, Editing_File *file, Edit_Step step, u8 *str,
History_Mode history_mode){
if (!file->state.undo.undo.edits) return;
General_Memory *general = &mem->general;
b32 can_merge = 0, do_merge = 0;
switch (step.type){
case ED_NORMAL:
{
if (step.edit.len == 1 && str && char_is_alpha_numeric(*str)) can_merge = 1;
if (step.edit.len == 1 && str && (can_merge || char_is_whitespace(*str))) do_merge = 1;
if (history_mode != hist_forward)
file_post_history(general, file, step, do_merge, can_merge);
file_post_undo(general, file, step, do_merge, can_merge);
}break;
case ED_REVERSE_NORMAL:
{
if (history_mode != hist_forward)
file_post_history(general, file, step, do_merge, can_merge);
undo_stack_pop(&file->state.undo.undo);
b32 restore_redos = 0;
Edit_Step *redo_end = 0;
if (history_mode == hist_backward && file->state.undo.edit_history_cursor > 0){
restore_redos = 1;
redo_end = file->state.undo.history.edits + (file->state.undo.edit_history_cursor - 1);
}
else if (history_mode == hist_forward && file->state.undo.history.edit_count > 0){
restore_redos = 1;
redo_end = file->state.undo.history.edits + (file->state.undo.history.edit_count - 1);
}
if (restore_redos){
Edit_Step *redo_start = redo_end;
i32 steps_of_redo = 0;
i32 strings_of_redo = 0;
i32 undo_count = 0;
while (redo_start->type == ED_REDO || redo_start->type == ED_UNDO){
if (redo_start->type == ED_REDO){
if (undo_count > 0) --undo_count;
else{
++steps_of_redo;
strings_of_redo += redo_start->edit.len;
}
}
else{
++undo_count;
}
--redo_start;
}
if (redo_start < redo_end){
++redo_start;
++redo_end;
if (file->state.undo.redo.edit_count + steps_of_redo > file->state.undo.redo.edit_max)
undo_stack_grow_edits(general, &file->state.undo.redo);
if (file->state.undo.redo.size + strings_of_redo > file->state.undo.redo.max)
undo_stack_grow_string(general, &file->state.undo.redo, strings_of_redo);
u8 *str_src = file->state.undo.history.strings + redo_end->edit.str_start;
u8 *str_dest_base = file->state.undo.redo.strings;
i32 str_redo_pos = file->state.undo.redo.size + strings_of_redo;
Edit_Step *edit_src = redo_end;
Edit_Step *edit_dest =
file->state.undo.redo.edits + file->state.undo.redo.edit_count + steps_of_redo;
i32 undo_count = 0;
for (i32 i = 0; i < steps_of_redo;){
--edit_src;
str_src -= edit_src->edit.len;
if (edit_src->type == ED_REDO){
if (undo_count > 0){
--undo_count;
}
else{
++i;
--edit_dest;
*edit_dest = *edit_src;
str_redo_pos -= edit_dest->edit.len;
edit_dest->edit.str_start = str_redo_pos;
memcpy(str_dest_base + str_redo_pos, str_src, edit_dest->edit.len);
}
}
else{
++undo_count;
}
}
Assert(undo_count == 0);
file->state.undo.redo.size += strings_of_redo;
file->state.undo.redo.edit_count += steps_of_redo;
}
}
}break;
case ED_UNDO:
{
if (history_mode != hist_forward)
file_post_history(general, file, step, do_merge, can_merge);
file_post_redo(general, file, step);
undo_stack_pop(&file->state.undo.undo);
}break;
case ED_REDO:
{
if (step.edit.len == 1 && str && char_is_alpha_numeric(*str)) can_merge = 1;
if (step.edit.len == 1 && str && (can_merge || char_is_whitespace(*str))) do_merge = 1;
if (history_mode != hist_forward)
file_post_history(general, file, step, do_merge, can_merge);
file_post_undo(general, file, step, do_merge, can_merge);
undo_stack_pop(&file->state.undo.redo);
}break;
}
if (history_mode != hist_forward){
if (step.type == ED_UNDO || step.type == ED_REDO){
if (file->state.undo.current_block_normal){
file_post_history_block(file, file->state.undo.history.edit_count - 1);
file->state.undo.current_block_normal = 0;
}
}
else{
if (!file->state.undo.current_block_normal){
file_post_history_block(file, file->state.undo.history.edit_count - 1);
file->state.undo.current_block_normal = 1;
}
}
}
else{
if (file->state.undo.history_head_block == file->state.undo.history.edit_count){
file_unpost_history_block(file);
file->state.undo.current_block_normal = !file->state.undo.current_block_normal;
}
}
if (history_mode == hist_normal){
file->state.undo.edit_history_cursor = file->state.undo.history.edit_count;
}
}
inline void
file_pre_edit_maintenance(System_Functions *system,
General_Memory *general,
Editing_File *file){
if (file->state.still_lexing){
system->cancel_job(BACKGROUND_THREADS, file->state.lex_job);
if (file->state.swap_stack.tokens){
general_memory_free(general, file->state.swap_stack.tokens);
file->state.swap_stack.tokens = 0;
}
}
file->state.last_4ed_edit_time = system->time();
}
struct Cursor_Fix_Descriptor{
b32 is_batch;
union{
struct{
Buffer_Edit *batch;
i32 batch_size;
};
struct{
i32 start, end;
i32 shift_amount;
};
};
};
internal void
file_edit_cursor_fix(System_Functions *system,
Partition *part, General_Memory *general,
Editing_File *file, Editing_Layout *layout,
Cursor_Fix_Descriptor desc){
Full_Cursor temp_cursor;
Temp_Memory cursor_temp = begin_temp_memory(part);
i32 cursor_max = layout->panel_max_count * 2;
Cursor_With_Index *cursors = push_array(part, Cursor_With_Index, cursor_max);
f32 y_offset = 0, y_position = 0;
i32 cursor_count = 0;
View *view;
Panel *panel, *used_panels;
used_panels = &layout->used_sentinel;
for (dll_items(panel, used_panels)){
view = panel->view;
if (view->file == file){
view_measure_wraps(system, general, view);
write_cursor_with_index(cursors, &cursor_count, view->cursor.pos);
write_cursor_with_index(cursors, &cursor_count, view->mark - 1);
write_cursor_with_index(cursors, &cursor_count, view->scroll_i - 1);
}
}
if (cursor_count > 0){
buffer_sort_cursors(cursors, cursor_count);
if (desc.is_batch){
buffer_batch_edit_update_cursors(cursors, cursor_count,
desc.batch, desc.batch_size);
}
else{
buffer_update_cursors(cursors, cursor_count,
desc.start, desc.end,
desc.shift_amount + (desc.end - desc.start));
}
buffer_unsort_cursors(cursors, cursor_count);
cursor_count = 0;
for (dll_items(panel, used_panels)){
view = panel->view;
if (view && view->file == file){
view_cursor_move(view, cursors[cursor_count++].pos);
view->preferred_x = view_get_cursor_x(view);
view->mark = cursors[cursor_count++].pos + 1;
i32 new_scroll_i = cursors[cursor_count++].pos + 1;
if (view->scroll_i != new_scroll_i){
view->scroll_i = new_scroll_i;
temp_cursor = view_compute_cursor_from_pos(view, view->scroll_i);
y_offset = MOD(view->scroll_y, view->font_height);
if (view->unwrapped_lines){
y_position = temp_cursor.unwrapped_y + y_offset;
view->target_y += (y_position - view->scroll_y);
view->scroll_y = y_position;
}
else{
y_position = temp_cursor.wrapped_y + y_offset;
view->target_y += (y_position - view->scroll_y);
view->scroll_y = y_position;
}
}
}
}
}
end_temp_memory(cursor_temp);
}
internal void
file_do_single_edit(System_Functions *system,
Models *models, Editing_File *file,
Edit_Spec spec, History_Mode history_mode, b32 use_high_permission = 0){
ProfileMomentFunction();
if (!use_high_permission && file->settings.read_only) return;
Mem_Options *mem = &models->mem;
Editing_Layout *layout = &models->layout;
// NOTE(allen): fixing stuff beforewards????
file_update_history_before_edit(mem, file, spec.step, spec.str, history_mode);
file_pre_edit_maintenance(system, &mem->general, file);
// NOTE(allen): actual text replacement
i32 shift_amount = 0;
General_Memory *general = &mem->general;
Partition *part = &mem->part;
char *str = (char*)spec.str;
i32 start = spec.step.edit.start;
i32 end = spec.step.edit.end;
i32 str_len = spec.step.edit.len;
i32 scratch_size = partition_remaining(part);
Assert(scratch_size > 0);
i32 request_amount = 0;
while (buffer_replace_range(&file->state.buffer, start, end, str, str_len, &shift_amount,
part->base + part->pos, scratch_size, &request_amount)){
void *new_data = 0;
if (request_amount > 0){
new_data = general_memory_allocate(general, request_amount, BUBBLE_BUFFER);
}
void *old_data = buffer_edit_provide_memory(&file->state.buffer, new_data, request_amount);
if (old_data) general_memory_free(general, old_data);
}
Buffer_Type *buffer = &file->state.buffer;
i32 line_start = buffer_get_line_index(&file->state.buffer, start);
i32 line_end = buffer_get_line_index(&file->state.buffer, end);
i32 replaced_line_count = line_end - line_start;
i32 new_line_count = buffer_count_newlines(&file->state.buffer, start, start+str_len);
i32 line_shift = new_line_count - replaced_line_count;
Render_Font *font = get_font_info(models->font_set, file->state.font_id)->font;
file_grow_starts_widths_as_needed(general, buffer, line_shift);
buffer_remeasure_starts(buffer, line_start, line_end, line_shift, shift_amount);
buffer_remeasure_widths(buffer, font->advance_data, line_start, line_end, line_shift);
Panel *panel, *used_panels;
used_panels = &layout->used_sentinel;
for (dll_items(panel, used_panels)){
View *view = panel->view;
if (view->file == file){
view_measure_wraps(system, general, view);
}
}
#if BUFFER_EXPERIMENT_SCALPEL <= 0
// NOTE(allen): fixing stuff afterwards
if (file->settings.tokens_exist)
file_relex_parallel(system, mem, file, start, end, shift_amount);
#endif
Cursor_Fix_Descriptor desc = {};
desc.start = start;
desc.end = end;
desc.shift_amount = shift_amount;
file_edit_cursor_fix(system, part, general,
file, layout, desc);
}
internal void
file_do_white_batch_edit(System_Functions *system, Models *models, Editing_File *file,
Edit_Spec spec, History_Mode history_mode, b32 use_high_permission = 0){
ProfileMomentFunction();
if (!use_high_permission && file->settings.read_only) return;
Mem_Options *mem = &models->mem;
Editing_Layout *layout = &models->layout;
// NOTE(allen): fixing stuff "beforewards"???
Assert(spec.str == 0);
file_update_history_before_edit(mem, file, spec.step, 0, history_mode);
file_pre_edit_maintenance(system, &mem->general, file);
// NOTE(allen): actual text replacement
General_Memory *general = &mem->general;
Partition *part = &mem->part;
u8 *str_base = file->state.undo.children.strings;
i32 batch_size = spec.step.child_count;
Buffer_Edit *batch = file->state.undo.children.edits + spec.step.first_child;
Assert(spec.step.first_child < file->state.undo.children.edit_count);
Assert(batch_size >= 0);
i32 scratch_size = partition_remaining(part);
Buffer_Batch_State state = {};
i32 request_amount;
while (buffer_batch_edit_step(&state, &file->state.buffer, batch,
(char*)str_base, batch_size, part->base + part->pos,
scratch_size, &request_amount)){
void *new_data = 0;
if (request_amount > 0){
new_data = general_memory_allocate(general, request_amount, BUBBLE_BUFFER);
}
void *old_data = buffer_edit_provide_memory(&file->state.buffer, new_data, request_amount);
if (old_data) general_memory_free(general, old_data);
}
// NOTE(allen): meta data
{
Buffer_Measure_Starts state = {};
Render_Font *font = get_font_info(models->font_set, file->state.font_id)->font;
float *advance_data = 0;
if (font) advance_data = font->advance_data;
buffer_measure_starts_widths(&state, &file->state.buffer, advance_data);
}
// NOTE(allen): cursor fixing
{
Cursor_Fix_Descriptor desc = {};
desc.is_batch = 1;
desc.batch = batch;
desc.batch_size = batch_size;
file_edit_cursor_fix(system, part, general, file, layout, desc);
}
// NOTE(allen): token fixing
if (file->state.tokens_complete){
Cpp_Token_Stack tokens = file->state.token_stack;
Cpp_Token *token = tokens.tokens;
Cpp_Token *end_token = tokens.tokens + tokens.count;
Buffer_Edit *edit = batch;
Buffer_Edit *end_edit = batch + batch_size;
i32 shift_amount = 0;
i32 local_shift = 0;
for (; token < end_token && edit < end_edit; ++edit){
local_shift = (edit->len - (edit->end - edit->start));
for (; token->start < edit->start && edit->start < token->start + token->size &&
token < end_token; ++token){
token->size += local_shift;
}
for (; token->start < edit->start && token < end_token; ++token){
token->start += shift_amount;
}
shift_amount += local_shift;
}
for (; token < end_token; ++token){
token->start += shift_amount;
}
}
}
inline void
file_replace_range(System_Functions *system, Models *models, Editing_File *file,
i32 start, i32 end, char *str, i32 len, i32 next_cursor, b32 use_high_permission = 0){
Edit_Spec spec = {};
spec.step.type = ED_NORMAL;
spec.step.edit.start = start;
spec.step.edit.end = end;
spec.step.edit.len = len;
spec.step.pre_pos = file->state.cursor_pos;
spec.step.post_pos = next_cursor;
spec.str = (u8*)str;
file_do_single_edit(system, models, file, spec, hist_normal, use_high_permission);
}
inline void
view_replace_range(System_Functions *system, Models *models, View *view,
i32 start, i32 end, char *str, i32 len, i32 next_cursor){
file_replace_range(system, models, view->file, start, end, str, len, next_cursor);
}
inline void
view_post_paste_effect(View *view, i32 ticks, i32 start, i32 size, u32 color){
Editing_File *file = view->file;
file->state.paste_effect.start = start;
file->state.paste_effect.end = start + size;
file->state.paste_effect.color = color;
file->state.paste_effect.tick_down = ticks;
file->state.paste_effect.tick_max = ticks;
}
internal void
view_undo_redo(System_Functions *system,
Models *models, View *view,
Edit_Stack *stack, Edit_Type expected_type){
Editing_File *file = view->file;
if (stack->edit_count > 0){
Edit_Step step = stack->edits[stack->edit_count-1];
Assert(step.type == expected_type);
Edit_Spec spec = {};
spec.step = step;
if (step.child_count == 0){
spec.step.edit.str_start = 0;
spec.str = stack->strings + step.edit.str_start;
file_do_single_edit(system, models, file, spec, hist_normal);
if (expected_type == ED_UNDO) view_cursor_move(view, step.pre_pos);
else view_cursor_move(view, step.post_pos);
view->mark = view->cursor.pos;
view_post_paste_effect(view, 10, step.edit.start, step.edit.len,
models->style.main.undo_color);
}
else{
TentativeAssert(spec.step.special_type == 1);
file_do_white_batch_edit(system, models, view->file, spec, hist_normal);
}
}
}
inline void
view_undo(System_Functions *system, Models *models, View *view){
view_undo_redo(system, models, view, &view->file->state.undo.undo, ED_UNDO);
}
inline void
view_redo(System_Functions *system, Models *models, View *view){
view_undo_redo(system, models, view, &view->file->state.undo.redo, ED_REDO);
}
inline u8*
write_data(u8 *ptr, void *x, i32 size){
memcpy(ptr, x, size);
return (ptr + size);
}
#define UseFileHistoryDump 0
#if UseFileHistoryDump
internal void
file_dump_history(System_Functions *system, Mem_Options *mem, Editing_File *file, char *filename){
if (!file->state.undo.undo.edits) return;
i32 size = 0;
size += sizeof(i32);
size += file->state.undo.undo.edit_count*sizeof(Edit_Step);
size += sizeof(i32);
size += file->state.undo.redo.edit_count*sizeof(Edit_Step);
size += sizeof(i32);
size += file->state.undo.history.edit_count*sizeof(Edit_Step);
size += sizeof(i32);
size += file->state.undo.children.edit_count*sizeof(Buffer_Edit);
size += sizeof(i32);
size += file->state.undo.undo.size;
size += sizeof(i32);
size += file->state.undo.redo.size;
size += sizeof(i32);
size += file->state.undo.history.size;
size += sizeof(i32);
size += file->state.undo.children.size;
Partition *part = &mem->part;
i32 remaining = partition_remaining(part);
if (size < remaining){
u8 *data, *curs;
data = (u8*)part->base + part->pos;
curs = data;
curs = write_data(curs, &file->state.undo.undo.edit_count, 4);
curs = write_data(curs, &file->state.undo.redo.edit_count, 4);
curs = write_data(curs, &file->state.undo.history.edit_count, 4);
curs = write_data(curs, &file->state.undo.children.edit_count, 4);
curs = write_data(curs, &file->state.undo.undo.size, 4);
curs = write_data(curs, &file->state.undo.redo.size, 4);
curs = write_data(curs, &file->state.undo.history.size, 4);
curs = write_data(curs, &file->state.undo.children.size, 4);
curs = write_data(curs, file->state.undo.undo.edits, sizeof(Edit_Step)*file->state.undo.undo.edit_count);
curs = write_data(curs, file->state.undo.redo.edits, sizeof(Edit_Step)*file->state.undo.redo.edit_count);
curs = write_data(curs, file->state.undo.history.edits, sizeof(Edit_Step)*file->state.undo.history.edit_count);
curs = write_data(curs, file->state.undo.children.edits, sizeof(Buffer_Edit)*file->state.undo.children.edit_count);
curs = write_data(curs, file->state.undo.undo.strings, file->state.undo.undo.size);
curs = write_data(curs, file->state.undo.redo.strings, file->state.undo.redo.size);
curs = write_data(curs, file->state.undo.history.strings, file->state.undo.history.size);
curs = write_data(curs, file->state.undo.children.strings, file->state.undo.children.size);
Assert((i32)(curs - data) == size);
system->save_file(filename, data, size);
}
}
#endif
internal void
view_history_step(System_Functions *system, Models *models, View *view, History_Mode history_mode){
Assert(history_mode != hist_normal);
Editing_File *file = view->file;
b32 do_history_step = 0;
Edit_Step step = {};
if (history_mode == hist_backward){
if (file->state.undo.edit_history_cursor > 0){
do_history_step = 1;
step = file->state.undo.history.edits[--file->state.undo.edit_history_cursor];
}
}
else{
if (file->state.undo.edit_history_cursor < file->state.undo.history.edit_count){
Assert(((file->state.undo.history.edit_count - file->state.undo.edit_history_cursor) & 1) == 0);
step = file->state.undo.history.edits[--file->state.undo.history.edit_count];
file->state.undo.history.size -= step.edit.len;
++file->state.undo.edit_history_cursor;
do_history_step = 1;
}
}
if (do_history_step){
Edit_Spec spec;
spec.step = step;
if (spec.step.child_count == 0){
spec.step.edit.str_start = 0;
spec.str = file->state.undo.history.strings + step.edit.str_start;
file_do_single_edit(system, models, file, spec, history_mode);
switch (spec.step.type){
case ED_NORMAL:
case ED_REDO:
view_cursor_move(view, step.post_pos);
break;
case ED_REVERSE_NORMAL:
case ED_UNDO:
view_cursor_move(view, step.pre_pos);
break;
}
view->mark = view->cursor.pos;
}
else{
TentativeAssert(spec.step.special_type == 1);
file_do_white_batch_edit(system, models, view->file, spec, history_mode);
}
}
}
// TODO(allen): write these as streamed operations
internal i32
view_find_end_of_line(View *view, i32 pos){
#if BUFFER_EXPERIMENT_SCALPEL <= 0
Editing_File *file = view->file;
char *data = file->state.buffer.data;
while (pos < file->state.buffer.size && data[pos] != '\n') ++pos;
if (pos > file->state.buffer.size) pos = file->state.buffer.size;
#endif
return pos;
}
internal i32
view_find_beginning_of_line(View *view, i32 pos){
#if BUFFER_EXPERIMENT_SCALPEL <= 0
Editing_File *file = view->file;
char *data = file->state.buffer.data;
if (pos > 0){
--pos;
while (pos > 0 && data[pos] != '\n') --pos;
if (pos != 0) ++pos;
}
#endif
return pos;
}
internal i32
view_find_beginning_of_next_line(View *view, i32 pos){
#if BUFFER_EXPERIMENT_SCALPEL <= 0
Editing_File *file = view->file;
char *data = file->state.buffer.data;
while (pos < file->state.buffer.size &&
!starts_new_line(data[pos])){
++pos;
}
if (pos < file->state.buffer.size){
++pos;
}
#endif
return pos;
}
internal String*
working_set_next_clipboard_string(General_Memory *general, Working_Set *working, i32 str_size){
String *result = 0;
i32 clipboard_current = working->clipboard_current;
if (working->clipboard_size == 0){
clipboard_current = 0;
working->clipboard_size = 1;
}
else{
++clipboard_current;
if (clipboard_current >= working->clipboard_max_size){
clipboard_current = 0;
}
else if (working->clipboard_size <= clipboard_current){
working->clipboard_size = clipboard_current+1;
}
}
result = &working->clipboards[clipboard_current];
working->clipboard_current = clipboard_current;
working->clipboard_rolling = clipboard_current;
char *new_str;
if (result->str){
new_str = (char*)general_memory_reallocate(general, result->str, result->size, str_size);
}
else{
new_str = (char*)general_memory_allocate(general, str_size+1);
}
// TODO(allen): What if new_str == 0?
*result = make_string(new_str, 0, str_size);
return result;
}
internal String*
working_set_clipboard_head(Working_Set *working){
String *result = 0;
if (working->clipboard_size > 0){
i32 clipboard_index = working->clipboard_current;
working->clipboard_rolling = clipboard_index;
result = &working->clipboards[clipboard_index];
}
return result;
}
internal String*
working_set_clipboard_roll_down(Working_Set *working){
String *result = 0;
if (working->clipboard_size > 0){
i32 clipboard_index = working->clipboard_rolling;
--clipboard_index;
if (clipboard_index < 0){
clipboard_index = working->clipboard_size-1;
}
working->clipboard_rolling = clipboard_index;
result = &working->clipboards[clipboard_index];
}
return result;
}
internal void
clipboard_copy(System_Functions *system, General_Memory *general, Working_Set *working, Range range, Editing_File *file){
i32 size = range.end - range.start;
String *dest = working_set_next_clipboard_string(general, working, size);
buffer_stringify(&file->state.buffer, range.start, range.end, dest->str);
dest->size = size;
system->post_clipboard(*dest);
}
internal Edit_Spec
file_compute_whitespace_edit(Mem_Options *mem, Editing_File *file, i32 cursor_pos,
Buffer_Edit *edits, char *str_base, i32 str_size,
Buffer_Edit *inverse_array, char *inv_str, i32 inv_max,
i32 edit_count){
General_Memory *general = &mem->general;
i32 inv_str_pos = 0;
Buffer_Invert_Batch state = {};
if (buffer_invert_batch(&state, &file->state.buffer, edits, edit_count,
inverse_array, inv_str, &inv_str_pos, inv_max))
Assert(0);
i32 first_child =
undo_children_push(general, &file->state.undo.children,
edits, edit_count, (u8*)(str_base), str_size);
i32 inverse_first_child =
undo_children_push(general, &file->state.undo.children,
inverse_array, edit_count, (u8*)(inv_str), inv_str_pos);
Edit_Spec spec = {};
spec.step.type = ED_NORMAL;
spec.step.first_child = first_child;
spec.step.inverse_first_child = inverse_first_child;
spec.step.special_type = 1;
spec.step.child_count = edit_count;
spec.step.inverse_child_count = edit_count;
spec.step.pre_pos = cursor_pos;
spec.step.post_pos = cursor_pos;
return spec;
}
internal void
view_clean_whitespace(System_Functions *system, Models *models, View *view){
Mem_Options *mem = &models->mem;
Editing_File *file = view->file;
Partition *part = &mem->part;
i32 line_count = file->state.buffer.line_count;
i32 edit_max = line_count * 2;
i32 edit_count = 0;
Assert(file && !file->state.is_dummy);
Temp_Memory temp = begin_temp_memory(part);
Buffer_Edit *edits = push_array(part, Buffer_Edit, edit_max);
char *str_base = (char*)part->base + part->pos;
i32 str_size = 0;
for (i32 line_i = 0; line_i < line_count; ++line_i){
i32 start = file->state.buffer.line_starts[line_i];
i32 preferred_indentation;
b32 all_whitespace = 0;
b32 all_space = 0;
i32 hard_start =
buffer_find_hard_start(&file->state.buffer, start, &all_whitespace, &all_space,
&preferred_indentation, 4);
if (all_whitespace) preferred_indentation = 0;
if ((all_whitespace && hard_start > start) || !all_space){
Buffer_Edit new_edit;
new_edit.str_start = str_size;
str_size += preferred_indentation;
char *str = push_array(part, char, preferred_indentation);
for (i32 j = 0; j < preferred_indentation; ++j) str[j] = ' ';
new_edit.len = preferred_indentation;
new_edit.start = start;
new_edit.end = hard_start;
edits[edit_count++] = new_edit;
}
Assert(edit_count <= edit_max);
}
if (edit_count > 0){
Assert(buffer_batch_debug_sort_check(edits, edit_count));
// NOTE(allen): computing edit spec, doing batch edit
Buffer_Edit *inverse_array = push_array(part, Buffer_Edit, edit_count);
Assert(inverse_array);
char *inv_str = (char*)part->base + part->pos;
Edit_Spec spec =
file_compute_whitespace_edit(mem, file, view->cursor.pos, edits, str_base, str_size,
inverse_array, inv_str, part->max - part->pos, edit_count);
file_do_white_batch_edit(system, models, view->file, spec, hist_normal);
}
end_temp_memory(temp);
}
internal void
view_auto_tab_tokens(System_Functions *system,
Models *models, View *view,
i32 start, i32 end, b32 empty_blank_lines){
#if BUFFER_EXPERIMENT_SCALPEL <= 0
Editing_File *file = view->file;
Mem_Options *mem = &models->mem;
Partition *part = &mem->part;
Buffer *buffer = &file->state.buffer;
Assert(file && !file->state.is_dummy);
Cpp_Token_Stack tokens = file->state.token_stack;
Assert(tokens.tokens);
i32 line_start = buffer_get_line_index(buffer, start);
i32 line_end = buffer_get_line_index(buffer, end) + 1;
i32 edit_max = (line_end - line_start) * 2;
i32 edit_count = 0;
i32 indent_mark_count = line_end - line_start;
Temp_Memory temp = begin_temp_memory(part);
i32 *indent_marks = push_array(part, i32, indent_mark_count);
{
i32 current_indent = 0;
i32 token_i;
Cpp_Token *token, *self_token;
{
i32 start_pos = file->state.buffer.line_starts[line_start];
Cpp_Get_Token_Result result = cpp_get_token(&tokens, start_pos);
token_i = result.token_index;
if (result.in_whitespace) token_i += 1;
self_token = tokens.tokens + token_i;
}
i32 line = line_start - 1;
for (; line >= 0; --line){
i32 start = file->state.buffer.line_starts[line];
b32 all_whitespace = 0;
b32 all_space = 0;
buffer_find_hard_start(&file->state.buffer, start,
&all_whitespace, &all_space, &current_indent, 4);
if (!all_whitespace) break;
}
if (line < 0){
token_i = 0;
token = tokens.tokens + token_i;
}
else{
i32 start_pos = file->state.buffer.line_starts[line];
Cpp_Get_Token_Result result = cpp_get_token(&tokens, start_pos);
token_i = result.token_index;
if (result.in_whitespace) token_i += 1;
token = tokens.tokens + token_i;
while (token >= tokens.tokens &&
token->flags & CPP_TFLAG_PP_DIRECTIVE ||
token->flags & CPP_TFLAG_PP_BODY){
--token;
}
if (token < tokens.tokens){
++token;
current_indent = 0;
}
else if (token->start < start_pos){
line = buffer_get_line_index(&file->state.buffer, token->start);
i32 start = file->state.buffer.line_starts[line];
b32 all_whitespace = 0;
b32 all_space = 0;
buffer_find_hard_start(&file->state.buffer, start,
&all_whitespace, &all_space, &current_indent, 4);
Assert(!all_whitespace);
}
}
indent_marks -= line_start;
i32 line_i = line_start;
i32 next_line_start = file->state.buffer.line_starts[line_i];
switch (token->type){
case CPP_TOKEN_BRACKET_OPEN: current_indent += 4; break;
case CPP_TOKEN_PARENTHESE_OPEN: current_indent += 4; break;
case CPP_TOKEN_BRACE_OPEN: current_indent += 4; break;
}
Cpp_Token *prev_token = token;
++token;
for (; line_i < line_end; ++token_i, ++token){
for (; token->start >= next_line_start && line_i < line_end;){
i32 this_line_start = next_line_start;
next_line_start = file->state.buffer.line_starts[line_i+1];
i32 this_indent;
if (prev_token && prev_token->type == CPP_TOKEN_COMMENT &&
prev_token->start <= this_line_start && prev_token->start + prev_token->size > this_line_start){
this_indent = -1;
}
else{
this_indent = current_indent;
if (token->start < next_line_start){
if (token->flags & CPP_TFLAG_PP_DIRECTIVE) this_indent = 0;
else{
switch (token->type){
case CPP_TOKEN_BRACKET_CLOSE: this_indent -= 4; break;
case CPP_TOKEN_PARENTHESE_CLOSE: this_indent -= 4; break;
case CPP_TOKEN_BRACE_CLOSE: this_indent -= 4; break;
case CPP_TOKEN_BRACE_OPEN: break;
default:
if (current_indent > 0 && prev_token){
if (!(prev_token->flags & CPP_TFLAG_PP_BODY ||
prev_token->flags & CPP_TFLAG_PP_DIRECTIVE)){
switch (prev_token->type){
case CPP_TOKEN_BRACKET_OPEN: case CPP_TOKEN_PARENTHESE_OPEN:
case CPP_TOKEN_BRACE_OPEN: case CPP_TOKEN_BRACE_CLOSE:
case CPP_TOKEN_SEMICOLON: case CPP_TOKEN_COLON: break;
case CPP_TOKEN_COMMA: case CPP_TOKEN_COMMENT: break;
default: this_indent += 4;
}
}
}
}
}
}
if (this_indent < 0) this_indent = 0;
}
indent_marks[line_i] = this_indent;
++line_i;
}
switch (token->type){
case CPP_TOKEN_BRACKET_OPEN: current_indent += 4; break;
case CPP_TOKEN_BRACKET_CLOSE: current_indent -= 4; break;
case CPP_TOKEN_PARENTHESE_OPEN: current_indent += 4; break;
case CPP_TOKEN_PARENTHESE_CLOSE: current_indent -= 4; break;
case CPP_TOKEN_BRACE_OPEN: current_indent += 4; break;
case CPP_TOKEN_BRACE_CLOSE: current_indent -= 4; break;
}
prev_token = token;
}
}
Buffer_Edit *edits = push_array(part, Buffer_Edit, edit_max);
char *str_base = (char*)part->base + part->pos;
i32 str_size = 0;
for (i32 line_i = line_start; line_i < line_end; ++line_i){
i32 start = file->state.buffer.line_starts[line_i];
i32 preferred_indentation;
i32 correct_indentation;
b32 all_whitespace = 0;
b32 all_space = 0;
i32 hard_start =
buffer_find_hard_start(&file->state.buffer, start, &all_whitespace, &all_space,
&preferred_indentation, 4);
correct_indentation = indent_marks[line_i];
if (all_whitespace && empty_blank_lines) correct_indentation = 0;
if (correct_indentation == -1) correct_indentation = preferred_indentation;
if ((all_whitespace && hard_start > start) || !all_space || correct_indentation != preferred_indentation){
Buffer_Edit new_edit;
new_edit.str_start = str_size;
str_size += correct_indentation;
char *str = push_array(part, char, correct_indentation);
for (i32 j = 0; j < correct_indentation; ++j) str[j] = ' ';
new_edit.len = correct_indentation;
new_edit.start = start;
new_edit.end = hard_start;
edits[edit_count++] = new_edit;
}
Assert(edit_count <= edit_max);
}
if (edit_count > 0){
Assert(buffer_batch_debug_sort_check(edits, edit_count));
// NOTE(allen): computing edit spec, doing batch edit
Buffer_Edit *inverse_array = push_array(part, Buffer_Edit, edit_count);
Assert(inverse_array);
char *inv_str = (char*)part->base + part->pos;
Edit_Spec spec =
file_compute_whitespace_edit(mem, file, view->cursor.pos, edits, str_base, str_size,
inverse_array, inv_str, part->max - part->pos, edit_count);
file_do_white_batch_edit(system, models, view->file, 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);
#endif
}
struct Get_Link_Result{
b32 in_link;
i32 index;
};
internal u32*
style_get_color(Style *style, Cpp_Token token){
u32 *result;
if (token.flags & CPP_TFLAG_IS_KEYWORD){
if (token.type == CPP_TOKEN_BOOLEAN_CONSTANT){
result = &style->main.bool_constant_color;
}
else{
result = &style->main.keyword_color;
}
}
else if(token.flags & CPP_TFLAG_PP_DIRECTIVE){
result = &style->main.preproc_color;
}
else{
switch (token.type){
case CPP_TOKEN_COMMENT:
result = &style->main.comment_color;
break;
case CPP_TOKEN_STRING_CONSTANT:
result = &style->main.str_constant_color;
break;
case CPP_TOKEN_CHARACTER_CONSTANT:
result = &style->main.char_constant_color;
break;
case CPP_TOKEN_INTEGER_CONSTANT:
result = &style->main.int_constant_color;
break;
case CPP_TOKEN_FLOATING_CONSTANT:
result = &style->main.float_constant_color;
break;
case CPP_TOKEN_INCLUDE_FILE:
result = &style->main.include_color;
break;
default:
result = &style->main.default_color;
}
}
return result;
}
inline f32
view_compute_max_target_y(i32 lowest_line, i32 line_height, real32 view_height){
real32 max_target_y = ((lowest_line+.5f)*line_height) - view_height*.5f;
return max_target_y;
}
internal real32
view_compute_max_target_y(View *view){
i32 lowest_line = view_compute_lowest_line(view);
i32 line_height = view->font_height;
real32 view_height = view_compute_height(view);
real32 max_target_y = view_compute_max_target_y(
lowest_line, line_height, view_height);
return max_target_y;
}
internal void
remeasure_file_view(System_Functions *system, View *view, i32_Rect rect){
if (file_is_ready(view->file)){
Relative_Scrolling relative = view_get_relative_scrolling(view);
view_measure_wraps(system, &view->models->mem.general, view);
view_cursor_move(view, view->cursor.pos);
view->preferred_x = view_get_cursor_x(view);
view_set_relative_scrolling(view, relative);
}
}
internal void
undo_shit(System_Functions *system, View *view, UI_State *state, UI_Layout *layout,
i32 total_count, i32 undo_count, i32 scrub_max){
Editing_File *file = view->file;
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)){
for (i32 i = 0; i < scrub_max && new_count < undo_count; ++i){
view_undo(system, view->models, view);
--undo_count;
}
for (i32 i = 0; i < scrub_max && new_count > undo_count; ++i){
view_redo(system, view->models, view);
++undo_count;
}
}
}
}
else{
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->state.undo.history.edit_count + file->state.undo.edit_history_cursor) >> 1);
i32 count = file->state.undo.edit_history_cursor;
if (do_undo_slider(wid, state, layout, mid, count, &file->state.undo, &new_count)){
for (i32 i = 0; i < scrub_max && new_count < count; ++i){
view_history_step(system, view->models, view, hist_backward);
}
for (i32 i = 0; i < scrub_max && new_count > count; ++i){
view_history_step(system, view->models, view, hist_forward);
}
}
}
}
else{
if (do_button(3, state, layout, "+ History", 1)){
view->widget.timeline.history_line = 1;
}
}
}
internal void
draw_file_view_queries(View *view, UI_State *state, UI_Layout *layout){
Widget_ID wid;
Query_Slot *slot;
Query_Bar *bar;
i32 i = 1;
for (slot = view->query_set.used_slot; slot != 0; slot = slot->next){
wid = make_id(state, i++);
bar = slot->query_bar;
do_text_field(wid, state, layout, bar->prompt, bar->string);
}
}
inline void
view_show_menu(View *fview, Command_Map *gui_map){
fview->ui_state = {};
fview->map_for_file = fview->map;
fview->map = gui_map;
fview->showing_ui = VUI_Menu;
}
inline void
view_show_config(View *fview, Command_Map *gui_map){
fview->ui_state = {};
fview->map_for_file = fview->map;
fview->map = gui_map;
fview->showing_ui = VUI_Config;
}
inline void
view_show_interactive(System_Functions *system, View *view, Command_Map *gui_map,
Interactive_Action action, Interactive_Interaction interaction, String query){
Models *models = view->models;
view->ui_state = {};
view->map_for_file = view->map;
view->map = gui_map;
view->showing_ui = VUI_Interactive;
view->action = action;
view->interaction = interaction;
view->finished = 0;
copy(&view->query, query);
view->dest.str[0] = 0;
view->dest.size = 0;
hot_directory_clean_end(&models->hot_directory);
hot_directory_reload(system, &models->hot_directory, &models->working_set);
}
inline void
view_show_theme(View *view, Command_Map *gui_map){
view->ui_state = {};
view->map_for_file = view->map;
view->map = gui_map;
view->showing_ui = VUI_Theme;
view->color_mode = CV_Mode_Library;
view->color = super_color_create(0xFF000000);
}
inline void
view_show_file(View *view, Command_Map *file_map){
view->ui_state = {};
if (file_map){
view->map = file_map;
}
else{
view->map = view->map_for_file;
}
view->showing_ui = VUI_None;
}
internal void
interactive_view_complete(View *view){
Models *models = view->models;
Panel *panel = view->panel;
Editing_File *old_file = view->file;
switch (view->action){
case IAct_Open:
delayed_open(&models->delay1, models->hot_directory.string, panel);
delayed_touch_file(&models->delay1, old_file);
break;
case IAct_Save_As:
delayed_save_as(&models->delay1, models->hot_directory.string, panel);
break;
case IAct_New:
if (models->hot_directory.string.size > 0 &&
!char_is_slash(models->hot_directory.string.str[models->hot_directory.string.size-1])){
delayed_new(&models->delay1, models->hot_directory.string, panel);
}
break;
case IAct_Switch:
delayed_switch(&models->delay1, view->dest, panel);
delayed_touch_file(&models->delay1, old_file);
break;
case IAct_Kill:
delayed_try_kill(&models->delay1, view->dest);
break;
case IAct_Sure_To_Kill:
switch (view->user_action){
case 0:
delayed_kill(&models->delay1, view->dest);
break;
case 1:
break;
case 2:
// TODO(allen): This is fishy! What if the save doesn't happen this time around?
// We need to ensure delayed acts happen in order I think.
delayed_save(&models->delay1, view->dest);
delayed_kill(&models->delay1, view->dest);
break;
}
break;
}
view_show_file(view, 0);
// TODO(allen): This is here to prevent the key press from being passed to the
// underlying file which is a giant pain.
view->file = 0;
}
internal void
update_highlighting(View *view){
View *file_view = view->hot_file_view;
if (!file_view){
view->highlight = {};
return;
}
Editing_File *file = file_view->file;
if (!file || !file_is_ready(file)){
view->highlight = {};
return;
}
Models *models = view->models;
Style *style = &models->style;
i32 pos = view_get_cursor_pos(file_view);
char c = buffer_get_char(&file->state.buffer, pos);
if (c == '\r'){
view->highlight.ids[0] =
raw_ptr_dif(&style->main.special_character_color, style);
}
else if (file->state.tokens_complete){
Cpp_Token_Stack *tokens = &file->state.token_stack;
Cpp_Get_Token_Result result = cpp_get_token(tokens, pos);
Cpp_Token token = tokens->tokens[result.token_index];
if (!result.in_whitespace){
u32 *color = style_get_color(style, token);
view->highlight.ids[0] = raw_ptr_dif(color, style);
if (token.type == CPP_TOKEN_JUNK){
view->highlight.ids[1] =
raw_ptr_dif(&style->main.highlight_junk_color, style);
}
else if (char_is_whitespace(c)){
view->highlight.ids[1] =
raw_ptr_dif(&style->main.highlight_white_color, style);
}
else{
view->highlight.ids[1] = 0;
}
}
else{
view->highlight.ids[0] = 0;
view->highlight.ids[1] =
raw_ptr_dif(&style->main.highlight_white_color, style);
}
}
else{
if (char_is_whitespace(c)){
view->highlight.ids[0] = 0;
view->highlight.ids[1] =
raw_ptr_dif(&style->main.highlight_white_color, style);
}
else{
view->highlight.ids[0] =
raw_ptr_dif(&style->main.default_color, style);
view->highlight.ids[1] = 0;
}
}
if (file_view->show_temp_highlight){
view->highlight.ids[2] =
raw_ptr_dif(&style->main.highlight_color, style);
view->highlight.ids[3] =
raw_ptr_dif(&style->main.at_highlight_color, style);
}
else if (file->state.paste_effect.tick_down > 0){
view->highlight.ids[2] =
raw_ptr_dif(&style->main.paste_color, style);
view->highlight.ids[3] = 0;
}
else{
view->highlight.ids[2] = 0;
view->highlight.ids[3] = 0;
}
}
internal b32
theme_library_shit(System_Functions *system, Exchange *exchange,
View *view, UI_State *state, UI_Layout *layout){
Models *models = view->models;
Mem_Options *mem = &models->mem;
i32 result = 0;
Library_UI ui;
ui.state = state;
ui.layout = layout;
ui.fonts = models->font_set;
ui.hot_directory = &models->hot_directory;
ui.styles = &models->styles;
Color_View_Mode mode = view->color_mode;
i32_Rect bar_rect = ui.layout->rect;
bar_rect.x0 = bar_rect.x1 - 20;
do_scroll_bar(ui.state, bar_rect);
ui.layout->y -= FLOOR32(view->ui_state.view_y);
ui.layout->rect.x1 -= 20;
b32 case_sensitive = 0;
switch (mode){
case CV_Mode_Library:
{
do_label(ui.state, ui.layout, literal("Current Theme - Click to Edit"));
if (do_style_preview(&ui, &models->style)){
view->color_mode = CV_Mode_Adjusting;
view->ui_state.selected = {};
ui.state->view_y = 0;
result = 1;
}
begin_row(ui.layout, 3);
if (ui.state->style->name.size >= 1){
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~", 2);
}
if (do_button(-3, ui.state, ui.layout, "Import", 2)){
view->color_mode = CV_Mode_Import_File;
hot_directory_clean_end(&models->hot_directory);
hot_directory_reload(system, &models->hot_directory, &models->working_set);
}
if (do_button(-4, ui.state, ui.layout, "Export", 2)){
view->color_mode = CV_Mode_Export;
hot_directory_clean_end(&models->hot_directory);
hot_directory_reload(system, &models->hot_directory, &models->working_set);
memset(view->import_export_check, 0, sizeof(view->import_export_check));
}
do_label(ui.state, ui.layout, literal("Theme Library - Click to Select"));
i32 style_count = models->styles.count;
Style *style = models->styles.styles;
for (i32 i = 0; i < style_count; ++i, ++style){
if (do_style_preview(&ui, style)){
style_copy(&models->style, style);
result = 1;
}
}
}break;
case CV_Mode_Import_File:
{
do_label(ui.state, ui.layout, literal("Current Theme"));
do_style_preview(&ui, &models->style);
b32 file_selected = 0;
do_label(ui.state, ui.layout, literal("Import Which File?"));
begin_row(ui.layout, 2);
if (do_button(-2, ui.state, ui.layout, "*.p4c only", 2, 1, view->p4c_only)){
view->p4c_only = !view->p4c_only;
}
if (do_button(-3, ui.state, ui.layout, "Cancel", 2)){
view->color_mode = CV_Mode_Library;
}
b32 new_dir = 0;
if (do_file_list_box(system, ui.state, ui.layout,
ui.hot_directory, view->p4c_only, 1, case_sensitive,
&new_dir, &file_selected, 0)){
result = 1;
}
if (new_dir){
hot_directory_reload(system, ui.hot_directory, ui.state->working_set);
}
if (file_selected){
memset(&view->inspecting_styles, 0, sizeof(Style_Library));
memset(view->import_export_check, 1,
sizeof(view->import_export_check));
view->import_file_id = exchange_request_file(exchange,
models->hot_directory.string.str,
models->hot_directory.string.size);
view->color_mode = CV_Mode_Import_Wait;
}
}break;
case CV_Mode_Import_Wait:
{
Style *styles = view->inspecting_styles.styles;
Data file = {};
i32 file_max = 0;
i32 count = 0;
i32 max = ArrayCount(view->inspecting_styles.styles);
AllowLocal(styles);
AllowLocal(max);
if (exchange_file_ready(exchange, view->import_file_id,
&file.data, &file.size, &file_max)){
if (file.data){
if (0 /* && style_library_import(file, ui.fonts, styles, max, &count) */){
view->color_mode = CV_Mode_Import;
}
else{
view->color_mode = CV_Mode_Library;
}
view->inspecting_styles.count = count;
}
else{
Assert(!"this shouldn't happen!");
}
exchange_free_file(exchange, view->import_file_id);
}
}break;
case CV_Mode_Export_File:
{
do_label(ui.state, ui.layout, literal("Current Theme"));
do_style_preview(&ui, &models->style);
b32 file_selected = 0;
do_label(ui.state, ui.layout, literal("Export File Name?"));
begin_row(ui.layout, 2);
if (do_button(-2, ui.state, ui.layout, "Finish Export", 2)){
file_selected = 1;
}
if (do_button(-3, ui.state, ui.layout, "Cancel", 2)){
view->color_mode = CV_Mode_Library;
}
b32 new_dir = 0;
if (do_file_list_box(system, ui.state, ui.layout,
ui.hot_directory, 1, 1, case_sensitive,
&new_dir, &file_selected, ".p4c")){
result = 1;
}
if (new_dir){
hot_directory_reload(system,
ui.hot_directory, ui.state->working_set);
}
if (file_selected){
i32 count = ui.styles->count;
Temp_Memory temp = begin_temp_memory(&mem->part);
Style **styles = push_array(&mem->part, Style*, sizeof(Style*)*count);
Style *style = ui.styles->styles;
b8 *export_check = view->import_export_check;
i32 export_count = 0;
for (i32 i = 0; i < count; ++i, ++style){
if (export_check[i]){
styles[export_count++] = style;
}
}
char *data = push_array(&mem->part, char, ui.hot_directory->string.size + 5);
String str = make_string(data, 0, ui.hot_directory->string.size + 5);
copy(&str, ui.hot_directory->string);
append(&str, make_lit_string(".p4c"));
/*style_library_export(system, exchange, mem, &target->font_set, str.str, styles, export_count);*/
end_temp_memory(temp);
view->color_mode = CV_Mode_Library;
}
}break;
case CV_Mode_Import:
{
do_label(ui.state, ui.layout, literal("Current Theme"));
do_style_preview(&ui, &models->style);
i32 style_count = view->inspecting_styles.count;
Style *styles = view->inspecting_styles.styles;
b8 *import_check = view->import_export_check;
do_label(ui.state, ui.layout, literal("Pack"));
begin_row(ui.layout, 2);
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);
}
view->color_mode = CV_Mode_Library;
}
if (do_button(-3, ui.state, ui.layout, "Cancel", 2)){
view->color_mode = CV_Mode_Library;
}
Style *style = styles;
for (i32 i = 0; i < style_count; ++i, ++style){
if (do_style_preview(&ui, style, import_check[i])){
import_check[i] = !import_check[i];
result = 1;
}
}
}break;
case CV_Mode_Export:
{
do_label(ui.state, ui.layout, literal("Current Theme"));
do_style_preview(&ui, &models->style);
do_label(ui.state, ui.layout, literal("Export Which Themes?"));
begin_row(ui.layout, 2);
if (do_button(-2, ui.state, ui.layout, "Export", 2)){
view->color_mode = CV_Mode_Export_File;
}
if (do_button(-3, ui.state, ui.layout, "Cancel", 2)){
view->color_mode = CV_Mode_Library;
}
i32 style_count = models->styles.count;
Style *style = models->styles.styles;
b8 *export_check = view->import_export_check;
for (i32 i = 0; i < style_count; ++i, ++style){
if (do_style_preview(&ui, style, export_check[i])){
export_check[i] = !export_check[i];
result = 1;
}
}
}break;
}
return (result);
}
internal b32
theme_adjusting_shit(View *view, UI_State *state, UI_Layout *layout, Super_Color *color){
update_highlighting(view);
Models *models = view->models;
Style *style = &models->style;
i32 result = 0;
Color_UI ui;
ui.state = state;
ui.layout = layout;
ui.fonts = models->font_set;
ui.global_font = &models->global_font;
ui.highlight = view->highlight;
ui.color = view->color;
ui.has_hover_color = 0;
ui.state->sub_id1_change = 0;
ui.hex_advance = font_get_max_width(ui.fonts, ui.state->font_id, "0123456789abcdefx");
ui.palette = models->palette;
ui.palette_size = models->palette_size;
i32_Rect bar_rect = ui.layout->rect;
bar_rect.x0 = bar_rect.x1 - 20;
do_scroll_bar(ui.state, bar_rect);
ui.layout->y -= FLOOR32(view->ui_state.view_y);
ui.layout->rect.x1 -= 20;
if (do_button(-1, ui.state, ui.layout, "Back to Library", 2)){
view->color_mode = CV_Mode_Library;
ui.state->view_y = 0;
}
do_style_name(&ui);
do_font_switch(&ui);
do_color_adjuster(&ui, &style->main.back_color,
style->main.default_color, style->main.back_color,
"Background");
do_color_adjuster(&ui, &style->main.margin_color,
style->main.default_color, style->main.margin_color,
"Margin");
do_color_adjuster(&ui, &style->main.margin_hover_color,
style->main.default_color, style->main.margin_hover_color,
"Margin Hover");
do_color_adjuster(&ui, &style->main.margin_active_color,
style->main.default_color, style->main.margin_active_color,
"Margin Active");
do_color_adjuster(&ui, &style->main.cursor_color,
style->main.at_cursor_color, style->main.cursor_color,
"Cursor");
do_color_adjuster(&ui, &style->main.at_cursor_color,
style->main.at_cursor_color, style->main.cursor_color,
"Text At Cursor");
do_color_adjuster(&ui, &style->main.mark_color,
style->main.mark_color, style->main.back_color,
"Mark");
do_color_adjuster(&ui, &style->main.highlight_color,
style->main.at_highlight_color, style->main.highlight_color,
"Highlight");
do_color_adjuster(&ui, &style->main.at_highlight_color,
style->main.at_highlight_color, style->main.highlight_color,
"Text At Highlight");
do_color_adjuster(&ui, &style->main.default_color,
style->main.default_color, style->main.back_color,
"Text Default");
do_color_adjuster(&ui, &style->main.comment_color,
style->main.comment_color, style->main.back_color,
"Comment");
do_color_adjuster(&ui, &style->main.keyword_color,
style->main.keyword_color, style->main.back_color,
"Keyword");
do_color_adjuster(&ui, &style->main.str_constant_color,
style->main.str_constant_color, style->main.back_color,
"String Constant");
do_color_adjuster(&ui, &style->main.char_constant_color,
style->main.char_constant_color, style->main.back_color,
"Character Constant");
do_color_adjuster(&ui, &style->main.int_constant_color,
style->main.int_constant_color, style->main.back_color,
"Integer Constant");
do_color_adjuster(&ui, &style->main.float_constant_color,
style->main.float_constant_color, style->main.back_color,
"Float Constant");
do_color_adjuster(&ui, &style->main.bool_constant_color,
style->main.bool_constant_color, style->main.back_color,
"Boolean Constant");
do_color_adjuster(&ui, &style->main.preproc_color,
style->main.preproc_color, style->main.back_color,
"Preprocessor");
do_color_adjuster(&ui, &style->main.include_color,
style->main.include_color, style->main.back_color,
"Include Constant");
do_color_adjuster(&ui, &style->main.special_character_color,
style->main.special_character_color, style->main.back_color,
"Special Character");
do_color_adjuster(&ui, &style->main.highlight_junk_color,
style->main.default_color, style->main.highlight_junk_color,
"Junk Highlight");
do_color_adjuster(&ui, &style->main.highlight_white_color,
style->main.default_color, style->main.highlight_white_color,
"Whitespace Highlight");
do_color_adjuster(&ui, &style->main.paste_color,
style->main.paste_color, style->main.back_color,
"Paste Color");
Interactive_Style *bar_style = &style->main.file_info_style;
do_color_adjuster(&ui, &bar_style->bar_color,
bar_style->base_color, bar_style->bar_color,
"Bar");
do_color_adjuster(&ui, &bar_style->base_color,
bar_style->base_color, bar_style->bar_color,
"Bar Text");
do_color_adjuster(&ui, &bar_style->pop1_color,
bar_style->pop1_color, bar_style->bar_color,
"Bar Pop 1");
do_color_adjuster(&ui, &bar_style->pop2_color,
bar_style->pop2_color, bar_style->bar_color,
"Bar Pop 2");
*color = ui.hover_color;
return (result);
}
internal b32
theme_shit(System_Functions *system, Exchange *exchange,
View *view, View *active, UI_State *state, UI_Layout *layout, Super_Color *color){
b32 result = 0;
if (view != active){
view->hot_file_view = active;
}
switch (view->color_mode){
case CV_Mode_Library:
case CV_Mode_Import_File:
case CV_Mode_Export_File:
case CV_Mode_Import:
case CV_Mode_Export:
case CV_Mode_Import_Wait:
if (theme_library_shit(system, exchange, view, state, layout)){
result = 1;
}
break;
case CV_Mode_Adjusting:
if (theme_adjusting_shit(view, state, layout, color)){
result = 1;
}
break;
}
return(result);
}
internal b32
interactive_shit(System_Functions *system, View *view, UI_State *state, UI_Layout *layout){
b32 result = 0;
b32 new_dir = 0;
b32 complete = 0;
Models *models = view->models;
do_label(state, layout, view->query, 1.f);
b32 case_sensitive = 0;
b32 input_stage = state->input_stage;
Key_Summary *keys = state->keys;
switch (view->interaction){
case IInt_Sys_File_List:
{
b32 is_new = (view->action == IAct_New);
if (do_file_list_box(system, state, layout,
&models->hot_directory, 0, !is_new, case_sensitive,
&new_dir, &complete, 0)){
result = 1;
}
if (new_dir){
hot_directory_reload(system, &models->hot_directory, &models->working_set);
}
}break;
case IInt_Live_File_List:
{
if (do_live_file_list_box(system, state, layout, &models->working_set, &view->dest, &complete)){
result = 1;
}
}break;
case IInt_Sure_To_Kill:
{
i32 action = -1;
char s_[256];
String s = make_fixed_width_string(s_);
append(&s, view->dest);
append(&s, " has unsaved changes, kill it?");
do_label(state, layout, s, 1.f);
i32 id = 0;
if (do_list_option(++id, state, layout, make_lit_string("(Y)es"))){
action = 0;
}
if (do_list_option(++id, state, layout, make_lit_string("(N)o"))){
action = 1;
}
if (do_list_option(++id, state, layout, make_lit_string("(S)ave and kill"))){
action = 2;
}
if (action == -1 && input_stage){
i32 key_count = keys->count;
for (i32 i = 0; i < key_count; ++i){
Key_Event_Data key = keys->keys[i];
switch (key.character){
case 'y': case 'Y': action = 0; break;
case 'n': case 'N': action = 1; break;
case 's': case 'S': action = 2; break;
}
if (action == -1 && key.keycode == key_esc) action = 1;
if (action != -1) break;
}
}
if (action != -1){
complete = 1;
view->user_action = action;
}
}break;
}
if (complete){
view->finished = 1;
interactive_view_complete(view);
result= 1;
}
return(result);
}
internal void
menu_shit(View *view, UI_State *state, UI_Layout *layout){
i32 id = 0;
do_label(state, layout, literal("Menu"), 2.f);
if (do_list_option(++id, state, layout, make_lit_string("Theme Options"))){
view_show_theme(view, view->map);
}
if (do_list_option(++id, state, layout, make_lit_string("Keyboard Layout Options"))){
view_show_config(view, view->map);
}
}
internal void
config_shit(View *view, UI_State *state, UI_Layout *layout){
i32 id = 0;
Models *models = view->models;
do_label(state, layout, literal("Config"), 2.f);
if (do_checkbox_list_option(++id, state, layout, make_lit_string("Left Ctrl + Left Alt = AltGr"),
models->settings.lctrl_lalt_is_altgr)){
models->settings.lctrl_lalt_is_altgr = !models->settings.lctrl_lalt_is_altgr;
}
}
struct File_Bar{
f32 pos_x, pos_y;
f32 text_shift_x, text_shift_y;
i32_Rect rect;
i16 font_id;
};
internal void
intbar_draw_string(Render_Target *target, File_Bar *bar, String str, u32 char_color){
i16 font_id = bar->font_id;
draw_string(target, font_id, str,
(i32)(bar->pos_x + bar->text_shift_x),
(i32)(bar->pos_y + bar->text_shift_y),
char_color);
bar->pos_x += font_string_width(target, font_id, str);
}
internal void
do_file_bar(View *view, Editing_File *file, UI_Layout *layout, Render_Target *target){
File_Bar bar;
Models *models = view->models;
Style_Font *font = &models->global_font;
i32 line_height = view->font_height;
Interactive_Style bar_style = models->style.main.file_info_style;
u32 back_color = bar_style.bar_color;
u32 base_color = bar_style.base_color;
u32 pop1_color = bar_style.pop1_color;
u32 pop2_color = bar_style.pop2_color;
bar.rect = layout_rect(layout, line_height + 2);
if (target){
bar.font_id = font->font_id;
bar.pos_x = (f32)bar.rect.x0;
bar.pos_y = (f32)bar.rect.y0;
bar.text_shift_y = 2;
bar.text_shift_x = 0;
draw_rectangle(target, bar.rect, back_color);
intbar_draw_string(target, &bar, file->name.live_name, base_color);
intbar_draw_string(target, &bar, make_lit_string(" -"), base_color);
if (file->state.is_loading){
intbar_draw_string(target, &bar, make_lit_string(" loading"), base_color);
}
else{
char line_number_space[30];
String line_number = make_string(line_number_space, 0, 30);
append(&line_number, " L#");
append_int_to_str(view->cursor.line, &line_number);
intbar_draw_string(target, &bar, line_number, base_color);
intbar_draw_string(target, &bar, make_lit_string(" -"), base_color);
if (file->settings.dos_write_mode){
intbar_draw_string(target, &bar, make_lit_string(" dos"), base_color);
}
else{
intbar_draw_string(target, &bar, make_lit_string(" nix"), base_color);
}
if (file->state.still_lexing){
intbar_draw_string(target, &bar, make_lit_string(" parsing"), pop1_color);
}
if (!file->settings.unimportant){
switch (buffer_get_sync(file)){
case SYNC_BEHIND_OS:
{
persist String out_of_sync = make_lit_string(" !");
intbar_draw_string(target, &bar, out_of_sync, pop2_color);
}break;
case SYNC_UNSAVED:
{
persist String out_of_sync = make_lit_string(" *");
intbar_draw_string(target, &bar, out_of_sync, pop2_color);
}break;
}
}
}
}
}
internal void
view_reinit_scrolling(View *view){
Editing_File *file = view->file;
f32 w, h;
f32 cursor_x, cursor_y;
f32 target_x, target_y;
view->reinit_scrolling = 0;
target_x = 0;
target_y = 0;
if (file && file_is_ready(file)){
cursor_x = view_get_cursor_x(view);
cursor_y = view_get_cursor_y(view);
w = view_compute_width(view);
h = view_compute_height(view);
if (cursor_x >= target_x + w){
target_x = (f32)(cursor_x - w*.5f);
}
target_y = (f32)FLOOR32(cursor_y - h*.5f);
if (target_y < view->scroll_min_limit) target_y = view->scroll_min_limit;
}
view->target_x = target_x;
view->target_y = target_y;
view->scroll_x = target_x;
view->scroll_y = target_y;
view->prev_target_x = -1000.f;
view->prev_target_y = -1000.f;
}
internal i32
step_file_view(System_Functions *system, Exchange *exchange, View *view, i32_Rect rect,
b32 is_active, Input_Summary *user_input){
Models *models = view->models;
i32 result = 0;
Editing_File *file = view->file;
i32 widget_height = 0;
{
UI_State state =
ui_state_init(&view->widget.state, 0, user_input,
&models->style, models->global_font.font_id, models->font_set, 0, 1);
UI_Layout layout;
begin_layout(&layout, rect);
switch (view->widget.type){
case FWIDG_NONE:
{
if (file && view->showing_ui == VUI_None){
do_file_bar(view, file, &layout, 0);
}
draw_file_view_queries(view, &state, &layout);
}break;
case FWIDG_TIMELINES:
{
i32 scrub_max = view->scrub_max;
i32 undo_count = file->state.undo.undo.edit_count;
i32 redo_count = file->state.undo.redo.edit_count;
i32 total_count = undo_count + redo_count;
undo_shit(system, view, &state, &layout, total_count, undo_count, scrub_max);
}break;
}
widget_height = layout.y - rect.y0;
if (ui_finish_frame(&view->widget.state, &state, &layout, rect, 0, 0)){
result = 1;
}
}
view->scroll_min_limit = (f32)-widget_height;
if (view->reinit_scrolling){
view_reinit_scrolling(view);
}
// TODO(allen): Split this into passive step and step that depends on input
if (view->showing_ui == VUI_None && file && !file->state.is_loading){
f32 line_height = (f32)view->font_height;
f32 cursor_y = view_get_cursor_y(view);
f32 target_y = view->target_y;
f32 max_y = view_compute_height(view) - line_height*2;
i32 lowest_line = view_compute_lowest_line(view);
f32 max_target_y = view_compute_max_target_y(lowest_line, (i32)line_height, max_y);
f32 delta_y = 3.f*line_height;
f32 extra_top = (f32)widget_height;
f32 taken_top_space = line_height + extra_top;
if (user_input->mouse.wheel != 0){
f32 wheel_multiplier = 3.f;
f32 delta_target_y = delta_y*user_input->mouse.wheel*wheel_multiplier;
target_y += delta_target_y;
if (target_y < -taken_top_space) target_y = -taken_top_space;
if (target_y > max_target_y) target_y = max_target_y;
f32 old_cursor_y = cursor_y;
if (cursor_y >= target_y + max_y) cursor_y = target_y + max_y;
if (cursor_y < target_y + taken_top_space) cursor_y = target_y + taken_top_space;
if (cursor_y != old_cursor_y){
view->cursor =
view_compute_cursor_from_xy(view,
view->preferred_x,
cursor_y);
}
result = 1;
}
if (cursor_y > target_y + max_y){
target_y = cursor_y - max_y + delta_y;
}
if (cursor_y < target_y + taken_top_space){
target_y = cursor_y - delta_y - taken_top_space;
}
if (target_y > max_target_y) target_y = max_target_y;
if (target_y < -extra_top) target_y = -extra_top;
view->target_y = target_y;
f32 cursor_x = view_get_cursor_x(view);
f32 target_x = view->target_x;
f32 max_x = view_compute_width(view);
if (cursor_x < target_x){
target_x = (f32)Max(0, cursor_x - max_x/2);
}
else if (cursor_x >= target_x + max_x){
target_x = (f32)(cursor_x - max_x/2);
}
view->target_x = target_x;
b32 is_new_target = 0;
if (view->target_x != view->prev_target_x) is_new_target = 1;
if (view->target_y != view->prev_target_y) is_new_target = 1;
if (view->models->scroll_rule(
view->target_x, view->target_y,
&view->scroll_x, &view->scroll_y,
(view->id) + 1, is_new_target)){
result = 1;
}
view->prev_target_x = view->target_x;
view->prev_target_y = view->target_y;
if (file->state.paste_effect.tick_down > 0){
--file->state.paste_effect.tick_down;
result = 1;
}
if (user_input->mouse.press_l && is_active){
f32 max_y = view_compute_height(view);
f32 rx = (f32)(user_input->mouse.x - rect.x0);
f32 ry = (f32)(user_input->mouse.y - rect.y0);
if (ry >= extra_top){
view_set_widget(view, FWIDG_NONE);
if (rx >= 0 && rx < max_x && ry >= 0 && ry < max_y){
view_cursor_move(view, rx + view->scroll_x, ry + view->scroll_y, 1);
view->mode = {};
}
}
result = 1;
}
if (!is_active) view_set_widget(view, FWIDG_NONE);
}
{
UI_State state =
ui_state_init(&view->ui_state, 0, user_input,
&models->style, models->global_font.font_id, models->font_set, &models->working_set, 1);
UI_Layout layout;
begin_layout(&layout, rect);
Super_Color color = {};
switch (view->showing_ui){
case VUI_None: break;
case VUI_Theme:
{
theme_shit(system, exchange, view, 0, &state, &layout, &color);
}break;
case VUI_Interactive:
{
if (interactive_shit(system, view, &state, &layout)){
result = 1;
}
}break;
case VUI_Menu:
{
menu_shit(view, &state, &layout);
}break;
case VUI_Config:
{
config_shit(view, &state, &layout);
}break;
}
i32 did_activation = 0;
if (ui_finish_frame(&view->ui_state, &state, &layout, rect, 0, &did_activation)){
result = 1;
}
if (did_activation){
if (view->showing_ui == VUI_Theme){
view->color = color;
result = 1;
}
}
}
return(result);
}
internal i32
draw_file_loaded(View *view, i32_Rect rect, b32 is_active, Render_Target *target){
Models *models = view->models;
Editing_File *file = view->file;
Style *style = &models->style;
i32 line_height = view->font_height;
i32 max_x = rect.x1 - rect.x0;
i32 max_y = rect.y1 - rect.y0 + line_height;
Assert(file && !file->state.is_dummy && buffer_good(&file->state.buffer));
b32 tokens_use = 0;
Cpp_Token_Stack token_stack = {};
if (file){
tokens_use = file->state.tokens_complete && (file->state.token_stack.count > 0);
token_stack = file->state.token_stack;
}
Partition *part = &models->mem.part;
Temp_Memory temp = begin_temp_memory(part);
partition_align(part, 4);
i32 max = partition_remaining(part) / sizeof(Buffer_Render_Item);
Buffer_Render_Item *items = push_array(part, Buffer_Render_Item, max);
i16 font_id = models->global_font.font_id;
Render_Font *font = get_font_info(models->font_set, font_id)->font;
float *advance_data = 0;
if (font) advance_data = font->advance_data;
i32 count;
Full_Cursor render_cursor;
Buffer_Render_Options opts = {};
f32 *wraps = view->line_wrap_y;
f32 scroll_x = view->scroll_x;
f32 scroll_y = view->scroll_y;
{
render_cursor = buffer_get_start_cursor(&file->state.buffer, wraps, scroll_y,
!view->unwrapped_lines, (f32)max_x, advance_data, (f32)line_height);
view->scroll_i = render_cursor.pos;
buffer_get_render_data(&file->state.buffer, items, max, &count,
(f32)rect.x0, (f32)rect.y0,
scroll_x, scroll_y, render_cursor,
!view->unwrapped_lines,
(f32)max_x, (f32)max_y,
advance_data, (f32)line_height,
opts);
}
Assert(count > 0);
i32 cursor_begin, cursor_end;
u32 cursor_color, at_cursor_color;
if (view->show_temp_highlight){
cursor_begin = view->temp_highlight.pos;
cursor_end = view->temp_highlight_end_pos;
cursor_color = style->main.highlight_color;
at_cursor_color = style->main.at_highlight_color;
}
else{
cursor_begin = view->cursor.pos;
cursor_end = cursor_begin + 1;
cursor_color = style->main.cursor_color;
at_cursor_color = style->main.at_cursor_color;
}
i32 token_i = 0;
u32 main_color = style->main.default_color;
u32 special_color = style->main.special_character_color;
if (tokens_use){
Cpp_Get_Token_Result result = cpp_get_token(&token_stack, items->index);
main_color = *style_get_color(style, token_stack.tokens[result.token_index]);
token_i = result.token_index + 1;
}
u32 mark_color = style->main.mark_color;
Buffer_Render_Item *item = items;
i32 prev_ind = -1;
u32 highlight_color = 0;
u32 highlight_this_color = 0;
for (i32 i = 0; i < count; ++i, ++item){
i32 ind = item->index;
highlight_this_color = 0;
if (tokens_use && ind != prev_ind){
Cpp_Token current_token = token_stack.tokens[token_i-1];
if (token_i < token_stack.count){
if (ind >= token_stack.tokens[token_i].start){
main_color =
*style_get_color(style, token_stack.tokens[token_i]);
current_token = token_stack.tokens[token_i];
++token_i;
}
else if (ind >= current_token.start + current_token.size){
main_color = 0xFFFFFFFF;
}
}
if (current_token.type == CPP_TOKEN_JUNK &&
i >= current_token.start && i < current_token.start + current_token.size){
highlight_color = style->main.highlight_junk_color;
}
else{
highlight_color = 0;
}
}
u32 char_color = main_color;
if (item->flags & BRFlag_Special_Character) char_color = special_color;
f32_Rect char_rect = f32R(item->x0, item->y0, item->x1, item->y1);
if (view->show_whitespace && highlight_color == 0 &&
char_is_whitespace((char)item->glyphid)){
highlight_this_color = style->main.highlight_white_color;
}
else{
highlight_this_color = highlight_color;
}
if (cursor_begin <= ind && ind < cursor_end && (ind != prev_ind || cursor_begin < ind)){
if (is_active){
draw_rectangle(target, char_rect, cursor_color);
char_color = at_cursor_color;
}
else{
if (!view->show_temp_highlight){
draw_rectangle_outline(target, char_rect, cursor_color);
}
}
}
else if (highlight_this_color){
draw_rectangle(target, char_rect, highlight_this_color);
}
u32 fade_color = 0xFFFF00FF;
f32 fade_amount = 0.f;
if (file->state.paste_effect.tick_down > 0 &&
file->state.paste_effect.start <= ind &&
ind < file->state.paste_effect.end){
fade_color = file->state.paste_effect.color;
fade_amount = (f32)(file->state.paste_effect.tick_down) / file->state.paste_effect.tick_max;
}
char_color = color_blend(char_color, fade_amount, fade_color);
if (ind == view->mark && prev_ind != ind){
draw_rectangle_outline(target, char_rect, mark_color);
}
if (item->glyphid != 0){
font_draw_glyph(target, font_id, (u8)item->glyphid,
item->x0, item->y0, char_color);
}
prev_ind = ind;
}
end_temp_memory(temp);
return(0);
}
internal i32
draw_file_view(System_Functions *system, Exchange *exchange,
View *view, View *active, i32_Rect rect, b32 is_active,
Render_Target *target, Input_Summary *user_input){
Models *models = view->models;
Editing_File *file = view->file;
i32 result = 0;
i32 widget_height = 0;
{
UI_State state =
ui_state_init(&view->widget.state, target, 0,
&models->style, models->global_font.font_id, models->font_set, 0, 0);
UI_Layout layout;
begin_layout(&layout, rect);
switch (view->widget.type){
case FWIDG_NONE:
{
if (file && view->showing_ui == VUI_None){
do_file_bar(view, file, &layout, target);
}
draw_file_view_queries(view, &state, &layout);
}break;
case FWIDG_TIMELINES:
{
if (file){
i32 undo_count = file->state.undo.undo.edit_count;
i32 redo_count = file->state.undo.redo.edit_count;
i32 total_count = undo_count + redo_count;
undo_shit(0, view, &state, &layout, total_count, undo_count, 0);
}
else{
view->widget.type = FWIDG_NONE;
}
}break;
}
widget_height = layout.y - rect.y0;
ui_finish_frame(&view->widget.state, &state, &layout, rect, 0, 0);
}
view->scroll_min_limit = (f32)-widget_height;
{
rect.y0 += widget_height;
target->push_clip(target, rect);
UI_State state =
ui_state_init(&view->ui_state, target, user_input,
&models->style, models->global_font.font_id, models->font_set, &models->working_set, 0);
UI_Layout layout;
begin_layout(&layout, rect);
rect.y0 -= widget_height;
Super_Color color = {};
switch (view->showing_ui){
case VUI_None:
{
if (file && file_is_ready(file)){
if (view->reinit_scrolling){
view_reinit_scrolling(view);
}
result = draw_file_loaded(view, rect, is_active, target);
}
}break;
case VUI_Theme:
{
theme_shit(system, exchange, view, active, &state, &layout, &color);
}break;
case VUI_Interactive:
{
interactive_shit(system, view, &state, &layout);
}break;
case VUI_Menu:
{
menu_shit(view, &state, &layout);
}break;
case VUI_Config:
{
config_shit(view, &state, &layout);
}break;
}
ui_finish_frame(&view->ui_state, &state, &layout, rect, 0, 0);
target->pop_clip(target);
}
return (result);
}
// TODO(allen): Passing this hook and app pointer is a hack. It can go as soon as we start
// initializing files independently of setting them to views.
internal void
kill_file(System_Functions *system, Exchange *exchange, Models *models, Editing_File *file,
Hook_Function *open_hook, Application_Links *app){
File_Node *node, *used;
file_close(system, &models->mem.general, file);
working_set_free_file(&models->working_set, file);
used = &models->working_set.used_sentinel;
node = used->next;
for (View_Iter iter = file_view_iter_init(&models->layout, file, 0);
file_view_iter_good(iter);
iter = file_view_iter_next(iter)){
if (node != used){
iter.view->file = 0;
view_set_file(iter.view, (Editing_File*)node, models, system, open_hook, app, 0);
node = node->next;
}
else{
iter.view->file = 0;
view_set_file(iter.view, 0, models, system, open_hook, app, 0);
}
}
}
inline void
free_file_view(View *view){
if (view->line_wrap_y)
general_memory_free(&view->models->mem.general, view->line_wrap_y);
}
struct Search_Range{
Buffer_Type *buffer;
i32 start, size;
};
struct Search_Set{
Search_Range *ranges;
i32 count, max;
};
struct Search_Iter{
String word;
i32 pos;
i32 i;
};
struct Search_Match{
Buffer_Type *buffer;
i32 start, end;
b32 found_match;
};
internal void
search_iter_init(General_Memory *general, Search_Iter *iter, i32 size){
i32 str_max;
if (iter->word.str == 0){
str_max = size*2;
iter->word.str = (char*)general_memory_allocate(general, str_max, 0);
iter->word.memory_size = str_max;
}
else if (iter->word.memory_size < size){
str_max = size*2;
iter->word.str = (char*)general_memory_reallocate_nocopy(general, iter->word.str, str_max, 0);
iter->word.memory_size = str_max;
}
iter->i = 0;
iter->pos = 0;
}
internal void
search_set_init(General_Memory *general, Search_Set *set, i32 set_count){
i32 max;
if (set->ranges == 0){
max = set_count*2;
set->ranges = (Search_Range*)general_memory_allocate(general, sizeof(Search_Range)*max, 0);
set->max = max;
}
else if (set->max < set_count){
max = set_count*2;
set->ranges = (Search_Range*)general_memory_reallocate_nocopy(
general, set->ranges, sizeof(Search_Range)*max, 0);
set->max = max;
}
set->count = set_count;
}
internal void
search_hits_table_alloc(General_Memory *general, Table *hits, i32 table_size){
i32 hash_size, mem_size;
hash_size = table_size * sizeof(u32);
hash_size = (hash_size + 7) & ~7;
mem_size = hash_size + table_size * sizeof(Offset_String);
hits->hash_array = (u32*)general_memory_allocate(general, mem_size, 0);
hits->data_array = (u8*)hits->hash_array + hash_size;
hits->max = table_size;
hits->item_size = sizeof(Offset_String);
}
internal void
search_hits_init(General_Memory *general, Table *hits, String_Space *str, i32 table_size, i32 str_size){
i32 hash_size, mem_size;
if (hits->hash_array == 0){
search_hits_table_alloc(general, hits, table_size);
}
else if (hits->max < table_size){
hash_size = table_size * sizeof(u32);
hash_size = (hash_size + 7) & ~7;
mem_size = hash_size + table_size * sizeof(Offset_String);
hits->hash_array = (u32*)general_memory_reallocate_nocopy(
general, hits->hash_array, mem_size, 0);
hits->data_array = (u8*)hits->hash_array + hash_size;
hits->max = table_size;
hits->item_size = sizeof(Offset_String);
}
if (str->space == 0){
str->space = (char*)general_memory_allocate(general, str_size, 0);
str->max = str_size;
}
else if (str->max < str_size){
str->space = (char*)general_memory_reallocate_nocopy(general, str->space, str_size, 0);
str->max = str_size;
}
str->pos = str->new_pos = 0;
table_clear(hits);
}
internal b32
search_hit_add(General_Memory *general, Table *hits, String_Space *space, char *str, i32 len){
b32 result;
i32 new_size;
Offset_String ostring;
Table new_hits;
Assert(len != 0);
ostring = strspace_append(space, str, len);
if (ostring.size == 0){
new_size = Max(space->max*2, space->max + len);
space->space = (char*)general_memory_reallocate(general, space->space, space->new_pos, new_size, 0);
ostring = strspace_append(space, str, len);
}
Assert(ostring.size != 0);
if (table_at_capacity(hits)){
search_hits_table_alloc(general, &new_hits, hits->max*2);
table_clear(&new_hits);
table_rehash(hits, &new_hits, space->space, tbl_offset_string_hash, tbl_offset_string_compare);
general_memory_free(general, hits->hash_array);
*hits = new_hits;
}
if (!table_add(hits, &ostring, space->space, tbl_offset_string_hash, tbl_offset_string_compare)){
result = 1;
strspace_keep_prev(space);
}
else{
result = 0;
strspace_discard_prev(space);
}
return(result);
}
internal Search_Match
search_next_match(Partition *part, Search_Set *set, Search_Iter *iter_){
Search_Match result = {};
Search_Iter iter = *iter_;
Search_Range *range;
Temp_Memory temp;
char *spare;
i32 start_pos, end_pos, count;
temp = begin_temp_memory(part);
spare = push_array(part, char, iter.word.size);
count = set->count;
for (; iter.i < count;){
range = set->ranges + iter.i;
end_pos = range->start + range->size;
if (iter.pos + iter.word.size < end_pos){
start_pos = Max(iter.pos, range->start);
result.start = buffer_find_string(range->buffer, start_pos, end_pos, iter.word.str, iter.word.size, spare);
if (result.start < end_pos){
iter.pos = result.start + 1;
if (result.start == 0 || !char_is_alpha_numeric(buffer_get_char(range->buffer, result.start - 1))){
result.end = buffer_seek_word_right_assume_on_word(range->buffer, result.start);
if (result.end < end_pos){
result.found_match = 1;
result.buffer = range->buffer;
iter.pos = result.end;
break;
}
}
}
else{
++iter.i, iter.pos = 0;
}
}
else{
++iter.i, iter.pos = 0;
}
}
end_temp_memory(temp);
*iter_ = iter;
return(result);
}
inline void
view_change_size(System_Functions *system, General_Memory *general, View *view){
if (view->file){
view_measure_wraps(system, general, view);
view->cursor = view_compute_cursor_from_pos(view, view->cursor.pos);
}
}
struct Live_Views{
View *views;
View free_sentinel;
i32 count, max;
};
internal View_And_ID
live_set_alloc_view(Live_Views *live_set, Panel *panel, Models *models){
View_And_ID result = {};
Assert(live_set->count < live_set->max);
++live_set->count;
result.view = live_set->free_sentinel.next;
result.id = (i32)(result.view - live_set->views);
dll_remove(result.view);
memset(result.view, 0, sizeof(View));
result.view->id = result.id;
result.view->in_use = 1;
panel->view = result.view;
result.view->panel = panel;
result.view->models = models;
result.view->scrub_max = 1;
// TODO(allen): Make "interactive" mode customizable just like the query bars!
result.view->query = make_fixed_width_string(result.view->query_);
result.view->dest = make_fixed_width_string(result.view->dest_);
init_query_set(&result.view->query_set);
return(result);
}
inline void
live_set_free_view(System_Functions *system, Exchange *exchange, Live_Views *live_set, View *view){
Assert(live_set->count > 0);
--live_set->count;
free_file_view(view);
dll_insert(&live_set->free_sentinel, view);
view->in_use = 0;
}
// BOTTOM