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 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; } */ }
bool lash::process_events() { lash_event_t *ev = NULL; // Process events while ((ev = lash_get_event(m_client)) != NULL) { handle_event(ev); lash_event_destroy(ev); } return true; }
/** 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 ); } }
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; }
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; }