smart cursors
parent
6918ae0be4
commit
c100efd1af
|
@ -126,7 +126,6 @@ HOOK_SIG(my_file_settings){
|
|||
push_parameter(cmd_context, par_lex_as_cpp_file, treat_as_code);
|
||||
push_parameter(cmd_context, par_wrap_lines, !treat_as_code);
|
||||
push_parameter(cmd_context, par_key_mapid, (treat_as_code)?(my_code_map):(mapid_file));
|
||||
push_parameter(cmd_context, par_end_line_mode, EOL_USE_CRLF);
|
||||
exec_command(cmd_context, cmdid_set_settings);
|
||||
}
|
||||
|
||||
|
@ -228,9 +227,8 @@ extern "C" GET_BINDING_DATA(get_bindings){
|
|||
bind(context, 'j', MDFR_CTRL, cmdid_to_lowercase);
|
||||
bind(context, '?', MDFR_CTRL, cmdid_toggle_show_whitespace);
|
||||
|
||||
// NOTE(allen): These whitespace manipulators are not currently functional
|
||||
bind(context, '`', MDFR_CTRL, cmdid_clean_line);
|
||||
bind(context, '~', MDFR_CTRL, cmdid_clean_all_lines);
|
||||
// NOTE(allen): These whitespace manipulators are not currently functional
|
||||
bind(context, '1', MDFR_CTRL, cmdid_eol_dosify);
|
||||
bind(context, '!', MDFR_CTRL, cmdid_eol_nixify);
|
||||
|
||||
|
|
|
@ -92,7 +92,6 @@ enum Command_ID{
|
|||
cmdid_to_uppercase,
|
||||
cmdid_to_lowercase,
|
||||
cmdid_toggle_show_whitespace,
|
||||
cmdid_clean_line,
|
||||
cmdid_clean_all_lines,
|
||||
cmdid_eol_dosify,
|
||||
cmdid_eol_nixify,
|
||||
|
@ -124,7 +123,6 @@ enum Param_ID{
|
|||
par_lex_as_cpp_file,
|
||||
par_wrap_lines,
|
||||
par_key_mapid,
|
||||
par_end_line_mode,
|
||||
// never below this
|
||||
par_type_count
|
||||
};
|
||||
|
@ -208,12 +206,6 @@ struct Extra_Font{
|
|||
int size;
|
||||
};
|
||||
|
||||
enum EOL_Option{
|
||||
EOL_USE_CRLF,
|
||||
EOL_USE_CR_USE_LF,
|
||||
EOL_SHOW_CR_USE_LF
|
||||
};
|
||||
|
||||
struct Buffer_Summary{
|
||||
// NOTE(allen): None of these members nor any of the data pointed to
|
||||
// by these members should be modified.
|
||||
|
@ -229,7 +221,6 @@ struct Buffer_Summary{
|
|||
|
||||
int file_cursor_pos;
|
||||
|
||||
EOL_Option eol_mode;
|
||||
int is_lexed;
|
||||
|
||||
int map_id;
|
||||
|
|
326
4ed.cpp
326
4ed.cpp
|
@ -8,78 +8,6 @@
|
|||
*/
|
||||
|
||||
// TOP
|
||||
// TODO(allen):
|
||||
//
|
||||
// BUGS & PROBLEMS
|
||||
//
|
||||
// - line_wrap_ys remeasurement optimization
|
||||
//
|
||||
// GENERAL
|
||||
//
|
||||
// - eol regularization
|
||||
//
|
||||
// - untabification
|
||||
//
|
||||
// - mode switching
|
||||
//
|
||||
// - auto mode switching
|
||||
//
|
||||
// - meta command stuff
|
||||
// command use frequency
|
||||
//
|
||||
// - configuration / GUI for generating configuration
|
||||
//
|
||||
// - travel packaging
|
||||
//
|
||||
// - multiple live name conflicts
|
||||
//
|
||||
// - nav links
|
||||
//
|
||||
// - on file reopen diff and try to find place for cursor
|
||||
//
|
||||
// TOOLS
|
||||
//
|
||||
// - calculator with: dec hex translation
|
||||
//
|
||||
// - solver
|
||||
//
|
||||
// TEXT MODE
|
||||
//
|
||||
// - replace
|
||||
//
|
||||
// - select word
|
||||
//
|
||||
// - match list
|
||||
//
|
||||
// - regular expression
|
||||
//
|
||||
// BASIC CODE MODE - general any language
|
||||
//
|
||||
// - select token
|
||||
//
|
||||
// - reprogrammable lexing / auto indent
|
||||
//
|
||||
// - bracket match / mismatch highlighting
|
||||
//
|
||||
// - smart line wrapping (using tokens and white space as separation points)
|
||||
//
|
||||
// - auto casing rules?
|
||||
//
|
||||
// SUPER CODE MODE - C/C++ editing
|
||||
//
|
||||
// - identifier rename
|
||||
//
|
||||
// - boolean inverse polarity
|
||||
//
|
||||
// - compose/explode class/hierarchy
|
||||
// - virtual to vtable sim/switch
|
||||
//
|
||||
// - explode class template?
|
||||
//
|
||||
// - enumerate template combinations?
|
||||
//
|
||||
// - generate header
|
||||
//
|
||||
|
||||
// App Structs
|
||||
|
||||
|
@ -273,15 +201,8 @@ COMMAND_DECL(write_character){
|
|||
u8 character = (u8)command->key.key.character;
|
||||
char str_space[2];
|
||||
String string = make_string(str_space, 2);
|
||||
if (character == '\n' && file->endline_mode == EOL_USE_CRLF){
|
||||
str_space[0] = '\r';
|
||||
str_space[1] = '\n';
|
||||
string.size = 2;
|
||||
}
|
||||
else{
|
||||
str_space[0] = character;
|
||||
string.size = 1;
|
||||
}
|
||||
str_space[0] = character;
|
||||
string.size = 1;
|
||||
|
||||
i32 pos;
|
||||
pos = view->cursor.pos;
|
||||
|
@ -338,6 +259,7 @@ COMMAND_DECL(seek_whitespace_left){
|
|||
view_cursor_move(view, pos);
|
||||
}
|
||||
|
||||
// TODO(allen): see if this becomes better by using buffer procudures directly
|
||||
COMMAND_DECL(seek_whitespace_up){
|
||||
ProfileMomentFunction();
|
||||
REQ_FILE_VIEW(view);
|
||||
|
@ -351,29 +273,17 @@ COMMAND_DECL(seek_whitespace_up){
|
|||
|
||||
bool32 no_hard_character = 0;
|
||||
while (pos > 0){
|
||||
if (starts_new_line(data[pos], file->endline_mode)){
|
||||
if (no_hard_character){
|
||||
break;
|
||||
}
|
||||
else{
|
||||
no_hard_character = 1;
|
||||
}
|
||||
if (starts_new_line(data[pos])){
|
||||
if (no_hard_character) break;
|
||||
else no_hard_character = 1;
|
||||
}
|
||||
else{
|
||||
if (!char_is_whitespace(data[pos])){
|
||||
no_hard_character = 0;
|
||||
}
|
||||
else if (!char_is_whitespace(data[pos])){
|
||||
no_hard_character = 0;
|
||||
}
|
||||
--pos;
|
||||
}
|
||||
|
||||
if (pos != 0){
|
||||
++pos;
|
||||
}
|
||||
|
||||
if (file->endline_mode == EOL_USE_CRLF){
|
||||
pos = pos_adjust_to_self(pos, (u8*)data, file->buffer.size);
|
||||
}
|
||||
if (pos != 0) ++pos;
|
||||
|
||||
view_cursor_move(view, pos);
|
||||
}
|
||||
|
@ -393,29 +303,21 @@ COMMAND_DECL(seek_whitespace_down){
|
|||
bool32 no_hard_character = 0;
|
||||
i32 prev_endline = -1;
|
||||
while (pos < size){
|
||||
if (starts_new_line(data[pos], file->endline_mode)){
|
||||
if (no_hard_character){
|
||||
break;
|
||||
}
|
||||
if (starts_new_line(data[pos])){
|
||||
if (no_hard_character) break;
|
||||
else{
|
||||
no_hard_character = 1;
|
||||
prev_endline = pos;
|
||||
}
|
||||
}
|
||||
else{
|
||||
if (!char_is_whitespace(data[pos])){
|
||||
no_hard_character = 0;
|
||||
}
|
||||
else if (!char_is_whitespace(data[pos])){
|
||||
no_hard_character = 0;
|
||||
}
|
||||
++pos;
|
||||
}
|
||||
|
||||
if (prev_endline == -1 || prev_endline+1 >= size){
|
||||
pos = size;
|
||||
}
|
||||
else{
|
||||
pos = prev_endline+1;
|
||||
}
|
||||
if (prev_endline == -1 || prev_endline+1 >= size) pos = size;
|
||||
else pos = prev_endline+1;
|
||||
|
||||
view_cursor_move(view, pos);
|
||||
}
|
||||
|
@ -665,9 +567,7 @@ COMMAND_DECL(cut){
|
|||
clipboard_copy(&mem->general, working_set, data, range);
|
||||
view_replace_range(mem, view, layout, range.start, range.end, 0, 0, next_cursor_pos);
|
||||
|
||||
view->mark = pos_universal_fix(range.start,
|
||||
(u8*)file->buffer.data, file->buffer.size,
|
||||
file->endline_mode);
|
||||
view->mark = range.start;
|
||||
view_measure_wraps(&mem->general, view);
|
||||
view_cursor_move(view, next_cursor_pos);
|
||||
}
|
||||
|
@ -691,9 +591,7 @@ COMMAND_DECL(paste){
|
|||
view_replace_range(mem, view, layout, pos_left, pos_left, (u8*)src->str, src->size, next_cursor_pos);
|
||||
|
||||
view_cursor_move(view, next_cursor_pos);
|
||||
view->mark = pos_universal_fix(pos_left,
|
||||
(u8*)file->buffer.data, file->buffer.size,
|
||||
file->endline_mode);
|
||||
view->mark = pos_left;
|
||||
|
||||
Editing_Layout *layout = command->layout;
|
||||
Panel *panels = layout->panels;
|
||||
|
@ -728,9 +626,7 @@ COMMAND_DECL(paste_next){
|
|||
(u8*)src->str, src->size, next_cursor_pos);
|
||||
|
||||
view_cursor_move(view, next_cursor_pos);
|
||||
view->mark = pos_universal_fix(range.start,
|
||||
(u8*)file->buffer.data, file->buffer.size,
|
||||
file->endline_mode);
|
||||
view->mark = range.start;
|
||||
|
||||
Editing_Layout *layout = command->layout;
|
||||
Panel *panels = layout->panels;
|
||||
|
@ -763,9 +659,7 @@ COMMAND_DECL(delete_chunk){
|
|||
view_replace_range(mem, view, layout, range.start, range.end, 0, 0, next_cursor_pos);
|
||||
view_measure_wraps(&mem->general, view);
|
||||
view_cursor_move(view, next_cursor_pos);
|
||||
view->mark = pos_universal_fix(range.start,
|
||||
(u8*)file->buffer.data, file->buffer.size,
|
||||
file->endline_mode);
|
||||
view->mark = range.start;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -884,8 +778,8 @@ app_open_file(App_Vars *vars, General_Memory *general, Panel *panel,
|
|||
if (!target_file){
|
||||
Get_File_Result file = working_set_get_available_file(working_set);
|
||||
if (file.file){
|
||||
buffer_get_dummy(file.file);
|
||||
created_file = buffer_create(general, file.file, (u8*)string->str, style->font);
|
||||
file_get_dummy(file.file);
|
||||
created_file = file_create(general, file.file, (u8*)string->str, style->font);
|
||||
table_add(&working_set->table, file.file->source_path, file.index);
|
||||
if (created_file){
|
||||
target_file = file.file;
|
||||
|
@ -919,7 +813,7 @@ app_open_file(App_Vars *vars, General_Memory *general, Panel *panel,
|
|||
new_view->map = app_get_map(vars, target_file->base_map_id);
|
||||
|
||||
if (created_file && target_file->tokens_exist)
|
||||
buffer_first_lex_parallel(general, target_file);
|
||||
file_first_lex_parallel(general, target_file);
|
||||
}
|
||||
|
||||
return result;
|
||||
|
@ -987,13 +881,13 @@ COMMAND_DECL(reopen){
|
|||
USE_VARS(vars);
|
||||
|
||||
Editing_File temp_file;
|
||||
if (buffer_create(&mem->general, &temp_file, (u8*)make_c_str(file->source_path), style->font)){
|
||||
buffer_close(&mem->general, file);
|
||||
if (file_create(&mem->general, &temp_file, (u8*)make_c_str(file->source_path), style->font)){
|
||||
file_close(&mem->general, file);
|
||||
*file = temp_file;
|
||||
file->source_path.str = file->source_path_;
|
||||
file->live_name.str = file->live_name_;
|
||||
if (file->tokens_exist)
|
||||
buffer_first_lex_parallel(&mem->general, file);
|
||||
file_first_lex_parallel(&mem->general, file);
|
||||
|
||||
Partition old_part = command->part;
|
||||
Temp_Memory temp = begin_temp_memory(&vars->mem.part);
|
||||
|
@ -1022,10 +916,11 @@ COMMAND_DECL(save){
|
|||
ProfileMomentFunction();
|
||||
REQ_FILE_VIEW(view);
|
||||
REQ_FILE(file, view);
|
||||
USE_MEM(mem);
|
||||
|
||||
String *file_path = &file->source_path;
|
||||
if (file_path->size > 0){
|
||||
file_save(file, (u8*)file_path->str);
|
||||
file_save(&mem->part, file, (u8*)file_path->str);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1139,29 +1034,10 @@ COMMAND_DECL(toggle_endline_mode){
|
|||
REQ_FILE_VIEW(view);
|
||||
REQ_FILE(file, view);
|
||||
USE_MEM(mem);
|
||||
|
||||
switch (file->endline_mode){
|
||||
case EOL_USE_CRLF:
|
||||
{
|
||||
file->endline_mode = EOL_USE_CR_USE_LF;
|
||||
}break;
|
||||
|
||||
case EOL_USE_CR_USE_LF:
|
||||
{
|
||||
file->endline_mode = EOL_SHOW_CR_USE_LF;
|
||||
}break;
|
||||
|
||||
case EOL_SHOW_CR_USE_LF:
|
||||
{
|
||||
view->cursor.pos = pos_adjust_to_self(view->cursor.pos, (u8*)view->file->buffer.data,
|
||||
view->file->buffer.size);
|
||||
file->endline_mode = EOL_USE_CRLF;
|
||||
}break;
|
||||
}
|
||||
|
||||
|
||||
file_measure_starts(&mem->general, view->file);
|
||||
view->cursor =
|
||||
view_compute_cursor_from_pos(view, view->cursor.pos);
|
||||
file_measure_starts(&mem->general, view->file);
|
||||
}
|
||||
|
||||
COMMAND_DECL(toggle_show_whitespace){
|
||||
|
@ -1177,10 +1053,10 @@ COMMAND_DECL(toggle_tokens){
|
|||
USE_MEM(mem);
|
||||
|
||||
if (file->tokens_exist){
|
||||
buffer_kill_tokens(&mem->general, file);
|
||||
file_kill_tokens(&mem->general, file);
|
||||
}
|
||||
else{
|
||||
buffer_first_lex_parallel(&mem->general, file);
|
||||
file_first_lex_parallel(&mem->general, file);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1212,7 +1088,7 @@ COMMAND_DECL(to_uppercase){
|
|||
}
|
||||
|
||||
if (file->token_stack.tokens){
|
||||
buffer_relex_parallel(mem, file, range.start, range.end, 0);
|
||||
file_relex_parallel(mem, file, range.start, range.end, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1245,98 +1121,22 @@ COMMAND_DECL(to_lowercase){
|
|||
}
|
||||
|
||||
if (file->token_stack.tokens){
|
||||
buffer_relex_parallel(mem, file, range.start, range.end, 0);
|
||||
file_relex_parallel(mem, file, range.start, range.end, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
internal void
|
||||
view_clean_line(Mem_Options *mem, File_View *view, Editing_File *file, i32 line_start){
|
||||
u8 *data = file->data;
|
||||
|
||||
i32 pos = line_start;
|
||||
i32 current_x_bumps = 0;
|
||||
i32 first_hard = -1;
|
||||
while (pos < file->size && data[pos] != '\n'){
|
||||
if (!char_is_whitespace(data[pos])){
|
||||
first_hard = pos;
|
||||
break;
|
||||
}
|
||||
else{
|
||||
switch (data[pos]){
|
||||
case ' ': current_x_bumps += 1; break;
|
||||
case '\t': current_x_bumps += 4; break;
|
||||
}
|
||||
}
|
||||
++pos;
|
||||
}
|
||||
|
||||
Indent_Definition indent = indent_by_width(current_x_bumps, 4);
|
||||
buffer_set_indent_whitespace(mem, file, indent,
|
||||
(u8*)partition_current(&mem->part), line_start);
|
||||
|
||||
pos = line_start;
|
||||
i32 last_hard_start = pos-1;
|
||||
i32 last_hard = last_hard_start;
|
||||
while (pos < file->size && data[pos] != '\n'){
|
||||
if (!char_is_whitespace(data[pos])){
|
||||
last_hard = pos;
|
||||
}
|
||||
++pos;
|
||||
}
|
||||
|
||||
if (last_hard != last_hard_start){
|
||||
pos = pos_adjust_to_left(pos, data);
|
||||
|
||||
if (last_hard + 1 < pos){
|
||||
buffer_replace_range(mem, file, last_hard+1, pos, 0, 0, REP_WHITESPACE);
|
||||
|
||||
if (view->cursor.pos > last_hard){
|
||||
view->cursor = view_compute_cursor_from_pos(view, last_hard + 1);
|
||||
}
|
||||
if (view->mark > last_hard && view->mark <= pos){
|
||||
view->mark = pos_adjust_to_self(last_hard+1, file->data, file->size);
|
||||
}
|
||||
else if (view->mark > pos){
|
||||
view->mark -= pos - (last_hard + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
else{
|
||||
view_auto_tab(mem, view, pos, pos);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
COMMAND_DECL(clean_line){
|
||||
#if 0
|
||||
ProfileMomentFunction();
|
||||
REQ_FILE_VIEW(view);
|
||||
REQ_FILE(file, view);
|
||||
USE_MEM(mem);
|
||||
|
||||
i32 line_start = view_find_beginning_of_line(view, view->cursor.pos);
|
||||
view_clean_line(mem, view, file, line_start);
|
||||
view_measure_wraps(&mem->general, view);
|
||||
#endif
|
||||
}
|
||||
|
||||
COMMAND_DECL(clean_all_lines){
|
||||
#if 0
|
||||
ProfileMomentFunction();
|
||||
REQ_FILE_VIEW(view);
|
||||
REQ_FILE(file, view);
|
||||
USE_LAYOUT(layout);
|
||||
USE_MEM(mem);
|
||||
|
||||
for (i32 i = 0; i < file->line_count; ++i){
|
||||
i32 line_start = file->line_starts[i];
|
||||
view_clean_line(mem, view, file, line_start);
|
||||
}
|
||||
view_clean_whitespace(mem, view, layout);
|
||||
|
||||
view_measure_wraps(&mem->general, view);
|
||||
view->cursor = view_compute_cursor_from_pos(view, view->cursor.pos);
|
||||
#endif
|
||||
}
|
||||
|
||||
COMMAND_DECL(eol_dosify){
|
||||
|
@ -1502,13 +1302,9 @@ COMMAND_DECL(move_left){
|
|||
REQ_FILE_VIEW(view);
|
||||
REQ_FILE(file, view);
|
||||
|
||||
u8 *data = (u8*)file->buffer.data;
|
||||
i32 pos = view->cursor.pos;
|
||||
if (pos > 0){
|
||||
--pos;
|
||||
if (file->endline_mode == EOL_USE_CRLF){
|
||||
pos = pos_adjust_to_self(pos, data, file->buffer.size);
|
||||
}
|
||||
}
|
||||
|
||||
view_cursor_move(view, pos);
|
||||
|
@ -1520,16 +1316,9 @@ COMMAND_DECL(move_right){
|
|||
REQ_FILE(file, view);
|
||||
|
||||
i32 size = file->buffer.size;
|
||||
u8* data = (u8*)file->buffer.data;
|
||||
i32 pos = view->cursor.pos;
|
||||
if (pos < size){
|
||||
if (file->endline_mode == EOL_USE_CRLF){
|
||||
pos = pos_adjust_to_right(pos, data, size);
|
||||
++pos;
|
||||
}
|
||||
else{
|
||||
++pos;
|
||||
}
|
||||
++pos;
|
||||
}
|
||||
|
||||
view_cursor_move(view, pos);
|
||||
|
@ -1543,17 +1332,10 @@ COMMAND_DECL(delete){
|
|||
USE_MEM(mem);
|
||||
|
||||
i32 cursor_pos = view->cursor.pos;
|
||||
u8 *data = (u8*)file->buffer.data;
|
||||
if (file->buffer.size > 0 && cursor_pos < file->buffer.size){
|
||||
i32 start, end;
|
||||
start = cursor_pos;
|
||||
if (file->endline_mode == EOL_USE_CRLF &&
|
||||
data[cursor_pos] == '\r' && data[cursor_pos+1] == '\n'){
|
||||
end = cursor_pos+2;
|
||||
}
|
||||
else{
|
||||
end = cursor_pos+1;
|
||||
}
|
||||
end = cursor_pos+1;
|
||||
|
||||
i32 shift = (end - start);
|
||||
Assert(shift > 0);
|
||||
|
@ -1573,20 +1355,11 @@ COMMAND_DECL(backspace){
|
|||
USE_MEM(mem);
|
||||
|
||||
i32 cursor_pos = view->cursor.pos;
|
||||
u8 *data = (u8*)file->buffer.data;
|
||||
if (cursor_pos > 0 && cursor_pos <= (i32)file->buffer.size){
|
||||
i32 start, end;
|
||||
end = cursor_pos;
|
||||
|
||||
if (file->endline_mode == EOL_USE_CRLF &&
|
||||
cursor_pos > 1 &&
|
||||
data[cursor_pos-1] == '\n' &&
|
||||
data[cursor_pos-2] == '\r'){
|
||||
start = cursor_pos-2;
|
||||
}
|
||||
else{
|
||||
start = cursor_pos-1;
|
||||
}
|
||||
start = cursor_pos-1;
|
||||
|
||||
i32 shift = (end - start);
|
||||
Assert(shift > 0);
|
||||
|
@ -1796,10 +1569,10 @@ COMMAND_DECL(set_settings){
|
|||
{
|
||||
int v = dynamic_to_bool(¶m->param.value);
|
||||
if (file->tokens_exist){
|
||||
if (!v) buffer_kill_tokens(&mem->general, file);
|
||||
if (!v) file_kill_tokens(&mem->general, file);
|
||||
}
|
||||
else{
|
||||
if (v) buffer_first_lex_parallel(&mem->general, file);
|
||||
if (v) file_first_lex_parallel(&mem->general, file);
|
||||
}
|
||||
}break;
|
||||
|
||||
|
@ -1839,9 +1612,6 @@ COMMAND_DECL(set_settings){
|
|||
else map = 0;
|
||||
}
|
||||
}break;
|
||||
|
||||
case par_end_line_mode:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1920,7 +1690,6 @@ extern "C"{
|
|||
buffer.file_name = file->source_path.str;
|
||||
buffer.buffer_name = file->live_name.str;
|
||||
buffer.file_cursor_pos = file->cursor_pos;
|
||||
buffer.eol_mode = file->endline_mode;
|
||||
buffer.is_lexed = file->tokens_exist;
|
||||
buffer.map_id = file->base_map_id;
|
||||
}
|
||||
|
@ -2007,7 +1776,6 @@ setup_file_commands(Command_Map *commands, Partition *part, Key_Codes *codes, Co
|
|||
map_add(commands, '|', MDFR_CTRL, command_toggle_tokens);
|
||||
map_add(commands, 'u', MDFR_CTRL, command_to_uppercase);
|
||||
map_add(commands, 'j', MDFR_CTRL, command_to_lowercase);
|
||||
map_add(commands, '`', MDFR_CTRL, command_clean_line);
|
||||
map_add(commands, '~', MDFR_CTRL, command_clean_all_lines);
|
||||
map_add(commands, '1', MDFR_CTRL, command_eol_dosify);
|
||||
map_add(commands, '!', MDFR_CTRL, command_eol_nixify);
|
||||
|
@ -2109,7 +1877,6 @@ setup_command_table(){
|
|||
SET(to_uppercase);
|
||||
SET(to_lowercase);
|
||||
SET(toggle_show_whitespace);
|
||||
SET(clean_line);
|
||||
SET(clean_all_lines);
|
||||
SET(eol_dosify);
|
||||
SET(eol_nixify);
|
||||
|
@ -2494,7 +2261,6 @@ HOOK_SIG(default_open_file_hook){
|
|||
app.push_parameter(cmd_context, dynamic_int(par_lex_as_cpp_file), dynamic_int(treat_as_code));
|
||||
app.push_parameter(cmd_context, dynamic_int(par_wrap_lines), dynamic_int(!treat_as_code));
|
||||
app.push_parameter(cmd_context, dynamic_int(par_key_mapid), dynamic_int(mapid_file));
|
||||
app.push_parameter(cmd_context, dynamic_int(par_end_line_mode), dynamic_int(EOL_USE_CRLF));
|
||||
|
||||
app.exec_command_keep_stack(cmd_context, cmdid_set_settings);
|
||||
app.clear_parameters(cmd_context);
|
||||
|
@ -2756,7 +2522,7 @@ app_init(Thread_Context *thread, Application_Memory *memory,
|
|||
vars->working_set.files =
|
||||
push_array(partition, Editing_File, vars->working_set.file_max_count);
|
||||
|
||||
buffer_get_dummy(&vars->working_set.files[0]);
|
||||
file_get_dummy(&vars->working_set.files[0]);
|
||||
|
||||
vars->working_set.table.max = vars->working_set.file_max_count * 3 / 2;
|
||||
vars->working_set.table.count = 0;
|
||||
|
@ -3250,7 +3016,7 @@ app_step(Thread_Context *thread, Key_Codes *codes,
|
|||
if (fview){
|
||||
Editing_File *file = fview->file;
|
||||
if (file && !file->is_dummy){
|
||||
file_save_and_set_names(file, (u8*)string->str);
|
||||
file_save_and_set_names(&vars->mem.part, file, (u8*)string->str);
|
||||
}
|
||||
}
|
||||
}break;
|
||||
|
@ -3259,14 +3025,14 @@ app_step(Thread_Context *thread, Key_Codes *codes,
|
|||
{
|
||||
Editing_File *file = working_set_lookup_file(working_set, *string);
|
||||
if (file && !file->is_dummy){
|
||||
file_save(file, (u8*)file->source_path.str);
|
||||
file_save(&vars->mem.part, file, (u8*)file->source_path.str);
|
||||
}
|
||||
}break;
|
||||
|
||||
case DACT_NEW:
|
||||
{
|
||||
Get_File_Result file = working_set_get_available_file(working_set);
|
||||
buffer_create_empty(general, file.file, (u8*)string->str, style->font);
|
||||
file_create_empty(general, file.file, (u8*)string->str, style->font);
|
||||
table_add(&working_set->table, file.file->source_path, file.index);
|
||||
|
||||
View *new_view = live_set_alloc_view(live_set, mem);
|
||||
|
@ -3277,7 +3043,7 @@ app_step(Thread_Context *thread, Key_Codes *codes,
|
|||
view_set_file(file_view, file.file, style,
|
||||
vars->hooks[hook_open_file], &command_data, app_links);
|
||||
new_view->map = app_get_map(vars, file.file->base_map_id);
|
||||
if (file.file->tokens_exist) buffer_first_lex_parallel(general, file.file);
|
||||
if (file.file->tokens_exist) file_first_lex_parallel(general, file.file);
|
||||
}break;
|
||||
|
||||
case DACT_SWITCH:
|
||||
|
@ -3391,7 +3157,7 @@ app_step(Thread_Context *thread, Key_Codes *codes,
|
|||
Editing_File *file = vars->working_set.files;
|
||||
for (i32 i = vars->working_set.file_index_count; i > 0; --i, ++file){
|
||||
if (file->buffer.data && !file->is_dummy){
|
||||
buffer_measure_widths(&vars->mem.general, file, vars->style.font);
|
||||
file_measure_widths(&vars->mem.general, file, vars->style.font);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
1149
4ed_file_view.cpp
1149
4ed_file_view.cpp
File diff suppressed because it is too large
Load Diff
|
@ -84,6 +84,8 @@ _OutDbgStr(u8*);
|
|||
|
||||
#define AllowLocal(name) (void)name
|
||||
#define ArrayCount(array) (sizeof(array)/sizeof(array[0]))
|
||||
#define OffsetOfStruct(S,c) ((i64)(& ((S*)0)->c ))
|
||||
#define OffsetOfPtr(s,c) ((i64)((char*)(&(s)->c) - (char*)(s)))
|
||||
|
||||
#define Swap(a,b) {auto t = a; a = b; b = t;}
|
||||
|
||||
|
|
|
@ -2,6 +2,8 @@
|
|||
* Mr. 4th Dimention - Allen Webster
|
||||
* Four Tech
|
||||
*
|
||||
* public domain -- no warranty is offered or implied; use this code at your own risk
|
||||
*
|
||||
* 16.10.2015
|
||||
*
|
||||
* Buffer data object
|
||||
|
@ -9,61 +11,92 @@
|
|||
*
|
||||
*/
|
||||
|
||||
// TOP
|
||||
|
||||
#ifndef defines_4tech
|
||||
#define inline_4tech inline
|
||||
#define internal_4tech static
|
||||
#define memset_4tech memset
|
||||
#define memcpy_4tech memcpy
|
||||
#define memmove_4tech memmove
|
||||
#define defines_4tech 1
|
||||
#define debug_4tech(x) x
|
||||
#endif
|
||||
|
||||
#ifndef Assert
|
||||
#define Assert
|
||||
#endif
|
||||
|
||||
typedef struct{
|
||||
char *data;
|
||||
int size, max;
|
||||
|
||||
float *line_widths;
|
||||
int *line_starts;
|
||||
int line_count;
|
||||
int line_max;
|
||||
int widths_max;
|
||||
} Buffer;
|
||||
|
||||
typedef struct{
|
||||
Buffer *buffer;
|
||||
char *data;
|
||||
int size;
|
||||
} Buffer_Save_Loop;
|
||||
} Buffer_Stringify_Loop;
|
||||
|
||||
inline_4tech Buffer_Save_Loop
|
||||
buffer_save_loop(Buffer *buffer){
|
||||
Buffer_Save_Loop result;
|
||||
result.buffer = buffer;
|
||||
result.data = buffer->data;
|
||||
result.size = buffer->size;
|
||||
inline_4tech Buffer_Stringify_Loop
|
||||
buffer_stringify_loop(Buffer *buffer, int start, int end){
|
||||
Buffer_Stringify_Loop result;
|
||||
if (0 <= start && start <= end && end < buffer->size){
|
||||
result.buffer = buffer;
|
||||
result.data = buffer->data + start;
|
||||
result.size = end - start;
|
||||
}
|
||||
else result.buffer = 0;
|
||||
return(result);
|
||||
}
|
||||
|
||||
inline_4tech int
|
||||
buffer_save_good(Buffer_Save_Loop *loop){
|
||||
buffer_stringify_good(Buffer_Stringify_Loop *loop){
|
||||
int result;
|
||||
result = (loop->buffer != 0);
|
||||
return(result);
|
||||
}
|
||||
|
||||
inline_4tech void
|
||||
buffer_save_next(Buffer_Save_Loop *loop){
|
||||
buffer_stringify_next(Buffer_Stringify_Loop *loop){
|
||||
loop->buffer = 0;
|
||||
}
|
||||
|
||||
inline_4tech void
|
||||
buffer_stringify(Buffer *buffer, int start, int end, char *out){
|
||||
for (Buffer_Stringify_Loop loop = buffer_stringify_loop(buffer, start, end);
|
||||
buffer_stringify_good(&loop);
|
||||
buffer_stringify_next(&loop)){
|
||||
memcpy_4tech(out, loop.data, loop.size);
|
||||
out += loop.size;
|
||||
}
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_count_newlines(Buffer *buffer, int start, int end, int CR, int LF){
|
||||
buffer_count_newlines(Buffer *buffer, int start, int end){
|
||||
int new_line, count;
|
||||
char *data;
|
||||
int i;
|
||||
|
||||
Assert(0 <= start);
|
||||
Assert(start <= end);
|
||||
Assert(end < buffer->size);
|
||||
|
||||
data = buffer->data;
|
||||
new_line = 0;
|
||||
count = 0;
|
||||
|
||||
for (i = start; i < end; ++i){
|
||||
switch(data[i]){
|
||||
case '\n': new_line = LF; break;
|
||||
case '\r': new_line = CR; break;
|
||||
default: new_line = 0; break;
|
||||
}
|
||||
new_line = (data[i] == '\n');
|
||||
count += new_line;
|
||||
}
|
||||
|
||||
return (count);
|
||||
return(count);
|
||||
}
|
||||
|
||||
typedef struct{
|
||||
|
@ -73,27 +106,28 @@ typedef struct{
|
|||
} Buffer_Measure_Starts;
|
||||
|
||||
internal_4tech int
|
||||
buffer_measure_starts_(Buffer_Measure_Starts *state, Buffer *buffer, int *starts, int max, int CR, int LF){
|
||||
buffer_measure_starts(Buffer_Measure_Starts *state, Buffer *buffer){
|
||||
int *starts;
|
||||
int max;
|
||||
char *data;
|
||||
int size;
|
||||
int start, count, i, new_line;
|
||||
int start, count, i;
|
||||
int result;
|
||||
|
||||
starts = buffer->line_starts;
|
||||
max = buffer->line_max;
|
||||
|
||||
data = buffer->data;
|
||||
size = buffer->size;
|
||||
|
||||
result = 0;
|
||||
start = state->start;
|
||||
count = state->count;
|
||||
|
||||
for (i = state->i; i < size; ++i){
|
||||
switch (data[i]){
|
||||
case '\n': new_line = LF; break;
|
||||
case '\r': new_line = CR; break;
|
||||
default: new_line = 0; break;
|
||||
}
|
||||
|
||||
if (new_line){
|
||||
i = state->i;
|
||||
count = state->count;
|
||||
start = state->start;
|
||||
|
||||
for (; i < size; ++i){
|
||||
if (data[i] == '\n'){
|
||||
if (count == max){
|
||||
result = 1;
|
||||
break;
|
||||
|
@ -113,6 +147,632 @@ buffer_measure_starts_(Buffer_Measure_Starts *state, Buffer *buffer, int *starts
|
|||
state->count = count;
|
||||
state->start = start;
|
||||
|
||||
return (result);
|
||||
return(result);
|
||||
}
|
||||
|
||||
inline_4tech float
|
||||
measure_character(void *advance_data, int offset, int stride, int *new_line, char character){
|
||||
char *advances;
|
||||
float width;
|
||||
|
||||
advances = (char*)advance_data + offset;
|
||||
switch (character){
|
||||
case 0: width = 0; *new_line = 1; break;
|
||||
case '\n': width = *(float*)(advances + stride * '\n'); *new_line = 1; break;
|
||||
case '\r': width = *(float*)(advances + stride * '\\') + *(float*)(advances + stride * '\r'); break;
|
||||
default: width = *(float*)(advances + stride * character);
|
||||
}
|
||||
|
||||
return(width);
|
||||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_measure_widths(Buffer *buffer, void *advance_data, int offset, int stride){
|
||||
float *widths;
|
||||
debug_4tech(int *starts);
|
||||
int line_count;
|
||||
char *data;
|
||||
int size;
|
||||
int i, j, new_line;
|
||||
float width;
|
||||
char ch, next;
|
||||
|
||||
Assert(buffer->widths_max >= buffer->line_count);
|
||||
|
||||
widths = buffer->line_widths;
|
||||
debug_4tech(starts = buffer->line_starts);
|
||||
line_count = buffer->line_count;
|
||||
|
||||
data = buffer->data;
|
||||
size = buffer->size;
|
||||
|
||||
Assert(size < buffer->max);
|
||||
data[size] = 0;
|
||||
|
||||
for (i = 0, j = 0; i < line_count; ++i){
|
||||
Assert(j == starts[i]);
|
||||
new_line = 0;
|
||||
width = 0;
|
||||
ch = data[j];
|
||||
next = data[++j];
|
||||
|
||||
while (new_line == 0){
|
||||
width += measure_character(advance_data, offset, stride, &new_line, ch);
|
||||
ch = next;
|
||||
next = data[++j];
|
||||
}
|
||||
|
||||
--j;
|
||||
widths[i] = width;
|
||||
}
|
||||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_remeasure_starts(Buffer *buffer, int line_start, int line_end, int line_shift, int text_shift){
|
||||
int *lines;
|
||||
int line_count;
|
||||
char *data;
|
||||
int size;
|
||||
int line_i, char_i, start;
|
||||
char character;
|
||||
|
||||
lines = buffer->line_starts;
|
||||
line_count = buffer->line_count;
|
||||
|
||||
if (line_shift != 0){
|
||||
memmove_4tech(lines + line_end + line_shift + 1, lines + line_end + 1,
|
||||
sizeof(int)*(line_count - line_end - 1));
|
||||
line_count += line_shift;
|
||||
}
|
||||
|
||||
if (text_shift != 0){
|
||||
line_i = line_end + 1;
|
||||
lines = lines + line_i;
|
||||
for (; line_i < line_count; ++line_i, ++lines){
|
||||
*lines += text_shift;
|
||||
}
|
||||
lines = buffer->line_starts;
|
||||
}
|
||||
|
||||
size = buffer->size;
|
||||
data = buffer->data;
|
||||
char_i = lines[line_start];
|
||||
line_i = line_start;
|
||||
|
||||
Assert(size < buffer->max);
|
||||
data[size] = '\n';
|
||||
|
||||
start = char_i;
|
||||
for (; char_i <= size; ++char_i){
|
||||
character = data[char_i];
|
||||
if (character == '\n'){
|
||||
if (line_i > line_end && start == lines[line_i]) break;
|
||||
lines[line_i++] = start;
|
||||
start = char_i + 1;
|
||||
}
|
||||
}
|
||||
|
||||
buffer->line_count = line_count;
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_get_line_index(Buffer *buffer, int pos, int l_bound, int u_bound){
|
||||
int *lines;
|
||||
int start, end;
|
||||
int i;
|
||||
|
||||
Assert(0 <= l_bound);
|
||||
Assert(l_bound <= u_bound);
|
||||
Assert(u_bound <= buffer->line_count);
|
||||
|
||||
start = l_bound;
|
||||
end = u_bound;
|
||||
lines = buffer->line_starts;
|
||||
for (;;){
|
||||
i = (start + end) >> 1;
|
||||
if (lines[i] < pos) start = i;
|
||||
else if (lines[i] > pos) end = i;
|
||||
else{
|
||||
start = i;
|
||||
break;
|
||||
}
|
||||
Assert(start < end);
|
||||
if (start == end - 1) break;
|
||||
}
|
||||
|
||||
return(start);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_replace_range(Buffer *buffer, int start, int end, char *str, int len, int *shift_amount){
|
||||
char *data;
|
||||
int result;
|
||||
|
||||
*shift_amount = (len - (end - start));
|
||||
if (*shift_amount + buffer->size + 1 <= buffer->max){
|
||||
data = (char*)buffer->data;
|
||||
memmove_4tech(data + end + *shift_amount, data + end, buffer->size - end);
|
||||
buffer->size += *shift_amount;
|
||||
data[buffer->size] = 0;
|
||||
if (len != 0) memcpy_4tech(data + start, str, len);
|
||||
|
||||
result = 0;
|
||||
}
|
||||
else{
|
||||
result = *shift_amount + buffer->size + 1;
|
||||
}
|
||||
|
||||
return(result);
|
||||
}
|
||||
|
||||
typedef struct{
|
||||
int pos, index;
|
||||
} Cursor_With_Index;
|
||||
|
||||
inline_4tech void
|
||||
write_cursor_with_index(Cursor_With_Index *positions, int *count, int pos){
|
||||
positions[*count].index = *count;
|
||||
positions[*count].pos = pos;
|
||||
++*count;
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_quick_partition_cursors(Cursor_With_Index *positions, int start, int pivot){
|
||||
int i;
|
||||
int pivot_pos;
|
||||
pivot_pos = positions[pivot].pos;
|
||||
for (i = start; i < pivot; ++i){
|
||||
if (positions[i].pos < pivot_pos){
|
||||
Swap(positions[start], positions[i]);
|
||||
++start;
|
||||
}
|
||||
}
|
||||
Swap(positions[start], positions[pivot]);
|
||||
return start;
|
||||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_quick_sort_cursors(Cursor_With_Index *positions, int start, int pivot){
|
||||
int mid;
|
||||
mid = buffer_quick_partition_cursors(positions, start, pivot);
|
||||
if (start < mid - 1) buffer_quick_sort_cursors(positions, start, mid - 1);
|
||||
if (mid + 1 < pivot) buffer_quick_sort_cursors(positions, mid + 1, pivot);
|
||||
}
|
||||
|
||||
inline_4tech void
|
||||
buffer_sort_cursors(Cursor_With_Index *positions, int count){
|
||||
Assert(count > 0);
|
||||
buffer_quick_sort_cursors(positions, 0, count-1);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_quick_unpartition_cursors(Cursor_With_Index *positions, int start, int pivot){
|
||||
int i;
|
||||
int pivot_index;
|
||||
pivot_index = positions[pivot].index;
|
||||
for (i = start; i < pivot; ++i){
|
||||
if (positions[i].index < pivot_index){
|
||||
Swap(positions[start], positions[i]);
|
||||
++start;
|
||||
}
|
||||
}
|
||||
Swap(positions[start], positions[pivot]);
|
||||
return start;
|
||||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_quick_unsort_cursors(Cursor_With_Index *positions, int start, int pivot){
|
||||
int mid;
|
||||
mid = buffer_quick_unpartition_cursors(positions, start, pivot);
|
||||
if (start < mid - 1) buffer_quick_unsort_cursors(positions, start, mid - 1);
|
||||
if (mid + 1 < pivot) buffer_quick_unsort_cursors(positions, mid + 1, pivot);
|
||||
}
|
||||
|
||||
inline_4tech void
|
||||
buffer_unsort_cursors(Cursor_With_Index *positions, int count){
|
||||
Assert(count > 0);
|
||||
buffer_quick_unsort_cursors(positions, 0, count-1);
|
||||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_update_cursors(Cursor_With_Index *sorted_positions, int count, int start, int end, int len){
|
||||
Cursor_With_Index *position, *end_position;
|
||||
int shift_amount;
|
||||
|
||||
shift_amount = (len - (end - start));
|
||||
|
||||
position = sorted_positions;
|
||||
end_position = sorted_positions + count;
|
||||
for (; position < end_position && position->pos < start; ++position);
|
||||
for (; position < end_position && position->pos < end; ++position) position->pos = start;
|
||||
for (; position < end_position; ++position) position->pos += shift_amount;
|
||||
}
|
||||
|
||||
typedef enum{
|
||||
buffer_seek_pos,
|
||||
buffer_seek_wrapped_xy,
|
||||
buffer_seek_unwrapped_xy,
|
||||
buffer_seek_line_char
|
||||
} Buffer_Seek_Type;
|
||||
|
||||
typedef struct{
|
||||
Buffer_Seek_Type type;
|
||||
union{
|
||||
struct { int pos; };
|
||||
struct { int round_down; float x, y; };
|
||||
struct { int line, character; };
|
||||
};
|
||||
} Buffer_Seek;
|
||||
|
||||
inline_4tech Buffer_Seek
|
||||
seek_pos(int pos){
|
||||
Buffer_Seek result;
|
||||
result.type = buffer_seek_pos;
|
||||
result.pos = pos;
|
||||
return(result);
|
||||
}
|
||||
|
||||
inline_4tech Buffer_Seek
|
||||
seek_wrapped_xy(float x, float y, int round_down){
|
||||
Buffer_Seek result;
|
||||
result.type = buffer_seek_wrapped_xy;
|
||||
result.x = x;
|
||||
result.y = y;
|
||||
result.round_down = round_down;
|
||||
return(result);
|
||||
}
|
||||
|
||||
inline_4tech Buffer_Seek
|
||||
seek_unwrapped_xy(float x, float y, int round_down){
|
||||
Buffer_Seek result;
|
||||
result.type = buffer_seek_unwrapped_xy;
|
||||
result.x = x;
|
||||
result.y = y;
|
||||
result.round_down = round_down;
|
||||
return(result);
|
||||
}
|
||||
|
||||
inline_4tech Buffer_Seek
|
||||
seek_line_char(int line, int character){
|
||||
Buffer_Seek result;
|
||||
result.type = buffer_seek_line_char;
|
||||
result.line = line;
|
||||
result.character = character;
|
||||
return(result);
|
||||
}
|
||||
|
||||
typedef struct{
|
||||
int pos;
|
||||
int line, character;
|
||||
float unwrapped_x, unwrapped_y;
|
||||
float wrapped_x, wrapped_y;
|
||||
} Full_Cursor;
|
||||
|
||||
internal_4tech Full_Cursor
|
||||
buffer_cursor_seek(Buffer *buffer, Buffer_Seek seek,
|
||||
float max_width, float font_height, void *width_data, int offset, int stride, Full_Cursor cursor){
|
||||
Full_Cursor prev_cursor;
|
||||
char *data, *data_;
|
||||
int size;
|
||||
int do_newline, do_slashr;
|
||||
char ch, next;
|
||||
float ch_width;
|
||||
|
||||
int get_out;
|
||||
int xy_seek;
|
||||
float x, y, px;
|
||||
|
||||
data = buffer->data;
|
||||
size = buffer->size;
|
||||
Assert(size < buffer->max);
|
||||
data[size] = 0;
|
||||
|
||||
data_ = (char*)width_data + offset;
|
||||
|
||||
xy_seek = (seek.type == buffer_seek_wrapped_xy || seek.type == buffer_seek_unwrapped_xy);
|
||||
|
||||
for (;;){
|
||||
prev_cursor = cursor;
|
||||
ch_width = 0;
|
||||
ch = data[cursor.pos];
|
||||
next = data[cursor.pos+1];
|
||||
|
||||
switch (ch){
|
||||
case '\r': do_newline = 0; do_slashr = 1; break;
|
||||
case '\n': do_newline = 1; do_slashr = 0; break;
|
||||
|
||||
default:
|
||||
do_newline = 0; do_slashr = 0;
|
||||
++cursor.character;
|
||||
ch_width = *(float*)(data_ + stride * ch);
|
||||
break;
|
||||
}
|
||||
|
||||
if (do_slashr){
|
||||
++cursor.character;
|
||||
ch_width = *(float*)(data_ + stride * '\\') + *(float*)(data_ + stride * 'r');
|
||||
}
|
||||
|
||||
if (cursor.wrapped_x + ch_width >= max_width){
|
||||
cursor.wrapped_y += font_height;
|
||||
cursor.wrapped_x = 0;
|
||||
prev_cursor = cursor;
|
||||
}
|
||||
|
||||
cursor.unwrapped_x += ch_width;
|
||||
cursor.wrapped_x += ch_width;
|
||||
|
||||
if (do_newline){
|
||||
++cursor.line;
|
||||
cursor.unwrapped_y += font_height;
|
||||
cursor.wrapped_y += font_height;
|
||||
cursor.character = 0;
|
||||
cursor.unwrapped_x = 0;
|
||||
cursor.wrapped_x = 0;
|
||||
}
|
||||
|
||||
++cursor.pos;
|
||||
|
||||
if (cursor.pos > size){
|
||||
cursor = prev_cursor;
|
||||
break;
|
||||
}
|
||||
|
||||
get_out = 0;
|
||||
x = 0;
|
||||
y = 0;
|
||||
px = 0;
|
||||
|
||||
switch (seek.type){
|
||||
case buffer_seek_pos:
|
||||
if (cursor.pos > seek.pos){
|
||||
cursor = prev_cursor;
|
||||
get_out = 1;
|
||||
}break;
|
||||
|
||||
case buffer_seek_wrapped_xy:
|
||||
x = cursor.wrapped_x; px = prev_cursor.wrapped_x;
|
||||
y = cursor.wrapped_y; break;
|
||||
|
||||
case buffer_seek_unwrapped_xy:
|
||||
x = cursor.unwrapped_x; px = prev_cursor.unwrapped_x;
|
||||
y = cursor.unwrapped_y; break;
|
||||
|
||||
case buffer_seek_line_char:
|
||||
if (cursor.line == seek.line && cursor.character >= seek.character){
|
||||
get_out = 1;
|
||||
}
|
||||
else if (cursor.line > seek.line){
|
||||
cursor = prev_cursor;
|
||||
get_out = 1;
|
||||
}break;
|
||||
}
|
||||
|
||||
if (get_out) break;
|
||||
if (xy_seek){
|
||||
if (y > seek.y){
|
||||
cursor = prev_cursor;
|
||||
break;
|
||||
}
|
||||
|
||||
if (seek.round_down){
|
||||
if (y > seek.y - font_height && x > seek.x){
|
||||
cursor = prev_cursor;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else{
|
||||
if (y > seek.y - font_height && x >= seek.x){
|
||||
if ((seek.x - px) < (x - seek.x)) cursor = prev_cursor;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return(cursor);
|
||||
}
|
||||
|
||||
typedef struct{
|
||||
char *str;
|
||||
int len;
|
||||
int start, end;
|
||||
} Buffer_Edit;
|
||||
|
||||
internal_4tech int
|
||||
buffer_batch_debug_sort_check(Buffer_Edit *sorted_edits, int edit_count){
|
||||
Buffer_Edit *edit;
|
||||
int i, result, start_point;
|
||||
|
||||
result = 1;
|
||||
start_point = 0;
|
||||
|
||||
edit = sorted_edits;
|
||||
for (i = 0; i < edit_count; ++i, ++edit){
|
||||
if (start_point > edit->start){
|
||||
result = 0; break;
|
||||
}
|
||||
start_point = Max(edit->end, edit->start + 1);
|
||||
}
|
||||
|
||||
return(result);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_batch_edit_max_shift(Buffer_Edit *sorted_edits, int edit_count){
|
||||
Buffer_Edit *edit;
|
||||
int i, result;
|
||||
int shift_total, shift_max;
|
||||
|
||||
result = 0;
|
||||
shift_total = 0;
|
||||
shift_max = 0;
|
||||
|
||||
edit = sorted_edits;
|
||||
for (i = 0; i < edit_count; ++i, ++edit){
|
||||
shift_total += (edit->len - (edit->end - edit->start));
|
||||
if (shift_total > shift_max) shift_max = shift_total;
|
||||
}
|
||||
|
||||
return shift_max;
|
||||
}
|
||||
|
||||
typedef struct{
|
||||
int i;
|
||||
int shift_total;
|
||||
} Buffer_Batch_State;
|
||||
|
||||
internal_4tech int
|
||||
buffer_batch_edit_step(Buffer_Batch_State *state, Buffer *buffer, Buffer_Edit *sorted_edits, int edit_count){
|
||||
Buffer_Edit *edit;
|
||||
int i, result;
|
||||
int shift_total, shift_amount;
|
||||
|
||||
result = 0;
|
||||
shift_total = state->shift_total;
|
||||
i = state->i;
|
||||
|
||||
edit = sorted_edits + i;
|
||||
for (; i < edit_count; ++i, ++edit){
|
||||
result = buffer_replace_range(buffer, edit->start + shift_total, edit->end + shift_total,
|
||||
edit->str, edit->len, &shift_amount);
|
||||
if (result) break;
|
||||
shift_total += shift_amount;
|
||||
}
|
||||
|
||||
state->shift_total = shift_total;
|
||||
state->i = i;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_batch_edit(Buffer *buffer, Buffer_Edit *sorted_edits, int edit_count){
|
||||
Buffer_Batch_State state;
|
||||
int result;
|
||||
|
||||
state.i = 0;
|
||||
state.shift_total = 0;
|
||||
|
||||
result = buffer_batch_edit_step(&state, buffer, sorted_edits, edit_count);
|
||||
Assert(result == 0);
|
||||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_batch_edit_update_cursors(Cursor_With_Index *sorted_positions, int count, Buffer_Edit *sorted_edits, int edit_count){
|
||||
Cursor_With_Index *position, *end_position;
|
||||
Buffer_Edit *edit, *end_edit;
|
||||
int start, end;
|
||||
int shift_amount;
|
||||
|
||||
position = sorted_positions;
|
||||
end_position = sorted_positions + count;
|
||||
|
||||
edit = sorted_edits;
|
||||
end_edit = sorted_edits + edit_count;
|
||||
|
||||
shift_amount = 0;
|
||||
|
||||
for (; edit < end_edit && position < end_position; ++edit){
|
||||
start = edit->start;
|
||||
end = edit->end;
|
||||
|
||||
for (; position->pos < start && position < end_position; ++position){
|
||||
position->pos += shift_amount;
|
||||
}
|
||||
|
||||
for (; position->pos < end && position < end_position; ++position){
|
||||
position->pos = start + shift_amount;
|
||||
}
|
||||
|
||||
shift_amount += (edit->len - (end - start));
|
||||
}
|
||||
|
||||
for (; position < end_position; ++position){
|
||||
position->pos += shift_amount;
|
||||
}
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_find_hard_start(Buffer *buffer, int line_start, int *all_whitespace, int *all_space,
|
||||
int *preferred_indent, int tab_width){
|
||||
char *data;
|
||||
int size;
|
||||
int result;
|
||||
char c;
|
||||
|
||||
*all_space = 0;
|
||||
*preferred_indent = 0;
|
||||
|
||||
data = buffer->data;
|
||||
size = buffer->size;
|
||||
|
||||
tab_width -= 1;
|
||||
|
||||
for (result = line_start; result < size; ++result){
|
||||
c = data[result];
|
||||
if (c == '\n' || c == 0){
|
||||
*all_whitespace = 1;
|
||||
break;
|
||||
}
|
||||
if (c >= '!' && c <= '~') break;
|
||||
if (c == '\t') *preferred_indent += tab_width;
|
||||
if (c != ' ') *all_space = 0;
|
||||
*preferred_indent += 1;
|
||||
}
|
||||
|
||||
return(result);
|
||||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_eol_convert_in(Buffer *buffer){
|
||||
char *data;
|
||||
int size;
|
||||
int i;
|
||||
|
||||
data = buffer->data;
|
||||
size = buffer->size;
|
||||
Assert(size < buffer->max);
|
||||
data[size] = 0;
|
||||
|
||||
for (i = 0; i < size; ++i){
|
||||
if (data[i] == '\r' && data[i+1] == '\n'){
|
||||
memmove_4tech(data + i, data + i + 1, size - i);
|
||||
size -= 1;
|
||||
}
|
||||
}
|
||||
|
||||
buffer->size = size;
|
||||
}
|
||||
|
||||
inline_4tech int
|
||||
buffer_eol_convert_out_size(Buffer *buffer){
|
||||
int size;
|
||||
size = buffer->size + buffer->line_count;
|
||||
return(size);
|
||||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_eol_convert_out(Buffer *buffer){
|
||||
char *data;
|
||||
int size;
|
||||
int i;
|
||||
|
||||
data = buffer->data;
|
||||
size = buffer->size;
|
||||
Assert(buffer_eol_convert_out_size(buffer) < buffer->max);
|
||||
data[size] = 0;
|
||||
|
||||
for (i = 0; i < size; ++i){
|
||||
if (data[i] == '\n'){
|
||||
memmove_4tech(data + i, data + i + 1, size - i);
|
||||
data[i] = '\r';
|
||||
++i;
|
||||
}
|
||||
}
|
||||
|
||||
buffer->size = size;
|
||||
}
|
||||
|
||||
// BOTTOM
|
||||
|
||||
|
|
Loading…
Reference in New Issue