typie

typer.c

---

#include <stdio.h>

#include "typer.h"
#include "opt.h"

#define PRINT_CONTROL(literal)  printf(literal); /* for hygeine. */
#define WRAP_LENGTH  79 /* one less than the desired max line length */


void
setup_termios(struct termios term_og)
{
	struct termios term_raw;
	term_raw = term_og;
	term_raw.c_iflag &= ~(
		IGNBRK | BRKINT | PARMRK | ISTRIP |
		INLCR | IGNCR | ICRNL | IXON
	);
	term_raw.c_oflag &= ~OPOST;
	term_raw.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
	term_raw.c_cflag &= ~(CSIZE | PARENB);
	term_raw.c_cflag |= CS8; 
	tcsetattr(0, 0, &term_raw);
}

void
restore_termios(struct termios term_og)
{
	tcsetattr(0, 0, &term_og);
	printf(COLOR_RESET "\n");
}

void
cursor_back(State * state, int steps)
{
	state->chars_printed_index -= steps;
	while (state->column < steps) {
		steps -= state->column;

		state->column = state->line_lengths[state->row-1];

		state->row--;

		/* carriage return, cursor up 1, right (until the end of line) */
		printf("\r" "\033[1A" "\033[%dC", state->column);
	}

	state->column -= steps;
	printf("\033[" "%d" "D", steps);
}

void
wrap(State * state)
{
	int line_length = state->line_lengths[state->row];
	int extras;
	int hard_wrap = 0;

	/* hard wrap very long lines */
	if (line_length < WRAP_LENGTH/4) {
		line_length = WRAP_LENGTH;
		state->line_lengths[state->row] = WRAP_LENGTH;
		hard_wrap = 1;
	}

	extras = WRAP_LENGTH - line_length;

	/* erase wrapped word from old line */
	printf("\r" "\033[%dC", line_length);
	if (hard_wrap) printf("-");
	printf(CLEAR_TO_LINE_END);

	/* cursor to beginning of next line */
	printf("\n\r");
	
	/* replace the wrapped word on the new line */
	for (int i = 0; i < extras; i++)
		printf("%c", state->chars_printed[state->chars_printed_index - extras + i]);

	state->column = extras;
	state->row++;
	if(state->row > state->max_row)
		state->max_row = state->row;
	state->line_lengths[state->row] = 0;
}

void
print_char(State * state, char c, int show_whitespace)
{
	if (state->column >= WRAP_LENGTH)
		wrap(state);

	if (show_whitespace && c == ' ') printf("\u00B7");
	else printf("%c", c);
	
	state->chars_printed[state->chars_printed_index] = c;
	state->chars_printed_index++;

	if (IS_BLANK(c))
		state->line_lengths[state->row] = state->column + 1;

	state->column++;
}

/* PAST THIS POINT, NO PRINTING OTHER THAN ESCAPE CODES. */
/* USE PRINT_CONTROL AND NO PRINTF PAST HERE */

void
add_jump(State * state, int size)
{
	state->jumps.buffer[state->jumps.length] = size;
	state->jumps.length++;
}

int
remove_jump(State * state)
{
	/* returns the size of the removed jump */

	state->jumps.length--;
	return state->jumps.buffer[state->jumps.length];
}

void
show_remaining(State * state, int reset_color)
{
	/* print the rest of the string after index, at the cursor. */
	const char * prompt = state->prompt;
	int index = state->index;
	int steps = 0;
	char c;

	if (reset_color)
		PRINT_CONTROL(COLOR_RESET);
	PRINT_CONTROL(CLEAR_TO_LINE_END);

	if (prompt[index] == '\0')
		return;

	for (;;) {
		c = prompt[index];
		if (c == '\0' || c == '\n')
			break;

		print_char(state, prompt[index], 0);
		steps++;
		index++;
	}
	printf(CLEAR_TO_FILE_END);
	cursor_back(state, steps);
}

void
skip(State * state, char input)
{
	/* jumps to the end of the current whitespace or non-whitespace chunk */

	int blankness = IS_BLANK(state->prompt[state->index]);
	char c;
	int steps = 0;
	
	for (;;) {
		c = state->prompt[state->index];
		if (c == '\0' || IS_BLANK(c) != blankness)
			break;

		print_char(state, c, 0);
		PRINT_CONTROL(COLOR_YELLOW);
		steps++;
		state->index++;
	}
	if (c != '\0') {
		print_char(state, input, 0);
		steps++;
		state->index++;
	}
	add_jump(state, steps);
}

void
on_correct(State * state, char c)
{
	PRINT_CONTROL(COLOR_GREEN);
	print_char(state, c, 0);
	add_jump(state, 1);
	state->index++;

	show_remaining(state, 1);
}

void
on_incorrect(State * state, char c)
{
	const char * prompt = state->prompt;
	char expected_c = prompt[state->index];
	int input_blank = IS_BLANK(c), prompt_blank = IS_BLANK(expected_c);

	PRINT_CONTROL(COLOR_RED);
	if (state->flags & FLAG_LEARN_MODE) {
		print_char(state, c, 1);
		show_remaining(state, 1);
		cursor_back(state, 1);
		return;
	}

	if (expected_c == '\0') {
		print_char(state, c, 1);
		add_jump(state, 0);
		return;
	}

	if (
		(input_blank && prompt_blank) ||
		(!input_blank && !prompt_blank)
	) {
		/* correct character type */
		print_char(state, c, 1);
		state->index++;
		add_jump(state, 1);
		return;
	}

	if (
		state->index != 0 &&
		IS_BLANK(prompt[state->index-1]) == input_blank
	) {
		/* extra letters at the end of a chunk */
		print_char(state, c, 1);
		add_jump(state, 0);
		show_remaining(state, 1);
		return;
	}

	skip(state, c);
	return;

}

void
on_backspace(State * state)
{
	int jump;

	if (state->flags & FLAG_LEARN_MODE) {
		show_remaining(state, 1);
		return;
	}

	if (state->jumps.length == 0)
		return;

	jump = remove_jump(state);
	if (jump == 0) {
		cursor_back(state, 1);
		show_remaining(state, 1);
		return;
	}

	cursor_back(state, jump);
	state->index -= jump;
	show_remaining(state, 1);
}

int
on_enter(State * state)
{
	return KEYPRESS_ENTER;
}

void
start_typing(State * state)
{
	printf(COLOR_BOLD);
	show_remaining(state, 0);
}

int
handle_keypress(State * state, char c)
{
	char expected = state->prompt[state->index];
	
	if (c == KEY_CTRL_C || c == KEY_CTRL_D || c == KEY_ESCAPE)
		return KEYPRESS_EXIT;

	if (c == KEY_ENTER)
		return on_enter(state);

	if (c == KEY_BACKSPACE || c == KEY_SHIFT_BACKSPACE) {
		on_backspace(state);
		return KEYPRESS_BACKSPACE;
	}
	
	if (c == expected) {
		on_correct(state, c);
		return KEYPRESS_CORRECT;
	}

	on_incorrect(state, c);
	return KEYPRESS_INCORRECT;
}