void
ags_devout_connect(AgsConnectable *connectable)
{
AgsDevout *devout;
GList *list;
devout = AGS_DEVOUT(connectable);
list = devout->audio;
while(list != NULL){
ags_connectable_connect(AGS_CONNECTABLE(list->data));
list = list->next;
}
}
void
ags_wave_window_disconnect(AgsConnectable *connectable)
{
AgsWaveWindow *wave_window;
wave_window = AGS_WAVE_WINDOW(connectable);
if((AGS_WAVE_WINDOW_CONNECTED & (wave_window->flags)) == 0){
return;
}
wave_window->flags &= (~AGS_WAVE_WINDOW_CONNECTED);
if(wave_window->wave_editor != NULL){
ags_connectable_disconnect(AGS_CONNECTABLE(wave_window->wave_editor));
}
}
void
ags_xorg_application_context_connect(AgsConnectable *connectable)
{
AgsXorgApplicationContext *xorg_application_context;
xorg_application_context = AGS_XORG_APPLICATION_CONTEXT(connectable);
if((AGS_APPLICATION_CONTEXT_CONNECTED & (AGS_APPLICATION_CONTEXT(xorg_application_context)->flags)) != 0) {
return;
}
ags_xorg_application_context_parent_connectable_interface->connect(connectable);
g_message("connecting gui\0");
ags_connectable_connect(AGS_CONNECTABLE(xorg_application_context->window));
}
void
ags_menu_bar_add_lv2_bridge_callback(GtkWidget *menu_item, AgsMenuBar *menu_bar)
{
AgsWindow *window;
AgsLv2Bridge *lv2_bridge;
AgsAddAudio *add_audio;
AgsThread *main_loop;
AgsTaskThread *task_thread;
AgsApplicationContext *application_context;
window = (AgsWindow *) gtk_widget_get_ancestor((GtkWidget *) menu_bar, AGS_TYPE_WINDOW);
application_context = window->application_context;
main_loop = application_context->main_loop;
task_thread = ags_thread_find_type(main_loop,
AGS_TYPE_TASK_THREAD);
lv2_bridge = ags_lv2_bridge_new(G_OBJECT(window->soundcard),
g_object_get_data(menu_item,
AGS_MENU_BAR_LV2_FILENAME_KEY),
g_object_get_data(menu_item,
AGS_MENU_BAR_LV2_URI_KEY));
add_audio = ags_add_audio_new(window->soundcard,
AGS_MACHINE(lv2_bridge)->audio);
ags_task_thread_append_task(task_thread,
AGS_TASK(add_audio));
gtk_box_pack_start((GtkBox *) window->machines,
(GtkWidget *) lv2_bridge,
FALSE, FALSE, 0);
ags_lv2_bridge_load(lv2_bridge);
ags_connectable_connect(AGS_CONNECTABLE(lv2_bridge));
// lv2_bridge->machine.audio->frequence = ;
lv2_bridge->machine.audio->audio_channels = 2;
ags_audio_set_pads(AGS_MACHINE(lv2_bridge)->audio, AGS_TYPE_INPUT, 1);
ags_audio_set_pads(AGS_MACHINE(lv2_bridge)->audio, AGS_TYPE_OUTPUT, 1);
ags_machine_find_port(AGS_MACHINE(lv2_bridge));
gtk_widget_show_all((GtkWidget *) lv2_bridge);
}
void
ags_synth_input_line_connect(AgsConnectable *connectable)
{
AgsSynthInputLine *synth_input_line;
synth_input_line = AGS_SYNTH_INPUT_LINE(connectable);
if((AGS_LINE_CONNECTED & (AGS_LINE(synth_input_line)->flags)) != 0){
return;
}
ags_synth_input_line_parent_connectable_interface->connect(connectable);
ags_connectable_connect(AGS_CONNECTABLE(synth_input_line->oscillator));
g_signal_connect_after((GObject *) synth_input_line->oscillator, "control-changed",
G_CALLBACK(ags_synth_input_line_oscillator_control_changed_callback), (gpointer) synth_input_line);
}
void
ags_recall_disconnect(AgsConnectable *connectable)
{
AgsRecall *recall;
GList *list;
recall = AGS_RECALL(connectable);
list = recall->children;
while(list != NULL){
ags_connectable_disconnect(AGS_CONNECTABLE(list->data));
list = list->next;
}
recall->flags &= (~AGS_RECALL_CONNECTED);
}
void
ags_menu_action_add_audiorec_callback(GtkWidget *menu_item, gpointer data)
{
AgsWindow *window;
AgsAudiorec *audiorec;
AgsThread *gui_thread;
AgsAddAudio *add_audio;
AgsApplicationContext *application_context;
application_context = ags_application_context_get_instance();
window = (AgsWindow *) ags_ui_provider_get_window(AGS_UI_PROVIDER(application_context));
gui_thread = ags_ui_provider_get_gui_thread(AGS_UI_PROVIDER(application_context));
/* create audiorec */
audiorec = ags_audiorec_new(G_OBJECT(window->soundcard));
add_audio = ags_add_audio_new((AgsApplicationContext *) window->application_context,
AGS_MACHINE(audiorec)->audio);
ags_gui_thread_schedule_task((AgsGuiThread *) gui_thread,
(GObject *) add_audio);
gtk_box_pack_start((GtkBox *) window->machines,
(GtkWidget *) audiorec,
FALSE, FALSE,
0);
ags_connectable_connect(AGS_CONNECTABLE(audiorec));
AGS_MACHINE(audiorec)->audio->audio_channels = 2;
ags_audio_set_pads(AGS_MACHINE(audiorec)->audio,
AGS_TYPE_INPUT,
1, 0);
ags_audio_set_pads(AGS_MACHINE(audiorec)->audio,
AGS_TYPE_OUTPUT,
1, 0);
gtk_widget_show_all((GtkWidget *) audiorec);
}
void
ags_menu_bar_add_matrix_callback(GtkWidget *menu_item, AgsMenuBar *menu_bar)
{
AgsWindow *window;
AgsMatrix *matrix;
AgsAddAudio *add_audio;
AgsThread *main_loop;
AgsTaskThread *task_thread;
AgsApplicationContext *application_context;
window = (AgsWindow *) gtk_widget_get_ancestor((GtkWidget *) menu_bar, AGS_TYPE_WINDOW);
application_context = window->application_context;
main_loop = application_context->main_loop;
task_thread = ags_thread_find_type(main_loop,
AGS_TYPE_TASK_THREAD);
matrix = ags_matrix_new(G_OBJECT(window->soundcard));
add_audio = ags_add_audio_new(window->soundcard,
AGS_MACHINE(matrix)->audio);
ags_task_thread_append_task(task_thread,
AGS_TASK(add_audio));
gtk_box_pack_start((GtkBox *) window->machines,
GTK_WIDGET(matrix),
FALSE, FALSE, 0);
/* connect everything */
ags_connectable_connect(AGS_CONNECTABLE(matrix));
/* */
gtk_widget_show_all(GTK_WIDGET(matrix));
/* */
matrix->machine.audio->audio_channels = 1;
/* AgsMatrixInputPad */
ags_audio_set_pads(matrix->machine.audio, AGS_TYPE_INPUT, 78);
ags_audio_set_pads(matrix->machine.audio, AGS_TYPE_OUTPUT, 1);
ags_machine_find_port(AGS_MACHINE(matrix));
}
void
ags_menu_bar_add_panel_callback(GtkWidget *menu_item, AgsMenuBar *menu_bar)
{
AgsWindow *window;
AgsPanel *panel;
AgsAddAudio *add_audio;
AgsThread *main_loop;
AgsTaskThread *task_thread;
AgsApplicationContext *application_context;
window = (AgsWindow *) gtk_widget_get_ancestor((GtkWidget *) menu_bar, AGS_TYPE_WINDOW);
application_context = window->application_context;
main_loop = application_context->main_loop;
task_thread = ags_thread_find_type(main_loop,
AGS_TYPE_TASK_THREAD);
panel = ags_panel_new(G_OBJECT(window->soundcard));
add_audio = ags_add_audio_new(window->soundcard,
AGS_MACHINE(panel)->audio);
ags_task_thread_append_task(task_thread,
AGS_TASK(add_audio));
gtk_box_pack_start((GtkBox *) window->machines,
GTK_WIDGET(panel),
FALSE, FALSE, 0);
ags_connectable_connect(AGS_CONNECTABLE(panel));
gtk_widget_show_all(GTK_WIDGET(panel));
AGS_MACHINE(panel)->audio->audio_channels = 2;
ags_audio_set_pads(AGS_MACHINE(panel)->audio,
AGS_TYPE_INPUT, 1);
ags_audio_set_pads(AGS_MACHINE(panel)->audio,
AGS_TYPE_OUTPUT, 1);
ags_machine_find_port(AGS_MACHINE(panel));
gtk_widget_show_all(panel->vbox);
}
void
ags_menu_bar_preferences_callback(GtkWidget *menu_item, AgsMenuBar *menu_bar)
{
AgsWindow *window;
window = (AgsWindow *) gtk_widget_get_ancestor((GtkWidget *) menu_bar, AGS_TYPE_WINDOW);
if(window->preferences != NULL){
return;
}
window->preferences = ags_preferences_new();
window->preferences->parent = GTK_WINDOW(window);
ags_applicable_reset(AGS_APPLICABLE(window->preferences));
ags_connectable_connect(AGS_CONNECTABLE(window->preferences));
gtk_widget_show_all(GTK_WIDGET(window->preferences));
}
void
ags_track_collection_disconnect(AgsConnectable *connectable)
{
AgsTrackCollection *track_collection;
GList *list, *list_start;
track_collection = AGS_TRACK_COLLECTION(connectable);
/* children */
list_start =
list = gtk_container_get_children(track_collection->child);
while(list != NULL){
ags_connectable_disconnect(AGS_CONNECTABLE(list->data));
list = list->next;
}
g_list_free(list_start);
}
void
ags_machine_popup_envelope_callback(GtkWidget *widget, AgsMachine *machine)
{
AgsEnvelopeDialog *envelope_dialog;
if(machine->envelope_dialog == NULL){
envelope_dialog = ags_envelope_dialog_new(machine);
if((AGS_MACHINE_IS_SEQUENCER & (machine->flags)) != 0){
ags_envelope_dialog_add_pattern_tab(envelope_dialog);
}
machine->envelope_dialog = (GtkDialog *) envelope_dialog;
ags_connectable_connect(AGS_CONNECTABLE(envelope_dialog));
ags_applicable_reset(AGS_APPLICABLE(envelope_dialog));
gtk_widget_show_all((GtkWidget *) envelope_dialog);
}
}
void
ags_recall_finalize(GObject *gobject)
{
AgsRecall *recall;
recall = AGS_RECALL(gobject);
#ifdef AGS_DEBUG
g_message("finalize %s\n\0", G_OBJECT_TYPE_NAME(gobject));
#endif
if(recall->devout != NULL){
g_object_unref(recall->devout);
}
if((AGS_RECALL_CONNECTED & (recall->flags)) != 0){
ags_connectable_disconnect(AGS_CONNECTABLE(recall));
}
if((AGS_RECALL_RUN_INITIALIZED & (recall->flags)) != 0){
ags_dynamic_connectable_disconnect_dynamic(AGS_DYNAMIC_CONNECTABLE(recall));
}
// if(recall->name != NULL)
// g_free(recall->name);
ags_list_free_and_unref_link(recall->dependencies);
ags_list_free_and_unref_link(recall->children);
if(recall->container != NULL){
ags_packable_unpack(recall);
}
if(recall->parent != NULL){
//TODO:JK: implement me
}
/* call parent */
G_OBJECT_CLASS(ags_recall_parent_class)->finalize(gobject);
}
void
ags_pulse_client_disconnect(AgsConnectable *connectable)
{
AgsPulseClient *pulse_client;
GList *list_start, *list;
pthread_mutex_t *pulse_client_mutex;
if(!ags_connectable_is_connected(connectable)){
return;
}
pulse_client = AGS_PULSE_CLIENT(connectable);
ags_pulse_client_unset_flags(pulse_client, AGS_PULSE_CLIENT_CONNECTED);
/* get pulse client mutex */
pthread_mutex_lock(ags_pulse_client_get_class_mutex());
pulse_client_mutex = pulse_client->obj_mutex;
pthread_mutex_unlock(ags_pulse_client_get_class_mutex());
/* port */
pthread_mutex_lock(pulse_client_mutex);
list =
list_start = g_list_copy(pulse_client->port);
pthread_mutex_unlock(pulse_client_mutex);
while(list != NULL){
ags_connectable_disconnect(AGS_CONNECTABLE(list->data));
list = list->next;
}
g_list_free(list_start);
}
void
ags_menu_action_preferences_callback(GtkWidget *menu_item, gpointer data)
{
AgsApplicationContext *application_context;
AgsWindow *window;
application_context = ags_application_context_get_instance();
window = (AgsWindow *) ags_ui_provider_get_window(AGS_UI_PROVIDER(application_context));
if(window->preferences != NULL){
return;
}
window->preferences = ags_preferences_new();
window->preferences->window = GTK_WINDOW(window);
ags_connectable_connect(AGS_CONNECTABLE(window->preferences));
ags_applicable_reset(AGS_APPLICABLE(window->preferences));
gtk_widget_show_all(GTK_WIDGET(window->preferences));
}
void
ags_menu_bar_add_ffplayer_callback(GtkWidget *menu_item, AgsMenuBar *menu_bar)
{
AgsWindow *window;
AgsFFPlayer *ffplayer;
AgsAddAudio *add_audio;
AgsThread *main_loop;
AgsTaskThread *task_thread;
AgsApplicationContext *application_context;
window = (AgsWindow *) gtk_widget_get_ancestor((GtkWidget *) menu_bar, AGS_TYPE_WINDOW);
application_context = window->application_context;
main_loop = application_context->main_loop;
task_thread = ags_thread_find_type(main_loop,
AGS_TYPE_TASK_THREAD);
ffplayer = ags_ffplayer_new(G_OBJECT(window->soundcard));
add_audio = ags_add_audio_new(window->soundcard,
AGS_MACHINE(ffplayer)->audio);
ags_task_thread_append_task(task_thread,
AGS_TASK(add_audio));
gtk_box_pack_start((GtkBox *) window->machines,
(GtkWidget *) ffplayer,
FALSE, FALSE, 0);
ags_connectable_connect(AGS_CONNECTABLE(ffplayer));
// ffplayer->machine.audio->frequence = ;
ffplayer->machine.audio->audio_channels = 2;
ags_audio_set_pads(AGS_MACHINE(ffplayer)->audio, AGS_TYPE_INPUT, 78);
ags_audio_set_pads(AGS_MACHINE(ffplayer)->audio, AGS_TYPE_OUTPUT, 1);
ags_machine_find_port(AGS_MACHINE(ffplayer));
gtk_widget_show_all((GtkWidget *) ffplayer);
}
void
ags_append_audio_launch(AgsTask *task)
{
AgsServer *server;
AgsAppendAudio *append_audio;
AgsAudioLoop *audio_loop;
append_audio = AGS_APPEND_AUDIO(task);
audio_loop = AGS_AUDIO_LOOP(append_audio->audio_loop);
/* append to AgsDevout */
ags_audio_loop_add_audio(audio_loop,
append_audio->audio);
/* add to server registry */
server = AGS_MAIN(audio_loop->ags_main)->server;
if(server != NULL && (AGS_SERVER_RUNNING & (server->flags)) != 0){
ags_connectable_add_to_registry(AGS_CONNECTABLE(append_audio->audio));
}
}
void
ags_machine_popup_midi_dialog_callback(GtkWidget *widget, AgsMachine *machine)
{
AgsMidiDialog *midi_dialog;
if(machine->midi_dialog == NULL){
midi_dialog = ags_midi_dialog_new(machine);
machine->midi_dialog = (GtkDialog *) midi_dialog;
midi_dialog->flags |= (AGS_MIDI_DIALOG_IO_OPTIONS |
AGS_MIDI_DIALOG_MAPPING |
AGS_MIDI_DIALOG_DEVICE);
ags_connectable_connect(AGS_CONNECTABLE(midi_dialog));
ags_applicable_reset(AGS_APPLICABLE(midi_dialog));
gtk_widget_show_all((GtkWidget *) midi_dialog);
}else{
midi_dialog = (AgsMidiDialog *) machine->midi_dialog;
}
gtk_widget_show_all((GtkWidget *) midi_dialog);
}
void
ags_connectable_test_disconnect_connection()
{
GObject *current;
GType current_type;
guint i;
gboolean success;
success = TRUE;
for(i = 0; connectable_test_types[i] != G_TYPE_NONE; i++){
current = g_object_new(connectable_test_types[i],
NULL);
if(AGS_CONNECTABLE_GET_INTERFACE(AGS_CONNECTABLE(current))->disconnect_connection != NULL){
ags_connectable_disconnect_connection(current,
NULL);
}
}
}
/**
* ags_output_map_audio_signal:
* @output: an #AgsOutput
* @recall_id: the assigned #AgsRecallID
*
* Maps audio signal and assigning it to recall id.
*
* Returns: a new #GList containing #AgsAudioSignal
*
* Since: 0.4
*/
GList*
ags_output_map_audio_signal(AgsOutput *output, AgsRecallID *recall_id)
{
AgsDevout *devout;
AgsAudioSignal *audio_signal;
GList *list_destination;
if(output != NULL){
list_destination = g_list_alloc();
goto ags_copy_pattern_map_destination0;
}else
return(NULL);
devout = AGS_DEVOUT(AGS_AUDIO(AGS_CHANNEL(output)->audio)->devout);
while(output != NULL){
list_destination->next = g_list_alloc();
list_destination->next->prev = list_destination;
list_destination = list_destination->next;
ags_copy_pattern_map_destination0:
g_message("ags_output_map_audio_signal\n\0");
audio_signal = ags_audio_signal_new((GObject *) devout,
(GObject *) output->channel.first_recycling,
(GObject *) recall_id);
ags_connectable_connect(AGS_CONNECTABLE(audio_signal));
ags_recycling_add_audio_signal(output->channel.first_recycling,
audio_signal);
audio_signal->stream_current = audio_signal->stream_beginning;
list_destination->data = (gpointer) audio_signal;
output = (AgsOutput *) output->channel.next_pad;
}
return(list_destination);
}
void
ags_menu_action_midi_export_track_callback(GtkWidget *menu_item, gpointer data)
{
AgsApplicationContext *application_context;
AgsWindow *window;
application_context = ags_application_context_get_instance();
window = (AgsWindow *) ags_ui_provider_get_window(AGS_UI_PROVIDER(application_context));
if(window->midi_export_wizard != NULL){
return;
}
window->midi_export_wizard = (GtkWidget *) ags_midi_export_wizard_new((GtkWidget *) window);
g_object_set(window->midi_export_wizard,
"application-context", application_context,
NULL);
ags_connectable_connect(AGS_CONNECTABLE(window->midi_export_wizard));
ags_applicable_reset(AGS_APPLICABLE(window->midi_export_wizard));
gtk_widget_show_all(GTK_WIDGET(window->midi_export_wizard));
}
void
ags_machine_open_extended_response_callback(GtkWidget *widget, gint response, AgsMachine *machine)
{
GtkFileChooserDialog *file_chooser;
AgsFileSelection *file_selection;
GtkCheckButton *overwrite;
GtkCheckButton *create;
GSList *filenames;
gchar *current_folder;
GError *error;
file_chooser = (GtkFileChooserDialog *) gtk_widget_get_toplevel(widget);
if(response == GTK_RESPONSE_ACCEPT){
filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(file_chooser));
overwrite = g_object_get_data((GObject *) widget, "overwrite");
create = g_object_get_data((GObject *) widget, "create");
current_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(file_chooser));
//TODO:JK: you need to check against recently used
//TODO:JK: add more file types to AgsFileSelection
/* check for supported packed audio files */
file_selection = (AgsFileSelection *) gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(file_chooser));
if(file_selection != NULL && g_strcmp0(file_selection->directory, current_folder)){
gtk_widget_destroy(GTK_WIDGET(file_selection));
file_selection = NULL;
}
if(file_selection == NULL ||
(AGS_FILE_SELECTION_COMPLETED & (file_selection->flags)) == 0){
if((AGS_MACHINE_ACCEPT_SOUNDFONT2 & (machine->file_input_flags)) != 0){
GDir *current_directory;
GList *new_entry, *old_entry;
GSList *slist;
gchar *current_filename;
slist = filenames;
new_entry = NULL;
while(slist != NULL){
if(g_str_has_suffix(slist->data,
".sf2")){
AgsFileSelectionEntry *entry;
entry = ags_file_selection_entry_alloc();
entry->filename = slist->data;
new_entry = g_list_prepend(new_entry,
entry);
}
slist = slist->next;
}
old_entry = NULL;
if(file_selection == NULL){
if(new_entry != NULL){
file_selection = ags_file_selection_new();
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(file_chooser),
GTK_WIDGET(file_selection));
ags_file_selection_set_entry(file_selection,
new_entry);
ags_connectable_connect(AGS_CONNECTABLE(file_selection));
gtk_widget_show_all(GTK_WIDGET(file_selection));
return;
}
}else if(AGS_IS_FILE_SELECTION(file_selection)){
GList *really_new_entry;
GList *list;
old_entry = file_selection->entry;
list = new_entry;
really_new_entry = NULL;
/* check against existing entries */
if(new_entry != NULL){
while(list != NULL){
if(g_list_find(old_entry, list->data) == NULL){
really_new_entry = g_list_prepend(really_new_entry,
list->data);
}else{
free(list->data);
}
list = list->next;
}
g_list_free(new_entry);
}
ags_file_selection_set_entry(file_selection,
really_new_entry);
/* adding lost files */
//TODO:JK: figure out if you need to copy the GSList of filenames
gtk_file_chooser_select_all(GTK_FILE_CHOOSER(file_chooser));
current_directory = g_dir_open(current_folder,
0,
&error);
while((current_filename = (gchar *) g_dir_read_name(current_directory)) != NULL){
if(!g_strcmp0(".", current_filename) ||
!g_strcmp0("..", current_filename))
continue;
if(!ags_file_selection_contains_file(file_selection,
current_filename) &&
g_slist_find(filenames, current_filename) == NULL){
gtk_file_chooser_unselect_filename(GTK_FILE_CHOOSER(file_chooser),
current_filename);
}
}
g_dir_close(current_directory);
return;
}
}
}
//TODO:JK: fix GSList filenames memory leak
ags_machine_open_files(machine,
filenames,
overwrite->toggle_button.active,
create->toggle_button.active);
}
}
void
ags_mixer_set_audio_channels(AgsAudio *audio,
guint audio_channels, guint audio_channels_old,
gpointer data)
{
AgsMixer *mixer;
GtkVScale *scale;
GList *list_input_pad;
guint i;
mixer = AGS_MIXER(audio->machine);
if(audio_channels_old < audio_channels){
AgsMixerInputPad *mixer_input_pad;
AgsChannel *channel;
/* AgsInput */
channel = audio->input;
list_input_pad = gtk_container_get_children((GtkContainer *) mixer->input_pad);
for(i = 0; i < audio->input_pads; i++){
if(audio_channels_old == 0){
/* create AgsPad's if necessary */
mixer_input_pad = g_object_new(AGS_TYPE_MIXER_INPUT_PAD,
"channel\0", channel,
NULL);
gtk_box_pack_start((GtkBox *) mixer->input_pad,
(GtkWidget *) mixer_input_pad,
FALSE, FALSE,
0);
ags_pad_resize_lines((AgsPad *) mixer_input_pad, AGS_TYPE_MIXER_INPUT_LINE,
AGS_AUDIO(channel->audio)->audio_channels, 0);
if(GTK_WIDGET_VISIBLE((GtkWidget *) mixer)){
ags_connectable_connect(AGS_CONNECTABLE(mixer_input_pad));
ags_pad_find_port(AGS_PAD(mixer_input_pad));
gtk_widget_show_all((GtkWidget *) mixer_input_pad);
}
}else{
mixer_input_pad = AGS_MIXER_INPUT_PAD(list_input_pad->data);
ags_pad_resize_lines((AgsPad *) mixer_input_pad, AGS_TYPE_MIXER_INPUT_LINE,
audio_channels, audio_channels_old);
}
channel = channel->next_pad;
if(audio_channels_old != 0)
list_input_pad = list_input_pad->next;
}
}else{
GList *list_input_pad_next;
list_input_pad = gtk_container_get_children((GtkContainer *) mixer->input_pad);
if(audio_channels == 0){
/* AgsInput */
while(list_input_pad != NULL){
list_input_pad_next = list_input_pad->next;
gtk_widget_destroy(GTK_WIDGET(list_input_pad->data));
list_input_pad->next = list_input_pad_next;
}
}else{
/* AgsInput */
for(i = 0; list_input_pad != NULL; i++){
ags_pad_resize_lines(AGS_PAD(list_input_pad->data), AGS_TYPE_MIXER_INPUT_PAD,
audio_channels, audio_channels_old);
list_input_pad = list_input_pad->next;
}
}
}
}
void
ags_machine_popup_destroy_activate_callback(GtkWidget *widget, AgsMachine *machine)
{
AgsWindow *window;
AgsAudio *audio;
AgsRemoveAudio *remove_audio;
AgsThread *gui_thread;
AgsApplicationContext *application_context;
GList *list, *list_start;
window = (AgsWindow *) gtk_widget_get_toplevel((GtkWidget *) machine);
application_context = (AgsApplicationContext *) window->application_context;
/* destroy editor */
list =
list_start = gtk_container_get_children((GtkContainer *) window->notation_editor->machine_selector);
list = list->next;
while(list != NULL){
if(AGS_IS_MACHINE_RADIO_BUTTON(list->data) && AGS_MACHINE_RADIO_BUTTON(list->data)->machine == machine){
gtk_widget_destroy(list->data);
break;
}
list = list->next;
}
g_list_free(list_start);
/* destroy automation editor */
list =
list_start = gtk_container_get_children((GtkContainer *) window->automation_window->automation_editor->machine_selector);
list = list->next;
while(list != NULL){
if(AGS_IS_MACHINE_RADIO_BUTTON(list->data) && AGS_MACHINE_RADIO_BUTTON(list->data)->machine == machine){
gtk_widget_destroy(list->data);
break;
}
list = list->next;
}
g_list_free(list_start);
/* destroy machine */
audio = machine->audio;
g_object_ref(audio);
ags_connectable_disconnect(AGS_CONNECTABLE(machine));
gtk_widget_destroy((GtkWidget *) machine);
/* get task thread */
gui_thread = ags_ui_provider_get_gui_thread(AGS_UI_PROVIDER(application_context));
remove_audio = ags_remove_audio_new(application_context,
audio);
ags_gui_thread_schedule_task((AgsGuiThread *) gui_thread,
(GObject *) remove_audio);
}
void
ags_open_file_launch(AgsTask *task)
{
AgsOpenFile *open_file;
AgsAudio *audio;
AgsChannel *channel, *iter;
AgsAudioFile *audio_file;
AgsFileLink *file_link;
GSList *current;
GList *audio_signal;
gchar *current_filename;
guint i, i_stop;
GError *error;
open_file = AGS_OPEN_FILE(task);
audio = open_file->audio;
current = open_file->filenames;
i_stop = 0;
if(open_file->overwrite_channels){
channel = audio->input;
i_stop = audio->input_pads;
}
/* */
if(open_file->create_channels){
guint pads_old;
i_stop = g_slist_length(open_file->filenames);
pads_old = audio->input_pads;
if(open_file->overwrite_channels){
if(i_stop > audio->input_pads){
ags_audio_set_pads(audio, AGS_TYPE_INPUT,
i_stop);
}
channel = audio->input;
}else{
ags_audio_set_pads(audio, AGS_TYPE_INPUT,
audio->input_pads + i_stop);
channel = ags_channel_pad_nth(audio->input,
pads_old);
}
iter = ags_channel_pad_nth(audio->input,
pads_old);
while(iter != NULL){
ags_connectable_connect(AGS_CONNECTABLE(iter));
iter = iter->next;
}
}
for(i = 0; i < i_stop && current != NULL; i++){
current_filename = (gchar *) current->data;
audio_file = ags_audio_file_new((gchar *) current_filename,
audio->soundcard,
0, open_file->audio->audio_channels);
ags_audio_file_open(audio_file);
ags_audio_file_read_audio_signal(audio_file);
iter = channel;
audio_signal = audio_file->audio_signal;
while(iter != channel->next_pad && audio_signal != NULL){
file_link = g_object_new(AGS_TYPE_FILE_LINK,
"filename\0", current_filename,
NULL);
g_object_set(G_OBJECT(iter),
"file-link", file_link,
NULL);
AGS_AUDIO_SIGNAL(audio_signal->data)->flags |= AGS_AUDIO_SIGNAL_TEMPLATE;
if(iter->link != NULL){
error = NULL;
ags_channel_set_link(iter, NULL,
&error);
if(error != NULL){
g_warning(error->message);
}
}
//TODO:JK: add mutex
ags_recycling_add_audio_signal(iter->first_recycling,
AGS_AUDIO_SIGNAL(audio_signal->data));
audio_signal = audio_signal->next;
iter = iter->next;
}
channel = channel->next_pad;
current = current->next;
}
}
void
ags_menu_action_add_live_lv2_bridge_callback(GtkWidget *menu_item, gpointer data)
{
AgsWindow *window;
AgsLiveLv2Bridge *live_lv2_bridge;
AgsThread *gui_thread;
AgsAddAudio *add_audio;
AgsApplicationContext *application_context;
AgsLv2Plugin *lv2_plugin;
gchar *filename, *effect;
filename = g_object_get_data((GObject *) menu_item,
AGS_MENU_ITEM_FILENAME_KEY);
effect = g_object_get_data((GObject *) menu_item,
AGS_MENU_ITEM_EFFECT_KEY);
application_context = ags_application_context_get_instance();
window = (AgsWindow *) ags_ui_provider_get_window(AGS_UI_PROVIDER(application_context));
gui_thread = ags_ui_provider_get_gui_thread(AGS_UI_PROVIDER(application_context));
/* create live lv2 bridge */
live_lv2_bridge = ags_live_lv2_bridge_new(G_OBJECT(window->soundcard),
filename,
effect);
lv2_plugin = ags_lv2_manager_find_lv2_plugin(ags_lv2_manager_get_instance(),
filename, effect);
add_audio = ags_add_audio_new((AgsApplicationContext *) window->application_context,
AGS_MACHINE(live_lv2_bridge)->audio);
ags_gui_thread_schedule_task((AgsGuiThread *) gui_thread,
(GObject *) add_audio);
gtk_box_pack_start((GtkBox *) window->machines,
GTK_WIDGET(live_lv2_bridge),
FALSE, FALSE, 0);
/* connect everything */
ags_connectable_connect(AGS_CONNECTABLE(live_lv2_bridge));
/* */
AGS_MACHINE(live_lv2_bridge)->audio->audio_channels = 2;
/* */
if(lv2_plugin != NULL){
if((AGS_LV2_PLUGIN_IS_SYNTHESIZER & (lv2_plugin->flags)) == 0){
ags_audio_set_pads(AGS_MACHINE(live_lv2_bridge)->audio,
AGS_TYPE_INPUT,
1, 0);
}else{
ags_audio_set_pads(AGS_MACHINE(live_lv2_bridge)->audio,
AGS_TYPE_INPUT,
128, 0);
}
}
ags_audio_set_pads(AGS_MACHINE(live_lv2_bridge)->audio,
AGS_TYPE_OUTPUT,
1, 0);
/* */
ags_live_lv2_bridge_load(live_lv2_bridge);
/* */
gtk_widget_show_all(GTK_WIDGET(live_lv2_bridge));
}
void
ags_menu_action_add_ladspa_bridge_callback(GtkWidget *menu_item, gpointer data)
{
AgsWindow *window;
AgsLadspaBridge *ladspa_bridge;
AgsThread *gui_thread;
AgsAddAudio *add_audio;
AgsApplicationContext *application_context;
gchar *filename, *effect;
pthread_mutex_t *application_mutex;
filename = g_object_get_data((GObject *) menu_item,
AGS_MENU_ITEM_FILENAME_KEY);
effect = g_object_get_data((GObject *) menu_item,
AGS_MENU_ITEM_EFFECT_KEY);
application_context = ags_application_context_get_instance();
window = (AgsWindow *) ags_ui_provider_get_window(AGS_UI_PROVIDER(application_context));
gui_thread = ags_ui_provider_get_gui_thread(AGS_UI_PROVIDER(application_context));
/* create ladspa bridge */
ladspa_bridge = ags_ladspa_bridge_new(G_OBJECT(window->soundcard),
filename,
effect);
add_audio = ags_add_audio_new((AgsApplicationContext *) window->application_context,
AGS_MACHINE(ladspa_bridge)->audio);
ags_gui_thread_schedule_task((AgsGuiThread *) gui_thread,
(GObject *) add_audio);
gtk_box_pack_start((GtkBox *) window->machines,
GTK_WIDGET(ladspa_bridge),
FALSE, FALSE, 0);
/* connect everything */
ags_connectable_connect(AGS_CONNECTABLE(ladspa_bridge));
/* */
AGS_MACHINE(ladspa_bridge)->audio->audio_channels = 2;
/* */
ags_audio_set_pads(AGS_MACHINE(ladspa_bridge)->audio,
AGS_TYPE_INPUT,
1, 0);
ags_audio_set_pads(AGS_MACHINE(ladspa_bridge)->audio,
AGS_TYPE_OUTPUT,
1, 0);
/* */
ags_ladspa_bridge_load(ladspa_bridge);
/* */
gtk_widget_show_all(GTK_WIDGET(ladspa_bridge));
}
void
ags_menu_action_add_lv2_bridge_callback(GtkWidget *menu_item, gpointer data)
{
AgsWindow *window;
AgsLv2Bridge *lv2_bridge;
AgsThread *gui_thread;
AgsAddAudio *add_audio;
AgsApplicationContext *application_context;
AgsLv2Plugin *lv2_plugin;
gchar *filename, *effect;
filename = g_object_get_data((GObject *) menu_item,
AGS_MENU_ITEM_FILENAME_KEY);
effect = g_object_get_data((GObject *) menu_item,
AGS_MENU_ITEM_EFFECT_KEY);
application_context = ags_application_context_get_instance();
window = (AgsWindow *) ags_ui_provider_get_window(AGS_UI_PROVIDER(application_context));
gui_thread = ags_ui_provider_get_gui_thread(AGS_UI_PROVIDER(application_context));
/* create lv2 bridge */
lv2_bridge = ags_lv2_bridge_new(G_OBJECT(window->soundcard),
filename,
effect);
lv2_plugin = ags_lv2_manager_find_lv2_plugin(ags_lv2_manager_get_instance(),
filename, effect);
if(lv2_plugin != NULL &&
(AGS_LV2_PLUGIN_IS_SYNTHESIZER & (lv2_plugin->flags)) != 0){
ags_audio_set_flags(AGS_MACHINE(lv2_bridge)->audio, (AGS_AUDIO_OUTPUT_HAS_RECYCLING |
AGS_AUDIO_INPUT_HAS_RECYCLING |
AGS_AUDIO_SYNC |
AGS_AUDIO_ASYNC));
ags_audio_set_ability_flags(AGS_MACHINE(lv2_bridge)->audio, (AGS_SOUND_ABILITY_NOTATION));
ags_audio_set_behaviour_flags(AGS_MACHINE(lv2_bridge)->audio, (AGS_SOUND_BEHAVIOUR_DEFAULTS_TO_INPUT |
AGS_SOUND_BEHAVIOUR_REVERSE_MAPPING));
g_object_set(AGS_MACHINE(lv2_bridge)->audio,
"max-input-pads", 128,
"audio-start-mapping", 0,
"audio-end-mapping", 128,
"midi-start-mapping", 0,
"midi-end-mapping", 128,
NULL);
AGS_MACHINE(lv2_bridge)->flags |= (AGS_MACHINE_IS_SYNTHESIZER |
AGS_MACHINE_REVERSE_NOTATION);
ags_machine_popup_add_connection_options((AgsMachine *) lv2_bridge,
(AGS_MACHINE_POPUP_MIDI_DIALOG));
ags_machine_popup_add_edit_options((AgsMachine *) lv2_bridge,
(AGS_MACHINE_POPUP_ENVELOPE));
}
add_audio = ags_add_audio_new((AgsApplicationContext *) window->application_context,
AGS_MACHINE(lv2_bridge)->audio);
ags_gui_thread_schedule_task((AgsGuiThread *) gui_thread,
(GObject *) add_audio);
gtk_box_pack_start((GtkBox *) window->machines,
GTK_WIDGET(lv2_bridge),
FALSE, FALSE, 0);
/* connect everything */
ags_connectable_connect(AGS_CONNECTABLE(lv2_bridge));
/* */
AGS_MACHINE(lv2_bridge)->audio->audio_channels = 2;
/* */
if(lv2_plugin != NULL){
if((AGS_LV2_PLUGIN_IS_SYNTHESIZER & (lv2_plugin->flags)) == 0){
ags_audio_set_pads(AGS_MACHINE(lv2_bridge)->audio,
AGS_TYPE_INPUT,
1, 0);
}else{
ags_audio_set_pads(AGS_MACHINE(lv2_bridge)->audio,
AGS_TYPE_INPUT,
128, 0);
}
}
ags_audio_set_pads(AGS_MACHINE(lv2_bridge)->audio,
AGS_TYPE_OUTPUT,
1, 0);
/* */
ags_lv2_bridge_load(lv2_bridge);
/* */
gtk_widget_show_all(GTK_WIDGET(lv2_bridge));
}
void
ags_xorg_application_context_init(AgsXorgApplicationContext *xorg_application_context)
{
AgsWindow *window;
AgsServer *server;
AgsAudioLoop *audio_loop;
GObject *soundcard;
AgsConfig *config;
struct passwd *pw;
uid_t uid;
gchar *wdir, *config_file;
AGS_APPLICATION_CONTEXT(xorg_application_context)->log = (AgsLog *) g_object_new(AGS_TYPE_LOG,
"file\0", stderr,
NULL);
/**/
config = ags_config_new(NULL);
AGS_APPLICATION_CONTEXT(xorg_application_context)->config = config;
g_object_set(config,
"application-context\0", xorg_application_context,
NULL);
uid = getuid();
pw = getpwuid(uid);
wdir = g_strdup_printf("%s/%s\0",
pw->pw_dir,
AGS_DEFAULT_DIRECTORY);
config_file = g_strdup_printf("%s/%s\0",
wdir,
AGS_DEFAULT_CONFIG);
ags_config_load_from_file(config,
config_file);
g_free(wdir);
g_free(config_file);
/* AgsSoundcard */
soundcard = ags_devout_new(xorg_application_context);
xorg_application_context->soundcard = g_list_prepend(xorg_application_context->soundcard,
soundcard);
g_object_ref(G_OBJECT(soundcard));
/* AgsWindow */
window = ags_window_new(xorg_application_context);
g_object_set(window,
"soundcard\0", soundcard,
NULL);
AGS_XORG_APPLICATION_CONTEXT(xorg_application_context)->window = window;
g_object_ref(G_OBJECT(window));
gtk_window_set_default_size((GtkWindow *) window, 500, 500);
gtk_paned_set_position((GtkPaned *) window->paned, 300);
ags_connectable_connect(AGS_CONNECTABLE(window));
gtk_widget_show_all((GtkWidget *) window);
/* AgsServer */
xorg_application_context->server = ags_server_new(xorg_application_context);
/* AgsMainLoop */
audio_loop = (AgsThread *) ags_audio_loop_new((GObject *) soundcard,
xorg_application_context);
g_object_set(xorg_application_context,
"main-loop\0", audio_loop,
NULL);
g_object_ref(audio_loop);
ags_connectable_connect(AGS_CONNECTABLE(audio_loop));
/* AgsTaskThread */
AGS_APPLICATION_CONTEXT(xorg_application_context)->task_thread = (AgsThread *) ags_task_thread_new();
ags_thread_add_child(AGS_THREAD(audio_loop), AGS_APPLICATION_CONTEXT(xorg_application_context)->task_thread);
/* AgsSoundcardThread */
xorg_application_context->soundcard_thread = (AgsThread *) ags_soundcard_thread_new(soundcard);
ags_thread_add_child(AGS_THREAD(audio_loop), xorg_application_context->soundcard_thread);
/* AgsExportThread */
xorg_application_context->export_thread = (AgsThread *) ags_export_thread_new(soundcard,
NULL);
ags_thread_add_child(AGS_THREAD(audio_loop), xorg_application_context->export_thread);
/* AgsGuiThread */
xorg_application_context->gui_thread = (AgsThread *) ags_gui_thread_new();
ags_thread_add_child(AGS_THREAD(audio_loop), xorg_application_context->gui_thread);
/* AgsThreadPool */
AGS_XORG_APPLICATION_CONTEXT(xorg_application_context)->thread_pool = ags_thread_pool_new(AGS_APPLICATION_CONTEXT(xorg_application_context)->task_thread);
}
/**
* ags_recall_add_child:
* @parent an #AgsRecall
* @child an #AgsRecall
*
* An #AgsRecall may have children.
*/
void
ags_recall_add_child(AgsRecall *parent, AgsRecall *child)
{
guint inheritated_flags_mask;
if(child == NULL ||
child->parent == parent)
return;
inheritated_flags_mask = (AGS_RECALL_PLAYBACK |
AGS_RECALL_SEQUENCER |
AGS_RECALL_NOTATION |
AGS_RECALL_PROPAGATE_DONE |
AGS_RECALL_INITIAL_RUN);
if(!AGS_IS_RECALL_AUDIO_SIGNAL(child)){
inheritated_flags_mask |= (AGS_RECALL_PERSISTENT |
AGS_RECALL_PERSISTENT_PLAYBACK |
AGS_RECALL_PERSISTENT_SEQUENCER |
AGS_RECALL_PERSISTENT_NOTATION);
}
/* unref old */
if(child->parent != NULL){
child->flags &= (~inheritated_flags_mask);
child->parent->children = g_list_remove(child->parent->children, child);
g_object_unref(child->parent);
g_object_unref(child);
g_object_set(G_OBJECT(child),
"recall_id\0", NULL,
NULL);
}
/* ref new */
if(parent != NULL){
g_object_ref(parent);
g_object_ref(child);
child->flags |= (inheritated_flags_mask & (parent->flags));
parent->children = g_list_prepend(parent->children, child);
g_object_set(G_OBJECT(child),
"devout\0", parent->devout,
"recall_id\0", parent->recall_id,
NULL);
g_signal_connect(G_OBJECT(child), "done\0",
G_CALLBACK(ags_recall_child_done), parent);
}
child->parent = parent;
if(parent != NULL){
ags_recall_child_added(parent,
child);
}
ags_connectable_connect(AGS_CONNECTABLE(child));
if(parent != NULL &&
(AGS_RECALL_RUN_INITIALIZED & (parent->flags)) != 0 &&
(AGS_RECALL_RUN_INITIALIZED & (child->flags)) == 0){
ags_recall_run_init_pre(AGS_RECALL(child));
ags_recall_run_init_inter(AGS_RECALL(child));
ags_recall_run_init_post(AGS_RECALL(child));
ags_dynamic_connectable_connect_dynamic(AGS_DYNAMIC_CONNECTABLE(child));
child->flags |= AGS_RECALL_RUN_INITIALIZED;
}
}