403 lines
11 KiB
C
403 lines
11 KiB
C
/* $NetBSD: draw.c,v 1.10 2023/06/29 19:06:54 nia Exp $ */
|
|
/*-
|
|
* Copyright (c) 2021 The NetBSD Foundation, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
* by Nia Alarie.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
#include <sys/audioio.h>
|
|
#include <sys/ioctl.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <curses.h>
|
|
#include <err.h>
|
|
#include <stdlib.h>
|
|
#include "draw.h"
|
|
|
|
static int get_enum_color(const char *);
|
|
static void draw_enum(struct aiomixer_control *, int, bool, bool);
|
|
static void draw_set(struct aiomixer_control *, int, bool);
|
|
static void draw_levels(struct aiomixer_control *,
|
|
const struct mixer_level *, bool, bool, bool);
|
|
|
|
void
|
|
draw_mixer_select(unsigned int num_mixers, unsigned int selected_mixer)
|
|
{
|
|
struct audio_device dev;
|
|
char mixer_path[16];
|
|
unsigned int i;
|
|
int fd;
|
|
|
|
mvprintw(0, 0, "Select a mixer device:\n");
|
|
|
|
for (i = 0; i < num_mixers; ++i) {
|
|
(void)snprintf(mixer_path, sizeof(mixer_path),
|
|
"/dev/mixer%d", i);
|
|
fd = open(mixer_path, O_RDWR);
|
|
if (fd == -1)
|
|
break;
|
|
if (ioctl(fd, AUDIO_GETDEV, &dev) < 0) {
|
|
close(fd);
|
|
break;
|
|
}
|
|
close(fd);
|
|
if (selected_mixer == i) {
|
|
attron(A_STANDOUT);
|
|
addstr("[*] ");
|
|
} else {
|
|
addstr("[ ] ");
|
|
}
|
|
printw("%s: %s %s %s\n", mixer_path,
|
|
dev.name, dev.version, dev.config);
|
|
if (selected_mixer == i)
|
|
attroff(A_STANDOUT);
|
|
}
|
|
}
|
|
|
|
void
|
|
draw_control(struct aiomixer *aio,
|
|
struct aiomixer_control *control, bool selected)
|
|
{
|
|
struct mixer_ctrl value;
|
|
|
|
value.dev = control->info.index;
|
|
value.type = control->info.type;
|
|
if (value.type == AUDIO_MIXER_VALUE)
|
|
value.un.value.num_channels = control->info.un.v.num_channels;
|
|
|
|
if (ioctl(aio->fd, AUDIO_MIXER_READ, &value) < 0)
|
|
err(EXIT_FAILURE, "failed to read from mixer device");
|
|
|
|
wclear(control->widgetpad);
|
|
if (selected)
|
|
wattron(control->widgetpad, A_STANDOUT);
|
|
if (value.type == AUDIO_MIXER_VALUE)
|
|
wprintw(control->widgetpad, "%s (%s)\n",
|
|
control->info.label.name, control->info.un.v.units.name);
|
|
else
|
|
wprintw(control->widgetpad, "%s\n", control->info.label.name);
|
|
if (selected)
|
|
wattroff(control->widgetpad, A_STANDOUT);
|
|
|
|
switch (value.type) {
|
|
case AUDIO_MIXER_ENUM:
|
|
draw_enum(control, value.un.ord, selected, aio->use_colour);
|
|
break;
|
|
case AUDIO_MIXER_SET:
|
|
draw_set(control, value.un.mask, aio->use_colour);
|
|
break;
|
|
case AUDIO_MIXER_VALUE:
|
|
draw_levels(control, &value.un.value,
|
|
aio->channels_unlocked, selected, aio->use_colour);
|
|
break;
|
|
}
|
|
|
|
wprintw(control->widgetpad, "\n");
|
|
}
|
|
|
|
void
|
|
draw_screen(struct aiomixer *aio)
|
|
{
|
|
int i, max_y;
|
|
|
|
/* Clear any leftovers if the screen changed. */
|
|
if (aio->widgets_resized) {
|
|
aio->widgets_resized = false;
|
|
max_y = getmaxy(stdscr);
|
|
for (i = 3; i < max_y; ++i) {
|
|
mvprintw(i, 0, "\n");
|
|
}
|
|
}
|
|
|
|
wnoutrefresh(stdscr);
|
|
wnoutrefresh(aio->header);
|
|
wnoutrefresh(aio->classbar);
|
|
max_y = aio->classes[aio->curclass].height + 1;
|
|
max_y -= aio->class_scroll_y;
|
|
if (max_y > (getmaxy(stdscr) - 3))
|
|
max_y = getmaxy(stdscr) - 3;
|
|
pnoutrefresh(aio->classes[aio->curclass].widgetpad,
|
|
aio->class_scroll_y, 0,
|
|
3, 0,
|
|
max_y, getmaxx(stdscr));
|
|
doupdate();
|
|
}
|
|
|
|
static int
|
|
get_enum_color(const char *name)
|
|
{
|
|
if (strcmp(name, AudioNon) == 0) {
|
|
return COLOR_ENUM_ON;
|
|
}
|
|
if (strcmp(name, AudioNoff) == 0) {
|
|
return COLOR_ENUM_OFF;
|
|
}
|
|
|
|
return COLOR_ENUM_MISC;
|
|
}
|
|
|
|
static void
|
|
draw_enum(struct aiomixer_control *control, int ord,
|
|
bool selected, bool colour)
|
|
{
|
|
struct audio_mixer_enum *e;
|
|
int color = COLOR_ENUM_MISC;
|
|
int i;
|
|
|
|
for (i = 0; i < control->info.un.e.num_mem; ++i) {
|
|
e = &control->info.un.e;
|
|
if (ord == e->member[i].ord && selected) {
|
|
if (termattrs() & A_BOLD)
|
|
wattron(control->widgetpad, A_BOLD);
|
|
else
|
|
wattron(control->widgetpad, A_STANDOUT);
|
|
}
|
|
waddch(control->widgetpad, '[');
|
|
if (ord == e->member[i].ord) {
|
|
if (colour) {
|
|
color = get_enum_color(e->member[i].label.name);
|
|
wattron(control->widgetpad,
|
|
COLOR_PAIR(color));
|
|
} else {
|
|
waddch(control->widgetpad, '*');
|
|
}
|
|
}
|
|
wprintw(control->widgetpad, "%s", e->member[i].label.name);
|
|
if (ord == control->info.un.e.member[i].ord) {
|
|
if (colour) {
|
|
wattroff(control->widgetpad,
|
|
COLOR_PAIR(color));
|
|
}
|
|
}
|
|
waddch(control->widgetpad, ']');
|
|
if (ord == e->member[i].ord && selected) {
|
|
if (termattrs() & A_BOLD)
|
|
wattroff(control->widgetpad, A_BOLD);
|
|
else
|
|
wattroff(control->widgetpad, A_STANDOUT);
|
|
}
|
|
if (i != (e->num_mem - 1))
|
|
waddstr(control->widgetpad, ", ");
|
|
}
|
|
waddch(control->widgetpad, '\n');
|
|
}
|
|
|
|
static void
|
|
draw_set(struct aiomixer_control *control, int mask, bool colour)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < control->info.un.s.num_mem; ++i) {
|
|
waddch(control->widgetpad, '[');
|
|
if (mask & control->info.un.s.member[i].mask) {
|
|
if (colour) {
|
|
wattron(control->widgetpad,
|
|
COLOR_PAIR(COLOR_SET_SELECTED));
|
|
}
|
|
waddch(control->widgetpad, '*');
|
|
if (colour) {
|
|
wattroff(control->widgetpad,
|
|
COLOR_PAIR(COLOR_SET_SELECTED));
|
|
}
|
|
} else {
|
|
waddch(control->widgetpad, ' ');
|
|
}
|
|
waddstr(control->widgetpad, "] ");
|
|
if (control->setindex == i) {
|
|
if (termattrs() & A_BOLD)
|
|
wattron(control->widgetpad, A_BOLD);
|
|
else
|
|
wattron(control->widgetpad, A_STANDOUT);
|
|
}
|
|
wprintw(control->widgetpad, "%s",
|
|
control->info.un.s.member[i].label.name);
|
|
if (control->setindex == i) {
|
|
if (termattrs() & A_BOLD)
|
|
wattroff(control->widgetpad, A_BOLD);
|
|
else
|
|
wattroff(control->widgetpad, A_STANDOUT);
|
|
}
|
|
if (i != (control->info.un.s.num_mem - 1))
|
|
waddstr(control->widgetpad, ", ");
|
|
}
|
|
}
|
|
|
|
static void
|
|
draw_levels(struct aiomixer_control *control,
|
|
const struct mixer_level *levels, bool channels_unlocked,
|
|
bool selected, bool colour)
|
|
{
|
|
int i;
|
|
int j, nchars;
|
|
|
|
for (i = 0; i < control->info.un.v.num_channels; ++i) {
|
|
if ((selected && !channels_unlocked) ||
|
|
(control->setindex == i && channels_unlocked)) {
|
|
if (termattrs() & A_BOLD)
|
|
wattron(control->widgetpad, A_BOLD);
|
|
else
|
|
wattron(control->widgetpad, A_STANDOUT);
|
|
}
|
|
wprintw(control->widgetpad, "[%3u/%3u ",
|
|
levels->level[i], AUDIO_MAX_GAIN);
|
|
if (colour) {
|
|
wattron(control->widgetpad,
|
|
COLOR_PAIR(COLOR_LEVELS));
|
|
}
|
|
nchars = (levels->level[i] *
|
|
(getmaxx(control->widgetpad) - 11)) / AUDIO_MAX_GAIN;
|
|
for (j = 0; j < nchars; ++j)
|
|
waddch(control->widgetpad, '*');
|
|
if (colour) {
|
|
wattroff(control->widgetpad,
|
|
COLOR_PAIR(COLOR_LEVELS));
|
|
}
|
|
nchars = getmaxx(control->widgetpad) - 11 - nchars;
|
|
for (j = 0; j < nchars; ++j)
|
|
waddch(control->widgetpad, ' ');
|
|
wprintw(control->widgetpad, "]\n");
|
|
if ((selected && !channels_unlocked) ||
|
|
(control->setindex == i && channels_unlocked)) {
|
|
if (termattrs() & A_BOLD)
|
|
wattroff(control->widgetpad, A_BOLD);
|
|
else
|
|
wattroff(control->widgetpad, A_STANDOUT);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
draw_classbar(struct aiomixer *aio)
|
|
{
|
|
unsigned int i;
|
|
|
|
wmove(aio->classbar, 0, 0);
|
|
|
|
for (i = 0; i < aio->numclasses; ++i) {
|
|
if (aio->curclass == i)
|
|
wattron(aio->classbar, A_STANDOUT);
|
|
wprintw(aio->classbar, "[%u:%s]",
|
|
i + 1, aio->classes[i].name);
|
|
if (aio->curclass == i)
|
|
wattroff(aio->classbar, A_STANDOUT);
|
|
waddch(aio->classbar, ' ');
|
|
}
|
|
|
|
wprintw(aio->classbar, "\n\n");
|
|
}
|
|
|
|
void
|
|
draw_header(struct aiomixer *aio)
|
|
{
|
|
wprintw(aio->header, "\n");
|
|
mvwaddstr(aio->header, 0,
|
|
getmaxx(aio->header) - (int)sizeof("NetBSD audio mixer"),
|
|
"NetBSD audio mixer");
|
|
|
|
if (aio->mixerdev.version[0] != '\0') {
|
|
mvwprintw(aio->header, 0, 0, "%s %s",
|
|
aio->mixerdev.name, aio->mixerdev.version);
|
|
} else {
|
|
mvwprintw(aio->header, 0, 0, "%s", aio->mixerdev.name);
|
|
}
|
|
}
|
|
|
|
void
|
|
create_widgets(struct aiomixer *aio)
|
|
{
|
|
size_t i, j;
|
|
struct aiomixer_class *class;
|
|
struct aiomixer_control *control;
|
|
|
|
aio->header = newwin(1, getmaxx(stdscr), 0, 0);
|
|
if (aio->header == NULL)
|
|
errx(EXIT_FAILURE, "failed to create window");
|
|
|
|
aio->classbar = newwin(2, getmaxx(stdscr), 1, 0);
|
|
if (aio->classbar == NULL)
|
|
errx(EXIT_FAILURE, "failed to create window");
|
|
|
|
for (i = 0; i < aio->numclasses; ++i) {
|
|
class = &aio->classes[i];
|
|
class->height = 0;
|
|
class->widgetpad = newpad(4 * __arraycount(class->controls),
|
|
getmaxx(stdscr));
|
|
if (class->widgetpad == NULL)
|
|
errx(EXIT_FAILURE, "failed to create curses pad");
|
|
for (j = 0; j < class->numcontrols; ++j) {
|
|
control = &class->controls[j];
|
|
switch (control->info.type) {
|
|
case AUDIO_MIXER_VALUE:
|
|
control->height = 2 +
|
|
control->info.un.v.num_channels;
|
|
break;
|
|
case AUDIO_MIXER_ENUM:
|
|
case AUDIO_MIXER_SET:
|
|
control->height = 3;
|
|
break;
|
|
}
|
|
control->widgetpad = subpad(class->widgetpad,
|
|
control->height, getmaxx(stdscr),
|
|
class->height, 0);
|
|
if (control->widgetpad == NULL)
|
|
errx(EXIT_FAILURE, "failed to create curses pad");
|
|
control->widget_y = class->height;
|
|
class->height += control->height;
|
|
}
|
|
wresize(class->widgetpad, class->height, getmaxx(stdscr));
|
|
}
|
|
|
|
aio->last_max_x = getmaxx(stdscr);
|
|
}
|
|
|
|
void
|
|
resize_widgets(struct aiomixer *aio)
|
|
{
|
|
size_t i, j;
|
|
struct aiomixer_class *class;
|
|
struct aiomixer_control *control;
|
|
int max_x;
|
|
|
|
max_x = getmaxx(stdscr);
|
|
|
|
if (aio->last_max_x != max_x) {
|
|
aio->last_max_x = max_x;
|
|
wresize(aio->header, 1, max_x);
|
|
wresize(aio->classbar, 2, max_x);
|
|
|
|
for (i = 0; i < aio->numclasses; ++i) {
|
|
class = &aio->classes[i];
|
|
wresize(class->widgetpad, class->height, max_x);
|
|
for (j = 0; j < class->numcontrols; ++j) {
|
|
control = &class->controls[j];
|
|
wresize(control->widgetpad,
|
|
control->height, max_x);
|
|
}
|
|
}
|
|
}
|
|
|
|
aio->widgets_resized = true;
|
|
}
|