395 lines
9.3 KiB
C
395 lines
9.3 KiB
C
// SPDX-FileCopyrightText: 2022 Geoffrey D. Bennett <g@b4.vu>
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
#include "alsa.h"
|
|
#include "routing-lines.h"
|
|
|
|
// dotted dash when a sink is going to be removed by a drag
|
|
static const double dash_dotted[] = { 1, 10 };
|
|
|
|
// dash when dragging and not connected
|
|
static const double dash[] = { 4 };
|
|
|
|
static void choose_line_colour(
|
|
struct routing_src *r_src,
|
|
struct routing_snk *r_snk,
|
|
double *r,
|
|
double *g,
|
|
double *b
|
|
) {
|
|
// left channels have odd numbers
|
|
// right channels have even numbers
|
|
int odd_src = r_src->lr_num & 1;
|
|
int odd_snk = r_snk->elem->lr_num & 1;
|
|
|
|
// for colouring, pair channels up
|
|
// 0 for odd pairs, 1 for even pairs
|
|
int src2 = ((r_src->lr_num - 1) / 2 & 1);
|
|
int snk2 = ((r_snk->elem->lr_num - 1) / 2 & 1);
|
|
|
|
// left -> left, black
|
|
if (odd_src && odd_snk) {
|
|
*r = 0;
|
|
*g = 0;
|
|
*b = 0;
|
|
|
|
// right -> right, red
|
|
} else if (!odd_src && !odd_snk) {
|
|
*r = 1;
|
|
*g = 0;
|
|
*b = 0;
|
|
|
|
// left -> right, dark green
|
|
} else if (odd_src) {
|
|
*r = 0;
|
|
*g = 0.25;
|
|
*b = 0;
|
|
|
|
// right -> left, dark brown/olive
|
|
} else {
|
|
*r = 0.25;
|
|
*g = 0.25;
|
|
*b = 0;
|
|
}
|
|
|
|
// mix <-> non-mix, add blue
|
|
if ((r_src->port_category == PC_MIX) !=
|
|
(r_snk->port_category == PC_MIX)) {
|
|
*b = 0.5;
|
|
}
|
|
|
|
// even input pairs, lighten red and green components
|
|
if (src2) {
|
|
*r = (*r + 1) / 2;
|
|
*g = (*g + 1) / 2;
|
|
}
|
|
|
|
// even output pairs, lighten blue component
|
|
if (snk2) {
|
|
*b = (*b + 1) / 2;
|
|
}
|
|
}
|
|
|
|
// draw a bezier curve given the end and control points
|
|
static void curve(
|
|
cairo_t *cr,
|
|
double x1,
|
|
double y1,
|
|
double x2,
|
|
double y2,
|
|
double x3,
|
|
double y3,
|
|
double x4,
|
|
double y4
|
|
) {
|
|
cairo_move_to(cr, x1, y1);
|
|
cairo_curve_to(cr, x2, y2, x3, y3, x4, y4);
|
|
}
|
|
|
|
// given the bezier end & control points and t-value, return the
|
|
// position and tangent angle at that point
|
|
static void point_and_angle_on_bezier(
|
|
double x1,
|
|
double y1,
|
|
double x2,
|
|
double y2,
|
|
double x3,
|
|
double y3,
|
|
double x4,
|
|
double y4,
|
|
double t,
|
|
double *x,
|
|
double *y,
|
|
double *a
|
|
) {
|
|
double t2 = t * t;
|
|
double t3 = t2 * t;
|
|
double ti = 1 - t;
|
|
double ti2 = ti * ti;
|
|
|
|
*x = x1 +
|
|
(-x1 * 3 + t * (3 * x1 - x1 * t)) * t +
|
|
(3 * x2 + t * (-6 * x2 + x2 * 3 * t)) * t +
|
|
(x3 * 3 - x3 * 3 * t) * t2 +
|
|
x4 * t3;
|
|
*y = y1 +
|
|
(-y1 * 3 + t * (3 * y1 - y1 * t)) * t +
|
|
(3 * y2 + t * (-6 * y2 + y2 * 3 * t)) * t +
|
|
(y3 * 3 - y3 * 3 * t) * t2 +
|
|
y4 * t3;
|
|
|
|
double dx = ti2 * (x2 - x1) +
|
|
2 * ti * t * (x3 - x2) +
|
|
t2 * (x4 - x3);
|
|
double dy = ti2 * (y2 - y1) +
|
|
2 * ti * t * (y3 - y2) +
|
|
t2 * (y4 - y3);
|
|
*a = atan2(dy, dx);
|
|
}
|
|
|
|
// draw an arrow in the middle of the line drawn by curve()
|
|
static void arrow(
|
|
cairo_t *cr,
|
|
double x1,
|
|
double y1,
|
|
double x2,
|
|
double y2,
|
|
double x3,
|
|
double y3,
|
|
double x4,
|
|
double y4
|
|
) {
|
|
// get midpoint and angle
|
|
double mx, my, a;
|
|
point_and_angle_on_bezier(x1, y1, x2, y2, x3, y3, x4, y4, 0.5, &mx, &my, &a);
|
|
|
|
// calculate point of arrow
|
|
double px = mx + cos(a) * 12;
|
|
double py = my + sin(a) * 12;
|
|
|
|
// calculate sides of arrow
|
|
double s1x = mx + cos(a - M_PI_2) * 2;
|
|
double s1y = my + sin(a - M_PI_2) * 2;
|
|
double s2x = mx + cos(a + M_PI_2) * 2;
|
|
double s2y = my + sin(a + M_PI_2) * 2;
|
|
|
|
// draw triangle
|
|
cairo_move_to(cr, px, py);
|
|
cairo_line_to(cr, s1x, s1y);
|
|
cairo_line_to(cr, s2x, s2y);
|
|
cairo_close_path(cr);
|
|
}
|
|
|
|
// draw a nice curved line connecting a source at (x1, y1) and a sink
|
|
// at (x2, y2)
|
|
static void draw_connection(
|
|
cairo_t *cr,
|
|
double x1,
|
|
double y1,
|
|
int src_is_mixer,
|
|
double x2,
|
|
double y2,
|
|
int snk_is_mixer,
|
|
double r,
|
|
double g,
|
|
double b,
|
|
double w
|
|
) {
|
|
double x3 = x1, y3 = y1, x4 = x2, y4 = y2;
|
|
|
|
// vertical/horizontal?
|
|
if (src_is_mixer == snk_is_mixer) {
|
|
double f1 = 0.3;
|
|
double f2 = 1 - f1;
|
|
|
|
// vertical
|
|
if (src_is_mixer) {
|
|
y3 = y1 * f2 + y2 * f1;
|
|
y4 = y1 * f1 + y2 * f2;
|
|
|
|
// horizontal
|
|
} else {
|
|
x3 = x1 * f2 + x2 * f1;
|
|
x4 = x1 * f1 + x2 * f2;
|
|
}
|
|
|
|
// diagonal
|
|
} else {
|
|
// calculate a fraction f1 close to 0 when approaching 45°
|
|
// and close to 0.5 when approaching 0°/90°
|
|
double a = fmod((atan2(y1 - y2, x2 - x1) * 180 / M_PI) + 360, 360);
|
|
double f1 = fabs(fmod(a, 90) - 45) / 90;
|
|
double f2 = 1 - f1;
|
|
|
|
// bottom to right
|
|
if (src_is_mixer) {
|
|
y3 = y1 * f2 + y2 * f1;
|
|
x4 = x1 * f1 + x2 * f2;
|
|
|
|
// left to top
|
|
} else {
|
|
x3 = x1 * f2 + x2 * f1;
|
|
y4 = y1 * f1 + y2 * f2;
|
|
}
|
|
}
|
|
|
|
cairo_set_source_rgb(cr, r, g, b);
|
|
cairo_set_line_width(cr, w);
|
|
curve(cr, x1, y1, x3, y3, x4, y4, x2, y2);
|
|
arrow(cr, x1, y1, x3, y3, x4, y4, x2, y2);
|
|
cairo_stroke(cr);
|
|
}
|
|
|
|
// locate the center of a widget in the parent coordinates
|
|
// used for drawing lines to/from the "socket" widget of routing
|
|
// sources and sinks
|
|
static void get_widget_center(
|
|
GtkWidget *w,
|
|
GtkWidget *parent,
|
|
double *x,
|
|
double *y
|
|
) {
|
|
double src_x = gtk_widget_get_allocated_width(w) / 2;
|
|
double src_y = gtk_widget_get_allocated_height(w) / 2;
|
|
gtk_widget_translate_coordinates(w, parent, src_x, src_y, x, y);
|
|
}
|
|
|
|
static void get_src_center(
|
|
struct routing_src *r_src,
|
|
GtkWidget *parent,
|
|
double *x,
|
|
double *y
|
|
) {
|
|
get_widget_center(r_src->widget2, parent, x, y);
|
|
if (r_src->port_category == PC_MIX)
|
|
(*y)++;
|
|
}
|
|
|
|
static void get_snk_center(
|
|
struct routing_snk *r_snk,
|
|
GtkWidget *parent,
|
|
double *x,
|
|
double *y
|
|
) {
|
|
get_widget_center(r_snk->elem->widget2, parent, x, y);
|
|
if (r_snk->port_category == PC_MIX)
|
|
(*y)++;
|
|
}
|
|
|
|
// redraw the overlay lines between the routing sources and sinks
|
|
void draw_routing_lines(
|
|
GtkDrawingArea *drawing_area,
|
|
cairo_t *cr,
|
|
int width,
|
|
int height,
|
|
void *user_data
|
|
) {
|
|
struct alsa_card *card = user_data;
|
|
GtkWidget *parent = card->routing_lines;
|
|
|
|
cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
|
|
|
|
int dragging = card->drag_type != DRAG_TYPE_NONE;
|
|
|
|
// go through all the routing sinks
|
|
for (int i = 0; i < card->routing_snks->len; i++) {
|
|
struct routing_snk *r_snk = &g_array_index(
|
|
card->routing_snks, struct routing_snk, i
|
|
);
|
|
|
|
// if dragging and a routing sink is being reconnected then draw
|
|
// it with dots
|
|
int dragging_this = dragging && card->snk_drag == r_snk;
|
|
if (dragging_this)
|
|
cairo_set_dash(cr, dash_dotted, 2, 0);
|
|
else
|
|
cairo_set_dash(cr, NULL, 0, 0);
|
|
|
|
// get the sink and skip if it's "Off"
|
|
int r_src_idx = alsa_get_elem_value(r_snk->elem);
|
|
if (!r_src_idx)
|
|
continue;
|
|
|
|
// look up the source
|
|
struct routing_src *r_src = &g_array_index(
|
|
card->routing_srcs, struct routing_src, r_src_idx
|
|
);
|
|
|
|
// locate the source and sink coordinates
|
|
double x1, y1, x2, y2;
|
|
get_src_center(r_src, parent, &x1, &y1);
|
|
get_snk_center(r_snk, parent, &x2, &y2);
|
|
|
|
// pick a colour
|
|
double r, g, b;
|
|
choose_line_colour(r_src, r_snk, &r, &g, &b);
|
|
|
|
// make the colour lighter if it's being shown dotted
|
|
if (dragging_this) {
|
|
r = (r + 1) / 2;
|
|
g = (g + 1) / 2;
|
|
b = (b + 1) / 2;
|
|
}
|
|
|
|
// draw the connection
|
|
draw_connection(
|
|
cr,
|
|
x1, y1, r_src->port_category == PC_MIX,
|
|
x2, y2, r_snk->port_category == PC_MIX,
|
|
r, g, b, 2
|
|
);
|
|
}
|
|
}
|
|
|
|
// draw the overlay dragging line
|
|
void draw_drag_line(
|
|
GtkDrawingArea *drawing_area,
|
|
cairo_t *cr,
|
|
int width,
|
|
int height,
|
|
void *user_data
|
|
) {
|
|
struct alsa_card *card = user_data;
|
|
GtkWidget *parent = card->drag_line;
|
|
|
|
// if not dragging or routing src & snk not specified or drag out of
|
|
// bounds then do nothing
|
|
if (card->drag_type == DRAG_TYPE_NONE ||
|
|
(!card->src_drag && !card->snk_drag) ||
|
|
card->drag_x < 0 ||
|
|
card->drag_y < 0)
|
|
return;
|
|
|
|
// the drag mouse position is relative to card->routing_grid
|
|
// translate it to the overlay card->drag_line
|
|
// (don't need to do this if both src_drag and snk_drag are set)
|
|
double drag_x, drag_y;
|
|
if (!card->src_drag || !card->snk_drag)
|
|
gtk_widget_translate_coordinates(
|
|
card->routing_grid, parent,
|
|
card->drag_x, card->drag_y,
|
|
&drag_x, &drag_y
|
|
);
|
|
|
|
// get the line start position; either a routing source socket
|
|
// widget or the drag mouse position
|
|
double x1, y1;
|
|
if (card->src_drag) {
|
|
get_src_center(card->src_drag, parent, &x1, &y1);
|
|
} else {
|
|
x1 = drag_x;
|
|
y1 = drag_y;
|
|
}
|
|
|
|
// get the line end position; either a routing sink socket widget or
|
|
// the drag mouse position
|
|
double x2, y2;
|
|
if (card->snk_drag) {
|
|
get_snk_center(card->snk_drag, parent, &x2, &y2);
|
|
} else {
|
|
x2 = drag_x;
|
|
y2 = drag_y;
|
|
}
|
|
|
|
// if routing src & snk both specified then draw a curved line as if
|
|
// it was connected (except black)
|
|
if (card->src_drag && card->snk_drag) {
|
|
draw_connection(
|
|
cr,
|
|
x1, y1, card->src_drag->port_category == PC_MIX,
|
|
x2, y2, card->snk_drag->port_category == PC_MIX,
|
|
0, 0, 0, 2
|
|
);
|
|
|
|
// otherwise draw a straight line
|
|
} else {
|
|
cairo_set_dash(cr, dash, 1, 0);
|
|
|
|
cairo_set_source_rgb(cr, 0, 0, 0);
|
|
cairo_set_line_width(cr, 2);
|
|
cairo_move_to(cr, x1, y1);
|
|
cairo_line_to(cr, x2, y2);
|
|
cairo_stroke(cr);
|
|
}
|
|
}
|