930 lines
32 KiB
C++
930 lines
32 KiB
C++
void ToggleFullscreen() {
|
|
if (IsInFullscreen) {
|
|
SDL_SetWindowSize(SDLWindow, FullScreenSizeX, FullScreenSizeY);
|
|
SDL_SetWindowPosition(SDLWindow, FullScreenPositionX, FullScreenPositionY);
|
|
} else {
|
|
SDL_GetWindowSize(SDLWindow, &FullScreenSizeX, &FullScreenSizeY);
|
|
SDL_GetWindowPosition(SDLWindow, &FullScreenPositionX, &FullScreenPositionY);
|
|
|
|
SDL_DisplayID display = SDL_GetDisplayForWindow(SDLWindow);
|
|
const SDL_DisplayMode *dm = SDL_GetCurrentDisplayMode(display);
|
|
SDL_SetWindowSize(SDLWindow, dm->w, dm->h);
|
|
SDL_SetWindowPosition(SDLWindow, 0, 0);
|
|
}
|
|
|
|
IsInFullscreen = !IsInFullscreen;
|
|
}
|
|
|
|
void CheckpointBeforeGoto(Window *window, View *view) {
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
if (buffer->gc == false) {
|
|
Add(&window->goto_history, {buffer->id, view->carets[0]});
|
|
window->goto_redo.len = 0;
|
|
}
|
|
}
|
|
|
|
void CheckpointBeforeGoto(Window *window) {
|
|
CheckpointBeforeGoto(window, GetView(window->active_view));
|
|
}
|
|
|
|
GotoCrumb GetCrumb(Array<GotoCrumb> *cr) {
|
|
for (; cr->len;) {
|
|
GotoCrumb c = Pop(cr);
|
|
Buffer *buffer = GetBufferStrict(c.buffer_id);
|
|
if (buffer) return c;
|
|
}
|
|
return {};
|
|
}
|
|
|
|
void GotoBackward(Window *window) {
|
|
BSet set = GetBSet(window);
|
|
if (window->goto_history.len <= 0) return;
|
|
Add(&window->goto_redo, {set.buffer->id, set.view->carets[0]});
|
|
|
|
GotoCrumb c = GetCrumb(&window->goto_history);
|
|
Buffer *buffer = GetBuffer(c.buffer_id);
|
|
View *view = WindowOpenBufferView(window, buffer->name);
|
|
view->carets[0] = c.caret;
|
|
UpdateScroll(window, true);
|
|
}
|
|
|
|
void GotoForward(Window *window) {
|
|
BSet set = GetBSet(window);
|
|
if (window->goto_redo.len <= 0) return;
|
|
Add(&window->goto_history, {set.buffer->id, set.view->carets[0]});
|
|
|
|
GotoCrumb c = GetCrumb(&window->goto_redo);
|
|
Buffer *buffer = GetBuffer(c.buffer_id);
|
|
View *view = WindowOpenBufferView(window, buffer->name);
|
|
view->carets[0] = c.caret;
|
|
UpdateScroll(window, true);
|
|
}
|
|
|
|
Int ScreenSpaceToBufferPos(Window *window, View *view, Buffer *buffer, Vec2I mouse) {
|
|
Vec2I mworld = mouse - window->document_rect.min + view->scroll;
|
|
Vec2I pos = mworld / Vec2I{FontCharSpacing, FontLineSpacing};
|
|
XY xy = {(Int)(pos.x), (Int)(pos.y)};
|
|
Int result = XYToPosWithoutNL(buffer, xy);
|
|
return result;
|
|
}
|
|
|
|
Int ScreenSpaceToBufferPosErrorOutOfBounds(Window *window, View *view, Buffer *buffer, Vec2I mouse) {
|
|
Vec2I mworld = mouse - window->document_rect.min + view->scroll;
|
|
Vec2I pos = mworld / Vec2I{FontCharSpacing, FontLineSpacing};
|
|
XY xy = {(Int)(pos.x), (Int)(pos.y)};
|
|
Int result = XYToPosErrorOutOfBounds(buffer, xy);
|
|
return result;
|
|
}
|
|
|
|
void MouseExecWord(Event event) {
|
|
Vec2I mouse = MouseVec2I();
|
|
BSet active = GetActiveSet();
|
|
|
|
bool mouse_in_document = CheckCollisionPointRec(mouse, active.window->document_rect);
|
|
if (mouse_in_document) {
|
|
Int p = ScreenSpaceToBufferPosErrorOutOfBounds(active.window, active.view, active.buffer, mouse);
|
|
if (p != -1) {
|
|
Range enclose = EncloseExecWord(active.buffer, p);
|
|
if (InBounds(active.view->carets[0].range, p)) {
|
|
enclose = active.view->carets[0].range;
|
|
}
|
|
String16 string = GetString(active.buffer, enclose);
|
|
Command_EvalLua(active.view, string);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Command_ListBuffers() {
|
|
BSet main = GetActiveMainSet();
|
|
CheckpointBeforeGoto(main.window);
|
|
|
|
Scratch scratch;
|
|
Array<String> strings = {scratch};
|
|
For(Buffers) {
|
|
String string = Format(scratch, "%.*s id=%d is_dir=%d", FmtString(it.o->name), (int)it.id, it.o->is_directory);
|
|
Add(&strings, string);
|
|
}
|
|
String result = Merge(scratch, strings, "\n");
|
|
String16 string16 = ToString16(scratch, result);
|
|
|
|
String buffer_name = GetUniqueBufferName(scratch, GetDir(main.buffer), "+list_buffers-");
|
|
View *new_view = WindowOpenBufferView(main.window, buffer_name);
|
|
Buffer *new_buffer = GetBuffer(new_view->active_buffer);
|
|
new_buffer->gc = true;
|
|
|
|
Command_SelectEntireBuffer(new_view);
|
|
Command_Replace(new_view, string16);
|
|
Command_SelectRangeOneCursor(new_view, {});
|
|
}
|
|
|
|
void MouseLoadWord(Event event) {
|
|
Vec2I mouse = MouseVec2I();
|
|
BSet active = GetActiveSet();
|
|
|
|
bool mouse_in_document = CheckCollisionPointRec(mouse, active.window->document_rect);
|
|
if (mouse_in_document) {
|
|
Int p = ScreenSpaceToBufferPosErrorOutOfBounds(active.window, active.view, active.buffer, mouse);
|
|
if (p != -1) {
|
|
Range enclose = EncloseLoadWord(active.buffer, p);
|
|
if (InBounds(active.view->carets[0].range, p)) enclose = active.view->carets[0].range;
|
|
String16 string = GetString(active.buffer, enclose);
|
|
|
|
active.view->carets.len = 1;
|
|
active.view->carets[0] = MakeCaret(p);
|
|
Open(string);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Command_ReplaceWithoutMovingCarets(View *view, Range range, String16 string) {
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
Array<Caret> caret_copy = Copy(GetSystemAllocator(), view->carets);
|
|
defer {
|
|
Dealloc(&view->carets);
|
|
view->carets = caret_copy;
|
|
};
|
|
|
|
Scratch scratch;
|
|
Command_SelectRangeOneCursor(view, range);
|
|
Array<Edit> edits = Command_ReplaceEx(scratch, view, string);
|
|
AdjustCarets(edits, &caret_copy);
|
|
}
|
|
|
|
void Command_Append(View *view, String16 string, bool scroll_to_end_if_cursor_on_last_line) {
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
|
|
bool scroll_to_end = false;
|
|
if (scroll_to_end_if_cursor_on_last_line) {
|
|
Int line = PosToLine(buffer, GetFront(view->carets[0]));
|
|
if (line == buffer->line_starts.len - 1) scroll_to_end = true;
|
|
}
|
|
|
|
Array<Caret> caret_copy = {};
|
|
if (!scroll_to_end) caret_copy = Copy(GetSystemAllocator(), view->carets);
|
|
defer {
|
|
if (!scroll_to_end) {
|
|
Dealloc(&view->carets);
|
|
view->carets = caret_copy;
|
|
}
|
|
};
|
|
|
|
Command_SelectRangeOneCursor(view, GetEndAsRange(buffer));
|
|
Command_Replace(view, string);
|
|
Command_Replace(view, L"\n");
|
|
|
|
if (scroll_to_end) {
|
|
view->carets[0] = MakeCaret(GetEndAsRange(buffer).min);
|
|
}
|
|
}
|
|
|
|
void Command_Append(View *view, String string, bool scroll_to_end_if_cursor_on_last_line) {
|
|
Scratch scratch;
|
|
String16 string16 = ToString16(scratch, string);
|
|
Command_Append(view, string16, scroll_to_end_if_cursor_on_last_line);
|
|
}
|
|
|
|
void Command_Appendf(View *view, const char *fmt, ...) {
|
|
Scratch scratch;
|
|
STRING_FORMAT(scratch, fmt, string);
|
|
Command_Append(view, string, true);
|
|
}
|
|
|
|
void ReportErrorf(const char *fmt, ...) {
|
|
Scratch scratch;
|
|
STRING_FORMAT(scratch, fmt, string);
|
|
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error!", string.data, NULL);
|
|
View *view = GetView(NullViewID);
|
|
Command_Append(view, string, true);
|
|
}
|
|
|
|
void ReportConsolef(const char *fmt, ...) {
|
|
Scratch scratch;
|
|
STRING_FORMAT(scratch, fmt, string);
|
|
View *view = GetView(NullViewID);
|
|
Command_Append(view, string, true);
|
|
}
|
|
|
|
void ReportWarningf(const char *fmt, ...) {
|
|
Scratch scratch;
|
|
STRING_FORMAT(scratch, fmt, string);
|
|
View *null_view = GetView(NullViewID);
|
|
Command_Append(null_view, string, true);
|
|
|
|
void Command_InsertTitlebarCommand(BSet title, String16 needle, String16 string, bool select_entire);
|
|
BSet title = GetActiveTitleSet();
|
|
Command_InsertTitlebarCommand(title, L"#Error('", ToString16(scratch, string), true);
|
|
}
|
|
|
|
void Command_MoveCursorsByPageSize(Window *window, int direction, bool shift = false) {
|
|
Assert(direction == DIR_UP || direction == DIR_DOWN);
|
|
BSet set = GetBSet(window);
|
|
|
|
Rect2I visible_cells_rect = GetVisibleCells(window);
|
|
Int y = GetSize(visible_cells_rect).y - 2;
|
|
if (direction == DIR_UP) y = -y;
|
|
|
|
For(set.view->carets) {
|
|
XY xy = PosToXY(set.buffer, GetFront(it));
|
|
if (direction == DIR_DOWN && xy.line == set.buffer->line_starts.len - 1) {
|
|
Range line_range = GetLineRange(set.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(set.buffer, xy);
|
|
if (shift) {
|
|
it = SetFront(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 {
|
|
Int indent = GetIndentAtPos(buffer, pos);
|
|
Int new_pos = GetLineStart(buffer, pos);
|
|
if (new_pos + indent != pos) {
|
|
pos = new_pos + indent;
|
|
} else {
|
|
pos = new_pos;
|
|
}
|
|
}
|
|
|
|
if (shift) {
|
|
it = SetFront(it, pos);
|
|
} else {
|
|
it.range.max = it.range.min = pos;
|
|
}
|
|
}
|
|
}
|
|
|
|
Caret MoveCaret(Buffer *buffer, Caret it, int direction, bool ctrl = false, bool shift = false) {
|
|
Int front = GetFront(it);
|
|
Int range_size = GetSize(it.range);
|
|
switch (direction) {
|
|
case DIR_UP: {
|
|
if (ctrl && shift) {
|
|
Int pos = GetPrevEmptyLineStart(buffer, front);
|
|
it = SetFront(it, pos);
|
|
} else if (ctrl) {
|
|
Int pos = GetPrevEmptyLineStart(buffer, it.range.min);
|
|
it = MakeCaret(pos);
|
|
} else if (shift) {
|
|
Int pos = OffsetByLine(buffer, front, -1);
|
|
it = SetFront(it, pos);
|
|
} else {
|
|
if (range_size == 0) {
|
|
Int pos = OffsetByLine(buffer, it.range.min, -1);
|
|
it = MakeCaret(pos);
|
|
} else {
|
|
it = MakeCaret(it.range.min);
|
|
}
|
|
}
|
|
} break;
|
|
case DIR_DOWN: {
|
|
if (ctrl && shift) {
|
|
Int pos = GetNextEmptyLineStart(buffer, front);
|
|
it = SetFront(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 = SetFront(it, pos);
|
|
} else {
|
|
if (range_size == 0) {
|
|
Int pos = OffsetByLine(buffer, it.range.max, 1);
|
|
it = MakeCaret(pos);
|
|
} else {
|
|
it = MakeCaret(it.range.max);
|
|
}
|
|
}
|
|
} break;
|
|
case DIR_LEFT: {
|
|
if (ctrl && shift) {
|
|
Int pos = GetPrevWordStart(buffer, front);
|
|
it = SetFront(it, pos);
|
|
} else if (ctrl) {
|
|
if (range_size != 0 && front != it.range.min) {
|
|
it = MakeCaret(it.range.min);
|
|
} else {
|
|
Int pos = GetPrevWordStart(buffer, it.range.min);
|
|
it = MakeCaret(pos);
|
|
}
|
|
} else if (shift) {
|
|
Int pos = GetPrevChar(buffer, front);
|
|
it = SetFront(it, pos);
|
|
} else {
|
|
if (range_size == 0) {
|
|
Int pos = GetPrevChar(buffer, it.range.min);
|
|
it = MakeCaret(pos);
|
|
} else {
|
|
it = MakeCaret(it.range.min);
|
|
}
|
|
}
|
|
} break;
|
|
case DIR_RIGHT: {
|
|
if (ctrl && shift) {
|
|
Int pos = GetNextWordEnd(buffer, front);
|
|
it = SetFront(it, pos);
|
|
} else if (ctrl) {
|
|
if (range_size != 0 && front != it.range.max) {
|
|
it = MakeCaret(it.range.max);
|
|
} else {
|
|
Int pos = GetNextWordEnd(buffer, it.range.max);
|
|
it = MakeCaret(pos);
|
|
}
|
|
} else if (shift) {
|
|
Int pos = GetNextChar(buffer, front);
|
|
it = SetFront(it, pos);
|
|
} else {
|
|
if (range_size == 0) {
|
|
Int pos = GetNextChar(buffer, it.range.max);
|
|
it = MakeCaret(pos);
|
|
} else {
|
|
it = MakeCaret(it.range.max);
|
|
}
|
|
}
|
|
} break;
|
|
}
|
|
return it;
|
|
}
|
|
|
|
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) {
|
|
it = MoveCaret(buffer, it, direction, ctrl, shift);
|
|
}
|
|
}
|
|
|
|
void Command_MoveLine(View *view, int direction) {
|
|
Assert(direction == DIR_DOWN || direction == DIR_UP);
|
|
Scratch scratch;
|
|
|
|
struct XYPair {
|
|
XY front;
|
|
XY back;
|
|
};
|
|
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
Array<Edit> edits = BeginEdit(scratch, buffer, view->carets);
|
|
MergeCarets(view);
|
|
Array<XYPair> saved_xy = {scratch};
|
|
For(view->carets) {
|
|
Add(&saved_xy, {PosToXY(buffer, GetFront(it)), PosToXY(buffer, GetBack(it))});
|
|
Range lines_to_move_range = {GetFullLineStart(buffer, it.range.min), GetFullLineEnd(buffer, it.range.max)};
|
|
|
|
String16 string = GetString(buffer, lines_to_move_range);
|
|
string = Copy(scratch, string);
|
|
AddEdit(&edits, lines_to_move_range, {});
|
|
|
|
// @todo: GetPrevLine, GetNextLine, GetNextFull
|
|
// GetPrevLineStart, GetNextLineEnd
|
|
if (direction == DIR_DOWN) {
|
|
Int next_line_start = lines_to_move_range.max;
|
|
Int next_line_end = GetFullLineEnd(buffer, next_line_start);
|
|
AddEdit(&edits, Rng(next_line_end), string);
|
|
} else {
|
|
Int prev_line_end = lines_to_move_range.min - 1;
|
|
Int prev_line_start = GetFullLineStart(buffer, prev_line_end);
|
|
AddEdit(&edits, Rng(prev_line_start), string);
|
|
}
|
|
}
|
|
EndEdit(buffer, &edits, &view->carets);
|
|
|
|
Int line_offset = direction == DIR_UP ? -1 : +1;
|
|
for (Int i = 0; i < saved_xy.len; i += 1) {
|
|
Caret &caret = view->carets[i];
|
|
XYPair &xypair = saved_xy[i];
|
|
xypair.front.line += line_offset;
|
|
xypair.back.line += line_offset;
|
|
Int front = XYToPos(buffer, xypair.front);
|
|
Int back = XYToPos(buffer, xypair.back);
|
|
|
|
caret = MakeCaret(front, back);
|
|
}
|
|
}
|
|
|
|
Array<Edit> Command_ReplaceEx(Allocator scratch, View *view, String16 string) {
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
Array<Edit> edits = BeginEdit(scratch, buffer, view->carets);
|
|
MergeCarets(view);
|
|
For(view->carets) AddEdit(&edits, it.range, string);
|
|
EndEdit(buffer, &edits, &view->carets);
|
|
return edits;
|
|
}
|
|
|
|
void Command_Replace(View *view, String16 string) {
|
|
Scratch scratch;
|
|
Command_ReplaceEx(scratch, view, string);
|
|
}
|
|
|
|
void Command_DuplicateLine(View *view, int direction) {
|
|
Assert(direction == DIR_UP || direction == DIR_DOWN);
|
|
Scratch scratch;
|
|
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
BeginEdit(scratch, buffer, view->carets);
|
|
For(view->carets) it = MakeCaret(GetFront(it));
|
|
MergeCarets(view);
|
|
|
|
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);
|
|
}
|
|
EndEdit(buffer, &edits, &view->carets);
|
|
|
|
Command_Move(view, direction);
|
|
}
|
|
|
|
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);
|
|
if (view->carets.len > 1) 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);
|
|
|
|
Array<Edit> edits = BeginEdit(scratch, buffer, view->carets);
|
|
MergeCarets(view);
|
|
|
|
Array<Range> line_ranges_to_indent = GetSelectedLinesSorted(scratch, view);
|
|
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"");
|
|
}
|
|
}
|
|
}
|
|
EndEdit(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);
|
|
|
|
Array<Edit> edits = BeginEdit(scratch, buffer, view->carets);
|
|
MergeCarets(view);
|
|
|
|
Array<Range> lines_to_skip_triming = {};
|
|
if (dont_trim_lines_with_cursor) lines_to_skip_triming = GetSelectedLinesSorted(scratch, view);
|
|
|
|
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"");
|
|
}
|
|
|
|
EndEdit(buffer, &edits, &view->carets, !KILL_SELECTION);
|
|
view->update_scroll = false;
|
|
}
|
|
|
|
void Command_ConvertLineEndings(View *view, bool dont_trim_lines_with_cursor) {
|
|
Scratch scratch;
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
|
|
Array<Edit> edits = BeginEdit(scratch, buffer, view->carets);
|
|
MergeCarets(view);
|
|
|
|
Array<Range> lines_to_skip_triming = {};
|
|
if (dont_trim_lines_with_cursor) lines_to_skip_triming = GetSelectedLinesSorted(scratch, view);
|
|
|
|
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);
|
|
wchar_t cr = GetChar(buffer, range.max - 1);
|
|
wchar_t lf = GetChar(buffer, range.max);
|
|
if (cr == L'\r' && lf == L'\n') {
|
|
AddEdit(&edits, {range.max - 1, range.max}, L"");
|
|
}
|
|
}
|
|
EndEdit(buffer, &edits, &view->carets, !KILL_SELECTION);
|
|
view->update_scroll = false;
|
|
}
|
|
|
|
bool IsCFile(String name) {
|
|
bool result = EndsWith(name, ".cpp") || EndsWith(name, ".c") || EndsWith(name, ".hpp") || EndsWith(name, ".h");
|
|
return result;
|
|
}
|
|
|
|
void SaveBuffer(View *view) {
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
bool dont_trim_lines_with_cursor = true;
|
|
Command_ConvertLineEndings(view, dont_trim_lines_with_cursor);
|
|
if (StyleTrimWhitespaceOnSave) {
|
|
Command_TrimTrailingWhitespace(view, dont_trim_lines_with_cursor);
|
|
Assert(view->active_buffer == buffer->id);
|
|
}
|
|
|
|
if (StyleClangFormatOnSave && IsCFile(buffer->name)) {
|
|
Scratch scratch;
|
|
String string = AllocCharString(scratch, buffer);
|
|
Buffer *temp_buffer = ExecAndWait(scratch, "clang-format", GetDir(buffer), string);
|
|
Command_ReplaceWithoutMovingCarets(view, GetRange(buffer), {temp_buffer->str, temp_buffer->len});
|
|
}
|
|
|
|
Scratch scratch;
|
|
String string = AllocCharString(scratch, buffer);
|
|
bool success = WriteFile(buffer->name, string);
|
|
|
|
if (success) {
|
|
buffer->file_mod_time = GetFileModTime(buffer->name);
|
|
buffer->dirty = false;
|
|
buffer->gc = false;
|
|
} else {
|
|
ReportWarningf("Failed to save file with name: %.*s", FmtString(buffer->name));
|
|
}
|
|
}
|
|
|
|
void Command_KillSelectedLines(View *view) {
|
|
Scratch scratch;
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
|
|
Array<Edit> edits = BeginEdit(scratch, buffer, view->carets);
|
|
MergeCarets(view);
|
|
|
|
Array<Range> lines = GetSelectedLinesSorted(scratch, view);
|
|
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;
|
|
}
|
|
|
|
EndEdit(buffer, &edits, &view->carets, KILL_SELECTION);
|
|
}
|
|
|
|
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);
|
|
Array<Edit> edits = BeginEdit(scratch, buffer, view->carets);
|
|
|
|
// Select things to delete
|
|
For(view->carets) {
|
|
if (GetSize(it.range)) continue;
|
|
if (direction == DIR_LEFT) {
|
|
|
|
// Delete indent in multiple of IndentSize
|
|
Range indent_range = GetIndentRangeAtPos(buffer, it.range.min);
|
|
if (ctrl == false && it.range.min > indent_range.min && it.range.max <= indent_range.max) {
|
|
Int offset = it.range.min - indent_range.min;
|
|
Int to_delete = (offset % (StyleIndentSize));
|
|
if (to_delete == 0) to_delete = StyleIndentSize;
|
|
to_delete = Clamp(to_delete, (Int)1, StyleIndentSize);
|
|
for (Int i = 0; i < to_delete; i += 1) {
|
|
it = MoveCaret(buffer, it, direction, false, SHIFT_PRESSED);
|
|
}
|
|
|
|
} else {
|
|
it = MoveCaret(buffer, it, direction, ctrl, SHIFT_PRESSED);
|
|
}
|
|
} else {
|
|
it = MoveCaret(buffer, it, direction, ctrl, SHIFT_PRESSED);
|
|
}
|
|
}
|
|
|
|
MergeCarets(view);
|
|
For(view->carets) AddEdit(&edits, it.range, {});
|
|
EndEdit(buffer, &edits, &view->carets);
|
|
}
|
|
|
|
void Command_SelectAll(View *view, String16 needle) {
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
String16 string_buffer = GetString(buffer);
|
|
|
|
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;
|
|
}
|
|
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);
|
|
|
|
Int line_offset = direction == DIR_UP ? -1 : 1;
|
|
|
|
Scratch scratch;
|
|
Array<Caret> arr = {scratch};
|
|
For(view.carets) {
|
|
if (PosToLine(buffer, it.range.min) == PosToLine(buffer, it.range.max)) {
|
|
Int f = OffsetByLine(buffer, GetFront(it), line_offset);
|
|
Int b = OffsetByLine(buffer, GetBack(it), line_offset);
|
|
Add(&arr, MakeCaret(f, b));
|
|
} else {
|
|
Int pos = direction == DIR_UP ? it.range.min : it.range.max;
|
|
Caret caret = MakeCaret(pos);
|
|
caret = MoveCaret(buffer, caret, direction);
|
|
Add(&arr, caret);
|
|
}
|
|
}
|
|
For(arr) Add(&view.carets, it);
|
|
MergeCarets(_view);
|
|
}
|
|
|
|
void Command_SelectRangeOneCursor(View *view, Caret caret) {
|
|
view->carets.len = 1;
|
|
view->carets[0] = caret;
|
|
}
|
|
|
|
void Command_SelectRangeOneCursor(View *view, Range range) {
|
|
Command_SelectRangeOneCursor(view, MakeCaret(range.min, range.max));
|
|
}
|
|
|
|
void Command_SelectEntireBuffer(View *view) {
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
Command_SelectRangeOneCursor(view, GetRange(buffer));
|
|
}
|
|
|
|
// 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) {
|
|
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);
|
|
if (view->carets.len > 1) 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);
|
|
} 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]);
|
|
}
|
|
|
|
Caret FindPrev(Buffer *buffer, String16 needle, Caret caret) {
|
|
Int pos = GetFront(caret);
|
|
String16 medium = GetString(buffer, {0, pos});
|
|
|
|
Caret result = caret;
|
|
Int index = 0;
|
|
if (Seek(medium, needle, &index, SeekFlag_MatchFindLast)) {
|
|
result = MakeCaret(index, index + needle.len);
|
|
} else {
|
|
medium = GetString(buffer);
|
|
if (Seek(medium, needle, &index, SeekFlag_MatchFindLast)) {
|
|
result = MakeCaret(index, index + needle.len);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
Caret FindNext(Buffer *buffer, String16 needle, Caret caret) {
|
|
Int pos = GetFront(caret);
|
|
String16 medium = GetString(buffer, {pos, INT64_MAX});
|
|
|
|
Caret result = caret;
|
|
Int index = 0;
|
|
if (Seek(medium, needle, &index)) {
|
|
result = MakeCaret(pos + index + needle.len, pos + index);
|
|
} else {
|
|
medium = GetString(buffer);
|
|
if (Seek(medium, needle, &index)) {
|
|
result = MakeCaret(index + needle.len, index);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void Command_IdentedNewLine(View *view) {
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
Scratch scratch;
|
|
Array<Edit> edits = BeginEdit(scratch, buffer, view->carets);
|
|
MergeCarets(view);
|
|
For(view->carets) {
|
|
Int front = GetFront(it);
|
|
Int line = PosToLine(buffer, front);
|
|
Int indent = GetLineIndent(buffer, line);
|
|
String string = Format(scratch, "\n%.*s", (int)indent, " ");
|
|
String16 string16 = ToString16(scratch, string);
|
|
AddEdit(&edits, it.range, string16);
|
|
}
|
|
EndEdit(buffer, &edits, &view->carets);
|
|
}
|
|
|
|
void Command_Find(View *seek_view, String16 needle, bool forward = true) {
|
|
Buffer *seek_buffer = GetBuffer(seek_view->active_buffer);
|
|
Caret caret = seek_view->carets[0];
|
|
if (forward) caret = FindNext(seek_buffer, needle, caret);
|
|
if (!forward) caret = FindPrev(seek_buffer, needle, caret);
|
|
Command_SelectRangeOneCursor(seek_view, caret);
|
|
|
|
IF_DEBUG(AssertRanges(seek_view->carets));
|
|
}
|
|
|
|
void Command_GotoNextInList(Window *window, Int line_offset = 1) {
|
|
Assert(line_offset == 1 || line_offset == -1);
|
|
View *active_view = GetView(window->active_view);
|
|
|
|
View *view_goto = GetView(window->active_goto_list);
|
|
window->active_view = view_goto->id;
|
|
|
|
Buffer *buffer_goto = GetBuffer(view_goto->active_buffer);
|
|
int64_t pos = GetFront(view_goto->carets[0]);
|
|
Int line = PosToLine(buffer_goto, pos);
|
|
|
|
bool opened = false;
|
|
for (Int i = line + line_offset; i >= 0 && i < buffer_goto->line_starts.len; i += line_offset) {
|
|
Range line_range = GetLineRangeWithoutNL(buffer_goto, line + line_offset);
|
|
String16 line = GetString(buffer_goto, line_range);
|
|
view_goto->carets[0] = MakeCaret(line_range.min);
|
|
line = Trim(line);
|
|
|
|
MergeCarets(view_goto);
|
|
IF_DEBUG(AssertRanges(view_goto->carets));
|
|
if (line.len == 0) continue;
|
|
|
|
CheckpointBeforeGoto(window, active_view);
|
|
Open(line);
|
|
opened = true;
|
|
break;
|
|
}
|
|
|
|
if (!opened) window->active_view = active_view->id;
|
|
}
|
|
|
|
void Command_FuzzySort(View *view, String16 needle) {
|
|
Buffer *buffer = GetBuffer(view->active_buffer);
|
|
|
|
Scratch scratch;
|
|
Array<FuzzyPair> ratings = FuzzySearchLines(scratch, buffer, 0, buffer->line_starts.len, needle);
|
|
|
|
Buffer *temp_buffer = CreateTempBuffer(scratch, buffer->cap);
|
|
For(ratings) {
|
|
String16 s = GetLineStringWithoutNL(buffer, it.index);
|
|
if (s.len == 0) continue;
|
|
IKnowWhatImDoing_ReplaceText(temp_buffer, GetEndAsRange(temp_buffer), s);
|
|
IKnowWhatImDoing_ReplaceText(temp_buffer, GetEndAsRange(temp_buffer), L"\n");
|
|
}
|
|
|
|
Command_SelectEntireBuffer(view);
|
|
Command_Replace(view, GetString(temp_buffer));
|
|
Command_SelectRangeOneCursor(view, Rng(0));
|
|
}
|
|
|
|
void Command_InsertTitlebarCommand(BSet title, String16 needle, String16 initial_value, bool select_entire_thing) {
|
|
Scratch scratch;
|
|
String16 quoted16 = {};
|
|
{
|
|
String needle8 = ToString(scratch, needle);
|
|
String initial_value8 = ToString(scratch, initial_value);
|
|
String quoted = Format(scratch, "%.*s%.*s')", FmtString(needle8), FmtString(initial_value8));
|
|
quoted16 = ToString16(scratch, quoted);
|
|
}
|
|
|
|
Range needle_range = {};
|
|
int64_t index = 0;
|
|
String16 buffer_string = GetString(title.buffer);
|
|
if (Seek(buffer_string, needle, &index)) {
|
|
Range range = EncloseExecWord(title.buffer, index);
|
|
Command_SelectRangeOneCursor(title.view, Rng(range.min - 1, range.max));
|
|
Command_Replace(title.view, quoted16);
|
|
needle_range = {index + needle.len, index + needle.len + initial_value.len};
|
|
} else {
|
|
Command_SelectRangeOneCursor(title.view, GetEndAsRange(title.buffer));
|
|
Command_Replace(title.view, quoted16);
|
|
Int end = GetEndAsRange(title.buffer).max - 2;
|
|
needle_range = {end - initial_value.len, end};
|
|
}
|
|
|
|
if (select_entire_thing) {
|
|
needle_range.min -= needle.len;
|
|
needle_range.max += 2;
|
|
}
|
|
Command_SelectRangeOneCursor(title.view, MakeCaret(needle_range.max, needle_range.min));
|
|
}
|
|
|
|
void Command_SelectTitlebarCommand(Window *window, String16 needle) {
|
|
BSet title = GetTitleSet(window);
|
|
ActiveWindow = title.window->id;
|
|
title.window->auto_enclose = true;
|
|
Command_InsertTitlebarCommand(title, needle, L"", false);
|
|
}
|