Changeset 406

Show
Ignore:
Timestamp:
07/18/06 15:08:06 (2 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