4coder/4ed_file.cpp

600 lines
20 KiB
C++
Raw Normal View History

/*
* Mr. 4th Dimention - Allen Webster
*
* 03.01.2017
*
* File layer for 4coder
*
*/
// TOP
2019-06-01 23:58:28 +00:00
internal String_Const_u8
string_from_file_name(Editing_File_Name *name){
return(SCu8(name->name_space, name->name_size));
}
////////////////////////////////
internal void
file_edit_positions_set_cursor(File_Edit_Positions *edit_pos, i64 pos){
edit_pos->cursor_pos = pos;
edit_pos->last_set_type = EditPos_CursorSet;
}
internal void
file_edit_positions_set_scroll(File_Edit_Positions *edit_pos, Buffer_Scroll scroll){
edit_pos->scroll = scroll;
edit_pos->last_set_type = EditPos_ScrollSet;
}
2019-02-04 03:51:43 +00:00
internal void
file_edit_positions_push(Editing_File *file, File_Edit_Positions edit_pos){
2019-02-04 03:51:43 +00:00
if (file->state.edit_pos_stack_top + 1 < ArrayCount(file->state.edit_pos_stack)){
file->state.edit_pos_stack_top += 1;
file->state.edit_pos_stack[file->state.edit_pos_stack_top] = edit_pos;
}
}
2019-02-04 03:51:43 +00:00
internal File_Edit_Positions
file_edit_positions_pop(Editing_File *file){
2019-02-04 03:51:43 +00:00
File_Edit_Positions edit_pos = {};
if (file->state.edit_pos_stack_top >= 0){
edit_pos = file->state.edit_pos_stack[file->state.edit_pos_stack_top];
file->state.edit_pos_stack_top -= 1;
}
2019-02-09 22:48:53 +00:00
else{
edit_pos = file->state.edit_pos_most_recent;
}
2019-02-04 03:51:43 +00:00
return(edit_pos);
}
////////////////////////////////
internal Face*
file_get_face(Models *models, Editing_File *file){
return(font_set_face_from_id(&models->font_set, file->settings.face_id));
}
internal Access_Flag
file_get_access_flags(Editing_File *file){
Access_Flag flags = Access_Read|Access_Visible;
if (!file->settings.read_only){
flags |= Access_Write;
}
return(flags);
}
2019-01-31 13:06:42 +00:00
internal b32
2019-01-29 05:36:17 +00:00
file_needs_save(Editing_File *file){
b32 result = false;
2019-02-26 21:05:02 +00:00
if (HasFlag(file->state.dirty, DirtyState_UnsavedChanges)){
result = true;
}
return(result);
}
2019-01-31 13:06:42 +00:00
internal b32
2019-01-29 05:36:17 +00:00
file_can_save(Editing_File *file){
b32 result = false;
2019-02-25 23:42:13 +00:00
if (HasFlag(file->state.dirty, DirtyState_UnsavedChanges) ||
HasFlag(file->state.dirty, DirtyState_UnloadedChanges)){
result = true;
}
return(result);
}
2019-01-31 13:06:42 +00:00
internal b32
file_is_ready(Editing_File *file){
b32 result = false;
if (file != 0 && file->is_loading == 0){
result = true;
}
return(result);
}
2019-01-31 13:06:42 +00:00
internal void
2018-05-07 02:47:22 +00:00
file_set_unimportant(Editing_File *file, b32 val){
if (val){
file->state.dirty = DirtyState_UpToDate;
}
2019-08-13 04:19:02 +00:00
file->settings.unimportant = (b8)(val);
2018-05-07 02:47:22 +00:00
}
2019-01-31 13:06:42 +00:00
internal void
file_set_to_loading(Editing_File *file){
2019-08-13 04:19:02 +00:00
block_zero_struct(&file->state);
block_zero_struct(&file->settings);
file->is_loading = true;
}
2019-01-31 13:06:42 +00:00
internal void
2019-02-25 23:42:13 +00:00
file_add_dirty_flag(Editing_File *file, Dirty_State state){
if (!file->settings.unimportant){
2019-02-25 23:42:13 +00:00
file->state.dirty |= state;
}
else{
file->state.dirty = DirtyState_UpToDate;
}
}
2019-02-25 23:42:13 +00:00
internal void
file_clear_dirty_flags(Editing_File *file){
file->state.dirty = DirtyState_UpToDate;
}
////////////////////////////////
2019-06-01 23:58:28 +00:00
internal void
file_name_terminate(Editing_File_Name *name){
umem size = name->name_size;
size = clamp_top(size, sizeof(name->name_space) - 1);
name->name_space[size] = 0;
name->name_size = size;
}
////////////////////////////////
2019-08-04 00:49:40 +00:00
// TODO(allen): file_name should be String_Const_u8
internal b32
save_file_to_name(Thread_Context *tctx, Models *models, Editing_File *file, u8 *file_name){
b32 result = false;
b32 using_actual_file_name = false;
if (file_name == 0){
2019-06-01 23:58:28 +00:00
file_name_terminate(&file->canon);
file_name = file->canon.name_space;
using_actual_file_name = true;
}
if (file_name != 0){
2019-10-14 22:57:47 +00:00
if (models->save_file != 0){
Application_Links app = {};
app.tctx = tctx;
app.cmd_context = models;
models->save_file(&app, file->id);
}
Gap_Buffer *buffer = &file->state.buffer;
2018-08-18 08:16:52 +00:00
b32 dos_write_mode = file->settings.dos_write_mode;
Scratch_Block scratch(tctx, Scratch_Share);
2019-06-01 23:58:28 +00:00
if (!using_actual_file_name){
2019-08-04 00:49:40 +00:00
String_Const_u8 s_file_name = SCu8(file_name);
String_Const_u8 canonical_file_name = system_get_canonical(scratch, s_file_name);
2019-08-04 00:49:40 +00:00
if (string_match(canonical_file_name, string_from_file_name(&file->canon))){
using_actual_file_name = true;
}
}
String_Const_u8 saveable_string = buffer_stringify(scratch, buffer, Ii64(0, buffer_size(buffer)));
File_Attributes new_attributes = system_save_file(scratch, (char*)file_name, saveable_string);
if (new_attributes.last_write_time > 0 &&
using_actual_file_name){
file->state.save_state = FileSaveState_SavedWaitingForNotification;
file_clear_dirty_flags(file);
}
LogEventF(log_string(M), scratch, file->id, 0, system_thread_get_id(),
2019-08-16 02:54:06 +00:00
"save file [last_write_time=0x%llx]", new_attributes.last_write_time);
}
return(result);
}
2019-01-31 13:06:42 +00:00
internal b32
save_file(Thread_Context *tctx, Models *models, Editing_File *file){
return(save_file_to_name(tctx, models, file, 0));
}
////////////////////////////////
internal Buffer_Cursor
file_compute_cursor(Editing_File *file, Buffer_Seek seek){
Buffer_Cursor result = {};
switch (seek.type){
case buffer_seek_pos:
{
result = buffer_cursor_from_pos(&file->state.buffer, seek.pos);
}break;
case buffer_seek_line_col:
{
result = buffer_cursor_from_line_col(&file->state.buffer, seek.line, seek.col);
}break;
}
return(result);
}
////////////////////////////////
internal void
file_create_from_string(Thread_Context *tctx, Models *models, Editing_File *file, String_Const_u8 val, File_Attributes attributes){
Scratch_Block scratch(tctx, Scratch_Share);
Base_Allocator *allocator = tctx->allocator;
block_zero_struct(&file->state);
buffer_init(&file->state.buffer, val.str, val.size, allocator);
if (buffer_size(&file->state.buffer) < (i64)val.size){
file->settings.dos_write_mode = true;
}
2019-02-25 23:42:13 +00:00
file_clear_dirty_flags(file);
file->attributes = attributes;
file->settings.face_id = models->global_face_id;
buffer_measure_starts(scratch, &file->state.buffer);
2019-09-04 05:31:35 +00:00
file->lifetime_object = lifetime_alloc_object(&models->lifetime_allocator, DynamicWorkspace_Buffer, file);
history_init(tctx, models, &file->state.history);
file->state.cached_layouts_arena = make_arena(allocator);
file->state.line_layout_table = make_table_Data_u64(allocator, 500);
file->settings.is_initialized = true;
2019-08-16 02:54:06 +00:00
{
Temp_Memory temp = begin_temp(scratch);
String_Const_u8 name = SCu8(file->unique_name.name_space, file->unique_name.name_size);
name = string_escape(scratch, name);
LogEventF(log_string(M), scratch, file->id, 0, system_thread_get_id(),
"init file [lwt=0x%llx] [name=\"%.*s\"]",
2019-08-16 02:54:06 +00:00
attributes.last_write_time, string_expand(name));
end_temp(temp);
}
2019-09-04 05:31:35 +00:00
////////////////////////////////
2019-10-14 22:57:47 +00:00
if (models->begin_buffer != 0){
Application_Links app = {};
app.tctx = tctx;
app.cmd_context = models;
models->begin_buffer(&app, file->id);
2019-09-04 05:31:35 +00:00
}
}
internal void
file_free(Thread_Context *tctx, Models *models, Editing_File *file){
Lifetime_Allocator *lifetime_allocator = &models->lifetime_allocator;
Working_Set *working_set = &models->working_set;
2019-09-04 05:31:35 +00:00
lifetime_free_object(lifetime_allocator, file->lifetime_object);
Gap_Buffer *buffer = &file->state.buffer;
if (buffer->data){
base_free(buffer->allocator, buffer->data);
base_free(buffer->allocator, buffer->line_starts);
}
history_free(tctx, &file->state.history);
linalloc_clear(&file->state.cached_layouts_arena);
table_free(&file->state.line_layout_table);
}
2019-02-08 10:03:48 +00:00
////////////////////////////////
internal i32
file_get_current_record_index(Editing_File *file){
return(file->state.current_record_index);
}
internal Managed_Scope
file_get_managed_scope(Editing_File *file){
Managed_Scope scope = 0;
if (file != 0){
Assert(file->lifetime_object != 0);
scope = (Managed_Scope)file->lifetime_object->workspace.scope_id;
}
return(scope);
}
////////////////////////////////
internal Layout_Item_List
file_get_line_layout(Thread_Context *tctx, Models *models, Editing_File *file,
Layout_Function *layout_func, f32 width, Face *face, i64 line_number){
Layout_Item_List result = {};
i64 line_count = buffer_line_count(&file->state.buffer);
if (1 <= line_number && line_number <= line_count){
Line_Layout_Key key = {};
key.face_id = face->id;
key.face_version_number = face->version_number;
key.width = width;
key.line_number = line_number;
Data key_data = make_data_struct(&key);
Layout_Item_List *list = 0;
Table_Lookup lookup = table_lookup(&file->state.line_layout_table, key_data);
if (lookup.found_match){
u64 val = 0;
table_read(&file->state.line_layout_table, lookup, &val);
list = (Layout_Item_List*)IntAsPtr(val);
}
else{
list = push_array(&file->state.cached_layouts_arena, Layout_Item_List, 1);
Range_i64 line_range = buffer_get_pos_range_from_line_number(&file->state.buffer, line_number);
Application_Links app = {};
app.tctx = tctx;
app.cmd_context = models;
*list = layout_func(&app, &file->state.cached_layouts_arena,
file->id, line_range, face->id, width);
key_data = push_data_copy(&file->state.cached_layouts_arena, key_data);
table_insert(&file->state.line_layout_table, key_data, (u64)PtrAsInt(list));
}
block_copy_struct(&result, list);
}
return(result);
}
internal void
file_clear_layout_cache(Editing_File *file){
linalloc_clear(&file->state.cached_layouts_arena);
table_clear(&file->state.line_layout_table);
}
internal Line_Shift_Vertical
file_line_shift_y(Thread_Context *tctx, Models *models, Editing_File *file,
Layout_Function *layout_func, f32 width, Face *face,
i64 line_number, f32 y_delta){
Line_Shift_Vertical result = {};
f32 line_y = 0.f;
if (y_delta < 0.f){
// NOTE(allen): Iterating upward
b32 has_result = false;
for (;;){
if (line_y <= y_delta){
has_result = true;
result.line = line_number;
result.y_delta = line_y;
break;
}
line_number -= 1;
if (line_number <= 0){
line_number = 1;
break;
}
Layout_Item_List line = file_get_line_layout(tctx, models, file, layout_func,
width, face, line_number);
line_y -= line.height;
}
if (!has_result){
result.line = line_number;
result.y_delta = line_y;
}
}
else{
// NOTE(allen): Iterating downward
b32 has_result = false;
i64 line_count = buffer_line_count(&file->state.buffer);
for (;;line_number += 1){
Layout_Item_List line = file_get_line_layout(tctx, models, file, layout_func,
width, face, line_number);
f32 next_y = line_y + line.height;
if (y_delta < next_y){
has_result = true;
result.line = line_number;
result.y_delta = line_y;
break;
}
if (line_number >= line_count){
break;
}
line_y = next_y;
}
if (!has_result){
result.line = line_number;
result.y_delta = line_y;
}
}
return(result);
}
internal f32
file_line_y_difference(Thread_Context *tctx, Models *models, Editing_File *file,
Layout_Function *layout_func, f32 width, Face *face,
i64 line_a, i64 line_b){
f32 result = 0.f;
if (line_a != line_b){
Interval_i64 line_range = Ii64(line_a, line_b);
for (i64 i = line_range.min; i < line_range.max; i += 1){
Layout_Item_List line = file_get_line_layout(tctx, models, file, layout_func,
width, face, i);
result += line.height;
}
if (line_a < line_b){
result *= -1.f;
}
}
return(result);
}
internal i64
file_pos_at_relative_xy(Thread_Context *tctx, Models *models, Editing_File *file,
Layout_Function *layout_func, f32 width, Face *face,
i64 base_line, Vec2_f32 relative_xy){
Line_Shift_Vertical shift = file_line_shift_y(tctx, models, file,
layout_func, width, face, base_line,
relative_xy.y);
relative_xy.y -= shift.y_delta;
Layout_Item_List line = file_get_line_layout(tctx, models, file,
layout_func, width, face,
shift.line);
return(buffer_layout_nearest_pos_to_xy(line, relative_xy));
}
2019-10-30 23:27:37 +00:00
internal Rect_f32
file_relative_box_of_pos(Thread_Context *tctx, Models *models, Editing_File *file,
Layout_Function *layout_func, f32 width, Face *face,
i64 base_line, i64 pos){
i64 line_number = buffer_get_line_index(&file->state.buffer, pos) + 1;
Layout_Item_List line = file_get_line_layout(tctx, models, file,
layout_func, width, face,
line_number);
2019-10-30 23:27:37 +00:00
Rect_f32 result = buffer_layout_box_of_pos(line, pos);
f32 y_difference = file_line_y_difference(tctx, models, file,
layout_func, width, face,
line_number, base_line);
result.y0 += y_difference;
result.y1 += y_difference;
return(result);
}
2019-10-30 23:27:37 +00:00
function Vec2_f32
file_relative_xy_of_pos(Thread_Context *tctx, Models *models, Editing_File *file,
Layout_Function *layout_func, f32 width, Face *face,
i64 base_line, i64 pos){
Rect_f32 rect = file_relative_box_of_pos(tctx, models, file,
layout_func, width, face,
base_line, pos);
return(rect_center(rect));
}
internal Buffer_Point
file_normalize_buffer_point(Thread_Context *tctx, Models *models, Editing_File *file,
Layout_Function *layout_func, f32 width, Face *face,
Buffer_Point point){
Line_Shift_Vertical shift = file_line_shift_y(tctx, models, file,
layout_func, width, face, point.line_number,
point.pixel_shift.y);
point.line_number = shift.line;
point.pixel_shift.y -= shift.y_delta;
point.pixel_shift.x = clamp_bot(0.f, point.pixel_shift.x);
point.pixel_shift.y = clamp_bot(0.f, point.pixel_shift.y);
return(point);
}
internal Vec2_f32
file_buffer_point_difference(Thread_Context *tctx, Models *models, Editing_File *file,
Layout_Function *layout_func, f32 width, Face *face,
Buffer_Point a, Buffer_Point b){
f32 y_difference = file_line_y_difference(tctx, models, file,
layout_func, width, face,
a.line_number, b.line_number);
Vec2_f32 result = a.pixel_shift - b.pixel_shift;
result.y += y_difference;
return(result);
}
internal Line_Shift_Character
file_line_shift_characters(Thread_Context *tctx, Models *models, Editing_File *file,
Layout_Function *layout_func, f32 width, Face *face,
i64 line_number, i64 character_delta){
Line_Shift_Character result = {};
i64 line_character = 0;
if (character_delta < 0){
// NOTE(allen): Iterating upward
b32 has_result = false;
for (;;){
if (line_character <= character_delta){
has_result = true;
result.line = line_number;
result.character_delta = line_character;
break;
}
line_number -= 1;
if (line_number <= 0){
line_number = 1;
break;
}
Layout_Item_List line = file_get_line_layout(tctx, models, file,
layout_func, width, face,
line_number);
line_character -= line.character_count;
}
if (!has_result){
result.line = line_number;
result.character_delta = line_character;
}
}
else{
// NOTE(allen): Iterating downward
b32 has_result = false;
i64 line_count = buffer_line_count(&file->state.buffer);
for (;;line_number += 1){
Layout_Item_List line = file_get_line_layout(tctx, models, file,
layout_func, width, face,
line_number);
i64 next_character = line_character + line.character_count;
if (character_delta < next_character){
has_result = true;
result.line = line_number;
result.character_delta = line_character;
break;
}
if (line_number >= line_count){
break;
}
line_character = next_character;
}
if (!has_result){
result.line = line_number;
result.character_delta = line_character;
}
}
return(result);
}
internal i64
file_line_character_difference(Thread_Context *tctx, Models *models, Editing_File *file,
Layout_Function *layout_func, f32 width, Face *face,
i64 line_a, i64 line_b){
i64 result = 0;
if (line_a != line_b){
Interval_i64 line_range = Ii64(line_a, line_b);
for (i64 i = line_range.min; i < line_range.max; i += 1){
Layout_Item_List line = file_get_line_layout(tctx, models, file,
layout_func, width, face, i);
result += line.character_count;
}
if (line_a < line_b){
result *= -1;
}
}
return(result);
}
internal i64
file_pos_from_relative_character(Thread_Context *tctx, Models *models, Editing_File *file,
Layout_Function *layout_func, f32 width, Face *face,
i64 base_line, i64 relative_character){
Line_Shift_Character shift = file_line_shift_characters(tctx, models, file,
layout_func, width, face,
base_line, relative_character);
relative_character -= shift.character_delta;
Layout_Item_List line = file_get_line_layout(tctx, models, file,
layout_func, width, face,
shift.line);
return(buffer_layout_get_pos_at_character(line, relative_character));
}
internal i64
file_relative_character_from_pos(Thread_Context *tctx, Models *models, Editing_File *file, Layout_Function *layout_func, f32 width, Face *face,
i64 base_line, i64 pos){
i64 line_number = buffer_get_line_index(&file->state.buffer, pos) + 1;
Layout_Item_List line = file_get_line_layout(tctx, models, file,
layout_func, width, face,
line_number);
i64 result = buffer_layout_character_from_pos(line, pos);
result += file_line_character_difference(tctx, models, file,
layout_func, width, face, line_number, base_line);
return(result);
}
// BOTTOM