git.y1.nz

state.c

#include <string.h> /* strstr */
#include <ctype.h> /* isprint */
#include <stdlib.h> /* malloc */

#include "config.h"
#include "state.h"

/* for printing dynamic messages into */
char message_buffer[MAX_SCREEN_WIDTH]; 

State *
init_state()
{
	State *ret = malloc(sizeof(State));
	ret->markup_count = 0;
	ret->markup_index = 0;
	ret->results = malloc(MAX_MARKUPS * sizeof(Markup *));
	ret->result_count = 0;
	ret->input = malloc(MAX_INPUT_LENGTH * sizeof(char));
	ret->input[0] = '\0';
	ret->input_length = 0;
	ret->mode = MODE_GROUND;
	ret->line_offset = 0;
	return ret;
}

/* functions for managing text input */
void
set_mode(State *state, int mode)
{
	state->mode = mode;
	state->input_length = 0;
	state->input[0] = '\0';
}
void
type_input_char(State *state, Wrap *wrap, char ch)
{
	if (
		state->input_length+1 >= wrap->width ||
		!isprint(ch)
	)
		return;

	state->input[state->input_length++] = ch;
	state->input[state->input_length] = '\0';
}
void
type_input_backspace(State *state)
{
	if (state->input_length == 0) {
		state->mode = MODE_GROUND;
		return;
	}
	state->input_length--;
	state->input[state->input_length] = '\0';
}

/* then, some wrap-related utilities */
// TODO extract wrap module from here (state.c) and text.c?
int
get_screen_start(Wrap *wrap, int line_offset)
{
	return wrap->lines[line_offset];
}
int
get_screen_end(Wrap *wrap, int line_offset)
{
	int last_line = line_offset + wrap->height;
	if (last_line > wrap->line_count) last_line = wrap->line_count;
	return wrap->lines[last_line];
}
int
is_onscreen(Wrap *wrap, int line_offset, int index)
{
	int first = get_screen_start(wrap, line_offset);
	int last = get_screen_end(wrap, line_offset);
	return index >= first && index <= last;
}
int
get_line_of(Wrap *wrap, int index)
{
	// TODO use binary instead of linear search
	int line = 0;
	for (;;) {
		if (
			line+1 >= wrap->line_count ||
			wrap->lines[line+1] > index
		) break;
		line++;
	}
	return line;
}

void
scroll_to(State *state, Wrap *wrap, int offset)
{
	/* clamp the offset */
	if (offset + wrap->height - 1 > wrap->line_count)
		offset = wrap->line_count + 1 - wrap->height;
	if (offset < 0) offset = 0;

	state->line_offset = offset;

	/* update message, but don't overwrite old ones */
	if (state->message == NULL) {
		if (state->line_offset >= wrap->line_count - wrap->height)
			state->message = "(END)";

		if (state->line_offset == 0)
			state->message = state->filename;
	}
}

void
unset_active(State *state)
{
	if (
		state->markup_index >= state->markup_count ||
		state->markups == NULL
	) return;
	state->markups[state->markup_index]->active = 0;
}

void
set_markup_index(State *state, int next)
{
	if (state->markup_count == 0) return;

	// TODO do we actually still need to clamp this?
	/* clamp the index */
	if (next < 0) next = 0;
	if (next > state->markup_count - 1)
		next = state->markup_count - 1;

	/* update colors */
	unset_active(state);
	state->markups[next]->active = 1;

	state->markup_index = next;
}

void
set_markups(State *state, Markup **new_markups, int new_count)
{
	unset_active(state);
	state->markups = new_markups;
	state->markup_count = new_count;
	set_markup_index(state, 0);
}

int
get_first_markup(State *state, Wrap *wrap)
{
	int i = state->markup_count - 1;
	int limit = get_screen_start(wrap, state->line_offset);
	for (;;) {
		if (i-1 < 0 ||  state->markups[i-1]->start < limit)
			return i;
		i--;
	}
}

int
get_last_markup(State *state, Wrap *wrap)
{
	int i = 0;
	int limit = get_screen_end(wrap, state->line_offset);
	for (;;) {
		if (
			i+1 >= state->markup_count ||
			state->markups[i+1]->start >= limit
		) return i;
		i++;
	}
}

void
do_search(FileContents *contents, State *state, Wrap *wrap)
{
	char *start = contents->buffer;
	char *match;
	Markup *markup;

	/* reset search state, free the old results */
	state->mode = MODE_GROUND;
	set_markups(state, contents->links, contents->link_count);
	for (int i = 0; i < state->result_count; i++)
		free_markup(state->results[i]);
	state->result_count = 0;

	/* return if the query is empty */
	if (state->input_length == 0)
		return;

	for (;;) {
		match = strstr(start, state->input);
		if (match == NULL) break;
		
		markup = create_markup(
			match - contents->buffer,
			state->input_length,
			SEARCH_COLOR
		);
		state->results[state->result_count++] = markup;
		start = match + state->input_length;
	}

	if (state->result_count == 0) {
		state->message = "No matches found";
		return;
	}

	set_markups(state, state->results, state->result_count);

	state->message = message_buffer;
	snprintf(message_buffer, wrap->width, "%d matches", state->result_count);
}

/* update scroll to ensure that a specific index is onscreen. */
void
scroll_to_show(State *state, Wrap *wrap, int index)
{
	int new_line_offset, line_to_show = get_line_of(wrap, index);
	int scrolling_up;

	/* if the line is already onscreen, do nothing */
	if (
		line_to_show >= state->line_offset &&
		line_to_show < state->line_offset + wrap->height
	) return;

	/* calculate the line offset, minimizing distance moved */
	scrolling_up = line_to_show < state->line_offset;
	new_line_offset = scrolling_up ?
		line_to_show:
		line_to_show - wrap->height + 1;
	scroll_to(state, wrap, new_line_offset);
}

void
show_markup_data(State *state, Wrap *wrap)
{
	const char *data;
	int width;

	data =  state->markups[state->markup_index]->data;
	if (data == NULL) return;

	/* -3 for "...", +1 for "\0" */
	width = wrap->width - 3 + 1;

	state->message = message_buffer;
	int length = snprintf(message_buffer, width, "Data: %s", data);
	if (length >= width)
		snprintf(
			message_buffer + (wrap->width-3),
			3 + 1, "..."
		);
}

void
next_markup(State *state, Wrap *wrap, int step)
{
	int start;
	int next = state->markup_index + step;

	if (state->markup_count == 0) {
		state->message = "None";
		return;
	}

	start = state->markups[state->markup_index]->start;
	if (!is_onscreen(wrap, state->line_offset, start)) {
		next = step > 0 ?
			get_first_markup(state, wrap) :
			get_last_markup(state, wrap);
	} else {
		if (next < 0) next = 0;
		if (next > state->markup_count-1) next = state->markup_count-1;
		if (next == state->markup_index && state->markup_count != 1) {
			state->message = "No more";
			return;
		}
	}

	set_markup_index(state, next);

	/* scroll to the start of the markup */
	start = state->markups[state->markup_index]->start;
	scroll_to_show(state, wrap, start);

	show_markup_data(state, wrap);
}

This webpage is intended to be an accessible preview of this repository. To get a fuller picture, clone it and use the git CLI.