Changeset 417

Show
Ignore:
Timestamp:
07/21/06 23:01:25 (2 years ago)
Author:
kickback
Message:

aube: replace some gtk functions and macros with recommended glib/gobject replacements. also remove unused custom signal marshaller in klav.c

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • aube/trunk/src/about_dialog.c

    r413 r417  
    3434    gtk_window_set_policy(GTK_WINDOW(about_dialog), FALSE, FALSE, FALSE); 
    3535    gtk_window_position(GTK_WINDOW(about_dialog), GTK_WIN_POS_CENTER); 
    36     gtk_signal_connect(GTK_OBJECT(about_dialog), "destroy", 
     36    g_signal_connect(G_OBJECT(about_dialog), "destroy", 
    3737                       (GtkSignalFunc) about_dialog_destroy, NULL); 
    38     gtk_signal_connect(GTK_OBJECT(about_dialog), "button_press_event", 
     38    g_signal_connect(G_OBJECT(about_dialog), "button_press_event", 
    3939                       (GtkSignalFunc) about_dialog_button, NULL); 
    4040    gtk_widget_set_events(about_dialog, GDK_BUTTON_PRESS_MASK); 
    …… 
    5757 
    5858    logo_area = gtk_drawing_area_new(); 
    59     gtk_signal_connect(GTK_OBJECT(logo_area), "expose_event", 
     59    g_signal_connect(G_OBJECT(logo_area), "expose_event", 
    6060                       (GtkSignalFunc) about_dialog_logo_expose, NULL); 
    6161    gtk_drawing_area_size(GTK_DRAWING_AREA(logo_area), logo_width, logo_height); 

  • aube/trunk/src/aube.c

    r413 r417  
    248248  m->has_if = m->class->new_if(m); 
    249249  gtk_widget_show(m->has_if); 
    250   gtk_signal_emit(GTK_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL]); 
     250  g_signal_emit(G_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL], 0); 
    251251  return 1; 
    252252} 
    …… 
    258258  master_ack_channels_modified(); 
    259259#if 0 
    260   gtk_signal_emit(GTK_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL]); 
     260  g_signal_emit(G_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL], 0); 
    261261#endif 
    262262  return 1; 
    …… 
    306306 
    307307  /* 
    308     gtk_signal_emit(GTK_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL]); 
    309   */ 
     308    g_signal_emit(G_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL], 0); 
     309  */ 
    310310 
    311311  return 1; 
    …… 
    329329  master_ack_channels_modified(); 
    330330#if 0 
    331   gtk_signal_emit(GTK_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL]); 
     331  g_signal_emit(G_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL], 0); 
    332332#endif 
    333333 
    …… 
    343343  master_ack_channels_modified(); 
    344344#if 0 
    345   gtk_signal_emit(GTK_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL]); 
     345  g_signal_emit(G_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL], 0); 
    346346#endif 
    347347 
    …… 
    363363  master_ack_channels_modified(); 
    364364#if 0 
    365   gtk_signal_emit(GTK_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL]); 
     365  g_signal_emit(G_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL], 0); 
    366366#endif 
    367367 

  • aube/trunk/src/inputoption.c

    r413 r417  
    111111  widget = gtk_button_new_with_label("Reread"); 
    112112  gtk_box_pack_start(GTK_BOX(inputoption), widget, FALSE, FALSE, 0); 
    113   gtk_signal_connect(GTK_OBJECT(widget), "clicked", 
    114                      GTK_SIGNAL_FUNC(reread_inputs_cb), inputoption); 
     113  g_signal_connect(G_OBJECT(widget), "clicked", 
     114                     G_CALLBACK(reread_inputs_cb), inputoption); 
    115115  gtk_widget_show(widget); 
    116116#endif 
    117117 
    118   inputoption->handler_id = gtk_signal_connect(GTK_OBJECT(master_daddy), 
    119          "modules_changed", GTK_SIGNAL_FUNC(reread_inputs_cb), inputoption); 
     118  inputoption->handler_id = g_signal_connect(G_OBJECT(master_daddy), 
     119         "modules_changed", G_CALLBACK(reread_inputs_cb), inputoption); 
    120120 
    121121#if 0 
    122122  gtk_widget_realize(hbox); 
    123   gtk_signal_connect(GTK_OBJECT(hbox), "drop_data_available_event", 
    124                      GTK_SIGNAL_FUNC(inputoption_dnd_drop), hbox); 
     123  g_signal_connect(G_OBJECT(hbox), "drop_data_available_event", 
     124                     G_CALLBACK(inputoption_dnd_drop), hbox); 
    125125  gtk_widget_dnd_drop_set(hbox, TRUE, accepted_drop_types, 1, FALSE); 
    126126#endif 
    127127 
    128   gtk_signal_connect(GTK_OBJECT(inputoption), "destroy", 
    129                      GTK_SIGNAL_FUNC(inputoption_dismiss), inputoption); 
     128  g_signal_connect(G_OBJECT(inputoption), "destroy", 
     129                     G_CALLBACK(inputoption_dismiss), inputoption); 
    130130 
    131131  return GTK_WIDGET(inputoption); 
    …… 
    143143inputoption_dismiss(GtkWidget * widget, gpointer data) 
    144144{ 
    145   gtk_signal_disconnect(GTK_OBJECT(master_daddy), 
     145  gtk_signal_disconnect(G_OBJECT(master_daddy), 
    146146                        INPUTOPTION(data)->handler_id); 
    147147  gtk_widget_destroy(GTK_WIDGET(data)); 
    …… 
    193193      INPUTOPTION(data)->ip[k].data = data; 
    194194      gtk_menu_append(GTK_MENU(INPUTOPTION(data)->inputsmenu), menuitem); 
    195       gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    196              GTK_SIGNAL_FUNC(select_input_cb), &(INPUTOPTION(data)->ip[k])); 
     195      g_signal_connect(G_OBJECT(menuitem), "activate", 
     196             G_CALLBACK(select_input_cb), &(INPUTOPTION(data)->ip[k])); 
    197197      gtk_widget_show(menuitem); 
    198198      k++; 
    …… 
    227227          INPUTOPTION(data)->ip[k].data = data; 
    228228          gtk_menu_append(GTK_MENU(INPUTOPTION(data)->inputsmenu), menuitem); 
    229           gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    230              GTK_SIGNAL_FUNC(select_input_cb), &(INPUTOPTION(data)->ip[k])); 
     229          g_signal_connect(G_OBJECT(menuitem), "activate", 
     230             G_CALLBACK(select_input_cb), &(INPUTOPTION(data)->ip[k])); 
    231231          gtk_widget_show(menuitem); 
    232232          k++; 

  • aube/trunk/src/master.c

    r413 r417  
    277277  menuitem = gtk_menu_item_new_with_label("Load Sample..."); 
    278278  gtk_menu_append(GTK_MENU(menu), menuitem); 
    279   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    280                      GTK_SIGNAL_FUNC(sample_load_cb), NULL); 
     279  g_signal_connect(G_OBJECT(menuitem), "activate", 
     280                     G_CALLBACK(sample_load_cb), NULL); 
    281281  gtk_widget_show(menuitem); 
    282282  gtk_widget_add_accelerator (menuitem, "activate", accel_group, 
    …… 
    288288  gtk_menu_append(GTK_MENU(menu), menuitem); 
    289289#if HAVE_LIBSNDFILE 
    290   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    291                      GTK_SIGNAL_FUNC(aube_samplelist_create), NULL); 
     290  g_signal_connect(G_OBJECT(menuitem), "activate", 
     291                     G_CALLBACK(aube_samplelist_create), NULL); 
    292292#else 
    293293  gtk_widget_set_state(GTK_WIDGET(menuitem), GTK_STATE_INSENSITIVE); 
    …… 
    298298  menuitem = gtk_menu_item_new_with_label("Clear Workspace"); 
    299299  gtk_menu_append(GTK_MENU(menu), menuitem); 
    300   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    301                      GTK_SIGNAL_FUNC(clear_workspace_cb), NULL); 
     300  g_signal_connect(G_OBJECT(menuitem), "activate", 
     301                     G_CALLBACK(clear_workspace_cb), NULL); 
    302302  gtk_widget_show(menuitem); 
    303303   
    …… 
    318318  menuitem = gtk_menu_item_new_with_label("Quit"); 
    319319  gtk_menu_append(GTK_MENU(menu), menuitem); 
    320   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    321                      GTK_SIGNAL_FUNC(quit_cb), master); 
     320  g_signal_connect(G_OBJECT(menuitem), "activate", 
     321                     G_CALLBACK(quit_cb), master); 
    322322  gtk_widget_show(menuitem); 
    323323  gtk_widget_add_accelerator (menuitem, "activate", accel_group, 
    …… 
    354354    menuitem = gtk_menu_item_new_with_label(module_classes[i]->u_name); 
    355355    gtk_menu_append(GTK_MENU(module_type_menus[module_classes[i]->category]), menuitem); 
    356     gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    357                        GTK_SIGNAL_FUNC(new_module_cb), module_classes[i]); 
     356    g_signal_connect(G_OBJECT(menuitem), "activate", 
     357                       G_CALLBACK(new_module_cb), module_classes[i]); 
    358358    gtk_widget_show(menuitem); 
    359359  } 
    …… 
    381381  gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu2); 
    382382  gtk_menu_append(GTK_MENU(menu), menuitem); 
    383   gtk_signal_connect(GTK_OBJECT(master), "modules_changed", 
    384                      GTK_SIGNAL_FUNC(change_unhide_menu_cb), menuitem); 
     383  g_signal_connect(G_OBJECT(master), "modules_changed", 
     384                     G_CALLBACK(change_unhide_menu_cb), menuitem); 
    385385  gtk_widget_show(menuitem); 
    386386 
    …… 
    430430    button = gtk_button_new_with_label (module_classes[i]->u_name); 
    431431    gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 1); 
    432     gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    433                        GTK_SIGNAL_FUNC(new_module_cb), module_classes[i]); 
     432    g_signal_connect(G_OBJECT(button), "clicked", 
     433                       G_CALLBACK(new_module_cb), module_classes[i]); 
    434434    gtk_widget_show (button); 
    435435  } 
    …… 
    462462 
    463463  /*  aube_samplelist->handler_id =*/ 
    464     gtk_signal_connect(GTK_OBJECT(master), 
     464    g_signal_connect(G_OBJECT(master), 
    465465                       "modules_changed", 
    466                        GTK_SIGNAL_FUNC(aube_refresh_samplelist), 
     466                       G_CALLBACK(aube_refresh_samplelist), 
    467467                       clist); 
    468   gtk_signal_connect(GTK_OBJECT(clist), "button_press_event", 
    469                      GTK_SIGNAL_FUNC(aube_samplelist_events), clist); 
     468  g_signal_connect(G_OBJECT(clist), "button_press_event", 
     469                     G_CALLBACK(aube_samplelist_events), clist); 
    470470 
    471471  /*  aube_samplelist->commands_menu = gtk_menu_new();*/ 
    …… 
    477477  menuitem = gtk_menu_item_new_with_label("Save..."); 
    478478  gtk_menu_append(GTK_MENU(commands_menu), menuitem); 
    479   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    480                      GTK_SIGNAL_FUNC(sample_save_cb), NULL); 
     479  g_signal_connect(G_OBJECT(menuitem), "activate", 
     480                     G_CALLBACK(sample_save_cb), NULL); 
    481481  gtk_widget_show(menuitem); 
    482482 
    483483  menuitem = gtk_menu_item_new_with_label("Close"); 
    484484  gtk_menu_append(GTK_MENU(commands_menu), menuitem); 
    485   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    486                      GTK_SIGNAL_FUNC(aube_remove_sample_cb), clist); 
     485  g_signal_connect(G_OBJECT(menuitem), "activate", 
     486                     G_CALLBACK(aube_remove_sample_cb), clist); 
    487487  gtk_widget_show(menuitem); 
    488488 
    …… 
    542542master_ack_channels_modified(void) 
    543543{ 
    544   gtk_signal_emit(GTK_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL]); 
     544  g_signal_emit(G_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL], 0); 
    545545} 
    546546 
    …… 
    563563  u->class = ui; 
    564564  gtk_widget_show(w); 
    565   gtk_signal_emit(GTK_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL]); 
     565  g_signal_emit(G_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL], 0); 
    566566#endif 
    567567} 
    …… 
    594594    u->class = ui; 
    595595    gtk_widget_show(w); 
    596     gtk_signal_emit(GTK_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL]); 
     596    g_signal_emit(G_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL], 0); 
    597597  } else { 
    598598    aube_error(AUBE_MESSAGE, "This module cannot be cloned."); 
    …… 
    622622  } 
    623623  if (l > 0) 
    624     gtk_signal_emit(GTK_OBJECT(master_daddy), 
    625                     master_signals[UNITS_CHANGED_SIGNAL]); 
     624          g_signal_emit(G_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL], 0); 
     625 
    626626} 
    627627 
    …… 
    666666  u->has_if = w; 
    667667  gtk_widget_show(w); 
    668   gtk_signal_emit(GTK_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL]); 
     668  g_signal_emit(G_OBJECT(master_daddy), master_signals[UNITS_CHANGED_SIGNAL], 0); 
    669669} 
    670670 

  • aube/trunk/src/modules/atonal_if.c

    r412 r417  
    100100    * as defined above. The data passed to the callback function is 
    101101    * NULL and is ignored in the callback. */ 
    102    gtk_signal_connect(GTK_OBJECT(atonal_if), "delete_event", 
    103                       GTK_SIGNAL_FUNC(delete_event), NULL); 
     102   g_signal_connect(G_OBJECT(atonal_if), "delete_event", 
     103                      G_CALLBACK(delete_event), NULL); 
    104104#endif 
    105105 
    …… 
    108108    * This event occurs when we call gtk_widget_destroy() on the 
    109109    * window, or if we return "TRUE" in the "delete_event" callback. */ 
    110    gtk_signal_connect(GTK_OBJECT(atonal_if), "destroy", 
    111                       GTK_SIGNAL_FUNC(atonal_if_close_cb), atonal_if); 
     110   g_signal_connect(G_OBJECT(atonal_if), "destroy", 
     111                      G_CALLBACK(atonal_if_close_cb), atonal_if); 
    112112#endif 
    113113    
    …… 
    123123  gtk_box_pack_start(GTK_BOX(hbox2), button, FALSE, FALSE, 1); 
    124124  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), atonal_if->data->module.on); 
    125   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    126     GTK_SIGNAL_FUNC(atonal_if_onoff_cb), atonal_if->data); 
     125  g_signal_connect(G_OBJECT(button), "clicked", 
     126    G_CALLBACK(atonal_if_onoff_cb), atonal_if->data); 
    127127  gtk_widget_show(button); 
    128128    
    …… 
    135135  button = gtk_button_new_with_label("Clear"); 
    136136  gtk_box_pack_start(GTK_BOX(hbox2), button, TRUE, TRUE, 1); 
    137   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    138     GTK_SIGNAL_FUNC(at_clear_cb), atonal_if); 
     137  g_signal_connect(G_OBJECT(button), "clicked", 
     138    G_CALLBACK(at_clear_cb), atonal_if); 
    139139  gtk_widget_show(button); 
    140140 
    141141  button = gtk_button_new_with_label("Chaos"); 
    142142  gtk_box_pack_start(GTK_BOX(hbox2), button, TRUE, TRUE, 1); 
    143   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    144     GTK_SIGNAL_FUNC(at_chaos_cb), atonal_if); 
     143  g_signal_connect(G_OBJECT(button), "clicked", 
     144    G_CALLBACK(at_chaos_cb), atonal_if); 
    145145  gtk_widget_show(button); 
    146146#endif 
    …… 
    186186    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), 
    187187      (atonal_if->data->sequence[i].trigger==1)); 
    188     gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    189       GTK_SIGNAL_FUNC(atonal_if_set_note_cb), atonal_if); 
     188    g_signal_connect(G_OBJECT(button), "clicked", 
     189      G_CALLBACK(atonal_if_set_note_cb), atonal_if); 
    190190    gtk_widget_show(button); 
    191191    atonal_if->buttons[i].button = button; 
    …… 
    209209  atonal_if = ATONAL_IF(data); 
    210210  for(i=0; i<AT_LENGTH; i++) { 
    211     gtk_signal_handler_block_by_data(GTK_OBJECT(atonal_if->buttons[i].button), atonal_if); 
     211       g_signal_handlers_block_matched (atonal_if->buttons[i].button, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, atonal_if); 
    212212    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(atonal_if->buttons[i].button), (atonal_if->data->sequence[i].trigger == 1)); 
    213     gtk_signal_handler_unblock_by_data(GTK_OBJECT(atonal_if->buttons[i].button), atonal_if); 
     213       g_signal_handlers_unblock_matched (atonal_if->buttons[i].button, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, atonal_if); 
    214214  } 
    215215} 

  • aube/trunk/src/modules/delay_if.c

    r412 r417  
    8787     * NULL and is ignored in the callback.  
    8888   */ 
    89   gtk_signal_connect(GTK_OBJECT(delay_if), "delete_event", 
    90                      GTK_SIGNAL_FUNC(delete_event), NULL); 
     89  g_signal_connect(G_OBJECT(delay_if), "delete_event", 
     90                     G_CALLBACK(delete_event), NULL); 
    9191#endif 
    9292 
    …… 
    9797     * window, or if we return "TRUE" in the "delete_event" callback.  
    9898   */ 
    99   gtk_signal_connect(GTK_OBJECT(delay_if), "destroy", 
    100                      GTK_SIGNAL_FUNC(delay_if_close_cb), delay_if); 
     99  g_signal_connect(G_OBJECT(delay_if), "destroy", 
     100                     G_CALLBACK(delay_if_close_cb), delay_if); 
    101101#endif 
    102102 
    …… 
    112112  gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 1); 
    113113  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(widget), delay_if->data->module.on); 
    114   gtk_signal_connect(GTK_OBJECT(widget), "clicked", 
    115                      GTK_SIGNAL_FUNC(delay_if_onoff_cb), delay_if->data); 
     114  g_signal_connect(G_OBJECT(widget), "clicked", 
     115                     G_CALLBACK(delay_if_onoff_cb), delay_if->data); 
    116116  gtk_widget_show(widget); 
    117117 

  • aube/trunk/src/modules/drummachine_if.c

    r412 r417  
    109109     * NULL and is ignored in the callback.  
    110110   */ 
    111   gtk_signal_connect(GTK_OBJECT(drummachine_if), "delete_event", 
    112                      GTK_SIGNAL_FUNC(delete_event), NULL); 
     111  g_signal_connect(G_OBJECT(drummachine_if), "delete_event", 
     112                     G_CALLBACK(delete_event), NULL); 
    113113#endif 
    114114 
    …… 
    119119     * window, or if we return "TRUE" in the "delete_event" callback.  
    120120   */ 
    121   gtk_signal_connect(GTK_OBJECT(drummachine_if), "destroy", 
    122                      GTK_SIGNAL_FUNC(drummachine_if_close_cb), drummachine_if); 
     121  g_signal_connect(G_OBJECT(drummachine_if), "destroy", 
     122                     G_CALLBACK(drummachine_if_close_cb), drummachine_if); 
    123123#endif 
    124124 
    …… 
    135135  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), 
    136136                              drummachine_if->data->module.on); 
    137   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    138                      GTK_SIGNAL_FUNC(drummachine_if_onoff_cb), 
     137  g_signal_connect(G_OBJECT(button), "clicked", 
     138                     G_CALLBACK(drummachine_if_onoff_cb), 
    139139                     drummachine_if->data); 
    140140  gtk_widget_show(button); 
    …… 
    162162  button = gtk_button_new_with_label("Clear"); 
    163163  gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 1); 
    164   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    165                      GTK_SIGNAL_FUNC(dm_clear_cb), drummachine_if); 
     164  g_signal_connect(G_OBJECT(button), "clicked", 
     165                     G_CALLBACK(dm_clear_cb), drummachine_if); 
    166166  gtk_widget_show(button); 
    167167 
    168168  button = gtk_button_new_with_label("Chaos"); 
    169169  gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 1); 
    170   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    171                      GTK_SIGNAL_FUNC(dm_chaos_cb), drummachine_if); 
     170  g_signal_connect(G_OBJECT(button), "clicked", 
     171                     G_CALLBACK(dm_chaos_cb), drummachine_if); 
    172172  gtk_widget_show(button); 
    173173 
    174174  button = gtk_button_new (); 
    175   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    176                      GTK_SIGNAL_FUNC(dm_shift_left_cb), 
     175  g_signal_connect(G_OBJECT(button), "clicked", 
     176                     G_CALLBACK(dm_shift_left_cb), 
    177177                     drummachine_if); 
    178178  gtk_button_set_relief (GTK_BUTTON(button), GTK_RELIEF_NONE); 
    …… 
    184184   
    185185  button = gtk_button_new (); 
    186   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    187                      GTK_SIGNAL_FUNC(dm_shift_right_cb), 
     186  g_signal_connect(G_OBJECT(button), "clicked", 
     187                     G_CALLBACK(dm_shift_right_cb), 
    188188                     drummachine_if); 
    189189  gtk_button_set_relief (GTK_BUTTON(button), GTK_RELIEF_NONE); 
    …… 
    217217 
    218218    button = gtk_button_new_with_label ("Clear"); 
    219     gtk_object_set_user_data (GTK_OBJECT(button), (gpointer)j); 
     219    g_object_set_data (G_OBJECT(button), "default", (gpointer) j); 
    220220    gtk_box_pack_start (GTK_BOX(hbox), button, FALSE, FALSE, 0); 
    221     gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    222                        GTK_SIGNAL_FUNC(dm_clear_track_cb), drummachine_if); 
     221    g_signal_connect(G_OBJECT(button), "clicked", 
     222                       G_CALLBACK(dm_clear_track_cb), drummachine_if); 
    223223    gtk_widget_show (button); 
    224224 
    …… 
    245245      gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), 
    246246                        (drummachine_if->data->sequence[j][i].note == 128)); 
    247       gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    248                GTK_SIGNAL_FUNC(drummachine_if_set_note_cb), drummachine_if); 
     247      g_signal_connect(G_OBJECT(button), "clicked", 
     248               G_CALLBACK(drummachine_if_set_note_cb), drummachine_if); 
    249249      gtk_widget_show(button); 
    250250      drummachine_if->buttons[j][i].button = button; 
    …… 
    256256 
    257257    button = gtk_button_new (); 
    258     gtk_object_set_user_data (GTK_OBJECT(button), (gpointer)j); 
    259     gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    260                        GTK_SIGNAL_FUNC(dm_shift_track_left_cb), 
     258    g_object_set_data (G_OBJECT(button), "default", (gpointer) j); 
     259    g_signal_connect(G_OBJECT(button), "clicked", 
     260                       G_CALLBACK(dm_shift_track_left_cb), 
    261261                       drummachine_if); 
    262262    gtk_button_set_relief (GTK_BUTTON(button), GTK_RELIEF_NONE); 
    …… 
    268268 
    269269    button = gtk_button_new (); 
    270     gtk_object_set_user_data (GTK_OBJECT(button), (gpointer)j); 
    271     gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    272                        GTK_SIGNAL_FUNC(dm_shift_track_right_cb), 
     270    g_object_set_data (G_OBJECT(button), "default",  (gpointer) j); 
     271    g_signal_connect(G_OBJECT(button), "clicked", 
     272                       G_CALLBACK(dm_shift_track_right_cb), 
    273273                       drummachine_if); 
    274274    gtk_button_set_relief (GTK_BUTTON(button), GTK_RELIEF_NONE); 
    …… 
    300300  for (j = 0; j < MAX_CHANNELS; j++) { 
    301301    for (i = 0; i < DM_LENGTH; i++) { 
    302       gtk_signal_handler_block_by_data(GTK_OBJECT(drummachine_if->buttons[j][i].button), drummachine_if); 
     302         g_signal_handlers_block_matched (drummachine_if->buttons[j][i].button, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, drummachine_if); 
    303303      gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(drummachine_if->buttons[j][i].button), (drummachine_if->data->sequence[j][i].note == 128)); 
    304       gtk_signal_handler_unblock_by_data(GTK_OBJECT(drummachine_if->buttons[j][i].button), drummachine_if); 
     304         g_signal_handlers_unblock_matched (drummachine_if->buttons[j][i].button, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, drummachine_if); 
    305305    } 
    306306  } 
    …… 
    423423{ 
    424424  DrumMachineIF * drummachine_if = DRUMMACHINE_IF (data); 
    425   int j = (int) gtk_object_get_user_data (GTK_OBJECT(widget)); 
     425  int j = (int) g_object_get_data (G_OBJECT(widget), "default"); 
    426426 
    427427  dm_clear_track (drummachine_if->data, j); 
    …… 
    434434{ 
    435435  DrumMachineIF * drummachine_if = DRUMMACHINE_IF (data); 
    436   int j = (int) gtk_object_get_user_data (GTK_OBJECT(widget)); 
     436  int j = (int) g_object_get_data (G_OBJECT(widget), "default"); 
    437437 
    438438  dm_shift_track (drummachine_if->data, j, -1); 
    …… 
    445445{ 
    446446  DrumMachineIF * drummachine_if = DRUMMACHINE_IF (data); 
    447   int j = (int) gtk_object_get_user_data (GTK_OBJECT(widget)); 
     447  int j = (int) g_object_get_data (G_OBJECT(widget), "default"); 
    448448 
    449449  dm_shift_track (drummachine_if->data, j, 1); 

  • aube/trunk/src/modules/filter_reslp_if.c

    r412 r417  
    8484     * NULL and is ignored in the callback.  
    8585   */ 
    86   gtk_signal_connect(GTK_OBJECT(filter_reslp_if), "delete_event", 
    87                      GTK_SIGNAL_FUNC(delete_event), NULL); 
     86  g_signal_connect(G_OBJECT(filter_reslp_if), "delete_event", 
     87                     G_CALLBACK(delete_event), NULL); 
    8888#endif 
    8989 
    …… 
    9494     * window, or if we return "TRUE" in the "delete_event" callback.  
    9595   */ 
    96   gtk_signal_connect(GTK_OBJECT(filter_reslp_if), "destroy", 
    97                      GTK_SIGNAL_FUNC(filter_reslp_if_close_cb), filter_reslp_if); 
     96  g_signal_connect(G_OBJECT(filter_reslp_if), "destroy", 
     97                     G_CALLBACK(filter_reslp_if_close_cb), filter_reslp_if); 
    9898#endif 
    9999 
    …… 
    114114  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), 
    115115                              filter_reslp_if->data->module.on); 
    116   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    117          GTK_SIGNAL_FUNC(filter_reslp_startstop_cb), filter_reslp_if->data); 
     116  g_signal_connect(G_OBJECT(button), "clicked", 
     117         G_CALLBACK(filter_reslp_startstop_cb), filter_reslp_if->data); 
    118118  gtk_widget_show(button); 
    119119 
    …… 
    137137  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), 
    138138                              filter_reslp_if->data->use_trigger); 
    139   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    140          GTK_SIGNAL_FUNC(filter_reslp_usetoggle_cb), filter_reslp_if->data); 
     139  g_signal_connect(G_OBJECT(button), "clicked", 
     140         G_CALLBACK(filter_reslp_usetoggle_cb), filter_reslp_if->data); 
    141141  gtk_widget_show(button); 
    142142 
    …… 
    178178  slider = slider_int_new("Tune", &(filter_reslp_if->data->tune), 1, 1024, 1); 
    179179  gtk_box_pack_start(GTK_BOX(hbox3), slider, TRUE, FALSE, 0); 
    180   gtk_signal_connect(GTK_OBJECT(SLIDER(slider)->adj), "value_changed", 
    181               GTK_SIGNAL_FUNC(harmonics_changed_cb), filter_reslp_if->data); 
     180  g_signal_connect(G_OBJECT(SLIDER(slider)->adj), "value_changed", 
     181              G_CALLBACK(harmonics_changed_cb), filter_reslp_if->data); 
    182182  gtk_widget_show(slider); 
    183183#endif 

  • aube/trunk/src/modules/general_mixer_if.c

    r413 r417  
    7979 
    8080#if 0 
    81   gtk_signal_connect(GTK_OBJECT(general_mixer_if), "delete_event", 
    82                      GTK_SIGNAL_FUNC(delete_event), NULL); 
     81  g_signal_connect(G_OBJECT(general_mixer_if), "delete_event", 
     82                     G_CALLBACK(delete_event), NULL); 
    8383#endif 
    8484 
    8585#if 1 
    86   gtk_signal_connect(GTK_OBJECT(general_mixer_if), "destroy", 
    87                      GTK_SIGNAL_FUNC(general_mixer_if_close_cb), general_mixer_if); 
     86  g_signal_connect(G_OBJECT(general_mixer_if), "destroy", 
     87                     G_CALLBACK(general_mixer_if_close_cb), general_mixer_if); 
    8888#endif 
    8989 
    …… 
    103103  gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); 
    104104  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), general_mixer_if->data->module.on); 
    105   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    106         GTK_SIGNAL_FUNC(general_mixer_if_onoff_cb), general_mixer_if->data); 
     105  g_signal_connect(G_OBJECT(button), "clicked", 
     106        G_CALLBACK(general_mixer_if_onoff_cb), general_mixer_if->data); 
    107107  gtk_widget_show(button); 
    108108 
    …… 
    113113  button = gtk_button_new_with_label("Add"); 
    114114  gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 2); 
    115   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    116           GTK_SIGNAL_FUNC(general_mixer_if_add_input_cb), general_mixer_if); 
     115  g_signal_connect(G_OBJECT(button), "clicked", 
     116          G_CALLBACK(general_mixer_if_add_input_cb), general_mixer_if); 
    117117  gtk_widget_show(button); 
    118118 
    119119  button = gtk_button_new_with_label("Remove"); 
    120120  gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 2); 
    121   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    122        GTK_SIGNAL_FUNC(general_mixer_if_remove_input_cb), general_mixer_if); 
     121  g_signal_connect(G_OBJECT(button), "clicked", 
     122       G_CALLBACK(general_mixer_if_remove_input_cb), general_mixer_if); 
    123123  gtk_widget_show(button); 
    124124 
    …… 
    143143  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), 
    144144                              general_mixer_if->data->master_mute); 
    145   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    146                      GTK_SIGNAL_FUNC(general_mixer_if_mute_cb), 
     145  g_signal_connect(G_OBJECT(button), "clicked", 
     146                     G_CALLBACK(general_mixer_if_mute_cb), 
    147147                     &(general_mixer_if->data->master_mute)); 
    148148  gtk_widget_show(button); 
    …… 
    254254  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), 
    255255                              general_mixer_if->data->mute[i]); 
    256   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    257                      GTK_SIGNAL_FUNC(general_mixer_if_mute_cb), 
     256  g_signal_connect(G_OBJECT(button), "clicked", 
     257                     G_CALLBACK(general_mixer_if_mute_cb), 
    258258                     &(general_mixer_if->data->mute[i])); 
    259259  gtk_widget_show(button); 

  • aube/trunk/src/modules/klav.c

    r406 r417  
    4040                             gint arg1, 
    4141                             gpointer data); 
    42  
    43 /* 
    44    Signal Marshalers  
    45  */ 
    46 static void 
    47      klav_marshal_signal_1(GtkObject * object, 
    48                            GtkSignalFunc func, 
    49                            gpointer func_data, 
    50                            GtkArg * args); 
    5142 
    5243/* 
    …… 
    671662  klav->key_pressed = key; 
    672663 
    673   gtk_signal_emit(GTK_OBJECT(klav), klav_signals[KLAVKEY_PRESS], key); 
     664  g_signal_emit(G_OBJECT(klav), klav_signals[KLAVKEY_PRESS], 0, key); 
    674665 
    675666  /* 
    …… 
    683674  klav->is_pressed = FALSE; 
    684675 
    685   gtk_signal_emit(GTK_OBJECT(klav), klav_signals[KLAVKEY_RELEASE], 
    686                   klav->key_pressed); 
    687  
     676  g_signal_emit(G_OBJECT(klav), klav_signals[KLAVKEY_RELEASE], 0, klav->key_pressed); 
     677  
    688678  /* 
    689679     printf ("release: %i\n", klav->key_pressed);  
    …… 
    860850  klav->dir = dir; 
    861851} 
    862  
    863 /* 
    864    Signal Marshalers  
    865  */ 
    866  
    867 static void 
    868 klav_marshal_signal_1(GtkObject * object, 
    869                       GtkSignalFunc func, 
    870                       gpointer func_data, 
    871                       GtkArg * args) 
    872 { 
    873   KlavSignal1 rfunc; 
    874  
    875   rfunc = (KlavSignal1) func; 
    876  
    877   (*rfunc) (object, GTK_VALUE_INT(args[0]), func_data); 
    878 } 

  • aube/trunk/src/modules/klavier_if.c

    r412 r417  
    9898     * NULL and is ignored in the callback.  
    9999   */ 
    100   gtk_signal_connect(GTK_OBJECT(klavier_if), "delete_event", 
    101                      GTK_SIGNAL_FUNC(delete_event), NULL); 
     100  g_signal_connect(G_OBJECT(klavier_if), "delete_event", 
     101                     G_CALLBACK(delete_event), NULL); 
    102102 
    103103#endif 
    …… 
    109109     * window, or if we return "TRUE" in the "delete_event" callback.  
    110110   */ 
    111   gtk_signal_connect(GTK_OBJECT(klavier_if), "destroy", 
    112                      GTK_SIGNAL_FUNC(klavier_if_close_cb), klavier_if); 
     111  g_signal_connect(G_OBJECT(klavier_if), "destroy", 
     112                     G_CALLBACK(klavier_if_close_cb), klavier_if); 
    113113#endif 
    114114 
    …… 
    124124  gtk_box_pack_start(GTK_BOX(hbox2), button, FALSE, FALSE, 1); 
    125125  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), klavier_if->data->module.on); 
    126   gtk_signal_connect(GTK_OBJECT(button), "clicked", 
    127                      GTK_SIGNAL_FUNC(klavier_if_onoff_cb), klavier_if->data); 
     126  g_signal_connect(G_OBJECT(button), "clicked", 
     127                     G_CALLBACK(klavier_if_onoff_cb), klavier_if->data); 
    128128  gtk_widget_show(button); 
    129129 
    …… 
    217217  klav_set_klav_type(KLAV(klav), klavtype); 
    218218 
    219   gtk_signal_connect(GTK_OBJECT(klav), "klavkey_press", 
    220                      GTK_SIGNAL_FUNC(klavkey_press_event), 
     219  g_signal_connect(G_OBJECT(klav), "klavkey_press", 
     220                     G_CALLBACK(klavkey_press_event), 
    221221                     klavier_if); 
    222222 
    223   gtk_signal_connect(GTK_OBJECT(klav), "klavkey_release", 
    224                      GTK_SIGNAL_FUNC(klavkey_release_event), 
     223  g_signal_connect(G_OBJECT(klav), "klavkey_release", 
     224                     G_CALLBACK(klavkey_release_event), 
    225225                     klavier_if); 
    226226 
    227   gtk_signal_connect(GTK_OBJECT(ebox), "key_press_event", 
    228                      GTK_SIGNAL_FUNC(klavkey_key_press_event), 
     227  g_signal_connect(G_OBJECT(ebox), "key_press_event", 
     228                     G_CALLBACK(klavkey_key_press_event), 
    229229                     klavier_if); 
    230230 
    231   gtk_signal_connect(GTK_OBJECT(ebox), "key_release_event", 
    232                      GTK_SIGNAL_FUNC(klavkey_key_release_event), 
     231  g_signal_connect(G_OBJECT(ebox), "key_release_event", 
     232                     G_CALLBACK(klavkey_key_release_event), 
    233233                     klavier_if); 
    234234 

  • aube/trunk/src/modules/linein_if.c

    r412 r417  
    8080 
    8181#if 0 
    82   gtk_signal_connect(GTK_OBJECT(linein_if), "delete_event", 
    83                      GTK_SIGNAL_FUNC(delete_event), NULL); 
     82  g_signal_connect(G_OBJECT(linein_if), "delete_event", 
     83                     G_CALLBACK(delete_event), NULL); 
    8484#endif 
    8585 
    8686#if 1 
    87   gtk_signal_connect(GTK_OBJECT(linein_if), "destroy", 
    88                      GTK_SIGNAL_FUNC(linein_if_close_cb), linein_if); 
     87  g_signal_connect(G_OBJECT(linein_if), "destroy", 
     88                     G_CALLBACK(linein_if_close_cb), linein_if); 
    8989#endif 
    9090 
    …… 
    109109  menuitem = gtk_menu_item_new_with_label("Close"); 
    110110  gtk_menu_append(GTK_MENU(menu), menuitem); 
    111   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    112                      GTK_SIGNAL_FUNC(linein_if_close_cb), linein_if); 
     111  g_signal_connect(G_OBJECT(menuitem), "activate", 
     112                     G_CALLBACK(linein_if_close_cb), linein_if); 
    113113  gtk_widget_show(menuitem); 
    114114 
    …… 
    129129  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(widget), 
    130130    linein_if->data->input_module.on); 
    131   gtk_signal_connect(GTK_OBJECT(widget), "clicked", 
    132                      GTK_SIGNAL_FUNC(linein_if_onoff_cb), linein_if->data); 
     131  g_signal_connect(G_OBJECT(widget), "clicked", 
     132                     G_CALLBACK(linein_if_onoff_cb), linein_if->data); 
    133133  gtk_widget_show(widget); 
    134134 
    …… 
    202202  menuitem = gtk_menu_item_new_with_label((char *) "Output"); 
    203203  gtk_menu_append(GTK_MENU(menu), menuitem); 
    204   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    205             GTK_SIGNAL_FUNC(linein_if_set_mode_output_cb), linein_if->data); 
     204  g_signal_connect(G_OBJECT(menuitem), "activate", 
     205            G_CALLBACK(linein_if_set_mode_output_cb), linein_if->data); 
    206206  gtk_widget_show(menuitem); 
    207207 
    208208  menuitem = gtk_menu_item_new_with_label((char *) "Input"); 
    209209  gtk_menu_append(GTK_MENU(menu), menuitem); 
    210   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    211              GTK_SIGNAL_FUNC(linein_if_set_mode_input_cb), linein_if->data); 
     210  g_signal_connect(G_OBJECT(menuitem), "activate", 
     211             G_CALLBACK(linein_if_set_mode_input_cb), linein_if->data); 
    212212  gtk_widget_show(menuitem); 
    213213 
    214214  menuitem = gtk_menu_item_new_with_label((char *) "Duplex"); 
    215215  gtk_menu_append(GTK_MENU(menu), menuitem); 
    216   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    217             GTK_SIGNAL_FUNC(linein_if_set_mode_duplex_cb), linein_if->data); 
     216  g_signal_connect(G_OBJECT(menuitem), "activate", 
     217            G_CALLBACK(linein_if_set_mode_duplex_cb), linein_if->data); 
    218218  gtk_widget_show(menuitem); 
    219219 
    …… 
    233233  menuitem = gtk_menu_item_new_with_label((char *) "/dev/dsp"); 
    234234  gtk_menu_append(GTK_MENU(menu), menuitem); 
    235   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    236              GTK_SIGNAL_FUNC(linein_if_set_device_dsp_cb), linein_if->data); 
     235  g_signal_connect(G_OBJECT(menuitem), "activate", 
     236             G_CALLBACK(linein_if_set_device_dsp_cb), linein_if->data); 
    237237  gtk_widget_show(menuitem); 
    238238 
    239239  menuitem = gtk_menu_item_new_with_label((char *) "/dev/dsp1"); 
    240240  gtk_menu_append(GTK_MENU(menu), menuitem); 
    241   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    242             GTK_SIGNAL_FUNC(linein_if_set_device_dsp1_cb), linein_if->data); 
     241  g_signal_connect(G_OBJECT(menuitem), "activate", 
     242            G_CALLBACK(linein_if_set_device_dsp1_cb), linein_if->data); 
    243243  gtk_widget_show(menuitem); 
    244244 
    …… 
    263263  gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); 
    264264#if 0 
    265   gtk_signal_connect(GTK_OBJECT(widget), "clicked", 
    266                      GTK_SIGNAL_FUNC(set_sinwave_cb), syre_if->data); 
     265  g_signal_connect(G_OBJECT(widget), "clicked", 
     266                     G_CALLBACK(set_sinwave_cb), syre_if->data); 
    267267#endif 
    268268  gtk_widget_show(widget); 
    …… 
    272272  gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); 
    273273#if 0 
    274   gtk_signal_connect(GTK_OBJECT(widget), "clicked", 
    275                      GTK_SIGNAL_FUNC(set_squarewave_cb), syre_if->data); 
     274  g_signal_connect(G_OBJECT(widget), "clicked", 
     275                     G_CALLBACK(set_squarewave_cb), syre_if->data); 
    276276#endif 
    277277  gtk_widget_show(widget); 
    …… 
    294294  gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); 
    295295#if 0 
    296   gtk_signal_connect(GTK_OBJECT(widget), "clicked", 
    297                      GTK_SIGNAL_FUNC(set_sinwave_cb), syre_if->data); 
     296  g_signal_connect(G_OBJECT(widget), "clicked", 
     297                     G_CALLBACK(set_sinwave_cb), syre_if->data); 
    298298#endif 
    299299  gtk_widget_show(widget); 
    …… 
    303303  gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); 
    304304#if 0 
    305   gtk_signal_connect(GTK_OBJECT(widget), "clicked", 
    306                      GTK_SIGNAL_FUNC(set_squarewave_cb), syre_if->data); 
     305  g_signal_connect(G_OBJECT(widget), "clicked", 
     306                     G_CALLBACK(set_squarewave_cb), syre_if->data); 
    307307#endif 
    308308  gtk_widget_show(widget);