Changeset 406

Show
Ignore:
Timestamp:
07/18/06 15:08:06 (6 years ago)
Author:
kickback
Message:

aube-gtk2: quick and dirty but apparently functional gtk2 port of aube. initial commit

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • aube/branches/aube-gtk2/configure.ac

    r398 r406  
    2929  fi 
    3030 
    31 AM_PATH_GTK(1.0.0, , echo "EEEEEK No GTK") 
    32 #AM_PATH_GENERIC(xml, 0.99.0) 
     31PKG_CHECK_MODULES(GTK, gtk+-2.0) 
     32AC_SUBST(GTK_CFLAGS) 
     33AC_SUBST(GTK_LIBS) 
     34 
    3335 
    3436AM_PATH_GDK_IMLIB(1.9, ,AC_MSG_ERROR([*** IMLIB 1.9 not installed ***])) 

  • aube/branches/aube-gtk2/src/about_dialog.c

    r397 r406  
    2929 
    3030  if (!about_dialog) { 
    31     about_dialog = gtk_window_new(GTK_WINDOW_DIALOG); 
     31    about_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL); 
    3232    gtk_window_set_wmclass(GTK_WINDOW(about_dialog), "about_dialog", "Aube"); 
    3333    gtk_window_set_title(GTK_WINDOW(about_dialog), "About AUBE"); 
    …… 
    6969 
    7070    style = gtk_style_new(); 
     71/* FIXME: use pango or remove entirely? 
    7172    gdk_font_unref(style->font); 
    7273    style->font = gdk_font_load("-Adobe-Helvetica-Medium-R-Normal--*-140-*-*-*-*-*-*"); 
    7374    gtk_widget_push_style(style); 
    74  
     75*/ 
    7576    label = gtk_label_new("This is AUBE Version " VERSION); 
    7677    gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0); 
    …… 
    8081    gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0); 
    8182    gtk_widget_show(label); 
    82  
     83/* FIXME  
    8384    gtk_widget_pop_style(); 
    84  
     85*/ 
    8586    alignment = gtk_alignment_new(0.5, 0.5, 0.0, 0.0); 
    8687    gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE, 0); 
    …… 
    102103 
    103104  } 
    104   if (!GTK_WIDGET_VISIBLE(about_dialog)) { 
     105  if (!GTK_WIDGET_MAPPED(about_dialog)) { 
    105106    gtk_widget_show(about_dialog); 
    106107  } else { 

  • aube/branches/aube-gtk2/src/aube.c

    r372 r406  
    463463  gtk_idle_add((GtkFunction) (aube_do_tick), aube_daddy); 
    464464  gtk_widget_show(master); 
    465  
    466465  nn = none_new(); 
    467466 

  • aube/branches/aube-gtk2/src/inputoption.c

    r397 r406  
    1010extern bit16 zero_buffer[]; 
    1111 
    12 guint inputoption_get_type(void); 
    13 static void inputoption_class_init(InputoptionClass * class); 
     12 
     13static void inputoption_class_init(InputoptionClass * klass); 
    1414static void inputoption_init(Inputoption * b); 
    1515GtkWidget *inputoption_new(); 
    …… 
    1919void select_input_cb(GtkWidget * widget, gpointer data); 
    2020 
    21 guint 
    22 inputoption_get_type() 
    23 { 
    24   static guint b_type = 0; 
     21GType 
     22inputoption_get_type(void) 
     23{ 
     24  static GType b_type = 0; 
    2525 
    2626  if (!b_type) { 
    27     GtkTypeInfo b_info = 
     27    static const GTypeInfo b_info = 
    2828    { 
    29       "Inputoption", 
    30       sizeof(Inputoption), 
    31       sizeof(InputoptionClass), 
    32       (GtkClassInitFunc) inputoption_class_init, 
    33       (GtkObjectInitFunc) inputoption_init, 
    34       (GtkArgSetFunc) NULL, 
    35       (GtkArgGetFunc) NULL, 
    36     }; 
    37  
    38     b_type = gtk_type_unique(gtk_frame_get_type(), &b_info); 
     29          sizeof(InputoptionClass), 
     30          NULL, /* base_init */ 
     31          NULL, /* base_finalize */ 
     32          (GClassInitFunc) inputoption_class_init, 
     33          NULL, /* class_finalize */ 
     34          NULL, /* class_data */ 
     35          sizeof(Inputoption), 
     36          0, /* n_preallocs */ 
     37          (GInstanceInitFunc) inputoption_init, 
     38        }; 
     39         
     40    b_type = g_type_register_static(GTK_TYPE_FRAME, 
     41                                                       "Inputoption", 
     42                                                        &b_info, 0); 
    3943  } 
    4044  return b_type; 
    4145} 
    4246 
     47/* FIXME: need these? 
    4348enum { 
    4449  LAST_SIGNAL 
    …… 
    4752static guint inputoption_signals[LAST_SIGNAL+1] = 
    4853{0}; 
    49  
     54*/ 
    5055static void 
    51 inputoption_class_init(InputoptionClass * class) 
    52 { 
     56inputoption_class_init(InputoptionClass * klass) 
     57{ 
     58/* FIXME: need these?    
     59 
    5360  GtkObjectClass *object_class; 
    5461 
    55   object_class = (GtkObjectClass *) class; 
     62  object_class = (GtkObjectClass *) klass; 
    5663 
    5764  gtk_object_class_add_signals(object_class, inputoption_signals, LAST_SIGNAL); 
    58  
    59   class->inputoption = NULL; 
     65*/ 
     66  klass->inputoption = NULL; 
    6067} 
    6168 

  • aube/branches/aube-gtk2/src/inputoption.h

    r372 r406  
    4545  }; 
    4646 
    47   guint inputoption_get_type(void); 
     47  GType inputoption_get_type(void); 
    4848  GtkWidget *inputoption_new(char *label_str, module * module, int input_i); 
    4949  void reread_inputs_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/levelmeter.c

    r372 r406  
    2222 */ 
    2323 
    24 static void levelmeter_class_init(LevelMeterClass * class); 
     24static void levelmeter_class_init(LevelMeterClass * klass); 
    2525static void levelmeter_init(LevelMeter * levelmeter); 
    2626static void levelmeter_destroy(GtkObject * object); 
    …… 
    4040static GtkStyle *levelmeter_style = NULL; 
    4141 
    42 guint 
    43 levelmeter_get_type() 
    44 { 
    45   static guint levelmeter_type = 0; 
     42GType 
     43levelmeter_get_type(void) 
     44{ 
     45  static GType levelmeter_type = 0; 
    4646 
    4747  if (!levelmeter_type) { 
    48     GtkTypeInfo levelmeter_info = 
     48    static const GTypeInfo levelmeter_info = 
    4949    { 
    50       "LevelMeter", 
     50      sizeof(LevelMeterClass), 
     51      NULL, /* base_init */ 
     52          NULL, /* base_finalize */ 
     53      (GClassInitFunc) levelmeter_class_init, 
     54      NULL, /* class_finalize */ 
     55          NULL, /* class_data */ 
    5156      sizeof(LevelMeter), 
    52       sizeof(LevelMeterClass), 
    53       (GtkClassInitFunc) levelmeter_class_init, 
    54       (GtkObjectInitFunc) levelmeter_init, 
    55       (GtkArgSetFunc) NULL, 
    56       (GtkArgGetFunc) NULL, 
     57      0, /* n_preallocs */ 
     58      (GInstanceInitFunc) levelmeter_init, 
    5759    }; 
    5860 
    59     levelmeter_type = gtk_type_unique(gtk_widget_get_type(), &levelmeter_info); 
     61    levelmeter_type = g_type_register_static(gtk_widget_get_type(), 
     62                                                                    "LevelMeter", 
     63                                                                        &levelmeter_info, 0); 
    6064  } 
    6165  return levelmeter_type; 
    …… 
    6367 
    6468static void 
    65 levelmeter_class_init(LevelMeterClass * class) 
     69levelmeter_class_init(LevelMeterClass * klass) 
    6670{ 
    6771  GtkObjectClass *object_class; 
    6872  GtkWidgetClass *widget_class; 
    6973 
    70   object_class = (GtkObjectClass *) class; 
    71   widget_class = (GtkWidgetClass *) class; 
     74  object_class = (GtkObjectClass *) klass; 
     75  widget_class = (GtkWidgetClass *) klass; 
    7276 
    7377  parent_class = gtk_type_class(gtk_widget_get_type()); 

  • aube/branches/aube-gtk2/src/levelmeter.h

    r372 r406  
    3030 
    3131  GtkWidget *levelmeter_new(guint state); 
    32   guint levelmeter_get_type(void); 
     32  GType levelmeter_get_type(void); 
    3333  guint levelmeter_get_level(LevelMeter * levelmeter); 
    3434  void levelmeter_set_level(LevelMeter * levelmeter, guint level); 

  • aube/branches/aube-gtk2/src/master.c

    r397 r406  
    108108 
    109109 
    110 guint master_get_type(void); 
    111110static void master_class_init(MasterClass * class); 
    112111static void master_init(Master * b); 
    …… 
    128127void save_workspace_cb(GtkWidget * widget, gpointer data); 
    129128 
    130 guint 
    131 master_get_type() 
    132 { 
    133   static guint b_type = 0; 
     129GType 
     130master_get_type(void) 
     131{ 
     132  static GType b_type = 0; 
    134133 
    135134  if (!b_type) { 
    136     GtkTypeInfo b_info = 
     135    static const GTypeInfo b_info = 
    137136    { 
    138       "Master", 
     137      sizeof(MasterClass), 
     138      NULL, /* base_init */ 
     139          NULL, /* base_finalise */ 
     140      (GClassInitFunc) master_class_init, 
     141          NULL, /* class_finalize */ 
     142          NULL, /* class_data */ 
    139143      sizeof(Master), 
    140       sizeof(MasterClass), 
    141       (GtkClassInitFunc) master_class_init, 
    142       (GtkObjectInitFunc) master_init, 
    143       (GtkArgSetFunc) NULL, 
    144       (GtkArgGetFunc) NULL, 
     144          0, /* n_preallocs */ 
     145          (GInstanceInitFunc) master_init, 
    145146    }; 
    146147 
    147     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     148    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     149                                                      "Master", 
     150                                                           &b_info, 0); 
    148151  } 
    149152  return b_type; 
    …… 
    156159 
    157160/* static gint master_signals[LAST_SIGNAL] = { 0 }; */ 
    158 guint master_signals[LAST_SIGNAL+1] = {0}; 
     161guint master_signals[LAST_SIGNAL] = {0}; 
    159162 
    160163static void 
    161 master_class_init(MasterClass * class) 
     164master_class_init(MasterClass * klass) 
    162165{ 
    163166  GtkObjectClass *object_class; 
    164167 
    165   object_class = (GtkObjectClass *) class; 
     168  object_class = (GtkObjectClass *) klass; 
    166169 
    167170  master_signals[UNITS_CHANGED_SIGNAL] = 
    168     gtk_signal_new("modules_changed", GTK_RUN_FIRST, object_class->type, 
    169                   GTK_SIGNAL_OFFSET(MasterClass, master), 
    170                   gtk_signal_default_marshaller, GTK_TYPE_NONE, 0); 
    171  
    172   gtk_object_class_add_signals(object_class, master_signals, LAST_SIGNAL); 
    173  
    174   class->master = NULL; 
     171    g_signal_new("modules_changed", 
     172                             G_TYPE_FROM_CLASS(klass), 
     173                             G_SIGNAL_RUN_FIRST, 
     174                         G_STRUCT_OFFSET(MasterClass, master), 
     175                         NULL, 
     176                             NULL, 
     177                                g_cclosure_marshal_VOID__VOID, GTK_TYPE_NONE, 0); 
    175178} 
    176179 
    …… 
    235238  GtkAccelGroup * accel_group; 
    236239 
    237   GtkWidget * logo; 
    238   GdkPixmap * p, * m; 
    239   GdkImlibImage * im; 
    240   gint w, h; 
     240  GtkWidget * im; 
     241 
    241242 
    242243  GtkWidget * scrolled; 
    …… 
    247248  aube_daddy = master->data; 
    248249 
    249   gtk_signal_connect (GTK_OBJECT (master), "destroy", 
    250                       GTK_SIGNAL_FUNC (quit_cb), master); 
     250  g_signal_connect (G_OBJECT (master), "destroy", 
     251                      G_CALLBACK (quit_cb), master); 
    251252 
    252253  gtk_window_set_title(GTK_WINDOW(master), "AUBE/Metadecks Live"); 
    …… 
    307308  menuitem = gtk_menu_item_new_with_label("About..."); 
    308309  gtk_menu_append(GTK_MENU(menu), menuitem); 
    309   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    310                      GTK_SIGNAL_FUNC(about_dialog_create), NULL); 
     310  g_signal_connect(G_OBJECT(menuitem), "activate", 
     311                     G_CALLBACK(about_dialog_create), NULL); 
    311312  gtk_widget_show(menuitem); 
    312313 
    …… 
    391392  gtk_widget_show(menubar); 
    392393 
    393   im = gdk_imlib_load_image (g_strconcat (DATADIR, "/aube_mini.png", NULL)); 
    394  
    395   if (im != NULL) { 
    396     /* Suck the image's original width and height out of the Image structure */ 
    397     w=im->rgb_width;h=im->rgb_height; 
     394   im = gtk_image_new_from_file (g_strconcat (DATADIR, "/aube_mini.png", NULL)); 
    398395     
    399     /* Render the original 24-bit Image data into a pixmap of size w * h */ 
    400     gdk_imlib_render(im,w,h); 
    401     /* Extract the Image and mask pixmaps from the Image */ 
    402     p=gdk_imlib_move_image(im); 
    403     /* The mask will be NULL if the image has no transparency */ 
    404     m=gdk_imlib_move_mask(im); 
    405      
    406     logo = gtk_pixmap_new (p, m); 
    407      
    408     gtk_box_pack_start(GTK_BOX(vbox2), logo, FALSE, TRUE, 0); 
    409     gtk_widget_show (logo); 
    410   } 
     396   gtk_box_pack_start(GTK_BOX(vbox2), im, FALSE, TRUE, 0); 
     397   gtk_widget_show (im); 
     398   
    411399 
    412400  /* 
    …… 
    740728 
    741729} 
    742  

  • aube/branches/aube-gtk2/src/master.h

    r372 r406  
    3535  }; 
    3636 
    37   guint master_get_type(void); 
     37  GType master_get_type(void); 
    3838  GtkWidget *master_new(void); 
    3939void master_ack_channels_modified(void); 

  • aube/branches/aube-gtk2/src/modulemenu.c

    r397 r406  
    1010extern bit16 zero_buffer[]; 
    1111 
    12 guint modulemenu_get_type(void); 
    1312static void modulemenu_class_init(UnitmenuClass * class); 
    1413static void modulemenu_init(Unitmenu * b); 
    …… 
    1716void reread_modules_cb(GtkWidget * widget, gpointer data); 
    1817 
    19 guint 
    20 modulemenu_get_type() 
     18GType 
     19modulemenu_get_type(void) 
    2120{ 
    22   static guint b_type = 0; 
     21  static GType b_type = 0; 
    2322 
    2423  if (!b_type) { 
    25     GtkTypeInfo b_info = 
     24    static const GTypeInfo b_info = 
    2625    { 
    27       "Unitmenu", 
     26      sizeof(UnitmenuClass), 
     27      NULL, /* base_init */ 
     28          NULL, /* base_finalise */ 
     29      (GClassInitFunc) modulemenu_class_init, 
     30          NULL, /* class_finalize */ 
     31          NULL, /* class_data */ 
    2832      sizeof(Unitmenu), 
    29       sizeof(UnitmenuClass), 
    30       (GtkClassInitFunc) modulemenu_class_init, 
    31       (GtkObjectInitFunc) modulemenu_init, 
    32       (GtkArgSetFunc) NULL, 
    33       (GtkArgGetFunc) NULL, 
     33          0, /* n_preallocs */ 
     34          (GInstanceInitFunc) modulemenu_init, 
    3435    }; 
    3536 
    36     b_type = gtk_type_unique(gtk_menu_get_type(), &b_info); 
     37    b_type = g_type_register_static(GTK_TYPE_MENU, 
     38                                                      "Unitmenu", 
     39                                                           &b_info, 0); 
    3740  } 
    3841  return b_type; 
    3942} 
    4043 
    41 enum { 
    42   LAST_SIGNAL 
    43 }; 
    44  
    45 static guint modulemenu_signals[LAST_SIGNAL+1] = 
    46 {0}; 
    47  
    4844static void 
    4945modulemenu_class_init(UnitmenuClass * class) 
    5046{ 
    51   GtkObjectClass *object_class; 
    52  
    53   object_class = (GtkObjectClass *) class; 
    54  
    55   gtk_object_class_add_signals(object_class, modulemenu_signals, LAST_SIGNAL); 
    56  
    57   class->modulemenu = NULL; 
     47  /* chickens? */ 
    5848} 
    5949 
    …… 
    8979      menuitem = gtk_menu_item_new_with_label(buf); 
    9080      gtk_menu_append(GTK_MENU(modulemenu), menuitem); 
    91       gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    92                          GTK_SIGNAL_FUNC(UNITMENU(modulemenu)->select_action), &UNITMENU(modulemenu)->up[k]); 
     81      g_signal_connect(G_OBJECT(menuitem), "activate", 
     82                         G_CALLBACK(UNITMENU(modulemenu)->select_action), &UNITMENU(modulemenu)->up[k]); 
    9383      gtk_widget_show(menuitem); 
    9484      k++; 

  • aube/branches/aube-gtk2/src/modulemenu.h

    r372 r406  
    4141  }; 
    4242 
    43   guint modulemenu_get_type(void); 
     43  GType modulemenu_get_type(void); 
    4444  GtkWidget *modulemenu_new(module * this_module, int *include_criterion(), void *select_action()); 
    4545 

  • aube/branches/aube-gtk2/src/modules/atonal_if.c

    r397 r406  
    1717extern char *note_names[97]; 
    1818 
    19 guint atonal_if_get_type(void); 
    20 static void atonal_if_class_init (AtonalIFClass *class); 
     19static void atonal_if_class_init (AtonalIFClass *klass); 
    2120static void atonal_if_init (AtonalIF *b); 
    2221GtkWidget* atonal_if_new (atonal *rsq); 
    …… 
    4039void at_rshift_cb(GtkWidget *widget, gpointer data); 
    4140 
    42 guint 
    43 atonal_if_get_type () 
    44 { 
    45   static guint b_type = 0; 
    46  
    47   if (!b_type) 
     41GType 
     42atonal_if_get_type(void) 
     43{ 
     44  static GType b_type = 0; 
     45 
     46  if (!b_type) { 
     47    static const GTypeInfo b_info = 
    4848    { 
    49       GtkTypeInfo b_info = 
    50       { 
    51         "AtonalIF", 
    52         sizeof (AtonalIF), 
    53         sizeof (AtonalIFClass), 
    54         (GtkClassInitFunc) atonal_if_class_init, 
    55         (GtkObjectInitFunc) atonal_if_init, 
    56         (GtkArgSetFunc) NULL, 
    57         (GtkArgGetFunc) NULL, 
    58       }; 
    59  
    60       b_type = gtk_type_unique (gtk_window_get_type(), &b_info); 
    61     } 
    62  
     49      sizeof(AtonalIFClass), 
     50      NULL, /* base_init */ 
     51          NULL, /* base_finalise */ 
     52      (GClassInitFunc) atonal_if_class_init, 
     53          NULL, /* class_finalize */ 
     54          NULL, /* class_data */ 
     55      sizeof(AtonalIF), 
     56          0, /* n_preallocs */ 
     57          (GInstanceInitFunc) atonal_if_init, 
     58    }; 
     59 
     60    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     61                                                      "AtonalIF", 
     62                                                           &b_info, 0); 
     63  } 
    6364  return b_type; 
    6465} 
    6566 
    66 enum { 
    67   LAST_SIGNAL 
    68 }; 
    69  
    70 static guint atonal_if_signals[LAST_SIGNAL+1] = { 0 }; 
    71  
    7267static void 
    73 atonal_if_class_init (AtonalIFClass *class) 
    74 { 
    75   GtkObjectClass *object_class; 
    76  
    77   object_class = (GtkObjectClass*) class; 
    78  
    79   gtk_object_class_add_signals (object_class, atonal_if_signals, LAST_SIGNAL); 
    80  
    81  
    82   class->atonal_if = NULL; 
     68atonal_if_class_init (AtonalIFClass *klass) 
     69{ 
     70  
    8371} 
    8472 

  • aube/branches/aube-gtk2/src/modules/atonal_if.h

    r372 r406  
    4040}; 
    4141 
    42 guint          atonal_if_get_type        (void); 
     42GType         atonal_if_get_type        (void); 
    4343GtkWidget*     atonal_if_new             (atonal *rsq); 
    4444void atonal_if_close_cb(GtkWidget *widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/delay_if.c

    r397 r406  
    1616extern GtkWidget *master_daddy; 
    1717 
    18 guint delay_if_get_type(void); 
    19 static void delay_if_class_init(DelayIFClass * class); 
     18static void delay_if_class_init(DelayIFClass * klass); 
    2019static void delay_if_init(DelayIF * b); 
    2120GtkWidget *delay_if_new(delay * dl); 
    …… 
    2625void delay_if_change_replace_menu_cb(GtkWidget * widget, gpointer data); 
    2726 
    28 guint 
    29 delay_if_get_type() 
    30 { 
    31   static guint b_type = 0; 
     27GType 
     28delay_if_get_type(void) 
     29{ 
     30  static GType b_type = 0; 
    3231 
    3332  if (!b_type) { 
    34     GtkTypeInfo b_info = 
     33    static const GTypeInfo b_info = 
    3534    { 
    36       "DelayIF", 
     35      sizeof(DelayIFClass), 
     36      NULL, /* base_init */ 
     37          NULL, /* base_finalise */ 
     38      (GClassInitFunc) delay_if_class_init, 
     39          NULL, /* class_finalize */ 
     40          NULL, /* class_data */ 
    3741      sizeof(DelayIF), 
    38       sizeof(DelayIFClass), 
    39       (GtkClassInitFunc) delay_if_class_init, 
    40       (GtkObjectInitFunc) delay_if_init, 
    41       (GtkArgSetFunc) NULL, 
    42       (GtkArgGetFunc) NULL, 
     42          0, /* n_preallocs */ 
     43          (GInstanceInitFunc)delay_if_init, 
    4344    }; 
    4445 
    45     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     46    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     47                                                      "DelayIF", 
     48                                                           &b_info, 0); 
    4649  } 
    4750  return b_type; 
    4851} 
    4952 
    50 enum { 
    51   LAST_SIGNAL 
    52 }; 
    53  
    54 static guint delay_if_signals[LAST_SIGNAL+1] = 
    55 {0}; 
    56  
    5753static void 
    58 delay_if_class_init(DelayIFClass * class) 
    59 { 
    60   GtkObjectClass *object_class; 
    61  
    62   object_class = (GtkObjectClass *) class; 
    63  
    64   gtk_object_class_add_signals(object_class, delay_if_signals, LAST_SIGNAL); 
    65   class->delay_if = NULL; 
     54delay_if_class_init(DelayIFClass * klass) 
     55{ 
     56  
    6657} 
    6758 

  • aube/branches/aube-gtk2/src/modules/delay_if.h

    r372 r406  
    3232  }; 
    3333 
    34   guint delay_if_get_type(void); 
     34  GType delay_if_get_type(void); 
    3535  GtkWidget *delay_if_new(delay * dl); 
    3636  void delay_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/drummachine_if.c

    r397 r406  
    1616extern char *note_names[97]; 
    1717 
    18 guint drummachine_if_get_type(void); 
    19 static void drummachine_if_class_init(DrumMachineIFClass * class); 
     18static void drummachine_if_class_init(DrumMachineIFClass * klass); 
    2019static void drummachine_if_init(DrumMachineIF * b); 
    2120GtkWidget *drummachine_if_new(drummachine * rsq); 
    …… 
    4746void dm_shift_track_right_cb (GtkWidget * widget, gpointer data); 
    4847 
    49 guint 
    50 drummachine_if_get_type() 
    51 { 
    52   static guint b_type = 0; 
     48GType 
     49drummachine_if_get_type(void) 
     50{ 
     51  static GType b_type = 0; 
    5352 
    5453  if (!b_type) { 
    55     GtkTypeInfo b_info = 
     54    static const GTypeInfo b_info = 
    5655    { 
    57       "DrumMachineIF", 
     56      sizeof(DrumMachineIFClass), 
     57      NULL, /* base_init */ 
     58          NULL, /* base_finalise */ 
     59      (GClassInitFunc) drummachine_if_class_init, 
     60          NULL, /* class_finalize */ 
     61          NULL, /* class_data */ 
    5862      sizeof(DrumMachineIF), 
    59       sizeof(DrumMachineIFClass), 
    60       (GtkClassInitFunc) drummachine_if_class_init, 
    61       (GtkObjectInitFunc) drummachine_if_init, 
    62       (GtkArgSetFunc) NULL, 
    63       (GtkArgGetFunc) NULL, 
     63          0, /* n_preallocs */ 
     64          (GInstanceInitFunc) drummachine_if_init, 
    6465    }; 
    6566 
    66     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     67    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     68                                                      "DrumMachineIF", 
     69                                                           &b_info, 0); 
    6770  } 
    6871  return b_type; 
    6972} 
    7073 
    71 enum { 
    72   LAST_SIGNAL 
    73 }; 
    74  
    75 static guint drummachine_if_signals[LAST_SIGNAL+1] = 
    76 {0}; 
    77  
    7874static void 
    79 drummachine_if_class_init(DrumMachineIFClass * class) 
    80 { 
    81   GtkObjectClass *object_class; 
    82  
    83   object_class = (GtkObjectClass *) class; 
    84  
    85   gtk_object_class_add_signals(object_class, drummachine_if_signals, LAST_SIGNAL); 
    86  
    87  
    88   class->drummachine_if = NULL; 
     75drummachine_if_class_init(DrumMachineIFClass * klass) 
     76{ 
     77   
    8978} 
    9079 

  • aube/branches/aube-gtk2/src/modules/drummachine_if.h

    r372 r406  
    3939  }; 
    4040 
    41   guint drummachine_if_get_type(void); 
     41  GType drummachine_if_get_type(void); 
    4242  GtkWidget *drummachine_if_new(drummachine * rsq); 
    4343  void drummachine_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/filter_reslp_if.c

    r397 r406  
    1111extern int tick; 
    1212 
    13 guint filter_reslp_if_get_type(void); 
    14 static void filter_reslp_if_class_init(FilterResLP_IFClass * class); 
     13static void filter_reslp_if_class_init(FilterResLP_IFClass * klass); 
    1514static void filter_reslp_if_init(FilterResLP_IF * b); 
    1615GtkWidget *filter_reslp_if_new(filter_reslp * fr); 
    …… 
    2322gint filter_reslp_get_envelopes(gpointer data); 
    2423 
    25 guint 
    26 filter_reslp_if_get_type() 
    27 { 
    28   static guint b_type = 0; 
     24GType 
     25filter_reslp_if_get_type(void) 
     26{ 
     27  static GType b_type = 0; 
    2928 
    3029  if (!b_type) { 
    31     GtkTypeInfo b_info = 
     30    static const GTypeInfo b_info = 
    3231    { 
    33       "FilterResLP_IF", 
     32      sizeof(FilterResLP_IFClass), 
     33      NULL, /* base_init */ 
     34          NULL, /* base_finalise */ 
     35      (GClassInitFunc) filter_reslp_if_class_init, 
     36          NULL, /* class_finalize */ 
     37          NULL, /* class_data */ 
    3438      sizeof(FilterResLP_IF), 
    35       sizeof(FilterResLP_IFClass), 
    36       (GtkClassInitFunc) filter_reslp_if_class_init, 
    37       (GtkObjectInitFunc) filter_reslp_if_init, 
    38       (GtkArgSetFunc) NULL, 
    39       (GtkArgGetFunc) NULL, 
     39          0, /* n_preallocs */ 
     40          (GInstanceInitFunc) filter_reslp_if_init, 
    4041    }; 
    4142 
    42     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     43    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     44                                                      "FilterResLP_IF", 
     45                                                           &b_info, 0); 
    4346  } 
    4447  return b_type; 
    4548} 
    4649 
    47 enum { 
    48   LAST_SIGNAL 
    49 }; 
    50  
    51 static guint filter_reslp_if_signals[LAST_SIGNAL+1] = 
    52 {0}; 
    53  
    5450static void 
    55 filter_reslp_if_class_init(FilterResLP_IFClass * class) 
    56 { 
    57   GtkObjectClass *object_class; 
    58  
    59   object_class = (GtkObjectClass *) class; 
    60  
    61   gtk_object_class_add_signals(object_class, filter_reslp_if_signals, LAST_SIGNAL); 
    62  
    63  
    64   class->filter_reslp_if = NULL; 
     51filter_reslp_if_class_init(FilterResLP_IFClass * klass) 
     52{ 
     53 
    6554} 
    6655 

  • aube/branches/aube-gtk2/src/modules/filter_reslp_if.h

    r372 r406  
    3535  }; 
    3636 
    37   guint filter_reslp_if_get_type(void); 
     37  GType filter_reslp_if_get_type(void); 
    3838  GtkWidget *filter_reslp_if_new(filter_reslp * fr); 
    3939  void filter_reslp_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/general_mixer_if.c

    r397 r406  
    1111#include "outputlabel.h" 
    1212 
    13 guint general_mixer_if_get_type(void); 
    14 static void general_mixer_if_class_init(GeneralMixerIFClass * class); 
     13static void general_mixer_if_class_init(GeneralMixerIFClass * klass); 
    1514static void general_mixer_if_init(GeneralMixerIF * b); 
    1615GtkWidget *general_mixer_if_new(general_mixer * xf); 
    …… 
    2524void general_mixer_if_mute_cb(GtkWidget * widget, gpointer data); 
    2625 
    27 guint 
    28 general_mixer_if_get_type() 
    29 { 
    30   static guint b_type = 0; 
     26GType 
     27general_mixer_if_get_type(void) 
     28{ 
     29  static GType b_type = 0; 
    3130 
    3231  if (!b_type) { 
    33     GtkTypeInfo b_info = 
     32    static const GTypeInfo b_info = 
    3433    { 
    35       "GeneralMixerIF", 
     34      sizeof(GeneralMixerIFClass), 
     35      NULL, /* base_init */ 
     36          NULL, /* base_finalise */ 
     37      (GClassInitFunc) general_mixer_if_class_init, 
     38          NULL, /* class_finalize */ 
     39          NULL, /* class_data */ 
    3640      sizeof(GeneralMixerIF), 
    37       sizeof(GeneralMixerIFClass), 
    38       (GtkClassInitFunc) general_mixer_if_class_init, 
    39       (GtkObjectInitFunc) general_mixer_if_init, 
    40       (GtkArgSetFunc) NULL, 
    41       (GtkArgGetFunc) NULL, 
     41          0, /* n_preallocs */ 
     42          (GInstanceInitFunc) general_mixer_if_init, 
    4243    }; 
    4344 
    44     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     45    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     46                                                      "GeneralMixerIF", 
     47                                                           &b_info, 0); 
    4548  } 
    4649  return b_type; 
    4750} 
    4851 
    49 enum { 
    50   LAST_SIGNAL 
    51 }; 
    52  
    53 static guint general_mixer_if_signals[LAST_SIGNAL+1] = 
    54 {0}; 
    55  
    5652static void 
    57 general_mixer_if_class_init(GeneralMixerIFClass * class) 
    58 { 
    59   GtkObjectClass *object_class; 
    60  
    61   object_class = (GtkObjectClass *) class; 
    62  
    63   gtk_object_class_add_signals(object_class, general_mixer_if_signals, LAST_SIGNAL); 
    64   class->general_mixer_if = NULL; 
     53general_mixer_if_class_init(GeneralMixerIFClass * klass) 
     54{ 
     55 
    6556} 
    6657 

  • aube/branches/aube-gtk2/src/modules/general_mixer_if.h

    r372 r406  
    3333  }; 
    3434 
    35   guint general_mixer_if_get_type(void); 
     35  GType general_mixer_if_get_type(void); 
    3636  GtkWidget *general_mixer_if_new(general_mixer * xf); 
    3737  void general_mixer_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/klav.c

    r397 r406  
    5353   Klav Methods  
    5454 */ 
    55 static void klav_class_init(KlavClass * class); 
     55static void klav_class_init(KlavClass * klass); 
    5656static void klav_init(Klav * klav); 
    5757 
    …… 
    7070static gint klav_motion_notify(GtkWidget * widget, GdkEventMotion * event); 
    7171 
    72 guint 
     72GType 
    7373klav_get_type(void) 
    7474{ 
    75   static guint klav_type = 0; 
    76  
    77   if (!klav_type) { 
    78     GtkTypeInfo klav_info = 
     75  static GType b_type = 0; 
     76 
     77  if (!b_type) { 
     78    static const GTypeInfo b_info = 
    7979    { 
    80       "Klav", 
     80      sizeof(KlavClass), 
     81      NULL, /* base_init */ 
     82          NULL, /* base_finalise */ 
     83      (GClassInitFunc) klav_class_init, 
     84          NULL, /* class_finalize */ 
     85          NULL, /* class_data */ 
    8186      sizeof(Klav), 
    82       sizeof(KlavClass), 
    83       (GtkClassInitFunc) klav_class_init, 
    84       (GtkObjectInitFunc) klav_init, 
    85       (GtkArgSetFunc) NULL, 
    86       (GtkArgGetFunc) NULL, 
     87          0, /* n_preallocs */ 
     88          (GInstanceInitFunc) klav_init, 
    8789    }; 
    8890 
    89     klav_type = gtk_type_unique(gtk_drawing_area_get_type(), &klav_info); 
    90   } 
    91   return klav_type; 
    92 } 
    93  
    94 static void 
    95 klav_class_init(KlavClass * class) 
     91    b_type = g_type_register_static(GTK_TYPE_DRAWING_AREA, 
     92                                                      "Klav", 
     93                                                           &b_info, 0); 
     94  } 
     95  return b_type; 
     96} 
     97 
     98static void 
     99klav_class_init(KlavClass * klass) 
    96100{ 
    97101  GtkObjectClass *object_class; 
    98102  GtkWidgetClass *widget_class; 
    99103 
    100   object_class = (GtkObjectClass *) class; 
    101   widget_class = (GtkWidgetClass *) class; 
     104  object_class = (GtkObjectClass *) klass; 
     105  widget_class = (GtkWidgetClass *) klass; 
    102106 
    103107  parent_class = gtk_type_class(gtk_drawing_area_get_type()); 
    104108 
    105109  klav_signals[KLAVKEY_PRESS] = 
    106     gtk_signal_new("klavkey_press", GTK_RUN_FIRST, object_class->type, 
     110        g_signal_new("klavkey_press", 
     111                             G_TYPE_FROM_CLASS(klass), 
     112                             G_SIGNAL_RUN_FIRST, 
     113                         G_STRUCT_OFFSET(KlavClass, klavkey_press), 
     114                         NULL, 
     115                             NULL, 
     116                                 g_cclosure_marshal_VOID__INT, GTK_TYPE_NONE, 1, GTK_TYPE_INT); 
     117         
     118   /* FIXME 
     119        gtk_signal_new("klavkey_press", GTK_RUN_FIRST, object_class->type, 
    107120                   GTK_SIGNAL_OFFSET(KlavClass, klavkey_press), 
    108121                   klav_marshal_signal_1, GTK_TYPE_NONE, 1, 
    109122                   GTK_TYPE_INT); 
    110  
     123*/ 
    111124  klav_signals[KLAVKEY_RELEASE] = 
     125        g_signal_new("klavkey_release", 
     126                             G_TYPE_FROM_CLASS(klass), 
     127                             G_SIGNAL_RUN_FIRST, 
     128                         G_STRUCT_OFFSET(KlavClass, klavkey_release), 
     129                         NULL, 
     130                             NULL, 
     131                                 g_cclosure_marshal_VOID__INT, GTK_TYPE_NONE, 1, GTK_TYPE_INT); 
     132         
     133 /* FIXME 
    112134    gtk_signal_new("klavkey_release", GTK_RUN_FIRST, object_class->type, 
    113135                   GTK_SIGNAL_OFFSET(KlavClass, klavkey_release), 
    114136                   klav_marshal_signal_1, GTK_TYPE_NONE, 1, 
    115137                   GTK_TYPE_INT); 
    116  
    117   gtk_object_class_add_signals(object_class, klav_signals, LAST_SIGNAL); 
     138*/ 
    118139 
    119140  object_class->destroy = klav_destroy; 
    …… 
    158179   */ 
    159180 
    160   if (klav->key_info) { 
    161     g_free(klav->key_info); 
    162   } 
    163181  if (GTK_OBJECT_CLASS(parent_class)->destroy) 
    164182    (*GTK_OBJECT_CLASS(parent_class)->destroy) (object); 
     183 /* FIXME: double free occurs if this is enabled.  
     184   if (klav->key_info) { 
     185    g_free(klav->key_info); 
     186  }*/ 
    165187} 
    166188 

  • aube/branches/aube-gtk2/src/modules/klav.h

    r372 r406  
    106106  }; 
    107107 
    108   guint klav_get_type(void); 
     108  GType klav_get_type(void); 
    109109  GtkWidget *klav_new(void); 
    110110 

  • aube/branches/aube-gtk2/src/modules/klavier_if.c

    r397 r406  
    1616extern int tick; 
    1717 
    18 guint klavier_if_get_type(void); 
    19 static void klavier_if_class_init(KlavierIFClass * class); 
     18static void klavier_if_class_init(KlavierIFClass * klass); 
    2019static void klavier_if_init(KlavierIF * b); 
    2120GtkWidget *klavier_if_new(klavier * k); 
    …… 
    3130gint get_note_from_key(guint keyval); 
    3231 
    33 guint 
    34 klavier_if_get_type() 
    35 { 
    36   static guint b_type = 0; 
     32GType 
     33klavier_if_get_type(void) 
     34{ 
     35  static GType b_type = 0; 
    3736 
    3837  if (!b_type) { 
    39     GtkTypeInfo b_info = 
     38    static const GTypeInfo b_info = 
    4039    { 
    41       "KlavierIF", 
     40      sizeof(KlavierIFClass), 
     41      NULL, /* base_init */ 
     42          NULL, /* base_finalise */ 
     43      (GClassInitFunc) klavier_if_class_init, 
     44          NULL, /* class_finalize */ 
     45          NULL, /* class_data */ 
    4246      sizeof(KlavierIF), 
    43       sizeof(KlavierIFClass), 
    44       (GtkClassInitFunc) klavier_if_class_init, 
    45       (GtkObjectInitFunc) klavier_if_init, 
    46       (GtkArgSetFunc) NULL, 
    47       (GtkArgGetFunc) NULL, 
     47          0, /* n_preallocs */ 
     48          (GInstanceInitFunc) klavier_if_init, 
    4849    }; 
    4950 
    50     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     51    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     52                                                      "KlavierIF", 
     53                                                           &b_info, 0); 
    5154  } 
    5255  return b_type; 
    5356} 
    5457 
    55 enum { 
    56   LAST_SIGNAL 
    57 }; 
    58  
    59 static guint klavier_if_signals[LAST_SIGNAL+1] = 
    60 {0}; 
    61  
    6258static void 
    63 klavier_if_class_init(KlavierIFClass * class) 
    64 { 
    65   GtkObjectClass *object_class; 
    66  
    67   object_class = (GtkObjectClass *) class; 
    68  
    69   gtk_object_class_add_signals(object_class, klavier_if_signals, LAST_SIGNAL); 
    70  
    71  
    72   class->klavier_if = NULL; 
     59klavier_if_class_init(KlavierIFClass * klass) 
     60{ 
     61   
    7362} 
    7463 

  • aube/branches/aube-gtk2/src/modules/klavier_if.h

    r372 r406  
    3131  }; 
    3232 
    33   guint klavier_if_get_type(void); 
     33  GType klavier_if_get_type(void); 
    3434  GtkWidget *klavier_if_new(klavier * k); 
    3535  void klavier_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/linein_if.c

    r397 r406  
    99#include "outputlabel.h" 
    1010 
    11 guint linein_if_get_type(void); 
    12 static void linein_if_class_init(LINEINIFClass * class); 
     11static void linein_if_class_init(LINEINIFClass * klass); 
    1312static void linein_if_init(LINEINIF * b); 
    1413GtkWidget *linein_if_new(oss_in * oss_p); 
    …… 
    2625#endif 
    2726 
    28 guint 
    29 linein_if_get_type() 
    30 { 
    31   static guint b_type = 0; 
     27GType 
     28linein_if_get_type(void) 
     29{ 
     30  static GType b_type = 0; 
    3231 
    3332  if (!b_type) { 
    34     GtkTypeInfo b_info = 
     33    static const GTypeInfo b_info = 
    3534    { 
    36       "LINEINIF", 
     35      sizeof(LINEINIFClass), 
     36      NULL, /* base_init */ 
     37          NULL, /* base_finalise */ 
     38      (GClassInitFunc) linein_if_class_init, 
     39          NULL, /* class_finalize */ 
     40          NULL, /* class_data */ 
    3741      sizeof(LINEINIF), 
    38       sizeof(LINEINIFClass), 
    39       (GtkClassInitFunc) linein_if_class_init, 
    40       (GtkObjectInitFunc) linein_if_init, 
    41       (GtkArgSetFunc) NULL, 
    42       (GtkArgGetFunc) NULL, 
     42          0, /* n_preallocs */ 
     43          (GInstanceInitFunc) linein_if_init, 
    4344    }; 
    4445 
    45     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     46    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     47                                                      "LINEINIF", 
     48                                                           &b_info, 0); 
    4649  } 
    4750  return b_type; 
    4851} 
    4952 
    50 enum { 
    51   LAST_SIGNAL 
    52 }; 
    53  
    54 static guint linein_if_signals[LAST_SIGNAL+1] = 
    55 {0}; 
    56  
    5753static void 
    58 linein_if_class_init(LINEINIFClass * class) 
    59 { 
    60   GtkObjectClass *object_class; 
    61  
    62   object_class = (GtkObjectClass *) class; 
    63  
    64   gtk_object_class_add_signals(object_class, linein_if_signals, LAST_SIGNAL); 
    65  
    66   class->linein_if = NULL; 
     54linein_if_class_init(LINEINIFClass * klass) 
     55{ 
     56 
    6757} 
    6858 

  • aube/branches/aube-gtk2/src/modules/linein_if.h

    r372 r406  
    3434  }; 
    3535 
    36   guint linein_if_get_type(void); 
     36  GType linein_if_get_type(void); 
    3737  GtkWidget *linein_if_new(oss_in * oss_p); 
    3838  void linein_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/lineout_if.c

    r397 r406  
    99#include "opsmenu.h" 
    1010 
    11 guint lineout_if_get_type(void); 
    12 static void lineout_if_class_init(LINEOUTIFClass * class); 
     11static void lineout_if_class_init(LINEOUTIFClass * klass); 
    1312static void lineout_if_init(LINEOUTIF * b); 
    1413GtkWidget *lineout_if_new(oss_out * oss_p); 
    …… 
    2019void lineout_if_set_device_dsp1_cb(GtkWidget * widget, gpointer data); 
    2120 
    22  
    23 guint 
    24 lineout_if_get_type() 
    25 { 
    26   static guint b_type = 0; 
     21GType 
     22lineout_if_get_type(void) 
     23{ 
     24  static GType b_type = 0; 
    2725 
    2826  if (!b_type) { 
    29     GtkTypeInfo b_info = 
     27    static const GTypeInfo b_info = 
    3028    { 
    31       "LINEOUTIF", 
     29      sizeof(LINEOUTIFClass), 
     30      NULL, /* base_init */ 
     31          NULL, /* base_finalise */ 
     32      (GClassInitFunc) lineout_if_class_init, 
     33          NULL, /* class_finalize */ 
     34          NULL, /* class_data */ 
    3235      sizeof(LINEOUTIF), 
    33       sizeof(LINEOUTIFClass), 
    34       (GtkClassInitFunc) lineout_if_class_init, 
    35       (GtkObjectInitFunc) lineout_if_init, 
    36       (GtkArgSetFunc) NULL, 
    37       (GtkArgGetFunc) NULL, 
     36          0, /* n_preallocs */ 
     37          (GInstanceInitFunc) lineout_if_init, 
    3838    }; 
    3939 
    40     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     40    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     41                                                      "LINEOUTIF", 
     42                                                           &b_info, 0); 
    4143  } 
    4244  return b_type; 
    4345} 
    4446 
    45 enum { 
    46   LAST_SIGNAL 
    47 }; 
    48  
    49 static guint lineout_if_signals[LAST_SIGNAL+1] = 
    50 {0}; 
    51  
    5247static void 
    53 lineout_if_class_init(LINEOUTIFClass * class) 
    54 { 
    55   GtkObjectClass *object_class; 
    56  
    57   object_class = (GtkObjectClass *) class; 
    58  
    59   gtk_object_class_add_signals(object_class, lineout_if_signals, LAST_SIGNAL); 
    60  
    61   class->lineout_if = NULL; 
     48lineout_if_class_init(LINEOUTIFClass * klass) 
     49{ 
     50  
    6251} 
    6352 

  • aube/branches/aube-gtk2/src/modules/lineout_if.h

    r372 r406  
    3333  }; 
    3434 
    35   guint lineout_if_get_type(void); 
     35  GType lineout_if_get_type(void); 
    3636  GtkWidget *lineout_if_new(oss_out * oss_p); 
    3737  void lineout_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/minimaube_if.c

    r397 r406  
    1717extern GtkWidget *master_daddy; 
    1818 
    19 guint minimaube_if_get_type(void); 
    20 static void minimaube_if_class_init(MiniMaubeIFClass * class); 
     19static void minimaube_if_class_init(MiniMaubeIFClass * klass); 
    2120static void minimaube_if_init(MiniMaubeIF * b); 
    2221GtkWidget *minimaube_if_new(minimaube * s); 
    …… 
    3130void minimaube_if_remove_input(MiniMaubeIF * minimaube_if, int i); 
    3231 
    33 guint 
    34 minimaube_if_get_type() 
    35 { 
    36   static guint b_type = 0; 
     32GType 
     33minimaube_if_get_type(void) 
     34{ 
     35  static GType b_type = 0; 
    3736 
    3837  if (!b_type) { 
    39     GtkTypeInfo b_info = 
     38    static const GTypeInfo b_info = 
    4039    { 
    41       "MiniMaubeIF", 
     40      sizeof(MiniMaubeIFClass), 
     41      NULL, /* base_init */ 
     42          NULL, /* base_finalise */ 
     43      (GClassInitFunc) minimaube_if_class_init, 
     44          NULL, /* class_finalize */ 
     45          NULL, /* class_data */ 
    4246      sizeof(MiniMaubeIF), 
    43       sizeof(MiniMaubeIFClass), 
    44       (GtkClassInitFunc) minimaube_if_class_init, 
    45       (GtkObjectInitFunc) minimaube_if_init, 
    46       (GtkArgSetFunc) NULL, 
    47       (GtkArgGetFunc) NULL, 
     47          0, /* n_preallocs */ 
     48          (GInstanceInitFunc) minimaube_if_init, 
    4849    }; 
    4950 
    50     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     51    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     52                                                      "MiniMaubeIF", 
     53                                                           &b_info, 0); 
    5154  } 
    5255  return b_type; 
    5356} 
    5457 
    55 enum { 
    56   LAST_SIGNAL 
    57 }; 
    58  
    59 static guint minimaube_if_signals[LAST_SIGNAL+1] = 
    60 {0}; 
    61  
    6258static void 
    63 minimaube_if_class_init(MiniMaubeIFClass * class) 
    64 { 
    65   GtkObjectClass *object_class; 
    66  
    67   object_class = (GtkObjectClass *) class; 
    68  
    69   gtk_object_class_add_signals(object_class, minimaube_if_signals, LAST_SIGNAL); 
    70   class->minimaube_if = NULL; 
     59minimaube_if_class_init(MiniMaubeIFClass * klass) 
     60{ 
     61  
    7162} 
    7263 

  • aube/branches/aube-gtk2/src/modules/minimaube_if.h

    r372 r406  
    3434  }; 
    3535 
    36   guint minimaube_if_get_type(void); 
     36  GType minimaube_if_get_type(void); 
    3737  GtkWidget *minimaube_if_new(minimaube * dl); 
    3838  void minimaube_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/minitracker_if.c

    r397 r406  
    1616extern char *note_names[97]; 
    1717 
    18 guint minitracker_if_get_type(void); 
    19 static void minitracker_if_class_init(MinitrackerIFClass * class); 
     18static void minitracker_if_class_init(MinitrackerIFClass * klass); 
    2019static void minitracker_if_init(MinitrackerIF * b); 
    2120GtkWidget *minitracker_if_new(minitracker * rsq); 
    …… 
    3938void rshift_cb(GtkWidget * widget, gpointer data); 
    4039 
    41 guint 
    42 minitracker_if_get_type() 
    43 { 
    44   static guint b_type = 0; 
     40GType 
     41minitracker_if_get_type(void) 
     42{ 
     43  static GType b_type = 0; 
    4544 
    4645  if (!b_type) { 
    47     GtkTypeInfo b_info = 
     46    static const GTypeInfo b_info = 
    4847    { 
    49       "MinitrackerIF", 
     48      sizeof(MinitrackerIFClass), 
     49      NULL, /* base_init */ 
     50          NULL, /* base_finalise */ 
     51      (GClassInitFunc) minitracker_if_class_init, 
     52          NULL, /* class_finalize */ 
     53          NULL, /* class_data */ 
    5054      sizeof(MinitrackerIF), 
    51       sizeof(MinitrackerIFClass), 
    52       (GtkClassInitFunc) minitracker_if_class_init, 
    53       (GtkObjectInitFunc) minitracker_if_init, 
    54       (GtkArgSetFunc) NULL, 
    55       (GtkArgGetFunc) NULL, 
     55          0, /* n_preallocs */ 
     56          (GInstanceInitFunc) minitracker_if_init, 
    5657    }; 
    5758 
    58     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     59    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     60                                                      "MinitrackerIF", 
     61                                                           &b_info, 0); 
    5962  } 
    6063  return b_type; 
    6164} 
    6265 
    63 enum { 
    64   LAST_SIGNAL 
    65 }; 
    66  
    67 static guint minitracker_if_signals[LAST_SIGNAL+1] = 
    68 {0}; 
    69  
    7066static void 
    71 minitracker_if_class_init(MinitrackerIFClass * class) 
    72 { 
    73   GtkObjectClass *object_class; 
    74  
    75   object_class = (GtkObjectClass *) class; 
    76  
    77   gtk_object_class_add_signals(object_class, minitracker_if_signals, LAST_SIGNAL); 
    78  
    79  
    80   class->minitracker_if = NULL; 
     67minitracker_if_class_init(MinitrackerIFClass * klass) 
     68{ 
     69   
    8170} 
    8271 

  • aube/branches/aube-gtk2/src/modules/minitracker_if.h

    r372 r406  
    3232  }; 
    3333 
    34   guint minitracker_if_get_type(void); 
     34  GType minitracker_if_get_type(void); 
    3535  GtkWidget *minitracker_if_new(minitracker * rsq); 
    3636  void minitracker_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/panner4_if.c

    r397 r406  
    1212extern int tick; 
    1313 
    14 guint panner4_if_get_type(void); 
    15 static void panner4_if_class_init(Panner4IFClass * class); 
     14static void panner4_if_class_init(Panner4IFClass * klass); 
    1615static void panner4_if_init(Panner4IF * b); 
    1716GtkWidget *panner4_if_new(panner4 * pn); 
    …… 
    2120void panner4_if_onoff_cb(GtkWidget * widget, gpointer data); 
    2221 
    23 guint 
    24 panner4_if_get_type() 
    25 { 
    26   static guint b_type = 0; 
     22GType 
     23panner4_if_get_type(void) 
     24{ 
     25  static GType b_type = 0; 
    2726 
    2827  if (!b_type) { 
    29     GtkTypeInfo b_info = 
     28    static const GTypeInfo b_info = 
    3029    { 
    31       "Panner4IF", 
     30      sizeof(Panner4IFClass), 
     31      NULL, /* base_init */ 
     32          NULL, /* base_finalise */ 
     33      (GClassInitFunc) panner4_if_class_init, 
     34          NULL, /* class_finalize */ 
     35          NULL, /* class_data */ 
    3236      sizeof(Panner4IF), 
    33       sizeof(Panner4IFClass), 
    34       (GtkClassInitFunc) panner4_if_class_init, 
    35       (GtkObjectInitFunc) panner4_if_init, 
    36       (GtkArgSetFunc) NULL, 
    37       (GtkArgGetFunc) NULL, 
     37          0, /* n_preallocs */ 
     38          (GInstanceInitFunc) panner4_if_init, 
    3839    }; 
    3940 
    40     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     41    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     42                                                      "Panner4IF", 
     43                                                           &b_info, 0); 
    4144  } 
    4245  return b_type; 
    4346} 
    4447 
    45 enum { 
    46   LAST_SIGNAL 
    47 }; 
    48  
    49 static guint panner4_if_signals[LAST_SIGNAL+1] = 
    50 {0}; 
    51  
    5248static void 
    53 panner4_if_class_init(Panner4IFClass * class) 
    54 { 
    55   GtkObjectClass *object_class; 
    56  
    57   object_class = (GtkObjectClass *) class; 
    58  
    59   gtk_object_class_add_signals(object_class, panner4_if_signals, LAST_SIGNAL); 
    60   class->panner4_if = NULL; 
     49panner4_if_class_init(Panner4IFClass * klass) 
     50{ 
     51  
    6152} 
    6253 

  • aube/branches/aube-gtk2/src/modules/panner4_if.h

    r372 r406  
    3131  }; 
    3232 
    33   guint panner4_if_get_type(void); 
     33  GType panner4_if_get_type(void); 
    3434  GtkWidget *panner4_if_new(panner4 * pn); 
    3535  void panner4_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/panner_if.c

    r397 r406  
    1212extern int tick; 
    1313 
    14 guint panner_if_get_type(void); 
    15 static void panner_if_class_init(PannerIFClass * class); 
     14static void panner_if_class_init(PannerIFClass * klass); 
    1615static void panner_if_init(PannerIF * b); 
    1716GtkWidget *panner_if_new(panner * pn); 
    …… 
    2120void panner_if_onoff_cb(GtkWidget * widget, gpointer data); 
    2221 
    23 guint 
    24 panner_if_get_type() 
     22GType 
     23panner_if_get_type(void) 
    2524{ 
    26   static guint b_type = 0; 
     25  static GType b_type = 0; 
    2726 
    2827  if (!b_type) { 
    29     GtkTypeInfo b_info = 
     28    static const GTypeInfo b_info = 
    3029    { 
    31       "PannerIF", 
     30      sizeof(PannerIFClass), 
     31      NULL, /* base_init */ 
     32          NULL, /* base_finalise */ 
     33      (GClassInitFunc) panner_if_class_init, 
     34          NULL, /* class_finalize */ 
     35          NULL, /* class_data */ 
    3236      sizeof(PannerIF), 
    33       sizeof(PannerIFClass), 
    34       (GtkClassInitFunc) panner_if_class_init, 
    35       (GtkObjectInitFunc) panner_if_init, 
    36       (GtkArgSetFunc) NULL, 
    37       (GtkArgGetFunc) NULL, 
     37          0, /* n_preallocs */ 
     38          (GInstanceInitFunc) panner_if_init, 
    3839    }; 
    3940 
    40     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     41    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     42                                                      "PannerIF", 
     43                                                           &b_info, 0); 
    4144  } 
    4245  return b_type; 
    4346} 
    4447 
    45 enum { 
    46   LAST_SIGNAL 
    47 }; 
    48  
    49 static guint panner_if_signals[LAST_SIGNAL+1] = 
    50 {0}; 
    51  
    5248static void 
    53 panner_if_class_init(PannerIFClass * class) 
     49panner_if_class_init(PannerIFClass * klass) 
    5450{ 
    55   GtkObjectClass *object_class; 
    56  
    57   object_class = (GtkObjectClass *) class; 
    58  
    59   gtk_object_class_add_signals(object_class, panner_if_signals, LAST_SIGNAL); 
    60   class->panner_if = NULL; 
     51  
    6152} 
    6253 

  • aube/branches/aube-gtk2/src/modules/panner_if.h

    r372 r406  
    3131  }; 
    3232 
    33   guint panner_if_get_type(void); 
     33  GType panner_if_get_type(void); 
    3434  GtkWidget *panner_if_new(panner * pn); 
    3535  void panner_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/sample_recorder_if.c

    r397 r406  
    1313extern int tick; 
    1414 
    15 guint sample_recorder_if_get_type(void); 
    16 static void sample_recorder_if_class_init(SampleRecorderIFClass * class); 
     15static void sample_recorder_if_class_init(SampleRecorderIFClass * klass); 
    1716static void sample_recorder_if_init(SampleRecorderIF * b); 
    1817GtkWidget *sample_recorder_if_new(sample_recorder * pn); 
    …… 
    3635void sample_recorder_if_add_sample(GtkWidget * widget, gpointer data); 
    3736 
    38  
    39 guint 
    40 sample_recorder_if_get_type() 
    41 { 
    42   static guint b_type = 0; 
     37GType 
     38sample_recorder_if_get_type(void) 
     39{ 
     40  static GType b_type = 0; 
    4341 
    4442  if (!b_type) { 
    45     GtkTypeInfo b_info = 
     43    static const GTypeInfo b_info = 
    4644    { 
    47       "SampleRecorderIF", 
     45      sizeof(SampleRecorderIFClass), 
     46      NULL, /* base_init */ 
     47          NULL, /* base_finalise */ 
     48      (GClassInitFunc) sample_recorder_if_class_init, 
     49          NULL, /* class_finalize */ 
     50          NULL, /* class_data */ 
    4851      sizeof(SampleRecorderIF), 
    49       sizeof(SampleRecorderIFClass), 
    50       (GtkClassInitFunc) sample_recorder_if_class_init, 
    51       (GtkObjectInitFunc) sample_recorder_if_init, 
    52       (GtkArgSetFunc) NULL, 
    53       (GtkArgGetFunc) NULL, 
     52          0, /* n_preallocs */ 
     53          (GInstanceInitFunc)sample_recorder_if_init, 
    5454    }; 
    5555 
    56     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     56    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     57                                                      "SampleRecorderIF", 
     58                                                           &b_info, 0); 
    5759  } 
    5860  return b_type; 
    5961} 
    6062 
    61 enum { 
    62   LAST_SIGNAL 
    63 }; 
    64  
    65 static guint sample_recorder_if_signals[LAST_SIGNAL+1] = 
    66 {0}; 
    67  
    6863static void 
    69 sample_recorder_if_class_init(SampleRecorderIFClass * class) 
    70 { 
    71   GtkObjectClass *object_class; 
    72  
    73   object_class = (GtkObjectClass *) class; 
    74  
    75   gtk_object_class_add_signals(object_class, sample_recorder_if_signals, LAST_SIGNAL); 
    76   class->sample_recorder_if = NULL; 
     64sample_recorder_if_class_init(SampleRecorderIFClass * klass) 
     65{ 
     66  
    7767} 
    7868 

  • aube/branches/aube-gtk2/src/modules/sample_recorder_if.h

    r372 r406  
    3535  }; 
    3636 
    37   guint sample_recorder_if_get_type(void); 
     37  GType sample_recorder_if_get_type(void); 
    3838  GtkWidget *sample_recorder_if_new(sample_recorder * pn); 
    3939  void sample_recorder_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/syre_if.c

    r397 r406  
    1818extern int tick; 
    1919 
    20 guint syre_if_get_type(void); 
    21 static void syre_if_class_init(SyreIFClass * class); 
     20static void syre_if_class_init(SyreIFClass * klass); 
    2221static void syre_if_init(SyreIF * b); 
    2322GtkWidget *syre_if_new(syre_if_data * syre_if_data); 
    …… 
    4039gint get_envelopes(gpointer data); 
    4140 
    42 guint 
    43 syre_if_get_type() 
    44 { 
    45   static guint b_type = 0; 
     41GType 
     42syre_if_get_type(void) 
     43{ 
     44  static GType b_type = 0; 
    4645 
    4746  if (!b_type) { 
    48     GtkTypeInfo b_info = 
     47    static const GTypeInfo b_info = 
    4948    { 
    50       "SyreIF", 
     49      sizeof(SyreIFClass), 
     50      NULL, /* base_init */ 
     51          NULL, /* base_finalise */ 
     52      (GClassInitFunc) syre_if_class_init, 
     53          NULL, /* class_finalize */ 
     54          NULL, /* class_data */ 
    5155      sizeof(SyreIF), 
    52       sizeof(SyreIFClass), 
    53       (GtkClassInitFunc) syre_if_class_init, 
    54       (GtkObjectInitFunc) syre_if_init, 
    55       (GtkArgSetFunc) NULL, 
    56       (GtkArgGetFunc) NULL, 
     56          0, /* n_preallocs */ 
     57          (GInstanceInitFunc) syre_if_init, 
    5758    }; 
    5859 
    59     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     60    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     61                                                      "SyreIF", 
     62                                                           &b_info, 0); 
    6063  } 
    6164  return b_type; 
    6265} 
    6366 
    64 enum { 
    65   LAST_SIGNAL 
    66 }; 
    67  
    68 static guint syre_if_signals[LAST_SIGNAL+1] = 
    69 {0}; 
    70  
    7167static void 
    72 syre_if_class_init(SyreIFClass * class) 
    73 { 
    74   GtkObjectClass *object_class; 
    75  
    76   object_class = (GtkObjectClass *) class; 
    77  
    78   gtk_object_class_add_signals(object_class, syre_if_signals, LAST_SIGNAL); 
    79  
    80  
    81   class->syre_if = NULL; 
     68syre_if_class_init(SyreIFClass * klass) 
     69{ 
     70  
    8271} 
    8372 

  • aube/branches/aube-gtk2/src/modules/syre_if.h

    r372 r406  
    3838  }; 
    3939 
    40   guint syre_if_get_type(void); 
     40  GType syre_if_get_type(void); 
    4141  GtkWidget *syre_if_new(syre_if_data * sd); 
    4242  void syre_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/whitenoise_if.c

    r397 r406  
    1010#include "outputlabel.h" 
    1111 
    12 guint whitenoise_if_get_type(void); 
    13 static void whitenoise_if_class_init(WhitenoiseIFClass * class); 
     12static void whitenoise_if_class_init(WhitenoiseIFClass * klass); 
    1413static void whitenoise_if_init(WhitenoiseIF * b); 
    1514GtkWidget *whitenoise_if_new(whitenoise * wn); 
    …… 
    1918void whitenoise_if_onoff_cb(GtkWidget * widget, gpointer data); 
    2019 
    21 guint 
    22 whitenoise_if_get_type() 
     20GType 
     21whitenoise_if_get_type(void) 
    2322{ 
    24   static guint b_type = 0; 
     23  static GType b_type = 0; 
    2524 
    2625  if (!b_type) { 
    27     GtkTypeInfo b_info = 
     26    static const GTypeInfo b_info = 
    2827    { 
    29       "WhitenoiseIF", 
     28      sizeof(WhitenoiseIFClass), 
     29      NULL, /* base_init */ 
     30          NULL, /* base_finalise */ 
     31      (GClassInitFunc) whitenoise_if_class_init, 
     32          NULL, /* class_finalize */ 
     33          NULL, /* class_data */ 
    3034      sizeof(WhitenoiseIF), 
    31       sizeof(WhitenoiseIFClass), 
    32       (GtkClassInitFunc) whitenoise_if_class_init, 
    33       (GtkObjectInitFunc) whitenoise_if_init, 
    34       (GtkArgSetFunc) NULL, 
    35       (GtkArgGetFunc) NULL, 
     35          0, /* n_preallocs */ 
     36          (GInstanceInitFunc) whitenoise_if_init, 
    3637    }; 
    3738 
    38     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     39    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     40                                                      "WhitenoiseIF", 
     41                                                           &b_info, 0); 
    3942  } 
    4043  return b_type; 
    4144} 
    4245 
    43 enum { 
    44   LAST_SIGNAL 
    45 }; 
     46static void 
     47whitenoise_if_class_init(WhitenoiseIFClass * klass) 
     48{ 
    4649 
    47 static guint whitenoise_if_signals[LAST_SIGNAL+1] = 
    48 {0}; 
    49  
    50 static void 
    51 whitenoise_if_class_init(WhitenoiseIFClass * class) 
    52 { 
    53   GtkObjectClass *object_class; 
    54  
    55   object_class = (GtkObjectClass *) class; 
    56  
    57   gtk_object_class_add_signals(object_class, whitenoise_if_signals, LAST_SIGNAL); 
    58   class->whitenoise_if = NULL; 
    5950} 
    6051 
    …… 
    123114              GTK_SIGNAL_FUNC(whitenoise_if_onoff_cb), whitenoise_if->data); 
    124115  gtk_widget_show(button); 
    125   gtk_accel_group_add (accel_group, GDK_Escape, GDK_NONE, 0, 
     116/* FIXME: funky accel business  
     117 gtk_accel_group_add (accel_group, GDK_Escape, GDK_NONE, 0, 
    126118                       GTK_OBJECT(button), "clicked"); 
    127  
     119 */ 
     120                                              
    128121  button = opsmenu_new((module *) whitenoise_if->data, GTK_WIDGET(whitenoise_if), 
    129122                       whitenoise_if_hide_cb, whitenoise_if_close_cb); 

  • aube/branches/aube-gtk2/src/modules/whitenoise_if.h

    r372 r406  
    3131  }; 
    3232 
    33   guint whitenoise_if_get_type(void); 
     33  GType whitenoise_if_get_type(void); 
    3434  GtkWidget *whitenoise_if_new(whitenoise * wn); 
    3535  void whitenoise_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/modules/xfader_if.c

    r397 r406  
    1010#include "outputlabel.h" 
    1111 
    12 guint xfader_if_get_type(void); 
    13 static void xfader_if_class_init(XFaderIFClass * class); 
     12static void xfader_if_class_init(XFaderIFClass * klass); 
    1413static void xfader_if_init(XFaderIF * b); 
    1514GtkWidget *xfader_if_new(xfader * xf); 
    …… 
    1918void xfader_if_onoff_cb(GtkWidget * widget, gpointer data); 
    2019 
    21 guint 
    22 xfader_if_get_type() 
    23 { 
    24   static guint b_type = 0; 
     20GType 
     21xfader_if_get_type(void) 
     22{ 
     23  static GType b_type = 0; 
    2524 
    2625  if (!b_type) { 
    27     GtkTypeInfo b_info = 
     26    static const GTypeInfo b_info = 
    2827    { 
    29       "XFaderIF", 
     28      sizeof(XFaderIFClass), 
     29      NULL, /* base_init */ 
     30          NULL, /* base_finalise */ 
     31      (GClassInitFunc) xfader_if_class_init, 
     32          NULL, /* class_finalize */ 
     33          NULL, /* class_data */ 
    3034      sizeof(XFaderIF), 
    31       sizeof(XFaderIFClass), 
    32       (GtkClassInitFunc) xfader_if_class_init, 
    33       (GtkObjectInitFunc) xfader_if_init, 
    34       (GtkArgSetFunc) NULL, 
    35       (GtkArgGetFunc) NULL, 
     35          0, /* n_preallocs */ 
     36          (GInstanceInitFunc) xfader_if_init, 
    3637    }; 
    3738 
    38     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     39    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     40                                                      "XFaderIF", 
     41                                                           &b_info, 0); 
    3942  } 
    4043  return b_type; 
    4144} 
    4245 
    43 enum { 
    44   LAST_SIGNAL 
    45 }; 
    46  
    47 static guint xfader_if_signals[LAST_SIGNAL+1] = 
    48 {0}; 
    49  
    5046static void 
    51 xfader_if_class_init(XFaderIFClass * class) 
    52 { 
    53   GtkObjectClass *object_class; 
    54  
    55   object_class = (GtkObjectClass *) class; 
    56  
    57   gtk_object_class_add_signals(object_class, xfader_if_signals, LAST_SIGNAL); 
    58   class->xfader_if = NULL; 
     47xfader_if_class_init(XFaderIFClass * klass) 
     48{ 
     49  
    5950} 
    6051 

  • aube/branches/aube-gtk2/src/modules/xfader_if.h

    r372 r406  
    3131  }; 
    3232 
    33   guint xfader_if_get_type(void); 
     33  GType xfader_if_get_type(void); 
    3434  GtkWidget *xfader_if_new(xfader * xf); 
    3535  void xfader_if_close_cb(GtkWidget * widget, gpointer data); 

  • aube/branches/aube-gtk2/src/none_config.c

    r397 r406  
    1414extern GtkWidget *master_daddy; 
    1515 
    16 guint none_config_get_type(void); 
    1716static void none_config_class_init(NoneConfigClass * class); 
    1817static void none_config_init(NoneConfig * b); 
    …… 
    3130} 
    3231 
    33 guint 
    34 none_config_get_type() 
     32GType 
     33none_config_get_type(void) 
    3534{ 
    36   static guint b_type = 0; 
     35  static GType b_type = 0; 
    3736 
    3837  if (!b_type) { 
    39     GtkTypeInfo b_info = 
     38    static const GTypeInfo b_info = 
    4039    { 
    41       "NoneConfig", 
     40      sizeof(NoneConfigClass), 
     41      NULL, /* base_init */ 
     42          NULL, /* base_finalise */ 
     43      (GClassInitFunc) none_config_class_init, 
     44          NULL, /* class_finalize */ 
     45          NULL, /* class_data */ 
    4246      sizeof(NoneConfig), 
    43       sizeof(NoneConfigClass), 
    44       (GtkClassInitFunc) none_config_class_init, 
    45       (GtkObjectInitFunc) none_config_init, 
    46       (GtkArgSetFunc) NULL, 
    47       (GtkArgGetFunc) NULL, 
     47          0, /* n_preallocs */ 
     48          (GInstanceInitFunc) none_config_init, 
    4849    }; 
    4950 
    50     b_type = gtk_type_unique(gtk_window_get_type(), &b_info); 
     51    b_type = g_type_register_static(GTK_TYPE_WINDOW, 
     52                                                      "NoneConfig", 
     53                                                           &b_info, 0); 
    5154  } 
    5255  return b_type; 
    5356} 
    5457 
    55 enum { 
    56   LAST_SIGNAL 
    57 }; 
    58  
    59 static guint none_config_signals[LAST_SIGNAL+1] = 
    60 {0}; 
    61  
    6258static void 
    6359none_config_class_init(NoneConfigClass * class) 
    6460{ 
    65   GtkObjectClass *object_class; 
    6661 
    67   object_class = (GtkObjectClass *) class; 
    68  
    69   gtk_object_class_add_signals(object_class, none_config_signals, LAST_SIGNAL); 
    70   class->none_config = NULL; 
    7162} 
    7263 
    …… 
    7465none_config_init(NoneConfig * none_config) 
    7566{ 
     67 
    7668} 
    7769 
    …… 
    9890     * NULL and is ignored in the callback.  
    9991   */ 
    100   gtk_signal_connect(GTK_OBJECT(none_config), "delete_event", 
    101                      GTK_SIGNAL_FUNC(delete_event), NULL); 
     92  g_signal_connect(G_OBJECT(none_config), "delete_event", 
     93                     G_CALLBACK(delete_event), NULL); 
    10294 
    10395  /* 
    …… 
    10698     * window, or if we return "TRUE" in the "delete_event" callback.  
    10799   */ 
    108   gtk_signal_connect(GTK_OBJECT(none_config), "destroy", 
    109                      GTK_SIGNAL_FUNC(destroy), NULL); 
     100  g_signal_connect(G_OBJECT(none_config), "destroy", 
     101                     G_CALLBACK(destroy), NULL); 
    110102#endif 
    111103 

  • aube/branches/aube-gtk2/src/none_config.h

    r372 r406  
    3535  void none_config_cb(module * u); 
    3636 
    37   guint none_config_get_type(void); 
     37  GType none_config_get_type(void); 
    3838  GtkWidget *none_config_new(module * u); 
    3939 

  • aube/branches/aube-gtk2/src/opsmenu.c

    r397 r406  
    99extern bit16 zero_buffer[]; 
    1010 
    11 guint opsmenu_get_type(void); 
    12 static void opsmenu_class_init(OpsmenuClass * class); 
     11static void opsmenu_class_init(OpsmenuClass * klass); 
    1312static void opsmenu_init(Opsmenu * b); 
    1413GtkWidget *opsmenu_new(); 
    …… 
    1716void select_input_cb(GtkWidget * widget, gpointer data); 
    1817 
    19 guint 
    20 opsmenu_get_type() 
     18GType 
     19opsmenu_get_type(void) 
    2120{ 
    22   static guint b_type = 0; 
     21  static GType b_type = 0; 
    2322 
    2423  if (!b_type) { 
    25     GtkTypeInfo b_info = 
     24    static const GTypeInfo b_info = 
    2625    { 
    27       "Opsmenu", 
     26      sizeof(OpsmenuClass), 
     27      NULL, /* base_init */ 
     28          NULL, /* base_finalise */ 
     29      (GClassInitFunc) opsmenu_class_init, 
     30          NULL, /* class_finalize */ 
     31          NULL, /* class_data */ 
    2832      sizeof(Opsmenu), 
    29       sizeof(OpsmenuClass), 
    30       (GtkClassInitFunc) opsmenu_class_init, 
    31       (GtkObjectInitFunc) opsmenu_init, 
    32       (GtkArgSetFunc) NULL, 
    33       (GtkArgGetFunc) NULL, 
     33          0, /* n_preallocs */ 
     34          (GInstanceInitFunc) opsmenu_init, 
    3435    }; 
    3536 
    36     b_type = gtk_type_unique(gtk_menu_bar_get_type(), &b_info); 
     37    b_type = g_type_register_static(GTK_TYPE_MENU_BAR, 
     38                                                      "Opsmenu", 
     39                                                           &b_info, 0); 
    3740  } 
    3841  return b_type; 
    3942} 
    4043 
    41 enum { 
    42   LAST_SIGNAL 
    43 }; 
    44  
    45 static guint opsmenu_signals[LAST_SIGNAL+1] = 
    46 {0}; 
    47  
    4844static void 
    49 opsmenu_class_init(OpsmenuClass * class) 
     45opsmenu_class_init(OpsmenuClass * klass) 
    5046{ 
    51   GtkObjectClass *object_class; 
    52  
    53   object_class = (GtkObjectClass *) class; 
    54  
    55   gtk_object_class_add_signals(object_class, opsmenu_signals, LAST_SIGNAL); 
    56  
    57   class->opsmenu = NULL; 
     47  
    5848} 
    5949 
    …… 
    8373  menuitem = gtk_menu_item_new_with_label("Configure..."); 
    8474  gtk_menu_append(GTK_MENU(menu), menuitem); 
    85   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    86                      GTK_SIGNAL_FUNC(module_config_cb), module); 
     75  g_signal_connect(G_OBJECT(menuitem), "activate", 
     76                     G_CALLBACK(module_config_cb), module); 
    8777  gtk_widget_show(menuitem); 
    8878#endif 
    …… 
    9080  menuitem = gtk_menu_item_new_with_label("Hide"); 
    9181  gtk_menu_append(GTK_MENU(menu), menuitem); 
    92   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    93                      GTK_SIGNAL_FUNC(if_hide_cb), parent_if); 
     82  g_signal_connect(G_OBJECT(menuitem), "activate", 
     83                     G_CALLBACK(if_hide_cb), parent_if); 
    9484  gtk_widget_show(menuitem); 
    9585 
    9686  menuitem = gtk_menu_item_new_with_label("Clone"); 
    9787  gtk_menu_append(GTK_MENU(menu), menuitem); 
    98   gtk_signal_connect(GTK_OBJECT(menuitem), "activate", 
    99                      GTK_SIGNAL_FUNC(module_clone_cb), module); 
     88  g_signal_connect(G_OBJECT(menuitem), "activate", 
     89                     G_CALLBACK(module_clone_cb), module); 
    10090  gtk_widget_show(menuitem); 
    10191 

  • aube/branches/aube-gtk2/src/opsmenu.h

    r372 r406  
    3434  }; 
    3535 
    36   guint opsmenu_get_type(void); 
     36  GType opsmenu_get_type(void); 
    3737  GtkWidget *opsmenu_new(module * module, GtkWidget * parent_if, void *if_hide_cb, void *if_close_cb); 
    3838 

  • aube/branches/aube-gtk2/src/outputlabel.c

    r397 r406  
    1111extern bit16 zero_buffer[]; 
    1212 
    13 guint outputlabel_get_type(void); 
    14 static void outputlabel_class_init(OutputlabelClass * class); 
     13static void outputlabel_class_init(OutputlabelClass * klass); 
    1514static void outputlabel_init(Outputlabel * b); 
    1615GtkWidget *outputlabel_new(); 
    …… 
    2827#endif 
    2928 
    30 guint 
    31 outputlabel_get_type() 
    32 { 
    33   static guint b_type = 0; 
     29GType 
     30outputlabel_get_type(void) 
     31{ 
     32  static GType b_type = 0; 
    3433 
    3534  if (!b_type) { 
    36     GtkTypeInfo b_info = 
     35    static const GTypeInfo b_info = 
    3736    { 
    38       "Outputlabel", 
     37      sizeof(OutputlabelClass), 
     38      NULL, /* base_init */ 
     39          NULL, /* base_finalise */ 
     40      (GClassInitFunc) outputlabel_class_init , 
     41          NULL, /* class_finalize */ 
     42          NULL, /* class_data */ 
    3943      sizeof(Outputlabel), 
    40       sizeof(OutputlabelClass), 
    41       (GtkClassInitFunc) outputlabel_class_init, 
    42       (GtkObjectInitFunc) outputlabel_init, 
    43       (GtkArgSetFunc) NULL, 
    44       (GtkArgGetFunc) NULL, 
     44          0, /* n_preallocs */ 
     45          (GInstanceInitFunc) outputlabel_init, 
    4546    }; 
    4647 
    47     b_type = gtk_type_unique(gtk_frame_get_type(), &b_info); 
     48    b_type = g_type_register_static(GTK_TYPE_FRAME, 
     49                                                      "Outputlabel", 
     50                                                           &b_info, 0); 
    4851  } 
    4952  return b_type; 
    5053} 
    5154 
    52 enum { 
    53   LAST_SIGNAL 
    54 }; 
    55  
    56 static guint outputlabel_signals[LAST_SIGNAL+1] = 
    57 {0}; 
    58  
    5955static void 
    60 outputlabel_class_init(OutputlabelClass * class) 
    61 { 
    62   GtkObjectClass *object_class; 
    63  
    64   object_class = (GtkObjectClass *) class; 
    65   gtk_object_class_add_signals(object_class, outputlabel_signals, LAST_SIGNAL); 
    66  
    67   class->outputlabel = NULL; 
     56outputlabel_class_init(OutputlabelClass * klass) 
     57{ 
     58   
    6859} 
    6960 
    …… 
    9485                                  440, 140, 0, 0, GTK_WINDOW_POPUP); 
    9586 
    96     gtk_signal_connect(GTK_OBJECT(drag_icon), "destroy", 
    97                        GTK_SIGNAL_FUNC(gtk_widget_destroyed), 
     87    g_signal_connect(G_OBJECT(drag_icon), "destroy", 
     88                       G_CALLBACK(gtk_widget_destroyed), 
    9889                       &drag_icon); 
    9990 
    …… 
    10495                                  440, 140, 0, 0, GTK_WINDOW_POPUP); 
    10596 
    106     gtk_signal_connect(GTK_OBJECT(drop_icon), "destroy", 
    107                        GTK_SIGNAL_FUNC(gtk_widget_destroyed), 
     97    g_signal_connect(G_OBJECT(drop_icon), "destroy", 
     98                       G_CALLBACK(gtk_widget_destroyed), 
    10899                       &drop_icon); 
    109100 
    …… 
    147138#if 0 
    148139  gtk_widget_realize(widget); 
    149   gtk_signal_connect(GTK_OBJECT(widget), "drag_request_event", 
    150                      GTK_SIGNAL_FUNC(outputlabel_drag_request), widget); 
     140  g_signal_connect(G_OBJECT(widget), "drag_request_event", 
     141                     G_CALLBACK(outputlabel_drag_request), widget); 
    151142  gtk_widget_dnd_drag_set(widget, TRUE, possible_drag_types, 1); 
    152143#endif 
    153144 
    154   gtk_signal_connect(GTK_OBJECT(outputlabel), "destroy", 
    155                      GTK_SIGNAL_FUNC(outputlabel_dismiss), outputlabel); 
     145  g_signal_connect(G_OBJECT(outputlabel), "destroy", 
     146                     G_CALLBACK(outputlabel_dismiss), outputlabel); 
    156147 
    157148  return GTK_WIDGET(outputlabel); 

  • aube/branches/aube-gtk2/src/outputlabel.h

    r372 r406  
    3737  }; 
    3838 
    39   guint outputlabel_get_type(void); 
     39  GType outputlabel_get_type(void); 
    4040  GtkWidget *outputlabel_new(module * module, int output_i); 
    4141 

  • aube/branches/aube-gtk2/src/sample_if.c

    r372 r406  
    1818sample_load_ok_cb(GtkWidget * widget, gpointer data) 
    1919{ 
    20   gchar *dir; 
     20  const gchar *dir; 
    2121 
    2222  dir = gtk_file_selection_get_filename(GTK_FILE_SELECTION(data)); 
    …… 
    7070sample_save_ok_cb(GtkWidget * widget, gpointer data) 
    7171{ 
    72   gchar *dir; 
     72  const gchar *dir; 
    7373 
    7474  dir = gtk_file_selection_get_filename(GTK_FILE_SELECTION(data)); 

  • aube/branches/aube-gtk2/src/slider.c

    r397 r406  
    55 
    66 
    7 guint slider_get_type(void); 
    8 static void slider_class_init(SliderClass * class); 
     7static void slider_class_init(SliderClass * klass); 
    98static void slider_init(Slider * b); 
    109GtkWidget *slider_new(); 
    …… 
    1211void slider_cb(GtkWidget * widget, gpointer data); 
    1312 
    14 guint 
    15 slider_get_type() 
     13GType 
     14slider_get_type(void) 
    1615{ 
    17   static guint b_type = 0; 
     16  static GType b_type = 0; 
    1817 
    1918  if (!b_type) { 
    20     GtkTypeInfo b_info = 
     19    static const GTypeInfo b_info = 
    2120    { 
    22       "Slider", 
     21      sizeof(SliderClass), 
     22      NULL, /* base_init */ 
     23          NULL, /* base_finalise */ 
     24      (GClassInitFunc) slider_class_init, 
     25          NULL, /* class_finalize */ 
     26          NULL, /* class_data */ 
    2327      sizeof(Slider), 
    24       sizeof(SliderClass), 
    25       (GtkClassInitFunc) slider_class_init, 
    26       (GtkObjectInitFunc) slider_init, 
    27       (GtkArgSetFunc) NULL, 
    28       (GtkArgGetFunc) NULL, 
     28          0, /* n_preallocs */ 
     29          (GInstanceInitFunc) slider_init, 
    2930    }; 
    3031 
    31     b_type = gtk_type_unique(gtk_vbox_get_type(), &b_info); 
     32    b_type = g_type_register_static(GTK_TYPE_VBOX, 
     33                                                      "Slider", 
     34                                                           &b_info, 0); 
    3235  } 
    3336  return b_type; 
    3437} 
    3538 
    36 enum { 
    37   LAST_SIGNAL 
    38 }; 
    39  
    40 static guint slider_signals[LAST_SIGNAL+1] = 
    41 {0}; 
    42  
    4339static void 
    44 slider_class_init(SliderClass * class) 
     40slider_class_init(SliderClass * klass) 
    4541{ 
    46   GtkObjectClass *object_class; 
    47  
    48   object_class = (GtkObjectClass *) class; 
    49  
    50   gtk_object_class_add_signals(object_class, slider_signals, LAST_SIGNAL); 
    51  
    52   class->slider = NULL; 
     42   
    5343} 
    5444 
    …… 
    9282  gtk_scale_set_draw_value(GTK_SCALE(slider->scale), FALSE); 
    9383 
    94   gtk_signal_connect(GTK_OBJECT(slider->adj), "value_changed", 
    95                      GTK_SIGNAL_FUNC(slider_cb), slider); 
     84  g_signal_connect(G_OBJECT(slider->adj), "value_changed", 
     85                     G_CALLBACK(slider_cb), slider); 
    9686  gtk_widget_show(GTK_WIDGET(slider->scale)); 
    9787 

  • aube/branches/aube-gtk2/src/slider.h

    r372 r406  
    3333}; 
    3434 
    35 guint slider_get_type(void); 
     35GType slider_get_type(void); 
    3636GtkWidget *slider_new(char *label_str, int *data, int lower, int upper, 
    3737                      int vert);