239 lines
8.0 KiB
C
239 lines
8.0 KiB
C
#include "tui.h"
|
||
#include <ncurses.h>
|
||
#include <string.h>
|
||
#include <stdlib.h>
|
||
#include <stdbool.h>
|
||
#include <unistd.h>
|
||
#include <fcntl.h>
|
||
#include <ctype.h>
|
||
#include <dirent.h>
|
||
#include <sys/stat.h>
|
||
#include <math.h>
|
||
|
||
/* ---------- FIFO command helper ---------- */
|
||
int send_command(const char *cmd) {
|
||
const char *fifo_path = getenv("LOOPER_CMD_FIFO");
|
||
if (!fifo_path) fifo_path = "/tmp/looper_cmd";
|
||
int fd = open(fifo_path, O_WRONLY | O_NONBLOCK);
|
||
if (fd < 0) return -1;
|
||
size_t len = strlen(cmd);
|
||
int n = write(fd, cmd, len);
|
||
if (n == (int)len && cmd[len-1] != '\n')
|
||
write(fd, "\n", 1);
|
||
close(fd);
|
||
return (n >= 0) ? 0 : -1;
|
||
}
|
||
|
||
/* ---------- Stub functions (no engine) ---------- */
|
||
// Clip states – dummy values used as placeholders
|
||
typedef enum { CLIP_EMPTY, CLIP_RECORDING, CLIP_LOOPING, CLIP_STOPPED } ClipState;
|
||
static const char *clip_state_string(ClipState s) { (void)s; return "?"; }
|
||
|
||
/* Grid dimensions */
|
||
#define GRID_ROWS 8
|
||
#define GRID_COLS 8
|
||
#define NUM_GRIDS 8
|
||
#define CELL_WIDTH 6
|
||
#define CELL_HEIGHT 3
|
||
|
||
/* status FIFO path */
|
||
#define STATUS_FIFO "/tmp/looper_status"
|
||
#define CMD_FIFO "/tmp/looper_cmd"
|
||
|
||
/* Per‑cell state array (indexed by row*GRID_COLS+col) */
|
||
typedef enum { STATE_IDLE, STATE_RECORD, STATE_LOOPING, STATE_PAUSED } ChannelState;
|
||
static ChannelState cell_state[GRID_ROWS * GRID_COLS];
|
||
|
||
/* Color pairs */
|
||
enum {
|
||
COLOR_EMPTY=1, COLOR_RECORDING, COLOR_LOOPING, COLOR_STOPPED,
|
||
COLOR_SELECTED, COLOR_HELP
|
||
};
|
||
|
||
static int selected_row = 0, selected_col = 0;
|
||
static int selected_grid = 0;
|
||
static bool show_help = false;
|
||
|
||
/* Visual mode, marks, yank buffer – keep but only local state */
|
||
static int marks[26];
|
||
typedef struct { int *clip_indices; int count; } YankBuffer;
|
||
static YankBuffer yank_buffer = {NULL, 0};
|
||
typedef enum { MODE_NORMAL, MODE_VISUAL, MODE_MOVE } UIMode;
|
||
static UIMode current_mode = MODE_NORMAL;
|
||
static int visual_start_row, visual_start_col, visual_end_row, visual_end_col;
|
||
|
||
/* Fuzzy search – keep struct but stub carla calls */
|
||
typedef struct {
|
||
char query[256]; int query_len, selected_index, num_results;
|
||
int result_indices[256]; bool active; char prompt[64];
|
||
void (*callback)(const char *);
|
||
const char **items; int num_items; bool free_items;
|
||
} FuzzySearch;
|
||
static FuzzySearch fuzzy_search = {0};
|
||
|
||
/* ---------- Parse status line from engine status FIFO ---------- */
|
||
bool parse_status_line(const char *line, int *ch, int *scene, ChannelState *state) {
|
||
int sta;
|
||
if (sscanf(line, "CH=%d SC=%d STATE=%d", ch, scene, &sta) == 3) {
|
||
if (sta >= 0 && sta <= 3) {
|
||
*state = (ChannelState)sta;
|
||
return true;
|
||
}
|
||
}
|
||
/* try text-based format */
|
||
char state_str[32];
|
||
if (sscanf(line, "CH=%d SC=%d STATE=%31s", ch, scene, state_str) != 3)
|
||
return false;
|
||
if (strcmp(state_str, "IDLE") == 0) { *state = STATE_IDLE; return true; }
|
||
if (strcmp(state_str, "RECORD") == 0) { *state = STATE_RECORD; return true; }
|
||
if (strcmp(state_str, "LOOPING") == 0) { *state = STATE_LOOPING; return true; }
|
||
if (strcmp(state_str, "PAUSED") == 0) { *state = STATE_PAUSED; return true; }
|
||
return false;
|
||
}
|
||
|
||
/* ---------- State to color (uses cell_state array) ---------- */
|
||
static int state_to_color(ChannelState s) {
|
||
switch (s) {
|
||
case STATE_IDLE: return COLOR_EMPTY;
|
||
case STATE_RECORD: return COLOR_RECORDING;
|
||
case STATE_LOOPING: return COLOR_LOOPING;
|
||
case STATE_PAUSED: return COLOR_STOPPED;
|
||
default: return COLOR_EMPTY;
|
||
}
|
||
}
|
||
|
||
/* ---------- Draw cell (no AppState) ---------- */
|
||
static void draw_cell(int grid, int row, int col, bool selected) {
|
||
int y = row * CELL_HEIGHT + 3;
|
||
int x = col * CELL_WIDTH + 1;
|
||
int idx = row * GRID_COLS + col;
|
||
ChannelState s = cell_state[idx];
|
||
int color = selected ? COLOR_SELECTED : state_to_color(s);
|
||
attron(COLOR_PAIR(color));
|
||
for (int dy=0; dy<CELL_HEIGHT; dy++)
|
||
for (int dx=0; dx<CELL_WIDTH; dx++)
|
||
mvaddch(y+dy, x+dx, ' ');
|
||
mvprintw(y+1, x+1, "%2d", grid*GRID_ROWS*GRID_COLS + row*GRID_COLS + col);
|
||
attroff(COLOR_PAIR(color));
|
||
}
|
||
|
||
static void draw_grid(void) {
|
||
clear();
|
||
attron(A_BOLD);
|
||
mvprintw(0,0,"JACK Looper - Client (FIFO only)");
|
||
attroff(A_BOLD);
|
||
for (int r=0; r<GRID_ROWS; r++)
|
||
for (int c=0; c<GRID_COLS; c++)
|
||
draw_cell(selected_grid, r, c, r==selected_row && c==selected_col);
|
||
mvprintw(GRID_ROWS*CELL_HEIGHT+3, 0, "Selected: Grid %d, Row %d, Col %d",
|
||
selected_grid, selected_row, selected_col);
|
||
if (show_help) {
|
||
attron(COLOR_PAIR(COLOR_HELP));
|
||
mvprintw(GRID_ROWS*CELL_HEIGHT+4, 0, "Help: h/j/k/l navigate, t record, d/D stop, s/S scene, a add, A add_midi, r remove, b bind, u unbind, ? help, Esc/Q quit");
|
||
attroff(COLOR_PAIR(COLOR_HELP));
|
||
}
|
||
refresh();
|
||
}
|
||
|
||
/* ---------- TUI init ---------- */
|
||
void tui_init(void) {
|
||
initscr();
|
||
cbreak(); noecho(); keypad(stdscr, TRUE); curs_set(0);
|
||
if (!has_colors()) { endwin(); fprintf(stderr,"No colors\n"); exit(1); }
|
||
start_color();
|
||
init_pair(COLOR_EMPTY, COLOR_WHITE, COLOR_BLACK);
|
||
init_pair(COLOR_RECORDING, COLOR_RED, COLOR_BLACK);
|
||
init_pair(COLOR_LOOPING, COLOR_GREEN, COLOR_BLACK);
|
||
init_pair(COLOR_STOPPED, COLOR_BLUE, COLOR_BLACK);
|
||
init_pair(COLOR_SELECTED, COLOR_BLACK, COLOR_CYAN);
|
||
init_pair(COLOR_HELP, COLOR_CYAN, COLOR_BLACK);
|
||
for (int i=0;i<26;i++) marks[i] = -1;
|
||
/* initialise cell states to idle */
|
||
for (int i = 0; i < GRID_ROWS * GRID_COLS; i++)
|
||
cell_state[i] = STATE_IDLE;
|
||
}
|
||
|
||
/* ---------- TUI run ---------- */
|
||
void tui_run(void) {
|
||
draw_grid();
|
||
while (1) {
|
||
/* read any available status lines */
|
||
int fd = open(STATUS_FIFO, O_RDONLY | O_NONBLOCK);
|
||
if (fd >= 0) {
|
||
char buf[256];
|
||
int n = read(fd, buf, sizeof(buf)-1);
|
||
if (n > 0) {
|
||
buf[n] = '\0';
|
||
char *line = buf;
|
||
while (*line) {
|
||
char *nl = strchr(line, '\n');
|
||
if (nl) *nl = '\0';
|
||
int ch, sc;
|
||
ChannelState st;
|
||
if (parse_status_line(line, &ch, &sc, &st)) {
|
||
if (ch >= 0 && ch < GRID_ROWS * GRID_COLS)
|
||
cell_state[ch] = st;
|
||
}
|
||
if (nl) {
|
||
*nl = '\n';
|
||
line = nl + 1;
|
||
} else break;
|
||
}
|
||
}
|
||
close(fd);
|
||
}
|
||
int chc = getch();
|
||
switch (chc) {
|
||
case 'h': case KEY_LEFT: selected_col = (selected_col-1+GRID_COLS)%GRID_COLS; break;
|
||
case 'j': case KEY_DOWN: selected_row = (selected_row+1)%GRID_ROWS; break;
|
||
case 'k': case KEY_UP: selected_row = (selected_row-1+GRID_ROWS)%GRID_ROWS; break;
|
||
case 'l': case KEY_RIGHT: selected_col = (selected_col+1)%GRID_COLS; break;
|
||
case 't': {
|
||
char cmd[32];
|
||
snprintf(cmd, sizeof(cmd), "record %d\n", selected_col);
|
||
send_command(cmd);
|
||
break;
|
||
}
|
||
case 's':
|
||
send_command("scene_next\n");
|
||
break;
|
||
case 'S':
|
||
send_command("scene_prev\n");
|
||
break;
|
||
case 'd': case 'D':
|
||
send_command("stop\n");
|
||
break;
|
||
case 'a':
|
||
send_command("add\n");
|
||
break;
|
||
case 'A':
|
||
send_command("add_midi\n");
|
||
break;
|
||
case 'r':
|
||
send_command("remove\n");
|
||
break;
|
||
case 'b': {
|
||
char cmd[16];
|
||
snprintf(cmd, sizeof(cmd), "bind %d\n", selected_col);
|
||
send_command(cmd);
|
||
break;
|
||
}
|
||
case 'u':
|
||
send_command("unbind\n");
|
||
break;
|
||
case '?': show_help = !show_help; break;
|
||
case 27: case 'Q': return;
|
||
default: break;
|
||
}
|
||
draw_grid();
|
||
}
|
||
}
|
||
|
||
void tui_cleanup(void) {
|
||
if (yank_buffer.clip_indices) free(yank_buffer.clip_indices);
|
||
/* delete FIFOs */
|
||
unlink(STATUS_FIFO);
|
||
unlink(CMD_FIFO);
|
||
curs_set(1); endwin();
|
||
}
|