335 lines
16 KiB
C++
335 lines
16 KiB
C++
#include "../../src/gui/main_window.hpp"
|
|
#include "../../src/gui/graph_widget.hpp"
|
|
#include "../../src/gui/sequencer_widget.hpp"
|
|
#include <unistd.h>
|
|
#include <FL/Fl.H>
|
|
#include <FL/Fl_Box.H>
|
|
#include <FL/Fl_Button.H>
|
|
#include <FL/Fl_Group.H>
|
|
#include <FL/Fl_Menu_Bar.H>
|
|
#include <FL/Fl_Tabs.H>
|
|
#include <chrono>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <cmath>
|
|
#include <initializer_list>
|
|
|
|
/* Fake only the public C backend boundary. Real FLTK widgets, callbacks and
|
|
* timers run under Xvfb; no server/device is required or touched. */
|
|
struct xtc_backend { int running = 0; xtc_plan *plan = nullptr; };
|
|
namespace {
|
|
xtc_backend handle;
|
|
xtc_result open_result = XTC_OK, start_result = XTC_OK, stop_result = XTC_OK, close_result = XTC_OK;
|
|
xtc_result status_result = XTC_OK, submit_result = XTC_OK;
|
|
unsigned int submissions = 0U;
|
|
xtc_backend_status engine_status = {};
|
|
bool partial_open = false;
|
|
unsigned int opens = 0, starts = 0, stops = 0, closes = 0, collects = 0, alive = 0;
|
|
int failures = 0;
|
|
#define CHECK(c) do { if (!(c)) { std::fprintf(stderr,"FAIL %s:%d: %s\n",__FILE__,__LINE__,#c); ++failures; } } while (0)
|
|
void pump()
|
|
{
|
|
const auto end = std::chrono::steady_clock::now() + std::chrono::milliseconds(180);
|
|
while (std::chrono::steady_clock::now() < end) Fl::wait(0.02);
|
|
}
|
|
Fl_Widget *find(Fl_Group *group, const char *label)
|
|
{
|
|
for (int i = 0; i < group->children(); ++i) {
|
|
Fl_Widget *child = group->child(i);
|
|
if (child->label() != nullptr && std::strcmp(child->label(), label) == 0) return child;
|
|
auto *nested = dynamic_cast<Fl_Group *>(child);
|
|
if (nested != nullptr) if (auto *match = find(nested, label)) return match;
|
|
}
|
|
return nullptr;
|
|
}
|
|
bool contains(Fl_Group *group, const char *text)
|
|
{
|
|
for (int i = 0; i < group->children(); ++i) {
|
|
Fl_Widget *child = group->child(i);
|
|
if (child->label() != nullptr && std::strstr(child->label(), text) != nullptr) return true;
|
|
if (auto *nested = dynamic_cast<Fl_Group *>(child)) if (contains(nested, text)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
SequencerWidget *timeline(Fl_Group *group)
|
|
{
|
|
for (int i = 0; i < group->children(); ++i) {
|
|
if (auto *s = dynamic_cast<SequencerWidget *>(group->child(i))) return s;
|
|
if (auto *g = dynamic_cast<Fl_Group *>(group->child(i))) if (auto *s = timeline(g)) return s;
|
|
}
|
|
return nullptr;
|
|
}
|
|
void gesture(SequencerWidget *s, int left, int top, int dx, int dy)
|
|
{
|
|
int old_x = Fl::e_x, old_y = Fl::e_y, old_key = Fl::e_keysym;
|
|
Fl::e_x = s->x() + left; Fl::e_y = s->y() + top; Fl::e_keysym = FL_Button + FL_LEFT_MOUSE;
|
|
CHECK(s->handle(FL_PUSH) == 1);
|
|
Fl::e_x += dx; Fl::e_y += dy;
|
|
CHECK(s->handle(FL_DRAG) == 1);
|
|
CHECK(s->handle(FL_RELEASE) == 1);
|
|
Fl::e_x = old_x; Fl::e_y = old_y; Fl::e_keysym = old_key;
|
|
}
|
|
void press(Fl_Widget *widget)
|
|
{
|
|
CHECK(widget != nullptr);
|
|
if (widget != nullptr) widget->do_callback();
|
|
}
|
|
void reset()
|
|
{
|
|
CHECK(alive == 0U);
|
|
open_result = start_result = stop_result = close_result = status_result = XTC_OK;
|
|
submit_result = XTC_OK;
|
|
engine_status = {};
|
|
engine_status.sample_rate = 48000U;
|
|
engine_status.buffer_frames = 1024U;
|
|
partial_open = false;
|
|
}
|
|
}
|
|
extern "C" {
|
|
xtc_result xtc_backend_open(const xtc_backend_config *config, xtc_backend **out)
|
|
{
|
|
CHECK(config->kind == XTC_BACKEND_JACK && config->channel_count == 1U);
|
|
++opens;
|
|
*out = open_result == XTC_OK || partial_open ? &handle : nullptr;
|
|
if (*out != nullptr) { ++alive; handle.running = 0; CHECK(handle.plan == nullptr); engine_status.active_revision = engine_status.submitted_revision = 0U; }
|
|
return open_result;
|
|
}
|
|
xtc_result xtc_backend_close(xtc_backend *backend)
|
|
{
|
|
if (backend == nullptr) return XTC_OK;
|
|
++closes;
|
|
if (close_result == XTC_OK) { CHECK(alive == 1U); --alive; handle.running = 0; xtc_plan_destroy(handle.plan); handle.plan = nullptr; }
|
|
return close_result;
|
|
}
|
|
xtc_result xtc_backend_start(xtc_backend *backend)
|
|
{ CHECK(backend == &handle); ++starts; if (start_result == XTC_OK) handle.running = 1; return start_result; }
|
|
xtc_result xtc_backend_stop(xtc_backend *backend)
|
|
{ CHECK(backend == &handle); ++stops; if (stop_result == XTC_OK) handle.running = 0; return stop_result; }
|
|
xtc_result xtc_backend_get_status(const xtc_backend *backend, xtc_backend_status *status)
|
|
{
|
|
CHECK(backend == &handle && alive == 1U);
|
|
*status = engine_status;
|
|
status->running = handle.running && !status->server_lost;
|
|
return status_result;
|
|
}
|
|
xtc_result xtc_backend_seek(xtc_backend *, uint64_t sample)
|
|
{ engine_status.sample_position = sample; return handle.running ? XTC_ERR_INVALID_STATE : XTC_OK; }
|
|
xtc_result xtc_backend_submit(xtc_backend *backend, const xtc_graph *graph)
|
|
{
|
|
CHECK(backend == &handle && graph != nullptr);
|
|
++submissions;
|
|
if (submit_result != XTC_OK) return submit_result;
|
|
xtc_plan *plan = nullptr;
|
|
xtc_result result = xtc_graph_compile(graph, 48000.0, 32U, &plan);
|
|
if (result != XTC_OK) return result;
|
|
xtc_plan_destroy(handle.plan); handle.plan = plan;
|
|
++engine_status.submitted_revision;
|
|
return XTC_OK;
|
|
}
|
|
void xtc_backend_collect(xtc_backend *backend)
|
|
{ CHECK(backend == &handle && alive == 1U); ++collects; }
|
|
}
|
|
int main(int argc, char **argv)
|
|
{
|
|
reset();
|
|
{
|
|
MainWindow window(false);
|
|
window.show(argc, argv);
|
|
auto *play = find(&window, "Play");
|
|
auto *stop = find(&window, "Stop");
|
|
auto *reconnect = find(&window, "Reconnect");
|
|
CHECK(play != nullptr && stop != nullptr && reconnect != nullptr);
|
|
if (play == nullptr || stop == nullptr || reconnect == nullptr) return 1;
|
|
CHECK(play->active() && !stop->active());
|
|
CHECK(contains(&window, "ready / stopped"));
|
|
press(play);
|
|
CHECK(starts == 1U && !play->active() && stop->active());
|
|
CHECK(contains(&window, "running — modular graph"));
|
|
press(stop);
|
|
CHECK(stops == 1U && play->active() && !stop->active());
|
|
start_result = XTC_ERR_IO;
|
|
press(play);
|
|
CHECK(contains(&window, "Start engine failed: I/O error"));
|
|
pump(); // A refresh must not erase a command error.
|
|
CHECK(contains(&window, "Start engine failed: I/O error"));
|
|
start_result = XTC_OK;
|
|
press(play);
|
|
CHECK(!contains(&window, "Start engine failed"));
|
|
stop_result = XTC_ERR_IO;
|
|
press(stop);
|
|
CHECK(contains(&window, "Stop engine failed") && stop->active());
|
|
stop_result = XTC_OK;
|
|
press(stop);
|
|
Fl_Menu_Bar *menu = nullptr;
|
|
Fl_Tabs *tabs = nullptr;
|
|
for (int i = 0; i < window.children(); ++i) {
|
|
if (auto *found = dynamic_cast<Fl_Menu_Bar *>(window.child(i))) menu = found;
|
|
if (auto *found = dynamic_cast<Fl_Tabs *>(window.child(i))) tabs = found;
|
|
}
|
|
CHECK(menu != nullptr && tabs != nullptr);
|
|
if (menu == nullptr || tabs == nullptr) return 1;
|
|
for (const char *view : {"View/Mixer", "View/Modular Graph", "View/Sequencer"}) {
|
|
const Fl_Menu_Item *item = menu->find_item(view);
|
|
CHECK(item != nullptr);
|
|
if (item != nullptr) {
|
|
menu->picked(item);
|
|
CHECK(std::strcmp(tabs->value()->label(), std::strchr(view, '/') + 1) == 0);
|
|
}
|
|
}
|
|
GraphWidget *canvas = nullptr;
|
|
auto *graph_group = dynamic_cast<Fl_Group *>(find(&window, "Modular Graph"));
|
|
CHECK(graph_group != nullptr);
|
|
if (graph_group != nullptr) {
|
|
for (int i = 0; i < graph_group->children(); ++i) if (auto *scroll = dynamic_cast<Fl_Group *>(graph_group->child(i)))
|
|
for (int j = 0; j < scroll->children(); ++j)
|
|
if (auto *found = dynamic_cast<GraphWidget *>(scroll->child(j))) canvas = found;
|
|
}
|
|
CHECK(canvas != nullptr);
|
|
if (canvas == nullptr) return 1;
|
|
menu->picked(menu->find_item("View/Modular Graph"));
|
|
press(find(&window, "Add oscillator"));
|
|
press(find(&window, "Add gain"));
|
|
press(find(&window, "Add meter"));
|
|
press(find(&window, "Add output"));
|
|
size_t nodes, edges;
|
|
CHECK(xtc_graph_get_counts(canvas->graph(), &nodes, &edges) == XTC_OK && nodes == 4U && edges == 0U);
|
|
CHECK(canvas->connect_ports({0U, 1U, 1U, 0U}) == XTC_OK);
|
|
CHECK(canvas->connect_ports({1U, 1U, 2U, 0U}) == XTC_OK);
|
|
CHECK(canvas->connect_ports({2U, 1U, 3U, 0U}) == XTC_OK);
|
|
float rendered[32];
|
|
CHECK(xtc_plan_process(handle.plan, nullptr, rendered, 32U) == XTC_OK);
|
|
CHECK(std::fabs(rendered[1] - static_cast<float>(std::sin(6.283185307179586 * 440.0 / 48000.0) * 0.1)) < 0.00001f);
|
|
const xtc_graph *before_invalid = canvas->graph();
|
|
unsigned int before_submit = submissions;
|
|
CHECK(canvas->connect_ports({2U, 1U, 1U, 0U}) == XTC_ERR_GRAPH_CYCLE);
|
|
CHECK(canvas->graph() == before_invalid && submissions == before_submit && contains(&window, "graph contains a cycle"));
|
|
CHECK(canvas->connect_ports({1U, 0U, 2U, 0U}) == XTC_ERR_INVALID_ARGUMENT);
|
|
CHECK(canvas->connect_ports({0U, 1U, 1U, 0U}) == XTC_ERR_INVALID_STATE);
|
|
submit_result = XTC_ERR_CAPACITY;
|
|
xtc_plan *before_plan = handle.plan;
|
|
CHECK(canvas->add_node(XTC_NODE_GAIN) == XTC_ERR_CAPACITY);
|
|
CHECK(canvas->graph() == before_invalid && handle.plan == before_plan && contains(&window, "Graph unchanged: capacity"));
|
|
submit_result = XTC_ERR_IO;
|
|
CHECK(canvas->add_node(XTC_NODE_GAIN) == XTC_ERR_IO && canvas->graph() == before_invalid);
|
|
submit_result = XTC_OK;
|
|
CHECK(canvas->select_node(0U) && canvas->move_node(0U, 65, 90));
|
|
CHECK(submissions == before_submit + 2U); // Moving is GUI state, no compilation.
|
|
CHECK(canvas->add_node(XTC_NODE_GAIN) == XTC_OK);
|
|
int left, top;
|
|
CHECK(canvas->node_position(0U, left, top) && left == 65 && top == 90);
|
|
CHECK(canvas->delete_selected() == XTC_OK); // Newly added node.
|
|
CHECK(canvas->select_connection(1U, 2U) && canvas->delete_selected() == XTC_OK);
|
|
CHECK(xtc_plan_process(handle.plan, nullptr, rendered, 32U) == XTC_OK && rendered[1] == 0.0f);
|
|
CHECK(canvas->connect_ports({1U, 1U, 2U, 0U}) == XTC_OK);
|
|
CHECK(canvas->select_node(1U) && canvas->delete_selected() == XTC_OK);
|
|
CHECK(xtc_graph_get_counts(canvas->graph(), &nodes, &edges) == XTC_OK && nodes == 3U && edges == 1U);
|
|
xtc_node_info surviving{};
|
|
CHECK(xtc_graph_get_node(canvas->graph(), 1U, &surviving) == XTC_OK && surviving.id == 2U);
|
|
engine_status.active_revision = engine_status.submitted_revision;
|
|
press(play);
|
|
pump();
|
|
CHECK(contains(&window, "Graph: active in engine"));
|
|
CHECK(canvas->add_node(XTC_NODE_GAIN) == XTC_OK);
|
|
CHECK(contains(&window, "Graph: queued"));
|
|
engine_status.active_revision = engine_status.submitted_revision;
|
|
pump();
|
|
CHECK(contains(&window, "Graph: active in engine"));
|
|
press(stop);
|
|
for (size_t id : {0U, 2U, 3U, 5U}) { CHECK(canvas->select_node(id)); CHECK(canvas->delete_selected() == XTC_OK); }
|
|
CHECK(xtc_graph_get_counts(canvas->graph(), &nodes, &edges) == XTC_OK && nodes == 0U && edges == 0U);
|
|
CHECK(xtc_plan_process(handle.plan, nullptr, rendered, 32U) == XTC_OK && rendered[1] == 0.0f);
|
|
auto *sequence = timeline(&window);
|
|
CHECK(sequence != nullptr);
|
|
char directory[] = "/tmp/xtc-gui-XXXXXX"; CHECK(mkdtemp(directory) != nullptr);
|
|
std::string filename = std::string(directory) + "/song.xtc";
|
|
press(find(&window, "Add track")); press(find(&window, "Add region"));
|
|
size_t track_count, clip_count;
|
|
CHECK(xtc_project_get_counts(sequence->project(), &track_count, &clip_count) == XTC_OK && track_count == 1 && clip_count == 1);
|
|
xtc_clip_info region{};
|
|
CHECK(xtc_project_get_clip(sequence->project(), 0, ®ion) == XTC_OK);
|
|
gesture(sequence, 150, 50, 144, 0); // Move by three beats.
|
|
gesture(sequence, 265, 50, 48, 0); // Trim left edge by one beat.
|
|
CHECK(xtc_project_get_clip(sequence->project(), 0, ®ion) == XTC_OK &&
|
|
region.start_tick == 3840 && region.length_tick == 2880 && region.offset_tick == 960);
|
|
int width = sequence->w();
|
|
press(find(&window, "Zoom +")); CHECK(sequence->w() > width);
|
|
press(find(&window, "Zoom -")); CHECK(sequence->w() == width);
|
|
CHECK(window.save_project(filename.c_str()) == XTC_OK);
|
|
const xtc_project *retained = sequence->project();
|
|
CHECK(window.open_project("/missing/xtc-project") == XTC_ERR_IO && sequence->project() == retained);
|
|
submit_result = XTC_ERR_CAPACITY;
|
|
CHECK(window.open_project(filename.c_str()) == XTC_ERR_CAPACITY && sequence->project() == retained);
|
|
submit_result = XTC_OK;
|
|
press(find(&window, "Delete region/track"));
|
|
CHECK(window.open_project(filename.c_str()) == XTC_OK);
|
|
CHECK(xtc_project_get_clip(sequence->project(), 0, ®ion) == XTC_OK && region.start_tick == 3840 && region.offset_tick == 960);
|
|
engine_status.sample_position = 48000; pump();
|
|
CHECK(sequence->position() == 1920);
|
|
CHECK(canvas->add_node(XTC_NODE_GAIN) == XTC_OK);
|
|
CHECK(sequence->position() == 1920); // Graph edits preserve the transport.
|
|
engine_status.sample_position = 0;
|
|
CHECK(unlink(filename.c_str()) == 0 && rmdir(directory) == 0);
|
|
engine_status.xruns = 3U;
|
|
engine_status.processed_blocks = 123U;
|
|
pump();
|
|
CHECK(contains(&window, "123 blocks | 3 xruns"));
|
|
engine_status.sample_rate_changed = 1;
|
|
pump();
|
|
CHECK(contains(&window, "sample rate changed") && !play->active());
|
|
engine_status.sample_rate_changed = 0;
|
|
engine_status.server_lost = 1;
|
|
pump();
|
|
CHECK(contains(&window, "server lost") && !play->active());
|
|
engine_status.server_lost = 0;
|
|
press(reconnect);
|
|
CHECK(contains(&window, "ready / stopped") && play->active());
|
|
status_result = XTC_ERR_IO;
|
|
pump();
|
|
CHECK(contains(&window, "status unavailable") && !play->active());
|
|
status_result = XTC_OK;
|
|
press(reconnect);
|
|
close_result = XTC_ERR_IO;
|
|
press(reconnect);
|
|
CHECK(contains(&window, "Reconnect could not close JACK") && alive == 1U);
|
|
window.do_callback();
|
|
CHECK(window.shown() && alive == 1U && contains(&window, "window kept open for retry"));
|
|
close_result = XTC_OK;
|
|
menu->picked(menu->find_item("File/Quit"));
|
|
CHECK(!window.shown() && alive == 0U);
|
|
unsigned int before = collects;
|
|
pump();
|
|
CHECK(collects == before); // Removed timer cannot call a closed backend.
|
|
}
|
|
for (xtc_result failure : {XTC_ERR_IO, XTC_ERR_UNSUPPORTED}) {
|
|
reset();
|
|
open_result = failure;
|
|
MainWindow window(false);
|
|
window.show(argc, argv);
|
|
CHECK(contains(&window, "Open JACK failed") && !find(&window, "Play")->active());
|
|
open_result = XTC_OK;
|
|
press(find(&window, "Reconnect"));
|
|
CHECK(find(&window, "Play")->active());
|
|
press(find(&window, "Play"));
|
|
window.do_callback(); // Close while running, without a preceding stop.
|
|
CHECK(!window.shown() && alive == 0U);
|
|
}
|
|
reset();
|
|
partial_open = true;
|
|
open_result = XTC_ERR_IO;
|
|
{
|
|
MainWindow window(false);
|
|
CHECK(alive == 1U && !find(&window, "Play")->active());
|
|
window.do_callback(); // Partially initialized handles are closed only.
|
|
CHECK(alive == 0U);
|
|
}
|
|
reset();
|
|
for (int i = 0; i < 10; ++i) {
|
|
MainWindow window(false);
|
|
press(find(&window, "Play"));
|
|
window.do_callback();
|
|
}
|
|
CHECK(alive == 0U);
|
|
if (failures != 0) return 1;
|
|
std::printf("GUI controls/errors/views/timers/cleanup passed: %u opens, %u closes.\n", opens, closes);
|
|
return 0;
|
|
}
|