void
ags_drum_index0_callback(GtkWidget *widget, AgsDrum *drum)
{
if(drum->selected0 != NULL){
GtkToggleButton *toggle_button;
if(GTK_TOGGLE_BUTTON(widget) != drum->selected0){
AgsCopyPatternAudio *copy_pattern_audio;
GList *list;
toggle_button = drum->selected0;
drum->selected0 = NULL;
gtk_toggle_button_set_active(toggle_button, FALSE);
drum->selected0 = (GtkToggleButton*) widget;
list = ags_recall_find_type(AGS_MACHINE(drum)->audio->play,
AGS_TYPE_COPY_PATTERN_AUDIO);
if(list != NULL){
GValue value = {0,};
g_value_init(&value, G_TYPE_UINT);
g_value_set_uint(&value, GPOINTER_TO_UINT(g_object_get_data((GObject *) widget, AGS_DRUM_INDEX)));
copy_pattern_audio = AGS_COPY_PATTERN_AUDIO(list->data);
ags_port_safe_write(copy_pattern_audio->bank_index_0, &value);
g_value_unset(&value);
}
list = ags_recall_find_type(AGS_MACHINE(drum)->audio->recall,
AGS_TYPE_COPY_PATTERN_AUDIO);
if(list != NULL){
GValue value = {0,};
g_value_init(&value, G_TYPE_UINT);
g_value_set_uint(&value, GPOINTER_TO_UINT(g_object_get_data((GObject *) widget, AGS_DRUM_INDEX)));
copy_pattern_audio = AGS_COPY_PATTERN_AUDIO(list->data);
ags_port_safe_write(copy_pattern_audio->bank_index_0, &value);
g_value_unset(&value);
}
}else if(! gtk_toggle_button_get_active(drum->selected0)){
toggle_button = drum->selected0;
drum->selected0 = NULL;
gtk_toggle_button_set_active((GtkToggleButton *) widget, TRUE);
drum->selected0 = (GtkToggleButton*) widget;
}
ags_drum_set_pattern(drum);
}
}
void
ags_panel_init(AgsPanel *panel)
{
g_signal_connect_after((GObject *) panel, "parent-set",
G_CALLBACK(ags_panel_parent_set_callback), (gpointer) panel);
ags_machine_popup_add_connection_options((AgsMachine *) panel,
(AGS_MACHINE_POPUP_CONNECTION_EDITOR));
AGS_MACHINE(panel)->connection_flags |= AGS_MACHINE_SHOW_AUDIO_OUTPUT_CONNECTION;
ags_audio_set_flags(AGS_MACHINE(panel)->audio, (AGS_AUDIO_SYNC));
g_object_set(AGS_MACHINE(panel)->audio,
"min-audio-channels", 1,
"min-output-pads", 1,
"min-input-pads", 1,
NULL);
AGS_MACHINE(panel)->input_pad_type = AGS_TYPE_PANEL_INPUT_PAD;
AGS_MACHINE(panel)->input_pad_type = AGS_TYPE_PANEL_INPUT_PAD;
AGS_MACHINE(panel)->input_line_type = AGS_TYPE_PANEL_INPUT_LINE;
AGS_MACHINE(panel)->output_pad_type = G_TYPE_NONE;
AGS_MACHINE(panel)->output_line_type = G_TYPE_NONE;
g_signal_connect(G_OBJECT(panel), "resize-audio-channels",
G_CALLBACK(ags_panel_resize_audio_channels), NULL);
g_signal_connect(G_OBJECT(panel), "resize-pads",
G_CALLBACK(ags_panel_resize_pads), NULL);
/* */
panel->name = NULL;
panel->xml_type = "ags-panel";
panel->vbox = (GtkVBox *) gtk_vbox_new(FALSE, 0);
gtk_container_add((GtkContainer*) (gtk_bin_get_child((GtkBin *) panel)), (GtkWidget *) panel->vbox);
/* output - discard messages */
g_hash_table_insert(ags_machine_generic_output_message_monitor,
panel,
ags_machine_generic_output_message_monitor_timeout);
g_timeout_add(1000 / 30,
(GSourceFunc) ags_machine_generic_output_message_monitor_timeout,
(gpointer) panel);
/* input */
AGS_MACHINE(panel)->input = (GtkContainer *) gtk_hbox_new(FALSE, 0);
gtk_box_pack_start((GtkBox *) panel->vbox, (GtkWidget *) AGS_MACHINE(panel)->input, FALSE, FALSE, 0);
}
void
ags_ffplayer_open_clicked_callback(GtkWidget *widget, AgsFFPlayer *ffplayer)
{
GtkFileChooserDialog *file_chooser;
file_chooser = ags_machine_file_chooser_dialog_new(AGS_MACHINE(ffplayer));
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser),
FALSE);
g_signal_connect((GObject *) file_chooser, "response\0",
G_CALLBACK(ags_ffplayer_open_dialog_response_callback), AGS_MACHINE(ffplayer));
gtk_widget_show_all((GtkWidget *) file_chooser);
}
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_menu_action_add_matrix_callback(GtkWidget *menu_item, gpointer data)
{
AgsWindow *window;
AgsMatrix *matrix;
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 matrix */
matrix = ags_matrix_new(G_OBJECT(window->soundcard));
add_audio = ags_add_audio_new((AgsApplicationContext *) window->application_context,
AGS_MACHINE(matrix)->audio);
ags_gui_thread_schedule_task((AgsGuiThread *) gui_thread,
(GObject *) add_audio);
gtk_box_pack_start((GtkBox *) window->machines,
GTK_WIDGET(matrix),
FALSE, FALSE,
0);
/* connect everything */
ags_connectable_connect(AGS_CONNECTABLE(matrix));
/* */
AGS_MACHINE(matrix)->audio->audio_channels = 1;
/* AgsMatrixInputPad */
ags_audio_set_pads(AGS_MACHINE(matrix)->audio,
AGS_TYPE_INPUT,
78, 0);
ags_audio_set_pads(AGS_MACHINE(matrix)->audio,
AGS_TYPE_OUTPUT,
1, 0);
/* */
gtk_widget_show_all(GTK_WIDGET(matrix));
}
void
ags_mixer_parent_set_callback(GtkWidget *widget, GtkObject *old_parent, AgsMixer *mixer)
{
AgsWindow *window;
gchar *str;
if(old_parent != NULL){
return;
}
window = (AgsWindow *) gtk_widget_get_toplevel(widget);
str = g_strdup_printf("Default %d",
ags_window_find_machine_counter(window, AGS_TYPE_MIXER)->counter);
g_object_set(AGS_MACHINE(mixer),
"machine-name", str,
NULL);
ags_window_increment_machine_counter(window,
AGS_TYPE_MIXER);
g_free(str);
}
void
ags_audiorec_connect(AgsConnectable *connectable)
{
AgsWindow *window;
AgsAudiorec *audiorec;
GList *list;
if((AGS_MACHINE_CONNECTED & (AGS_MACHINE(connectable)->flags)) != 0){
return;
}
ags_audiorec_parent_connectable_interface->connect(connectable);
audiorec = AGS_AUDIOREC(connectable);
/* filename */
g_signal_connect(audiorec->open, "clicked",
G_CALLBACK(ags_audiorec_open_callback), audiorec);
/* mode */
g_signal_connect_after(audiorec->keep_data, "clicked",
G_CALLBACK(ags_audiorec_keep_data_callback), audiorec);
g_signal_connect_after(audiorec->mix_data, "clicked",
G_CALLBACK(ags_audiorec_mix_data_callback), audiorec);
g_signal_connect_after(audiorec->replace_data, "clicked",
G_CALLBACK(ags_audiorec_replace_data_callback), audiorec);
}
void
ags_drum_input_line_connect(AgsConnectable *connectable)
{
AgsDrum *drum;
AgsDrumInputLine *drum_input_line;
GList *line_member;
drum_input_line = AGS_DRUM_INPUT_LINE(connectable);
if((AGS_LINE_CONNECTED & (AGS_LINE(drum_input_line)->flags)) != 0){
return;
}
ags_drum_input_line_parent_connectable_interface->connect(connectable);
/* AgsDrumInputLine */
drum = AGS_DRUM(gtk_widget_get_ancestor((GtkWidget *) AGS_LINE(drum_input_line)->pad, AGS_TYPE_DRUM));
/* AgsAudio */
g_signal_connect_after(G_OBJECT(AGS_MACHINE(drum)->audio), "set_pads\0",
G_CALLBACK(ags_drum_input_line_audio_set_pads_callback), drum_input_line);
/* AgsDrumInputLine */
}
void
ags_mixer_init(AgsMixer *mixer)
{
g_signal_connect_after((GObject *) mixer, "parent_set\0",
G_CALLBACK(ags_mixer_parent_set_callback), (gpointer) mixer);
AGS_MACHINE(mixer)->input_pad_type = AGS_TYPE_MIXER_INPUT_PAD;
AGS_MACHINE(mixer)->audio->flags |= (AGS_AUDIO_ASYNC);
mixer->name = NULL;
mixer->xml_type = "ags-mixer\0";
mixer->input_pad = (GtkHBox *) gtk_hbox_new(FALSE, 0);
AGS_MACHINE(mixer)->input = (GtkContainer *) mixer->input_pad;
gtk_container_add((GtkContainer*) (gtk_container_get_children((GtkContainer *) mixer))->data, (GtkWidget *) mixer->input_pad);
}
void
ags_panel_parent_set_callback(GtkWidget *widget, GtkObject *old_parent, AgsPanel *panel)
{
AgsWindow *window;
gchar *str;
if(old_parent != NULL){
return;
}
window = AGS_WINDOW(gtk_widget_get_toplevel(widget));
str = g_strdup_printf("Default %d",
ags_window_find_machine_counter(window, AGS_TYPE_PANEL)->counter);
g_object_set(AGS_MACHINE(panel),
"machine-name", str,
NULL);
ags_window_increment_machine_counter(window,
AGS_TYPE_PANEL);
g_free(str);
}
void
ags_link_editor_reset(AgsApplicable *applicable)
{
AgsLinkEditor *link_editor;
GtkTreeModel *model;
GtkTreeIter iter;
link_editor = AGS_LINK_EDITOR(applicable);
model = gtk_combo_box_get_model(link_editor->combo);
if(gtk_tree_model_get_iter_first(model,
&iter)){
AgsMachine *machine, *link;
AgsLineEditor *line_editor;
AgsChannel *channel;
gint i;
gboolean found;
line_editor = AGS_LINE_EDITOR(gtk_widget_get_ancestor(GTK_WIDGET(link_editor),
AGS_TYPE_LINE_EDITOR));
channel = line_editor->channel;
if(channel->link != NULL)
machine = AGS_MACHINE(AGS_AUDIO(channel->link->audio)->machine_widget);
else
machine = NULL;
i = 0;
found = FALSE;
do{
gtk_tree_model_get(model,
&iter,
1, &link,
-1);
if(machine == link){
found = TRUE;
break;
}
i++;
}while(gtk_tree_model_iter_next(model,
&iter));
if(found){
gtk_combo_box_set_active(link_editor->combo, i);
if(channel->link == NULL)
gtk_spin_button_set_value(link_editor->spin_button, 0);
else
gtk_spin_button_set_value(link_editor->spin_button, channel->link->line);
}else
gtk_combo_box_set_active(link_editor->combo, -1);
}
}
void
ags_matrix_connect(AgsConnectable *connectable)
{
AgsMatrix *matrix;
AgsDelayAudioRun *play_delay_audio_run;
AgsRecallHandler *recall_handler;
GList *list;
int i;
if((AGS_MACHINE_CONNECTED & (AGS_MACHINE(connectable)->flags)) != 0){
return;
}
ags_matrix_parent_connectable_interface->connect(connectable);
matrix = AGS_MATRIX(connectable);
/* AgsMatrix */
for(i = 0; i < 9; i++){
g_signal_connect (G_OBJECT (matrix->index[i]), "clicked\0",
G_CALLBACK (ags_matrix_index_callback), (gpointer) matrix);
}
g_signal_connect (G_OBJECT (matrix->drawing_area), "expose_event\0",
G_CALLBACK (ags_matrix_drawing_area_expose_callback), (gpointer) matrix);
g_signal_connect (G_OBJECT (matrix->drawing_area), "button_press_event\0",
G_CALLBACK (ags_matrix_drawing_area_button_press_callback), (gpointer) matrix);
g_signal_connect (G_OBJECT (matrix->adjustment), "value_changed\0",
G_CALLBACK (ags_matrix_adjustment_value_changed_callback), (gpointer) matrix);
g_signal_connect_after((GObject *) matrix->length_spin, "value-changed\0",
G_CALLBACK(ags_matrix_length_spin_callback), (gpointer) matrix);
g_signal_connect((GObject *) matrix->loop_button, "clicked\0",
G_CALLBACK(ags_matrix_loop_button_callback), (gpointer) matrix);
g_signal_connect_after(G_OBJECT(AGS_MACHINE(matrix)->audio), "tact\0",
G_CALLBACK(ags_matrix_tact_callback), matrix);
g_signal_connect_after(G_OBJECT(AGS_MACHINE(matrix)->audio), "done\0",
G_CALLBACK(ags_matrix_done_callback), matrix);
}
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_drum_sequencer_count_callback(AgsDelayAudioRun *delay_audio_run,
guint nth_run,
guint delay, guint attack,
AgsDrum *drum)
{
AgsWindow *window;
AgsAudio *audio;
AgsCountBeatsAudio *play_count_beats_audio;
AgsCountBeatsAudioRun *play_count_beats_audio_run;
AgsToggleLed *toggle_led;
GList *list;
guint counter, active_led;
gdouble active_led_old, active_led_new;
GValue value = {0,};
window = AGS_WINDOW(gtk_widget_get_ancestor((GtkWidget *) drum, AGS_TYPE_WINDOW));
audio = AGS_MACHINE(drum)->audio;
/* get some recalls */
list = ags_recall_find_type(audio->play,
AGS_TYPE_COUNT_BEATS_AUDIO);
if(list != NULL){
play_count_beats_audio = AGS_COUNT_BEATS_AUDIO(list->data);
}
list = ags_recall_find_type_with_recycling_container(audio->play,
AGS_TYPE_COUNT_BEATS_AUDIO_RUN,
(GObject *) AGS_RECALL(delay_audio_run)->recall_id->recycling_container);
if(list != NULL){
play_count_beats_audio_run = AGS_COUNT_BEATS_AUDIO_RUN(list->data);
}
/* set optical feedback */
active_led_new = (guint) play_count_beats_audio_run->sequencer_counter % AGS_DRUM_PATTERN_CONTROLS;
drum->active_led = (guint) active_led_new;
if(play_count_beats_audio_run->sequencer_counter == 0){
g_value_init(&value, G_TYPE_DOUBLE);
ags_port_safe_read(play_count_beats_audio->sequencer_loop_end,
&value);
active_led_old = (guint) (g_value_get_double(&value) - 1.0) % AGS_DRUM_PATTERN_CONTROLS;
}else{
active_led_old = (guint) (drum->active_led - 1.0) % AGS_DRUM_PATTERN_CONTROLS;
}
toggle_led = ags_toggle_led_new(gtk_container_get_children(GTK_CONTAINER(drum->led)),
(guint) active_led_new,
(guint) active_led_old);
ags_task_thread_append_task(AGS_TASK_THREAD(AGS_AUDIO_LOOP(AGS_MAIN(window->ags_main)->main_loop)->task_thread),
AGS_TASK(toggle_led));
}
void
ags_drum_init_audio_launch_callback(AgsTask *task, AgsDrum *drum)
{
AgsAudio *audio;
audio = AGS_MACHINE(drum)->audio;
g_signal_connect_after(audio, "done\0",
G_CALLBACK(ags_drum_audio_done_callback), drum);
}
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_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_panel_disconnect(AgsConnectable *connectable)
{
if((AGS_MACHINE_CONNECTED & (AGS_MACHINE(connectable)->flags)) == 0){
return;
}
ags_panel_parent_connectable_interface->disconnect(connectable);
/* empty */
}
void
ags_matrix_output_map_recall(AgsMatrix *matrix, guint output_pad_start)
{
AgsAudio *audio;
AgsChannel *source;
AgsDelayAudio *recall_delay_audio;
AgsCountBeatsAudioRun *recall_count_beats_audio_run;
GList *list;
audio = AGS_MACHINE(matrix)->audio;
if(matrix->mapped_output_pad > output_pad_start){
return;
}
source = ags_channel_nth(audio->output,
output_pad_start * audio->audio_channels);
if(source == NULL){
return;
}
/* get some recalls */
list = ags_recall_find_type(audio->play, AGS_TYPE_DELAY_AUDIO);
if(list != NULL){
recall_delay_audio = AGS_DELAY_AUDIO(list->data);
}else{
recall_delay_audio = NULL;
}
list = ags_recall_find_type(audio->play, AGS_TYPE_COUNT_BEATS_AUDIO_RUN);
if(list != NULL){
recall_count_beats_audio_run = AGS_COUNT_BEATS_AUDIO_RUN(list->data);
}else{
recall_count_beats_audio_run = NULL;
}
/* ags-stream */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-stream\0",
source->audio_channel, source->audio_channel + 1,
output_pad_start, audio->output_pads,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_ADD),
0);
matrix->mapped_output_pad = output_pad_start;
}
void
ags_mixer_init(AgsMixer *mixer)
{
g_signal_connect_after((GObject *) mixer, "parent_set\0",
G_CALLBACK(ags_mixer_parent_set_callback), (gpointer) mixer);
AGS_MACHINE(mixer)->audio->flags |= (AGS_AUDIO_ASYNC);
AGS_MACHINE(mixer)->input_pad_type = AGS_TYPE_MIXER_INPUT_PAD;
AGS_MACHINE(mixer)->input_line_type = AGS_TYPE_MIXER_INPUT_LINE;
AGS_MACHINE(mixer)->output_pad_type = G_TYPE_NONE;
AGS_MACHINE(mixer)->output_line_type = G_TYPE_NONE;
/* AgsAudio */
g_signal_connect_after(G_OBJECT(mixer->machine.audio), "set_audio_channels\0",
G_CALLBACK(ags_mixer_set_audio_channels), NULL);
g_signal_connect_after(G_OBJECT(mixer->machine.audio), "set_pads\0",
G_CALLBACK(ags_mixer_set_pads), NULL);
/* */
mixer->name = NULL;
mixer->xml_type = "ags-mixer\0";
mixer->input_pad = (GtkHBox *) gtk_hbox_new(FALSE, 0);
AGS_MACHINE(mixer)->input = (GtkContainer *) mixer->input_pad;
gtk_container_add((GtkContainer*) (gtk_container_get_children((GtkContainer *) mixer))->data, (GtkWidget *) mixer->input_pad);
}
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_replicator_bridge_connect(AgsConnectable *connectable)
{
AgsReplicatorBridge *replicator_bridge;
if((AGS_MACHINE_CONNECTED & (AGS_MACHINE(connectable)->flags)) != 0){
return;
}
ags_replicator_bridge_parent_connectable_interface->connect(connectable);
replicator_bridge = AGS_REPLICATOR_BRIDGE(connectable);
}
/**
* ags_desk_new:
* @soundcard: the assigned soundcard.
*
* Creates an #AgsDesk
*
* Returns: a new #AgsDesk
*
* Since: 2.0.0
*/
AgsDesk*
ags_desk_new(GObject *soundcard)
{
AgsDesk *desk;
desk = (AgsDesk *) g_object_new(AGS_TYPE_DESK,
NULL);
g_object_set(G_OBJECT(AGS_MACHINE(desk)->audio),
"soundcard", soundcard,
NULL);
return(desk);
}
/**
* ags_panel_new:
* @soundcard: the assigned soundcard.
*
* Create a new instance of #AgsPanel
*
* Returns: the new #AgsPanel
*
* Since: 2.0.0
*/
AgsPanel*
ags_panel_new(GObject *soundcard)
{
AgsPanel *panel;
panel = (AgsPanel *) g_object_new(AGS_TYPE_PANEL,
NULL);
g_object_set(AGS_MACHINE(panel)->audio,
"output-soundcard", soundcard,
NULL);
return(panel);
}
/**
* ags_audiorec_new:
* @soundcard: the assigned soundcard.
*
* Create a new instance of #AgsAudiorec
*
* Returns: the new #AgsAudiorec
*
* Since: 2.0.0
*/
AgsAudiorec*
ags_audiorec_new(GObject *soundcard)
{
AgsAudiorec *audiorec;
audiorec = (AgsAudiorec *) g_object_new(AGS_TYPE_AUDIOREC,
NULL);
g_object_set(G_OBJECT(AGS_MACHINE(audiorec)->audio),
"output-soundcard", soundcard,
NULL);
return(audiorec);
}
AgsMixer*
ags_mixer_new(GObject *devout)
{
AgsMixer *mixer;
mixer = (AgsMixer *) g_object_new(AGS_TYPE_MIXER,
NULL);
g_object_set(G_OBJECT(AGS_MACHINE(mixer)->audio),
"devout\0", devout,
NULL);
return(mixer);
}
void
ags_panel_parent_set_callback(GtkWidget *widget, GtkObject *old_parent, AgsPanel *panel)
{
AgsWindow *window;
if(old_parent != NULL)
return;
window = AGS_WINDOW(gtk_widget_get_toplevel(widget));
AGS_MACHINE(panel)->name = g_strdup_printf("Default %d\0",
ags_window_find_machine_counter(window, AGS_TYPE_PANEL)->counter);
ags_window_increment_machine_counter(window,
AGS_TYPE_PANEL);
}
void
ags_synth_parent_set_callback(GtkWidget *widget, GtkObject *old_parent, AgsSynth *synth)
{
AgsWindow *window;
if(old_parent != NULL)
return;
window = (AgsWindow *) gtk_widget_get_toplevel(widget);
AGS_MACHINE(synth)->name = g_strdup_printf("Default %d\0",
ags_window_find_machine_counter(window, AGS_TYPE_SYNTH)->counter);
ags_window_increment_machine_counter(window,
AGS_TYPE_SYNTH);
}
void
ags_drum_parent_set_callback(GtkWidget *widget, GtkObject *old_parent, AgsDrum *drum)
{
AgsWindow *window;
if(old_parent != NULL)
return;
window = AGS_WINDOW(gtk_widget_get_ancestor((GtkWidget *) drum, AGS_TYPE_WINDOW));
AGS_MACHINE(drum)->name = g_strdup_printf("Default %d\0",
ags_window_find_machine_counter(window, AGS_TYPE_DRUM)->counter);
ags_window_increment_machine_counter(window,
AGS_TYPE_DRUM);
}
void
ags_desk_disconnect(AgsConnectable *connectable)
{
AgsDesk *desk;
int i;
if((AGS_MACHINE_CONNECTED & (AGS_MACHINE(connectable)->flags)) == 0){
return;
}
desk = AGS_DESK(connectable);
/* call parent */
ags_desk_parent_connectable_interface->disconnect(connectable);
}