gboolean idle_cb(gpointer data)
{
lash_client_t *lash_client = (lash_client_t *)data;
lash_event_t *event;
lash_config_t *config;
while ((event = lash_get_event(lash_client))) {
if (lash_event_get_type(event) == LASH_Save_Data_Set) {
/* we can ignore this as timemachine has no state thats not on the
* command line */
} else if (lash_event_get_type(event) == LASH_Quit) {
cleanup();
} else {
DEBUG(0, "unhandled LASH event: type %d, '%s''\n",
lash_event_get_type(event),
lash_event_get_string(event));
}
}
while ((config = lash_get_config(lash_client))) {
DEBUG(0, "got unexpected LASH config: %s\n",
lash_config_get_key(config));
}
usleep(10000);
return TRUE;
}
static gboolean
lash_callback(gpointer notused)
{
lash_event_t * event;
while ((event = lash_get_event(lash_client)))
{
switch (lash_event_get_type(event))
{
case LASH_Restore_Data_Set:
case LASH_Save_Data_Set:
break;
case LASH_Quit:
g_warning("Exiting due to LASH request.");
ctrl_c_pressed = 1;
break;
default:
g_warning
(
"Received unknown LASH event of type %d.",
lash_event_get_type(event)
);
lash_event_destroy(event);
}
}
return TRUE;
}
void
lash::handle_event(lash_event_t* ev)
{
LASH_Event_Type type = lash_event_get_type(ev);
const char *c_str = lash_event_get_string(ev);
std::string str = (c_str == NULL) ? "" : c_str;
if (type == LASH_Save_File)
{
midifile f(str + "/seq32.mid");
f.write(m_perform, c_no_export_sequence);
lash_send_event(m_client, lash_event_new_with_type(LASH_Save_File));
}
else if (type == LASH_Restore_File)
{
midifile f(str + "/seq32.mid");
f.parse(m_perform, m_mainwnd, 0 );
lash_send_event(m_client, lash_event_new_with_type(LASH_Restore_File));
}
else if (type == LASH_Quit)
{
m_client = NULL;
Gtk::Main::quit();
}
else
{
fprintf(stderr, "Warning: Unhandled LASH event.\n");
}
}
//==============================================================================
void LashManager::timerCallback()
{
if (! client || ! filter)
return;
lash_event_t* event;
while ((event = lash_get_event ((lash_client_t*) client)) != 0)
{
String eventString (lash_event_get_string (event));
switch (lash_event_get_type (event))
{
case LASH_Save_File:
printf ("Asked to save data in %s\n", (const char*) eventString);
saveState (File (eventString + "/" + filter->getName () + ".lash"));
lash_send_event ((lash_client_t*) client, lash_event_new_with_type (LASH_Save_File));
break;
case LASH_Restore_File:
printf ("Asked to restore data from %s\n", (const char*) eventString);
loadState (File (eventString + "/" + filter->getName () + ".lash"));
lash_send_event ((lash_client_t*) client, lash_event_new_with_type (LASH_Restore_File));
break;
case LASH_Quit:
printf ("Asked to quit !\n");
stopTimer ();
break;
case LASH_Server_Lost:
printf ("Server lost !\n");
stopTimer ();
lash_event_destroy (event);
return;
default:
printf("Got unhandled LADCCA event\n");
break;
}
lash_event_destroy (event);
}
/*
while ((config = lash_get_config(client)) != 0)
{
printf ("Unexpected LASH config: %s\n", lash_config_get_key(config));
lash_config_free(config);
free(config);
config = 0;
}
*/
}
int lash_pollevent()
{
if (!lash_enabled(lash_client))
return -1;
lash_event_t *event;
char *l_path;
while (event = lash_get_event(lash_client)) {
if (lash_event_get_type(event) == LASH_Save_File) {
lash_buffer = (char *)lash_event_get_string(event);
l_path = (char *)malloc(strlen(lash_buffer) + 13);
sprintf(l_path, "%s/phasex.phx", lash_buffer);
save_patch(l_path, 0);
sprintf(l_path, "%s/phasex.map", lash_buffer);
save_midimap(l_path);
lash_send_event(lash_client, lash_event_new_with_type(LASH_Save_File));
free(l_path);
break;
}
else if (lash_event_get_type(event) == LASH_Restore_File) {
lash_buffer = (char *)lash_event_get_string(event);
l_path = (char *)malloc(strlen(lash_buffer) + 13);
sprintf(l_path, "%s/phasex.phx", lash_buffer);
read_patch(l_path, 0);
sprintf(l_path, "%s/phasex.map", lash_buffer);
read_midimap(l_path);
lash_send_event(lash_client, lash_event_new_with_type(LASH_Restore_File));
free(l_path);
break;
}
else if (lash_event_get_type(event) == LASH_Quit) {
shutdown = 1;
break;
}
lash_event_destroy(event);
}
return 0;
}
/** process any queued events */
void
Lash::process ( void )
{
lash_event_t *e;
char *name;
while ( ( e = lash_get_event( _client ) ) )
{
asprintf( &name, "%s/%s", lash_event_get_string( e ), "song.non" );
const int t = lash_event_get_type ( e );
switch ( t )
{
case LASH_Save_File:
{
MESSAGE( "LASH wants us to save \"%s\"", name );
save_song( name );
lash_send_event( _client, lash_event_new_with_type( LASH_Save_File ) );
break;
}
case LASH_Restore_File:
{
MESSAGE( "LASH wants us to load \"%s\"", name );
if ( ! load_song( name ) )
/* FIXME: should we tell lash that we couldn't load the song? */;
lash_send_event( _client, lash_event_new_with_type( LASH_Restore_File ) );
break;
}
case LASH_Quit:
MESSAGE( "LASH wants us to quit" );
quit();
break;
default:
WARNING( "unhandled LASH event (%d)", t );
}
lash_event_destroy( e );
}
}
static void *
fluid_lash_run (void * data)
{
lash_event_t * event;
lash_config_t * config;
fluid_synth_t * synth;
int done = 0;
int err;
int pending_restores = 0;
synth = (fluid_synth_t *) data;
while (!done)
{
while ( (event = lash_get_event (fluid_lash_client)) )
{
switch (lash_event_get_type (event))
{
case LASH_Save_Data_Set:
fluid_lash_save (synth);
lash_send_event (fluid_lash_client, event);
break;
case LASH_Restore_Data_Set:
lash_event_destroy (event);
break;
case LASH_Quit:
err = kill (getpid(), SIGQUIT);
if (err)
fprintf (stderr, "%s: error sending signal: %s",
__FUNCTION__, strerror (errno));
lash_event_destroy (event);
done = 1;
break;
case LASH_Server_Lost:
lash_event_destroy (event);
done = 1;
break;
default:
fprintf (stderr, "Recieved unknown LASH event of type %d\n", lash_event_get_type (event));
lash_event_destroy (event);
break;
}
}
while ( (config = lash_get_config (fluid_lash_client)) )
{
if (strcmp (lash_config_get_key (config), "soundfont count") == 0)
pending_restores = lash_config_get_value_int (config);
else
{
fluid_lash_load (synth, lash_config_get_value_string (config));
pending_restores--;
}
lash_config_destroy (config);
if (!pending_restores)
{
event = lash_event_new_with_type (LASH_Restore_Data_Set);
lash_send_event (fluid_lash_client, event);
}
}
usleep (10000);
}
return NULL;
}
