From 64b836ed269133d579c76a8f88dbca572bb62220 Mon Sep 17 00:00:00 2001
From: genBTC <genBTC@gmx.com>
Date: Thu, 6 Mar 2025 18:17:57 -0500
Subject: [PATCH 1/3] echomixer.c: port from GTK2 to GTK3

---
 echomixer/configure.ac |   2 +-
 echomixer/echomixer.c  | 934 +++++++++++++++++++++++------------------
 2 files changed, 527 insertions(+), 409 deletions(-)

diff --git a/echomixer/configure.ac b/echomixer/configure.ac
index c360442..ba85660 100644
--- a/echomixer/configure.ac
+++ b/echomixer/configure.ac
@@ -5,6 +5,6 @@ AC_HEADER_STDC
 AM_INIT_AUTOMAKE
 AM_MAINTAINER_MODE([enable])
 
-PKG_CHECK_MODULES(ECHOMIXER, gtk+-2.0 alsa >= 1.0.0)
+PKG_CHECK_MODULES(ECHOMIXER, gtk+-3.0 alsa >= 1.0.0)
 
 AC_OUTPUT(Makefile desktop/Makefile)
diff --git a/echomixer/echomixer.c b/echomixer/echomixer.c
index adc10e1..564853d 100644
--- a/echomixer/echomixer.c
+++ b/echomixer/echomixer.c
@@ -87,6 +87,7 @@
 #include <ctype.h>
 #include <gtk/gtk.h>
 #include <gdk/gdk.h>
+#include <cairo.h>
 #include <alsa/asoundlib.h>
 
 
@@ -136,7 +137,7 @@ struct mixerControl_s {
   GtkWidget *window;
   GtkWidget *volume[ECHO_MAXAUDIOOUTPUTS];
   GtkWidget *label[ECHO_MAXAUDIOOUTPUTS];
-  GtkObject *adj[ECHO_MAXAUDIOOUTPUTS];
+  GtkAdjustment *adj[ECHO_MAXAUDIOOUTPUTS];
   GtkWidget *outsel[ECHO_MAXAUDIOOUTPUTS];
   GtkWidget *inpsel[ECHO_MAXAUDIOINPUTS];
   GtkWidget *vchsel[ECHO_MAXAUDIOOUTPUTS];
@@ -150,7 +151,7 @@ struct VolumeControl_s {
   GtkWidget *window;
   GtkWidget *volume[ECHO_MAXAUDIOOUTPUTS];
   GtkWidget *label[ECHO_MAXAUDIOOUTPUTS];
-  GtkObject *adj[ECHO_MAXAUDIOOUTPUTS];
+  GtkAdjustment *adj[ECHO_MAXAUDIOOUTPUTS];
   int Gain[ECHO_MAXAUDIOOUTPUTS];
 } lineinControl, lineoutControl, pcmoutControl;
 
@@ -173,10 +174,11 @@ GtkWidget *window, *Mainwindow, *Miscwindow, *LVwindow, *VUwindow, *GMwindow;
 GtkWidget *VUdarea, *Mixdarea;
 gint VUtimer, Mixtimer, clocksrctimer;
 
-GdkGC *gc=0;
-static GdkPixmap *VUpixmap = NULL;
-static GdkPixmap *Mixpixmap = NULL;
-GdkFont *fnt;
+cairo_t *cr = NULL;
+static cairo_surface_t *VUpixmap = NULL;
+static cairo_surface_t *Mixpixmap = NULL;
+PangoFontDescription *fnt = NULL;
+
 
 void Clock_source_activate(GtkWidget *widget, gpointer clk);
 
@@ -571,19 +573,20 @@ gint CheckInputs(gpointer unused) {
   if (source>=0 && source!=clocksrcVal) {
     // Set the clock source, but do not change the value of AutoClock
     Clock_source_activate(clocksrc_menuitem[source], (gpointer)(long)(source|DONT_CHANGE));
-    gtk_option_menu_set_history(GTK_OPTION_MENU(clocksrcOpt), clocksrcVal);
+	gtk_combo_box_set_active(GTK_COMBO_BOX(clocksrcOpt), clocksrcVal);
   }
   return(TRUE);
 }
 
 
-
 void DrawBar(int x, int y, int level, int peak, int gain) {
   GdkColor Bars={0x00FF00, 0, 0, 0};
   GdkColor Bars1={0x000000, 0, 0, 0};
   GdkColor Peak={0x1BABFF, 0, 0, 0};
   GdkColor Level={0xC0B000, 0, 0, 0};
   int db;
+  // Get the drawing context from the widget’s window
+  cr = gdk_cairo_create(gtk_widget_get_window(window));
 
   x=XMETER+XCELLTOT*x;
   y=YCELLTOT*y+YCELLBORDER;
@@ -591,263 +594,309 @@ void DrawBar(int x, int y, int level, int peak, int gain) {
   if (level>ECHOGAIN_MUTED) {
     // Draw the "integer" part of the bar
     db=level>>2;
-    gdk_gc_set_foreground(gc, &Bars);
-    gdk_draw_rectangle(Mixpixmap, gc, TRUE, x, y-db, GM_BARWIDTH, YCELLDIM+db);
+
+	GdkRGBA rgba_color = {
+	    .red = Bars.red / 65535.0,
+	    .green = Bars.green / 65535.0,
+	    .blue = Bars.blue / 65535.0,
+	    .alpha = 1.0 // Assuming full opacity
+	};
+	// Set the color (Bars should be a GdkRGBA)
+	gdk_cairo_set_source_rgba(cr, &rgba_color);
+	// Draw the rectangle
+	cairo_rectangle(cr, x, y - db, GM_BARWIDTH, YCELLDIM + db);
+	cairo_fill(cr); // Fill the rectangle with the set color
 
     // Draw the antialiased part
     Bars1.pixel=(level&3) << (6 + 8);	// 4 levels (256/4==64==2^6) of green (2^8)
     if (Bars1.pixel) {
-      gdk_gc_set_foreground(gc, &Bars1);
-      gdk_draw_rectangle(Mixpixmap, gc, TRUE, x, y-db-1, GM_BARWIDTH, 1);
+
+		GdkRGBA rgba_color = {
+		    .red = Bars1.red / 65535.0,
+		    .green = Bars1.green / 65535.0,
+		    .blue = Bars1.blue / 65535.0,
+		    .alpha = 1.0 // Assuming full opacity
+		};
+		// Set the color (Bars1 should be a GdkRGBA)
+		gdk_cairo_set_source_rgba(cr, &rgba_color);
+		// Draw the thin rectangle (1px height)
+		cairo_rectangle(cr, x, y - db - 1, GM_BARWIDTH, 1);
+		cairo_fill(cr);
     }
   }
 
   // Draw the peak
   if (peak>ECHOGAIN_MUTED) {
     db=peak>>2;
-    gdk_gc_set_foreground(gc, &Peak);
-    gdk_draw_rectangle(Mixpixmap, gc, TRUE, x, y-db, GM_BARWIDTH, 1);
+
+	GdkRGBA rgba_color = {
+	    .red = Peak.red / 65535.0,
+	    .green = Peak.green / 65535.0,
+	    .blue = Peak.blue / 65535.0,
+	    .alpha = 1.0 // Assuming full opacity
+	};
+	// Set the color (Peak should be a GdkRGBA)
+	gdk_cairo_set_source_rgba(cr, &rgba_color);
+
+	// Draw the peak indicator (1px height)
+	cairo_rectangle(cr, x, y - db, GM_BARWIDTH, 1);
+	cairo_fill(cr);
   }
 
   // Draw the mixer gain
   if (gain>=ECHOGAIN_MUTED) {
     db=gain>>2;
-    gdk_gc_set_foreground(gc, &Level);
-    gdk_draw_rectangle(Mixpixmap, gc, TRUE, x-XMETER+XVOLUME, y, 1, YCELLDIM);
-    gdk_draw_rectangle(Mixpixmap, gc, TRUE, x-XMETER+XVOLUME-2, y-db, 5, 1);
+
+	GdkRGBA rgba_color = {
+	    .red = Level.red / 65535.0,
+	    .green = Level.green / 65535.0,
+	    .blue = Level.blue / 65535.0,
+	    .alpha = 1.0 // Assuming full opacity
+	};
+	gdk_cairo_set_source_rgba(cr, &rgba_color);
+
+	// Draw the first rectangle (vertical line)
+	cairo_rectangle(cr, x - XMETER + XVOLUME, y, 1, YCELLDIM);
+	// Draw the second rectangle (horizontal line)
+	cairo_rectangle(cr, x - XMETER + XVOLUME - 2, y - db, 5, 1);
+	cairo_fill(cr);
   }
+  // Clean up
+  cairo_destroy(cr);
 }
 
-
-
 // Draw the matrix mixer
 gint DrawMixer(gpointer unused) {
-  GdkRectangle update_rect;
-  int InLevel[ECHO_MAXAUDIOINPUTS];
-  int InPeak[ECHO_MAXAUDIOINPUTS];
-  int OutLevel[ECHO_MAXAUDIOOUTPUTS];
-  int OutPeak[ECHO_MAXAUDIOOUTPUTS];
-  int VirLevel[ECHO_MAXAUDIOOUTPUTS];
-  int VirPeak[ECHO_MAXAUDIOOUTPUTS];
-  char str[16];
-  int i, o, dB;
-  GdkColor Grid={0x787878, 0, 0, 0};
-  GdkColor Labels={0x9694C4, 0, 0, 0};
-  GdkColor Hilight={0x000078, 0, 0, 0};
-  GdkColor Hilight2={0x600000, 0, 0, 0};
+    cairo_t *cr;
+    int InLevel[ECHO_MAXAUDIOINPUTS];
+    int InPeak[ECHO_MAXAUDIOINPUTS];
+    int OutLevel[ECHO_MAXAUDIOOUTPUTS];
+    int OutPeak[ECHO_MAXAUDIOOUTPUTS];
+    int VirLevel[ECHO_MAXAUDIOOUTPUTS];
+    int VirPeak[ECHO_MAXAUDIOOUTPUTS];
+    static int InClip[ECHO_MAXAUDIOINPUTS];
+    static int OutClip[ECHO_MAXAUDIOOUTPUTS];
+    char str[8];
+    int i, o, dB;
 
-  if (!Mixpixmap)
-    return(TRUE);
+    if (!Mixpixmap)
+        return TRUE;
 
-  update_rect.x = 0;
-  update_rect.y = 0;
-  update_rect.width = Mixwidth;
-  update_rect.height = Mixheight;
-  GetVUmeters(InLevel, InPeak, OutLevel, OutPeak, VirLevel, VirPeak);
+    GetVUmeters(InLevel, InPeak, OutLevel, OutPeak, VirLevel, VirPeak);
 
-  if (!gc)
-    gc=gdk_gc_new(gtk_widget_get_parent_window(Mixdarea));
+    GdkWindow *window = gtk_widget_get_window(Mixdarea);
+    if (!window)
+        return TRUE;
 
-  gdk_draw_rectangle(Mixpixmap, Mixdarea->style->black_gc, TRUE, 0, 0, Mixwidth, Mixheight);
+    cr = gdk_cairo_create(window);
 
-  // Highlight
-  gdk_gc_set_foreground(gc, &Hilight);
-  gdk_draw_rectangle(Mixpixmap, gc, TRUE, 0, YCELLTOT*mixerControl.input, XCELLTOT*(mixerControl.output+1), YCELLTOT);
-  gdk_draw_rectangle(Mixpixmap, gc, TRUE, XCELLTOT*(mixerControl.output+1), YCELLTOT*mixerControl.input, XCELLTOT, Mixheight);
-  if (vmixerId) {
-    gdk_gc_set_foreground(gc, &Hilight2);
-    gdk_draw_rectangle(Mixpixmap, gc, TRUE, 0, YCELLTOT*(GMixerSection.VmixerFirst+vmixerControl.input), XCELLTOT*(vmixerControl.output+1), YCELLTOT);
-    gdk_draw_rectangle(Mixpixmap, gc, TRUE, XCELLTOT*(vmixerControl.output+1), YCELLTOT*(GMixerSection.VmixerFirst+vmixerControl.input), XCELLTOT, Mixheight);
-  }
+    // Clear the background to black
+    cairo_set_source_rgb(cr, 0, 0, 0);
+    cairo_rectangle(cr, 0, 0, Mixwidth, Mixheight);
+    cairo_fill(cr);
 
-  // Draw the grid
+    // Highlight
+    cairo_set_source_rgb(cr, 0, 0, 0.47);
+    cairo_rectangle(cr, 0, YCELLTOT * mixerControl.input, Mixwidth, YCELLTOT);
+    cairo_fill(cr);
 
-  gdk_gc_set_font(gc, fnt);
-  // Horizontal lines and input channel labels
-  for (i=0; i<GMixerSection.LineOut; i++) {
-    gdk_gc_set_foreground(gc, &Grid);
-    gdk_draw_rectangle(Mixpixmap, gc, TRUE, 0, YCELLTOT*(i+1)-1, Mixwidth, 1);
-    if (i<fdIn)
-      sprintf(str, "A%d", i);		// Analog
-    else if (i<nIn)
-      sprintf(str, "D%d", i-fdIn);	// Digital
-    else
-      sprintf(str, "V%d", i-nIn);	// Virtual
-    gdk_gc_set_foreground(gc, &Labels);
-    gdk_draw_string(Mixpixmap, fnt, gc, 1, YCELLTOT*i+(YCELLTOT/2)+4, str);
-  }
-
-  // Vertical lines and output channel labels
-  for (o=0; o<nLOut; o++) {
-    gdk_gc_set_foreground(gc, &Grid);
-    gdk_draw_rectangle(Mixpixmap, gc, TRUE, XCELLTOT*(o+1), 0, 1, Mixheight);
-    if (o<fdOut)
-      sprintf(str, "A%d", o);
-    else
-      sprintf(str, "D%d", o-fdOut);
-    gdk_gc_set_foreground(gc, &Labels);
-    gdk_draw_string(Mixpixmap, fnt, gc, XCELLTOT*(o+1)+(XCELLTOT/2)-6, YCELLTOT*GMixerSection.LineOut+YCELLTOT+8, str);
-  }
-  gdk_draw_string(Mixpixmap, fnt, gc, 1, 8, "In");
-  gdk_draw_string(Mixpixmap, fnt, gc, 1, YCELLTOT*GMixerSection.LineOut+YCELLTOT+8, "Out");
-  gdk_gc_set_foreground(gc, &Grid);
-  gdk_draw_rectangle(Mixpixmap, gc, TRUE, 0, YCELLTOT*(GMixerSection.LineOut+1)-1, Mixwidth, 1);
-
-  // Draw input levels and peaks
-  for (i=0; i<GMixerSection.Inputs; i++)
-    DrawBar(0, i, InLevel[i], InPeak[i], DONT_DRAW);
-
-  // Draw vchannels levels and peaks (Vmixer cards only)
-  if (vmixerId) {
-    for (i=0; i<vmixerControl.inputs; i++)
-      DrawBar(0, i+GMixerSection.VmixerFirst, VirLevel[i], VirPeak[i], DONT_DRAW);
-  }
-
-  // Draw output levels, peaks and volumes
-  for (o=0; o<GMixerSection.Outputs; o++)
-    DrawBar(o+1, GMixerSection.LineOut, OutLevel[o], OutPeak[o], lineoutControl.Gain[o]);
-
-  // Draw monitor mixer elements
-  for (o=0; o<GMixerSection.Outputs; o++) {
-    for (i=0; i<GMixerSection.Inputs; i++) {
-      dB=Add_dB(mixerControl.mixer[o][i].Gain, InLevel[i]);
-      DrawBar(o+1, i, dB, DONT_DRAW, mixerControl.mixer[o][i].Gain);
+    if (vmixerId) {
+        cairo_set_source_rgb(cr, 0.38, 0, 0);
+        cairo_rectangle(cr, 0, YCELLTOT * (GMixerSection.VmixerFirst + vmixerControl.input), Mixwidth, YCELLTOT);
+        cairo_fill(cr);
     }
-  }
 
-  // Draw vmixer elements (Vmixer cards only)
-  if (vmixerId) {
-    for (o=0; o<GMixerSection.Outputs; o++)
-      for (i=0; i<vmixerControl.inputs; i++) {
-        dB=Add_dB(vmixerControl.mixer[o][i].Gain, VirLevel[i]);
-        DrawBar(o+1, i+GMixerSection.VmixerFirst, dB, DONT_DRAW, vmixerControl.mixer[o][i].Gain);
-      }
-  }
+    // Draw the grid and labels
+    for (i = 0; i < GMixerSection.LineOut; i++) {
+        cairo_set_source_rgb(cr, 0.47, 0.47, 0.47);
+        cairo_move_to(cr, 0, YCELLTOT * (i + 1) - 1);
+        cairo_line_to(cr, Mixwidth, YCELLTOT * (i + 1) - 1);
+        cairo_stroke(cr);
+    }
 
-  gtk_widget_draw(Mixdarea, &update_rect);
-  return(TRUE);
+    for (o = 0; o < nLOut; o++) {
+        cairo_move_to(cr, XCELLTOT * (o + 1), 0);
+        cairo_line_to(cr, XCELLTOT * (o + 1), Mixheight);
+        cairo_stroke(cr);
+    }
+
+    // Draw input levels and peaks
+    for (i = 0; i < GMixerSection.Inputs; i++)
+        DrawBar(0, i, InLevel[i], InPeak[i], DONT_DRAW);
+
+    if (vmixerId) {
+        for (i = 0; i < vmixerControl.inputs; i++)
+            DrawBar(0, i + GMixerSection.VmixerFirst, VirLevel[i], VirPeak[i], DONT_DRAW);
+    }
+
+    for (o = 0; o < GMixerSection.Outputs; o++)
+        DrawBar(o + 1, GMixerSection.LineOut, OutLevel[o], OutPeak[o], lineoutControl.Gain[o]);
+
+    for (o = 0; o < GMixerSection.Outputs; o++) {
+        for (i = 0; i < GMixerSection.Inputs; i++) {
+            dB = Add_dB(mixerControl.mixer[o][i].Gain, InLevel[i]);
+            DrawBar(o + 1, i, dB, DONT_DRAW, mixerControl.mixer[o][i].Gain);
+        }
+    }
+
+    if (vmixerId) {
+        for (o = 0; o < GMixerSection.Outputs; o++)
+            for (i = 0; i < vmixerControl.inputs; i++) {
+                dB = Add_dB(vmixerControl.mixer[o][i].Gain, VirLevel[i]);
+                DrawBar(o + 1, i + GMixerSection.VmixerFirst, dB, DONT_DRAW, vmixerControl.mixer[o][i].Gain);
+            }
+    }
+
+    cairo_destroy(cr);
+    return TRUE;
 }
 
-
-
 // Draw the VU-meter
 gint DrawVUmeters(gpointer unused) {
-  GdkRectangle update_rect;
-  int InLevel[ECHO_MAXAUDIOINPUTS];
-  int InPeak[ECHO_MAXAUDIOINPUTS];
-  int OutLevel[ECHO_MAXAUDIOOUTPUTS];
-  int OutPeak[ECHO_MAXAUDIOOUTPUTS];
-  int VirLevel[ECHO_MAXAUDIOOUTPUTS];
-  int VirPeak[ECHO_MAXAUDIOOUTPUTS];
-  static int InClip[ECHO_MAXAUDIOINPUTS];
-  static int OutClip[ECHO_MAXAUDIOOUTPUTS];
-  int i, x, dB;
-  char str[16];
-  GdkColor Selected={0xC86060, 0, 0, 0};
-  GdkColor Grid={0x9694C4, 0, 0, 0};
-  GdkColor Grid2={0x646383, 0, 0, 0};
-  GdkColor dBValues={0x00B000, 0, 0, 0};
-  GdkColor AnBars={0x00E0B8, 0, 0, 0};
-  GdkColor DiBars={0x98E000, 0, 0, 0};
-  GdkColor ClipPeak={0, 0, 0, 0};
-  GdkColor Peak={0x00FF00, 0, 0, 0};
+    GdkRectangle update_rect;
+    int InLevel[ECHO_MAXAUDIOINPUTS];
+    int InPeak[ECHO_MAXAUDIOINPUTS];
+    int OutLevel[ECHO_MAXAUDIOOUTPUTS];
+    int OutPeak[ECHO_MAXAUDIOOUTPUTS];
+    int VirLevel[ECHO_MAXAUDIOOUTPUTS];
+    int VirPeak[ECHO_MAXAUDIOOUTPUTS];
+    static int InClip[ECHO_MAXAUDIOINPUTS];
+    static int OutClip[ECHO_MAXAUDIOOUTPUTS];
+    int i, x, dB;
+    char str[16];
+    GdkRGBA Selected = {0xC8 / 255.0, 0, 0, 1};
+    GdkRGBA Grid = {0x96 / 255.0, 0x94 / 255.0, 0xC4 / 255.0, 1};
+    GdkRGBA Grid2 = {0x64 / 255.0, 0x63 / 255.0, 0x83 / 255.0, 1};
+    GdkRGBA dBValues = {0, 0.69, 0, 1};
+    GdkRGBA AnBars = {0, 0.88, 0.72, 1};
+    GdkRGBA DiBars = {0.60, 0.88, 0, 1};
+    GdkRGBA ClipPeak = {0, 0, 0, 0};
+    GdkRGBA Peak = {0, 1, 0, 1};
 
-  if (!VUpixmap)
-    return(TRUE);
+    if (!VUpixmap)
+        return TRUE;
 
-  update_rect.x = 0;
-  update_rect.y = 0;
-  update_rect.width = VUwidth;
-  update_rect.height = VUheight;
-  GetVUmeters(InLevel, InPeak, OutLevel, OutPeak, VirLevel, VirPeak);
+    update_rect.x = 0;
+    update_rect.y = 0;
+    update_rect.width = VUwidth;
+    update_rect.height = VUheight;
+    GetVUmeters(InLevel, InPeak, OutLevel, OutPeak, VirLevel, VirPeak);
 
-  if (!gc) {
-    gc=gdk_gc_new(gtk_widget_get_parent_window(VUdarea));
-    for (i=0; i<nIn; i++)
-      InClip[i]=0;
-    for (i=0; i<nLOut; i++)
-      OutClip[i]=0;
-  }
-
-  // Clear the image
-  gdk_draw_rectangle(VUpixmap, VUdarea->style->black_gc, TRUE, 0, 0, VUwidth, VUheight);
-
-  // Draw the dB scale and the grid
-  gdk_gc_set_font(gc, fnt);
-  gdk_gc_set_foreground(gc, &Peak);
-  gdk_draw_string(VUpixmap, fnt, gc, 2, VU_YGRAF-12+4, "  dB");
-  for (i=0; i<=120; i+=12) {
-    sprintf(str, "%4d", -i);
-    gdk_gc_set_foreground(gc, &dBValues);
-    gdk_draw_string(VUpixmap, fnt, gc, 2, VU_YGRAF+i+4, str);
-    gdk_gc_set_foreground(gc, &Grid);
-    gdk_draw_rectangle(VUpixmap, gc, TRUE, VU_XGRAF, VU_YGRAF+i, VUwidth-VU_XGRAF, 1);
-  }
-  gdk_gc_set_foreground(gc, &Grid2);
-  gdk_draw_rectangle(VUpixmap, gc, TRUE, VU_XGRAF, VU_YGRAF+128, VUwidth-VU_XGRAF, 1);
-
-  x=VU_XGRAF+VU_BARSEP;
-
-  // Draw inputs
-  for (i=0; i<nIn; i++) {
-    if (i<fdIn)
-      gdk_gc_set_foreground(gc, &AnBars);
-    else
-      gdk_gc_set_foreground(gc, &DiBars);
-    dB=InLevel[i];
-    gdk_draw_rectangle(VUpixmap, gc, TRUE, x, VU_YGRAF-dB, VU_BARWIDTH, 129+VU_YGRAF-(VU_YGRAF-dB));
-
-    dB=InPeak[i];
-    if (dB==0)
-      InClip[i]=64;
-    if (InClip[i]) {
-      InClip[i]--;
-      ClipPeak.pixel=(InClip[i]<<18)+((255-(InClip[i]*3))<<8);
-      gdk_gc_set_foreground(gc, &ClipPeak);
-    } else {
-      gdk_gc_set_foreground(gc, &Peak);
+    if (!cr) { // Cairo context
+        cr = gdk_cairo_create(gtk_widget_get_window(VUdarea));
+        for (i = 0; i < nIn; i++)
+            InClip[i] = 0;
+        for (i = 0; i < nLOut; i++)
+            OutClip[i] = 0;
     }
-    gdk_draw_rectangle(VUpixmap, gc, TRUE, x, VU_YGRAF-dB, VU_BARWIDTH, 1);
-    if (mixerControl.input==i) {
-      gdk_gc_set_foreground(gc, &Selected);
-      gdk_draw_rectangle(VUpixmap, gc, TRUE, x+1, VU_YGRAF+128+3, VU_BARWIDTH-2, 1);
-      gdk_draw_rectangle(VUpixmap, gc, TRUE, x, VU_YGRAF+128+4, VU_BARWIDTH, 1);
+
+    // Clear the image
+    cairo_set_source_rgba(cr, 0, 0, 0, 1);
+    cairo_paint(cr);
+
+    // Draw the dB scale and the grid
+    PangoLayout *layout = gtk_widget_create_pango_layout(VUdarea, NULL);
+    pango_layout_set_font_description(layout, fnt);
+
+    cairo_set_source_rgba(cr, Peak.red, Peak.green, Peak.blue, 1);
+    cairo_move_to(cr, 2, VU_YGRAF - 12 + 4);
+    cairo_show_text(cr, "  dB");
+
+    for (i = 0; i <= 120; i += 12) {
+        sprintf(str, "%4d", -i);
+        cairo_set_source_rgba(cr, dBValues.red, dBValues.green, dBValues.blue, 1);
+        cairo_move_to(cr, 2, VU_YGRAF + i + 4);
+        cairo_show_text(cr, str);
+        cairo_set_source_rgba(cr, Grid.red, Grid.green, Grid.blue, 1);
+        cairo_rectangle(cr, VU_XGRAF, VU_YGRAF + i, VUwidth - VU_XGRAF, 1);
+        cairo_fill(cr);
     }
-    x+=VU_BARWIDTH+VU_BARSEP;
-  }
 
-  // Draw outputs
-  x+=VU_BARWIDTH+VU_BARSEP;
-  for (i=0; i<nLOut; i++) {
-    if (i<fdOut)
-      gdk_gc_set_foreground(gc, &AnBars);
-    else
-      gdk_gc_set_foreground(gc, &DiBars);
-    dB=OutLevel[i];
-    gdk_draw_rectangle(VUpixmap, gc, TRUE, x, VU_YGRAF-dB, VU_BARWIDTH, 129+VU_YGRAF-(VU_YGRAF-dB));
+    cairo_set_source_rgba(cr, Grid2.red, Grid2.green, Grid2.blue, 1);
+    cairo_rectangle(cr, VU_XGRAF, VU_YGRAF + 128, VUwidth - VU_XGRAF, 1);
+    cairo_fill(cr);
 
-    dB=OutPeak[i];
-    if (dB==0)
-      OutClip[i]=64;
-    if (OutClip[i]) {
-      OutClip[i]--;
-      ClipPeak.pixel=(OutClip[i]<<18)+((255-(OutClip[i]*3))<<8);
-      gdk_gc_set_foreground(gc, &ClipPeak);
-    } else {
-      gdk_gc_set_foreground(gc, &Peak);
+    x = VU_XGRAF + VU_BARSEP;
+
+    // Draw inputs
+    for (i = 0; i < nIn; i++) {
+        if (i < fdIn)
+            cairo_set_source_rgba(cr, AnBars.red, AnBars.green, AnBars.blue, 1);
+        else
+            cairo_set_source_rgba(cr, DiBars.red, DiBars.green, DiBars.blue, 1);
+
+        dB = InLevel[i];
+        cairo_rectangle(cr, x, VU_YGRAF - dB, VU_BARWIDTH, 129 + VU_YGRAF - (VU_YGRAF - dB));
+        cairo_fill(cr);
+
+        dB = InPeak[i];
+        if (dB == 0)
+            InClip[i] = 64;
+        if (InClip[i]) {
+            InClip[i]--;
+            ClipPeak.red = (InClip[i] << 18) / 255.0;
+            ClipPeak.green = (255 - (InClip[i] * 3)) / 255.0;
+            cairo_set_source_rgba(cr, ClipPeak.red, ClipPeak.green, ClipPeak.blue, 1);
+        } else {
+            cairo_set_source_rgba(cr, Peak.red, Peak.green, Peak.blue, 1);
+        }
+
+        cairo_rectangle(cr, x, VU_YGRAF - dB, VU_BARWIDTH, 1);
+        cairo_fill(cr);
+
+        if (mixerControl.input == i) {
+            cairo_set_source_rgba(cr, Selected.red, Selected.green, Selected.blue, 1);
+            cairo_rectangle(cr, x + 1, VU_YGRAF + 128 + 3, VU_BARWIDTH - 2, 1);
+            cairo_fill(cr);
+            cairo_rectangle(cr, x, VU_YGRAF + 128 + 4, VU_BARWIDTH, 1);
+            cairo_fill(cr);
+        }
+
+        x += VU_BARWIDTH + VU_BARSEP;
     }
-    gdk_draw_rectangle(VUpixmap, gc, TRUE, x, VU_YGRAF-dB, VU_BARWIDTH, 1);
-    if (mixerControl.output==i) {
-      gdk_gc_set_foreground(gc, &Selected);
-      gdk_draw_rectangle(VUpixmap, gc, TRUE, x+1, VU_YGRAF+128+3, VU_BARWIDTH-2, 1);
-      gdk_draw_rectangle(VUpixmap, gc, TRUE, x, VU_YGRAF+128+4, VU_BARWIDTH, 1);
+
+    // Draw outputs
+    x += VU_BARWIDTH + VU_BARSEP;
+    for (i = 0; i < nLOut; i++) {
+        if (i < fdOut)
+            cairo_set_source_rgba(cr, AnBars.red, AnBars.green, AnBars.blue, 1);
+        else
+            cairo_set_source_rgba(cr, DiBars.red, DiBars.green, DiBars.blue, 1);
+
+        dB = OutLevel[i];
+        cairo_rectangle(cr, x, VU_YGRAF - dB, VU_BARWIDTH, 129 + VU_YGRAF - (VU_YGRAF - dB));
+        cairo_fill(cr);
+
+        dB = OutPeak[i];
+        if (dB == 0)
+            OutClip[i] = 64;
+        if (OutClip[i]) {
+            OutClip[i]--;
+            ClipPeak.red = (OutClip[i] << 18) / 255.0;
+            ClipPeak.green = (255 - (OutClip[i] * 3)) / 255.0;
+            cairo_set_source_rgba(cr, ClipPeak.red, ClipPeak.green, ClipPeak.blue, 1);
+        } else {
+            cairo_set_source_rgba(cr, Peak.red, Peak.green, Peak.blue, 1);
+        }
+
+        cairo_rectangle(cr, x, VU_YGRAF - dB, VU_BARWIDTH, 1);
+        cairo_fill(cr);
+
+        if (mixerControl.output == i) {
+            cairo_set_source_rgba(cr, Selected.red, Selected.green, Selected.blue, 1);
+            cairo_rectangle(cr, x + 1, VU_YGRAF + 128 + 3, VU_BARWIDTH - 2, 1);
+            cairo_fill(cr);
+            cairo_rectangle(cr, x, VU_YGRAF + 128 + 4, VU_BARWIDTH, 1);
+            cairo_fill(cr);
+        }
+
+        x += VU_BARWIDTH + VU_BARSEP;
     }
-    x+=VU_BARWIDTH+VU_BARSEP;
-  }
 
-  gtk_widget_draw(VUdarea, &update_rect);
+    // Update the widget
+    gtk_widget_queue_draw_area(VUdarea, update_rect.x, update_rect.y, update_rect.width, update_rect.height);
 
-  return(TRUE);
+    return TRUE;
 }
 
 
@@ -1040,7 +1089,7 @@ void Monitor_volume_changed(GtkWidget *widget, gpointer cnl) {
   char str[16];
 
   UI_DEBUG(("Monitor_volume_changed()  %d %d\n",mixerControl.input,mixerControl.output));
-  val=rval=INVERT((int)GTK_ADJUSTMENT(widget)->value);
+  val = rval = INVERT((int)gtk_adjustment_get_value(GTK_ADJUSTMENT(widget)));
 
   ch=(int)(long)cnl;
 
@@ -1103,13 +1152,13 @@ void PCM_volume_changed(GtkWidget *widget, gpointer ch) {
     // Input
     channel=(int)(long)ch;
     vol=&lineinControl;
-    rval=val=IN_INVERT((int)GTK_ADJUSTMENT(widget)->value);
+	rval = val = IN_INVERT((int)gtk_adjustment_get_value(GTK_ADJUSTMENT(widget)));
     sprintf(str, "%+4.1f", 0.5*val);
   } else {
     // Output
     channel=(int)(long)ch-ECHO_MAXAUDIOINPUTS;
     vol=&pcmoutControl;
-    val=rval=INVERT((int)GTK_ADJUSTMENT(widget)->value);
+	val = rval = INVERT((int)gtk_adjustment_get_value(GTK_ADJUSTMENT(widget)));
     pcmoutControl.Gain[channel]=val;
     // Emulate the line-out volume if this card can't do it in hw.
     if (!lineoutId) {
@@ -1137,7 +1186,7 @@ void PCM_volume_changed(GtkWidget *widget, gpointer ch) {
     vol->Gain[channel]=val;
   }
   if (Gang)
-    gtk_adjustment_set_value(GTK_ADJUSTMENT(vol->adj[channel^1]), (gfloat)GTK_ADJUSTMENT(widget)->value);
+	gtk_adjustment_set_value(vol->adj[channel^1], (gfloat)gtk_adjustment_get_value(GTK_ADJUSTMENT(widget)));
 }
 
 
@@ -1219,7 +1268,8 @@ void LineOut_volume_changed(GtkWidget *widget, gpointer ch) {
 
   channel=(int)(long)ch;
 
-  val=INVERT((int)GTK_ADJUSTMENT(widget)->value);
+  val = INVERT((int)gtk_adjustment_get_value(GTK_ADJUSTMENT(widget)));
+
   lineoutControl.Gain[channel]=val;
 
   gtk_label_set_text(GTK_LABEL(lineoutControl.label[channel]), strOutGain(str, val));
@@ -1248,7 +1298,7 @@ void LineOut_volume_changed(GtkWidget *widget, gpointer ch) {
   }
 
   if (Gang)
-    gtk_adjustment_set_value(GTK_ADJUSTMENT(lineoutControl.adj[channel^1]), (gfloat)GTK_ADJUSTMENT(widget)->value);
+	gtk_adjustment_set_value(lineoutControl.adj[channel^1], (gfloat)gtk_adjustment_get_value(GTK_ADJUSTMENT(widget)));
 }
 
 
@@ -1259,7 +1309,7 @@ void Vmixer_volume_changed(GtkWidget *widget, gpointer ch) {
   int o, v;
 
   channel=(int)(long)ch;
-  val=rval=INVERT((int)GTK_ADJUSTMENT(widget)->value);
+  val = rval = INVERT((int)gtk_adjustment_get_value(GTK_ADJUSTMENT(widget)));
 
 #ifdef REVERSE
   v=channel;
@@ -1282,7 +1332,7 @@ void Vmixer_volume_changed(GtkWidget *widget, gpointer ch) {
     SetMixerGain(&vmixerControl.mixer[o^1][v^1], rval);
     vmixerControl.mixer[o^1][v^1].Gain=val;
   }
-  
+
   gtk_label_set_text(GTK_LABEL(vmixerControl.label[channel]), strOutGain(str, val));
 }
 
@@ -1318,7 +1368,7 @@ void Vmixer_output_selector_clicked(GtkWidget *widget, gpointer ch) {
   snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
   for (c=vmixerControl.inputs-1; c>=0; c--) {
     val=INVERT(vmixerControl.mixer[vmixerControl.output][c].Gain);
-    gtk_adjustment_set_value(GTK_ADJUSTMENT(vmixerControl.adj[c]), (gfloat)val);
+    gtk_adjustment_set_value(vmixerControl.adj[c], (gfloat)val);
   }
 }
 
@@ -1339,7 +1389,7 @@ void Vmixer_vchannel_selector_clicked(GtkWidget *widget, gpointer ch) {
   snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
   for (c=vmixerControl.outputs-1; c>=0; c--) {
     val=INVERT(vmixerControl.mixer[c][vmixerControl.input].Gain);
-    gtk_adjustment_set_value(GTK_ADJUSTMENT(vmixerControl.adj[c]), (gfloat)val);
+    gtk_adjustment_set_value(vmixerControl.adj[c], (gfloat)val);
   }
 }
 
@@ -1399,37 +1449,34 @@ void Switch_toggled(GtkWidget *widget, gpointer Ctl) {
 }
 
 
-
 void AutoClock_toggled(GtkWidget *widget, gpointer unused) {
   char str[32];
 
   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) {
-    AutoClock=clocksrcVal;
-    snprintf(str, 31, "Autoclock [%s]", clocksrcName[AutoClock]);
-    str[31]=0;
-    gtk_label_set_text(GTK_LABEL(GTK_BIN(widget)->child), str);
+    AutoClock = clocksrcVal;
+    snprintf(str, sizeof(str), "Autoclock [%s]", clocksrcName[AutoClock]);
+    str[sizeof(str)-1] = '\0';  // Ensure null termination
+    gtk_label_set_text(GTK_LABEL(gtk_bin_get_child(GTK_BIN(widget))), str);
   } else {
-    AutoClock=-1;
-    gtk_label_set_text(GTK_LABEL(GTK_BIN(widget)->child), "Autoclock");
+    AutoClock = -1;
+    gtk_label_set_text(GTK_LABEL(gtk_bin_get_child(GTK_BIN(widget))), "Autoclock");
   }
-
 }
 
 
-
 void Digital_mode_activate(GtkWidget *widget, gpointer mode) {
   int adat;
 
   if (SetEnum(dmodeId, (int)(long)mode)<0) {
     // Restore old value if it failed
-    gtk_option_menu_set_history(GTK_OPTION_MENU(dmodeOpt), dmodeVal);
+	gtk_combo_box_set_active(GTK_COMBO_BOX(dmodeOpt), dmodeVal);
     return;
   }
 
   dmodeVal=(int)(long)mode;
   // When I change the digital mode, the clock source can change too
   clocksrcVal=GetEnum(clocksrcId);
-  gtk_option_menu_set_history(GTK_OPTION_MENU(clocksrcOpt), clocksrcVal);
+  gtk_combo_box_set_active(GTK_COMBO_BOX(clocksrcOpt), clocksrcVal);
 
   adat=!memcmp(dmodeName[dmodeVal], "ADAT", 4);
   SetSensitivity(adat);
@@ -1449,7 +1496,7 @@ void Clock_source_activate(GtkWidget *widget, gpointer clk) {
 
   source=(unsigned int)(long)clk & 0xff;
   if (SetEnum(clocksrcId, source)<0) {
-    gtk_option_menu_set_history(GTK_OPTION_MENU(clocksrcOpt), clocksrcVal);
+    gtk_combo_box_set_active(GTK_COMBO_BOX(clocksrcOpt), clocksrcVal);
   } else {
     clocksrcVal=(int)(long)clk & 0xff;
     // Change only when the user triggers it
@@ -1472,61 +1519,120 @@ void SPDIF_mode_activate(GtkWidget *widget, gpointer mode) {
 
 // Create a new backing pixmap of the appropriate size
 static gint VU_configure_event(GtkWidget *widget, GdkEventConfigure *event) {
+    // Release the previous surface if it exists
+    if (VUpixmap)
+        cairo_surface_destroy(VUpixmap); // Destroy the Cairo surface
 
-  if (VUpixmap)
-    gdk_pixmap_unref(VUpixmap);
-  VUpixmap=gdk_pixmap_new(widget->window, widget->allocation.width, widget->allocation.height, -1);
-  gdk_draw_rectangle(VUpixmap, widget->style->black_gc, TRUE, 0, 0, widget->allocation.width, widget->allocation.height);
-  return(TRUE);
+    // Create a Cairo context for drawing
+    cairo_t *cr = cairo_create(VUpixmap);
+
+    // Set a background color (black in this case)
+    cairo_set_source_rgb(cr, 0, 0, 0); // Black color
+    // Get the widget's allocation (position and size)
+    GtkAllocation allocation;
+    gtk_widget_get_allocation(widget, &allocation);
+    // Create a new Cairo surface for the widget
+    cairo_set_source_surface(
+		cr,
+		VUpixmap,
+        allocation.width,                        // Width of the widget
+        allocation.height                       // Height of the widget
+    );
+
+    cairo_paint(cr); // Fill the surface with the black color
+
+    // Clean up the Cairo context
+    cairo_destroy(cr);
+
+    return TRUE;
 }
 
 
 
-// Redraw the screen from the backing pixmap
+// Redraw the screen from the backing surface (pixmap equivalent)
 static gint VU_expose(GtkWidget *widget, GdkEventExpose *event) {
+    GdkWindow *window = gtk_widget_get_window(widget);
 
-  if (VUpixmap)
-    gdk_draw_pixmap(widget->window, widget->style->fg_gc[GTK_WIDGET_STATE(widget)], VUpixmap,
-                    event->area.x, event->area.y,
-                    event->area.x, event->area.y,
-                    event->area.width, event->area.height);
-  return(FALSE);
+    if (VUpixmap) {
+        // Create a cairo context for the widget's window
+        cr = cairo_create(VUpixmap);
+
+        // Set the source surface to VUpixmap (this is the backing surface)
+        cairo_set_source_surface(cr, VUpixmap, event->area.x, event->area.y);
+
+        // Paint the surface onto the widget's window
+        cairo_paint(cr);
+
+        // Clean up the cairo context
+        cairo_destroy(cr);
+    }
+
+    return FALSE;
 }
 
 
-
-// Create a new backing pixmap of the appropriate size
+// Create a new backing surface of the appropriate size
 static gint Gmixer_configure_event(GtkWidget *widget, GdkEventConfigure *event) {
+    // Release the previous surface if it exists
+    if (Mixpixmap)
+        cairo_surface_destroy(Mixpixmap); // Destroy the Cairo surface
 
-  if (Mixpixmap)
-    gdk_pixmap_unref(Mixpixmap);
-  Mixpixmap=gdk_pixmap_new(widget->window, widget->allocation.width, widget->allocation.height, -1);
-  gdk_draw_rectangle(Mixpixmap, widget->style->black_gc, TRUE, 0, 0, widget->allocation.width, widget->allocation.height);
-  return(TRUE);
+    // Create a Cairo context for drawing
+    cairo_t *cr = cairo_create(Mixpixmap);
+
+    // Set a background color (black in this case)
+    cairo_set_source_rgb(cr, 0, 0, 0); // Black color
+    // Get the widget's allocation (position and size)
+    GtkAllocation allocation;
+    gtk_widget_get_allocation(widget, &allocation);
+    // Create a new Cairo surface for the widget
+    cairo_set_source_surface(
+		cr,
+		Mixpixmap,
+        allocation.width,                        // Width of the widget
+        allocation.height                       // Height of the widget
+    );
+
+    cairo_paint(cr); // Fill the surface with the black color
+
+    // Clean up the Cairo context
+    cairo_destroy(cr);
+
+    return TRUE;
 }
 
 
-
-// Redraw the screen from the backing pixmap
+// Redraw the screen from the backing surface (cairo equivalent to pixmap)
 static gint Gmixer_expose(GtkWidget *widget, GdkEventExpose *event) {
+    GdkWindow *window = gtk_widget_get_window(widget);
 
-  if (Mixpixmap)
-    gdk_draw_pixmap(widget->window, widget->style->fg_gc[GTK_WIDGET_STATE(widget)], Mixpixmap,
-                    event->area.x, event->area.y,
-                    event->area.x, event->area.y,
-                    event->area.width, event->area.height);
-  return(FALSE);
+    if (Mixpixmap) {
+        // Create a cairo context for the widget's window
+        cr = cairo_create(Mixpixmap);
+
+        // Set the source surface to Mixpixmap (this is the backing surface)
+        cairo_set_source_surface(cr, Mixpixmap, event->area.x, event->area.y);
+
+        // Paint the surface onto the widget's window
+        cairo_paint(cr);
+
+        // Clean up the cairo context
+        cairo_destroy(cr);
+    }
+
+    return FALSE;
 }
 
 
 
+
 gint CloseWindow(GtkWidget *widget, GdkEvent *event, gpointer geom) {
   struct geometry *g=geom;
 
-  gdk_window_get_root_origin(widget->window, &g->x, &g->y);
-  gdk_window_get_size(widget->window, &g->w, &g->h);
+  gdk_window_get_root_origin(gtk_widget_get_window(widget), &g->x, &g->y);
+  gtk_window_get_size(GTK_WINDOW(widget), &g->w, &g->h);
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->toggler), FALSE);	// This hides the window
-  //gtk_widget_set_uposition(widget, g->x, g->y);
+  gtk_window_move(GTK_WINDOW(widget), g->x, g->y);
   return(TRUE);		// Do not destroy it
 }
 
@@ -1536,14 +1642,14 @@ gint Mainwindow_delete(GtkWidget *widget, GdkEvent *event, gpointer geom) {
   struct geometry *g=geom;
 
   if (VUwindow) {
-    gdk_window_get_root_origin(VUwindow->window, &VUw_geom.x, &VUw_geom.y);
+    gdk_window_get_root_origin(gtk_widget_get_window(VUwindow), &VUw_geom.x, &VUw_geom.y);
     gtk_widget_destroy(VUwindow);
   }
   if (GMwindow) {
-    gdk_window_get_root_origin(GMwindow->window, &GMw_geom.x, &GMw_geom.y);
+    gdk_window_get_root_origin(gtk_widget_get_window(GMwindow), &GMw_geom.x, &GMw_geom.y);
     gtk_widget_destroy(GMwindow);
   }
-  gdk_window_get_root_origin(Mainwindow->window, &g->x, &g->y);
+  gdk_window_get_root_origin(gtk_widget_get_window(Mainwindow), &g->x, &g->y);
   gtk_main_quit();
   return(FALSE);
 }
@@ -1553,7 +1659,7 @@ gint Mainwindow_delete(GtkWidget *widget, GdkEvent *event, gpointer geom) {
 gint VUwindow_delete(GtkWidget *widget, GdkEvent *event, gpointer geom) {
   struct geometry *g=geom;
 
-  gdk_window_get_root_origin(widget->window, &g->x, &g->y);
+  gdk_window_get_root_origin(gtk_widget_get_window(widget), &g->x, &g->y);
   g->st=0;
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->toggler), FALSE);
   return(FALSE);
@@ -1564,7 +1670,7 @@ gint VUwindow_delete(GtkWidget *widget, GdkEvent *event, gpointer geom) {
 gint VUwindow_destroy(GtkWidget *widget, gpointer unused) {
 
   SetVUmeters(0);
-  gtk_timeout_remove(VUtimer);
+  g_source_remove(VUtimer);
   //@@@del gc and fnt
   VUwindow=0;
   return(TRUE);
@@ -1575,7 +1681,7 @@ gint VUwindow_destroy(GtkWidget *widget, gpointer unused) {
 gint GMwindow_delete(GtkWidget *widget, GdkEvent *event, gpointer geom) {
   struct geometry *g=geom;
 
-  gdk_window_get_root_origin(widget->window, &g->x, &g->y);
+  gdk_window_get_root_origin(gtk_widget_get_window(widget), &g->x, &g->y);
   g->st=0;
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->toggler), FALSE);
   return(FALSE);
@@ -1586,7 +1692,7 @@ gint GMwindow_delete(GtkWidget *widget, GdkEvent *event, gpointer geom) {
 gint GMwindow_destroy(GtkWidget *widget, gpointer unused) {
 
   SetVUmeters(0);
-  gtk_timeout_remove(Mixtimer);
+  g_source_remove(Mixtimer);
   //@@@del gc and fnt
   GMwindow=0;
   return(TRUE);
@@ -1609,23 +1715,24 @@ void VUmeters_button_click(GtkWidget *widget, gpointer unused) {
     sprintf(str, "%s VU-meters", cardId);
     gtk_window_set_title (GTK_WINDOW (VUwindow), str);
     gtk_window_set_wmclass(GTK_WINDOW(VUwindow), "vumeters", "Emixer");
-    gtk_signal_connect(GTK_OBJECT(VUwindow), "destroy", GTK_SIGNAL_FUNC(VUwindow_destroy), NULL);
-    gtk_signal_connect(GTK_OBJECT(VUwindow), "delete_event", GTK_SIGNAL_FUNC(VUwindow_delete), (gpointer)&VUw_geom);
-    gtk_window_set_policy(GTK_WINDOW(VUwindow), FALSE, FALSE, TRUE);
+    g_signal_connect(VUwindow, "destroy", G_CALLBACK(VUwindow_destroy), NULL);
+    g_signal_connect(VUwindow, "delete_event", G_CALLBACK(VUwindow_delete), (gpointer)&VUw_geom);
+	gtk_window_set_resizable(GTK_WINDOW(VUwindow), FALSE);  // Disable window resizing
+
     if (VUw_geom.st!=NOPOS)
-      gtk_widget_set_uposition(VUwindow, VUw_geom.x, VUw_geom.y);
+      gtk_window_move(GTK_WINDOW(VUwindow), VUw_geom.x, VUw_geom.y);
     gtk_widget_show(VUwindow);
 
     VUdarea=gtk_drawing_area_new();
     gtk_widget_set_events(VUdarea, GDK_EXPOSURE_MASK);
-    gtk_drawing_area_size(GTK_DRAWING_AREA(VUdarea), VUwidth, VUheight);
+    gtk_widget_set_size_request(GTK_WIDGET(VUdarea), VUwidth, VUheight);
     gtk_container_add(GTK_CONTAINER(VUwindow), VUdarea);
 
     gtk_widget_show(VUdarea);
-    gtk_signal_connect(GTK_OBJECT(VUdarea), "expose_event", (GtkSignalFunc)VU_expose, NULL);
-    gtk_signal_connect(GTK_OBJECT(VUdarea), "configure_event", (GtkSignalFunc)VU_configure_event, NULL);
-    VUtimer=gtk_timeout_add(30, DrawVUmeters, 0);	// The hw updates the meters about 30 times/s
-    gdk_window_clear_area(VUdarea->window, 0, 0, VUwidth, VUheight);
+    g_signal_connect(VUdarea, "expose_event", G_CALLBACK(VU_expose), NULL);
+    g_signal_connect(VUdarea, "configure_event", G_CALLBACK(VU_configure_event), NULL);
+    VUtimer=g_timeout_add(30, DrawVUmeters, 0);	// The hw updates the meters about 30 times/s
+    gtk_widget_queue_draw(GTK_WIDGET(VUdarea));
     VUw_geom.st=1;
   }
 }
@@ -1647,26 +1754,26 @@ void GMixer_button_click(GtkWidget *widget, gpointer unused) {
     sprintf(str, "%s Mixer", cardId);
     gtk_window_set_title (GTK_WINDOW (GMwindow), str);
     gtk_window_set_wmclass(GTK_WINDOW(GMwindow), "gridmixer", "Emixer");
-    gtk_signal_connect(GTK_OBJECT(GMwindow), "destroy", GTK_SIGNAL_FUNC(GMwindow_destroy), NULL);
-    gtk_signal_connect(GTK_OBJECT(GMwindow), "delete_event", GTK_SIGNAL_FUNC(GMwindow_delete), (gpointer)&GMw_geom);
-    gtk_window_set_policy(GTK_WINDOW(GMwindow), FALSE, FALSE, TRUE);
+    g_signal_connect(GMwindow, "destroy", G_CALLBACK(GMwindow_destroy), NULL);
+    g_signal_connect(GMwindow, "delete_event", G_CALLBACK(GMwindow_delete), (gpointer)&GMw_geom);
+    gtk_window_set_resizable(GTK_WINDOW(GMwindow), FALSE);  // Disable window resizing
     if (GMw_geom.st!=NOPOS)
-      gtk_widget_set_uposition(GMwindow, GMw_geom.x, GMw_geom.y);
+        gtk_window_move(GTK_WINDOW(GMwindow), GMw_geom.x, GMw_geom.y);
     gtk_widget_show(GMwindow);
 
     Mixdarea=gtk_drawing_area_new();
     gtk_widget_set_events(Mixdarea, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
-    gtk_drawing_area_size(GTK_DRAWING_AREA(Mixdarea), Mixwidth, Mixheight);
+    gtk_widget_set_size_request(GTK_WIDGET(Mixdarea), Mixwidth, Mixheight);
     gtk_container_add(GTK_CONTAINER(GMwindow), Mixdarea);
 
     gtk_widget_show(Mixdarea);
-    gtk_signal_connect(GTK_OBJECT(Mixdarea), "expose_event", (GtkSignalFunc)Gmixer_expose, NULL);
-    gtk_signal_connect(GTK_OBJECT(Mixdarea), "configure_event", (GtkSignalFunc)Gmixer_configure_event, NULL);
-    gtk_signal_connect(GTK_OBJECT(Mixdarea), "motion_notify_event", (GtkSignalFunc)Gmixer_motion_notify, NULL);
-    gtk_signal_connect(GTK_OBJECT(Mixdarea), "button_press_event", (GtkSignalFunc)Gmixer_button_press, NULL);
-    gtk_signal_connect(GTK_OBJECT(Mixdarea), "button_release_event", (GtkSignalFunc)Gmixer_button_release, NULL);
-    Mixtimer=gtk_timeout_add(30, DrawMixer, 0);		// The hw updates the meters about 30 times/s
-    gdk_window_clear_area(Mixdarea->window, 0, 0, Mixwidth, Mixheight);
+    g_signal_connect(Mixdarea, "expose_event", G_CALLBACK(Gmixer_expose), NULL);
+    g_signal_connect(Mixdarea, "configure_event", G_CALLBACK(Gmixer_configure_event), NULL);
+    g_signal_connect(Mixdarea, "motion_notify_event", G_CALLBACK(Gmixer_motion_notify), NULL);
+    g_signal_connect(Mixdarea, "button_press_event", G_CALLBACK(Gmixer_button_press), NULL);
+    g_signal_connect(Mixdarea, "button_release_event", G_CALLBACK(Gmixer_button_release), NULL);
+    Mixtimer=g_timeout_add(30, DrawMixer, 0);		// The hw updates the meters about 30 times/s
+    gtk_widget_queue_draw(GTK_WIDGET(Mixdarea));
     GMw_geom.st=1;
   }
 }
@@ -1686,7 +1793,7 @@ void ToggleWindow(GtkWidget *widget, gpointer window) {
 // Scan all controls and sets up the structures needed to access them.
 int OpenControls(const char *card, const char *cardname) {
   int err, i, o;
-  int numid, items, item;
+  int numid, count, items, item;
   snd_hctl_t *handle;
   snd_hctl_elem_t *elem;
   snd_ctl_elem_id_t *id;
@@ -1719,6 +1826,7 @@ int OpenControls(const char *card, const char *cardname) {
       continue;
     snd_hctl_elem_get_id(elem, id);
     numid=snd_ctl_elem_id_get_numid(id);
+    count=snd_ctl_elem_info_get_count(info);
     if (!strcmp("Monitor Mixer Volume", snd_ctl_elem_id_get_name(id))) {
       if (!mixerId) {
         mixerId=numid;
@@ -1869,9 +1977,10 @@ int main(int argc, char *argv[]) {
   GtkWidget *mainbox;
   GtkWidget *vbsel, *frame, *button;
   GtkWidget *label, *menu, *menuitem;
+  GMenu *gmenu;
   GSList *bgroup;
   int err, i, o, n, cardnum, value;
-  char hwname[16], cardname[32], load, save;
+  char hwname[8], cardname[32], load, save;
   snd_ctl_card_info_t *hw_info;
 
   load=save=1;
@@ -1892,8 +2001,8 @@ int main(int argc, char *argv[]) {
     }
     if ((err=snd_ctl_card_info(ctlhandle, hw_info))>=0) {
       if (!strncmp(snd_ctl_card_info_get_driver(hw_info), "Echo_", 5)) {
-        strncpy(card, hwname, sizeof(hwname)-1);
-        card[sizeof(hwname)-1]=0;
+        strncpy(card, hwname, 7);
+        hwname[7]=0;
         strncpy(cardname, snd_ctl_card_info_get_name(hw_info), 31);
         cardname[31]=0;
         strncpy(cardId, snd_ctl_card_info_get_name(hw_info), 15);
@@ -2012,7 +2121,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
     }
   }
   gtk_init(&argc, &argv);
-  fnt=gdk_font_load("-misc-fixed-medium-r-*-*-10-*-*-*-*-*-*-*");
+  fnt = pango_font_description_from_string("fixed 10");
   if (!fnt) {
     printf("Cannot find the font\n");
     exit(1);
@@ -2027,10 +2136,10 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
   sprintf(str, "%s Misc controls", cardId);
   gtk_window_set_title(GTK_WINDOW(Miscwindow), str);
   gtk_window_set_wmclass(GTK_WINDOW(Miscwindow), "misc", "Emixer");
-  gtk_signal_connect(GTK_OBJECT(Miscwindow), "delete_event", GTK_SIGNAL_FUNC(CloseWindow), (gpointer)&Miscw_geom);
+  g_signal_connect(Miscwindow, "delete_event", G_CALLBACK(CloseWindow), (gpointer)&Miscw_geom);
   gtk_container_set_border_width(GTK_CONTAINER(Miscwindow), BORDER);
   if (Miscw_geom.st!=NOPOS) {
-    gtk_widget_set_uposition(Miscwindow, Miscw_geom.x, Miscw_geom.y);
+    gtk_window_move(GTK_WINDOW(Miscwindow), Miscw_geom.x, Miscw_geom.y);
     gtk_window_set_default_size(GTK_WINDOW(Miscwindow), Miscw_geom.w, Miscw_geom.h);
   }
 
@@ -2054,7 +2163,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
       gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1);
       gtk_widget_show(button);
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), NominalIn.Level[i]);	// Forces handler call
-      gtk_signal_connect(GTK_OBJECT(button), "toggled", GTK_SIGNAL_FUNC(Nominal_level_toggled), (gpointer)(long)i);
+	  g_signal_connect(button, "toggled", G_CALLBACK(Nominal_level_toggled), (gpointer)(long)i);
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), !NominalIn.Level[i]);
     }
   }
@@ -2075,7 +2184,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
       gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1);
       gtk_widget_show(button);
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), NominalOut.Level[i]);
-      gtk_signal_connect(GTK_OBJECT(button), "toggled", GTK_SIGNAL_FUNC(Nominal_level_toggled), (gpointer)(long)(i+ECHO_MAXAUDIOINPUTS));
+	  g_signal_connect(button, "toggled", G_CALLBACK(Nominal_level_toggled), (gpointer)(long)(i+ECHO_MAXAUDIOINPUTS));
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), !NominalOut.Level[i]);
     }
   }
@@ -2090,19 +2199,18 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
     gtk_widget_show(hbox);
     gtk_container_add(GTK_CONTAINER(frame), hbox);
 
-    dmodeOpt=gtk_option_menu_new();
+	dmodeOpt = gtk_combo_box_text_new();
     gtk_widget_show(dmodeOpt);
     menu=gtk_menu_new();
     gtk_widget_show(menu);
     for (i=0; i<ndmodes; i++) {
       menuitem=gtk_menu_item_new_with_label(dmodeName[i]);
       gtk_widget_show(menuitem);
-      gtk_signal_connect(GTK_OBJECT(menuitem), "activate", G_CALLBACK(Digital_mode_activate), (gpointer)(long)i);
-      gtk_menu_append(GTK_MENU(menu), menuitem);
+	  g_signal_connect(menuitem, "activate", G_CALLBACK(Digital_mode_activate), (gpointer)(long)i);
+      gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
     }
-    gtk_option_menu_set_menu(GTK_OPTION_MENU(dmodeOpt), menu);
     gtk_box_pack_start(GTK_BOX(hbox), dmodeOpt, TRUE, TRUE, 0);
-    gtk_option_menu_set_history(GTK_OPTION_MENU(dmodeOpt), dmodeVal=GetEnum(dmodeId));
+    gtk_combo_box_set_active(GTK_COMBO_BOX(dmodeOpt), dmodeVal=GetEnum(dmodeId));
   }
 
 
@@ -2115,7 +2223,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
     gtk_widget_show(hbox);
     gtk_container_add(GTK_CONTAINER(frame), hbox);
 
-    clocksrcOpt=gtk_option_menu_new();
+    clocksrcOpt = gtk_combo_box_text_new();  // For a combo box with text items
     gtk_widget_show(clocksrcOpt);
     menu=gtk_menu_new();
     gtk_widget_show(menu);
@@ -2123,13 +2231,12 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
       clocksrc_menuitem[i]=gtk_menu_item_new_with_label(clocksrcName[i]);
       gtk_widget_show(clocksrc_menuitem[i]);
       gtk_widget_set_sensitive(clocksrc_menuitem[i], FALSE);
-      gtk_signal_connect(GTK_OBJECT(clocksrc_menuitem[i]), "activate", G_CALLBACK(Clock_source_activate), (gpointer)(long)i);
-      gtk_menu_append(GTK_MENU(menu), clocksrc_menuitem[i]);
+	  g_signal_connect(clocksrc_menuitem[i], "activate", G_CALLBACK(Clock_source_activate), (gpointer)(long)i);
+      gtk_menu_shell_append(GTK_MENU_SHELL(menu), clocksrc_menuitem[i]);
     }
-    gtk_option_menu_set_menu(GTK_OPTION_MENU(clocksrcOpt), menu);
     gtk_box_pack_start(GTK_BOX(hbox), clocksrcOpt, TRUE, TRUE, 0);
-    gtk_option_menu_set_history(GTK_OPTION_MENU(clocksrcOpt), clocksrcVal=GetEnum(clocksrcId));
-    clocksrctimer=gtk_timeout_add(2000, CheckInputs, 0);
+    gtk_combo_box_set_active(GTK_COMBO_BOX(clocksrcOpt), clocksrcVal=GetEnum(clocksrcId));
+    clocksrctimer=g_timeout_add(2000, CheckInputs, 0);
   }
 
 
@@ -2142,19 +2249,18 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
     gtk_widget_show(hbox);
     gtk_container_add(GTK_CONTAINER(frame), hbox);
 
-    spdifmodeOpt=gtk_option_menu_new();
+    spdifmodeOpt = gtk_combo_box_text_new();  // For a combo box with text items
     gtk_widget_show(spdifmodeOpt);
     menu=gtk_menu_new();
     gtk_widget_show(menu);
     for (i=0; i<nspdifmodes; i++) {
       menuitem=gtk_menu_item_new_with_label(spdifmodeName[i]);
       gtk_widget_show(menuitem);
-      gtk_signal_connect(GTK_OBJECT(menuitem), "activate", G_CALLBACK(SPDIF_mode_activate), (gpointer)(long)i);
-      gtk_menu_append(GTK_MENU(menu), menuitem);
+	  g_signal_connect(menuitem, "activate", G_CALLBACK(SPDIF_mode_activate), (gpointer)(long)i);
+      gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
     }
-    gtk_option_menu_set_menu(GTK_OPTION_MENU(spdifmodeOpt), menu);
     gtk_box_pack_start(GTK_BOX(hbox), spdifmodeOpt, TRUE, TRUE, 0);
-    gtk_option_menu_set_history(GTK_OPTION_MENU(spdifmodeOpt), spdifmodeVal=GetEnum(spdifmodeId));
+    gtk_combo_box_set_active(GTK_COMBO_BOX(spdifmodeOpt), spdifmodeVal=GetEnum(spdifmodeId));
   }
 
 
@@ -2174,7 +2280,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
       gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 0);
       ReadControl(&i, 1, PhantomPower.id, SND_CTL_ELEM_IFACE_MIXER);
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), i);
-      gtk_signal_connect(GTK_OBJECT(button), "toggled", G_CALLBACK(Switch_toggled), (gpointer)&PhantomPower);
+	  g_signal_connect(button, "toggled", G_CALLBACK(Switch_toggled), (gpointer)&PhantomPower);
       PhantomPower.Button=button;
     }
 
@@ -2185,7 +2291,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
       gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 0);
       ReadControl(&i, 1, Automute.id, SND_CTL_ELEM_IFACE_CARD);
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), i);
-      gtk_signal_connect(GTK_OBJECT(button), "toggled", G_CALLBACK(Switch_toggled), (gpointer)&Automute);
+	  g_signal_connect(button, "toggled", G_CALLBACK(Switch_toggled), (gpointer)&Automute);
       Automute.Button=button;
     }
 
@@ -2194,7 +2300,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
       autoclockChkbutton=gtk_check_button_new_with_label("Autoclock");
       gtk_widget_show(autoclockChkbutton);
       gtk_box_pack_start(GTK_BOX(hbox), autoclockChkbutton, TRUE, FALSE, 0);
-      gtk_signal_connect(GTK_OBJECT(autoclockChkbutton), "toggled", G_CALLBACK(AutoClock_toggled), NULL);
+	  g_signal_connect(autoclockChkbutton, "toggled", G_CALLBACK(AutoClock_toggled), NULL);
       AutoClock=-1;
     }
   }
@@ -2206,10 +2312,10 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
   sprintf(str, "%s PCM volume", cardId);
   gtk_window_set_title(GTK_WINDOW (pcmoutControl.window), str);
   gtk_window_set_wmclass(GTK_WINDOW(pcmoutControl.window), "pcm", "Emixer");
-  gtk_signal_connect(GTK_OBJECT(pcmoutControl.window), "delete_event", GTK_SIGNAL_FUNC(CloseWindow), (gpointer)&PVw_geom);
+  g_signal_connect(pcmoutControl.window, "delete_event", G_CALLBACK(CloseWindow), (gpointer)&PVw_geom);
   gtk_container_set_border_width(GTK_CONTAINER(pcmoutControl.window), BORDER);
   if (PVw_geom.st!=NOPOS) {
-    gtk_widget_set_uposition(pcmoutControl.window, PVw_geom.x, PVw_geom.y);
+    gtk_window_move(GTK_WINDOW(pcmoutControl.window), PVw_geom.x, PVw_geom.y);
     gtk_window_set_default_size(GTK_WINDOW(pcmoutControl.window), PVw_geom.w, PVw_geom.h);
   }
 
@@ -2246,14 +2352,14 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
       gtk_widget_show(pcmoutControl.volume[i]);
       gtk_box_pack_start(GTK_BOX(vbox), pcmoutControl.volume[i], TRUE, TRUE, 0);
       gtk_scale_set_draw_value(GTK_SCALE(pcmoutControl.volume[i]), 0);
-      gtk_signal_connect(GTK_OBJECT(pcmoutControl.adj[i]), "value_changed", GTK_SIGNAL_FUNC(PCM_volume_changed), (gpointer)(long)(i+ECHO_MAXAUDIOINPUTS));
+	  g_signal_connect(pcmoutControl.adj[i], "value_changed", G_CALLBACK(PCM_volume_changed), (gpointer)(long)(i+ECHO_MAXAUDIOINPUTS));
       // Value label
       pcmoutControl.label[i]=gtk_label_new("xxx");
       gtk_widget_show(pcmoutControl.label[i]);
       gtk_box_pack_start(GTK_BOX(vbox), pcmoutControl.label[i], FALSE, FALSE, 0);
-      gtk_adjustment_set_value(GTK_ADJUSTMENT(pcmoutControl.adj[i]), value);
+      gtk_adjustment_set_value(pcmoutControl.adj[i], value);
     }
-    gtk_widget_set_usize(GTK_WIDGET(pcmoutControl.volume[0]), 0, 170);		// Set minimum y size
+    gtk_widget_set_size_request(GTK_WIDGET(pcmoutControl.volume[0]), -1, 170);  // Set minimum y size
   }
 
 
@@ -2263,10 +2369,10 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
   sprintf(str, "%s Line volume", cardId);
   gtk_window_set_title(GTK_WINDOW (LVwindow), str);
   gtk_window_set_wmclass(GTK_WINDOW(LVwindow), "line", "Emixer");
-  gtk_signal_connect(GTK_OBJECT(LVwindow), "delete_event", GTK_SIGNAL_FUNC(CloseWindow), (gpointer)&LVw_geom);
+  g_signal_connect(LVwindow, "delete_event", G_CALLBACK(CloseWindow), (gpointer)&LVw_geom);
   gtk_container_set_border_width(GTK_CONTAINER(LVwindow), BORDER);
   if (LVw_geom.st!=NOPOS) {
-    gtk_widget_set_uposition(LVwindow, LVw_geom.x, LVw_geom.y);
+    gtk_window_move(GTK_WINDOW(LVwindow), LVw_geom.x, LVw_geom.y);
     gtk_window_set_default_size(GTK_WINDOW(LVwindow), LVw_geom.w, LVw_geom.h);
   }
 
@@ -2299,14 +2405,14 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
       gtk_widget_show(lineinControl.volume[i]);
       gtk_box_pack_start(GTK_BOX(vbox), lineinControl.volume[i], TRUE, TRUE, 0);
       gtk_scale_set_draw_value(GTK_SCALE(lineinControl.volume[i]), 0);
-      gtk_signal_connect(GTK_OBJECT(lineinControl.adj[i]), "value_changed", GTK_SIGNAL_FUNC(PCM_volume_changed), (gpointer)(long)i);
+	  g_signal_connect(lineinControl.adj[i], "value_changed", G_CALLBACK(PCM_volume_changed), (gpointer)(long)i);
       // Value label
       lineinControl.label[i]=gtk_label_new("xxx");
       gtk_widget_show(lineinControl.label[i]);
       gtk_box_pack_start(GTK_BOX(vbox), lineinControl.label[i], FALSE, FALSE, 0);
       gtk_adjustment_set_value(GTK_ADJUSTMENT(lineinControl.adj[i]), value);
     }
-    gtk_widget_set_usize(GTK_WIDGET(lineinControl.volume[0]), 0, 170);	// Set minimum y size
+    gtk_widget_set_size_request(GTK_WIDGET(lineinControl.volume[0]), 0, 170);	// Set minimum y size
   }
 
 
@@ -2338,14 +2444,14 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
       gtk_widget_show(lineoutControl.volume[i]);
       gtk_box_pack_start(GTK_BOX(vbox), lineoutControl.volume[i], TRUE, TRUE, 0);
       gtk_scale_set_draw_value(GTK_SCALE(lineoutControl.volume[i]), 0);
-      gtk_signal_connect(GTK_OBJECT(lineoutControl.adj[i]), "value_changed", GTK_SIGNAL_FUNC(LineOut_volume_changed), (gpointer)(long)i);
+	  g_signal_connect(lineoutControl.adj[i], "value_changed", G_CALLBACK(LineOut_volume_changed), (gpointer)(long)i);
       // Value label
       lineoutControl.label[i]=gtk_label_new("xxx");
       gtk_widget_show(lineoutControl.label[i]);
       gtk_box_pack_start(GTK_BOX(vbox), lineoutControl.label[i], FALSE, FALSE, 0);
       gtk_adjustment_set_value(GTK_ADJUSTMENT(lineoutControl.adj[i]), value);
     }
-    gtk_widget_set_usize(GTK_WIDGET(lineoutControl.volume[0]), 0, 170);		// Set minimum y size
+    gtk_widget_set_size_request(GTK_WIDGET(lineoutControl.volume[0]), 0, 170);		// Set minimum y size
   }
 
 
@@ -2357,14 +2463,11 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
     sprintf(str, "%s Monitor mixer", cardId);
     gtk_window_set_title(GTK_WINDOW(mixerControl.window), str);
     gtk_window_set_wmclass(GTK_WINDOW(mixerControl.window), "mixer", "Emixer");
-    gtk_signal_connect(GTK_OBJECT(mixerControl.window), "delete_event", GTK_SIGNAL_FUNC(CloseWindow), (gpointer)&Mixerw_geom);
+    g_signal_connect(mixerControl.window, "delete_event", G_CALLBACK(CloseWindow), (gpointer)&Mixerw_geom);
     gtk_container_set_border_width(GTK_CONTAINER(mixerControl.window), BORDER);
     if (Mixerw_geom.st!=NOPOS) {
-      gtk_widget_set_uposition(mixerControl.window, Mixerw_geom.x, Mixerw_geom.y);
+      gtk_window_move(GTK_WINDOW(mixerControl.window), Mixerw_geom.x, Mixerw_geom.y);
       gtk_window_set_default_size(GTK_WINDOW(mixerControl.window), Mixerw_geom.w, Mixerw_geom.h);
-//      gdk_window_move_resize(mixerControl.window->window, Mixerw_geom.x, Mixerw_geom.y, Mixerw_geom.w, Mixerw_geom.h);
-/*      gtk_widget_set_usize(mixerControl.window, Mixerw_geom.w, Mixerw_geom.h);
-      gtk_widget_set_usize(mixerControl.window, -1, -1);*/
     }
 
     mainbox=gtk_hbox_new(FALSE, SPACING);
@@ -2398,14 +2501,14 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
       gtk_widget_show(mixerControl.volume[i]);
       gtk_box_pack_start(GTK_BOX(vbox), mixerControl.volume[i], TRUE, TRUE, 0);
       gtk_scale_set_draw_value(GTK_SCALE(mixerControl.volume[i]), 0);
-      gtk_signal_connect(GTK_OBJECT(mixerControl.volume[i]), "grab_focus", GTK_SIGNAL_FUNC(Monitor_volume_clicked), (gpointer)i);
-      gtk_signal_connect(GTK_OBJECT(mixerControl.adj[i]), "value_changed", GTK_SIGNAL_FUNC(Monitor_volume_changed), (gpointer)i);
+	  g_signal_connect(mixerControl.volume[i], "grab_focus", G_CALLBACK(Monitor_volume_clicked), (gpointer)i);
+	  g_signal_connect(mixerControl.adj[i], "value_changed", G_CALLBACK(Monitor_volume_changed), (gpointer)i);
       // Value label
       mixerControl.label[i]=gtk_label_new("xxx");
       gtk_widget_show(mixerControl.label[i]);
       gtk_box_pack_start(GTK_BOX(vbox), mixerControl.label[i], FALSE, FALSE, 0);
     }
-    gtk_widget_set_usize(GTK_WIDGET(mixerControl.volume[0]), 0, 170);		// Set minimum y size
+    gtk_widget_set_size_request(GTK_WIDGET(mixerControl.volume[0]), 0, 170);		// Set minimum y size
 
     // Output channel selectors
     frame=gtk_frame_new("Mixer output");
@@ -2421,12 +2524,16 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
         sprintf(str, "An-%d", i);
       else
         sprintf(str, "Di-%d", i-fdOut);
-      if (i)
-        bgroup=gtk_radio_button_group(GTK_RADIO_BUTTON(mixerControl.outsel[i-1]));
-      mixerControl.outsel[i]=gtk_radio_button_new_with_label(bgroup, str);
+      if (i == 0)
+        // For the first radio button, create it without a group (it will be its own group).
+        mixerControl.outsel[i] = gtk_radio_button_new_with_label(NULL, str);
+      else
+        // For subsequent radio buttons, create and group them with the first one.
+        mixerControl.outsel[i] = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(mixerControl.outsel[0]), str);
       gtk_widget_show(mixerControl.outsel[i]);
       gtk_box_pack_start(GTK_BOX(vbsel), mixerControl.outsel[i], FALSE, FALSE, 0);
-      gtk_signal_connect(GTK_OBJECT(mixerControl.outsel[i]), "toggled", GTK_SIGNAL_FUNC(Mixer_Output_selector_clicked), (gpointer)i);
+      //gtk_signal_connect(GTK_OBJECT(mixerControl.outsel[i]), "toggled", GTK_SIGNAL_FUNC(Mixer_Output_selector_clicked), (gpointer)i);
+	  g_signal_connect(mixerControl.outsel[i], "toggled", G_CALLBACK(Mixer_Output_selector_clicked), (gpointer)i);
     }
     mixerControl.input=0;
     mixerControl.output=-1;
@@ -2448,12 +2555,15 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
         sprintf(str, "An-%d", i);
       else
         sprintf(str, "Di-%d", i-fdIn);
-      if (i)
-        bgroup=gtk_radio_button_group(GTK_RADIO_BUTTON(mixerControl.inpsel[i-1]));
-      mixerControl.inpsel[i]=gtk_radio_button_new_with_label(bgroup, str);
+      if (i == 0)
+        // For the first radio button, create it without a group (it will be its own group).
+        mixerControl.inpsel[i] = gtk_radio_button_new_with_label(NULL, str);
+      else
+        // For subsequent radio buttons, create and group them with the first one.
+        mixerControl.inpsel[i] = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(mixerControl.inpsel[0]), str);
       gtk_widget_show(mixerControl.inpsel[i]);
       gtk_box_pack_start(GTK_BOX(vbsel), mixerControl.inpsel[i], FALSE, FALSE, 0);
-      gtk_signal_connect(GTK_OBJECT(mixerControl.inpsel[i]), "toggled", GTK_SIGNAL_FUNC(Mixer_Input_selector_clicked), (gpointer)(long)i);
+	  g_signal_connect(mixerControl.inpsel[i], "toggled", G_CALLBACK(Mixer_Input_selector_clicked), (gpointer)(long)i);
     }
 
     // Mixer volume widgets
@@ -2482,14 +2592,14 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
       gtk_widget_show(mixerControl.volume[i]);
       gtk_box_pack_start(GTK_BOX(vbox), mixerControl.volume[i], TRUE, TRUE, 0);
       gtk_scale_set_draw_value(GTK_SCALE(mixerControl.volume[i]), 0);
-      gtk_signal_connect(GTK_OBJECT(mixerControl.volume[i]), "grab_focus", GTK_SIGNAL_FUNC(Monitor_volume_clicked), (gpointer)(long)i);
-      gtk_signal_connect(GTK_OBJECT(mixerControl.adj[i]), "value_changed", GTK_SIGNAL_FUNC(Monitor_volume_changed), (gpointer)(long)i);
+	  g_signal_connect(mixerControl.volume[i], "grab_focus", G_CALLBACK(Monitor_volume_clicked), (gpointer)(long)i);
+	  g_signal_connect(mixerControl.adj[i], "value_changed", G_CALLBACK(Monitor_volume_changed), (gpointer)(long)i);
       // Value label
       mixerControl.label[i]=gtk_label_new("xxx");
       gtk_widget_show(mixerControl.label[i]);
       gtk_box_pack_start(GTK_BOX(vbox), mixerControl.label[i], FALSE, FALSE, 0);
     }
-    gtk_widget_set_usize(GTK_WIDGET(mixerControl.volume[0]), 0, 170);		// Set minimum y size
+    gtk_widget_set_size_request(GTK_WIDGET(mixerControl.volume[0]), 0, 170);		// Set minimum y size
     mixerControl.input=-1;
     mixerControl.output=0;
     Mixer_Input_selector_clicked(0, 0);
@@ -2504,10 +2614,10 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
     sprintf(str, "%s Vmixer", cardId);
     gtk_window_set_title(GTK_WINDOW(vmixerControl.window), str);
     gtk_window_set_wmclass(GTK_WINDOW(vmixerControl.window), "vmixer", "Emixer");
-    gtk_signal_connect(GTK_OBJECT(vmixerControl.window), "delete_event", GTK_SIGNAL_FUNC(CloseWindow), (gpointer)&Vmixerw_geom);
+    g_signal_connect(vmixerControl.window, "delete_event", G_CALLBACK(CloseWindow), (gpointer)&Vmixerw_geom);
     gtk_container_set_border_width(GTK_CONTAINER(vmixerControl.window), BORDER);
     if (Vmixerw_geom.st!=NOPOS) {
-      gtk_widget_set_uposition(vmixerControl.window, Vmixerw_geom.x, Vmixerw_geom.y);
+      gtk_window_move(GTK_WINDOW(vmixerControl.window), Vmixerw_geom.x, Vmixerw_geom.y);
       gtk_window_set_default_size(GTK_WINDOW(vmixerControl.window), Vmixerw_geom.w, Vmixerw_geom.h);
     }
 
@@ -2540,14 +2650,14 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
       gtk_widget_show(vmixerControl.volume[i]);
       gtk_box_pack_start(GTK_BOX(vbox), vmixerControl.volume[i], TRUE, TRUE, 0);
       gtk_scale_set_draw_value(GTK_SCALE(vmixerControl.volume[i]), 0);
-      gtk_signal_connect(GTK_OBJECT(vmixerControl.volume[i]), "grab_focus", GTK_SIGNAL_FUNC(Vmixer_volume_clicked), (gpointer)i);
-      gtk_signal_connect(GTK_OBJECT(vmixerControl.adj[i]), "value_changed", GTK_SIGNAL_FUNC(Vmixer_volume_changed), (gpointer)i);
+	  g_signal_connect(vmixerControl.volume[i], "grab_focus", G_CALLBACK(Vmixer_volume_clicked), (gpointer)i);
+	  g_signal_connect(vmixerControl.adj[i], "value_changed", G_CALLBACK(Vmixer_volume_changed), (gpointer)i);
       // Value label
       vmixerControl.label[i]=gtk_label_new("xxx");
       gtk_widget_show(vmixerControl.label[i]);
       gtk_box_pack_start(GTK_BOX(vbox), vmixerControl.label[i], FALSE, FALSE, 0);
     }
-    gtk_widget_set_usize(GTK_WIDGET(vmixerControl.volume[0]), 0, 170);		// Set minimum y size
+    gtk_widget_set_size_request(GTK_WIDGET(vmixerControl.volume[0]), 0, 170);		// Set minimum y size
 
     // Input channel selectors
     frame=gtk_frame_new("Output");
@@ -2563,12 +2673,16 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
         sprintf(str, "A%d", i);
       else
         sprintf(str, "D%d", i);
-      if (i)
-        bgroup=gtk_radio_button_group(GTK_RADIO_BUTTON(vmixerControl.outsel[i-1]));
-      vmixerControl.outsel[i]=gtk_radio_button_new_with_label(bgroup, str);
+      if (i == 0)
+        // For the first radio button, create it without a group (it will be its own group).
+        vmixerControl.outsel[i] = gtk_radio_button_new_with_label(NULL, str);
+      else
+        // For subsequent radio buttons, create and group them with the first one.
+        vmixerControl.outsel[i] = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(vmixerControl.outsel[0]), str);
       gtk_widget_show(vmixerControl.outsel[i]);
       gtk_box_pack_start(GTK_BOX(vbsel), vmixerControl.outsel[i], FALSE, FALSE, 0);
-      gtk_signal_connect(GTK_OBJECT(vmixerControl.outsel[i]), "toggled", GTK_SIGNAL_FUNC(Vmixer_output_selector_clicked), (gpointer)i);
+      //gtk_signal_connect(GTK_OBJECT(vmixerControl.outsel[i]), "toggled", GTK_SIGNAL_FUNC(Vmixer_output_selector_clicked), (gpointer)i);
+	  g_signal_connect(vmixerControl.outsel[i], "toggled", G_CALLBACK(Vmixer_output_selector_clicked), (gpointer)i);
     }
     vmixerControl.output=-1;
     Vmixer_output_selector_clicked(0, 0);
@@ -2586,12 +2700,15 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
     bgroup=0;
     for (i=0; i<vmixerControl.inputs; i++) {
       sprintf(str, "V%d", i);
-      if (i)
-        bgroup=gtk_radio_button_group(GTK_RADIO_BUTTON(vmixerControl.vchsel[i-1]));
-      vmixerControl.vchsel[i]=gtk_radio_button_new_with_label(bgroup, str);
+      if (i == 0)
+        // For the first radio button, create it without a group (it will be its own group).
+        vmixerControl.vchsel[i] = gtk_radio_button_new_with_label(NULL, str);
+      else
+        // For subsequent radio buttons, create and group them with the previous button.
+        vmixerControl.vchsel[i] = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(vmixerControl.vchsel[i-1]), str);
       gtk_widget_show(vmixerControl.vchsel[i]);
       gtk_box_pack_start(GTK_BOX(vbsel), vmixerControl.vchsel[i], FALSE, FALSE, 0);
-      gtk_signal_connect(GTK_OBJECT(vmixerControl.vchsel[i]), "toggled", GTK_SIGNAL_FUNC(Vmixer_vchannel_selector_clicked), (gpointer)(long)i);
+	  g_signal_connect(vmixerControl.vchsel[i], "toggled", G_CALLBACK(Vmixer_vchannel_selector_clicked), (gpointer)(long)i);
     }
 
     // Vmixer volume widgets
@@ -2620,14 +2737,14 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
       gtk_widget_show(vmixerControl.volume[i]);
       gtk_box_pack_start(GTK_BOX(vbox), vmixerControl.volume[i], TRUE, TRUE, 0);
       gtk_scale_set_draw_value(GTK_SCALE(vmixerControl.volume[i]), 0);
-      gtk_signal_connect(GTK_OBJECT(vmixerControl.volume[i]), "grab_focus", GTK_SIGNAL_FUNC(Vmixer_volume_clicked), (gpointer)(long)i);
-      gtk_signal_connect(GTK_OBJECT(vmixerControl.adj[i]), "value_changed", GTK_SIGNAL_FUNC(Vmixer_volume_changed), (gpointer)(long)i);
+	  g_signal_connect(vmixerControl.volume[i], "grab_focus", G_CALLBACK(Vmixer_volume_clicked), (gpointer)(long)i);
+	  g_signal_connect(vmixerControl.adj[i], "value_changed", G_CALLBACK(Vmixer_volume_changed), (gpointer)(long)i);
       // Value label
       vmixerControl.label[i]=gtk_label_new("xxx");
       gtk_widget_show(vmixerControl.label[i]);
       gtk_box_pack_start(GTK_BOX(vbox), vmixerControl.label[i], FALSE, FALSE, 0);
     }
-    gtk_widget_set_usize(GTK_WIDGET(vmixerControl.volume[0]), 0, 170);		// Set minimum y size
+    gtk_widget_set_size_request(GTK_WIDGET(vmixerControl.volume[0]), 0, 170);		// Set minimum y size
     vmixerControl.input=-1;
     Vmixer_vchannel_selector_clicked(0, 0);
 #endif
@@ -2640,11 +2757,11 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
   sprintf(str, EM_VERSION, cardId);
   gtk_window_set_title(GTK_WINDOW(Mainwindow), str);
   gtk_window_set_wmclass(GTK_WINDOW(Mainwindow), "emixer", "Emixer");
-  gtk_signal_connect(GTK_OBJECT(Mainwindow), "delete_event", GTK_SIGNAL_FUNC(Mainwindow_delete), (gpointer)&Mainw_geom);
+  g_signal_connect(Mainwindow, "delete_event", G_CALLBACK(Mainwindow_delete), (gpointer)&Mainw_geom);
   gtk_container_set_border_width(GTK_CONTAINER(Mainwindow), BORDER);
   gtk_widget_show(Mainwindow);
   if (Mainw_geom.x!=NOPOS) {
-    gtk_widget_set_uposition(Mainwindow, Mainw_geom.x, Mainw_geom.y);
+    gtk_window_move(GTK_WINDOW(Mainwindow), Mainw_geom.x, Mainw_geom.y);
     gtk_window_set_default_size(GTK_WINDOW(Mainwindow), Mainw_geom.w, Mainw_geom.h);
   }
 
@@ -2664,7 +2781,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
   gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), 1);
   gtk_widget_show(button);
-  gtk_signal_connect(GTK_OBJECT(button), "toggled", G_CALLBACK(Gang_button_toggled), 0);
+  g_signal_connect(button, "toggled", G_CALLBACK(Gang_button_toggled), 0);
 
   // Controls frame
   frame=gtk_frame_new("Controls");
@@ -2679,7 +2796,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
     button=gtk_toggle_button_new_with_label("VU");
     gtk_widget_show(button);
     gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 1);
-    gtk_signal_connect(GTK_OBJECT(button), "toggled", G_CALLBACK(VUmeters_button_click), 0);
+    g_signal_connect(button, "toggled", G_CALLBACK(VUmeters_button_click), 0);
     VUw_geom.toggler=button;
     if (VUw_geom.st==1)
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
@@ -2689,7 +2806,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
   button=gtk_toggle_button_new_with_label("Line");
   gtk_widget_show(button);
   gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 1);
-  gtk_signal_connect(GTK_OBJECT(button), "toggled", G_CALLBACK(ToggleWindow), (gpointer)LVwindow);
+  g_signal_connect(button, "toggled", G_CALLBACK(ToggleWindow), (gpointer)LVwindow);
   LVw_geom.toggler=button;
   if (LVw_geom.st==1)
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
@@ -2699,7 +2816,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
     button=gtk_toggle_button_new_with_label("Misc");
     gtk_widget_show(button);
     gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 1);
-    gtk_signal_connect(GTK_OBJECT(button), "toggled", G_CALLBACK(ToggleWindow), (gpointer)Miscwindow);
+    g_signal_connect(button, "toggled", G_CALLBACK(ToggleWindow), (gpointer)Miscwindow);
     Miscw_geom.toggler=button;
     if (Miscw_geom.st==1)
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
@@ -2710,7 +2827,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
     button=gtk_toggle_button_new_with_label("GrMix");
     gtk_widget_show(button);
     gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 1);
-    gtk_signal_connect(GTK_OBJECT(button), "toggled", G_CALLBACK(GMixer_button_click), 0);
+    g_signal_connect(button, "toggled", G_CALLBACK(GMixer_button_click), 0);
     GMw_geom.toggler=button;
     if (GMw_geom.st==1)
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
@@ -2719,7 +2836,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
     button=gtk_toggle_button_new_with_label("Mixer");
     gtk_widget_show(button);
     gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 1);
-    gtk_signal_connect(GTK_OBJECT(button), "toggled", G_CALLBACK(ToggleWindow), (gpointer)mixerControl.window);
+    g_signal_connect(button, "toggled", G_CALLBACK(ToggleWindow), (gpointer)mixerControl.window);
     Mixerw_geom.toggler=button;
     if (Mixerw_geom.st==1)
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
@@ -2730,7 +2847,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
     button=gtk_toggle_button_new_with_label("Vmixer");
     gtk_widget_show(button);
     gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 1);
-    gtk_signal_connect(GTK_OBJECT(button), "toggled", G_CALLBACK(ToggleWindow), (gpointer)vmixerControl.window);
+    g_signal_connect(button, "toggled", G_CALLBACK(ToggleWindow), (gpointer)vmixerControl.window);
     Vmixerw_geom.toggler=button;
     if (Vmixerw_geom.st==1)
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
@@ -2741,7 +2858,7 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
     button=gtk_toggle_button_new_with_label("PCM");
     gtk_widget_show(button);
     gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 1);
-    gtk_signal_connect(GTK_OBJECT(button), "toggled", G_CALLBACK(ToggleWindow), (gpointer)pcmoutControl.window);
+    g_signal_connect(button, "toggled", G_CALLBACK(ToggleWindow), (gpointer)pcmoutControl.window);
     PVw_geom.toggler=button;
     if (PVw_geom.st==1)
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
@@ -2797,41 +2914,42 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
         fprintf(f, "-- xxWindow <x> <y> <width> <height> <visible>\n");
         fprintf(f, "MainWindow %d %d %d %d\n", Mainw_geom.x, Mainw_geom.y, Mainw_geom.w, Mainw_geom.h);
         if (VUwindow)
-          gdk_window_get_root_origin(VUwindow->window, &VUw_geom.x, &VUw_geom.y);
+          gdk_window_get_root_origin(gtk_widget_get_window(VUwindow), &VUw_geom.x, &VUw_geom.y);
         fprintf(f, "VUmetersWindow %d %d %d\n", VUw_geom.x, VUw_geom.y, VUw_geom.st);
         if (GMwindow)
-          gdk_window_get_root_origin(GMwindow->window, &VUw_geom.x, &VUw_geom.y);
+          gdk_window_get_root_origin(gtk_widget_get_window(GMwindow), &VUw_geom.x, &VUw_geom.y);
         fprintf(f, "GfxMixerWindow %d %d %d\n", GMw_geom.x, GMw_geom.y, GMw_geom.st);
         if (pcmoutId) {
-          if (pcmoutControl.window->window) {
-            gdk_window_get_root_origin(pcmoutControl.window->window, &PVw_geom.x, &PVw_geom.y);
-            gdk_window_get_size(pcmoutControl.window->window, &PVw_geom.w, &PVw_geom.h);
+		GdkWindow* pcmwin = gtk_widget_get_window(pcmoutControl.window);
+		  if (pcmwin) {
+            gdk_window_get_root_origin(pcmwin, &PVw_geom.x, &PVw_geom.y);
+			gtk_window_get_size(GTK_WINDOW(pcmoutControl.window), &PVw_geom.w, &PVw_geom.h);
           }
-          fprintf(f, "PcmVolumeWindow %d %d %d %d %d\n", PVw_geom.x, PVw_geom.y, PVw_geom.w, PVw_geom.h, !!GTK_WIDGET_VISIBLE(pcmoutControl.window));
+          fprintf(f, "PcmVolumeWindow %d %d %d %d %d\n", PVw_geom.x, PVw_geom.y, PVw_geom.w, PVw_geom.h, !!gtk_widget_get_visible(pcmoutControl.window));
         }
-        if (LVwindow->window) {
-          gdk_window_get_root_origin(LVwindow->window, &LVw_geom.x, &LVw_geom.y);
-          gdk_window_get_size(LVwindow->window, &LVw_geom.w, &LVw_geom.h);
+        if (LVwindow) {
+          gdk_window_get_root_origin(gtk_widget_get_window(LVwindow), &LVw_geom.x, &LVw_geom.y);
+          gtk_window_get_size(GTK_WINDOW(LVwindow), &LVw_geom.w, &LVw_geom.h);
         }
-        fprintf(f, "LineVolumeWindow %d %d %d %d %d\n", LVw_geom.x, LVw_geom.y, LVw_geom.w, LVw_geom.h, !!GTK_WIDGET_VISIBLE(LVwindow));
-        if (Miscwindow->window) {
-          gdk_window_get_root_origin(Miscwindow->window, &Miscw_geom.x, &Miscw_geom.y);
-          gdk_window_get_size(Miscwindow->window, &Miscw_geom.w, &Miscw_geom.h);
+        fprintf(f, "LineVolumeWindow %d %d %d %d %d\n", LVw_geom.x, LVw_geom.y, LVw_geom.w, LVw_geom.h, !!gtk_widget_get_visible(LVwindow));
+        if (Miscwindow) {
+          gdk_window_get_root_origin(gtk_widget_get_window(Miscwindow), &Miscw_geom.x, &Miscw_geom.y);
+          gtk_window_get_size(GTK_WINDOW(Miscwindow), &Miscw_geom.w, &Miscw_geom.h);
         }
-        fprintf(f, "MiscControlsWindow %d %d %d %d %d\n", Miscw_geom.x, Miscw_geom.y, Miscw_geom.w, Miscw_geom.h, !!GTK_WIDGET_VISIBLE(Miscwindow));
+        fprintf(f, "MiscControlsWindow %d %d %d %d %d\n", Miscw_geom.x, Miscw_geom.y, Miscw_geom.w, Miscw_geom.h, !!gtk_widget_get_visible(Miscwindow));
         if (mixerId) {
-          if (mixerControl.window->window) {
-            gdk_window_get_root_origin(mixerControl.window->window, &Mixerw_geom.x, &Mixerw_geom.y);
-            gdk_window_get_size(mixerControl.window->window, &Mixerw_geom.w, &Mixerw_geom.h);
+          if (mixerControl.window) {
+            gdk_window_get_root_origin(gtk_widget_get_window(mixerControl.window), &Mixerw_geom.x, &Mixerw_geom.y);
+            gtk_window_get_size(GTK_WINDOW(mixerControl.window), &Mixerw_geom.w, &Mixerw_geom.h);
           }
-          fprintf(f, "MixerWindow %d %d %d %d %d\n", Mixerw_geom.x, Mixerw_geom.y, Mixerw_geom.w, Mixerw_geom.h, !!GTK_WIDGET_VISIBLE(mixerControl.window));
+          fprintf(f, "MixerWindow %d %d %d %d %d\n", Mixerw_geom.x, Mixerw_geom.y, Mixerw_geom.w, Mixerw_geom.h, !!gtk_widget_get_visible(mixerControl.window));
         }
         if (vmixerId) {
-          if (vmixerControl.window->window) {
-            gdk_window_get_root_origin(vmixerControl.window->window, &Vmixerw_geom.x, &Vmixerw_geom.y);
-            gdk_window_get_size(vmixerControl.window->window, &Vmixerw_geom.w, &Vmixerw_geom.h);
+          if (vmixerControl.window) {
+            gdk_window_get_root_origin(gtk_widget_get_window(vmixerControl.window), &Vmixerw_geom.x, &Vmixerw_geom.y);
+            gtk_window_get_size(GTK_WINDOW(vmixerControl.window), &Vmixerw_geom.w, &Vmixerw_geom.h);
           }
-          fprintf(f, "VmixerWindow %d %d %d %d %d\n", Vmixerw_geom.x, Vmixerw_geom.y, Vmixerw_geom.w, Vmixerw_geom.h, !!GTK_WIDGET_VISIBLE(vmixerControl.window));
+          fprintf(f, "VmixerWindow %d %d %d %d %d\n", Vmixerw_geom.x, Vmixerw_geom.y, Vmixerw_geom.w, Vmixerw_geom.h, !!gtk_widget_get_visible(vmixerControl.window));
         }
         fprintf(f, "\n");
         fclose(f);
@@ -2841,11 +2959,11 @@ printf("components = %s\n", snd_ctl_card_info_get_components(hw_info));*/
 
   if (VUwindow) {
     SetVUmeters(0);
-    gtk_timeout_remove(VUtimer);
+    g_source_remove(VUtimer);
   }
   if (GMwindow) {
     SetVUmeters(0);
-    gtk_timeout_remove(Mixtimer);
+    g_source_remove(Mixtimer);
   }
   snd_ctl_close(ctlhandle);
   return(0);

From 60f14308821e724d6f4540208788944b060e13ed Mon Sep 17 00:00:00 2001
From: genBTC <genBTC@gmx.com>
Date: Thu, 6 Mar 2025 18:59:46 -0500
Subject: [PATCH 2/3] envycontrol/: port from GTK2 to GTK3

---
 envy24control/config.c        |   2 +-
 envy24control/configure.ac    |   2 +-
 envy24control/driverevents.c  |   7 +-
 envy24control/envy24control.c | 511 ++++++++++++++++------------------
 envy24control/envy24control.h |  14 +-
 envy24control/hardware.c      |  18 +-
 envy24control/levelmeters.c   | 379 +++++++++++++++++--------
 envy24control/midi.c          |   3 +-
 envy24control/midi.h          |   2 +-
 envy24control/mixer.c         |  17 +-
 envy24control/patchbay.c      |   2 +-
 envy24control/volume.c        |  18 +-
 12 files changed, 553 insertions(+), 422 deletions(-)

diff --git a/envy24control/config.c b/envy24control/config.c
index c27cf27..f3ce2c9 100644
--- a/envy24control/config.c
+++ b/envy24control/config.c
@@ -47,7 +47,7 @@ void config_close()
 void config_set_stereo(GtkWidget *but, gpointer data)
 {
   gint i=GPOINTER_TO_INT(data);
-  config_stereo[i]=GTK_TOGGLE_BUTTON(but)->active;
+  config_stereo[i]=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(but));
 }
 
 void config_restore_stereo()
diff --git a/envy24control/configure.ac b/envy24control/configure.ac
index 776f290..dfb21bd 100644
--- a/envy24control/configure.ac
+++ b/envy24control/configure.ac
@@ -5,6 +5,6 @@ AC_HEADER_STDC
 AM_INIT_AUTOMAKE
 AM_MAINTAINER_MODE([enable])
 
-PKG_CHECK_MODULES(ENVY24CONTROL, gtk+-2.0 alsa >= 0.9.0)
+PKG_CHECK_MODULES(ENVY24CONTROL, gtk+-3.0 alsa >= 0.9.0)
 
 AC_OUTPUT(Makefile desktop/Makefile)
diff --git a/envy24control/driverevents.c b/envy24control/driverevents.c
index 377363d..51fb647 100644
--- a/envy24control/driverevents.c
+++ b/envy24control/driverevents.c
@@ -19,7 +19,7 @@
 
 #include "envy24control.h"
 
-void control_input_callback(gpointer data, gint source, GdkInputCondition condition)
+gint control_input_callback(GIOChannel *source, GIOCondition condition, gpointer data)
 {
 	snd_ctl_t *ctl = (snd_ctl_t *)data;
 	snd_ctl_event_t *ev;
@@ -29,12 +29,12 @@ void control_input_callback(gpointer data, gint source, GdkInputCondition condit
 
 	snd_ctl_event_alloca(&ev);
 	if (snd_ctl_read(ctl, ev) < 0)
-		return;
+		return FALSE;
 	name = snd_ctl_event_elem_get_name(ev);
 	index = snd_ctl_event_elem_get_index(ev);
 	mask = snd_ctl_event_elem_get_mask(ev);
 	if (! (mask & (SND_CTL_EVENT_MASK_VALUE | SND_CTL_EVENT_MASK_INFO)))
-		return;
+		return FALSE;
 
 	switch (snd_ctl_event_elem_get_interface(ev)) {
 	case SND_CTL_ELEM_IFACE_MIXER:
@@ -84,5 +84,6 @@ void control_input_callback(gpointer data, gint source, GdkInputCondition condit
 	default:
 		break;
 	}
+	return TRUE;
 }
 
diff --git a/envy24control/envy24control.c b/envy24control/envy24control.c
index bce41eb..d481e4b 100644
--- a/envy24control/envy24control.c
+++ b/envy24control/envy24control.c
@@ -45,7 +45,7 @@ GtkWidget *window;
 GtkWidget *mixer_mix_drawing;
 GtkWidget *mixer_clear_peaks_button;
 GtkWidget *mixer_drawing[20];
-GtkObject *mixer_adj[20][2];
+GtkAdjustment *mixer_adj[20][2];
 GtkWidget *mixer_vscale[20][2];
 GtkWidget *mixer_mute_toggle[20][2];
 GtkWidget *mixer_stereo_toggle[20];
@@ -71,7 +71,7 @@ GtkWidget *hw_clock_state_reset;
 GtkWidget *hw_rate_locking_check;
 GtkWidget *hw_rate_reset_check;
 
-GtkObject *hw_volume_change_adj;
+GtkAdjustment *hw_volume_change_adj;
 GtkWidget *hw_volume_change_spin;
 
 GtkWidget *hw_spdif_profi_nonaudio_radio;
@@ -115,9 +115,9 @@ GtkWidget *input_interface_wavetable;
 GtkWidget *hw_phono_input_on_radio;
 GtkWidget *hw_phono_input_off_radio;
 
-GtkObject *av_dac_volume_adj[10];
-GtkObject *av_adc_volume_adj[10];
-GtkObject *av_ipga_volume_adj[10];
+GtkAdjustment *av_dac_volume_adj[10];
+GtkAdjustment *av_adc_volume_adj[10];
+GtkAdjustment *av_ipga_volume_adj[10];
 GtkLabel *av_dac_volume_label[10];
 GtkLabel *av_adc_volume_label[10];
 GtkLabel *av_ipga_volume_label[10];
@@ -130,7 +130,7 @@ struct profile_button {
 } profiles_toggle_buttons[MAX_PROFILES];
 
 GtkWidget *active_button = NULL;
-GtkObject *card_number_adj;
+GtkAdjustment *card_number_adj;
 
 
 static void create_mixer_frame(GtkWidget *box, int stream)
@@ -139,7 +139,7 @@ static void create_mixer_frame(GtkWidget *box, int stream)
 	GtkWidget *vbox1;
 	GtkWidget *hbox;
 	GtkWidget *frame;
-	GtkObject *adj;
+	GtkAdjustment *adj;
 	GtkWidget *vscale;
 	GtkWidget *drawing;
 	GtkWidget *label;
@@ -192,8 +192,8 @@ static void create_mixer_frame(GtkWidget *box, int stream)
 	gtk_box_pack_start(GTK_BOX(hbox), vscale, TRUE, FALSE, 0);
 	gtk_scale_set_value_pos(GTK_SCALE(vscale), GTK_POS_BOTTOM);
 	gtk_scale_set_digits(GTK_SCALE(vscale), 0);
-	gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
-			   GTK_SIGNAL_FUNC(mixer_adjust),
+	g_signal_connect(adj, "value_changed",
+			   G_CALLBACK(mixer_adjust),
 			   (gpointer)(long)((stream << 16) + 0));
 
 	vbox1 = gtk_vbox_new(FALSE, 0);
@@ -205,12 +205,13 @@ static void create_mixer_frame(GtkWidget *box, int stream)
 	sprintf(drawname, "Mixer%i", stream);
 	gtk_widget_set_name(drawing, drawname);
 	gtk_widget_show(drawing);
-	gtk_signal_connect(GTK_OBJECT(drawing), "expose_event",
-			   GTK_SIGNAL_FUNC(level_meters_expose_event), NULL);
-	gtk_signal_connect(GTK_OBJECT(drawing), "configure_event",
-			   GTK_SIGNAL_FUNC(level_meters_configure_event), NULL);
+	g_signal_connect(drawing, "expose_event",
+			   G_CALLBACK(level_meters_expose_event), NULL);
+	g_signal_connect(drawing, "configure_event",
+			   G_CALLBACK(level_meters_configure_event), NULL);
 	gtk_widget_set_events(drawing, GDK_EXPOSURE_MASK);
-	gtk_widget_set_usize(drawing, 36, (60 * tall_equal_mixer_ht + 204));
+	gtk_widget_set_size_request(drawing, 36, (60 * tall_equal_mixer_ht + 204));
+
 	gtk_box_pack_start(GTK_BOX(vbox1), drawing, FALSE, FALSE, 1);
 
 	label = gtk_label_new("");
@@ -225,10 +226,10 @@ static void create_mixer_frame(GtkWidget *box, int stream)
 	gtk_box_pack_start(GTK_BOX(hbox), vscale, TRUE, FALSE, 0);
 	gtk_scale_set_value_pos(GTK_SCALE(vscale), GTK_POS_BOTTOM);
 	gtk_scale_set_digits(GTK_SCALE(vscale), 0);
-	gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
-			   GTK_SIGNAL_FUNC(mixer_adjust),
+	g_signal_connect(adj, "value_changed",
+			   G_CALLBACK(mixer_adjust),
 			   (gpointer)(long)((stream << 16) + 1));
-	
+
 	hbox = gtk_hbox_new(TRUE, 0);
 	gtk_widget_show(hbox);
 	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, FALSE, 0);
@@ -237,7 +238,7 @@ static void create_mixer_frame(GtkWidget *box, int stream)
 	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 	gtk_widget_show(label);
 	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
-	
+
 	label = gtk_label_new("Right");
 	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
 	gtk_widget_show(label);
@@ -247,9 +248,8 @@ static void create_mixer_frame(GtkWidget *box, int stream)
 	mixer_stereo_toggle[stream-1] = toggle;
 	gtk_widget_show(toggle);
 	gtk_box_pack_end(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
-	/* gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), TRUE); */
-	gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
-			   GTK_SIGNAL_FUNC(config_set_stereo), GINT_TO_POINTER(stream-1));
+	g_signal_connect(toggle, "toggled",
+              G_CALLBACK(config_set_stereo), GINT_TO_POINTER(stream-1));
 
 	hbox = gtk_hbox_new(TRUE, 6);
 	gtk_widget_show(hbox);
@@ -260,8 +260,8 @@ static void create_mixer_frame(GtkWidget *box, int stream)
 	gtk_widget_show(toggle);
 	gtk_box_pack_start(GTK_BOX(hbox), toggle, FALSE, TRUE, 0);
 	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), TRUE);
-	gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
-			   GTK_SIGNAL_FUNC(mixer_toggled_mute),
+	g_signal_connect(toggle, "toggled",
+			   G_CALLBACK(mixer_toggled_mute),
 			   (gpointer)(long)((stream << 16) + 0));
 
 	toggle = gtk_toggle_button_new_with_label("Mute");
@@ -269,8 +269,8 @@ static void create_mixer_frame(GtkWidget *box, int stream)
 	gtk_widget_show(toggle);
 	gtk_box_pack_start(GTK_BOX(hbox), toggle, FALSE, TRUE, 0);
 	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), TRUE);
-	gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
-			   GTK_SIGNAL_FUNC(mixer_toggled_mute),
+	g_signal_connect(toggle, "toggled",
+			   G_CALLBACK(mixer_toggled_mute),
 			   (gpointer)(long)((stream << 16) + 1));
 }
 
@@ -432,7 +432,7 @@ static void create_router_frame(GtkWidget *box, int stream, int pos)
 		}
 	if ((stream == MAX_PCM_OUTPUT_CHANNELS + 1) || (stream == MAX_PCM_OUTPUT_CHANNELS + 2)) {
 		sprintf(str1, "S/PDIF Out (%s)", stream & 1 ? "L" : "R");
-	} else { 
+	} else {
 		sprintf(str1, "PCM Out %i", stream);
 	}
 
@@ -449,13 +449,11 @@ static void create_router_frame(GtkWidget *box, int stream, int pos)
 
 	radiobutton = gtk_radio_button_new_with_label(group, str1);
 	router_radio[stream-1][0] = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)patchbay_toggled, 
-			   (gpointer)(long)((stream << 16) + 0));
-
+	g_signal_connect(radiobutton, "toggled",
+			G_CALLBACK(patchbay_toggled),
+			(gpointer)(long)((stream << 16) + 0));
 
 	hseparator = gtk_hseparator_new();
 	gtk_widget_show(hseparator);
@@ -468,15 +466,14 @@ static void create_router_frame(GtkWidget *box, int stream, int pos)
 	if( (stream <= 2) /* hw1/2 */ ||
 	    ((stream > MAX_OUTPUT_CHANNELS) && (stream <= MAX_OUTPUT_CHANNELS + 2)) /* spdif1/2 */
 	    ) {
-		radiobutton = gtk_radio_button_new_with_label(group, stream & 1 ? "Digital Mix L" : "Digital Mix R");
+        radiobutton = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radiobutton), stream & 1 ? "Digital Mix L" : "Digital Mix R");
 		router_radio[stream-1][1] = radiobutton;
-		group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 		gtk_widget_show(radiobutton);
-		gtk_box_pack_start(GTK_BOX(vbox), 
+		gtk_box_pack_start(GTK_BOX(vbox),
 				    radiobutton, FALSE, FALSE, 0);
-		gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-				  (GtkSignalFunc)patchbay_toggled, 
-				   (gpointer)(long)((stream << 16) + 1));
+		g_signal_connect(radiobutton, "toggled",
+				G_CALLBACK(patchbay_toggled),
+				(gpointer)(long)((stream << 16) + 1));
 	}
 	else {
 	  label = gtk_label_new("");
@@ -484,22 +481,20 @@ static void create_router_frame(GtkWidget *box, int stream, int pos)
 	  gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
 	}
 
-
 	hseparator = gtk_hseparator_new();
 	gtk_widget_show(hseparator);
 	gtk_box_pack_start(GTK_BOX(vbox), hseparator, FALSE, TRUE, 0);
 
 
 	for(idx = 2 - spdif_channels; idx < input_channels + 2; idx++) {
-		radiobutton = gtk_radio_button_new_with_label(group, table[idx]);
+		radiobutton = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radiobutton), table[idx]);
 		router_radio[stream-1][2+idx] = radiobutton;
-		group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 		gtk_widget_show(radiobutton);
-		gtk_box_pack_start(GTK_BOX(vbox), 
+		gtk_box_pack_start(GTK_BOX(vbox),
 				    radiobutton, FALSE, FALSE, 0);
-		gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-				  (GtkSignalFunc)patchbay_toggled, 
-				   (gpointer)(long)((stream << 16) + 2 + idx));
+		g_signal_connect(radiobutton, "toggled",
+				G_CALLBACK(patchbay_toggled),
+				(gpointer)(long)((stream << 16) + 2 + idx));
 	}
 }
 
@@ -563,75 +558,60 @@ static void create_master_clock(GtkWidget *box)
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Int 22050");
 	hw_master_clock_xtal_22050 = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)internal_clock_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(internal_clock_toggled),
 			  (gpointer)"22050");
 
-
 	radiobutton = gtk_radio_button_new_with_label(group, "Int 32000");
 	hw_master_clock_xtal_32000 = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)internal_clock_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(internal_clock_toggled),
 			  (gpointer)"32000");
 
-
 	radiobutton = gtk_radio_button_new_with_label(group, "Int 44100");
 	hw_master_clock_xtal_44100 = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)internal_clock_toggled, 
-			  (gpointer)"44100");
-
+	g_signal_connect(radiobutton, "toggled",
+              G_CALLBACK(internal_clock_toggled),
+              (gpointer)"44100");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Int 48000");
 	hw_master_clock_xtal_48000 = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)internal_clock_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(internal_clock_toggled),
 			  (gpointer)"48000");
 
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Int 88200");
 	hw_master_clock_xtal_88200 = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)internal_clock_toggled, 
-			  (gpointer)"88200");
-
+	g_signal_connect(radiobutton, "toggled",
+              G_CALLBACK(internal_clock_toggled),
+              (gpointer)"88200");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Int 96000");
 	hw_master_clock_xtal_96000 = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)internal_clock_toggled, 
-			  (gpointer)"96000");
-
-
+	g_signal_connect(radiobutton, "toggled",
+              G_CALLBACK(internal_clock_toggled),
+              (gpointer)"96000");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "S/PDIF In");
 	hw_master_clock_spdif_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)internal_clock_toggled, 
-			  (gpointer)"SPDIF");
-
-
+	g_signal_connect(radiobutton, "toggled",
+              G_CALLBACK(internal_clock_toggled),
+              (gpointer)"SPDIF");
 
 	if (card_eeprom.subvendor != ICE1712_SUBDEVICE_DELTA1010 &&
 	    card_eeprom.subvendor != ICE1712_SUBDEVICE_DELTA1010LT)
@@ -639,13 +619,12 @@ static void create_master_clock(GtkWidget *box)
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Word Clock");
 	hw_master_clock_word_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)internal_clock_toggled, 
-			  (gpointer)"WordClock");
-	
+	g_signal_connect(radiobutton, "toggled",
+              G_CALLBACK(internal_clock_toggled),
+              (gpointer)"WordClock");
+
         label = gtk_label_new("Locked");
         hw_master_clock_status_label = label;
         gtk_widget_show(label);
@@ -671,19 +650,17 @@ static void create_rate_state(GtkWidget *box)
 	hw_rate_locking_check = check;
 	gtk_widget_show(check);
 	gtk_box_pack_start(GTK_BOX(hbox), check, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(check), "toggled",
-			  (GtkSignalFunc)rate_locking_toggled, 
+	g_signal_connect(check, "toggled",
+			  G_CALLBACK(rate_locking_toggled),
 			  (gpointer)"locked");
 
-
 	check = gtk_check_button_new_with_label("Reset");
 	hw_rate_reset_check = check;
 	gtk_widget_show(check);
 	gtk_box_pack_start(GTK_BOX(hbox), check, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(check), "toggled",
-			  (GtkSignalFunc)rate_reset_toggled, 
+	g_signal_connect(check, "toggled",
+			  G_CALLBACK(rate_reset_toggled),
 			  (gpointer)"reset");
-
 }
 
 static void create_actual_rate(GtkWidget *box)
@@ -707,7 +684,7 @@ static void create_volume_change(GtkWidget *box)
 {
 	GtkWidget *frame;
 	GtkWidget *hbox;
-	GtkObject *spinbutton_adj;
+	GtkAdjustment *spinbutton_adj;
 	GtkWidget *spinbutton;
 	GtkWidget *label;
 
@@ -731,9 +708,8 @@ static void create_volume_change(GtkWidget *box)
 	gtk_widget_show(spinbutton);
 	gtk_box_pack_start(GTK_BOX(hbox), spinbutton, TRUE, FALSE, 0);
 	gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spinbutton), TRUE);
-	gtk_signal_connect(GTK_OBJECT(spinbutton_adj), "value_changed",
-			   GTK_SIGNAL_FUNC(volume_change_rate_adj), NULL);
-	
+	g_signal_connect(spinbutton_adj, "value_changed",
+			   G_CALLBACK(volume_change_rate_adj), NULL);
 }
 
 static void create_spdif_output_settings_profi_data(GtkWidget *box)
@@ -756,21 +732,19 @@ static void create_spdif_output_settings_profi_data(GtkWidget *box)
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Non-audio");
 	hw_spdif_profi_nonaudio_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)profi_data_toggled, 
-			  (gpointer)"Non-audio");
+	g_signal_connect(radiobutton, "toggled",
+ 			  G_CALLBACK(profi_data_toggled),
+ 			  (gpointer)"Non-audio");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Audio");
 	hw_spdif_profi_audio_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)profi_data_toggled, 
-			  (gpointer)"Audio");
+	g_signal_connect(radiobutton, "toggled",
+ 			  G_CALLBACK(profi_data_toggled),
+ 			  (gpointer)"Audio");
 }
 
 static void create_spdif_output_settings_profi_stream(GtkWidget *box)
@@ -792,21 +766,20 @@ static void create_spdif_output_settings_profi_stream(GtkWidget *box)
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Stereophonic");
 	hw_profi_stream_stereo_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)profi_stream_toggled, 
-			  (gpointer)"Stereo");
+	g_signal_connect(radiobutton, "toggled",
+ 			  G_CALLBACK(profi_stream_toggled),
+ 			  (gpointer)"Stereo");
+
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Not indicated");
 	hw_profi_stream_notid_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)profi_stream_toggled, 
-			  (gpointer)"NOTID");
+	g_signal_connect(radiobutton, "toggled",
+ 			  G_CALLBACK(profi_stream_toggled),
+ 			  (gpointer)"NOTID");
 }
 
 static void create_spdif_output_settings_profi_emphasis(GtkWidget *box)
@@ -829,38 +802,34 @@ static void create_spdif_output_settings_profi_emphasis(GtkWidget *box)
 
 	radiobutton = gtk_radio_button_new_with_label(group, "No emphasis");
 	hw_profi_emphasis_none_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)profi_emphasis_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(profi_emphasis_toggled),
 			  (gpointer)"No");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "50/15us");
 	hw_profi_emphasis_5015_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)profi_emphasis_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(profi_emphasis_toggled),
 			  (gpointer)"5015");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "CCITT J.17");
 	hw_profi_emphasis_ccitt_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)profi_emphasis_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(profi_emphasis_toggled),
 			  (gpointer)"CCITT");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Not indicated");
 	hw_profi_emphasis_notid_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)profi_emphasis_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(profi_emphasis_toggled),
 			  (gpointer)"NOTID");
 }
 
@@ -906,7 +875,7 @@ static void create_spdif_output_settings_consumer_copyright(GtkWidget *box)
 	frame = gtk_frame_new("Copyright");
 	gtk_widget_show(frame);
 	gtk_box_pack_start(GTK_BOX(box), frame, FALSE, TRUE, 0);
-	
+
 	vbox = gtk_vbox_new(FALSE, 0);
 	gtk_widget_show(vbox);
 	gtk_container_add(GTK_CONTAINER(frame), vbox);
@@ -915,20 +884,18 @@ static void create_spdif_output_settings_consumer_copyright(GtkWidget *box)
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Copyrighted");
 	hw_consumer_copyright_on_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)consumer_copyright_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(consumer_copyright_toggled),
 			  (gpointer)"Copyright");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Copy permitted");
 	hw_consumer_copyright_off_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)consumer_copyright_toggled,
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(consumer_copyright_toggled),
 			  (gpointer)"Permitted");
 }
 
@@ -951,20 +918,18 @@ static void create_spdif_output_settings_consumer_copy(GtkWidget *box)
 	radiobutton = gtk_radio_button_new_with_label(group,
 						      "1-st generation");
 	hw_consumer_copy_1st_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)consumer_copy_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(consumer_copy_toggled),
 			  (gpointer)"1st");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Original");
 	hw_consumer_copy_original_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)consumer_copy_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(consumer_copy_toggled),
 			  (gpointer)"Original");
 }
 
@@ -986,20 +951,18 @@ static void create_spdif_output_settings_consumer_emphasis(GtkWidget *box)
 
 	radiobutton = gtk_radio_button_new_with_label(group, "No emphasis");
 	hw_consumer_emphasis_none_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)consumer_emphasis_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(consumer_emphasis_toggled),
 			  (gpointer)"No");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "50/15us");
 	hw_consumer_emphasis_5015_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)consumer_emphasis_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(consumer_emphasis_toggled),
 			  (gpointer)"5015");
 }
 
@@ -1021,38 +984,34 @@ static void create_spdif_output_settings_consumer_category(GtkWidget *box)
 
 	radiobutton = gtk_radio_button_new_with_label(group, "DAT");
 	hw_consumer_category_dat_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)consumer_category_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(consumer_category_toggled),
 			  (gpointer)"DAT");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "PCM encoder");
 	hw_consumer_category_pcm_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)consumer_category_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(consumer_category_toggled),
 			  (gpointer)"PCM");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "CD (ICE-908)");
 	hw_consumer_category_cd_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)consumer_category_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(consumer_category_toggled),
 			  (gpointer)"CD");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "General");
 	hw_consumer_category_general_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)consumer_category_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(consumer_category_toggled),
 			  (gpointer)"General");
 }
 
@@ -1122,22 +1081,20 @@ static void create_spdif_output_settings(GtkWidget *box)
 
 	radiobutton = gtk_radio_button_new_with_label(NULL, "Professional");
 	hw_spdif_professional_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(hbox), radiobutton, FALSE, FALSE, 0);
 	gtk_container_set_border_width(GTK_CONTAINER(radiobutton), 6);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)spdif_output_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(spdif_output_toggled),
 			  (gpointer)"Professional");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Consumer");
 	hw_spdif_consumer_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(hbox), radiobutton, FALSE, FALSE, 0);
 	gtk_container_set_border_width(GTK_CONTAINER(radiobutton), 6);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)spdif_output_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(spdif_output_toggled),
 			  (gpointer)"Consumer");
 
 
@@ -1174,34 +1131,41 @@ static void create_spdif_input_select(GtkWidget *box)
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Coaxial");
 	hw_spdif_input_coaxial_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)spdif_input_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(spdif_input_toggled),
 			  (gpointer)"Coaxial");
 
 	radiobutton = gtk_radio_button_new_with_label(group, "Optical");
 	hw_spdif_input_optical_radio = radiobutton;
-	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 	gtk_widget_show(radiobutton);
 	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-			  (GtkSignalFunc)spdif_input_toggled, 
+	g_signal_connect(radiobutton, "toggled",
+			  G_CALLBACK(spdif_input_toggled),
 			  (gpointer)"Optical");
 
-        radiobutton = gtk_radio_button_new_with_label(group, "Internal CD");
-        hw_spdif_switch_off_radio = radiobutton;
-        group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
+    radiobutton = gtk_radio_button_new_with_label(group, "Internal CD");
+    hw_spdif_switch_off_radio = radiobutton;
 	if(card_is_dmx6fire)
 	        gtk_widget_show(radiobutton);
         gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-        gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-                          (GtkSignalFunc)spdif_input_toggled,
-                          (gpointer)"Off");
+        g_signal_connect(radiobutton, "toggled",
+                      G_CALLBACK(spdif_input_toggled),
+                      (gpointer)"Off");
 
         if(hide)
-                gtk_widget_hide_all(frame);
+		{
+			GtkWidget *child;
+			GList *children = gtk_container_get_children(GTK_CONTAINER(frame));
+
+			for (GList *iter = children; iter != NULL; iter = iter->next) {
+			    child = GTK_WIDGET(iter->data);
+			    gtk_widget_hide(child);
+			}
+
+			g_list_free(children);  // Free the list of children
+		}
 }
 
 
@@ -1228,24 +1192,32 @@ static void create_phono_input(GtkWidget *box)
 
         radiobutton = gtk_radio_button_new_with_label(group, "Phono");
         hw_phono_input_on_radio = radiobutton;
-        group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
         gtk_widget_show(radiobutton);
         gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-        gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-                          (GtkSignalFunc)phono_input_toggled,
-                          (gpointer)"Phono");
+        g_signal_connect(radiobutton, "toggled",
+                      G_CALLBACK(phono_input_toggled),
+                      (gpointer)"Phono");
 
         radiobutton = gtk_radio_button_new_with_label(group, "Mic");
         hw_phono_input_off_radio = radiobutton;
-        group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
         gtk_widget_show(radiobutton);
         gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-        gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-                          (GtkSignalFunc)phono_input_toggled,
-                          (gpointer)"Mic");
+        g_signal_connect(radiobutton, "toggled",
+	                  G_CALLBACK(phono_input_toggled),
+                      (gpointer)"Mic");
 
         if(hide)
-                gtk_widget_hide_all(frame);
+		{
+			GtkWidget *child;
+			GList *children = gtk_container_get_children(GTK_CONTAINER(frame));
+
+			for (GList *iter = children; iter != NULL; iter = iter->next) {
+			    child = GTK_WIDGET(iter->data);
+			    gtk_widget_hide(child);
+			}
+
+			g_list_free(children);  // Free the list of children
+		}
 }
 
 static void create_input_interface(GtkWidget *box)
@@ -1262,7 +1234,6 @@ static void create_input_interface(GtkWidget *box)
         frame = gtk_frame_new("Line In Selector");
         gtk_widget_show(frame);
         gtk_box_pack_start(GTK_BOX(box), frame, FALSE, TRUE, 4);
-        //gtk_container_set_border_width(GTK_CONTAINER(frame), 6);
 
         vbox = gtk_vbox_new(FALSE, 0);
         gtk_widget_show(vbox);
@@ -1271,42 +1242,48 @@ static void create_input_interface(GtkWidget *box)
 
         radiobutton = gtk_radio_button_new_with_label(group, "Internal");
         input_interface_internal = radiobutton;
-        group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
         gtk_widget_show(radiobutton);
         gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-        gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-                          (GtkSignalFunc)analog_input_select_toggled,
-                          (gpointer)"Internal");
+        g_signal_connect(radiobutton, "toggled",
+                      G_CALLBACK(analog_input_select_toggled),
+                      (gpointer)"Internal");
 
         radiobutton = gtk_radio_button_new_with_label(group, "Front Input");
         input_interface_front_input = radiobutton;
-        group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
         gtk_widget_show(radiobutton);
         gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-        gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-                          (GtkSignalFunc)analog_input_select_toggled,
-                          (gpointer)"Front Input");
+        g_signal_connect(radiobutton, "toggled",
+                      G_CALLBACK(analog_input_select_toggled),
+                      (gpointer)"Front Input");
 
         radiobutton = gtk_radio_button_new_with_label(group, "Rear Input");
         input_interface_rear_input = radiobutton;
-        group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
         gtk_widget_show(radiobutton);
         gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-        gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-                          (GtkSignalFunc)analog_input_select_toggled,
-                          (gpointer)"Rear Input");
+        g_signal_connect(radiobutton, "toggled",
+                      G_CALLBACK(analog_input_select_toggled),
+                      (gpointer)"Rear Input");
 
         radiobutton = gtk_radio_button_new_with_label(group, "Wavetable");
         input_interface_wavetable = radiobutton;
-        group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
         gtk_widget_show(radiobutton);
         gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);
-        gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-                          (GtkSignalFunc)analog_input_select_toggled,
-                          (gpointer)"Wave Table");
+        g_signal_connect(radiobutton, "toggled",
+                      G_CALLBACK(analog_input_select_toggled),
+                      (gpointer)"Wave Table");
 
         if(hide)
-                gtk_widget_hide_all(frame);
+		{
+			GtkWidget *child;
+			GList *children = gtk_container_get_children(GTK_CONTAINER(frame));
+
+			for (GList *iter = children; iter != NULL; iter = iter->next) {
+			    child = GTK_WIDGET(iter->data);
+			    gtk_widget_hide(child);
+			}
+
+			g_list_free(children);  // Free the list of children
+		}
 }
 
 static void create_hardware(GtkWidget *main, GtkWidget *notebook, int page)
@@ -1447,7 +1424,7 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
 	GtkWidget *hbox;
 	GtkWidget *vbox;
 	GtkWidget *frame;
-	GtkObject *adj;
+	GtkAdjustment *adj;
 	GtkWidget *vscale;
 	GtkWidget *radiobutton;
 	GSList *group;
@@ -1498,7 +1475,6 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
 		sprintf(name, "DAC %d", i);
 		frame = gtk_frame_new(name);
 		gtk_widget_show(frame);
-		//gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
 		gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, TRUE, 0);
 		gtk_container_set_border_width(GTK_CONTAINER(frame), 6);
 
@@ -1521,8 +1497,8 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
 		gtk_widget_show(vscale);
 		gtk_box_pack_start(GTK_BOX(vbox), vscale, TRUE, TRUE, 6);
 		gtk_scale_set_digits(GTK_SCALE(vscale), 0);
-		gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
-				   GTK_SIGNAL_FUNC(dac_volume_adjust), 
+		g_signal_connect(adj, "value_changed",
+				   G_CALLBACK(dac_volume_adjust),
 				   (gpointer)(long)(i));
 
 	        label = gtk_label_new("000");
@@ -1535,16 +1511,15 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
 			continue;
 		group = NULL;
 		for (j = 0; j < envy_dac_sense_items(); j++) {
-		  radiobutton = gtk_radio_button_new_with_label(group, 
+		    radiobutton = gtk_radio_button_new_with_label(group, 
 								envy_dac_sense_enum_name(j));
 			av_dac_sense_radio[i][j] = radiobutton;
 			gtk_widget_show(radiobutton);
-			gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-					  (GtkSignalFunc)dac_sense_toggled, 
-					   (gpointer)(long)((i << 8) + j));
+			g_signal_connect(radiobutton, "toggled",
+						G_CALLBACK(dac_sense_toggled),
+						(gpointer)(long)((i << 8) + j));
 			gtk_box_pack_start(GTK_BOX(vbox), 
 					    radiobutton, FALSE, TRUE, 0);
-			group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 		}
 	}
 
@@ -1554,7 +1529,6 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
 		sprintf(name, "ADC %d", i);
 		frame = gtk_frame_new(name);
 		gtk_widget_show(frame);
-		//gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
 		gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, TRUE, 0);
 		gtk_container_set_border_width(GTK_CONTAINER(frame), 6);
 
@@ -1578,8 +1552,8 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
 		gtk_box_pack_start(GTK_BOX(vbox), vscale, TRUE, TRUE, 6);
 		gtk_scale_set_value_pos(GTK_SCALE(vscale), GTK_POS_BOTTOM);
 		gtk_scale_set_digits(GTK_SCALE(vscale), 0);
-		gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
-				   GTK_SIGNAL_FUNC(adc_volume_adjust), 
+		g_signal_connect(adj, "value_changed",
+				   G_CALLBACK(adc_volume_adjust),
 				   (gpointer)(long)(i));
 
 	        label = gtk_label_new("000");
@@ -1595,12 +1569,11 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
 								      envy_adc_sense_enum_name(j));
 			av_adc_sense_radio[i][j] = radiobutton;
 			gtk_widget_show(radiobutton);
-			gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",
-					  (GtkSignalFunc)adc_sense_toggled, 
-					   (gpointer)(long)((i << 8) + j));
+			g_signal_connect(radiobutton, "toggled",
+					  G_CALLBACK(adc_sense_toggled),
+					  (gpointer)(long)((i << 8) + j));
 			gtk_box_pack_start(GTK_BOX(vbox), 
 					    radiobutton, FALSE, TRUE, 0);
-			group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));
 		}
 	}
 
@@ -1610,7 +1583,6 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
 		sprintf(name, "IPGA %d", i);
 		frame = gtk_frame_new(name);
 		gtk_widget_show(frame);
-		//gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
 		gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, TRUE, 0);
 		gtk_container_set_border_width(GTK_CONTAINER(frame), 6);
 
@@ -1634,8 +1606,8 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
 		gtk_box_pack_start(GTK_BOX(vbox), vscale, TRUE, TRUE, 6);
 		gtk_scale_set_value_pos(GTK_SCALE(vscale), GTK_POS_BOTTOM);
 		gtk_scale_set_digits(GTK_SCALE(vscale), 0);
-		gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
-				   GTK_SIGNAL_FUNC(ipga_volume_adjust), 
+		g_signal_connect(adj, "value_changed",
+				   G_CALLBACK(ipga_volume_adjust),
 				   (gpointer)(long)(i));
 
 	        label = gtk_label_new("000");
@@ -1671,19 +1643,20 @@ int delete_card_number(GtkWidget *delete_button)
 	gint card_nr;
 	gint index;
 
-	if (!(GTK_TOGGLE_BUTTON (delete_button)->active))
+	if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(delete_button)))
 		return EXIT_SUCCESS;
 
-	card_nr = GTK_ADJUSTMENT (card_number_adj)->value;
+	card_nr = gtk_adjustment_get_value(GTK_ADJUSTMENT(card_number_adj));
+
 	if ((card_nr < 0) || (card_nr >= MAX_CARD_NUMBERS)) {
 		fprintf(stderr, "card number not in [0 ... %d]\n", MAX_CARD_NUMBERS - 1);
-		gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (delete_button), FALSE);
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(delete_button), FALSE);
 		return -EINVAL;
 	}
 
 	res = delete_card(card_number, profiles_file_name);
 	if (res < 0) {
-		gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (delete_button), FALSE);
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (delete_button), FALSE);
 		return res;
 	}
 	if (card_nr == card_number) {
@@ -1693,7 +1666,7 @@ int delete_card_number(GtkWidget *delete_button)
 		}
 	}
 
-	gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (delete_button), FALSE);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (delete_button), FALSE);
 
 	return EXIT_SUCCESS;
 }
@@ -1712,18 +1685,18 @@ int save_active_profile(GtkWidget *save_button)
 	gint res;
 	gint index;
 
-	if (!(GTK_TOGGLE_BUTTON (save_button)->active))
+	if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(save_button)))
 		return EXIT_SUCCESS;
 	if ((index = index_active_profile()) >= 0) {
 		res = save_restore(ALSACTL_OP_STORE, index + 1, card_number, profiles_file_name, \
 			gtk_entry_get_text(GTK_ENTRY (profiles_toggle_buttons[index].entry)));
 	} else {
 		fprintf(stderr, "No active profile found.\n");
-		gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (save_button), FALSE);
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (save_button), FALSE);
 		return -EXIT_FAILURE;
 	}
 
-	gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (save_button), FALSE);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (save_button), FALSE);
 
 	return res;
 }
@@ -1734,21 +1707,22 @@ void entry_toggle_editable(GtkWidget *toggle_button, GtkWidget *entry)
 	gint profile_number;
 
 	if (active_button == toggle_button) {
-		gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (toggle_button), TRUE);
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (toggle_button), TRUE);
 		gtk_editable_set_editable(GTK_EDITABLE (entry), TRUE);
 		gtk_widget_grab_focus(entry);
 		return;
-	} else if (GTK_TOGGLE_BUTTON (toggle_button)->active) {
+	} else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggle_button))) {
 		active_button = toggle_button;
 	}
-	gtk_editable_set_editable(GTK_EDITABLE (entry), GTK_TOGGLE_BUTTON (toggle_button)->active);
-	if (GTK_TOGGLE_BUTTON (toggle_button)->active) {
+	gtk_editable_set_editable(GTK_EDITABLE(entry), gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggle_button)));
+
+	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggle_button))) {
 		gtk_widget_grab_focus(entry);
 		profile_number = NOTFOUND;
 		for (index = 0; index < MAX_PROFILES; index++)
 		{
 			if (profiles_toggle_buttons[index].toggle_button != toggle_button) {
-				gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (profiles_toggle_buttons[index].toggle_button), FALSE);
+				gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (profiles_toggle_buttons[index].toggle_button), FALSE);
 			} else {
 				profile_number = index + 1;
 			}
@@ -1774,18 +1748,18 @@ static GtkWidget *toggle_button_entry(const GtkWidget *parent, const gchar *prof
 	box = gtk_hbox_new(FALSE, 0);
 
 	toggle_button = gtk_toggle_button_new();
-	gtk_container_border_width(GTK_CONTAINER(toggle_button), 3);
+	gtk_container_set_border_width(GTK_CONTAINER(toggle_button), 3);
 
 	profiles_toggle_buttons[index].entry = entry_label = gtk_entry_new();
 	gtk_entry_set_max_length(GTK_ENTRY (entry_label), MAX_PROFILE_NAME_LENGTH);
 	gtk_entry_set_text(GTK_ENTRY (entry_label), profile_name);
 	/* only the active profile can be modified */
 	gtk_editable_set_editable(GTK_EDITABLE (entry_label), FALSE);
-	gtk_signal_connect(GTK_OBJECT (entry_label), "activate",
-			 GTK_SIGNAL_FUNC (enter_callback),
+	g_signal_connect(entry_label, "activate",
+			 G_CALLBACK(enter_callback),
 			 (gpointer) entry_label);
-	gtk_signal_connect(GTK_OBJECT (toggle_button), "toggled",
-			 GTK_SIGNAL_FUNC (entry_toggle_editable),
+	g_signal_connect(toggle_button, "toggled",
+			 G_CALLBACK(entry_toggle_editable),
 			 (gpointer) entry_label);
 
 	gtk_box_pack_start(GTK_BOX (box), entry_label, FALSE, FALSE, 20);
@@ -1806,7 +1780,7 @@ static void create_profiles(GtkWidget *main, GtkWidget *notebook, int page)
 	GtkWidget *hbox1;
 	GtkWidget *save_button;
 	GtkWidget *delete_button;
-	GtkObject *card_button_adj;
+	GtkAdjustment *card_button_adj;
 	GtkWidget *card_button;
 	GtkWidget *scrolledwindow;
 	GtkWidget *viewport;
@@ -1847,18 +1821,20 @@ static void create_profiles(GtkWidget *main, GtkWidget *notebook, int page)
 	/* Create button boxes */
 	vbox1 = gtk_vbutton_box_new();
 
-	gtk_vbutton_box_set_spacing_default(0);
+	gtk_box_set_spacing(GTK_BOX(delete_button), 0);
+
+
 	for (index = 0; index < MAX_PROFILES; index++)	{
 		profile_name = get_profile_name(index + 1, card_number, profiles_file_name);
 		profiles_toggle_buttons[index].toggle_button = toggle_button_entry(window, profile_name, index);
 		gtk_box_pack_start(GTK_BOX (vbox1), profiles_toggle_buttons[index].toggle_button, FALSE, FALSE, 0);
 	}
 	gtk_widget_show(vbox1);
-	gtk_container_border_width(GTK_CONTAINER(vbox1), 6);
+	gtk_container_set_border_width(GTK_CONTAINER(vbox1), 6);
 
 	vbox2 = gtk_vbutton_box_new();
 	gtk_widget_show(vbox2);
-	gtk_container_border_width(GTK_CONTAINER(vbox2), 50);
+	gtk_container_set_border_width(GTK_CONTAINER(vbox2), 50);
 
 	hbox1 = gtk_hbox_new(FALSE, 0);
 	gtk_widget_show(hbox1);
@@ -1880,15 +1856,15 @@ static void create_profiles(GtkWidget *main, GtkWidget *notebook, int page)
 	delete_button = gtk_toggle_button_new_with_label("Delete card from profiles");
 	gtk_widget_show(delete_button);
 	gtk_box_pack_start(GTK_BOX (vbox2), delete_button, FALSE, FALSE, 20);
-	gtk_signal_connect(GTK_OBJECT (delete_button), "toggled",
-			 GTK_SIGNAL_FUNC (delete_card_number),
+	g_signal_connect(delete_button, "toggled",
+			 G_CALLBACK(delete_card_number),
 			 NULL);
 
 	save_button = gtk_toggle_button_new_with_label("Save active profile");
 	gtk_widget_show(save_button);
 	gtk_box_pack_end(GTK_BOX (vbox2), save_button, FALSE, FALSE, 20);
-	gtk_signal_connect(GTK_OBJECT (save_button), "toggled",
-			 GTK_SIGNAL_FUNC (save_active_profile),
+	g_signal_connect(save_button, "toggled",
+			 G_CALLBACK(save_active_profile),
 			 NULL);
 
 	gtk_container_add(GTK_CONTAINER(hbox), vbox1);
@@ -1915,7 +1891,7 @@ static void create_profiles(GtkWidget *main, GtkWidget *notebook, int page)
 			profile_number = get_profile_number(default_profile, card_number, profiles_file_name);
 		}
 		if ((profile_number > 0) && (profile_number <= MAX_PROFILES)) {
-			gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (profiles_toggle_buttons[profile_number - 1].toggle_button), TRUE);
+			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (profiles_toggle_buttons[profile_number - 1].toggle_button), TRUE);
 		} else {
 			fprintf(stderr, "Cannot find profile '%s' for card '%d'.\n", default_profile, card_number);
 		}
@@ -1937,7 +1913,6 @@ static void create_outer(GtkWidget *main)
 	gtk_box_pack_start(GTK_BOX(main), vbox, FALSE, FALSE, 0);
 
 	label = gtk_label_new(" Rt-clk Menu >>");
-	//gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 	gtk_widget_show(label);
 	gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 3);
 	frame = gtk_frame_new("Digital Mixer");
@@ -1949,7 +1924,7 @@ static void create_outer(GtkWidget *main)
 
 	vbox = gtk_vbox_new(FALSE, 0);
 	gtk_widget_show(vbox);
-	gtk_container_add(GTK_CONTAINER(frame), vbox);	
+	gtk_container_add(GTK_CONTAINER(frame), vbox);
 
 	hbox1 = gtk_hbox_new(FALSE, 0);
 	gtk_widget_show(hbox1);
@@ -1960,14 +1935,14 @@ static void create_outer(GtkWidget *main)
 	gtk_widget_set_name(drawing, "DigitalMixer");
 	gtk_box_pack_start(GTK_BOX(hbox1), drawing, TRUE, FALSE, 6);
 	if (tall_equal_mixer_ht > 1 ) {
-		gtk_widget_set_usize(drawing, 60, 264 + 60 * (tall_equal_mixer_ht - 1));
+		gtk_widget_set_size_request(drawing, 60, 264 + 60 * (tall_equal_mixer_ht - 1));
 	} else {
-		gtk_widget_set_usize(drawing, 60, 264);
+		gtk_widget_set_size_request(drawing, 60, 264);
 	}
-	gtk_signal_connect(GTK_OBJECT(drawing), "expose_event",
-			   (GtkSignalFunc)level_meters_expose_event, NULL);
-	gtk_signal_connect(GTK_OBJECT(drawing), "configure_event",
-			   (GtkSignalFunc)level_meters_configure_event, NULL);
+	g_signal_connect(drawing, "expose_event",
+			   G_CALLBACK(level_meters_expose_event), NULL);
+	g_signal_connect(drawing, "configure_event",
+			   G_CALLBACK(level_meters_configure_event), NULL);
 	gtk_widget_set_events(drawing, GDK_EXPOSURE_MASK);
 	gtk_widget_show(drawing);
 
@@ -1991,8 +1966,8 @@ static void create_outer(GtkWidget *main)
 	gtk_widget_show(mixer_clear_peaks_button);
 	gtk_box_pack_start(GTK_BOX(vbox), mixer_clear_peaks_button, TRUE, FALSE, 0);
 	gtk_container_set_border_width(GTK_CONTAINER(mixer_clear_peaks_button), 4);
-	gtk_signal_connect(GTK_OBJECT(mixer_clear_peaks_button), "clicked",
-			   GTK_SIGNAL_FUNC(level_meters_reset_peaks), NULL);
+	g_signal_connect(mixer_clear_peaks_button, "clicked",
+			   G_CALLBACK(level_meters_reset_peaks), NULL);
 }/* End create_outer  */
 
 static void create_blank(GtkWidget *main, GtkWidget *notebook, int page)
@@ -2258,8 +2233,8 @@ int main(int argc, char **argv)
         /* Create the main window */
         window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
         gtk_window_set_title(GTK_WINDOW(window), title);
-        gtk_signal_connect(GTK_OBJECT (window), "delete_event", 
-                           (GtkSignalFunc) gtk_main_quit, NULL);
+        g_signal_connect(window, "delete_event",
+                       G_CALLBACK(gtk_main_quit), NULL);
         signal(SIGINT, (void *)gtk_main_quit);
 
 	gtk_window_set_default_size(GTK_WINDOW(window), wwidth, 300);
@@ -2294,27 +2269,31 @@ int main(int argc, char **argv)
 		pfds = alloca(sizeof(*pfds) * npfds);
 		npfds = snd_ctl_poll_descriptors(ctl, pfds, npfds);
 		for (i = 0; i < npfds; i++)
-			gdk_input_add(pfds[i].fd,
-				      GDK_INPUT_READ,
-				      control_input_callback,
-				      ctl);
+		{
+			GIOChannel *channel = g_io_channel_unix_new(pfds[i].fd);
+			g_io_add_watch(channel, G_IO_IN, control_input_callback, NULL);
+			g_io_channel_unref(channel);
+		}
+
 		snd_ctl_subscribe_events(ctl, 1);
 	}
 	if (midi_fd >= 0) {
-		gdk_input_add(midi_fd, GDK_INPUT_READ, midi_process, NULL);
+		GIOChannel *channel = g_io_channel_unix_new(midi_fd);
+		g_io_add_watch(channel, G_IO_IN, midi_process, NULL);
+		g_io_channel_unref(channel);  // Don't forget to unref the GIOChannel when done
 	}
-	gtk_timeout_add(40, level_meters_timeout_callback, NULL);
-	gtk_timeout_add(100, master_clock_status_timeout_callback, NULL);
-	gtk_timeout_add(100, internal_clock_status_timeout_callback, NULL);
-	gtk_timeout_add(100, rate_locking_status_timeout_callback, NULL);
-	gtk_timeout_add(100, rate_reset_status_timeout_callback, NULL);
+	g_timeout_add(40, level_meters_timeout_callback, NULL);
+	g_timeout_add(100, master_clock_status_timeout_callback, NULL);
+	g_timeout_add(100, internal_clock_status_timeout_callback, NULL);
+	g_timeout_add(100, rate_locking_status_timeout_callback, NULL);
+	g_timeout_add(100, rate_reset_status_timeout_callback, NULL);
 
 
 	gtk_widget_show(window);
 
 	level_meters_postinit();
 	mixer_postinit();
-	patchbay_postinit();	
+	patchbay_postinit();
 	hardware_postinit();
 	analog_volume_postinit();
 
diff --git a/envy24control/envy24control.h b/envy24control/envy24control.h
index f5c1e39..da75645 100644
--- a/envy24control/envy24control.h
+++ b/envy24control/envy24control.h
@@ -85,7 +85,7 @@ extern ice1712_eeprom_t card_eeprom;
 extern GtkWidget *mixer_mix_drawing;
 extern GtkWidget *mixer_clear_peaks_button;
 extern GtkWidget *mixer_drawing[20];
-extern GtkObject *mixer_adj[20][2];
+extern GtkAdjustment *mixer_adj[20][2];
 extern GtkWidget *mixer_vscale[20][2];
 extern GtkWidget *mixer_solo_toggle[20][2];
 extern GtkWidget *mixer_mute_toggle[20][2];
@@ -108,7 +108,7 @@ extern GtkWidget *hw_master_clock_actual_rate_label;
 extern GtkWidget *hw_rate_locking_check;
 extern GtkWidget *hw_rate_reset_check;
 
-extern GtkObject *hw_volume_change_adj;
+extern GtkAdjustment *hw_volume_change_adj;
 extern GtkWidget *hw_volume_change_spin;
 
 extern GtkWidget *hw_spdif_profi_nonaudio_radio;
@@ -151,9 +151,9 @@ extern GtkWidget *input_interface_internal;
 extern GtkWidget *input_interface_front_input;
 extern GtkWidget *input_interface_rear_input;
 extern GtkWidget *input_interface_wavetable;
-extern GtkObject *av_dac_volume_adj[];
-extern GtkObject *av_adc_volume_adj[];
-extern GtkObject *av_ipga_volume_adj[];
+extern GtkAdjustment *av_dac_volume_adj[];
+extern GtkAdjustment *av_adc_volume_adj[];
+extern GtkAdjustment *av_ipga_volume_adj[];
 extern GtkLabel *av_dac_volume_label[];
 extern GtkLabel *av_adc_volume_label[];
 extern GtkLabel *av_ipga_volume_label[];
@@ -238,6 +238,6 @@ void ipga_volume_adjust(GtkAdjustment *adj, gpointer data);
 void dac_sense_toggled(GtkWidget *togglebutton, gpointer data);
 void adc_sense_toggled(GtkWidget *togglebutton, gpointer data);
 
-void control_input_callback(gpointer data, gint source, GdkInputCondition condition);
-void mixer_input_callback(gpointer data, gint source, GdkInputCondition condition);
+gint control_input_callback(GIOChannel *source, GIOCondition condition, gpointer data);
+gint mixer_input_callback(GIOChannel *source, GIOCondition condition, gpointer data);
 
diff --git a/envy24control/hardware.c b/envy24control/hardware.c
index 7e0094e..611f9fd 100644
--- a/envy24control/hardware.c
+++ b/envy24control/hardware.c
@@ -39,13 +39,13 @@ static inline int is_update_needed(void);
 
 static int is_active(GtkWidget *widget)
 {
-	return GTK_TOGGLE_BUTTON(widget)->active ? 1 : 0;
+	return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 }
 
 void master_clock_update(void)
 {
 	int err, rate, need_default_update;
-	
+
 	if ((err = snd_ctl_elem_read(ctl, internal_clock)) < 0)
 		g_print("Unable to read Internal Clock state: %s\n", snd_strerror(err));
 	if ((err = snd_ctl_elem_read(ctl, internal_clock_default)) < 0)
@@ -343,7 +343,7 @@ void rate_reset_toggled(GtkWidget *togglebutton, gpointer data)
 void volume_change_rate_update(void)
 {
 	int err;
-	
+
 	if ((err = snd_ctl_elem_read(ctl, volume_rate)) < 0)
 		g_print("Unable to read volume change rate: %s\n", snd_strerror(err));
 	gtk_adjustment_set_value(GTK_ADJUSTMENT(hw_volume_change_adj),
@@ -353,8 +353,8 @@ void volume_change_rate_update(void)
 void volume_change_rate_adj(GtkAdjustment *adj, gpointer data)
 {
 	int err;
-	
-	snd_ctl_elem_value_set_integer(volume_rate, 0, adj->value);
+	double adjustment_value = gtk_adjustment_get_value(adj);
+	snd_ctl_elem_value_set_integer(volume_rate, 0, adjustment_value);
 	if ((err = snd_ctl_elem_write(ctl, volume_rate)) < 0)
 		g_print("Unable to write volume change rate: %s\n", snd_strerror(err));
 }
@@ -363,7 +363,7 @@ void spdif_output_update(void)
 {
 	int err;
 	snd_aes_iec958_t iec958;
-	
+
 	if ((err = snd_ctl_elem_read(ctl, spdif_output)) < 0) {
 		if (err == -ENOENT)
 			return;
@@ -550,7 +550,7 @@ void consumer_category_toggled(GtkWidget *togglebutton, gpointer data)
 	char *str = (char *)data;
 	snd_aes_iec958_t iec958;
 
-	snd_ctl_elem_value_get_iec958(spdif_output, &iec958);	
+	snd_ctl_elem_value_get_iec958(spdif_output, &iec958);
 	if (!is_active(togglebutton))
 		return;
 	if (iec958.status[0] & IEC958_AES0_PROFESSIONAL)
@@ -598,7 +598,7 @@ void spdif_output_toggled(GtkWidget *togglebutton, gpointer data)
 			page = 1;
 		}
 		spdif_output_write();
-		gtk_notebook_set_page(GTK_NOTEBOOK(hw_spdif_output_notebook), page);
+		gtk_notebook_set_current_page(GTK_NOTEBOOK(hw_spdif_output_notebook), page);
 		spdif_output_update();
 	}
 }
@@ -635,7 +635,7 @@ void spdif_input_toggled(GtkWidget *togglebutton, gpointer data)
 {
 	int err;
 	char *str = (char *)data;
-	
+
 	if (!is_active(togglebutton))
 		return;
 	if (!strcmp(str, "Off"))
diff --git a/envy24control/levelmeters.c b/envy24control/levelmeters.c
index 5933721..616c56a 100644
--- a/envy24control/levelmeters.c
+++ b/envy24control/levelmeters.c
@@ -19,13 +19,13 @@
 
 #include "envy24control.h"
 
-static GdkGC *penGreenShadow[21] = { NULL, };
-static GdkGC *penGreenLight[21] = { NULL, };
-static GdkGC *penOrangeShadow[21] = { NULL, };
-static GdkGC *penOrangeLight[21] = { NULL, };
-static GdkGC *penRedShadow[21] = { NULL, };
-static GdkGC *penRedLight[21] = { NULL, };
-static GdkPixmap *pixmap[21] = { NULL, };
+static GdkRGBA *penGreenShadow[21] = { NULL, };
+static GdkRGBA *penGreenLight[21] = { NULL, };
+static GdkRGBA *penOrangeShadow[21] = { NULL, };
+static GdkRGBA *penOrangeLight[21] = { NULL, };
+static GdkRGBA *penRedShadow[21] = { NULL, };
+static GdkRGBA *penRedLight[21] = { NULL, };
+static GdkPixbuf *pixmap[21] = { NULL, };
 static snd_ctl_elem_value_t *peaks;
 
 extern int input_channels, output_channels, pcm_output_channels, spdif_channels, view_spdif_playback;
@@ -41,7 +41,7 @@ static void update_peak_switch(void)
 static void get_levels(int idx, int *l1, int *l2)
 {
 	*l1 = *l2 = 0;
-	
+
 	if (idx == 0) {
 		*l1 = snd_ctl_elem_value_get_integer(peaks, 20);
 		*l2 = snd_ctl_elem_value_get_integer(peaks, 21);
@@ -50,19 +50,14 @@ static void get_levels(int idx, int *l1, int *l2)
 	}
 }
 
-static GdkGC *get_pen(int idx, int nRed, int nGreen, int nBlue)
+static GdkRGBA *get_pen(int idx, int nRed, int nGreen, int nBlue)
 {
-	GdkColor *c;
-	GdkGC *gc;
-	
-	c = (GdkColor *)g_malloc(sizeof(GdkColor));
-	c->red = nRed;
-	c->green = nGreen;
-	c->blue = nBlue;
-	gdk_color_alloc(gdk_colormap_get_system(), c);
-	gc = gdk_gc_new(pixmap[idx]);
-	gdk_gc_set_foreground(gc, c);
-	return gc;
+    GdkRGBA *c = g_malloc(sizeof(GdkRGBA));
+    c->red = nRed / 255.0;
+    c->green = nGreen / 255.0;
+    c->blue = nBlue / 255.0;
+    c->alpha = 1.0; // Fully opaque
+    return c;
 }
 
 static int get_index(const gchar *name)
@@ -91,61 +86,129 @@ static void redraw_meters(int idx, int width, int height, int level1, int level2
 	int segs_on1 = ((segments * level1) + 128) / 255;
 	int segs_on2 = ((segments * level2) + 128) / 255;
 
+    GdkPixbuf *pixbuf = pixmap[idx];
+    // Create a Cairo surface from the GdkPixbuf
+    cairo_surface_t *surface = gdk_cairo_surface_create_from_pixbuf(pixbuf, 0, NULL);
+    // Create a Cairo context from the surface
+    cairo_t *cr = cairo_create(surface);
+
 	// g_print("segs_on1 = %i (%i), segs_on2 = %i (%i)\n", segs_on1, level1, segs_on2, level2);
 	for (seg = 0; seg < green_segments; seg++) {
-		gdk_draw_rectangle(pixmap[idx],
-				   segs_on1 > 0 ? penGreenLight[idx] : penGreenShadow[idx],
-				   TRUE,
-				   6, 3 + ((segments - seg - 1) * 4),
-				   segment_width,
-				   3);
+		// Set the drawing color
+		if (segs_on1 > 0) {
+		    cairo_set_source_rgb(cr, penGreenLight[idx]->red,
+		                             penGreenLight[idx]->green,
+		                             penGreenLight[idx]->blue);
+		} else {
+		    cairo_set_source_rgb(cr, penGreenShadow[idx]->red,
+		                             penGreenShadow[idx]->green,
+		                             penGreenShadow[idx]->blue);
+		}
+
+		// Set the rectangle and draw
+		cairo_rectangle(cr, 6, 3 + ((segments - seg - 1) * 4), segment_width, 3);
+		cairo_fill(cr);
+
+
 		if (stereo)
-			gdk_draw_rectangle(pixmap[idx],
-					   segs_on2 > 0 ? penGreenLight[idx] : penGreenShadow[idx],
-					   TRUE,
-					   2 + (width / 2),
-					   3 + ((segments - seg - 1) * 4),
-					   segment_width,
-					   3);
+		{
+			// Set the drawing color
+			if (segs_on2 > 0) {
+			    cairo_set_source_rgb(cr, penGreenLight[idx]->red,
+			                             penGreenLight[idx]->green,
+			                             penGreenLight[idx]->blue);
+			} else {
+			    cairo_set_source_rgb(cr, penGreenShadow[idx]->red,
+			                             penGreenShadow[idx]->green,
+			                             penGreenShadow[idx]->blue);
+			}
+
+			// Set the rectangle and draw
+			cairo_rectangle(cr, 2 + (width / 2), 3 + ((segments - seg - 1) * 4), segment_width, 3);
+			cairo_fill(cr);
+		}
 		segs_on1--;
 		segs_on2--;
+
 	}
 	for (seg = green_segments; seg < green_segments + orange_segments; seg++) {
-		gdk_draw_rectangle(pixmap[idx],
-				   segs_on1 > 0 ? penOrangeLight[idx] : penOrangeShadow[idx],
-				   TRUE,
-				   6, 3 + ((segments - seg - 1) * 4),
-				   segment_width,
-				   3);
+		// Set the drawing color
+		if (segs_on1 > 0) {
+		    cairo_set_source_rgb(cr, penOrangeLight[idx]->red,
+		                             penOrangeLight[idx]->green,
+		                             penOrangeLight[idx]->blue);
+		} else {
+		    cairo_set_source_rgb(cr, penOrangeShadow[idx]->red,
+		                             penOrangeShadow[idx]->green,
+		                             penOrangeShadow[idx]->blue);
+		}
+
+		// Set the rectangle and draw
+		cairo_rectangle(cr, 6, 3 + ((segments - seg - 1) * 4), segment_width, 3);
+		cairo_fill(cr);
+
 		if (stereo)
-			gdk_draw_rectangle(pixmap[idx],
-					   segs_on2 > 0 ? penOrangeLight[idx] : penOrangeShadow[idx],
-					   TRUE,
-					   2 + (width / 2),
-					   3 + ((segments - seg - 1) * 4),
-					   segment_width,
-					   3);
+		{
+
+			// Set the drawing color
+			if (segs_on2 > 0) {
+			    cairo_set_source_rgb(cr, penOrangeLight[idx]->red,
+			                             penOrangeLight[idx]->green,
+			                             penOrangeLight[idx]->blue);
+			} else {
+			    cairo_set_source_rgb(cr, penOrangeShadow[idx]->red,
+			                             penOrangeShadow[idx]->green,
+			                             penOrangeShadow[idx]->blue);
+			}
+
+			// Set the rectangle and draw
+			cairo_rectangle(cr, 2 + (width / 2), 3 + ((segments - seg - 1) * 4), segment_width, 3);
+			cairo_fill(cr);
+		}
+
 		segs_on1--;
 		segs_on2--;
 	}
 	for (seg = green_segments + orange_segments; seg < segments; seg++) {
-		gdk_draw_rectangle(pixmap[idx],
-				   segs_on1 > 0 ? penRedLight[idx] : penRedShadow[idx],
-				   TRUE,
-				   6, 3 + ((segments - seg - 1) * 4),
-				   segment_width,
-				   3);
+
+		// Set the drawing color
+		if (segs_on1 > 0) {
+		    cairo_set_source_rgb(cr, penRedLight[idx]->red,
+		                             penRedLight[idx]->green,
+		                             penRedLight[idx]->blue);
+		} else {
+		    cairo_set_source_rgb(cr, penRedShadow[idx]->red,
+		                             penRedShadow[idx]->green,
+		                             penRedShadow[idx]->blue);
+		}
+
+		// Set the rectangle and draw
+		cairo_rectangle(cr, 6, 3 + ((segments - seg - 1) * 4), segment_width, 3);
+		cairo_fill(cr);
+
 		if (stereo)
-			gdk_draw_rectangle(pixmap[idx],
-					   segs_on2 > 0 ? penRedLight[idx] : penRedShadow[idx],
-					   TRUE,
-					   2 + (width / 2),
-					   3 + ((segments - seg - 1) * 4),
-					   segment_width,
-					   3);
+		{
+			// Set the drawing color based on segs_on2
+			if (segs_on2 > 0) {
+			    cairo_set_source_rgb(cr, penRedLight[idx]->red,
+			                             penRedLight[idx]->green,
+			                             penRedLight[idx]->blue);
+			} else {
+			    cairo_set_source_rgb(cr, penRedShadow[idx]->red,
+			                             penRedShadow[idx]->green,
+			                             penRedShadow[idx]->blue);
+			}
+
+			// Set the rectangle and draw
+			cairo_rectangle(cr, 2 + (width / 2), 3 + ((segments - seg - 1) * 4), segment_width, 3);
+			cairo_fill(cr);
+		}
+
 		segs_on1--;
 		segs_on2--;
 	}
+	// Clean up the Cairo context
+	cairo_destroy(cr);
 }
 
 gint level_meters_configure_event(GtkWidget *widget, GdkEventConfigure *event)
@@ -153,25 +216,45 @@ gint level_meters_configure_event(GtkWidget *widget, GdkEventConfigure *event)
 	int idx = get_index(gtk_widget_get_name(widget));
 
 	if (pixmap[idx] != NULL)
-		gdk_pixmap_unref(pixmap[idx]);
-	pixmap[idx] = gdk_pixmap_new(widget->window,
-				     widget->allocation.width,
-				     widget->allocation.height,
-				     -1);
+		g_object_unref(pixmap[idx]);
+
+	cairo_surface_t *surface = gdk_window_create_similar_surface(gtk_widget_get_window(widget),
+	    CAIRO_FORMAT_ARGB32, gtk_widget_get_allocated_width(widget), gtk_widget_get_allocated_height(widget));
+	// Create a GdkPixbuf from the cairo surface
+	pixmap[idx] = gdk_pixbuf_get_from_surface(surface, 0, 0, gtk_widget_get_allocated_width(widget), gtk_widget_get_allocated_height(widget));
+
 	penGreenShadow[idx] = get_pen(idx, 0, 0x77ff, 0);
 	penGreenLight[idx] = get_pen(idx, 0, 0xffff, 0);
 	penOrangeShadow[idx] = get_pen(idx, 0xddff, 0x55ff, 0);
 	penOrangeLight[idx] = get_pen(idx, 0xffff, 0x99ff, 0);
 	penRedShadow[idx] = get_pen(idx, 0xaaff, 0, 0);
 	penRedLight[idx] = get_pen(idx, 0xffff, 0, 0);
-	gdk_draw_rectangle(pixmap[idx],
-			   widget->style->black_gc,
-			   TRUE,
-			   0, 0,
-			   widget->allocation.width,
-			   widget->allocation.height);
-	// g_print("configure: %i:%i\n", widget->allocation.width, widget->allocation.height);
-	redraw_meters(idx, widget->allocation.width, widget->allocation.height, 0, 0);
+
+	// Get the window for the widget
+	GdkWindow *window = gtk_widget_get_window(widget);
+	// Begin drawing on the window (this replaces gdk_cairo_create)
+	GdkDrawingContext *context = gdk_window_begin_draw_frame(window, NULL);
+	// Get the Cairo context from the drawing context
+	cairo_t *cr = gdk_drawing_context_get_cairo_context(context);
+	//cairo_t *cr = gdk_cairo_create(gtk_widget_get_window(widget)); //DEPRECATED
+	GtkAllocation allocation;
+	gtk_widget_get_allocation(widget, &allocation);
+
+	// Set the source color (black in this case)
+	cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);  // RGB for black
+	// Create the rectangle with the specified dimensions
+	cairo_rectangle(cr, 0, 0, allocation.width, allocation.height);
+	// Fill the rectangle (similar to the "TRUE" parameter for filled in gdk_draw_rectangle)
+	cairo_fill(cr);
+
+	// g_print("configure: %i:%i\n", allocation.width, allocation.height);
+	redraw_meters(idx, allocation.width, allocation.height, 0, 0);
+
+    gdk_window_end_draw_frame(window, NULL); // End the draw frame
+
+	// Don't forget to manage memory and clean up
+	cairo_surface_destroy(surface);
+
 	return TRUE;
 }
 
@@ -179,18 +262,34 @@ gint level_meters_expose_event(GtkWidget *widget, GdkEventExpose *event)
 {
 	int idx = get_index(gtk_widget_get_name(widget));
 	int l1, l2;
-	
+
 	get_levels(idx, &l1, &l2);
-	redraw_meters(idx, widget->allocation.width, widget->allocation.height, l1, l2);
-	gdk_draw_pixmap(widget->window,
-			widget->style->black_gc,
-			pixmap[idx],
-			event->area.x, event->area.y,
-			event->area.x, event->area.y,
-			event->area.width, event->area.height);
+	GtkAllocation allocation;
+	gtk_widget_get_allocation(widget, &allocation);
+	redraw_meters(idx, allocation.width, allocation.height, l1, l2);
+
+	// Get the window for the widget
+	GdkWindow *window = gtk_widget_get_window(widget);
+	// Begin drawing on the window (this replaces gdk_cairo_create)
+	GdkDrawingContext *context = gdk_window_begin_draw_frame(window, NULL);
+	// Get the Cairo context from the drawing context
+	cairo_t *cr = gdk_drawing_context_get_cairo_context(context);
+	// Convert GdkPixbuf to Cairo surface
+	cairo_surface_t *surface = gdk_cairo_surface_create_from_pixbuf(pixmap[idx], 0, gtk_widget_get_window(widget));
+	// Set the source surface to the Cairo context
+	cairo_set_source_surface(cr, surface, event->area.x, event->area.y);
+	// Define the area to draw and fill it
+	cairo_rectangle(cr, event->area.x, event->area.y, event->area.width, event->area.height);
+	cairo_fill(cr);
+	// Clean up the Cairo surface
+	cairo_surface_destroy(surface);
+	// End the drawing frame
+	gdk_window_end_draw_frame(window, context);
+
 	return FALSE;
 }
 
+//TODO: Reduce/Remove/Refactor repeated code
 gint level_meters_timeout_callback(gpointer data)
 {
 	GtkWidget *widget;
@@ -200,56 +299,112 @@ gint level_meters_timeout_callback(gpointer data)
 	for (idx = 0; idx <= pcm_output_channels; idx++) {
 		get_levels(idx, &l1, &l2);
 		widget = idx == 0 ? mixer_mix_drawing : mixer_drawing[idx-1];
-		if (GTK_WIDGET_VISIBLE(widget) && (pixmap[idx] != NULL)) {
-			redraw_meters(idx, widget->allocation.width, widget->allocation.height, l1, l2);
-			gdk_draw_pixmap(widget->window,
-					widget->style->black_gc,
-					pixmap[idx],
-					0, 0,
-					0, 0,
-					widget->allocation.width, widget->allocation.height);
+		if (gtk_widget_get_visible(widget) && (pixmap[idx] != NULL)) {
+			GtkAllocation allocation;
+			gtk_widget_get_allocation(widget, &allocation);
+			redraw_meters(idx, allocation.width, allocation.height, l1, l2);
+
+			// Get the window for the widget
+			GdkWindow *window = gtk_widget_get_window(widget);
+			// Begin drawing on the window
+			GdkDrawingContext *context = gdk_window_begin_draw_frame(window, NULL);
+			// Get the Cairo context from the drawing context
+			cairo_t *cr = gdk_drawing_context_get_cairo_context(context);
+			// Create a Cairo surface from the pixmap
+			cairo_surface_t *surface = gdk_cairo_surface_create_from_pixbuf(pixmap[idx], 0, window);
+			// Set the source surface to the pixmap (Cairo surface)
+			cairo_set_source_surface(cr, surface, 0, 0);
+			// Define the area to draw (same as the width and height of the widget)
+			cairo_rectangle(cr, 0, 0, allocation.width, allocation.height);
+			cairo_fill(cr); // Fill the rectangle with the pixmap
+			// Clean up the Cairo surface
+			cairo_surface_destroy(surface);
+			// End the drawing frame
+			gdk_window_end_draw_frame(window, context);
 		}
 	}
 	if (view_spdif_playback) {
 		for (idx = MAX_PCM_OUTPUT_CHANNELS + 1; idx <= MAX_OUTPUT_CHANNELS + spdif_channels; idx++) {
 			get_levels(idx, &l1, &l2);
 			widget = idx == 0 ? mixer_mix_drawing : mixer_drawing[idx-1];
-			if (GTK_WIDGET_VISIBLE(widget) && (pixmap[idx] != NULL)) {
-				redraw_meters(idx, widget->allocation.width, widget->allocation.height, l1, l2);
-				gdk_draw_pixmap(widget->window,
-						widget->style->black_gc,
-						pixmap[idx],
-						0, 0,
-						0, 0,
-						widget->allocation.width, widget->allocation.height);
+			if (gtk_widget_get_visible(widget) && (pixmap[idx] != NULL)) {
+				GtkAllocation allocation;
+				gtk_widget_get_allocation(widget, &allocation);
+				redraw_meters(idx, allocation.width, allocation.height, l1, l2);
+
+			// Get the window for the widget
+			GdkWindow *window = gtk_widget_get_window(widget);
+			// Begin drawing on the window
+			GdkDrawingContext *context = gdk_window_begin_draw_frame(window, NULL);
+			// Get the Cairo context from the drawing context
+			cairo_t *cr = gdk_drawing_context_get_cairo_context(context);
+			// Create a Cairo surface from the pixmap
+			cairo_surface_t *surface = gdk_cairo_surface_create_from_pixbuf(pixmap[idx], 0, window);
+			// Set the source surface to the pixmap (Cairo surface)
+			cairo_set_source_surface(cr, surface, 0, 0);
+			// Define the area to draw (same as the width and height of the widget)
+			cairo_rectangle(cr, 0, 0, allocation.width, allocation.height);
+			cairo_fill(cr); // Fill the rectangle with the pixmap
+			// Clean up the Cairo surface
+			cairo_surface_destroy(surface);
+			// End the drawing frame
+			gdk_window_end_draw_frame(window, context);
 			}
 		}
 	}
 	for (idx = MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS + 1; idx <= input_channels + MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS; idx++) {
 		get_levels(idx, &l1, &l2);
 		widget = idx == 0 ? mixer_mix_drawing : mixer_drawing[idx-1];
-		if (GTK_WIDGET_VISIBLE(widget) && (pixmap[idx] != NULL)) {
-			redraw_meters(idx, widget->allocation.width, widget->allocation.height, l1, l2);
-			gdk_draw_pixmap(widget->window,
-					widget->style->black_gc,
-					pixmap[idx],
-					0, 0,
-					0, 0,
-					widget->allocation.width, widget->allocation.height);
+		if (gtk_widget_get_visible(widget) && (pixmap[idx] != NULL)) {
+			GtkAllocation allocation;
+			gtk_widget_get_allocation(widget, &allocation);
+			redraw_meters(idx, allocation.width, allocation.height, l1, l2);
+
+			// Get the window for the widget
+			GdkWindow *window = gtk_widget_get_window(widget);
+			// Begin drawing on the window
+			GdkDrawingContext *context = gdk_window_begin_draw_frame(window, NULL);
+			// Get the Cairo context from the drawing context
+			cairo_t *cr = gdk_drawing_context_get_cairo_context(context);
+			// Create a Cairo surface from the pixmap
+			cairo_surface_t *surface = gdk_cairo_surface_create_from_pixbuf(pixmap[idx], 0, window);
+			// Set the source surface to the pixmap (Cairo surface)
+			cairo_set_source_surface(cr, surface, 0, 0);
+			// Define the area to draw (same as the width and height of the widget)
+			cairo_rectangle(cr, 0, 0, allocation.width, allocation.height);
+			cairo_fill(cr); // Fill the rectangle with the pixmap
+			// Clean up the Cairo surface
+			cairo_surface_destroy(surface);
+			// End the drawing frame
+			gdk_window_end_draw_frame(window, context);
 		}
 	}
 	for (idx = MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS + MAX_INPUT_CHANNELS + 1; \
 		    idx <= spdif_channels + MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS + MAX_INPUT_CHANNELS; idx++) {
 		get_levels(idx, &l1, &l2);
 		widget = idx == 0 ? mixer_mix_drawing : mixer_drawing[idx-1];
-		if (GTK_WIDGET_VISIBLE(widget) && (pixmap[idx] != NULL)) {
-			redraw_meters(idx, widget->allocation.width, widget->allocation.height, l1, l2);
-			gdk_draw_pixmap(widget->window,
-					widget->style->black_gc,
-					pixmap[idx],
-					0, 0,
-					0, 0,
-					widget->allocation.width, widget->allocation.height);
+		if (gtk_widget_get_visible(widget) && (pixmap[idx] != NULL)) {
+			GtkAllocation allocation;
+			gtk_widget_get_allocation(widget, &allocation);
+			redraw_meters(idx, allocation.width, allocation.height, l1, l2);
+
+			// Get the window for the widget
+			GdkWindow *window = gtk_widget_get_window(widget);
+			// Begin drawing on the window
+			GdkDrawingContext *context = gdk_window_begin_draw_frame(window, NULL);
+			// Get the Cairo context from the drawing context
+			cairo_t *cr = gdk_drawing_context_get_cairo_context(context);
+			// Create a Cairo surface from the pixmap
+			cairo_surface_t *surface = gdk_cairo_surface_create_from_pixbuf(pixmap[idx], 0, window);
+			// Set the source surface to the pixmap (Cairo surface)
+			cairo_set_source_surface(cr, surface, 0, 0);
+			// Define the area to draw (same as the width and height of the widget)
+			cairo_rectangle(cr, 0, 0, allocation.width, allocation.height);
+			cairo_fill(cr); // Fill the rectangle with the pixmap
+			// Clean up the Cairo surface
+			cairo_surface_destroy(surface);
+			// End the drawing frame
+			gdk_window_end_draw_frame(window, context);
 		}
 	}
 	return TRUE;
diff --git a/envy24control/midi.c b/envy24control/midi.c
index ff12537..56ceb33 100644
--- a/envy24control/midi.c
+++ b/envy24control/midi.c
@@ -243,7 +243,7 @@ int midi_init(char *appname, int channel, int midi_enhanced)
 void mixer_adjust(GtkAdjustment *adj, gpointer data);
 void mixer_set_mute(int stream, int left, int right);
 
-void midi_process(gpointer data, gint source, GdkInputCondition condition)
+gint midi_process(GIOChannel *source, GIOCondition condition, gpointer data)
 {
   snd_seq_event_t *ev;
   static GtkAdjustment *adj=0;
@@ -306,6 +306,7 @@ void midi_process(gpointer data, gint source, GdkInputCondition condition)
       snd_seq_free_event(ev);
     }
   while (snd_seq_event_input_pending(seq, 0) > 0);
+  return TRUE;
 }
 
 /* ************************************************* */
diff --git a/envy24control/midi.h b/envy24control/midi.h
index f821d42..9edb692 100644
--- a/envy24control/midi.h
+++ b/envy24control/midi.h
@@ -7,7 +7,7 @@ int midi_init(char *appname, int channel, int midi_enhanced);
 int midi_close();
 void midi_maxstreams(int);
 int midi_controller(int c, int v);
-void midi_process(gpointer data, gint source, GdkInputCondition condition);
+gint midi_process(GIOChannel *source, GIOCondition condition, gpointer data);
 int midi_button(int b, int v);
 
 #endif
diff --git a/envy24control/mixer.c b/envy24control/mixer.c
index dd42681..283ee0d 100644
--- a/envy24control/mixer.c
+++ b/envy24control/mixer.c
@@ -39,13 +39,13 @@ extern int input_channels, output_channels, pcm_output_channels, spdif_channels,
 
 static int is_active(GtkWidget *widget)
 {
-	return GTK_TOGGLE_BUTTON(widget)->active ? 1 : 0;
+	return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 }
 
 void mixer_update_stream(int stream, int vol_flag, int sw_flag)
 {
 	int err;
-	
+
 	if (! stream_is_active[stream - 1])
 		return;
 
@@ -180,12 +180,13 @@ void mixer_adjust(GtkAdjustment *adj, gpointer data)
 	int button = (long)data & 1;
 	int stereo = is_active(mixer_stereo_toggle[stream-1]) ? 1 : 0;
 	int vol[2] = { -1, -1 };
-	
-	vol[button] = 96 - adj->value;
-	if (stereo) {
-		gtk_adjustment_set_value(GTK_ADJUSTMENT(mixer_adj[stream-1][button ^ 1]), adj->value);
-		vol[button ^ 1] = 96 - adj->value;
-	}
+	double adjustment_value = gtk_adjustment_get_value(adj);
+
+    vol[button] = 96 - adjustment_value;
+    if (stereo) {
+        gtk_adjustment_set_value(GTK_ADJUSTMENT(mixer_adj[stream-1][button ^ 1]), adjustment_value);
+        vol[button ^ 1] = 96 - adjustment_value;
+    }
 	set_volume1(stream, vol[0], vol[1]);
 }
 
diff --git a/envy24control/patchbay.c b/envy24control/patchbay.c
index 89bdf72..f5ec2b2 100644
--- a/envy24control/patchbay.c
+++ b/envy24control/patchbay.c
@@ -30,7 +30,7 @@ extern int output_channels, input_channels, pcm_output_channels, spdif_channels;
 
 static int is_active(GtkWidget *widget)
 {
-	return GTK_TOGGLE_BUTTON(widget)->active ? 1 : 0;
+	return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 }
 
 static int get_toggle_index(int stream)
diff --git a/envy24control/volume.c b/envy24control/volume.c
index 471f9ce..050ccd3 100644
--- a/envy24control/volume.c
+++ b/envy24control/volume.c
@@ -105,9 +105,6 @@ int envy_analog_volume_available(void)
 }
 
 
-/*
- */
-
 void dac_volume_update(int idx)
 {
 	snd_ctl_elem_value_t *val;
@@ -210,14 +207,12 @@ void adc_sense_update(int idx)
 }
 
 
-/*
- */
-
 void dac_volume_adjust(GtkAdjustment *adj, gpointer data)
 {
 	int idx = (int)(long)data;
 	snd_ctl_elem_value_t *val;
-	int err, ival = -(int)adj->value;
+	double adjustment_value = gtk_adjustment_get_value(adj);
+	int err, ival = -(int)adjustment_value;
 	char text[16];
 
 	snd_ctl_elem_value_alloca(&val);
@@ -235,7 +230,8 @@ void adc_volume_adjust(GtkAdjustment *adj, gpointer data)
 {
 	int idx = (int)(long)data;
 	snd_ctl_elem_value_t *val;
-	int err, ival = -(int)adj->value;
+	double adjustment_value = gtk_adjustment_get_value(adj);
+	int err, ival = -(int)adjustment_value;
 	char text[16];
 
 	snd_ctl_elem_value_alloca(&val);
@@ -253,7 +249,8 @@ void ipga_volume_adjust(GtkAdjustment *adj, gpointer data)
 {
 	int idx = (int)(long)data;
 	snd_ctl_elem_value_t *val;
-	int err, ival = -(int)adj->value;
+	double adjustment_value = gtk_adjustment_get_value(adj);
+	int err, ival = -(int)adjustment_value;
 	char text[16];
 
 	snd_ctl_elem_value_alloca(&val);
@@ -299,9 +296,6 @@ void adc_sense_toggled(GtkWidget *togglebutton, gpointer data)
 		g_print("Unable to write adc sense: %s\n", snd_strerror(err));
 }
 
-/*
- */
-
 void analog_volume_init(void)
 {
 	snd_ctl_elem_info_t *info;

From e9beb0aef6d7c06e6898050743efb27336cf6d62 Mon Sep 17 00:00:00 2001
From: genBTC <genBTC@gmx.com>
Date: Thu, 6 Mar 2025 19:34:34 -0500
Subject: [PATCH 3/3] rmedigicontrol/: port from GTK2 to GTK3

---
 rmedigicontrol/configure.ac     |  2 +-
 rmedigicontrol/level.c          | 39 ++++++++++++++++------------
 rmedigicontrol/loopback.c       | 12 ++++-----
 rmedigicontrol/rmedigicontrol.c | 46 ++++++++++++++++-----------------
 4 files changed, 53 insertions(+), 46 deletions(-)

diff --git a/rmedigicontrol/configure.ac b/rmedigicontrol/configure.ac
index 9c38754..ab9bbb3 100644
--- a/rmedigicontrol/configure.ac
+++ b/rmedigicontrol/configure.ac
@@ -4,6 +4,6 @@ AM_MAINTAINER_MODE([enable])
 AC_PROG_CC
 AC_PROG_INSTALL
 AC_HEADER_STDC
-PKG_CHECK_MODULES(RMEDIGICONTROL, gtk+-2.0 alsa >= 1.0.0)
+PKG_CHECK_MODULES(RMEDIGICONTROL, gtk+-3.0 alsa >= 1.0.0)
 
 AC_OUTPUT(Makefile)
diff --git a/rmedigicontrol/level.c b/rmedigicontrol/level.c
index bce2e95..b8b2ee6 100644
--- a/rmedigicontrol/level.c
+++ b/rmedigicontrol/level.c
@@ -13,7 +13,7 @@
    GNU General Public License for more details.
 *****************************************************************************/
 
-#include "rmedigicontrol.h" 
+#include "rmedigicontrol.h"
 
 static snd_ctl_elem_value_t *val;
 static snd_ctl_elem_info_t *info;
@@ -24,21 +24,22 @@ static char *val2char(gdouble val)
 	sprintf(vlab,"%2.0f",100-val);
 	return(vlab);
 }
-static void changed(GtkAdjustment *a,gpointer p)
+static void changed(GtkAdjustment *a, gpointer p)
 {
-	snd_ctl_elem_value_set_integer(val,0,((100-a->value)*snd_ctl_elem_info_get_max(info))/100);
-	snd_ctl_elem_value_set_integer(val,1,((100-a->value)*snd_ctl_elem_info_get_max(info))/100);
-	snd_ctl_elem_write(ctl,val);
-	gtk_label_set_text(p,val2char(a->value));
+	double value = gtk_adjustment_get_value(a);
+	int adjusted_value = ((100 - value) * snd_ctl_elem_info_get_max(info)) / 100;
+	snd_ctl_elem_value_set_integer(val, 0, adjusted_value);
+	snd_ctl_elem_value_set_integer(val, 1, adjusted_value);
+	snd_ctl_elem_write(ctl, val);
+	gtk_label_set_text(GTK_LABEL(p), val2char(value));
 }
 
 GtkWidget *create_level_box()
 {
-	GtkObject *adjust;
+	GtkAdjustment *adjust;
 	GtkWidget *box,*slider1,*label1,*vlabel;
 	char *elem_name="DAC Playback Volume";
-	
-	box=gtk_vbox_new(FALSE,2);
+	box=gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);
 
 	snd_ctl_elem_info_malloc(&info);
 	snd_ctl_elem_value_malloc(&val);
@@ -47,19 +48,25 @@ GtkWidget *create_level_box()
 	snd_ctl_elem_info_set_name(info,elem_name);
 	snd_ctl_elem_info_set_numid(info,0);
 	snd_ctl_elem_info(ctl,info);
-	
+
 	snd_ctl_elem_value_set_interface(val,SND_CTL_ELEM_TYPE_INTEGER);
 	snd_ctl_elem_value_set_name(val,elem_name);
 	snd_ctl_elem_read(ctl,val);
 
-	adjust=GTK_OBJECT(gtk_adjustment_new(100-(snd_ctl_elem_value_get_integer(val,0)*100)/snd_ctl_elem_info_get_max(info),0,100,1,5,0));
-
-	vlabel=gtk_label_new(val2char((GTK_ADJUSTMENT(adjust))->value));
-	gtk_signal_connect(adjust,"value_changed",GTK_SIGNAL_FUNC(changed),vlabel);
-	slider1=gtk_vscale_new(GTK_ADJUSTMENT(adjust));
+	adjust = gtk_adjustment_new(
+		100 - (snd_ctl_elem_value_get_integer(val, 0) * 100) / snd_ctl_elem_info_get_max(info),
+		0,   // lower
+		100, // upper
+		1,   // step increment
+		5,   // page increment
+		0    // page size
+	);
+	vlabel = gtk_label_new(val2char(gtk_adjustment_get_value(adjust)));
+	g_signal_connect(adjust,"value_changed",G_CALLBACK(changed),vlabel);
+	slider1=gtk_scale_new(GTK_ORIENTATION_VERTICAL, adjust);
 	gtk_scale_set_draw_value(GTK_SCALE(slider1),FALSE);
 	gtk_scale_set_digits(GTK_SCALE(slider1),0);
-	
+
 	label1=gtk_label_new("Level");
 	gtk_box_pack_start(GTK_BOX(box),label1,FALSE,TRUE,5);
 	gtk_box_pack_start(GTK_BOX(box),slider1,TRUE,TRUE,5);
diff --git a/rmedigicontrol/loopback.c b/rmedigicontrol/loopback.c
index b47eb20..c09f645 100644
--- a/rmedigicontrol/loopback.c
+++ b/rmedigicontrol/loopback.c
@@ -13,7 +13,7 @@
    GNU General Public License for more details.
 ******************************************************************************/
 
-#include "rmedigicontrol.h" 
+#include "rmedigicontrol.h"
 
 static snd_ctl_elem_value_t *val;
 
@@ -28,18 +28,18 @@ GtkWidget *create_loopback_toggle()
 	GtkWidget *t;
 	GtkWidget *box;
 	char *elem_name="Loopback Input";
-	
+
 	box=gtk_hbox_new(FALSE,0);
-	
+
 	snd_ctl_elem_value_malloc(&val);
-	
+
 	snd_ctl_elem_value_set_interface(val, SND_CTL_ELEM_IFACE_MIXER);
 	snd_ctl_elem_value_set_name(val,elem_name);
 	snd_ctl_elem_read(ctl, val);
-	
+
 	t=gtk_check_button_new_with_label(elem_name);
 
-	gtk_signal_connect(GTK_OBJECT(t),"toggled",GTK_SIGNAL_FUNC(loopback_toggled),NULL);
+	g_signal_connect(t,"toggled",G_CALLBACK(loopback_toggled),NULL);
 	if(snd_ctl_elem_value_get_integer(val,0))
 		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(t),TRUE);
 
diff --git a/rmedigicontrol/rmedigicontrol.c b/rmedigicontrol/rmedigicontrol.c
index 1119637..2df5013 100644
--- a/rmedigicontrol/rmedigicontrol.c
+++ b/rmedigicontrol/rmedigicontrol.c
@@ -23,7 +23,7 @@ ctl_elem_info_val_t att_iv;
 
 void destroy(GtkWidget *widget,gpointer data)
 {
-	snd_ctl_close(ctl);	
+	snd_ctl_close(ctl);
     gtk_main_quit();
 }
 int main(int argc, char *argv[])
@@ -32,7 +32,7 @@ int main(int argc, char *argv[])
 	char name[16],*err;
 	snd_ctl_card_info_t *hw_info;
 	card_type_t type;
-	
+
 	GtkWidget *window,*main_box,*input_box,*loopback_box,*clock_box,*monitor_box,*att_box,*level_box;
 	GtkWidget *col1_box,*col2_box,*err_lbl;
 	snd_ctl_card_info_alloca(&hw_info);
@@ -76,27 +76,27 @@ int main(int argc, char *argv[])
 	}
 	if(card<0)
 		err="No RME Digi Soundcard found...";
-	gtk_init(&argc, &argv);	
+	gtk_init(&argc, &argv);
 	window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
-	gtk_signal_connect(GTK_OBJECT(window),"destroy",GTK_SIGNAL_FUNC(destroy),NULL);
+	g_signal_connect(window,"destroy",G_CALLBACK(destroy),NULL);
 	if(err)
 	{
 		err_lbl=gtk_label_new(err);
 		gtk_container_add(GTK_CONTAINER(window),err_lbl);
 		gtk_widget_show_all(window);
-		gtk_main ();	
-		exit(EXIT_FAILURE);	
+		gtk_main ();
+		exit(EXIT_FAILURE);
 	}
 
 	gtk_window_set_title(GTK_WINDOW(window),snd_ctl_card_info_get_name(hw_info));
-	
+	//-Wdeprecated-declarations
 	main_box=gtk_hbox_new(FALSE,0);
-	col1_box=gtk_vbox_new(FALSE,0);	
-	col2_box=gtk_vbox_new(FALSE,0);	
-	
+	col1_box=gtk_vbox_new(FALSE,0);
+	col2_box=gtk_vbox_new(FALSE,0);
+
 	input_box=create_enum_elem_radio("Input Connector",&input_iv);
 	gtk_box_pack_start(GTK_BOX(col1_box),input_box,TRUE,FALSE,0);
-	
+
 	loopback_box=create_loopback_toggle();
 	gtk_box_pack_start(GTK_BOX(col1_box),loopback_box,TRUE,FALSE,0);
 
@@ -109,7 +109,7 @@ int main(int argc, char *argv[])
 	{
 		monitor_box=create_enum_elem_radio("Monitor Tracks",&monitor_iv);
 		gtk_box_pack_start(GTK_BOX(col2_box),monitor_box,TRUE,FALSE,0);
-	
+
 		att_box=create_enum_elem_radio("Attenuation",&att_iv);
 		gtk_box_pack_start(GTK_BOX(col2_box),att_box,TRUE,FALSE,0);
 
@@ -118,7 +118,7 @@ int main(int argc, char *argv[])
 		level_box=create_level_box();
 		gtk_box_pack_start(GTK_BOX(main_box),level_box,TRUE,TRUE,8);
 	}
-	gtk_container_add(GTK_CONTAINER(window),main_box);		
+	gtk_container_add(GTK_CONTAINER(window),main_box);
 	gtk_widget_show_all(window);
 	gtk_main ();
 	return EXIT_SUCCESS;
@@ -128,9 +128,9 @@ void elem_radio_toggled(GtkRadioButton *r,gpointer p)
 	int i;
 	GSList *l;
 	ctl_elem_info_val_t *iv;
-	
+
 	iv=(ctl_elem_info_val_t *)p;
-	l=gtk_radio_button_group(r);
+	l=gtk_radio_button_get_group(r);
 	i=snd_ctl_elem_info_get_items(iv->info);
 	while(l)
 	{
@@ -151,27 +151,27 @@ GtkWidget *create_enum_elem_radio(char *elem_name,ctl_elem_info_val_t *iv)
 
 	snd_ctl_elem_info_malloc(&iv->info);
 	snd_ctl_elem_value_malloc(&iv->val);
-	
+
 	group=NULL;
 	active=NULL;
-	box=gtk_vbox_new(TRUE,0);
-	
+	box=gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+
 	snd_ctl_elem_info_set_interface(iv->info, SND_CTL_ELEM_IFACE_MIXER);
 	snd_ctl_elem_info_set_name(iv->info,elem_name);
 	snd_ctl_elem_info_set_numid(iv->info,0);
 	snd_ctl_elem_info(ctl,iv->info);
-	
+
 	snd_ctl_elem_value_set_interface(iv->val, SND_CTL_ELEM_IFACE_MIXER);
 	snd_ctl_elem_value_set_name(iv->val,elem_name);
 	snd_ctl_elem_read(ctl,iv->val);
-	
+
 	for(i=0;i<snd_ctl_elem_info_get_items(iv->info);i++)
 	{
 		snd_ctl_elem_info_set_item(iv->info, i);
 		snd_ctl_elem_info(ctl,iv->info);
-		r=gtk_radio_button_new_with_label(group,snd_ctl_elem_info_get_item_name(iv->info));
-		group=gtk_radio_button_group(GTK_RADIO_BUTTON(r));
-		gtk_signal_connect(GTK_OBJECT(r),"toggled",GTK_SIGNAL_FUNC(elem_radio_toggled),(gpointer)iv);
+		r=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(r),
+            snd_ctl_elem_info_get_item_name(iv->info));
+		g_signal_connect(r,"toggled",G_CALLBACK(elem_radio_toggled),(gpointer)iv);
 		if(i==snd_ctl_elem_value_get_integer(iv->val,0))
 			active=r;
 		gtk_box_pack_start(GTK_BOX(box),r,TRUE,FALSE,0);