FantasyPvP
349 lines
9.8 KiB
C
349 lines
9.8 KiB
C
#include <stdbool.h>
|
|
#include <stdlib.h>
|
|
#include "dynstr.h"
|
|
#include <ncurses.h>
|
|
|
|
#define min(x, y) ((x) < (y) ? (x) : (y))
|
|
#define max(x, y) ((x) > (y) ? (x) : (y))
|
|
|
|
typedef struct {
|
|
uint32_t lines;
|
|
uint32_t capacity;
|
|
uint32_t buffer_line;
|
|
uint32_t buffer_col;
|
|
uint32_t y_offset;
|
|
uint32_t x_offset;
|
|
bool unsaved_changes;
|
|
bool editmode;
|
|
String_t* buffer;
|
|
String_t* original;
|
|
String_t filename;
|
|
} Editor;
|
|
|
|
void add_toolbar(Editor* self) {
|
|
int max_x, max_y;
|
|
getmaxyx(stdscr, max_y, max_x);
|
|
|
|
attron(COLOR_PAIR(2));
|
|
|
|
// add an entry for the current mode
|
|
move(max_y - 1, 0);
|
|
char mode[9];
|
|
snprintf(mode, 9, "[%6s]", self->editmode ? "Insert" : "Normal");
|
|
addstr(mode);
|
|
|
|
// add an entry for the current line and col
|
|
char line_and_col[24];
|
|
snprintf(line_and_col, 24, " [ln: %d, col: %d]", self->buffer_line + 1, self->buffer_col + 1);
|
|
addstr(line_and_col);
|
|
attroff(COLOR_PAIR(2));
|
|
|
|
// add an entry for unsaved changes
|
|
attron(COLOR_PAIR(1));
|
|
char unsaved_changes[20];
|
|
snprintf(unsaved_changes, 20, " [%s]", self->unsaved_changes ? "Unsaved Changes!" : "No Changes Yet! ");
|
|
addstr(unsaved_changes);
|
|
attroff(COLOR_PAIR(1));
|
|
}
|
|
|
|
|
|
void refresh_buffer(Editor* self) {
|
|
move(0, 0);
|
|
clear();
|
|
|
|
// get the screen size so we can figure out where to place characters
|
|
int max_x, max_y;
|
|
getmaxyx(stdscr, max_y, max_x);
|
|
max_y--; // Reserve bottom line for toolbar
|
|
|
|
// Ensure y_offset is valid
|
|
if (self->buffer_line >= self->y_offset + max_y) {
|
|
self->y_offset = self->buffer_line - max_y + 1;
|
|
}
|
|
if (self->buffer_line < self->y_offset) {
|
|
self->y_offset = self->buffer_line;
|
|
}
|
|
|
|
// Display visible lines
|
|
for (size_t i = self->y_offset; i < self->lines && i < self->y_offset + max_y; i++) {
|
|
move(i - self->y_offset, 0);
|
|
|
|
// adding the line number
|
|
attron(COLOR_PAIR(1));
|
|
char line_no[6];
|
|
snprintf(line_no, 6, "%-4d]", i + 1);
|
|
addstr(line_no);
|
|
attroff(COLOR_PAIR(1));
|
|
|
|
// Only try to display the line if it's within bounds
|
|
if (i < self->lines) {
|
|
// Calculate visible portion of line
|
|
int visible_start = self->x_offset;
|
|
int line_len = str_len(&self->buffer[i]);
|
|
int visible_end = min(line_len, self->x_offset + max_x - 5);
|
|
|
|
if (visible_start < line_len) {
|
|
String_t line_segment = str_slice(
|
|
&self->buffer[i],
|
|
visible_start,
|
|
visible_end
|
|
);
|
|
|
|
char* data = to_chars(&line_segment);
|
|
|
|
addstr(data);
|
|
str_dealloc(&line_segment);
|
|
free(data);
|
|
}
|
|
}
|
|
}
|
|
|
|
add_toolbar(self);
|
|
|
|
// Ensure cursor position is valid
|
|
int cursor_y = self->buffer_line - self->y_offset;
|
|
int cursor_x = self->buffer_col - self->x_offset + 5;
|
|
|
|
// Clamp cursor position to screen bounds
|
|
cursor_y = min(max(cursor_y, 0), max_y - 1);
|
|
cursor_x = min(max(cursor_x, 5), max_x - 1);
|
|
|
|
move(cursor_y, cursor_x);
|
|
}
|
|
|
|
void move_cursor_on_screen(Editor* editor, int x, int y) {
|
|
int max_x, max_y;
|
|
getmaxyx(stdscr, max_y, max_x);
|
|
max_y--; // Reserve bottom line for toolbar
|
|
max_x -= 5; // Account for line number margin
|
|
|
|
// Adjust x_offset if cursor would be off screen
|
|
if (x + 5 >= max_x + editor->x_offset) {
|
|
editor->x_offset = x - max_x + 6;
|
|
}
|
|
if (x < editor->x_offset) {
|
|
editor->x_offset = x;
|
|
}
|
|
|
|
// Adjust y_offset if cursor would be off screen
|
|
if (y >= max_y + editor->y_offset) {
|
|
editor->y_offset = y - max_y + 1;
|
|
}
|
|
if (y < editor->y_offset) {
|
|
editor->y_offset = y;
|
|
}
|
|
|
|
refresh_buffer(editor);
|
|
}
|
|
|
|
void switch_mode(Editor* self) {
|
|
self->editmode = !self->editmode;
|
|
refresh_buffer(self);
|
|
}
|
|
|
|
void newline(Editor* self) {
|
|
move(self->buffer_line, 0);
|
|
char line_no[6];
|
|
snprintf(line_no, 6, "%-6d", self->buffer_line + 1);
|
|
|
|
// add the line number
|
|
attron(COLOR_PAIR(1));
|
|
addstr(line_no);
|
|
attroff(COLOR_PAIR(1));
|
|
move_cursor_on_screen(self, self->buffer_col, self->buffer_line);
|
|
}
|
|
|
|
Editor editor_from(String_t input_string, String_t filename) {
|
|
Editor e;
|
|
e.lines = 0;
|
|
e.buffer_line = 0;
|
|
e.buffer_col = 0;
|
|
e.y_offset = 0;
|
|
e.x_offset = 0;
|
|
e.editmode = false;
|
|
e.unsaved_changes = false;
|
|
e.filename = filename;
|
|
|
|
int linenum = 0;
|
|
e.buffer = str_lines(&input_string, &linenum);
|
|
e.lines = (uint32_t)linenum;
|
|
e.capacity = e.lines;
|
|
|
|
str_dealloc(&input_string);
|
|
|
|
refresh_buffer(&e);
|
|
return e;
|
|
}
|
|
|
|
Editor new_editor(String_t filename) {
|
|
return editor_from(str_new(), filename);
|
|
}
|
|
|
|
int save_file(Editor* self) {
|
|
char* name = to_chars(&self->filename);
|
|
|
|
// writes the content line by line to the file
|
|
FILE* file = fopen(name, "w");
|
|
for (size_t i = 0; i < self->lines; i++) {
|
|
if (str_to_file(&self->buffer[i], file) == -1) {
|
|
|
|
free(name);
|
|
fprintf(stderr, "Error writing to file\n");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
free(name);
|
|
fclose(file);
|
|
return 0;
|
|
}
|
|
|
|
void move_cursor(Editor* self, int x, int y) {
|
|
if (y != 0
|
|
&& (int)(self->buffer_line) + y >= 0
|
|
&& self->buffer_line + y < self->lines)
|
|
{
|
|
// move the cursor up or down
|
|
self->buffer_line += y;
|
|
int line_width = str_len(&self->buffer[self->buffer_line]);
|
|
if (self->buffer_col > line_width) {
|
|
self->buffer_col = line_width;
|
|
}
|
|
} else if ((int)(self->buffer_col) + x < 0) {
|
|
// moving the cursor off the left hand side of the line
|
|
if ((int)self->buffer_line > 0) {
|
|
self->buffer_line -= 1;
|
|
self->buffer_col = str_len(&self->buffer[self->buffer_line]);
|
|
}
|
|
} else if (x != 0 && self->buffer_line < self->lines) {
|
|
int line_width = str_len(&self->buffer[self->buffer_line]);
|
|
if (self->buffer_col + x > line_width) {
|
|
// moving the cursor off the right hand side of the line
|
|
if (self->buffer_line + 1 < self->lines) {
|
|
self->buffer_col = 0;
|
|
self->buffer_line += 1;
|
|
}
|
|
} else {
|
|
// moving the cursor left or right in any other case
|
|
self->buffer_col += x;
|
|
}
|
|
}
|
|
move_cursor_on_screen(self, self->buffer_col, self->buffer_line);
|
|
}
|
|
|
|
void delchar(Editor* self) {
|
|
self->unsaved_changes = true;
|
|
|
|
if (self->buffer_col == str_len(&self->buffer[self->buffer_line])) {
|
|
|
|
if (self->buffer_line +1 == self->lines) {
|
|
return;
|
|
}
|
|
|
|
// obtain string objects that reference the old lines.
|
|
String_t old_curr_line = self->buffer[self->buffer_line];
|
|
String_t old_next_line = self->buffer[self->buffer_line + 1];
|
|
|
|
// assign the new line
|
|
self->buffer[self->buffer_line] = str_merge(&self->buffer[self->buffer_line], &self->buffer[self->buffer_line + 1]);
|
|
|
|
// deallocate the memory for the old lines
|
|
str_dealloc(&old_curr_line);
|
|
str_dealloc(&old_next_line);
|
|
|
|
for (size_t i = self->buffer_line + 2; i < self->lines; i++) {
|
|
self->buffer[i - 1] = self->buffer[i];
|
|
}
|
|
|
|
// replace the last line
|
|
self->buffer[self->lines - 1] = str_new();
|
|
self->lines--;
|
|
refresh_buffer(self);
|
|
} else {
|
|
// removes the character from the current line
|
|
str_remove(&self->buffer[self->buffer_line], self->buffer_col);
|
|
delch();
|
|
}
|
|
|
|
}
|
|
|
|
void pressed_enter(Editor* self) {
|
|
self->unsaved_changes = true;
|
|
|
|
// allocate memory immediately since we know a new line is being added
|
|
self->lines++;
|
|
|
|
while (self->lines > self->capacity) {
|
|
self->capacity++;
|
|
}
|
|
self->buffer = (String_t*)realloc(self->buffer, sizeof(String_t) * (self->capacity));
|
|
|
|
if (self->buffer_line == self->lines -1) {
|
|
// if at end of file add an empty line
|
|
self->buffer[self->lines - 1] = str_new();
|
|
} else {
|
|
// else shift each line downwards including everything past the cursor on the current line
|
|
for (size_t i = self->lines - 1; i > self->buffer_line + 1; i--) {
|
|
self->buffer[i] = self->buffer[i - 1];
|
|
}
|
|
|
|
String_t old_line = self->buffer[self->buffer_line];
|
|
|
|
self->buffer[self->buffer_line + 1] = str_slice(
|
|
&self->buffer[self->buffer_line],
|
|
self->buffer_col,
|
|
str_len(&self->buffer[self->buffer_line])
|
|
);
|
|
|
|
self->buffer[self->buffer_line] = str_slice(
|
|
&self->buffer[self->buffer_line],
|
|
0,
|
|
self->buffer_col
|
|
);
|
|
|
|
str_dealloc(&old_line);
|
|
}
|
|
// refresh the screen with the new data
|
|
refresh_buffer(self);
|
|
move_cursor(self, 1, 0);
|
|
}
|
|
|
|
// inserts a character at the cursor
|
|
void addchar(Editor* self, char c) {
|
|
self->unsaved_changes = true;
|
|
|
|
if (self->buffer_line == self->lines) {
|
|
// if we are at the end of the file then we need to add a new line
|
|
newline(self);
|
|
|
|
// reallocate self->buffer to be 1 larger
|
|
self->lines++;
|
|
|
|
while (self->lines > self->capacity) {
|
|
self->capacity++;
|
|
}
|
|
|
|
self->buffer = (String_t*)realloc(self->buffer, sizeof(String_t) * (self->capacity));
|
|
|
|
// allocate the memory space for the new line and add it to the buffer
|
|
self->buffer[self->buffer_line] = str_new();
|
|
}
|
|
|
|
insch(c);
|
|
// insert the character into the string at the given index
|
|
str_insert(&self->buffer[self->buffer_line], self->buffer_col, c);
|
|
move_cursor(self, 1, 0);
|
|
}
|
|
|
|
void shutdown_editor(Editor* self) {
|
|
for (size_t i = 0; i < self->capacity; i++) {
|
|
str_dealloc(&self->buffer[i]);
|
|
}
|
|
str_dealloc(&self->filename);
|
|
free(self->buffer);
|
|
}
|
|
|
|
String_t* to_string(Editor* self) {
|
|
|
|
}
|