path: root/alsamixer/textbox.c

/*
 * textbox.c - show a text box for messages, files or help
 * Copyright (c) 1998,1999 Tim Janik
 *                         Jaroslav Kysela <perex@perex.cz>
 * Copyright (c) 2009      Clemens Ladisch <clemens@ladisch.de>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "aconfig.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include CURSESINC
#include <alsa/asoundlib.h>
#include "gettext_curses.h"
#include "utils.h"
#include "die.h"
#include "mem.h"
#include "colors.h"
#include "widget.h"
#include "textbox.h"
#include "bindings.h"

static void create_text_box(const char *const *lines, unsigned int count,
			    const char *title, int attrs);

void show_error(const char *msg, int err)
{
	const char *lines[2];
	unsigned int count;

	lines[0] = msg;
	count = 1;
	if (err) {
		lines[1] = strerror(err);
		count = 2;
	}
	create_text_box(lines, count, _("Error"), attrs.errormsg);
}

void show_alsa_error(const char *msg, int err)
{
	const char *lines[2];
	unsigned int count;

	lines[0] = msg;
	count = 1;
	if (err < 0) {
		lines[1] = snd_strerror(err);
		count = 2;
	}
	create_text_box(lines, count, _("Error"), attrs.errormsg);
}

void show_textfile(const char *file_name)
{
	char *buf;
	unsigned int file_size;
	unsigned int line_count;
	unsigned int i;
	const char **lines;
	const char *start_line;

	buf = read_file(file_name, &file_size);
	if (!buf) {
		int err = errno;
		buf = casprintf(_("Cannot open file \"%s\"."), file_name);
		show_error(buf, err);
		return;
	}
	line_count = 0;
	for (i = 0; i < file_size; ++i)
		line_count += buf[i] == '\n';
	lines = ccalloc(line_count, sizeof *lines);
	line_count = 0;
	start_line = buf;
	for (i = 0; i < file_size; ++i) {
		if (buf[i] == '\n') {
			lines[line_count++] = start_line;
			buf[i] = '\0';
			start_line = &buf[i + 1];
		}
		if (buf[i] == '\t')
			buf[i] = ' ';
	}
	create_text_box(lines, line_count, file_name, attrs.textbox);
	free(lines);
	free(buf);
}

void show_text(const char *const *lines, unsigned int count, const char *title)
{
	create_text_box(lines, count, title, attrs.textbox);
}

/**********************************************************************/

static struct widget text_widget;
static char *title;
static int widget_attrs;
static char **text_lines;
static unsigned int text_lines_count;
static int max_line_width;
static int text_box_y;
static int text_box_x;
static int max_scroll_y;
static int max_scroll_x;
static int current_top;
static int current_left;

static void update_text_lines(void)
{
	int i;
	int width;
	const char *line_begin;
	const char *line_end;
	int cur_y, cur_x;
	int rest_of_line;

	for (i = 0; i < text_box_y; ++i) {
		width = current_left;
		line_begin = mbs_at_width(text_lines[current_top + i], &width, 1);
		wmove(text_widget.window, i + 1, 1);
		if (width > current_left)
			waddch(text_widget.window, ' ');
		if (*line_begin != '\0') {
			width = text_box_x - (width > current_left);
			line_end = mbs_at_width(line_begin, &width, -1);
			if (width)
				waddnstr(text_widget.window, line_begin,
					 line_end - line_begin);
		}
		getyx(text_widget.window, cur_y, cur_x);
		if (cur_y == i + 1) {
			rest_of_line = text_box_x + 1 - cur_x;
			if (rest_of_line > 0)
				wprintw(text_widget.window, "%*s", rest_of_line, "");
		}
	}
}

static void update_y_scroll_bar(void)
{
	int length;
	int begin;

	if (max_scroll_y <= 0 || text_lines_count == 0)
		return;
	length = text_box_y * text_box_y / text_lines_count;
	if (length >= text_box_y)
		return;
	begin = current_top * (text_box_y - length) / max_scroll_y;
	mvwvline(text_widget.window, 1, text_box_x + 1, ' ', text_box_y);
	mvwvline(text_widget.window, begin + 1, text_box_x + 1, ACS_BOARD, length);
}

static void update_x_scroll_bar(void)
{
	int length;
	int begin;

	if (max_scroll_x <= 0 || max_line_width <= 0)
		return;
	length = text_box_x * text_box_x / max_line_width;
	if (length >= text_box_x)
		return;
	begin = current_left * (text_box_x - length) / max_scroll_x;
	mvwhline(text_widget.window, text_box_y + 1, 1, ' ', text_box_x);
	mvwhline(text_widget.window, text_box_y + 1, begin + 1, ACS_BOARD, length);
}

static void move_x(int delta)
{
	int left;

	left = current_left + delta;
	if (left < 0)
		left = 0;
	else if (left > max_scroll_x)
		left = max_scroll_x;
	if (left != current_left) {
		current_left = left;
		update_text_lines();
		update_x_scroll_bar();
	}
}

static void move_y(int delta)
{
	int top;

	top = current_top + delta;
	if (top < 0)
		top = 0;
	else if (top > max_scroll_y)
		top = max_scroll_y;
	if (top != current_top) {
		current_top = top;
		update_text_lines();
		update_y_scroll_bar();
	}
}

static void on_handle_key(int key)
{
	if (key >= ARRAY_SIZE(textbox_bindings))
		return;

	switch (textbox_bindings[key]) {
	case CMD_TEXTBOX_CLOSE:
		text_widget.close();
		break;
	case CMD_TEXTBOX_DOWN:
		move_y(1);
		break;
	case CMD_TEXTBOX_UP:
		move_y(-1);
		break;
	case CMD_TEXTBOX_LEFT:
		move_x(-1);
		break;
	case CMD_TEXTBOX_RIGHT:
		move_x(1);
		break;
	case CMD_TEXTBOX_PAGE_DOWN:
		move_y(text_box_y);
		break;
	case CMD_TEXTBOX_PAGE_UP:
		move_y(-text_box_y);
		break;
	case CMD_TEXTBOX_TOP:
		move_x(-max_scroll_x);
		break;
	case CMD_TEXTBOX_BOTTOM:
		move_x(max_scroll_x);
		break;
	case CMD_TEXTBOX_PAGE_RIGHT:
		move_x(8);
		break;
	case CMD_TEXTBOX_PAGE_LEFT:
		move_x(-8);
		break;
	}
}

static bool create(void)
{
	int len, width;

	if (screen_lines < 3 || screen_cols < 8) {
		text_widget.close();
		beep();
		return FALSE;
	}

	width = max_line_width;
	len = get_mbs_width(title) + 2;
	if (width < len)
		width = len;

	text_box_y = text_lines_count;
	if (text_box_y > screen_lines - 2)
		text_box_y = screen_lines - 2;
	max_scroll_y = text_lines_count - text_box_y;
	text_box_x = width;
	if (text_box_x > screen_cols - 2)
		text_box_x = screen_cols - 2;
	max_scroll_x = max_line_width - text_box_x;

	widget_init(&text_widget, text_box_y + 2, text_box_x + 2,
		    SCREEN_CENTER, SCREEN_CENTER, widget_attrs, WIDGET_BORDER);
	mvwprintw(text_widget.window, 0, (text_box_x + 2 - get_mbs_width(title) - 2) / 2, " %s ", title);

	if (current_top > max_scroll_y)
		current_top = max_scroll_y;
	if (current_left > max_scroll_x)
		current_left = max_scroll_x;
	update_text_lines();
	update_y_scroll_bar();
	update_x_scroll_bar();
	return TRUE;
}

static void on_window_size_changed(void)
{
	create();
}

static void on_close(void)
{
	unsigned int i;

	for (i = 0; i < text_lines_count; ++i)
		free(text_lines[i]);
	free(text_lines);
	widget_free(&text_widget);
}

static struct widget text_widget = {
	.handle_key = on_handle_key,
	.window_size_changed = on_window_size_changed,
	.close = on_close,
};

static void create_text_box(const char *const *lines, unsigned int count,
			    const char *title_, int attrs)
{
	unsigned int i;

	text_lines = ccalloc(count, sizeof *text_lines);
	for (i = 0; i < count; ++i)
		text_lines[i] = cstrdup(lines[i]);
	text_lines_count = count;
	max_line_width = get_max_mbs_width(lines, count);
	title = cstrdup(title_);
	widget_attrs = attrs;

	current_top = 0;
	current_left = 0;

	create();
}