4coder/4ed_file.cpp

986 lines
27 KiB
C++
Raw Normal View History

2016-02-21 17:44:23 +00:00
/*
* Mr. 4th Dimention - Allen Webster
*
* 20.02.2016
*
* File editing view for 4coder
*
*/
// TOP
enum Edit_Pos_Set_Type{
EditPos_None,
EditPos_CursorSet,
EditPos_ScrollSet
};
struct File_Edit_Positions{
GUI_Scroll_Vars scroll;
Full_Cursor cursor;
i32 mark;
f32 preferred_x;
i32 scroll_i;
i32 last_set_type;
b32 in_view;
};
2016-09-13 19:56:14 +00:00
static File_Edit_Positions null_edit_pos = {0};
2016-02-21 17:44:23 +00:00
enum Edit_Type{
ED_NORMAL,
ED_REVERSE_NORMAL,
ED_UNDO,
ED_REDO,
};
struct Edit_Step{
Edit_Type type;
union{
struct{
b32 can_merge;
Buffer_Edit edit;
i32 next_block;
i32 prev_block;
2016-02-21 17:44:23 +00:00
};
struct{
i32 first_child;
i32 inverse_first_child;
i32 inverse_child_count;
i32 special_type;
};
};
i32 child_count;
};
struct Edit_Stack{
u8 *strings;
i32 size, max;
Edit_Step *edits;
i32 edit_count, edit_max;
};
struct Small_Edit_Stack{
u8 *strings;
i32 size, max;
Buffer_Edit *edits;
i32 edit_count, edit_max;
};
struct Undo_Data{
Edit_Stack undo;
Edit_Stack redo;
Edit_Stack history;
Small_Edit_Stack children;
i32 history_block_count, history_head_block;
i32 edit_history_cursor;
b32 current_block_normal;
};
struct Text_Effect{
i32 start, end;
u32 color;
2016-06-24 04:02:09 +00:00
f32 seconds_down, seconds_max;
2016-02-21 17:44:23 +00:00
};
// NOTE(allen): The Editing_File struct is now divided into two
// parts. Variables in the Settings part can be set even when the
2016-03-21 03:58:34 +00:00
// file is still streaming in, and persists thorugh all operations except
// for the initial allocation of the file.
2016-02-21 17:44:23 +00:00
struct Editing_File_Settings{
i32 base_map_id;
i32 display_width;
b32 dos_write_mode;
b32 virtual_white;
i16 font_id;
2016-03-21 03:58:34 +00:00
b8 unwrapped_lines;
2016-02-21 17:44:23 +00:00
b8 tokens_exist;
b8 is_initialized;
b8 unimportant;
2016-03-04 21:26:00 +00:00
b8 read_only;
2016-03-20 21:51:58 +00:00
b8 never_kill;
2016-02-21 17:44:23 +00:00
};
static Editing_File_Settings null_editing_file_settings = {0};
2016-02-21 17:44:23 +00:00
// NOTE(allen): This part of the Editing_File is cleared whenever
// the contents of the file is set.
struct Editing_File_State{
Buffer_Type buffer;
i32 *wrap_line_index;
i32 wrap_max;
i32 *character_starts;
i32 character_start_max;
f32 *line_indents;
i32 line_indent_max;
i32 wrap_line_count;
i32 *wrap_positions;
i32 wrap_position_count;
i32 wrap_position_max;
2016-02-21 17:44:23 +00:00
Undo_Data undo;
Cpp_Token_Array token_array;
Cpp_Token_Array swap_array;
2016-02-21 17:44:23 +00:00
u32 lex_job;
b32 tokens_complete;
b32 still_lexing;
Text_Effect paste_effect;
Dirty_State dirty;
2016-08-26 21:30:08 +00:00
u32 ignore_behind_os;
File_Edit_Positions edit_pos_space[16];
File_Edit_Positions *edit_poss[16];
i32 edit_poss_count;
2016-02-21 17:44:23 +00:00
};
static Editing_File_State null_editing_file_state = {0};
2016-02-21 17:44:23 +00:00
struct Editing_File_Name{
char live_name_[256];
char source_path_[256];
char extension_[16];
2016-03-08 23:06:27 +00:00
String live_name;
2016-02-21 17:44:23 +00:00
String source_path;
String extension;
};
struct Editing_File_Canon_Name{
char name_[256];
String name;
};
2016-03-04 21:26:00 +00:00
struct File_Node{
File_Node *next, *prev;
};
union Buffer_Slot_ID{
2016-03-08 23:06:27 +00:00
i32 id;
i16 part[2];
};
inline Buffer_Slot_ID
2016-03-08 23:06:27 +00:00
to_file_id(i32 id){
Buffer_Slot_ID result;
2016-03-08 23:06:27 +00:00
result.id = id;
return(result);
}
2016-02-21 17:44:23 +00:00
struct Editing_File{
2016-03-08 23:06:27 +00:00
// NOTE(allen): node must be the first member of Editing_File!
2016-03-04 21:26:00 +00:00
File_Node node;
2016-02-21 17:44:23 +00:00
Editing_File_Settings settings;
2016-05-29 22:01:27 +00:00
struct{
b32 is_loading;
b32 is_dummy;
2016-02-21 17:44:23 +00:00
Editing_File_State state;
};
Editing_File_Name name;
Editing_File_Canon_Name canon;
Buffer_Slot_ID id;
u64 unique_buffer_id;
2016-02-21 17:44:23 +00:00
};
struct Non_File_Table_Entry{
String name;
Buffer_Slot_ID id;
};
2016-03-08 23:06:27 +00:00
struct File_Array{
Editing_File *files;
i32 size;
};
2016-02-21 17:44:23 +00:00
struct Working_Set{
2016-03-08 23:06:27 +00:00
File_Array *file_arrays;
2016-03-05 04:10:55 +00:00
i32 file_count, file_max;
2016-03-08 23:06:27 +00:00
i16 array_count, array_max;
File_Node free_sentinel;
2016-03-04 21:26:00 +00:00
File_Node used_sentinel;
2016-02-21 17:44:23 +00:00
Table canon_table;
2016-08-24 14:36:29 +00:00
Table name_table;
2016-02-21 17:44:23 +00:00
String clipboards[64];
i32 clipboard_size, clipboard_max_size;
i32 clipboard_current, clipboard_rolling;
u64 unique_file_counter;
2016-07-20 16:16:02 +00:00
File_Node *sync_check_iter;
i32 default_display_width;
2016-02-21 17:44:23 +00:00
};
//
// File_Edit_Positions stuff
//
internal void
edit_pos_set_cursor_(File_Edit_Positions *edit_pos,
Full_Cursor cursor,
b32 set_preferred_x,
b32 unwrapped_lines){
edit_pos->cursor = cursor;
if (set_preferred_x){
edit_pos->preferred_x = cursor.wrapped_x;
if (unwrapped_lines){
edit_pos->preferred_x = cursor.unwrapped_x;
}
}
edit_pos->last_set_type = EditPos_CursorSet;
}
internal void
edit_pos_set_scroll_(File_Edit_Positions *edit_pos, GUI_Scroll_Vars scroll){
edit_pos->scroll = scroll;
edit_pos->last_set_type = EditPos_ScrollSet;
}
internal i32
edit_pos_get_index(Editing_File *file, File_Edit_Positions *edit_pos){
i32 edit_pos_index = -1;
i32 count = file->state.edit_poss_count;
File_Edit_Positions **edit_poss = file->state.edit_poss;
for (i32 i = 0; i < count; ++i){
if (edit_poss[i] == edit_pos){
edit_pos_index = i;
break;
}
}
return(edit_pos_index);
}
internal b32
edit_pos_move_to_front(Editing_File *file, File_Edit_Positions *edit_pos){
b32 result = false;
if (file && edit_pos){
i32 edit_pos_index = edit_pos_get_index(file, edit_pos);
Assert(edit_pos_index != -1);
File_Edit_Positions **edit_poss = file->state.edit_poss;
memmove(edit_poss + 1, edit_poss, edit_pos_index*sizeof(*edit_poss));
edit_poss[0] = edit_pos;
result = true;
}
return(result);
}
internal b32
edit_pos_unset(Editing_File *file, File_Edit_Positions *edit_pos){
b32 result = false;
if (file && edit_pos){
i32 edit_pos_index = edit_pos_get_index(file, edit_pos);
Assert(edit_pos_index != -1);
i32 count = file->state.edit_poss_count;
File_Edit_Positions **edit_poss = file->state.edit_poss;
memmove(edit_poss + edit_pos_index,
edit_poss + edit_pos_index + 1,
(count - edit_pos_index - 1)*sizeof(*edit_poss));
edit_pos->in_view = false;
if (file->state.edit_poss_count > 1){
file->state.edit_poss_count -= 1;
}
result = true;
}
return(result);
}
internal File_Edit_Positions*
edit_pos_get_new(Editing_File *file, i32 index){
File_Edit_Positions *result = 0;
if (file && 0 <= index && index < 16){
result = file->state.edit_pos_space + index;
i32 edit_pos_index = edit_pos_get_index(file, result);
if (edit_pos_index == -1){
File_Edit_Positions **edit_poss = file->state.edit_poss;
i32 count = file->state.edit_poss_count;
if (count > 0){
if (edit_poss[0]->in_view){
memcpy(result, edit_poss[0], sizeof(*result));
memmove(edit_poss+1, edit_poss, sizeof(*edit_poss)*count);
file->state.edit_poss_count = count + 1;
}
else{
Assert(count == 1);
memcpy(result, edit_poss[0], sizeof(*result));
}
}
else{
memset(result, 0, sizeof(*result));
file->state.edit_poss_count = 1;
}
edit_poss[0] = result;
}
result->in_view = true;
}
return(result);
}
2016-09-23 20:02:58 +00:00
//
// File Cursor Seeking
//
inline Partial_Cursor
file_compute_cursor_from_pos(Editing_File *file, i32 pos){
Partial_Cursor result = buffer_partial_from_pos(&file->state.buffer, pos);
return(result);
}
inline Partial_Cursor
file_compute_cursor_from_line_character(Editing_File *file, i32 line, i32 character){
Partial_Cursor result = buffer_partial_from_line_character(&file->state.buffer, line, character);
return(result);
}
inline b32
file_compute_partial_cursor(Editing_File *file, Buffer_Seek seek, Partial_Cursor *cursor){
b32 result = 1;
switch (seek.type){
case buffer_seek_pos:
{
*cursor = file_compute_cursor_from_pos(file, seek.pos);
}break;
case buffer_seek_line_char:
{
*cursor = file_compute_cursor_from_line_character(file, seek.line, seek.character);
}break;
default:
{
result = 0;
}break;
}
return(result);
}
//
// Working_Set stuff
//
2016-08-24 14:36:29 +00:00
struct File_Name_Entry{
String name;
Buffer_Slot_ID id;
};
internal i32
tbl_name_compare(void *a, void *b, void *arg){
String *fa = (String*)a;
File_Name_Entry *fb = (File_Name_Entry*)b;
i32 result = 1;
if (match_ss(*fa, fb->name)){
2016-08-24 14:36:29 +00:00
result = 0;
}
return(result);
}
2016-03-08 23:06:27 +00:00
internal void
working_set_extend_memory(Working_Set *working_set, Editing_File *new_space, i16 number_of_files){
Buffer_Slot_ID id;
2016-03-08 23:06:27 +00:00
i16 i, high_part;
Editing_File *file_ptr;
File_Node *free_sentinel;
Assert(working_set->array_count < working_set->array_max);
high_part = working_set->array_count++;
working_set->file_arrays[high_part].files = new_space;
working_set->file_arrays[high_part].size = number_of_files;
working_set->file_max += number_of_files;
id.part[1] = high_part;
file_ptr = new_space;
free_sentinel = &working_set->free_sentinel;
for (i = 0; i < number_of_files; ++i, ++file_ptr){
id.part[0] = i;
file_ptr->id = id;
dll_insert(free_sentinel, &file_ptr->node);
}
}
inline Editing_File
editing_file_zero(){
Editing_File file = {0};
return(file);
}
2016-03-08 23:06:27 +00:00
internal Editing_File*
working_set_alloc(Working_Set *working_set){
Editing_File *result = 0;
File_Node *node;
Buffer_Slot_ID id;
2016-03-08 23:06:27 +00:00
if (working_set->file_count < working_set->file_max){
node = working_set->free_sentinel.next;
Assert(node != &working_set->free_sentinel);
result = (Editing_File*)node;
dll_remove(node);
id = result->id;
*result = editing_file_zero();
2016-03-08 23:06:27 +00:00
result->id = id;
result->unique_buffer_id = ++working_set->unique_file_counter;
2016-03-08 23:06:27 +00:00
dll_insert(&working_set->used_sentinel, node);
result->settings.display_width = working_set->default_display_width;
2016-03-08 23:06:27 +00:00
++working_set->file_count;
}
2016-08-24 14:36:29 +00:00
return(result);
2016-03-08 23:06:27 +00:00
}
internal Editing_File*
working_set_alloc_always(System_Functions *system, Working_Set *working_set, General_Memory *general){
2016-03-08 23:06:27 +00:00
Editing_File *result = 0;
Editing_File *new_chunk;
i32 full_new_count = working_set->file_max;
i16 new_count;
if (full_new_count > max_i16) new_count = max_i16;
else new_count = (i16)full_new_count;
2016-03-08 23:06:27 +00:00
if (working_set->file_count == working_set->file_max &&working_set->array_count < working_set->array_max){
new_chunk = gen_array(system, general, Editing_File, new_count);
2016-03-08 23:06:27 +00:00
working_set_extend_memory(working_set, new_chunk, new_count);
}
result = working_set_alloc(working_set);
return(result);
}
inline void
working_set_free_file(Working_Set *working_set, Editing_File *file){
2016-07-20 16:16:02 +00:00
if (working_set->sync_check_iter == &file->node){
working_set->sync_check_iter = working_set->sync_check_iter->next;
}
2016-05-29 22:01:27 +00:00
file->is_dummy = 1;
2016-03-08 23:06:27 +00:00
dll_remove(&file->node);
dll_insert(&working_set->free_sentinel, &file->node);
--working_set->file_count;
}
inline Editing_File*
working_set_index(Working_Set *working_set, Buffer_Slot_ID id){
2016-03-08 23:06:27 +00:00
Editing_File *result = 0;
2016-08-24 14:36:29 +00:00
File_Array *array = 0;
2016-03-08 23:06:27 +00:00
if (id.part[1] >= 0 && id.part[1] < working_set->array_count){
array = working_set->file_arrays + id.part[1];
if (id.part[0] >= 0 && id.part[0] < array->size){
result = array->files + id.part[0];
}
}
return(result);
}
inline Editing_File*
working_set_index(Working_Set *working_set, i32 id){
2016-08-24 14:36:29 +00:00
Editing_File *result = working_set_index(working_set, to_file_id(id));
2016-03-08 23:06:27 +00:00
return(result);
}
inline Editing_File*
working_set_get_active_file(Working_Set *working_set, Buffer_Slot_ID id){
2016-03-08 23:06:27 +00:00
Editing_File *result = 0;
result = working_set_index(working_set, id);
2016-05-29 22:01:27 +00:00
if (result && result->is_dummy){
2016-03-08 23:06:27 +00:00
result = 0;
}
return(result);
}
inline Editing_File*
working_set_get_active_file(Working_Set *working_set, i32 id){
Editing_File *result;
result = working_set_get_active_file(working_set, to_file_id(id));
return(result);
}
2016-03-11 03:33:19 +00:00
internal void
working_set_init(System_Functions *system, Working_Set *working_set, Partition *partition, General_Memory *general){
2016-03-24 02:14:44 +00:00
i16 init_count = 16;
i16 array_init_count = 256;
2016-03-11 03:33:19 +00:00
dll_init_sentinel(&working_set->free_sentinel);
dll_init_sentinel(&working_set->used_sentinel);
2016-08-24 14:36:29 +00:00
working_set->array_max = array_init_count;
working_set->file_arrays = push_array(partition, File_Array, array_init_count);
2016-08-24 14:36:29 +00:00
Editing_File *files = push_array(partition, Editing_File, init_count);
2016-03-11 03:33:19 +00:00
working_set_extend_memory(working_set, files, init_count);
2016-08-24 14:36:29 +00:00
// NOTE(allen): init null file
{
Editing_File *null_file = working_set_index(working_set, 0);
dll_remove(&null_file->node);
null_file->is_dummy = 1;
++working_set->file_count;
}
// NOTE(allen): init canon table
2016-08-24 14:36:29 +00:00
{
i32 item_size = sizeof(File_Name_Entry);
2016-08-24 14:36:29 +00:00
i32 table_size = working_set->file_max;
i32 mem_size = table_required_mem_size(table_size, item_size);
void *mem = general_memory_allocate(system, general, mem_size);
2016-08-24 14:36:29 +00:00
memset(mem, 0, mem_size);
table_init_memory(&working_set->canon_table, mem, table_size, item_size);
2016-08-24 14:36:29 +00:00
}
// NOTE(allen): init name table
{
i32 item_size = sizeof(File_Name_Entry);
i32 table_size = working_set->file_max;
i32 mem_size = table_required_mem_size(table_size, item_size);
void *mem = general_memory_allocate(system, general, mem_size);
2016-08-24 14:36:29 +00:00
memset(mem, 0, mem_size);
table_init_memory(&working_set->name_table, mem, table_size, item_size);
}
2016-03-11 03:33:19 +00:00
}
inline void
working_set__grow_if_needed(System_Functions *system, Table *table, General_Memory *general, void *arg, Hash_Function *hash_func, Compare_Function *comp_func){
if (table_at_capacity(table)){
2016-08-24 14:36:29 +00:00
Table btable = {0};
i32 new_max = table->max * 2;
i32 mem_size = table_required_mem_size(new_max, table->item_size);
void *mem = general_memory_allocate(system, general, mem_size);
table_init_memory(&btable, mem, new_max, table->item_size);
table_clear(&btable);
table_rehash(table, &btable, 0, hash_func, comp_func);
general_memory_free(system, general, table->hash_array);
*table = btable;
}
}
2016-08-24 14:36:29 +00:00
internal Editing_File*
working_set_contains_basic(Working_Set *working_set, Table *table, String name){
2016-08-24 14:36:29 +00:00
Editing_File *result = 0;
File_Name_Entry *entry = (File_Name_Entry*)
table_find_item(table, &name, 0, tbl_string_hash, tbl_string_compare);
2016-08-24 14:36:29 +00:00
if (entry){
result = working_set_index(working_set, entry->id);
}
return(result);
}
internal b32
working_set_add_basic(System_Functions *system, General_Memory *general, Working_Set *working_set, Table *table, Editing_File *file, String name){
working_set__grow_if_needed(system, table, general, 0, tbl_string_hash, tbl_string_compare);
2016-08-24 14:36:29 +00:00
File_Name_Entry entry;
entry.name = name;
2016-08-24 14:36:29 +00:00
entry.id = file->id;
b32 result = (table_add(table, &entry, 0, tbl_string_hash, tbl_string_compare) == 0);
return(result);
2016-08-24 14:36:29 +00:00
}
internal void
working_set_remove_basic(Working_Set *working_set, Table *table, String name){
table_remove_match(table, &name, 0, tbl_string_hash, tbl_string_compare);
2016-08-24 14:36:29 +00:00
}
internal Editing_File*
working_set_canon_contains(Working_Set *working_set, String name){
Editing_File *result =
working_set_contains_basic(working_set, &working_set->canon_table, name);
2016-08-24 14:36:29 +00:00
return(result);
}
internal b32
working_set_canon_add(System_Functions *system, General_Memory *general, Working_Set *working_set,
2016-08-24 14:36:29 +00:00
Editing_File *file, String name){
b32 result = working_set_add_basic(system, general,working_set, &working_set->canon_table, file, name);
return(result);
2016-08-24 14:36:29 +00:00
}
internal void
working_set_canon_remove(Working_Set *working_set, String name){
working_set_remove_basic(working_set, &working_set->canon_table, name);
2016-08-24 14:36:29 +00:00
}
internal Editing_File*
working_set_name_contains(Working_Set *working_set, String name){
Editing_File *result =
working_set_contains_basic(working_set, &working_set->name_table, name);
return(result);
2016-03-11 03:33:19 +00:00
}
internal b32
working_set_name_add(System_Functions *system, General_Memory *general, Working_Set *working_set,
Editing_File *file, String name){
b32 result = working_set_add_basic(system, general, working_set, &working_set->name_table, file, name);
2016-03-24 02:14:44 +00:00
return(result);
}
internal void
working_set_name_remove(Working_Set *working_set, String name){
working_set_remove_basic(working_set, &working_set->name_table, name);
}
2016-03-11 03:33:19 +00:00
2016-03-08 23:06:27 +00:00
// TODO(allen): Pick better first options.
internal Editing_File*
working_set_lookup_file(Working_Set *working_set, String string){
Editing_File *file = 0;
{
2016-08-24 14:36:29 +00:00
// TODO(allen): use the name table for this
2016-03-08 23:06:27 +00:00
File_Node *node, *used_nodes;
used_nodes = &working_set->used_sentinel;
for (dll_items(node, used_nodes)){
file = (Editing_File*)node;
if (string.size == 0 || match_ss(string, file->name.live_name)){
2016-03-08 23:06:27 +00:00
break;
}
}
if (node == used_nodes) file = 0;
}
if (!file){
File_Node *node, *used_nodes;
used_nodes = &working_set->used_sentinel;
for (dll_items(node, used_nodes)){
file = (Editing_File*)node;
if (string.size == 0 || has_substr_s(file->name.live_name, string)){
2016-03-08 23:06:27 +00:00
break;
}
}
if (node == used_nodes) file = 0;
}
return (file);
}
2016-05-19 16:23:12 +00:00
internal void
touch_file(Working_Set *working_set, Editing_File *file){
2016-05-29 20:50:07 +00:00
if (file){
2016-05-29 22:01:27 +00:00
Assert(!file->is_dummy);
2016-05-29 20:50:07 +00:00
dll_remove(&file->node);
dll_insert(&working_set->used_sentinel, &file->node);
}
2016-05-19 16:23:12 +00:00
}
2016-03-08 23:06:27 +00:00
2016-02-21 17:44:23 +00:00
// Hot Directory
struct Hot_Directory{
String string;
File_List file_list;
// TODO(allen): eliminate slash
2016-02-23 03:14:23 +00:00
char slash;
2016-02-21 17:44:23 +00:00
};
internal void
hot_directory_clean_end(Hot_Directory *hot_directory){
String *str = &hot_directory->string;
2016-02-23 03:14:23 +00:00
if (str->size != 0 && str->str[str->size-1] != hot_directory->slash){
2016-02-21 17:44:23 +00:00
str->size = reverse_seek_slash(*str) + 1;
str->str[str->size] = 0;
}
}
internal i32
hot_directory_quick_partition(File_Info *infos, i32 start, i32 pivot){
File_Info *p = infos + pivot;
File_Info *a = infos + start;
for (i32 i = start; i < pivot; ++i, ++a){
i32 comp = 0;
comp = p->folder - a->folder;
if (comp == 0){
comp = compare_cc(a->filename, p->filename);
}
2016-02-21 17:44:23 +00:00
if (comp < 0){
Swap(File_Info, *a, infos[start]);
2016-02-21 17:44:23 +00:00
++start;
}
}
Swap(File_Info, *p, infos[start]);
2016-02-21 17:44:23 +00:00
return start;
}
internal void
hot_directory_quick_sort(File_Info *infos, i32 start, i32 pivot){
i32 mid = hot_directory_quick_partition(infos, start, pivot);
if (start < mid-1) hot_directory_quick_sort(infos, start, mid-1);
if (mid+1 < pivot) hot_directory_quick_sort(infos, mid+1, pivot);
}
inline void
hot_directory_fixup(Hot_Directory *hot_directory, Working_Set *working_set){
File_List *files = &hot_directory->file_list;
if (files->count >= 2)
hot_directory_quick_sort(files->infos, 0, files->count - 1);
}
inline void
hot_directory_set(System_Functions *system, Hot_Directory *hot_directory,
String str, Working_Set *working_set){
b32 success = copy_checked_ss(&hot_directory->string, str);
2016-02-21 17:44:23 +00:00
terminate_with_null(&hot_directory->string);
if (success){
2016-02-29 05:01:31 +00:00
if (str.size > 0){
system->set_file_list(&hot_directory->file_list, str);
}
else{
system->set_file_list(&hot_directory->file_list, make_string((char*)1, 0));
}
2016-02-21 17:44:23 +00:00
}
hot_directory_fixup(hot_directory, working_set);
}
inline void
hot_directory_reload(System_Functions *system, Hot_Directory *hot_directory, Working_Set *working_set){
system->set_file_list(&hot_directory->file_list, hot_directory->string);
hot_directory_fixup(hot_directory, working_set);
}
internal void
hot_directory_init(Hot_Directory *hot_directory, String base, String dir, char slash){
hot_directory->string = base;
hot_directory->string.str[255] = 0;
hot_directory->string.size = 0;
copy_ss(&hot_directory->string, dir);
append_s_char(&hot_directory->string, slash);
hot_directory->slash = slash;
}
2016-02-21 17:44:23 +00:00
struct Hot_Directory_Match{
String filename;
b32 is_folder;
};
internal b32
filename_match(String query, Absolutes *absolutes, String filename){
2016-02-21 17:44:23 +00:00
b32 result;
result = (query.size == 0);
if (!result) result = wildcard_match_s(absolutes, filename, 0);
2016-02-21 17:44:23 +00:00
return result;
}
2016-02-27 17:34:13 +00:00
inline b32
buffer_needs_save(Editing_File *file){
b32 result = 0;
2016-07-20 15:19:54 +00:00
if (!file->settings.unimportant){
if (file->state.dirty == DirtyState_UnsavedChanges){
2016-02-27 17:34:13 +00:00
result = 1;
2016-07-20 15:19:54 +00:00
}
}
2016-02-27 17:34:13 +00:00
return(result);
}
2016-08-26 21:30:08 +00:00
inline b32
buffer_can_save(Editing_File *file){
b32 result = 0;
if (!file->settings.unimportant){
if (file->state.dirty == DirtyState_UnsavedChanges ||
file->state.dirty == DirtyState_UnloadedChanges){
2016-08-26 21:30:08 +00:00
result = 1;
}
}
return(result);
}
inline b32
file_is_ready(Editing_File *file){
b32 result = 0;
2016-05-29 22:01:27 +00:00
if (file && file->is_loading == 0){
result = 1;
}
return(result);
}
2016-03-04 21:26:00 +00:00
inline void
file_set_to_loading(Editing_File *file){
file->state = null_editing_file_state;
file->settings = null_editing_file_settings;
2016-05-29 22:01:27 +00:00
file->is_loading = 1;
}
2016-07-20 15:19:54 +00:00
inline void
file_mark_clean(Editing_File *file){
if (file->state.dirty != DirtyState_UnloadedChanges){
file->state.dirty = DirtyState_UpToDate;
2016-07-20 15:19:54 +00:00
}
}
inline void
file_mark_dirty(Editing_File *file){
if (file->state.dirty != DirtyState_UnloadedChanges){
file->state.dirty = DirtyState_UnsavedChanges;
2016-07-20 15:19:54 +00:00
}
}
2016-07-20 15:19:54 +00:00
inline void
file_mark_behind_os(Editing_File *file){
file->state.dirty = DirtyState_UnloadedChanges;
2016-07-20 15:19:54 +00:00
}
inline Dirty_State
2016-07-20 15:19:54 +00:00
file_get_sync(Editing_File *file){
return (file->state.dirty);
2016-07-20 15:19:54 +00:00
}
2016-08-24 14:36:29 +00:00
internal void
editing_file_name_init(Editing_File_Name *name){
name->live_name = make_fixed_width_string(name->live_name_);
name->source_path = make_fixed_width_string(name->source_path_);
name->extension = make_fixed_width_string(name->extension_);
}
internal b32
get_canon_name(System_Functions *system, Editing_File_Canon_Name *canon_name, String filename){
canon_name->name = make_fixed_width_string(canon_name->name_);
canon_name->name.size =
system->get_canonical(filename.str, filename.size,
canon_name->name.str, canon_name->name.memory_size);
terminate_with_null(&canon_name->name);
b32 result = (canon_name->name.size != 0);
return(result);
}
2016-08-24 14:36:29 +00:00
internal void
buffer_get_new_name(Working_Set *working_set, Editing_File_Name *name, String filename){
Assert(name->live_name.str != 0);
copy_checked_ss(&name->source_path, filename);
copy_ss(&name->live_name, front_of_directory(filename));
2016-08-24 14:36:29 +00:00
if (name->source_path.size == name->live_name.size){
name->extension.size = 0;
}
else{
String ext = file_extension(filename);
copy_ss(&name->extension, ext);
2016-08-24 14:36:29 +00:00
}
{
i32 original_len = name->live_name.size;
i32 file_x = 0;
b32 hit_conflict = 1;
while (hit_conflict){
hit_conflict = 0;
File_Node *used_nodes = &working_set->used_sentinel, *node;
for (dll_items(node, used_nodes)){
Editing_File *file_ptr = (Editing_File*)node;
if (file_is_ready(file_ptr)){
if (match_ss(name->live_name, file_ptr->name.live_name)){
2016-08-24 14:36:29 +00:00
++file_x;
hit_conflict = 1;
break;
}
}
}
if (hit_conflict){
name->live_name.size = original_len;
append_ss(&name->live_name, make_lit_string(" <"));
2016-08-24 14:36:29 +00:00
append_int_to_str(&name->live_name, file_x);
append_s_char(&name->live_name, '>');
2016-08-24 14:36:29 +00:00
}
}
}
}
inline void
buffer_get_new_name(Working_Set *working_set, Editing_File_Name *name, char *filename){
String f = make_string_slowly(filename);
buffer_get_new_name(working_set, name, f);
}
internal void
2016-08-26 21:30:08 +00:00
buffer_bind_file(System_Functions *system, General_Memory *general, Working_Set *working_set,
Editing_File *file, String canon_filename){
2016-08-24 14:36:29 +00:00
Assert(file->name.live_name.size == 0 &&
file->name.source_path.size == 0 &&
file->name.extension.size == 0);
Assert(file->canon.name.size == 0);
2016-08-24 14:36:29 +00:00
file->canon.name = make_fixed_width_string(file->canon.name_);
copy_ss(&file->canon.name, canon_filename);
terminate_with_null(&file->canon.name);
2016-08-26 21:30:08 +00:00
system->add_listener(file->canon.name_);
b32 result = working_set_canon_add(system, general, working_set, file, file->canon.name);
Assert(result); AllowLocal(result);
2016-08-24 14:36:29 +00:00
}
internal void
2016-08-26 21:30:08 +00:00
buffer_unbind_file(System_Functions *system, Working_Set *working_set, Editing_File *file){
2016-08-24 14:36:29 +00:00
Assert(file->name.live_name.size == 0 &&
file->name.source_path.size == 0 &&
file->name.extension.size == 0);
Assert(file->canon.name.size != 0);
2016-08-24 14:36:29 +00:00
2016-08-26 21:30:08 +00:00
system->remove_listener(file->canon.name_);
working_set_canon_remove(working_set, file->canon.name);
file->canon.name.size = 0;
2016-08-24 14:36:29 +00:00
}
internal void
buffer_bind_name(System_Functions *system, General_Memory *general, Working_Set *working_set,
Editing_File *file, String filename){
2016-08-24 14:36:29 +00:00
Assert(file->name.live_name.size == 0 &&
file->name.source_path.size == 0 &&
file->name.extension.size == 0);
Editing_File_Name new_name;
editing_file_name_init(&new_name);
buffer_get_new_name(working_set, &new_name, filename);
editing_file_name_init(&file->name);
copy_ss(&file->name.live_name, new_name.live_name);
copy_ss(&file->name.source_path, new_name.source_path);
copy_ss(&file->name.extension, new_name.extension);
2016-08-24 14:36:29 +00:00
b32 result = working_set_name_add(system, general, working_set, file, file->name.live_name);
Assert(result); AllowLocal(result);
2016-08-24 14:36:29 +00:00
}
internal void
buffer_unbind_name(Working_Set *working_set, Editing_File *file){
Assert(file->name.live_name.size != 0);
working_set_name_remove(working_set, file->name.live_name);
file->name.live_name.size = 0;
file->name.source_path.size = 0;
file->name.extension.size = 0;
}
2016-02-21 17:44:23 +00:00
// BOTTOM