/* The suite initialization function.
* Opens the temporary file used by the tests.
* Returns zero on success, non-zero otherwise.
*/
int
ags_functional_ffplayer_test_init_suite()
{
/* get gui thread */
gui_thread = ags_thread_find_type(ags_application_context->main_loop,
AGS_TYPE_GUI_THREAD);
task_thread = ags_thread_find_type(ags_application_context->main_loop,
AGS_TYPE_TASK_THREAD);
return(0);
}
void
ags_soundcard_thread_dispatch_callback(AgsPollFd *poll_fd,
AgsSoundcardThread *soundcard_thread)
{
AgsAudioLoop *audio_loop;
AgsPollingThread *polling_thread;
guint time_spent;
audio_loop = (AgsAudioLoop *) ags_thread_get_toplevel((AgsThread *) soundcard_thread);
if(ags_soundcard_is_available(AGS_SOUNDCARD(soundcard_thread->soundcard))){
pthread_mutex_lock(audio_loop->timing_mutex);
g_atomic_int_set(&(audio_loop->time_spent),
audio_loop->time_cycle);
pthread_mutex_unlock(audio_loop->timing_mutex);
// ags_main_loop_interrupt(AGS_MAIN_LOOP(audio_loop),
// AGS_THREAD_SUSPEND_SIG,
// 0, &time_spent);
polling_thread = (AgsPollingThread *) ags_thread_find_type((AgsThread *) audio_loop,
AGS_TYPE_POLLING_THREAD);
if(polling_thread != NULL){
g_atomic_int_or(&(polling_thread->flags),
AGS_POLLING_THREAD_OMIT);
g_atomic_int_inc(&(polling_thread->omit_count));
}
}
}
void
ags_midi_preferences_add_callback(GtkWidget *widget, AgsMidiPreferences *midi_preferences)
{
AgsWindow *window;
AgsPreferences *preferences;
AgsSequencerEditor *sequencer_editor;
AgsSequencerThread *sequencer_thread;
AgsThread *main_loop;
AgsApplicationContext *application_context;
GObject *sequencer;
GList *start_list, *list;
preferences = (AgsPreferences *) gtk_widget_get_ancestor(GTK_WIDGET(midi_preferences),
AGS_TYPE_PREFERENCES);
window = (AgsWindow *) preferences->window;
application_context = (AgsApplicationContext *) window->application_context;
main_loop = ags_concurrency_provider_get_main_loop(AGS_CONCURRENCY_PROVIDER(application_context));
/* retrieve first sequencer */
sequencer = NULL;
list =
start_list = ags_sound_provider_get_sequencer(AGS_SOUND_PROVIDER(application_context));
if(list != NULL){
sequencer = list->data;
}
g_list_free_full(start_list,
g_object_unref);
/* sequencer editor */
sequencer_editor = ags_sequencer_editor_new();
if(sequencer != NULL){
sequencer_editor->sequencer = sequencer;
sequencer_editor->sequencer_thread = (GObject *) ags_thread_find_type(main_loop,
AGS_TYPE_SEQUENCER_THREAD);
}
gtk_box_pack_start((GtkBox *) midi_preferences->sequencer_editor,
(GtkWidget *) sequencer_editor,
FALSE, FALSE,
0);
ags_applicable_reset(AGS_APPLICABLE(sequencer_editor));
ags_connectable_connect(AGS_CONNECTABLE(sequencer_editor));
g_signal_connect(sequencer_editor->remove, "clicked",
G_CALLBACK(ags_midi_preferences_remove_sequencer_editor_callback), midi_preferences);
gtk_widget_show_all((GtkWidget *) sequencer_editor);
g_object_unref(main_loop);
}
/* The suite initialization function.
* Opens the temporary file used by the tests.
* Returns zero on success, non-zero otherwise.
*/
int
ags_functional_machine_add_and_destroy_test_init_suite()
{
/* get gui thread */
gui_thread = ags_thread_find_type(ags_application_context->main_loop,
AGS_TYPE_GUI_THREAD);
return(0);
}
void
ags_menu_bar_save_as_callback(GtkWidget *menu_item, AgsMenuBar *menu_bar)
{
AgsWindow *window;
GtkFileChooserDialog *file_chooser;
gint response;
window = (AgsWindow *) gtk_widget_get_toplevel((GtkWidget *) menu_bar);
file_chooser = (GtkFileChooserDialog *) gtk_file_chooser_dialog_new("save file as\0",
(GtkWindow *) window,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser), FALSE);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(file_chooser), TRUE);
gtk_widget_show_all((GtkWidget *) file_chooser);
response = gtk_dialog_run(GTK_DIALOG(file_chooser));
if(response == GTK_RESPONSE_ACCEPT){
AgsSaveFile *save_file;
AgsThread *main_loop;
AgsTaskThread *task_thread;
AgsApplicationContext *application_context;
AgsFile *file;
char *filename;
application_context = window->application_context;
main_loop = application_context->main_loop;
task_thread = ags_thread_find_type(main_loop,
AGS_TYPE_TASK_THREAD);
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser));
window->name = filename;
file = (AgsFile *) g_object_new(AGS_TYPE_FILE,
"application-context\0", application_context,
"filename\0", filename,
NULL);
save_file = ags_save_file_new(file);
ags_task_thread_append_task(task_thread,
AGS_TASK(save_file));
}
gtk_widget_destroy((GtkWidget *) file_chooser);
}
void
ags_soundcard_thread_start(AgsThread *thread)
{
AgsSoundcardThread *soundcard_thread;
AgsThread *main_loop;
AgsPollingThread *polling_thread;
GObject *soundcard;
GList *poll_fd;
GError *error;
soundcard_thread = AGS_SOUNDCARD_THREAD(thread);
main_loop = ags_thread_get_toplevel(thread);
soundcard = soundcard_thread->soundcard;
/* disable timing */
g_atomic_int_and(&(thread->flags),
(~AGS_THREAD_TIMING));
/* find polling thread */
polling_thread = (AgsPollingThread *) ags_thread_find_type(main_loop,
AGS_TYPE_POLLING_THREAD);
/* add poll fd and connect dispatch */
poll_fd = ags_soundcard_get_poll_fd(AGS_SOUNDCARD(soundcard));
while(poll_fd != NULL){
if(polling_thread != NULL){
gint position;
ags_polling_thread_add_poll_fd(polling_thread,
poll_fd->data);
g_signal_connect(G_OBJECT(poll_fd->data), "dispatch",
G_CALLBACK(ags_soundcard_thread_dispatch_callback), soundcard_thread);
position = ags_polling_thread_fd_position(polling_thread,
AGS_POLL_FD(poll_fd->data)->fd);
if(position != -1){
polling_thread->fds[position].events = POLLOUT;
}
}
poll_fd = poll_fd->next;
}
if((AGS_THREAD_SINGLE_LOOP & (g_atomic_int_get(&(thread->flags)))) == 0){
AGS_THREAD_CLASS(ags_soundcard_thread_parent_class)->start(thread);
}
}
void
ags_menu_bar_add_drum_callback(GtkWidget *menu_item, AgsMenuBar *menu_bar)
{
AgsWindow *window;
AgsDrum *drum;
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);
drum = ags_drum_new(G_OBJECT(window->soundcard));
add_audio = ags_add_audio_new(window->soundcard,
AGS_MACHINE(drum)->audio);
ags_task_thread_append_task(task_thread,
AGS_TASK(add_audio));
gtk_box_pack_start((GtkBox *) window->machines,
GTK_WIDGET(drum),
FALSE, FALSE, 0);
/* connect everything */
ags_connectable_connect(AGS_CONNECTABLE(drum));
/* */
gtk_widget_show_all(GTK_WIDGET(drum));
/* */
drum->machine.audio->audio_channels = 2;
/* AgsDrumInputPad */
ags_audio_set_pads(drum->machine.audio, AGS_TYPE_INPUT, 8);
ags_audio_set_pads(drum->machine.audio, AGS_TYPE_OUTPUT, 1);
ags_machine_find_port(AGS_MACHINE(drum));
gtk_widget_show_all(drum->output_pad);
gtk_widget_show_all(drum->input_pad);
}
void
ags_soundcard_thread_stop(AgsThread *thread)
{
AgsSoundcardThread *soundcard_thread;
AgsThread *main_loop;
AgsPollingThread *polling_thread;
GObject *soundcard;
GList *poll_fd;
soundcard_thread = AGS_SOUNDCARD_THREAD(thread);
main_loop = ags_thread_get_toplevel(thread);
soundcard = soundcard_thread->soundcard;
/* stop thread and soundcard */
AGS_THREAD_CLASS(ags_soundcard_thread_parent_class)->stop(thread);
//FIXME:JK: is this safe?
ags_soundcard_stop(AGS_SOUNDCARD(soundcard));
g_atomic_int_or(&(thread->flags),
AGS_THREAD_TIMING);
/* find polling thread */
polling_thread = (AgsPollingThread *) ags_thread_find_type(main_loop,
AGS_TYPE_POLLING_THREAD);
/* remove poll fd */
poll_fd = ags_soundcard_get_poll_fd(AGS_SOUNDCARD(soundcard));
while(poll_fd != NULL){
if(polling_thread != NULL){
gint position;
g_object_disconnect(G_OBJECT(poll_fd->data),
"any_signal::dispatch",
G_CALLBACK(ags_soundcard_thread_dispatch_callback),
soundcard_thread,
NULL);
ags_polling_thread_remove_poll_fd(polling_thread,
poll_fd->data);
}
poll_fd = poll_fd->next;
}
}
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_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_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);
}
gboolean
ags_window_delete_event_callback(GtkWidget *widget, gpointer data)
{
AgsWindow *window;
GtkDialog *dialog;
GtkWidget *cancel_button;
AgsApplicationContext *application_context;
gint response;
window = AGS_WINDOW(widget);
application_context = window->application_context;
/* ask the user if he wants save to a file */
dialog = (GtkDialog *) gtk_message_dialog_new(GTK_WINDOW(window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
"Do you want to save '%s'?\0", window->name);
cancel_button = gtk_dialog_add_button(dialog,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
gtk_widget_grab_focus(cancel_button);
response = gtk_dialog_run(dialog);
if(response == GTK_RESPONSE_YES) {
AgsThread *main_loop;
AgsTaskThread *task_thread;
AgsSaveFile *save_file;
AgsFile *file;
char *filename;
main_loop = application_context->main_loop;
task_thread = ags_thread_find_type(main_loop,
AGS_TYPE_TASK_THREAD);
filename = window->name;
file = (AgsFile *) g_object_new(AGS_TYPE_FILE,
"application-context\0", application_context,
"filename\0", g_strdup(filename),
NULL);
save_file = ags_save_file_new(file);
ags_task_thread_append_task(task_thread,
AGS_TASK(save_file));
g_object_unref(G_OBJECT(file));
}
if(response != GTK_RESPONSE_CANCEL) {
ags_main_quit(application_context);
} else {
gtk_widget_destroy(GTK_WIDGET(dialog));
}
return(TRUE);
}
void
ags_test_launch_filename(gchar *filename,
gboolean single_thread)
{
AgsThread *audio_loop, *polling_thread, *gui_thread, *task_thread;
AgsThreadPool *thread_pool;
AgsConfig *config;
GList *start_queue;
/* get threads, thread pool and config */
g_object_get(ags_application_context,
"config", &config,
"main-loop", &audio_loop,
"task-thread", &task_thread,
NULL);
g_object_get(task_thread,
"thread-pool", &thread_pool,
NULL);
polling_thread = ags_thread_find_type(audio_loop,
AGS_TYPE_POLLING_THREAD);
gui_thread = ags_thread_find_type(audio_loop,
AGS_TYPE_GUI_THREAD);
/* open file */
if(g_strcmp0(ags_config_get_value(config,
AGS_CONFIG_GENERIC,
"simple-file\0"),
"false\0")){
AgsSimpleFile *simple_file;
AgsSimpleFileRead *simple_file_read;
GError *error;
simple_file = (AgsSimpleFile *) g_object_new(AGS_TYPE_SIMPLE_FILE,
"application-context\0", ags_application_context,
"filename\0", filename,
NULL);
error = NULL;
ags_simple_file_open(simple_file,
&error);
if(error != NULL){
ags_test_show_file_error(filename,
error);
ags_application_context_quit(ags_application_context);
}
/* start engine */
pthread_mutex_lock(audio_loop->start_mutex);
start_queue = NULL;
start_queue = g_list_prepend(start_queue,
polling_thread);
start_queue = g_list_prepend(start_queue,
task_thread);
// start_queue = g_list_prepend(start_queue,
// gui_thread);
g_atomic_pointer_set(&(audio_loop->start_queue),
start_queue);
pthread_mutex_unlock(audio_loop->start_mutex);
/* start audio loop and thread pool */
ags_thread_start(audio_loop);
ags_thread_pool_start(thread_pool);
if(!single_thread){
/* wait for audio loop */
pthread_mutex_lock(audio_loop->start_mutex);
if(g_atomic_int_get(&(audio_loop->start_wait)) == TRUE){
g_atomic_int_set(&(audio_loop->start_done),
FALSE);
while(g_atomic_int_get(&(audio_loop->start_wait)) == TRUE &&
g_atomic_int_get(&(audio_loop->start_done)) == FALSE){
pthread_cond_wait(audio_loop->start_cond,
audio_loop->start_mutex);
}
}
pthread_mutex_unlock(audio_loop->start_mutex);
/* start gui thread */
ags_thread_start(gui_thread);
/* wait for gui thread */
pthread_mutex_lock(gui_thread->start_mutex);
if(g_atomic_int_get(&(gui_thread->start_done)) == FALSE){
g_atomic_int_set(&(gui_thread->start_wait),
TRUE);
while(g_atomic_int_get(&(gui_thread->start_done)) == FALSE){
g_atomic_int_set(&(gui_thread->start_wait),
TRUE);
pthread_cond_wait(gui_thread->start_cond,
gui_thread->start_mutex);
}
}
pthread_mutex_unlock(gui_thread->start_mutex);
/* autosave thread */
if(!g_strcmp0(ags_config_get_value(config,
AGS_CONFIG_GENERIC,
"autosave-thread\0"),
"true\0")){
pthread_mutex_lock(audio_loop->start_mutex);
start_queue = g_atomic_pointer_get(&(audio_loop->start_queue));
start_queue = g_list_prepend(start_queue,
task_thread);
g_atomic_pointer_set(&(audio_loop->start_queue),
start_queue);
pthread_mutex_unlock(audio_loop->start_mutex);
}
/* now start read task */
simple_file_read = ags_simple_file_read_new(simple_file);
ags_task_thread_append_task((AgsTaskThread *) task_thread,
(AgsTask *) simple_file_read);
}else{
AgsFile *file;
GError *error;
file = g_object_new(AGS_TYPE_FILE,
"application-context\0", ags_application_context,
"filename\0", filename,
NULL);
error = NULL;
ags_file_open(file,
&error);
if(error != NULL){
ags_test_show_file_error(filename,
error);
ags_application_context_quit(ags_application_context);
}
ags_file_read(file);
ags_file_close(file);
}
}
}
void
ags_test_launch(gboolean single_thread)
{
AgsThread *audio_loop, *polling_thread, *gui_thread, *task_thread;
AgsThreadPool *thread_pool;
AgsConfig *config;
GList *start_queue;
g_object_get(ags_application_context,
"config", &config,
"main-loop", &audio_loop,
"task-thread", &task_thread,
NULL);
g_object_get(task_thread,
"thread-pool", &thread_pool,
NULL);
polling_thread = ags_thread_find_type(audio_loop,
AGS_TYPE_POLLING_THREAD);
gui_thread = ags_thread_find_type(audio_loop,
AGS_TYPE_GUI_THREAD);
/* start engine */
pthread_mutex_lock(audio_loop->start_mutex);
start_queue = NULL;
start_queue = g_list_prepend(start_queue,
polling_thread);
start_queue = g_list_prepend(start_queue,
task_thread);
// start_queue = g_list_prepend(start_queue,
// gui_thread);
g_atomic_pointer_set(&(audio_loop->start_queue),
start_queue);
pthread_mutex_unlock(audio_loop->start_mutex);
/* start audio loop and thread pool*/
ags_thread_start(audio_loop);
ags_thread_pool_start(thread_pool);
if(!single_thread){
/* wait for audio loop */
pthread_mutex_lock(audio_loop->start_mutex);
if(g_atomic_int_get(&(audio_loop->start_wait)) == TRUE){
g_atomic_int_set(&(audio_loop->start_done),
FALSE);
while(g_atomic_int_get(&(audio_loop->start_wait)) == TRUE &&
g_atomic_int_get(&(audio_loop->start_done)) == FALSE){
pthread_cond_wait(audio_loop->start_cond,
audio_loop->start_mutex);
}
}
pthread_mutex_unlock(audio_loop->start_mutex);
/* start gui thread */
ags_thread_start(gui_thread);
/* wait for gui thread */
pthread_mutex_lock(gui_thread->start_mutex);
if(g_atomic_int_get(&(gui_thread->start_done)) == FALSE){
g_atomic_int_set(&(gui_thread->start_wait),
TRUE);
while(g_atomic_int_get(&(gui_thread->start_done)) == FALSE){
g_atomic_int_set(&(gui_thread->start_wait),
TRUE);
pthread_cond_wait(gui_thread->start_cond,
gui_thread->start_mutex);
}
}
pthread_mutex_unlock(gui_thread->start_mutex);
g_atomic_int_set(&(AGS_XORG_APPLICATION_CONTEXT(ags_application_context)->gui_ready),
1);
/* autosave thread */
if(!g_strcmp0(ags_config_get_value(config,
AGS_CONFIG_GENERIC,
"autosave-thread\0"),
"true\0")){
pthread_mutex_lock(audio_loop->start_mutex);
start_queue = g_atomic_pointer_get(&(audio_loop->start_queue));
start_queue = g_list_prepend(start_queue,
task_thread);
g_atomic_pointer_set(&(audio_loop->start_queue),
start_queue);
pthread_mutex_unlock(audio_loop->start_mutex);
}
}else{
AgsSingleThread *single_thread;
/* single thread */
single_thread = ags_single_thread_new((GObject *) ags_sound_provider_get_soundcard(AGS_SOUND_PROVIDER(ags_application_context))->data);
/* add known threads to single_thread */
ags_thread_add_child(AGS_THREAD(single_thread),
audio_loop);
/* autosave thread */
if(!g_strcmp0(ags_config_get_value(config,
AGS_CONFIG_GENERIC,
"autosave-thread\0"),
"true\0")){
pthread_mutex_lock(audio_loop->start_mutex);
start_queue = g_atomic_pointer_get(&(audio_loop->start_queue));
start_queue = g_list_prepend(start_queue,
task_thread);
g_atomic_pointer_set(&(audio_loop->start_queue),
start_queue);
pthread_mutex_unlock(audio_loop->start_mutex);
}
/* start thread tree */
ags_thread_start((AgsThread *) single_thread);
}
}
void
ags_link_editor_apply(AgsApplicable *applicable)
{
AgsLinkEditor *link_editor;
GtkTreeIter iter;
link_editor = AGS_LINK_EDITOR(applicable);
if(gtk_combo_box_get_active_iter(link_editor->combo,
&iter)){
AgsWindow *window;
AgsMachine *link_machine;
AgsMachineEditor *machine_editor;
AgsLineEditor *line_editor;
GtkTreeModel *model;
AgsChannel *channel, *link;
AgsLinkChannel *link_channel;
AgsThread *main_loop, *current;
AgsTaskThread *task_thread;
AgsApplicationContext *application_context;
line_editor = AGS_LINE_EDITOR(gtk_widget_get_ancestor(GTK_WIDGET(link_editor),
AGS_TYPE_LINE_EDITOR));
machine_editor = gtk_widget_get_ancestor(line_editor,
AGS_TYPE_MACHINE_EDITOR);
window = machine_editor->parent;
application_context = window->application_context;
channel = line_editor->channel;
main_loop = application_context->main_loop;
task_thread = ags_thread_find_type(main_loop,
AGS_TYPE_TASK_THREAD);
model = gtk_combo_box_get_model(link_editor->combo);
gtk_tree_model_get(model,
&iter,
1, &link_machine,
-1);
if(link_machine == NULL){
/* create task */
link_channel = ags_link_channel_new(channel, NULL);
/* append AgsLinkChannel */
ags_task_thread_append_task(task_thread,
AGS_TASK(link_channel));
}else{
guint link_line;
link_line = (guint) gtk_spin_button_get_value_as_int(link_editor->spin_button);
if(AGS_IS_INPUT(channel))
link = ags_channel_nth(link_machine->audio->output,
link_line);
else
link = ags_channel_nth(link_machine->audio->input,
link_line);
/* create task */
link_channel = ags_link_channel_new(channel, link);
/* append AgsLinkChannel */
ags_task_thread_append_task(task_thread,
AGS_TASK(link_channel));
}
}
}
void
ags_link_collection_editor_apply(AgsApplicable *applicable)
{
AgsLinkCollectionEditor *link_collection_editor;
GtkTreeIter iter;
link_collection_editor = AGS_LINK_COLLECTION_EDITOR(applicable);
if(gtk_combo_box_get_active_iter(link_collection_editor->link,
&iter)){
AgsWindow *window;
AgsMachine *machine, *link_machine;
AgsMachineEditor *machine_editor;
GtkTreeModel *model;
AgsChannel *channel, *link;
AgsLinkChannel *link_channel;
AgsThread *main_loop;
AgsTaskThread *task_thread;
AgsApplicationContext *application_context;
GList *task;
guint first_line, count;
guint i;
GError *error;
machine_editor = AGS_MACHINE_EDITOR(gtk_widget_get_ancestor(GTK_WIDGET(link_collection_editor),
AGS_TYPE_MACHINE_EDITOR));
window = machine_editor->parent;
application_context = window->application_context;
machine = machine_editor->machine;
first_line = (guint) gtk_spin_button_get_value_as_int(link_collection_editor->first_line);
if(link_collection_editor->channel_type == AGS_TYPE_INPUT){
channel = ags_channel_nth(machine_editor->machine->audio->input, first_line);
}else{
channel = ags_channel_nth(machine_editor->machine->audio->output, first_line);
}
main_loop = application_context->main_loop;
task_thread = ags_thread_find_type(main_loop,
AGS_TYPE_TASK_THREAD);
model = gtk_combo_box_get_model(link_collection_editor->link);
gtk_tree_model_get(model,
&iter,
1, &link_machine,
-1);
task = NULL;
count = (guint) gtk_spin_button_get_value_as_int(link_collection_editor->count);
error = NULL;
if(link_machine == NULL){
for(i = 0; i < count; i++){
/* create task */
link_channel = ags_link_channel_new(channel, NULL);
task = g_list_prepend(task, link_channel);
channel = channel->next;
}
/* append AgsLinkChannel */
task = g_list_reverse(task);
ags_task_thread_append_tasks(task_thread,
task);
}else{
guint first_link;
first_link = (guint) gtk_spin_button_get_value_as_int(link_collection_editor->first_link);
if(link_collection_editor->channel_type == AGS_TYPE_INPUT)
link = ags_channel_nth(link_machine->audio->output, first_link);
else
link = ags_channel_nth(link_machine->audio->input, first_link);
for(i = 0; i < count; i++){
/* create task */
link_channel = ags_link_channel_new(channel, link);
task = g_list_prepend(task, link_channel);
channel = channel->next;
link = link->next;
}
task = g_list_reverse(task);
ags_task_thread_append_tasks(task_thread,
task);
}
}
}
