Working

src/app.h

@@ -74,6 +74,17 @@ app_create(const char *win_title)
 {
 	SCE(SDL_Init(SDL_INIT_VIDEO));
 
+	struct app app = {
+		.win = window_create(win_title),
+		.rdr = NULL,
+		.running = true,
+		.buf = buffer_create(),
+		.cfg = {
+			.tab_size = 8
+		},
+		.target_fps = 120,
+	};
+
 	{
 		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
 		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
@@ -88,21 +99,9 @@ app_create(const char *win_title)
 		printf("GL Version: %d.%d\n", major, minor);
 	}
 
-	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, GL_DOUBLEBUFFER);
-	SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
-	SDL_GL_SetSwapInterval(0);
-
-	struct app app = {
-		.win = window_create(win_title),
-		.rdr = NULL,
-		.running = true,
-		.buf = buffer_create(),
-		.cfg = {
-			.tab_size = 8
-		},
-		.target_fps = 120,
-	};
-
+	/* SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, GL_DOUBLEBUFFER); */
+	/* SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1); */
+	/* SDL_GL_SetSwapInterval(0); */
 
 	app.glctx = SDL_GL_CreateContext(app.win.ptr);
 	SCP(app.glctx);
@@ -112,9 +111,6 @@ app_create(const char *win_title)
 		exit(EXIT_FAILURE);
 	}
 
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
 	if ( ! GLEW_ARB_draw_instanced ) {
 		fprintf(stderr,
 			"WARNING! GLEW_ARB_draw_instanced is not availible\n");
@@ -135,14 +131,8 @@ app_create(const char *win_title)
 			"WARNING! GLEW_ARB_debug_output is not availible\n");
 	}
 
-	/* app.rdr = SDL_CreateRenderer(app.win.ptr, -1, SDL_RENDERER_ACCELERATED); */
-	/* if ( app.rdr == NULL ) { */
-	/* 	printf("Using software acceleration: %s\n", SDL_GetError()); */
-	/* 	app.rdr = SDL_CreateRenderer(app.win.ptr, -1, */
-	/* 				     SDL_RENDERER_SOFTWARE); */
-	/* } */
-	/* SCP(app.rdr); */
-
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
 	return app;
 }

src/buffer.h

@@ -301,6 +301,9 @@ buffer_remove_between(struct buffer buf, size_t start, size_t end)
 	size_t nrm = end - start;
 	memmove(da.items+start, da.items+end, da.size - nrm);
 	da.size -= nrm;
+	memset(da.items+da.size, 0, da.cap - da.size);
+
+	DA_ASSIGN(buf.data, da);
 
 	return (struct ret_buffer_size_t_err) {
 		.f1 = buf,
@@ -378,7 +381,6 @@ buffer_index_fw_word(struct buffer buf)
 		err = BUFFER_ERR_INVALID_CUR_POS;
 		goto err;
 	}
-
 	bool found_letter = false;
 	size_t i = buf.cur;
 	for ( ; i < buf.data.size; ++i) {

src/config.h

@@ -24,6 +24,18 @@ static struct keybinds keybinds[KMS] = {
 			{KMOD_NONE, keybind_delete_char, {.dir = DIR_FORWARD}},
 		}
 	},
+	[SDLK_UP % KMS] = {
+		.size = 1,
+		.binds = {
+			{KMOD_NONE, keybind_mv_cur_line, {.dir = DIR_BACKWARD}}
+		}
+	},
+	[SDLK_DOWN % KMS] = {
+		.size = 1,
+		.binds = {
+			{KMOD_NONE, keybind_mv_cur_line, {.dir = DIR_FORWARD}}
+		}
+	},
 	[SDLK_RETURN % KMS] = {
 		.size = 1,
 		.binds = {
@@ -74,6 +86,18 @@ static struct keybinds keybinds[KMS] = {
 			{KMOD_CTRL, keybind_save_buffer, {.ptr = NULL}}
 		}
 	},
+	[SDLK_GREATER % KMS] = {
+		.size = 1,
+		.binds = {
+			{KMOD_ALT, keybind_mv_cur_end_buffer, {.dir = DIR_FORWARD}}
+		}
+	},
+	[SDLK_LESS % KMS] = {
+		.size = 1,
+		.binds = {
+			{KMOD_ALT, keybind_mv_cur_end_buffer, {.dir = DIR_BACKWARD}}
+		}
+	},
 };
 
 

src/keybind.h

@@ -38,6 +38,7 @@ struct app keybind_delete_char(struct app app, union keybind_args args);
 struct app keybind_mv_cur_word(struct app app, union keybind_args args);
 struct app keybind_delete_word(struct app app, union keybind_args args);
 
+struct app keybind_mv_cur_line(struct app app, union keybind_args args);
 struct app keybind_mv_cur_beg_line(struct app app, union keybind_args args);
 struct app keybind_mv_cur_end_line(struct app app, union keybind_args args);
 
@@ -45,6 +46,7 @@ struct app keybind_insert_newline(struct app app, union keybind_args args);
 
 struct app keybind_toggle_fps(struct app app, union keybind_args args);
 
+struct app keybind_mv_cur_end_buffer(struct app app, union keybind_args args);
 
 #if defined(KEYBIND_IMP) || defined(IMP)
 
@@ -146,10 +148,11 @@ keybind_delete_word(struct app app, union keybind_args args)
 		start = app.buf.cur;
 		end = index;
 	} break;
-	default:
+	default: {
 		fprintf(stderr, "Got invalid direction in %s: %d",
 			__func__, args.dir);
 		exit(EXIT_FAILURE);
+	} break;
 	}
 	RET_UNWRAP3(app.buf, n_rm, err,
 		    struct ret_buffer_size_t_err,
@@ -157,7 +160,47 @@ keybind_delete_word(struct app app, union keybind_args args)
 	if ( err != BUFFER_ERR_OK ) {
 		return app;
 	}
-	app.buf.cur -= n_rm;
+	app.buf.cur -= ( args.dir == DIR_BACKWARD ) * n_rm;
+	return app;
+}
+
+struct app
+keybind_mv_cur_line(struct app app, union keybind_args args)
+{
+	(void) args;
+	enum buffer_err err;
+	size_t index;
+	size_t col = buffer_calc_cur_col(app.buf);
+
+	switch ( args.dir ) {
+	case DIR_FORWARD: {
+		RET_UNWRAP2(index, err, struct ret_size_t_err,
+			    buffer_index_fw_char(app.buf,
+						 app.buf.cur, '\n'));
+		index = ( err == BUFFER_ERR_NOT_FOUND ) * app.buf.data.size
+			+ ( err == BUFFER_ERR_OK ) * (index + 1);
+	} break;
+	case DIR_BACKWARD: {
+		RET_UNWRAP2(index, err, struct ret_size_t_err,
+			    buffer_index_bw_char(app.buf,
+						 app.buf.cur, '\n'));
+		RET_UNWRAP2(index, err, struct ret_size_t_err,
+			    buffer_index_bw_char(app.buf,
+						 index, '\n'));
+		index = ( err == BUFFER_ERR_OK ) * (index + 1);
+	} break;
+	default: {
+		fprintf(stderr, "Got invalid direction in %s: %d",
+			__func__, args.dir);
+		exit(EXIT_FAILURE);
+	} break;
+	}
+	size_t c;
+	RET_UNWRAP2(c, err, struct ret_size_t_err,
+		    buffer_count_char_between(app.buf, '\n',
+					      index, index + col));
+	app.buf.cur = index + ( c == 0 ) * col;
+
 	return app;
 }
 
@@ -213,6 +256,25 @@ keybind_toggle_fps(struct app app, union keybind_args args)
 	return app;
 }
 
+struct app
+keybind_mv_cur_end_buffer(struct app app, union keybind_args args)
+{
+	switch ( args.dir ) {
+	case DIR_FORWARD: {
+		app.buf.cur = app.buf.data.size - 1;
+	} break;
+	case DIR_BACKWARD: {
+		app.buf.cur = 0;
+	} break;
+	default: {
+		fprintf(stderr, "Got invalid direction in %s: %d",
+			__func__, args.dir);
+		exit(EXIT_FAILURE);
+	} break;
+	}
+	return app;
+}
+
 #endif /* defined(KEYBIND_IMP) || defined(IMP) */
 
 #endif

src/main.c

@@ -103,45 +103,57 @@ int32_t get_uniform(uint32_t prog, const char *name);
 int32_t
 main(int32_t argc, char **argv)
 {
-	(void) argc; (void) argv;
+	enum buffer_err buffer_err;
+	enum shader_err shader_err;
+
+	if ( argc != 2 ) {
+		fprintf(stderr, "MUST pass file to open\n");
+		exit(EXIT_FAILURE);
+	}
 
 	struct app app = app_create("ged");
 	const char *font_path = "./charmap-oldschool_white.png";
 	app.font = font_create(app.rdr, font_path, 7, 18);
 	app.font.scale = 4.0;
 
+	RET_UNWRAP2(app.buf, buffer_err,
+		    struct ret_buffer_err,
+		    buffer_load_from_file(app.buf, argv[1]));
+	if ( buffer_err != BUFFER_ERR_OK ) {
+		fprintf(stderr, "Failed to open buffer: %d\n", buffer_err);
+		exit(EXIT_FAILURE);
+	}
+
 	struct glyphs glys;
 	glys.cap = 1024 * 1024;
 	glys.size = 0;
 	glys.items = calloc(glys.cap, sizeof(struct glyph));
 
-	enum shader_err err;
-
 	uint32_t prog;
 	uint32_t vert_shader;
 	uint32_t frag_shader;
 
 	/* Loading shaders and linking prog */
 	{
-		RET_UNWRAP2(vert_shader, err, struct ret_uint32_t_err,
+		RET_UNWRAP2(vert_shader, shader_err, struct ret_uint32_t_err,
 			    shader_compile_file("./shaders/font.vert",
 						GL_VERTEX_SHADER));
-		if ( err != SHADER_ERR_OK ) {
+		if ( shader_err != SHADER_ERR_OK ) {
 			fprintf(stderr, "Failed to compile shader font.vert\n");
 			exit(EXIT_FAILURE);
 		}
 
-		RET_UNWRAP2(frag_shader, err, struct ret_uint32_t_err,
+		RET_UNWRAP2(frag_shader, shader_err, struct ret_uint32_t_err,
 			    shader_compile_file("./shaders/font.frag",
 						GL_FRAGMENT_SHADER));
-		if ( err != SHADER_ERR_OK ) {
+		if ( shader_err != SHADER_ERR_OK ) {
 			fprintf(stderr, "Failed to compile shader font.frag\n");
 			exit(EXIT_FAILURE);
 		}
 
-		RET_UNWRAP2(prog, err, struct ret_uint32_t_err,
+		RET_UNWRAP2(prog, shader_err, struct ret_uint32_t_err,
 			    program_link(vert_shader, frag_shader));
-		if ( err != SHADER_ERR_OK ) {
+		if ( shader_err != SHADER_ERR_OK ) {
 			fprintf(stderr, "Failed to link program\n");
 			exit(EXIT_FAILURE);
 		}
@@ -224,20 +236,10 @@ main(int32_t argc, char **argv)
 
 	}
 
-	enum buffer_err err_;
-	RET_UNWRAP2(app.buf, err_,
-		    struct ret_buffer_err,
-		    buffer_load_from_file(app.buf, "./src/main.c"));
-	if ( err_ != BUFFER_ERR_OK ) {
-		fprintf(stderr, "Failed to read load buffer: %d\n", err_);
-		exit(EXIT_FAILURE);
-	}
-
 	glUniform1f(app.uniforms.scale, (float)app.font.scale);
 	glUniform2f(app.uniforms.scale, 5.0, 5.0);
 
 	double dt = (1.0 / (double)app.target_fps) * 3;
-	(void) dt;
 	uint32_t frame_target_dur = (uint32_t)(1000 / app.target_fps);
 
 	char *fps_text = calloc(1, 128);
@@ -247,7 +249,6 @@ main(int32_t argc, char **argv)
 	uint32_t fr_start = 0;
 	uint32_t fr_dur = 1;
 
-	/* struct vec2i cur = app_calc_cursor(app); */
 	while ( app.running ) {
 		fr_start = SDL_GetTicks();
 		struct buffer *buf = &app.buf;