870 lines
30 KiB
C++
870 lines
30 KiB
C++
void Command_Replace(View *view, String16 string) {
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
Scratch scratch;
|
|
BeforeEdit(buffer, view->carets);
|
|
MergeCarets(view);
|
|
Array<Edit> edits = {scratch};
|
|
For(view->carets) AddEdit(&edits, it.range, string);
|
|
ApplyEdits(buffer, edits);
|
|
AfterEdit(buffer, &edits, &view->carets);
|
|
}
|
|
|
|
void Command_DuplicateLine(View *view, int direction) {
|
|
Assert(direction == DIR_UP || direction == DIR_DOWN);
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
BeforeEdit(buffer, view->carets);
|
|
For(view->carets) it = MakeCaret(GetFront(it));
|
|
MergeCarets(view);
|
|
|
|
Scratch scratch;
|
|
Array<Edit> edits = {scratch};
|
|
For(view->carets) {
|
|
Int line = PosToLine(*buffer, it.range.min);
|
|
Range range = GetLineRange(*buffer, line);
|
|
String16 string = Copy(scratch, GetString(*buffer, range));
|
|
Int pos = direction == DIR_UP ? range.min : range.max;
|
|
AddEdit(&edits, Rng(pos), string);
|
|
}
|
|
ApplyEdits(buffer, edits);
|
|
AfterEdit(buffer, &edits, &view->carets);
|
|
|
|
For(view->carets) it = MakeCaret(MovePos(*buffer, it.range.min, direction, false));
|
|
}
|
|
|
|
Int FindRangeByPos(Array<Range> &ranges, Int pos) {
|
|
// binary search
|
|
Int low = 0;
|
|
Int high = ranges.len - 1;
|
|
Int result = -1;
|
|
|
|
while (low <= high) {
|
|
Int mid = low + (high - low) / 2;
|
|
Range range = ranges[mid];
|
|
if (pos >= range.min && pos < range.max) {
|
|
result = mid;
|
|
break;
|
|
}
|
|
|
|
if (range.min < pos) {
|
|
low = mid + 1;
|
|
} else {
|
|
high = mid - 1;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
Array<Range> GetSelectedLinesSorted(Allocator allocator, View *view) {
|
|
Scratch scratch(allocator);
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
Array<Caret> caret_copy = TightCopy(scratch, view->carets);
|
|
Array<Caret> temp = TightCopy(scratch, view->carets);
|
|
MergeSort(view->carets.len, caret_copy.data, temp.data);
|
|
|
|
Array<Range> result = {allocator};
|
|
For(caret_copy) {
|
|
Int min_line = PosToLine(*buffer, it.range.min);
|
|
Int max_line = PosToLine(*buffer, it.range.max);
|
|
Range line_range = {min_line, max_line + 1};
|
|
|
|
if (result.len == 0) {
|
|
Add(&result, line_range);
|
|
continue;
|
|
}
|
|
|
|
Range *last = GetLast(result);
|
|
if (AreOverlapping(*last, line_range)) {
|
|
last->max = Max(last->max, line_range.max);
|
|
} else {
|
|
Add(&result, line_range);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void Command_IndentSelectedLines(View *view, bool shift = false) {
|
|
Scratch scratch;
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
|
|
BeforeEdit(buffer, view->carets);
|
|
MergeCarets(view);
|
|
|
|
Array<Range> line_ranges_to_indent = GetSelectedLinesSorted(scratch, view);
|
|
Array<Edit> edits = {scratch};
|
|
For(line_ranges_to_indent) {
|
|
for (Int i = it.min; i < it.max; i += 1) {
|
|
Range pos_range_of_line = GetLineRange(*buffer, i);
|
|
|
|
if (!shift) {
|
|
String16 whitespace_string = {L" ", StyleIndentSize};
|
|
AddEdit(&edits, {pos_range_of_line.min, pos_range_of_line.min}, whitespace_string);
|
|
} else {
|
|
String16 string = GetString(*buffer, pos_range_of_line);
|
|
Int whitespace_len = 0;
|
|
for (Int i = 0; i < StyleIndentSize && i < string.len && string.data[i] == ' '; i += 1) {
|
|
whitespace_len += 1;
|
|
}
|
|
|
|
AddEdit(&edits, {pos_range_of_line.min, pos_range_of_line.min + whitespace_len}, L"");
|
|
}
|
|
}
|
|
}
|
|
|
|
ApplyEdits(buffer, edits);
|
|
AfterEdit(buffer, &edits, &view->carets, !KILL_SELECTION);
|
|
view->update_scroll = false;
|
|
}
|
|
|
|
void Command_TrimTrailingWhitespace(View *view, bool dont_trim_lines_with_cursor) {
|
|
Scratch scratch;
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
|
|
BeforeEdit(buffer, view->carets);
|
|
MergeCarets(view);
|
|
|
|
Array<Range> lines_to_skip_triming = {};
|
|
if (dont_trim_lines_with_cursor) lines_to_skip_triming = GetSelectedLinesSorted(scratch, view);
|
|
|
|
Array<Edit> edits = {scratch};
|
|
for (Int i = 0; i < buffer->line_starts.len; i += 1) {
|
|
Int range_index = FindRangeByPos(lines_to_skip_triming, i);
|
|
if (range_index != -1) continue;
|
|
|
|
Range range = GetLineRangeWithoutNL(*buffer, i);
|
|
Int whitespace_end = range.max;
|
|
for (; whitespace_end > range.min; whitespace_end -= 1) {
|
|
U16 w = buffer->data[whitespace_end - 1];
|
|
bool is_whitespace = w == ' ' || w == '\t' || w == '\v' || w == '\r';
|
|
if (!is_whitespace) break;
|
|
}
|
|
|
|
Range whitespace_range = {whitespace_end, range.max};
|
|
AddEdit(&edits, whitespace_range, L"");
|
|
}
|
|
|
|
ApplyEdits(buffer, edits);
|
|
AfterEdit(buffer, &edits, &view->carets, !KILL_SELECTION);
|
|
view->update_scroll = false;
|
|
}
|
|
|
|
void Command_KillSelectedLines(View *view) {
|
|
Scratch scratch;
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
|
|
BeforeEdit(buffer, view->carets);
|
|
MergeCarets(view);
|
|
|
|
Array<Range> lines = GetSelectedLinesSorted(scratch, view);
|
|
Array<Edit> edits = {scratch};
|
|
For(lines) {
|
|
|
|
Range add_range = GetLineRange(*buffer, it.min);
|
|
for (Int i = it.min + 1; i < it.max; i += 1) {
|
|
Range line_range = GetLineRange(*buffer, i);
|
|
add_range.max = Max(line_range.max, add_range.max);
|
|
}
|
|
AddEdit(&edits, add_range, L"");
|
|
}
|
|
|
|
For(view->carets) {
|
|
Int line = PosToLine(*buffer, it.range.min);
|
|
Range range = GetLineRange(*buffer, line);
|
|
it.range.min = it.range.max = range.min;
|
|
}
|
|
|
|
ApplyEdits(buffer, edits);
|
|
AfterEdit(buffer, &edits, &view->carets, KILL_SELECTION);
|
|
}
|
|
|
|
bool SHIFT_PRESSED = true;
|
|
void Command_MoveCursorsByPageSize(Window *window, int direction, bool shift = false) {
|
|
Assert(direction == DIR_UP || direction == DIR_DOWN);
|
|
View &view = *GetActiveView(window);
|
|
Buffer *buffer = GetBuffer(view.active_buffer);
|
|
|
|
Rect2I visible_cells_rect = GetVisibleCells(window);
|
|
Int y = GetSize(visible_cells_rect).y - 2;
|
|
if (direction == DIR_UP) y = -y;
|
|
|
|
For(view.carets) {
|
|
XY xy = PosToXY(*buffer, GetFront(it));
|
|
if (direction == DIR_DOWN && xy.line == buffer->line_starts.len - 1) {
|
|
Range line_range = GetLineRange(*buffer, xy.line);
|
|
xy.col = line_range.max - line_range.min;
|
|
} else if (direction == DIR_UP && xy.line == 0) {
|
|
xy.col = 0;
|
|
}
|
|
xy.line += y;
|
|
|
|
Int pos = XYToPos(*buffer, xy);
|
|
if (shift) {
|
|
it = ChangeFront(it, pos);
|
|
} else {
|
|
it = MakeCaret(pos);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Command_MoveCursorsToSide(View *view, int direction, bool shift = false) {
|
|
Assert(direction == DIR_LEFT || direction == DIR_RIGHT);
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
|
|
For(view->carets) {
|
|
Int pos = GetFront(it);
|
|
if (direction == DIR_RIGHT) {
|
|
pos = GetLineEnd(buffer, pos);
|
|
} else {
|
|
pos = GetLineStart(buffer, pos);
|
|
}
|
|
|
|
if (shift) {
|
|
it = ChangeFront(it, pos);
|
|
} else {
|
|
it.range.max = it.range.min = pos;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Command_Move(View *view, int direction, bool ctrl = false, bool shift = false) {
|
|
Assert(direction < DIR_COUNT);
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
For(view->carets) {
|
|
Int front = GetFront(it);
|
|
switch (direction) {
|
|
case DIR_UP: {
|
|
} break;
|
|
case DIR_DOWN: {
|
|
if (ctrl && shift) {
|
|
Int pos = GetNextEmptyLineStart(buffer, front);
|
|
it = ChangeFront(it, pos);
|
|
} else if (ctrl) {
|
|
Int pos = GetNextEmptyLineStart(buffer, it.range.max);
|
|
it = MakeCaret(pos);
|
|
} else if (shift) {
|
|
Int pos = OffsetByLine(buffer, front, 1);
|
|
it = ChangeFront(it, pos);
|
|
} else {
|
|
if (GetSize(it.range) == 0) {
|
|
Int pos = OffsetByLine(buffer, it.range.max, 1);
|
|
it = MakeCaret(pos);
|
|
} else {
|
|
it = MakeCaret(it.range.max);
|
|
}
|
|
}
|
|
} break;
|
|
case DIR_LEFT: {
|
|
} break;
|
|
case DIR_RIGHT: {
|
|
} break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Command_Delete(View *view, int direction, bool ctrl = false) {
|
|
Assert(direction == DIR_LEFT || direction == DIR_RIGHT);
|
|
Scratch scratch;
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
|
|
BeforeEdit(buffer, view->carets);
|
|
|
|
// Select things to delete
|
|
For(view->carets) {
|
|
if (GetSize(it.range)) continue;
|
|
Int pos = MovePos(*buffer, it.range.min, direction, ctrl);
|
|
it = MakeCaret(pos, it.range.min);
|
|
}
|
|
|
|
MergeCarets(view);
|
|
Array<Edit> edits = {scratch};
|
|
For(view->carets) AddEdit(&edits, it.range, {});
|
|
ApplyEdits(buffer, edits);
|
|
AfterEdit(buffer, &edits, &view->carets);
|
|
}
|
|
|
|
void Command_SelectAll(View *view, String16 needle) {
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
String16 string_buffer = GetString(*buffer);
|
|
|
|
Int debug_id = 0;
|
|
for (Int pos = 0;;) {
|
|
Int index = 0;
|
|
String16 medium = Skip(string_buffer, pos);
|
|
if (!Seek(medium, needle, &index)) {
|
|
break;
|
|
}
|
|
|
|
Add(&view->carets, MakeCaret(pos + index + needle.len, pos + index));
|
|
pos += needle.len;
|
|
debug_id += 1;
|
|
}
|
|
MergeCarets(view);
|
|
}
|
|
|
|
void Command_CreateCursorVertical(View *_view, int direction) {
|
|
Assert(direction == DIR_UP || direction == DIR_DOWN);
|
|
View &view = *_view;
|
|
Buffer *buffer = GetBuffer(view.active_buffer);
|
|
|
|
Scratch scratch;
|
|
Array<Caret> arr = {scratch};
|
|
For(view.carets) {
|
|
if (PosToLine(*buffer, it.range.min) == PosToLine(*buffer, it.range.max)) {
|
|
Int f = MovePos(*buffer, GetFront(it), direction);
|
|
Int b = MovePos(*buffer, GetBack(it), direction);
|
|
Add(&arr, MakeCaret(f, b));
|
|
} else {
|
|
Int pos = direction == DIR_UP ? it.range.min : it.range.max;
|
|
Int min = MovePos(*buffer, pos, direction);
|
|
Add(&arr, MakeCaret(min));
|
|
}
|
|
}
|
|
For(arr) Add(&view.carets, it);
|
|
MergeCarets(_view);
|
|
}
|
|
|
|
void Command_SelectRangeOneCursor(View *view, Range range) {
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
view->carets.len = 1;
|
|
view->carets[0] = MakeCaret(range.min, range.max);
|
|
}
|
|
|
|
void Command_SelectEntireBuffer(View *view) {
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
view->carets.len = 1;
|
|
view->carets[0] = MakeCaret(0, buffer->len);
|
|
}
|
|
|
|
void Command_EvalLua(View *view, String16 string) {
|
|
Scratch scratch;
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
String16 eval_result = EvalString(scratch, string);
|
|
|
|
if (eval_result.len) {
|
|
Command_SelectEntireBuffer(view);
|
|
Command_Replace(view, eval_result);
|
|
Command_SelectRangeOneCursor(view, {});
|
|
Command_Replace(view, L"\n");
|
|
Command_SelectRangeOneCursor(view, {});
|
|
}
|
|
|
|
else {
|
|
Range range = GetLineRangeWithoutNL(*buffer, 0);
|
|
Command_SelectRangeOneCursor(view, range);
|
|
Command_Replace(view, {});
|
|
}
|
|
}
|
|
|
|
// Merge carets that overlap, this needs to be handled before any edits to
|
|
// make sure overlapping edits won't happen.
|
|
//
|
|
// mouse_selection_anchor is special case for mouse handling !
|
|
|
|
void MergeCarets(View *view, Range *mouse_selection_anchor) {
|
|
ProfileFunction();
|
|
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
For(view->carets) it.range = Clamp(*buffer, it.range);
|
|
Caret first_caret = view->carets.data[0];
|
|
|
|
Scratch scratch;
|
|
Array<Caret> c1 = TightCopy(scratch, view->carets);
|
|
MergeSort(view->carets.len, c1.data, view->carets.data);
|
|
view->carets.len = 0;
|
|
|
|
Int first_caret_index = 0;
|
|
Add(&view->carets, c1[0]);
|
|
for (Int i = 1; i < c1.len; i += 1) {
|
|
Caret &it = c1[i];
|
|
Caret *last = GetLast(view->carets);
|
|
|
|
if (AreOverlapping(*last, it)) {
|
|
last->range.max = Max(last->range.max, it.range.max);
|
|
if (mouse_selection_anchor) *mouse_selection_anchor = last->range;
|
|
} else {
|
|
Add(&view->carets, it);
|
|
}
|
|
|
|
if (AreEqual(it, first_caret)) first_caret_index = view->carets.len - 1;
|
|
}
|
|
|
|
Swap(&view->carets[first_caret_index], &view->carets[0]);
|
|
}
|
|
|
|
void WindowCommand(Event event, Window *window, View *view) {
|
|
ProfileFunction();
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
|
|
if (Ctrl(SDLK_F2)) {
|
|
LoadBigLine(buffer);
|
|
} else if (Press(SDLK_F2)) {
|
|
LoadBigText(buffer);
|
|
}
|
|
|
|
if (Press(SDLK_ESCAPE)) {
|
|
if (window->deactivate_on_escape) {
|
|
SetActiveWindow(GetLastActiveWindow());
|
|
} else {
|
|
view->carets.len = 1;
|
|
}
|
|
}
|
|
|
|
// Underline
|
|
if (event.ctrl) {
|
|
Caret caret = view->carets[0];
|
|
if (GetSize(caret.range) == 0) {
|
|
view->underline_pos[view->underline_count++] = caret.range.min;
|
|
Assert(view->underline_count <= 2);
|
|
}
|
|
|
|
{
|
|
Vec2I mouse = MouseVec2I();
|
|
Vec2I mworld = mouse - window->document_rect.min + view->scroll;
|
|
Vec2I pos = mworld / Vec2I{FontCharSpacing, FontLineSpacing};
|
|
XY xy = {(Int)(pos.x), (Int)(pos.y)};
|
|
Int p = XYToPosErrorOutOfBounds(*buffer, xy);
|
|
if (p != -1) {
|
|
view->underline_pos[view->underline_count++] = p;
|
|
Assert(view->underline_count <= 2);
|
|
|
|
if (Mouse(LEFT)) {
|
|
Range enclose = EncloseLoadWord(buffer, p);
|
|
String16 string = GetString(*buffer, enclose);
|
|
Open(string);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (CtrlAlt(SDLK_DOWN)) {
|
|
Command_DuplicateLine(view, DIR_DOWN);
|
|
} else if (AltShift(SDLK_DOWN)) {
|
|
Command_CreateCursorVertical(view, DIR_DOWN);
|
|
} else if (CtrlShift(SDLK_DOWN)) {
|
|
Command_Move(view, DIR_DOWN, CTRL_PRESSED, SHIFT_PRESSED);
|
|
} else if (Ctrl(SDLK_DOWN)) {
|
|
Command_Move(view, DIR_DOWN, CTRL_PRESSED);
|
|
} else if (Shift(SDLK_DOWN)) {
|
|
Command_Move(view, DIR_DOWN, false, SHIFT_PRESSED);
|
|
} else if (Press(SDLK_DOWN)) {
|
|
Command_Move(view, DIR_DOWN);
|
|
}
|
|
|
|
if (CtrlAlt(SDLK_UP)) {
|
|
Command_DuplicateLine(view, DIR_UP);
|
|
} else if (AltShift(SDLK_UP)) {
|
|
Command_CreateCursorVertical(view, DIR_UP);
|
|
} else if (CtrlShift(SDLK_UP)) {
|
|
For(view->carets) it = ChangeFront(it, MovePos(*buffer, GetFront(it), DIR_UP, CTRL_PRESSED));
|
|
} else if (Ctrl(SDLK_UP)) {
|
|
For(view->carets) it = MakeCaret(MovePos(*buffer, it.range.min, DIR_UP, CTRL_PRESSED));
|
|
} else if (Shift(SDLK_UP)) {
|
|
For(view->carets) it = ChangeFront(it, MovePos(*buffer, GetFront(it), DIR_UP));
|
|
} else if (Press(SDLK_UP)) {
|
|
For(view->carets) {
|
|
if (GetSize(it.range) == 0) {
|
|
it = MakeCaret(MovePos(*buffer, it.range.min, DIR_UP));
|
|
} else {
|
|
it = MakeCaret(it.range.min);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (CtrlShift(SDLK_LEFT)) {
|
|
For(view->carets) it = ChangeFront(it, MovePos(*buffer, GetFront(it), DIR_LEFT, true));
|
|
} else if (Ctrl(SDLK_LEFT)) {
|
|
For(view->carets) {
|
|
if (GetSize(it.range) != 0 && GetFront(it) != it.range.min) {
|
|
it = MakeCaret(it.range.min);
|
|
} else {
|
|
it = MakeCaret(MovePos(*buffer, it.range.min, DIR_LEFT, true));
|
|
}
|
|
}
|
|
} else if (Shift(SDLK_LEFT)) {
|
|
For(view->carets) it = ChangeFront(it, MovePos(*buffer, GetFront(it), DIR_LEFT, false));
|
|
} else if (Press(SDLK_LEFT)) {
|
|
For(view->carets) {
|
|
if (GetSize(it.range) == 0) {
|
|
it = MakeCaret(MovePos(*buffer, it.range.min, DIR_LEFT, false));
|
|
} else {
|
|
it = MakeCaret(it.range.min);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (CtrlShift(SDLK_RIGHT)) {
|
|
For(view->carets) it = ChangeFront(it, MovePos(*buffer, GetFront(it), DIR_RIGHT, true));
|
|
} else if (Ctrl(SDLK_RIGHT)) {
|
|
For(view->carets) {
|
|
if (GetSize(it.range) != 0 && GetFront(it) != it.range.max) {
|
|
it = MakeCaret(it.range.max);
|
|
} else {
|
|
it = MakeCaret(MovePos(*buffer, it.range.max, DIR_RIGHT, true));
|
|
}
|
|
}
|
|
} else if (Shift(SDLK_RIGHT)) {
|
|
For(view->carets) it = ChangeFront(it, MovePos(*buffer, GetFront(it), DIR_RIGHT, false));
|
|
} else if (Press(SDLK_RIGHT)) {
|
|
For(view->carets) {
|
|
if (GetSize(it.range) == 0) {
|
|
it = MakeCaret(MovePos(*buffer, it.range.max, DIR_RIGHT, false));
|
|
} else {
|
|
it = MakeCaret(it.range.max);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (CtrlShift(SDLK_Z)) {
|
|
RedoEdit(buffer, &view->carets);
|
|
} else if (Ctrl(SDLK_Z)) {
|
|
UndoEdit(buffer, &view->carets);
|
|
}
|
|
|
|
if (Ctrl(SDLK_C)) {
|
|
Command_Copy(view);
|
|
} else if (Ctrl(SDLK_V)) {
|
|
Command_Paste(view);
|
|
} else if (Ctrl(SDLK_X)) {
|
|
Command_Copy(view);
|
|
Command_Replace(view, L"");
|
|
}
|
|
|
|
if (Ctrl(SDLK_A)) {
|
|
Command_SelectEntireBuffer(view);
|
|
view->update_scroll = false;
|
|
}
|
|
|
|
if (Shift(SDLK_PAGEUP)) {
|
|
Command_MoveCursorsByPageSize(window, DIR_UP, SHIFT_PRESSED);
|
|
} else if (Press(SDLK_PAGEUP)) {
|
|
Command_MoveCursorsByPageSize(window, DIR_UP);
|
|
}
|
|
|
|
if (Shift(SDLK_PAGEDOWN)) {
|
|
Command_MoveCursorsByPageSize(window, DIR_DOWN, SHIFT_PRESSED);
|
|
} else if (Press(SDLK_PAGEDOWN)) {
|
|
Command_MoveCursorsByPageSize(window, DIR_DOWN);
|
|
}
|
|
|
|
if (Shift(SDLK_HOME)) {
|
|
Command_MoveCursorsToSide(view, DIR_LEFT, SHIFT_PRESSED);
|
|
} else if (Press(SDLK_HOME)) {
|
|
Command_MoveCursorsToSide(view, DIR_LEFT);
|
|
}
|
|
|
|
if (Shift(SDLK_END)) {
|
|
Command_MoveCursorsToSide(view, DIR_RIGHT, SHIFT_PRESSED);
|
|
} else if (Press(SDLK_END)) {
|
|
Command_MoveCursorsToSide(view, DIR_RIGHT);
|
|
}
|
|
|
|
bool search = false;
|
|
if (Shift(SDLK_TAB)) {
|
|
Command_IndentSelectedLines(view, SHIFT_PRESSED);
|
|
search = true;
|
|
} else if (Press(SDLK_TAB)) {
|
|
Command_IndentSelectedLines(view);
|
|
search = true;
|
|
}
|
|
|
|
if (Ctrl(SDLK_W)) {
|
|
Int pos = view->carets[0].range.min;
|
|
view->carets[0] = MakeCaret(GetPrevWordStart(buffer, pos));
|
|
}
|
|
|
|
if (Ctrl(SDLK_R)) {
|
|
Int pos = view->carets[0].range.min;
|
|
view->carets[0] = MakeCaret(GetWordStart(buffer, pos));
|
|
}
|
|
|
|
if (CtrlShift(SDLK_K)) {
|
|
Command_KillSelectedLines(view);
|
|
}
|
|
|
|
if (Ctrl(SDLK_BACKSPACE)) {
|
|
Command_Delete(view, DIR_LEFT, CTRL_PRESSED);
|
|
search = true;
|
|
} else if (Press(SDLK_BACKSPACE)) {
|
|
Command_Delete(view, DIR_LEFT);
|
|
search = true;
|
|
}
|
|
|
|
if (Ctrl(SDLK_DELETE)) {
|
|
Command_Delete(view, DIR_RIGHT, CTRL_PRESSED);
|
|
search = true;
|
|
} else if (Press(SDLK_DELETE)) {
|
|
Command_Delete(view, DIR_RIGHT);
|
|
search = true;
|
|
}
|
|
|
|
if (event.text) {
|
|
Scratch scratch;
|
|
String string = event.text;
|
|
String16 string16 = ToString16(scratch, string);
|
|
|
|
Window *window = GetActiveWindow();
|
|
View *view = GetActiveView(window);
|
|
Command_Replace(view, string16);
|
|
|
|
search = true;
|
|
}
|
|
|
|
if (Ctrl(SDLK_D)) {
|
|
String16 string = GetString(*buffer, view->carets[0].range);
|
|
Caret caret = FindInBuffer(buffer, string, view->carets[0], true);
|
|
Insert(&view->carets, caret, 0);
|
|
MergeCarets(view);
|
|
}
|
|
|
|
if (Ctrl(SDLK_F3)) {
|
|
Buffer *search_buffer = GetBuffer("*search*");
|
|
String16 search_string = GetString(*search_buffer);
|
|
Caret caret = FindInBuffer(buffer, search_string, view->carets[0], true);
|
|
Insert(&view->carets, caret, 0);
|
|
MergeCarets(view);
|
|
} else if (Press(SDLK_F3)) {
|
|
Buffer *search_buffer = GetBuffer("*search*");
|
|
String16 search_string = GetString(*search_buffer);
|
|
Caret caret = FindInBuffer(buffer, search_string, view->carets[0], true);
|
|
view->carets.len = 1;
|
|
view->carets[0] = caret;
|
|
}
|
|
|
|
if (window->id.id == SearchWindowID.id) {
|
|
Window *seek_window = GetWindow(GetLastActiveWindow());
|
|
View *seek_view = GetView(seek_window->active_view);
|
|
Buffer *seek_buffer = GetBuffer(seek_view->active_buffer);
|
|
String16 needle = GetString(*buffer);
|
|
if (search) {
|
|
seek_view->carets[0] = FindInBuffer(seek_buffer, needle, seek_view->carets[0]);
|
|
seek_view->carets.len = 1;
|
|
}
|
|
if (Alt(SDLK_RETURN)) {
|
|
Command_SelectAll(seek_view, needle);
|
|
SetActiveWindow(seek_window->id);
|
|
} else if (Ctrl(SDLK_RETURN)) {
|
|
Caret caret = FindInBuffer(seek_buffer, needle, seek_view->carets[0], true);
|
|
Insert(&seek_view->carets, caret, 0);
|
|
MergeCarets(seek_view);
|
|
} else if (Press(SDLK_RETURN)) {
|
|
Caret caret = FindInBuffer(seek_buffer, needle, seek_view->carets[0], true);
|
|
seek_view->carets.len = 1;
|
|
seek_view->carets[0] = caret;
|
|
}
|
|
}
|
|
|
|
// @todo: consider making this view command
|
|
if (window->fuzzy_search && search) {
|
|
Scratch scratch;
|
|
String16 first_line_string = GetLineStringWithoutNL(*buffer, 0);
|
|
Array<FuzzyPair> ratings = FuzzySearchLines(scratch, buffer, 1, buffer->line_starts.len, first_line_string);
|
|
|
|
Buffer *temp_buffer = CreateTempBuffer(scratch, buffer->cap);
|
|
ReplaceText(temp_buffer, GetEndAsRange(*temp_buffer), first_line_string);
|
|
ReplaceText(temp_buffer, GetEndAsRange(*temp_buffer), L"\n");
|
|
For(ratings) {
|
|
String16 s = GetLineStringWithoutNL(*buffer, it.index);
|
|
if (s.len == 0) continue;
|
|
ReplaceText(temp_buffer, GetEndAsRange(*temp_buffer), s);
|
|
ReplaceText(temp_buffer, GetEndAsRange(*temp_buffer), L"\n");
|
|
}
|
|
|
|
Caret caret = view->carets[0];
|
|
Command_SelectEntireBuffer(view);
|
|
Command_Replace(view, GetString(*temp_buffer));
|
|
view->carets[0] = caret;
|
|
}
|
|
|
|
if (window->fuzzy_search) {
|
|
if (Press(SDLK_RETURN)) {
|
|
Scratch scratch;
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
Int line = PosToLine(*buffer, GetFront(view->carets[0]));
|
|
if (line == 0) line = 1;
|
|
|
|
String16 string = GetLineStringWithoutNL(*buffer, line);
|
|
EvalString(scratch, string);
|
|
|
|
// Clear text
|
|
Command_SelectRangeOneCursor(view, GetLineRangeWithoutNL(*buffer, 0));
|
|
Command_Replace(view, {});
|
|
}
|
|
} else if (window->id.id == SearchWindowID.id) {
|
|
} else {
|
|
if (Ctrl(SDLK_RETURN)) {
|
|
Command_MoveCursorsToSide(view, DIR_RIGHT);
|
|
Command_Replace(view, L"\n");
|
|
} else if (Press(SDLK_RETURN)) {
|
|
Command_Replace(view, L"\n");
|
|
}
|
|
}
|
|
|
|
if (Ctrl(SDLK_S)) {
|
|
if (StyleTrimWhitespaceOnSave) {
|
|
bool dont_trim_lines_with_cursor = true;
|
|
Command_TrimTrailingWhitespace(view, dont_trim_lines_with_cursor);
|
|
}
|
|
|
|
String16 string16 = GetString(*buffer);
|
|
Scratch scratch;
|
|
String string = ToString(scratch, string16);
|
|
bool success = false;
|
|
success = WriteFile(buffer->name, string);
|
|
|
|
if (success) {
|
|
buffer->dirty = false;
|
|
} else {
|
|
ReportWarningf("Failed to save file with name: %.*s", FmtString(buffer->name));
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
Vec2I mouse = MouseVec2I();
|
|
|
|
// Special case for full-screen where we can have document
|
|
// aligned with monitor screen in which case mouse cursor cannot
|
|
// be smaller then 0 which means we cannot scroll
|
|
if (mouse.y == 0 && window->document_rect.min.y == 0) {
|
|
float x, y;
|
|
SDL_GetGlobalMouseState(&x, &y);
|
|
if (y == 0) {
|
|
mouse.y = -10;
|
|
}
|
|
}
|
|
|
|
bool mouse_in_document = CheckCollisionPointRec(mouse, window->document_rect);
|
|
bool mouse_in_scrollbar = CheckCollisionPointRec(mouse, window->scrollbar_rect);
|
|
|
|
bool scrollbar_action = mouse_in_scrollbar || window->mouse_selecting_scrollbar;
|
|
bool document_action = false;
|
|
{
|
|
bool a = mouse_in_document && IsMouseEvent(event.kind);
|
|
bool b = window->mouse_selecting && !mouse_in_document;
|
|
document_action = a || b;
|
|
}
|
|
|
|
if (!scrollbar_action && document_action) {
|
|
Vec2I mworld = mouse - window->document_rect.min + view->scroll;
|
|
Vec2I pos = mworld / Vec2I{FontCharSpacing, FontLineSpacing};
|
|
XY xy = {(Int)(pos.x), (Int)(pos.y)};
|
|
Int p = XYToPosWithoutNL(*buffer, xy);
|
|
|
|
if (mouse_in_document && Mouse(LEFT) && event.shift) {
|
|
Caret *c = &view->carets[0];
|
|
*c = ChangeFront(*c, p);
|
|
} else if (mouse_in_document && Mouse(LEFT) && event.mouse_double_click) {
|
|
Caret *c = &view->carets[0];
|
|
if (InBounds({c->range.min - 1, c->range.max + 1}, p)) {
|
|
c->range = EncloseWord(buffer, p);
|
|
view->selection_anchor = c->range;
|
|
} else {
|
|
view->selection_anchor = Rng(p);
|
|
}
|
|
} else if (mouse_in_document && Mouse(LEFT) && event.alt) {
|
|
Insert(&view->carets, MakeCaret(p, p), 0);
|
|
view->selection_anchor = view->carets[0].range;
|
|
} else if (mouse_in_document && Mouse(LEFT)) {
|
|
view->carets.len = 0;
|
|
Insert(&view->carets, MakeCaret(p, p), 0);
|
|
view->selection_anchor = view->carets[0].range;
|
|
}
|
|
|
|
if (mouse_in_document && Mouse(LEFT)) {
|
|
window->mouse_selecting = true;
|
|
}
|
|
|
|
if (window->mouse_selecting) {
|
|
if (Mouse(LEFT_UP)) {
|
|
window->mouse_selecting = false;
|
|
}
|
|
|
|
MergeCarets(view, &view->selection_anchor);
|
|
Caret &caret = view->carets[0];
|
|
if (view->selection_anchor.min > p) {
|
|
caret = MakeCaret(p, view->selection_anchor.max);
|
|
} else if (view->selection_anchor.max < p) {
|
|
caret = MakeCaret(p, view->selection_anchor.min);
|
|
} else {
|
|
caret = MakeCaret(view->selection_anchor.max, view->selection_anchor.min);
|
|
}
|
|
MergeCarets(view, &view->selection_anchor);
|
|
}
|
|
} else if (!(mouse_in_document || window->mouse_selecting) && mouse_in_scrollbar || window->mouse_selecting_scrollbar) {
|
|
Vec2 mouse_vec2 = MouseVec2();
|
|
Scroller s = ComputeScrollerRect(window);
|
|
double size_y = (double)GetSize(window->scrollbar_rect).y;
|
|
double p = mouse_vec2.y - window->scrollbar_rect.min.y;
|
|
|
|
if (Mouse(LEFT)) {
|
|
window->mouse_selecting_scrollbar = true;
|
|
} else if (Mouse(LEFT_UP)) {
|
|
window->mouse_selecting_scrollbar = false;
|
|
}
|
|
|
|
if (Mouse(LEFT)) {
|
|
if (mouse_vec2.y < s.rect.min.y || mouse_vec2.y > s.rect.max.y) {
|
|
view->scroll.y = (Int)(p / size_y * (double)s.line_count * (double)FontLineSpacing);
|
|
window->mouse_scroller_offset = -(double)GetSize(s.rect).y / 2.0 / size_y;
|
|
} else {
|
|
window->mouse_scroller_offset = (s.rect.min.y - p) / size_y;
|
|
}
|
|
}
|
|
|
|
if (window->mouse_selecting_scrollbar) {
|
|
double v = p / size_y;
|
|
v = v + (window->mouse_scroller_offset);
|
|
view->scroll.y = (Int)(v * (double)s.line_count * (double)FontLineSpacing);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UpdateScroll(Window *window, bool update_caret_scrolling) {
|
|
ProfileFunction();
|
|
View *view = GetActiveView(window);
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
|
|
// Scrolling with caret
|
|
if (update_caret_scrolling) {
|
|
Caret c = view->carets[0];
|
|
Int front = GetFront(c);
|
|
XY xy = PosToXY(*buffer, front);
|
|
|
|
Rect2I visible = GetVisibleCells(window);
|
|
Vec2I visible_cells = GetSize(visible);
|
|
Vec2I visible_size = visible_cells * Vec2I{FontCharSpacing, FontLineSpacing};
|
|
Vec2I rect_size = GetSize(window->document_rect);
|
|
|
|
if (xy.line >= visible.max.y - 2) {
|
|
Int set_view_at_line = xy.line - (visible_cells.y - 1);
|
|
Int cut_off_y = Max((Int)0, visible_size.y - rect_size.y);
|
|
view->scroll.y = (set_view_at_line * FontLineSpacing) + cut_off_y;
|
|
}
|
|
|
|
if (xy.line < visible.min.y + 1) {
|
|
view->scroll.y = xy.line * FontLineSpacing;
|
|
}
|
|
|
|
if (xy.col >= visible.max.x - 1) {
|
|
Int set_view_at_line = xy.col - (visible_cells.x - 1);
|
|
Int cut_off_x = Max((Int)0, visible_size.x - rect_size.x);
|
|
view->scroll.x = (set_view_at_line * FontCharSpacing) + cut_off_x;
|
|
}
|
|
|
|
if (xy.col <= visible.min.x) {
|
|
view->scroll.x = xy.col * FontCharSpacing;
|
|
}
|
|
}
|
|
|
|
// Clip scroll
|
|
{
|
|
Int last_line = LastLine(*buffer);
|
|
view->scroll.y = Clamp(view->scroll.y, (Int)0, Max((Int)0, (last_line - 1) * FontLineSpacing));
|
|
|
|
// @note:
|
|
// GetCharCountOfLongestLine is a bottleneck, there is probably an algorithm for
|
|
// calculating this value incrementally but do we even need X scrollbar or x clipping?
|
|
view->scroll.x = ClampBottom(view->scroll.x, (Int)0);
|
|
}
|
|
} |