changeset 359:b1a858b8cb1a

Re-indentation all (non-generated) code.
author Matti Hamalainen <ccr@tnsp.org>
date Mon, 07 Nov 2005 09:50:04 +0000
parents 4f247b19c9ea
children 3bea6584259f
files src/xmms-sid.c src/xs_about.c src/xs_config.c src/xs_curve.c src/xs_fileinfo.c src/xs_filter.c src/xs_genui.c src/xs_init.c src/xs_length.c src/xs_md5.c src/xs_sidplay.h src/xs_sidplay1.cc src/xs_sidplay2.cc src/xs_stil.c src/xs_support.c src/xs_title.c
diffstat 16 files changed, 3873 insertions(+), 4140 deletions(-) [+]
line wrap: on
line diff
--- a/src/xmms-sid.c	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xmms-sid.c	Mon Nov 07 09:50:04 2005 +0000
@@ -59,22 +59,22 @@
  */
 t_xs_player xs_playerlist[] = {
 #ifdef HAVE_SIDPLAY1
-	{ XS_ENG_SIDPLAY1,
-		xs_sidplay1_isourfile,
-		xs_sidplay1_init, xs_sidplay1_close,
-		xs_sidplay1_initsong, xs_sidplay1_fillbuffer,
-		xs_sidplay1_loadsid, xs_sidplay1_deletesid,
-		xs_sidplay1_getsidinfo
-	},
+	{XS_ENG_SIDPLAY1,
+	 xs_sidplay1_isourfile,
+	 xs_sidplay1_init, xs_sidplay1_close,
+	 xs_sidplay1_initsong, xs_sidplay1_fillbuffer,
+	 xs_sidplay1_loadsid, xs_sidplay1_deletesid,
+	 xs_sidplay1_getsidinfo}
+	,
 #endif
 #ifdef HAVE_SIDPLAY2
-	{ XS_ENG_SIDPLAY2,
-		xs_sidplay2_isourfile,
-		xs_sidplay2_init, xs_sidplay2_close,
-		xs_sidplay2_initsong, xs_sidplay2_fillbuffer,
-		xs_sidplay2_loadsid, xs_sidplay2_deletesid,
-		xs_sidplay2_getsidinfo
-	},
+	{XS_ENG_SIDPLAY2,
+	 xs_sidplay2_isourfile,
+	 xs_sidplay2_init, xs_sidplay2_close,
+	 xs_sidplay2_initsong, xs_sidplay2_fillbuffer,
+	 xs_sidplay2_loadsid, xs_sidplay2_deletesid,
+	 xs_sidplay2_getsidinfo}
+	,
 #endif
 };
 
@@ -84,16 +84,16 @@
 /*
  * Global variables
  */
-t_xs_status		xs_status;
+t_xs_status xs_status;
 XS_MUTEX(xs_status);
-static pthread_t	xs_decode_thread;
+static pthread_t xs_decode_thread;
 
-static GtkWidget	*xs_subctrl	= NULL;
-static GtkObject	*xs_subctrl_adj = NULL;
+static GtkWidget *xs_subctrl = NULL;
+static GtkObject *xs_subctrl_adj = NULL;
 XS_MUTEX(xs_subctrl);
 
-void	xs_subctrl_close(void);
-void	xs_subctrl_update(void);
+void xs_subctrl_close(void);
+void xs_subctrl_update(void);
 
 
 /*
@@ -101,22 +101,22 @@
  */
 void XSERR(const char *fmt, ...)
 {
- va_list ap;
- fprintf(stderr, "XMMS-SID: ");
- va_start(ap, fmt);
- vfprintf(stderr, fmt, ap);
- va_end(ap); 
+	va_list ap;
+	fprintf(stderr, "XMMS-SID: ");
+	va_start(ap, fmt);
+	vfprintf(stderr, fmt, ap);
+	va_end(ap);
 }
 
 #ifndef DEBUG_NP
 void XSDEBUG(const char *fmt, ...)
 {
 #ifdef DEBUG
- va_list ap;
- fprintf(stderr, "XSDEBUG: ");
- va_start(ap, fmt);
- vfprintf(stderr, fmt, ap);
- va_end(ap); 
+	va_list ap;
+	fprintf(stderr, "XSDEBUG: ");
+	va_start(ap, fmt);
+	vfprintf(stderr, fmt, ap);
+	va_end(ap);
 #endif
 }
 #endif
@@ -126,94 +126,85 @@
  */
 void xs_reinit(void)
 {
- gint iPlayer;
- gboolean isInitialized;
- 
- /* Stop playing, if we are */
- XS_MUTEX_LOCK(xs_status);
- if (xs_status.isPlaying)
- 	{
- 	XS_MUTEX_UNLOCK(xs_status);
-	xs_stop();
+	gint iPlayer;
+	gboolean isInitialized;
+
+	/* Stop playing, if we are */
+	XS_MUTEX_LOCK(xs_status);
+	if (xs_status.isPlaying) {
+		XS_MUTEX_UNLOCK(xs_status);
+		xs_stop();
 	} else {
-	XS_MUTEX_UNLOCK(xs_status);
+		XS_MUTEX_UNLOCK(xs_status);
 	}
- 
- /* Initialize status and sanitize configuration */
- xs_memset(&xs_status, 0, sizeof(xs_status));
- 
- if (xs_cfg.audioFrequency < 8000)
- 	xs_cfg.audioFrequency = 8000;
+
+	/* Initialize status and sanitize configuration */
+	xs_memset(&xs_status, 0, sizeof(xs_status));
+
+	if (xs_cfg.audioFrequency < 8000)
+		xs_cfg.audioFrequency = 8000;
 
- if (xs_cfg.oversampleFactor < XS_MIN_OVERSAMPLE)
- 	xs_cfg.oversampleFactor = XS_MIN_OVERSAMPLE;
- 	else
- if (xs_cfg.oversampleFactor > XS_MAX_OVERSAMPLE)
- 	xs_cfg.oversampleFactor = XS_MAX_OVERSAMPLE;
+	if (xs_cfg.oversampleFactor < XS_MIN_OVERSAMPLE)
+		xs_cfg.oversampleFactor = XS_MIN_OVERSAMPLE;
+	else if (xs_cfg.oversampleFactor > XS_MAX_OVERSAMPLE)
+		xs_cfg.oversampleFactor = XS_MAX_OVERSAMPLE;
+
+	if (xs_cfg.audioChannels != XS_CHN_MONO)
+		xs_cfg.oversampleEnable = FALSE;
 
- if (xs_cfg.audioChannels != XS_CHN_MONO)
- 	xs_cfg.oversampleEnable = FALSE;
- 
- xs_status.audioFrequency	= xs_cfg.audioFrequency;
- xs_status.audioBitsPerSample	= xs_cfg.audioBitsPerSample;
- xs_status.audioChannels	= xs_cfg.audioChannels;
- xs_status.audioFormat		= -1;
- xs_status.oversampleEnable	= xs_cfg.oversampleEnable;
- xs_status.oversampleFactor	= xs_cfg.oversampleFactor;
- 
- /* Try to initialize emulator engine */
- XSDEBUG("initializing emulator engine #%i...\n", xs_cfg.playerEngine);
+	xs_status.audioFrequency = xs_cfg.audioFrequency;
+	xs_status.audioBitsPerSample = xs_cfg.audioBitsPerSample;
+	xs_status.audioChannels = xs_cfg.audioChannels;
+	xs_status.audioFormat = -1;
+	xs_status.oversampleEnable = xs_cfg.oversampleEnable;
+	xs_status.oversampleFactor = xs_cfg.oversampleFactor;
+
+	/* Try to initialize emulator engine */
+	XSDEBUG("initializing emulator engine #%i...\n", xs_cfg.playerEngine);
 
- iPlayer = 0;
- isInitialized = FALSE;
- while ((iPlayer < xs_nplayerlist) && !isInitialized)
- 	{
- 	if (xs_playerlist[iPlayer].plrIdent == xs_cfg.playerEngine)
- 		{
- 		if (xs_playerlist[iPlayer].plrInit(&xs_status))
- 			{
- 			isInitialized = TRUE;
- 			xs_status.sidPlayer = (t_xs_player *) &xs_playerlist[iPlayer];
- 			}
- 		}
-	iPlayer++;
- 	}
+	iPlayer = 0;
+	isInitialized = FALSE;
+	while ((iPlayer < xs_nplayerlist) && !isInitialized) {
+		if (xs_playerlist[iPlayer].plrIdent == xs_cfg.playerEngine) {
+			if (xs_playerlist[iPlayer].plrInit(&xs_status)) {
+				isInitialized = TRUE;
+				xs_status.sidPlayer = (t_xs_player *) & xs_playerlist[iPlayer];
+			}
+		}
+		iPlayer++;
+	}
 
- XSDEBUG("init#1: %s, %i\n", (isInitialized) ? "OK" : "FAILED", iPlayer);
+	XSDEBUG("init#1: %s, %i\n", (isInitialized) ? "OK" : "FAILED", iPlayer);
 
- iPlayer = 0;
- while ((iPlayer < xs_nplayerlist) && !isInitialized)
- 	{
-	if (xs_playerlist[iPlayer].plrInit(&xs_status))
-		{
-		isInitialized = TRUE;
-		xs_status.sidPlayer = (t_xs_player *) &xs_playerlist[iPlayer];
-		xs_cfg.playerEngine = xs_playerlist[iPlayer].plrIdent;
- 		} else
- 		iPlayer++;
- 	}
- 
- XSDEBUG("init#2: %s, %i\n", (isInitialized) ? "OK" : "FAILED", iPlayer);
+	iPlayer = 0;
+	while ((iPlayer < xs_nplayerlist) && !isInitialized) {
+		if (xs_playerlist[iPlayer].plrInit(&xs_status)) {
+			isInitialized = TRUE;
+			xs_status.sidPlayer = (t_xs_player *) & xs_playerlist[iPlayer];
+			xs_cfg.playerEngine = xs_playerlist[iPlayer].plrIdent;
+		} else
+			iPlayer++;
+	}
+
+	XSDEBUG("init#2: %s, %i\n", (isInitialized) ? "OK" : "FAILED", iPlayer);
 
- /* Get settings back, in case the chosen emulator backend changed them */
- xs_cfg.audioFrequency		= xs_status.audioFrequency;
- xs_cfg.audioBitsPerSample	= xs_status.audioBitsPerSample;
- xs_cfg.audioChannels		= xs_status.audioChannels;
- xs_cfg.oversampleEnable	= xs_status.oversampleEnable;
+	/* Get settings back, in case the chosen emulator backend changed them */
+	xs_cfg.audioFrequency = xs_status.audioFrequency;
+	xs_cfg.audioBitsPerSample = xs_status.audioBitsPerSample;
+	xs_cfg.audioChannels = xs_status.audioChannels;
+	xs_cfg.oversampleEnable = xs_status.oversampleEnable;
 
- /* Initialize song-length database */
- xs_songlen_close();
- if (xs_cfg.songlenDBEnable && (xs_songlen_init() != 0))
- 	{
-	XSERR("Error initializing song-length database!\n");
+	/* Initialize song-length database */
+	xs_songlen_close();
+	if (xs_cfg.songlenDBEnable && (xs_songlen_init() != 0)) {
+		XSERR("Error initializing song-length database!\n");
 	}
-	
- /* Initialize STIL database */
- xs_stil_close();
- if (xs_cfg.stilDBEnable && (xs_stil_init() != 0))
- 	{
- 	XSERR("Error initializing STIL database!\n");
- 	}
+
+	/* Initialize STIL database */
+	xs_stil_close();
+	if (xs_cfg.stilDBEnable && (xs_stil_init() != 0)) {
+		XSERR("Error initializing STIL database!\n");
+	}
 }
 
 
@@ -222,17 +213,17 @@
  */
 void xs_init(void)
 {
- XSDEBUG("xs_init()\n");
+	XSDEBUG("xs_init()\n");
 
- /* Initialize and get configuration */
- xs_memset(&xs_cfg, 0, sizeof(xs_cfg));
- xs_init_configuration();
- xs_read_configuration();
+	/* Initialize and get configuration */
+	xs_memset(&xs_cfg, 0, sizeof(xs_cfg));
+	xs_init_configuration();
+	xs_read_configuration();
 
- /* Initialize subsystems */
- xs_reinit();
- 
- XSDEBUG("OK\n");
+	/* Initialize subsystems */
+	xs_reinit();
+
+	XSDEBUG("OK\n");
 }
 
 
@@ -241,57 +232,61 @@
  */
 void xs_close(void)
 {
- XSDEBUG("xs_close(): shutting down...\n");
+	XSDEBUG("xs_close(): shutting down...\n");
 
- /* Stop playing, free structures */
- xs_stop();
+	/* Stop playing, free structures */
+	xs_stop();
 
- xs_tuneinfo_free(xs_status.tuneInfo);
- xs_status.tuneInfo = NULL;
- xs_status.sidPlayer->plrDeleteSID(&xs_status);
- xs_status.sidPlayer->plrClose(&xs_status);
+	xs_tuneinfo_free(xs_status.tuneInfo);
+	xs_status.tuneInfo = NULL;
+	xs_status.sidPlayer->plrDeleteSID(&xs_status);
+	xs_status.sidPlayer->plrClose(&xs_status);
 
- xs_songlen_close();
- xs_stil_close();
+	xs_songlen_close();
+	xs_stil_close();
 
- XSDEBUG("shutdown finished.\n");
+	XSDEBUG("shutdown finished.\n");
 }
 
 
 /*
  * Check whether the given file is handled by this plugin
  */
-gint xs_is_our_file(gchar *pcFilename)
+gint xs_is_our_file(gchar * pcFilename)
 {
- gchar *pcExt;
- assert(xs_status.sidPlayer);
+	gchar *pcExt;
+	assert(xs_status.sidPlayer);
 
- /* Check the filename */
- if (pcFilename == NULL)
-	return FALSE;
+	/* Check the filename */
+	if (pcFilename == NULL)
+		return FALSE;
 
- /* Try to detect via detection routine, if required */
- if (xs_cfg.detectMagic && xs_status.sidPlayer->plrIsOurFile(pcFilename))
- 	return TRUE;
+	/* Try to detect via detection routine, if required */
+	if (xs_cfg.detectMagic && xs_status.sidPlayer->plrIsOurFile(pcFilename))
+		return TRUE;
 
- /* Detect just by checking filename extension */
- pcExt = xs_strrchr(pcFilename, '.');
- if (pcExt)
-	{
-	pcExt++;
-	switch (xs_cfg.playerEngine) {
-	case XS_ENG_SIDPLAY1:
-	case XS_ENG_SIDPLAY2:
-		if (!g_strcasecmp(pcExt, "psid")) return TRUE;
-		if (!g_strcasecmp(pcExt, "sid")) return TRUE;
-		if (!g_strcasecmp(pcExt, "dat")) return TRUE;
-		if (!g_strcasecmp(pcExt, "inf")) return TRUE;
-		if (!g_strcasecmp(pcExt, "info")) return TRUE;
-		break;
-	}
+	/* Detect just by checking filename extension */
+	pcExt = xs_strrchr(pcFilename, '.');
+	if (pcExt) {
+		pcExt++;
+		switch (xs_cfg.playerEngine) {
+		case XS_ENG_SIDPLAY1:
+		case XS_ENG_SIDPLAY2:
+			if (!g_strcasecmp(pcExt, "psid"))
+				return TRUE;
+			if (!g_strcasecmp(pcExt, "sid"))
+				return TRUE;
+			if (!g_strcasecmp(pcExt, "dat"))
+				return TRUE;
+			if (!g_strcasecmp(pcExt, "inf"))
+				return TRUE;
+			if (!g_strcasecmp(pcExt, "info"))
+				return TRUE;
+			break;
+		}
 	}
 
- return FALSE;
+	return FALSE;
 }
 
 
@@ -300,251 +295,231 @@
  */
 void *xs_playthread(void *argPointer)
 {
- t_xs_status myStatus;
- t_xs_tuneinfo *myTune;
- gboolean audioOpen = FALSE, doPlay = FALSE, isFound = FALSE;
- gboolean playedTune[XS_STIL_MAXENTRY + 1];
- gint audioGot, songLength, i;
- gchar *audioBuffer = NULL, *oversampleBuffer = NULL;
+	t_xs_status myStatus;
+	t_xs_tuneinfo *myTune;
+	gboolean audioOpen = FALSE, doPlay = FALSE, isFound = FALSE;
+	gboolean playedTune[XS_STIL_MAXENTRY + 1];
+	gint audioGot, songLength, i;
+	gchar *audioBuffer = NULL, *oversampleBuffer = NULL;
 
- (void)argPointer;
- 
- /* Initialize */
- XSDEBUG("entering player thread\n");
- XS_MUTEX_LOCK(xs_status);
- memcpy(&myStatus, &xs_status, sizeof(t_xs_status));
- myTune = xs_status.tuneInfo;
- XS_MUTEX_UNLOCK(xs_status);
+	(void) argPointer;
+
+	/* Initialize */
+	XSDEBUG("entering player thread\n");
+	XS_MUTEX_LOCK(xs_status);
+	memcpy(&myStatus, &xs_status, sizeof(t_xs_status));
+	myTune = xs_status.tuneInfo;
+	XS_MUTEX_UNLOCK(xs_status);
 
- xs_memset(&playedTune, 0, sizeof(playedTune));
+	xs_memset(&playedTune, 0, sizeof(playedTune));
 
- /* Allocate audio buffer */
- audioBuffer = (gchar *) g_malloc(XS_AUDIOBUF_SIZE);
- if (audioBuffer == NULL)
- 	{
-	XSERR("Couldn't allocate memory for audio data buffer!\n");
-	goto xs_err_exit;
- 	}
+	/* Allocate audio buffer */
+	audioBuffer = (gchar *) g_malloc(XS_AUDIOBUF_SIZE);
+	if (audioBuffer == NULL) {
+		XSERR("Couldn't allocate memory for audio data buffer!\n");
+		goto xs_err_exit;
+	}
 
- if (myStatus.oversampleEnable)
- 	{
- 	oversampleBuffer = (gchar *) g_malloc(XS_AUDIOBUF_SIZE * myStatus.oversampleFactor);
- 	if (oversampleBuffer == NULL)
-	 	{
-		XSERR("Couldn't allocate memory for audio oversampling buffer!\n");
-		goto xs_err_exit;
- 		}
+	if (myStatus.oversampleEnable) {
+		oversampleBuffer = (gchar *) g_malloc(XS_AUDIOBUF_SIZE * myStatus.oversampleFactor);
+		if (oversampleBuffer == NULL) {
+			XSERR("Couldn't allocate memory for audio oversampling buffer!\n");
+			goto xs_err_exit;
+		}
 	}
 
- /*
-  * Main player loop: while not stopped, loop here - play subtunes
-  */
- audioOpen = FALSE;
- doPlay = TRUE;
- while (xs_status.isPlaying && doPlay)
- {
- /* Automatic sub-tune change logic */
- XS_MUTEX_LOCK(xs_cfg);
- XS_MUTEX_LOCK(xs_status);
- assert(xs_status.currSong >= 1);
- assert(xs_status.currSong <= XS_STIL_MAXENTRY);
- myStatus.isPlaying = TRUE;
+	/*
+	 * Main player loop: while not stopped, loop here - play subtunes
+	 */
+	audioOpen = FALSE;
+	doPlay = TRUE;
+	while (xs_status.isPlaying && doPlay) {
+		/* Automatic sub-tune change logic */
+		XS_MUTEX_LOCK(xs_cfg);
+		XS_MUTEX_LOCK(xs_status);
+		assert(xs_status.currSong >= 1);
+		assert(xs_status.currSong <= XS_STIL_MAXENTRY);
+		myStatus.isPlaying = TRUE;
 
- if (xs_cfg.subAutoEnable && (myStatus.currSong == xs_status.currSong))
- 	{
- 	/* Check if currently selected sub-tune has been played already */
- 	if (playedTune[myStatus.currSong])
- 		{
- 		/* Find a tune that has not been played */
- 		XSDEBUG("tune #%i already played, finding next match ...\n", myStatus.currSong);
- 		isFound = FALSE;
- 		i = 0;
- 		while (!isFound && (++i <= myTune->nsubTunes))
- 			{
- 			if (xs_cfg.subAutoMinOnly)
- 				{
- 				/* A tune with minimum length must be found */
- 				if (!playedTune[i] && myTune->subTunes[i].tuneLength >= xs_cfg.subAutoMinTime)
- 					isFound = TRUE;
- 				} else {
- 				/* Any unplayed tune is okay */
- 				if (!playedTune[i])
- 					isFound = TRUE;
- 				}
- 			}
+		if (xs_cfg.subAutoEnable && (myStatus.currSong == xs_status.currSong)) {
+			/* Check if currently selected sub-tune has been played already */
+			if (playedTune[myStatus.currSong]) {
+				/* Find a tune that has not been played */
+				XSDEBUG("tune #%i already played, finding next match ...\n", myStatus.currSong);
+				isFound = FALSE;
+				i = 0;
+				while (!isFound && (++i <= myTune->nsubTunes)) {
+					if (xs_cfg.subAutoMinOnly) {
+						/* A tune with minimum length must be found */
+						if (!playedTune[i]
+						    && myTune->subTunes[i].tuneLength >= xs_cfg.subAutoMinTime)
+							isFound = TRUE;
+					} else {
+						/* Any unplayed tune is okay */
+						if (!playedTune[i])
+							isFound = TRUE;
+					}
+				}
 
-		if (isFound)
-			{
-			/* Set the new sub-tune */
-			XSDEBUG("found #%i\n", i);
-			xs_status.currSong = i;
-			} else
-			/* This is the end */
-			doPlay = FALSE;
+				if (isFound) {
+					/* Set the new sub-tune */
+					XSDEBUG("found #%i\n", i);
+					xs_status.currSong = i;
+				} else
+					/* This is the end */
+					doPlay = FALSE;
 
+				XS_MUTEX_UNLOCK(xs_status);
+				XS_MUTEX_UNLOCK(xs_cfg);
+				continue;	/* This is ugly, but ... */
+			}
+		}
+
+		/* Tell that we are initializing, update sub-tune controls */
+		myStatus.currSong = xs_status.currSong;
+		playedTune[myStatus.currSong] = TRUE;
 		XS_MUTEX_UNLOCK(xs_status);
 		XS_MUTEX_UNLOCK(xs_cfg);
-		continue; /* This is ugly, but ... */
- 		}
- 	}
+
+		XSDEBUG("subtune #%i selected, initializing...\n", myStatus.currSong);
 
- /* Tell that we are initializing, update sub-tune controls */ 
- myStatus.currSong = xs_status.currSong;
- playedTune[myStatus.currSong] = TRUE;
- XS_MUTEX_UNLOCK(xs_status);
- XS_MUTEX_UNLOCK(xs_cfg);
-
- XSDEBUG("subtune #%i selected, initializing...\n", myStatus.currSong);
-
- GDK_THREADS_ENTER(); 
- xs_subctrl_update();
- GDK_THREADS_LEAVE();
+		GDK_THREADS_ENTER();
+		xs_subctrl_update();
+		GDK_THREADS_LEAVE();
 
- /* Check minimum playtime */
- songLength = myTune->subTunes[myStatus.currSong - 1].tuneLength;
- if (xs_cfg.playMinTimeEnable && (songLength >= 0))
- 	{
-	if (songLength < xs_cfg.playMinTime)
-		songLength = xs_cfg.playMinTime;
-	}
+		/* Check minimum playtime */
+		songLength = myTune->subTunes[myStatus.currSong - 1].tuneLength;
+		if (xs_cfg.playMinTimeEnable && (songLength >= 0)) {
+			if (songLength < xs_cfg.playMinTime)
+				songLength = xs_cfg.playMinTime;
+		}
 
- /* Initialize song */
- if (!myStatus.sidPlayer->plrInitSong(&myStatus))
-	{
-	XSERR("Couldn't initialize SID-tune '%s' (sub-tune #%i)!\n",
-		myTune->sidFilename, myStatus.currSong);
-	goto xs_err_exit;
-	}
+		/* Initialize song */
+		if (!myStatus.sidPlayer->plrInitSong(&myStatus)) {
+			XSERR("Couldn't initialize SID-tune '%s' (sub-tune #%i)!\n",
+			      myTune->sidFilename, myStatus.currSong);
+			goto xs_err_exit;
+		}
 
 
- /* Open the audio output */
- if (!xs_plugin_ip.output->open_audio(myStatus.audioFormat, myStatus.audioFrequency, myStatus.audioChannels))
-	{
-	XSERR("Couldn't open XMMS audio output (fmt=%x, freq=%i, nchan=%i)!\n",
-	myStatus.audioFormat, myStatus.audioFrequency, myStatus.audioChannels);
-	
-	XS_MUTEX_LOCK(xs_status);
-	xs_status.isError = TRUE;
-	XS_MUTEX_UNLOCK(xs_status);
-	goto xs_err_exit;
-	}
-
- audioOpen = TRUE;
-
- /* Set song information for current subtune */
- xs_plugin_ip.set_info(
- 	myTune->subTunes[myStatus.currSong - 1].tuneTitle,
- 	(songLength > 0) ? (songLength * 1000) : -1,
- 	(myTune->subTunes[myStatus.currSong - 1].tuneSpeed > 0) ? (myTune->subTunes[myStatus.currSong - 1].tuneSpeed * 1000) : -1,
-	myStatus.audioFrequency,
-	myStatus.audioChannels);
-
+		/* Open the audio output */
+		if (!xs_plugin_ip.output->
+		    open_audio(myStatus.audioFormat, myStatus.audioFrequency, myStatus.audioChannels)) {
+			XSERR("Couldn't open XMMS audio output (fmt=%x, freq=%i, nchan=%i)!\n", myStatus.audioFormat,
+			      myStatus.audioFrequency, myStatus.audioChannels);
 
- XSDEBUG("playing\n");
-
- /*
-  * Play the subtune
-  */
- while (xs_status.isPlaying && myStatus.isPlaying && (xs_status.currSong == myStatus.currSong))
-	{
-	/* Render audio data */
-	if (myStatus.oversampleEnable)
-		{
-		/* Perform oversampled rendering */
-		audioGot = myStatus.sidPlayer->plrFillBuffer(&myStatus,
-			oversampleBuffer, (XS_AUDIOBUF_SIZE * myStatus.oversampleFactor));
-		
-		audioGot /= myStatus.oversampleFactor;		
-		
-		/* Execute rate-conversion with filtering */
-		if (xs_filter_rateconv(audioBuffer, oversampleBuffer,
-			myStatus.audioFormat, myStatus.oversampleFactor,
-			audioGot) < 0)
-			{
-			XSERR("Oversampling rate-conversion pass failed.\n");
 			XS_MUTEX_LOCK(xs_status);
 			xs_status.isError = TRUE;
 			XS_MUTEX_UNLOCK(xs_status);
 			goto xs_err_exit;
-			}
-		} else 
-		audioGot = myStatus.sidPlayer->plrFillBuffer(&myStatus, audioBuffer, XS_AUDIOBUF_SIZE);
+		}
+
+		audioOpen = TRUE;
+
+		/* Set song information for current subtune */
+		xs_plugin_ip.set_info(myTune->subTunes[myStatus.currSong - 1].tuneTitle,
+				      (songLength > 0) ? (songLength * 1000) : -1,
+				      (myTune->subTunes[myStatus.currSong - 1].tuneSpeed >
+				       0) ? (myTune->subTunes[myStatus.currSong - 1].tuneSpeed * 1000) : -1,
+				      myStatus.audioFrequency, myStatus.audioChannels);
+
+
+		XSDEBUG("playing\n");
 
-	/* I <3 visualice/haujobb */
-	xs_plugin_ip.add_vis_pcm(
-		xs_plugin_ip.output->written_time(),
-		myStatus.audioFormat, myStatus.audioChannels,
-		audioGot, audioBuffer);
+		/*
+		 * Play the subtune
+		 */
+		while (xs_status.isPlaying && myStatus.isPlaying && (xs_status.currSong == myStatus.currSong)) {
+			/* Render audio data */
+			if (myStatus.oversampleEnable) {
+				/* Perform oversampled rendering */
+				audioGot = myStatus.sidPlayer->plrFillBuffer(&myStatus,
+									     oversampleBuffer,
+									     (XS_AUDIOBUF_SIZE *
+									      myStatus.oversampleFactor));
 
-	/* Wait a little */
-	while (xs_status.isPlaying &&
-		(xs_status.currSong == myStatus.currSong) &&
-		(xs_plugin_ip.output->buffer_free() < audioGot))
-		xmms_usleep(500);
+				audioGot /= myStatus.oversampleFactor;
 
-	/* Output audio */
-	if (xs_status.isPlaying && (xs_status.currSong == myStatus.currSong))
-		xs_plugin_ip.output->write_audio(audioBuffer, audioGot);
+				/* Execute rate-conversion with filtering */
+				if (xs_filter_rateconv(audioBuffer, oversampleBuffer,
+						       myStatus.audioFormat, myStatus.oversampleFactor, audioGot) < 0) {
+					XSERR("Oversampling rate-conversion pass failed.\n");
+					XS_MUTEX_LOCK(xs_status);
+					xs_status.isError = TRUE;
+					XS_MUTEX_UNLOCK(xs_status);
+					goto xs_err_exit;
+				}
+			} else
+				audioGot = myStatus.sidPlayer->plrFillBuffer(&myStatus, audioBuffer, XS_AUDIOBUF_SIZE);
+
+			/* I <3 visualice/haujobb */
+			xs_plugin_ip.add_vis_pcm(xs_plugin_ip.output->written_time(),
+						 myStatus.audioFormat, myStatus.audioChannels, audioGot, audioBuffer);
 
-	/* Check if we have played enough */
-	if (xs_cfg.playMaxTimeEnable)
-		{
-		if (xs_cfg.playMaxTimeUnknown)
-			{
-			if ((songLength < 0) &&
-				(xs_plugin_ip.output->output_time() >= (xs_cfg.playMaxTime * 1000)))
-				myStatus.isPlaying = FALSE;
-			} else {
-			if (xs_plugin_ip.output->output_time() >= (xs_cfg.playMaxTime * 1000))
-				myStatus.isPlaying = FALSE;
+			/* Wait a little */
+			while (xs_status.isPlaying &&
+			       (xs_status.currSong == myStatus.currSong) &&
+			       (xs_plugin_ip.output->buffer_free() < audioGot))
+				xmms_usleep(500);
+
+			/* Output audio */
+			if (xs_status.isPlaying && (xs_status.currSong == myStatus.currSong))
+				xs_plugin_ip.output->write_audio(audioBuffer, audioGot);
+
+			/* Check if we have played enough */
+			if (xs_cfg.playMaxTimeEnable) {
+				if (xs_cfg.playMaxTimeUnknown) {
+					if ((songLength < 0) &&
+					    (xs_plugin_ip.output->output_time() >= (xs_cfg.playMaxTime * 1000)))
+						myStatus.isPlaying = FALSE;
+				} else {
+					if (xs_plugin_ip.output->output_time() >= (xs_cfg.playMaxTime * 1000))
+						myStatus.isPlaying = FALSE;
+				}
+			}
+
+			if (songLength >= 0) {
+				if (xs_plugin_ip.output->output_time() >= (songLength * 1000))
+					myStatus.isPlaying = FALSE;
 			}
 		}
 
-	if (songLength >= 0)
-		{
-		if (xs_plugin_ip.output->output_time() >= (songLength * 1000))
-			myStatus.isPlaying = FALSE;
-		}
-	}
+		XSDEBUG("subtune ended/stopped\n");
 
- XSDEBUG("subtune ended/stopped\n");
+		/* Close audio output plugin */
+		if (audioOpen) {
+			XSDEBUG("close audio #1\n");
+			xs_plugin_ip.output->close_audio();
+			audioOpen = FALSE;
+		}
 
- /* Close audio output plugin */
- if (audioOpen)
-	{
-	XSDEBUG("close audio #1\n");
-	xs_plugin_ip.output->close_audio();
-	audioOpen = FALSE;
+		/* Now determine if we continue by selecting other subtune or something */
+		if (!myStatus.isPlaying && !xs_cfg.subAutoEnable)
+			doPlay = FALSE;
 	}
 
- /* Now determine if we continue by selecting other subtune or something */
- if (!myStatus.isPlaying && !xs_cfg.subAutoEnable)
- 	doPlay = FALSE;
- }
-
-xs_err_exit:
- /* Close audio output plugin */
- if (audioOpen)
-	{
-	XSDEBUG("close audio #2\n");
-	xs_plugin_ip.output->close_audio();
+      xs_err_exit:
+	/* Close audio output plugin */
+	if (audioOpen) {
+		XSDEBUG("close audio #2\n");
+		xs_plugin_ip.output->close_audio();
 	}
 
- g_free(audioBuffer);
- g_free(oversampleBuffer);
+	g_free(audioBuffer);
+	g_free(oversampleBuffer);
 
- /* Set playing status to false (stopped), thus when
-  * XMMS next calls xs_get_time(), it can return appropriate
-  * value "not playing" status and XMMS knows to move to
-  * next entry in the playlist .. or whatever it wishes.
-  */
- XS_MUTEX_LOCK(xs_status);
- xs_status.isPlaying = FALSE;
- XS_MUTEX_UNLOCK(xs_status);
- 
- /* Exit the playing thread */
- XSDEBUG("exiting thread, bye.\n");
- pthread_exit(NULL);
+	/* Set playing status to false (stopped), thus when
+	 * XMMS next calls xs_get_time(), it can return appropriate
+	 * value "not playing" status and XMMS knows to move to
+	 * next entry in the playlist .. or whatever it wishes.
+	 */
+	XS_MUTEX_LOCK(xs_status);
+	xs_status.isPlaying = FALSE;
+	XS_MUTEX_UNLOCK(xs_status);
+
+	/* Exit the playing thread */
+	XSDEBUG("exiting thread, bye.\n");
+	pthread_exit(NULL);
 }
 
 
@@ -554,46 +529,43 @@
  * Usually you would also initialize the output-plugin, but
  * this is XMMS-SID and we do it on the player thread instead.
  */
-void xs_play_file(gchar *pcFilename)
+void xs_play_file(gchar * pcFilename)
 {
- assert(xs_status.sidPlayer);
+	assert(xs_status.sidPlayer);
 
- XSDEBUG("play '%s'\n", pcFilename);
- 
- /* Get tune information */
- if ((xs_status.tuneInfo =
- 	xs_status.sidPlayer->plrGetSIDInfo(pcFilename)) == NULL)
- 	return;
+	XSDEBUG("play '%s'\n", pcFilename);
 
- /* Initialize the tune */
- if (!xs_status.sidPlayer->plrLoadSID(&xs_status, pcFilename))
- 	{
- 	xs_tuneinfo_free(xs_status.tuneInfo);
- 	xs_status.tuneInfo = NULL;
- 	return;
- 	}
+	/* Get tune information */
+	if ((xs_status.tuneInfo = xs_status.sidPlayer->plrGetSIDInfo(pcFilename)) == NULL)
+		return;
 
- XSDEBUG("load ok\n");
- 
- /* Set general status information */
- xs_status.isPlaying	= TRUE;
- xs_status.isError	= FALSE;
- xs_status.currSong	= xs_status.tuneInfo->startTune;
- 
- /* Start the playing thread! */
- if (pthread_create(&xs_decode_thread, NULL, xs_playthread, NULL) < 0)
-	{
-	XSERR("Couldn't start playing thread!\n");
- 	xs_tuneinfo_free(xs_status.tuneInfo);
-	xs_status.tuneInfo = NULL;
-	xs_status.sidPlayer->plrDeleteSID(&xs_status);
+	/* Initialize the tune */
+	if (!xs_status.sidPlayer->plrLoadSID(&xs_status, pcFilename)) {
+		xs_tuneinfo_free(xs_status.tuneInfo);
+		xs_status.tuneInfo = NULL;
+		return;
 	}
 
- /* Okay, here the playing thread has started up and we
-  * return from here to XMMS. Rest is up to XMMS's GUI
-  * and playing thread.
-  */
- XSDEBUG("systems should be up?\n");
+	XSDEBUG("load ok\n");
+
+	/* Set general status information */
+	xs_status.isPlaying = TRUE;
+	xs_status.isError = FALSE;
+	xs_status.currSong = xs_status.tuneInfo->startTune;
+
+	/* Start the playing thread! */
+	if (pthread_create(&xs_decode_thread, NULL, xs_playthread, NULL) < 0) {
+		XSERR("Couldn't start playing thread!\n");
+		xs_tuneinfo_free(xs_status.tuneInfo);
+		xs_status.tuneInfo = NULL;
+		xs_status.sidPlayer->plrDeleteSID(&xs_status);
+	}
+
+	/* Okay, here the playing thread has started up and we
+	 * return from here to XMMS. Rest is up to XMMS's GUI
+	 * and playing thread.
+	 */
+	XSDEBUG("systems should be up?\n");
 }
 
 
@@ -609,33 +581,32 @@
  */
 void xs_stop(void)
 {
- XSDEBUG("STOP_REQ\n");
+	XSDEBUG("STOP_REQ\n");
 
- /* Close the sub-tune control window, if any */
- xs_subctrl_close();
+	/* Close the sub-tune control window, if any */
+	xs_subctrl_close();
 
- /* Lock xs_status and stop playing thread */
- XS_MUTEX_LOCK(xs_status);
- if (xs_status.isPlaying)
-	{
-	/* Stop playing */
-	XSDEBUG("stopping...\n");
-	xs_status.isPlaying = FALSE;
-	XS_MUTEX_UNLOCK(xs_status);
-	pthread_join(xs_decode_thread, NULL);
+	/* Lock xs_status and stop playing thread */
+	XS_MUTEX_LOCK(xs_status);
+	if (xs_status.isPlaying) {
+		/* Stop playing */
+		XSDEBUG("stopping...\n");
+		xs_status.isPlaying = FALSE;
+		XS_MUTEX_UNLOCK(xs_status);
+		pthread_join(xs_decode_thread, NULL);
 	} else {
-	XS_MUTEX_UNLOCK(xs_status);
+		XS_MUTEX_UNLOCK(xs_status);
 	}
 
- /* Status is now stopped, update the sub-tune
-  * controller in fileinfo window (if open)
-  */
- xs_fileinfo_update();
+	/* Status is now stopped, update the sub-tune
+	 * controller in fileinfo window (if open)
+	 */
+	xs_fileinfo_update();
 
- /* Free tune information */
- xs_status.sidPlayer->plrDeleteSID(&xs_status);
- xs_tuneinfo_free(xs_status.tuneInfo);
- xs_status.tuneInfo = NULL;
+	/* Free tune information */
+	xs_status.sidPlayer->plrDeleteSID(&xs_status);
+	xs_tuneinfo_free(xs_status.tuneInfo);
+	xs_status.tuneInfo = NULL;
 }
 
 
@@ -644,13 +615,13 @@
  */
 void xs_pause(short pauseState)
 {
- XS_MUTEX_LOCK(xs_status);
- /* FIXME FIX ME todo: pause should disable sub-tune controls */
- XS_MUTEX_UNLOCK(xs_status);
+	XS_MUTEX_LOCK(xs_status);
+	/* FIXME FIX ME todo: pause should disable sub-tune controls */
+	XS_MUTEX_UNLOCK(xs_status);
 
- xs_subctrl_close();
- xs_fileinfo_update();
- xs_plugin_ip.output->pause(pauseState);
+	xs_subctrl_close();
+	xs_fileinfo_update();
+	xs_plugin_ip.output->pause(pauseState);
 }
 
 
@@ -659,186 +630,172 @@
  */
 void xs_subctrl_setsong(void)
 {
- gint n;
- 
- XS_MUTEX_LOCK(xs_status);
- XS_MUTEX_LOCK(xs_subctrl);
- 
- if (xs_status.tuneInfo && xs_status.isPlaying)
- 	{
- 	n = (gint) GTK_ADJUSTMENT(xs_subctrl_adj)->value;
- 	if ((n >= 1) && (n <= xs_status.tuneInfo->nsubTunes))
- 		xs_status.currSong = n;
+	gint n;
+
+	XS_MUTEX_LOCK(xs_status);
+	XS_MUTEX_LOCK(xs_subctrl);
+
+	if (xs_status.tuneInfo && xs_status.isPlaying) {
+		n = (gint) GTK_ADJUSTMENT(xs_subctrl_adj)->value;
+		if ((n >= 1) && (n <= xs_status.tuneInfo->nsubTunes))
+			xs_status.currSong = n;
 	}
 
- XS_MUTEX_UNLOCK(xs_subctrl);
- XS_MUTEX_UNLOCK(xs_status);
+	XS_MUTEX_UNLOCK(xs_subctrl);
+	XS_MUTEX_UNLOCK(xs_status);
 }
 
 
 void xs_subctrl_prevsong(void)
 {
- XS_MUTEX_LOCK(xs_status);
- 
- if (xs_status.tuneInfo && xs_status.isPlaying)
- 	{
- 	if (xs_status.currSong > 1)
- 		xs_status.currSong--;
+	XS_MUTEX_LOCK(xs_status);
+
+	if (xs_status.tuneInfo && xs_status.isPlaying) {
+		if (xs_status.currSong > 1)
+			xs_status.currSong--;
 	}
 
- XS_MUTEX_UNLOCK(xs_status);
+	XS_MUTEX_UNLOCK(xs_status);
 
- xs_subctrl_update();
+	xs_subctrl_update();
 }
 
 
 void xs_subctrl_nextsong(void)
 {
- XS_MUTEX_LOCK(xs_status);
- 
- if (xs_status.tuneInfo && xs_status.isPlaying)
- 	{
- 	if (xs_status.currSong < xs_status.tuneInfo->nsubTunes)
- 		xs_status.currSong++;
+	XS_MUTEX_LOCK(xs_status);
+
+	if (xs_status.tuneInfo && xs_status.isPlaying) {
+		if (xs_status.currSong < xs_status.tuneInfo->nsubTunes)
+			xs_status.currSong++;
 	}
 
- XS_MUTEX_UNLOCK(xs_status);
+	XS_MUTEX_UNLOCK(xs_status);
 
- xs_subctrl_update();
+	xs_subctrl_update();
 }
 
 
 void xs_subctrl_update(void)
 {
- GtkAdjustment *tmpAdj;
- 
- XS_MUTEX_LOCK(xs_status);
- XS_MUTEX_LOCK(xs_subctrl);
- 
- /* Check if control window exists, we are currently playing and have a tune */
- if (xs_subctrl)
-	{
-	if (xs_status.tuneInfo && xs_status.isPlaying)
-		{
-	 	tmpAdj = GTK_ADJUSTMENT(xs_subctrl_adj);
- 	
- 		tmpAdj->value = xs_status.currSong;
- 		tmpAdj->lower = 1;
-		tmpAdj->upper = xs_status.tuneInfo->nsubTunes;
+	GtkAdjustment *tmpAdj;
+
+	XS_MUTEX_LOCK(xs_status);
+	XS_MUTEX_LOCK(xs_subctrl);
+
+	/* Check if control window exists, we are currently playing and have a tune */
+	if (xs_subctrl) {
+		if (xs_status.tuneInfo && xs_status.isPlaying) {
+			tmpAdj = GTK_ADJUSTMENT(xs_subctrl_adj);
+
+			tmpAdj->value = xs_status.currSong;
+			tmpAdj->lower = 1;
+			tmpAdj->upper = xs_status.tuneInfo->nsubTunes;
+			XS_MUTEX_UNLOCK(xs_status);
+			XS_MUTEX_UNLOCK(xs_subctrl);
+			gtk_adjustment_value_changed(tmpAdj);
+		} else {
+			XS_MUTEX_UNLOCK(xs_status);
+			XS_MUTEX_UNLOCK(xs_subctrl);
+			xs_subctrl_close();
+		}
+	} else {
+		XS_MUTEX_UNLOCK(xs_subctrl);
 		XS_MUTEX_UNLOCK(xs_status);
-		XS_MUTEX_UNLOCK(xs_subctrl);
- 		gtk_adjustment_value_changed(tmpAdj);
- 		} else {
- 		XS_MUTEX_UNLOCK(xs_status);
- 		XS_MUTEX_UNLOCK(xs_subctrl);
- 		xs_subctrl_close();
- 		}
- 	} else {
-	XS_MUTEX_UNLOCK(xs_subctrl);
-	XS_MUTEX_UNLOCK(xs_status);
 	}
 
- xs_fileinfo_update();
+	xs_fileinfo_update();
 }
 
 
 void xs_subctrl_close(void)
 {
- XS_MUTEX_LOCK(xs_subctrl);
+	XS_MUTEX_LOCK(xs_subctrl);
 
- if (xs_subctrl)
- 	{
-	gtk_widget_destroy(xs_subctrl);
-	xs_subctrl = NULL;
+	if (xs_subctrl) {
+		gtk_widget_destroy(xs_subctrl);
+		xs_subctrl = NULL;
 	}
 
- XS_MUTEX_UNLOCK(xs_subctrl);
+	XS_MUTEX_UNLOCK(xs_subctrl);
 }
 
 
-gboolean xs_subctrl_keypress(GtkWidget *win, GdkEventKey *ev)
+gboolean xs_subctrl_keypress(GtkWidget * win, GdkEventKey * ev)
 {
- (void)win;
- 
- if (ev->keyval == GDK_Escape)
- 	xs_subctrl_close();
+	(void) win;
 
- return FALSE;
+	if (ev->keyval == GDK_Escape)
+		xs_subctrl_close();
+
+	return FALSE;
 }
 
 
 void xs_subctrl_open(void)
 {
- GtkWidget *frame25, *hbox15, *subctrl_prev, *subctrl_current, *subctrl_next;
+	GtkWidget *frame25, *hbox15, *subctrl_prev, *subctrl_current, *subctrl_next;
 
- XS_MUTEX_LOCK(xs_subctrl);
- if (!xs_status.tuneInfo || !xs_status.isPlaying ||
-    xs_subctrl || (xs_status.tuneInfo->nsubTunes <= 1))
-    {
-    XS_MUTEX_UNLOCK(xs_subctrl);
-    return;
-    }
+	XS_MUTEX_LOCK(xs_subctrl);
+	if (!xs_status.tuneInfo || !xs_status.isPlaying || xs_subctrl || (xs_status.tuneInfo->nsubTunes <= 1)) {
+		XS_MUTEX_UNLOCK(xs_subctrl);
+		return;
+	}
 
- /* Create the pop-up window */
- xs_subctrl = gtk_window_new (GTK_WINDOW_DIALOG);
- gtk_widget_set_name (xs_subctrl, "xs_subctrl");
- gtk_object_set_data (GTK_OBJECT (xs_subctrl), "xs_subctrl", xs_subctrl);
+	/* Create the pop-up window */
+	xs_subctrl = gtk_window_new(GTK_WINDOW_DIALOG);
+	gtk_widget_set_name(xs_subctrl, "xs_subctrl");
+	gtk_object_set_data(GTK_OBJECT(xs_subctrl), "xs_subctrl", xs_subctrl);
 
- gtk_window_set_title(GTK_WINDOW(xs_subctrl), "Subtune Control");
- gtk_window_set_position(GTK_WINDOW(xs_subctrl), GTK_WIN_POS_MOUSE);
- gtk_container_set_border_width(GTK_CONTAINER(xs_subctrl), 0);
- gtk_window_set_policy(GTK_WINDOW(xs_subctrl), FALSE, FALSE, FALSE);
+	gtk_window_set_title(GTK_WINDOW(xs_subctrl), "Subtune Control");
+	gtk_window_set_position(GTK_WINDOW(xs_subctrl), GTK_WIN_POS_MOUSE);
+	gtk_container_set_border_width(GTK_CONTAINER(xs_subctrl), 0);
+	gtk_window_set_policy(GTK_WINDOW(xs_subctrl), FALSE, FALSE, FALSE);
 
- gtk_signal_connect(GTK_OBJECT(xs_subctrl), "destroy",
-	GTK_SIGNAL_FUNC(gtk_widget_destroyed), &xs_subctrl);
+	gtk_signal_connect(GTK_OBJECT(xs_subctrl), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &xs_subctrl);
 
- gtk_signal_connect(GTK_OBJECT(xs_subctrl), "focus_out_event",
-	GTK_SIGNAL_FUNC(xs_subctrl_close), NULL);
+	gtk_signal_connect(GTK_OBJECT(xs_subctrl), "focus_out_event", GTK_SIGNAL_FUNC(xs_subctrl_close), NULL);
 
- gtk_widget_realize(xs_subctrl);
- gdk_window_set_decorations(xs_subctrl->window, (GdkWMDecoration) 0);
+	gtk_widget_realize(xs_subctrl);
+	gdk_window_set_decorations(xs_subctrl->window, (GdkWMDecoration) 0);
 
 
- /* Create the control widgets */
- frame25 = gtk_frame_new (NULL);
- gtk_container_add (GTK_CONTAINER (xs_subctrl), frame25);
- gtk_container_set_border_width (GTK_CONTAINER (frame25), 2);
- gtk_frame_set_shadow_type (GTK_FRAME (frame25), GTK_SHADOW_OUT);
+	/* Create the control widgets */
+	frame25 = gtk_frame_new(NULL);
+	gtk_container_add(GTK_CONTAINER(xs_subctrl), frame25);
+	gtk_container_set_border_width(GTK_CONTAINER(frame25), 2);
+	gtk_frame_set_shadow_type(GTK_FRAME(frame25), GTK_SHADOW_OUT);
 
- hbox15 = gtk_hbox_new (FALSE, 4);
- gtk_container_add (GTK_CONTAINER (frame25), hbox15);
+	hbox15 = gtk_hbox_new(FALSE, 4);
+	gtk_container_add(GTK_CONTAINER(frame25), hbox15);
 
- subctrl_prev = gtk_button_new_with_label (" < ");
- gtk_widget_set_name (subctrl_prev, "subctrl_prev");
- gtk_box_pack_start (GTK_BOX (hbox15), subctrl_prev, FALSE, FALSE, 0);
+	subctrl_prev = gtk_button_new_with_label(" < ");
+	gtk_widget_set_name(subctrl_prev, "subctrl_prev");
+	gtk_box_pack_start(GTK_BOX(hbox15), subctrl_prev, FALSE, FALSE, 0);
 
- xs_subctrl_adj = gtk_adjustment_new (xs_status.currSong, 1, xs_status.tuneInfo->nsubTunes, 1, 1, 0);
- gtk_signal_connect (GTK_OBJECT (xs_subctrl_adj), "value_changed",
-	GTK_SIGNAL_FUNC (xs_subctrl_setsong), NULL);
+	xs_subctrl_adj = gtk_adjustment_new(xs_status.currSong, 1, xs_status.tuneInfo->nsubTunes, 1, 1, 0);
+	gtk_signal_connect(GTK_OBJECT(xs_subctrl_adj), "value_changed", GTK_SIGNAL_FUNC(xs_subctrl_setsong), NULL);
 
- subctrl_current = gtk_hscale_new (GTK_ADJUSTMENT(xs_subctrl_adj));
- gtk_widget_set_name (subctrl_current, "subctrl_current");
- gtk_box_pack_start (GTK_BOX (hbox15), subctrl_current, FALSE, TRUE, 0);
- gtk_scale_set_digits (GTK_SCALE (subctrl_current), 0);
- gtk_range_set_update_policy (GTK_RANGE (subctrl_current), GTK_UPDATE_DELAYED);
- gtk_widget_grab_focus (subctrl_current);
-
- subctrl_next = gtk_button_new_with_label (" > ");
- gtk_widget_set_name (subctrl_next, "subctrl_next");
- gtk_box_pack_start (GTK_BOX (hbox15), subctrl_next, FALSE, FALSE, 0);
+	subctrl_current = gtk_hscale_new(GTK_ADJUSTMENT(xs_subctrl_adj));
+	gtk_widget_set_name(subctrl_current, "subctrl_current");
+	gtk_box_pack_start(GTK_BOX(hbox15), subctrl_current, FALSE, TRUE, 0);
+	gtk_scale_set_digits(GTK_SCALE(subctrl_current), 0);
+	gtk_range_set_update_policy(GTK_RANGE(subctrl_current), GTK_UPDATE_DELAYED);
+	gtk_widget_grab_focus(subctrl_current);
 
- gtk_signal_connect (GTK_OBJECT (subctrl_prev), "clicked",
-	GTK_SIGNAL_FUNC (xs_subctrl_prevsong), NULL);
+	subctrl_next = gtk_button_new_with_label(" > ");
+	gtk_widget_set_name(subctrl_next, "subctrl_next");
+	gtk_box_pack_start(GTK_BOX(hbox15), subctrl_next, FALSE, FALSE, 0);
 
- gtk_signal_connect (GTK_OBJECT (subctrl_next), "clicked",
-	GTK_SIGNAL_FUNC (xs_subctrl_nextsong), NULL);
+	gtk_signal_connect(GTK_OBJECT(subctrl_prev), "clicked", GTK_SIGNAL_FUNC(xs_subctrl_prevsong), NULL);
 
- gtk_signal_connect (GTK_OBJECT (xs_subctrl), "key_press_event",
- 	GTK_SIGNAL_FUNC (xs_subctrl_keypress), NULL);
- 
- gtk_widget_show_all(xs_subctrl);
+	gtk_signal_connect(GTK_OBJECT(subctrl_next), "clicked", GTK_SIGNAL_FUNC(xs_subctrl_nextsong), NULL);
+
+	gtk_signal_connect(GTK_OBJECT(xs_subctrl), "key_press_event", GTK_SIGNAL_FUNC(xs_subctrl_keypress), NULL);
 
- XS_MUTEX_UNLOCK(xs_subctrl);
+	gtk_widget_show_all(xs_subctrl);
+
+	XS_MUTEX_UNLOCK(xs_subctrl);
 }
 
 
@@ -853,43 +810,39 @@
  */
 void xs_seek(gint iTime)
 {
- /* Check status */
- XS_MUTEX_LOCK(xs_status);
- if (!xs_status.tuneInfo || !xs_status.isPlaying)
- 	{
- 	XS_MUTEX_UNLOCK(xs_status);
- 	return;
- 	}
+	/* Check status */
+	XS_MUTEX_LOCK(xs_status);
+	if (!xs_status.tuneInfo || !xs_status.isPlaying) {
+		XS_MUTEX_UNLOCK(xs_status);
+		return;
+	}
 
- /* Act according to settings */
- switch (xs_cfg.subsongControl) {
- case XS_SSC_SEEK:
-	if (iTime < xs_status.lastTime)
-		{
-	 	if (xs_status.currSong > 1)
- 			xs_status.currSong--;
-		} else
-	if (iTime > xs_status.lastTime)
-		{
-	 	if (xs_status.currSong < xs_status.tuneInfo->nsubTunes)
- 			xs_status.currSong++;
+	/* Act according to settings */
+	switch (xs_cfg.subsongControl) {
+	case XS_SSC_SEEK:
+		if (iTime < xs_status.lastTime) {
+			if (xs_status.currSong > 1)
+				xs_status.currSong--;
+		} else if (iTime > xs_status.lastTime) {
+			if (xs_status.currSong < xs_status.tuneInfo->nsubTunes)
+				xs_status.currSong++;
 		}
-	break;
+		break;
 
- case XS_SSC_POPUP:
- 	xs_subctrl_open();
- 	break;
- 
- /* If we have song-position patch, check settings */
+	case XS_SSC_POPUP:
+		xs_subctrl_open();
+		break;
+
+		/* If we have song-position patch, check settings */
 #ifdef HAVE_SONG_POSITION
- case XS_SSC_PATCH:
-	if ((iTime > 0) && (iTime <= xs_status.tuneInfo->nsubTunes))
-		xs_status.currSong = iTime;
-	break;
+	case XS_SSC_PATCH:
+		if ((iTime > 0) && (iTime <= xs_status.tuneInfo->nsubTunes))
+			xs_status.currSong = iTime;
+		break;
 #endif
- }
+	}
 
- XS_MUTEX_UNLOCK(xs_status);
+	XS_MUTEX_UNLOCK(xs_status);
 }
 
 
@@ -902,45 +855,42 @@
  */
 gint xs_get_time(void)
 {
- /* If errorflag is set, return -2 to signal it to XMMS's idle callback */
- XS_MUTEX_LOCK(xs_status);
- if (xs_status.isError)
- 	{
- 	XS_MUTEX_UNLOCK(xs_status);
-	return -2;
+	/* If errorflag is set, return -2 to signal it to XMMS's idle callback */
+	XS_MUTEX_LOCK(xs_status);
+	if (xs_status.isError) {
+		XS_MUTEX_UNLOCK(xs_status);
+		return -2;
+	}
+
+	/* If there is no tune, return -1 */
+	if (!xs_status.tuneInfo) {
+		XS_MUTEX_UNLOCK(xs_status);
+		return -1;
 	}
 
- /* If there is no tune, return -1 */
- if (!xs_status.tuneInfo)
- 	{
- 	XS_MUTEX_UNLOCK(xs_status);
- 	return -1;
- 	}
- 
- /* If tune has ended, return -1 */
- if (!xs_status.isPlaying)
- 	{
- 	XS_MUTEX_UNLOCK(xs_status);
-	return -1;
+	/* If tune has ended, return -1 */
+	if (!xs_status.isPlaying) {
+		XS_MUTEX_UNLOCK(xs_status);
+		return -1;
 	}
 
- /* Let's see what we do */
- switch (xs_cfg.subsongControl) {
- case XS_SSC_SEEK:
- 	xs_status.lastTime = (xs_plugin_ip.output->output_time() / 1000);
- 	break;
- 
+	/* Let's see what we do */
+	switch (xs_cfg.subsongControl) {
+	case XS_SSC_SEEK:
+		xs_status.lastTime = (xs_plugin_ip.output->output_time() / 1000);
+		break;
+
 #ifdef HAVE_SONG_POSITION
- case XS_SSC_PATCH:
-	set_song_position(xs_status.currSong, 1, xs_status.tuneInfo->nsubTunes);
-	break;
+	case XS_SSC_PATCH:
+		set_song_position(xs_status.currSong, 1, xs_status.tuneInfo->nsubTunes);
+		break;
 #endif
- }
- 
- XS_MUTEX_UNLOCK(xs_status);
+	}
 
- /* Return output time reported by audio output plugin */
- return xs_plugin_ip.output->output_time();
+	XS_MUTEX_UNLOCK(xs_status);
+
+	/* Return output time reported by audio output plugin */
+	return xs_plugin_ip.output->output_time();
 }
 
 
@@ -950,107 +900,105 @@
  * Subsequent changes to information are made by the player thread,
  * which uses xs_plugin_ip.set_info();
  */
-void xs_get_song_info(gchar *songFilename, gchar **songTitle, gint *songLength)
+void xs_get_song_info(gchar * songFilename, gchar ** songTitle, gint * songLength)
 {
- t_xs_tuneinfo *pInfo;
- gint tmpInt;
- 
- /* Get tune information from emulation engine */
- pInfo = xs_status.sidPlayer->plrGetSIDInfo(songFilename);
- if (!pInfo) return;
- 
- /* Get sub-tune information, if available */
- if ((pInfo->startTune > 0) && (pInfo->startTune <= pInfo->nsubTunes))
- 	{
-	(*songTitle) = g_strdup(pInfo->subTunes[pInfo->startTune - 1].tuneTitle);
+	t_xs_tuneinfo *pInfo;
+	gint tmpInt;
+
+	/* Get tune information from emulation engine */
+	pInfo = xs_status.sidPlayer->plrGetSIDInfo(songFilename);
+	if (!pInfo)
+		return;
 
-	tmpInt = pInfo->subTunes[pInfo->startTune - 1].tuneLength;
-	if (tmpInt < 0)
-		(*songLength) = -1;
+	/* Get sub-tune information, if available */
+	if ((pInfo->startTune > 0) && (pInfo->startTune <= pInfo->nsubTunes)) {
+		(*songTitle) = g_strdup(pInfo->subTunes[pInfo->startTune - 1].tuneTitle);
+
+		tmpInt = pInfo->subTunes[pInfo->startTune - 1].tuneLength;
+		if (tmpInt < 0)
+			(*songLength) = -1;
 		else
-		(*songLength) = (tmpInt * 1000);
+			(*songLength) = (tmpInt * 1000);
 	}
 
- /* Free tune information */	
- xs_tuneinfo_free(pInfo);
+	/* Free tune information */
+	xs_tuneinfo_free(pInfo);
 }
 
 
 /* Allocate a new tune information structure
  */
-t_xs_tuneinfo *xs_tuneinfo_new(gchar *pcFilename, gint nsubTunes, gint startTune,
-	gchar *sidName, gchar *sidComposer, gchar *sidCopyright,
-	gint loadAddr, gint initAddr, gint playAddr, gint dataFileLen)
+t_xs_tuneinfo *xs_tuneinfo_new(gchar * pcFilename, gint nsubTunes, gint startTune,
+			       gchar * sidName, gchar * sidComposer, gchar * sidCopyright,
+			       gint loadAddr, gint initAddr, gint playAddr, gint dataFileLen)
 {
- t_xs_tuneinfo *pResult;
- 
- /* Allocate structure */
- pResult = (t_xs_tuneinfo *) g_malloc0(sizeof(t_xs_tuneinfo));
- if (!pResult)
- 	{
- 	XSERR("Could not allocate memory for t_xs_tuneinfo ('%s')\n", pcFilename);
- 	return NULL;
- 	}
- 
- pResult->sidFilename = g_strdup(pcFilename);
- if (!pResult->sidFilename)
- 	{
- 	XSERR("Could not allocate sidFilename ('%s')\n", pcFilename);
- 	g_free(pResult);
- 	return NULL;
- 	}
+	t_xs_tuneinfo *pResult;
+
+	/* Allocate structure */
+	pResult = (t_xs_tuneinfo *) g_malloc0(sizeof(t_xs_tuneinfo));
+	if (!pResult) {
+		XSERR("Could not allocate memory for t_xs_tuneinfo ('%s')\n", pcFilename);
+		return NULL;
+	}
+
+	pResult->sidFilename = g_strdup(pcFilename);
+	if (!pResult->sidFilename) {
+		XSERR("Could not allocate sidFilename ('%s')\n", pcFilename);
+		g_free(pResult);
+		return NULL;
+	}
 
- /* Allocate space for subtune information */
- if (nsubTunes > 0)
- 	{
- 	pResult->subTunes = g_malloc0(sizeof(t_xs_subtuneinfo) * nsubTunes);
- 	if (!pResult->subTunes)
- 		{
- 		XSERR("Could not allocate memory for t_xs_subtuneinfo ('%s', %i)\n",
- 		pcFilename, nsubTunes);
+	/* Allocate space for subtune information */
+	if (nsubTunes > 0) {
+		pResult->subTunes = g_malloc0(sizeof(t_xs_subtuneinfo) * nsubTunes);
+		if (!pResult->subTunes) {
+			XSERR("Could not allocate memory for t_xs_subtuneinfo ('%s', %i)\n", pcFilename, nsubTunes);
 
-	 	g_free(pResult->sidFilename);
- 		g_free(pResult);
- 		return NULL;
- 		}
+			g_free(pResult->sidFilename);
+			g_free(pResult);
+			return NULL;
+		}
 	}
- 
- /* The following allocations don't matter if they fail */
- pResult->sidName	= g_strdup(sidName);
- pResult->sidComposer	= g_strdup(sidComposer);
- pResult->sidCopyright	= g_strdup(sidCopyright);
+
+	/* The following allocations don't matter if they fail */
+	pResult->sidName = g_strdup(sidName);
+	pResult->sidComposer = g_strdup(sidComposer);
+	pResult->sidCopyright = g_strdup(sidCopyright);
 
- pResult->nsubTunes	= nsubTunes;
- pResult->startTune	= startTune;
+	pResult->nsubTunes = nsubTunes;
+	pResult->startTune = startTune;
 
- pResult->loadAddr	= loadAddr;
- pResult->initAddr	= initAddr;
- pResult->playAddr	= playAddr;
- pResult->dataFileLen	= dataFileLen;
- 
- return pResult;
+	pResult->loadAddr = loadAddr;
+	pResult->initAddr = initAddr;
+	pResult->playAddr = playAddr;
+	pResult->dataFileLen = dataFileLen;
+
+	return pResult;
 }
 
 
 /* Free given tune information structure
  */
-void xs_tuneinfo_free(t_xs_tuneinfo *pTune)
+void xs_tuneinfo_free(t_xs_tuneinfo * pTune)
 {
- gint i;
- if (!pTune) return;
+	gint i;
+	if (!pTune)
+		return;
+
+	for (i = 0; i < pTune->nsubTunes; i++) {
+		g_free(pTune->subTunes[i].tuneTitle);
+		pTune->subTunes[i].tuneTitle = NULL;
+	}
 
- for (i = 0; i < pTune->nsubTunes; i++)
- 	{
-	g_free(pTune->subTunes[i].tuneTitle);
-	pTune->subTunes[i].tuneTitle = NULL;
- 	}
- 
- g_free(pTune->subTunes);
- pTune->nsubTunes = 0;
- g_free(pTune->sidFilename);	pTune->sidFilename = NULL;
- g_free(pTune->sidName);	pTune->sidName = NULL;
- g_free(pTune->sidComposer);	pTune->sidComposer = NULL;
- g_free(pTune->sidCopyright);	pTune->sidCopyright = NULL;
- g_free(pTune);
+	g_free(pTune->subTunes);
+	pTune->nsubTunes = 0;
+	g_free(pTune->sidFilename);
+	pTune->sidFilename = NULL;
+	g_free(pTune->sidName);
+	pTune->sidName = NULL;
+	g_free(pTune->sidComposer);
+	pTune->sidComposer = NULL;
+	g_free(pTune->sidCopyright);
+	pTune->sidCopyright = NULL;
+	g_free(pTune);
 }
-
--- a/src/xs_about.c	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_about.c	Mon Nov 07 09:50:04 2005 +0000
@@ -37,25 +37,25 @@
  */
 gint xs_about_theme(void)
 {
- const gint iSession = 0; /* Assume session 0 */
- gint iPos;
+	const gint iSession = 0;	/* Assume session 0 */
+	gint iPos;
 
- /* Stop current song, add theme to playlist, play. */
- xmms_remote_stop(iSession);
- iPos = xmms_remote_get_playlist_length(iSession);
- xmms_remote_playlist_add_url_string(iSession, THEMETUNE_FILE);
- xmms_remote_set_playlist_pos(iSession, iPos);
- xmms_remote_play(iSession);
- return 0;
+	/* Stop current song, add theme to playlist, play. */
+	xmms_remote_stop(iSession);
+	iPos = xmms_remote_get_playlist_length(iSession);
+	xmms_remote_playlist_add_url_string(iSession, THEMETUNE_FILE);
+	xmms_remote_set_playlist_pos(iSession, iPos);
+	xmms_remote_play(iSession);
+	return 0;
 }
 #endif
 
 
 gint xs_about_ok(void)
 {
- gtk_widget_destroy(xs_aboutwin);
- xs_aboutwin = NULL;
- return 0;
+	gtk_widget_destroy(xs_aboutwin);
+	xs_aboutwin = NULL;
+	return 0;
 }
 
 
@@ -64,163 +64,143 @@
  */
 void xs_about(void)
 {
- GtkWidget *about_vbox1;
- GtkWidget *about_frame;
- GtkWidget *about_logo;
- GdkPixmap *about_logo_pixmap = NULL, *about_logo_mask = NULL;
- GtkWidget *about_scrwin;
- GtkWidget *about_text;
- GtkWidget *alignment6;
- GtkWidget *about_close;
+	GtkWidget *about_vbox1;
+	GtkWidget *about_frame;
+	GtkWidget *about_logo;
+	GdkPixmap *about_logo_pixmap = NULL, *about_logo_mask = NULL;
+	GtkWidget *about_scrwin;
+	GtkWidget *about_text;
+	GtkWidget *alignment6;
+	GtkWidget *about_close;
 
- /* Check if there already is an open about window */
- if (xs_aboutwin != NULL)
- 	{
-	gdk_window_raise(xs_aboutwin->window);
-	return;
+	/* Check if there already is an open about window */
+	if (xs_aboutwin != NULL) {
+		gdk_window_raise(xs_aboutwin->window);
+		return;
 	}
 
- /* No, create one ... */	
- xs_aboutwin = gtk_window_new (GTK_WINDOW_DIALOG);
- gtk_widget_set_name (xs_aboutwin, "xs_aboutwin");
- gtk_object_set_data (GTK_OBJECT (xs_aboutwin), "xs_aboutwin", xs_aboutwin);
- gtk_window_set_title (GTK_WINDOW (xs_aboutwin), "About " PACKAGE_STRING);
- gtk_window_set_default_size (GTK_WINDOW (xs_aboutwin), 300, -1);
+	/* No, create one ... */
+	xs_aboutwin = gtk_window_new(GTK_WINDOW_DIALOG);
+	gtk_widget_set_name(xs_aboutwin, "xs_aboutwin");
+	gtk_object_set_data(GTK_OBJECT(xs_aboutwin), "xs_aboutwin", xs_aboutwin);
+	gtk_window_set_title(GTK_WINDOW(xs_aboutwin), "About " PACKAGE_STRING);
+	gtk_window_set_default_size(GTK_WINDOW(xs_aboutwin), 300, -1);
 
- about_vbox1 = gtk_vbox_new (FALSE, 0);
- gtk_widget_set_name (about_vbox1, "about_vbox1");
- gtk_widget_ref (about_vbox1);
- gtk_object_set_data_full (GTK_OBJECT (xs_aboutwin), "about_vbox1", about_vbox1,
-                          (GtkDestroyNotify) gtk_widget_unref);
- gtk_widget_show (about_vbox1);
- gtk_container_add (GTK_CONTAINER (xs_aboutwin), about_vbox1);
+	about_vbox1 = gtk_vbox_new(FALSE, 0);
+	gtk_widget_set_name(about_vbox1, "about_vbox1");
+	gtk_widget_ref(about_vbox1);
+	gtk_object_set_data_full(GTK_OBJECT(xs_aboutwin), "about_vbox1", about_vbox1,
+				 (GtkDestroyNotify) gtk_widget_unref);
+	gtk_widget_show(about_vbox1);
+	gtk_container_add(GTK_CONTAINER(xs_aboutwin), about_vbox1);
 
 #ifdef HAVE_THEMETUNE
- about_frame = gtk_button_new();
+	about_frame = gtk_button_new();
 #else
- about_frame = gtk_frame_new (NULL);
+	about_frame = gtk_frame_new(NULL);
 #endif
- gtk_widget_set_name (about_frame, "about_frame");
- gtk_widget_ref (about_frame);
- gtk_object_set_data_full (GTK_OBJECT (xs_aboutwin), "about_frame", about_frame,
-                          (GtkDestroyNotify) gtk_widget_unref);
- gtk_widget_show (about_frame);
- gtk_box_pack_start (GTK_BOX (about_vbox1), about_frame, FALSE, FALSE, 0);
- gtk_container_set_border_width (GTK_CONTAINER (about_frame), 4);
+	gtk_widget_set_name(about_frame, "about_frame");
+	gtk_widget_ref(about_frame);
+	gtk_object_set_data_full(GTK_OBJECT(xs_aboutwin), "about_frame", about_frame,
+				 (GtkDestroyNotify) gtk_widget_unref);
+	gtk_widget_show(about_frame);
+	gtk_box_pack_start(GTK_BOX(about_vbox1), about_frame, FALSE, FALSE, 0);
+	gtk_container_set_border_width(GTK_CONTAINER(about_frame), 4);
 
 #ifdef HAVE_THEMETUNE
- gtk_signal_connect (GTK_OBJECT (about_frame), "clicked", GTK_SIGNAL_FUNC (xs_about_theme), NULL);
+	gtk_signal_connect(GTK_OBJECT(about_frame), "clicked", GTK_SIGNAL_FUNC(xs_about_theme), NULL);
 #else
- gtk_frame_set_shadow_type (GTK_FRAME (about_frame), GTK_SHADOW_OUT);
+	gtk_frame_set_shadow_type(GTK_FRAME(about_frame), GTK_SHADOW_OUT);
 #endif
 
- /* Create the Gdk data for logo pixmap */
- gtk_widget_realize (xs_aboutwin);
- about_logo_pixmap = gdk_pixmap_create_from_xpm_d(
- 	xs_aboutwin->window,
- 	&about_logo_mask,
- 	NULL,
- 	(gchar **) xmms_sid_logo_xpm);
+	/* Create the Gdk data for logo pixmap */
+	gtk_widget_realize(xs_aboutwin);
+	about_logo_pixmap = gdk_pixmap_create_from_xpm_d(xs_aboutwin->window,
+							 &about_logo_mask, NULL, (gchar **) xmms_sid_logo_xpm);
+
+	about_logo = gtk_pixmap_new(about_logo_pixmap, about_logo_mask);
 
- about_logo = gtk_pixmap_new(about_logo_pixmap, about_logo_mask);
-
- /* Create logo widget */
- gtk_widget_set_name (about_logo, "about_logo");
- gtk_widget_ref (about_logo);
- gtk_object_set_data_full (GTK_OBJECT (xs_aboutwin), "about_logo", about_logo,
-                          (GtkDestroyNotify) gtk_widget_unref);
- gtk_widget_show (about_logo);
- gtk_container_add (GTK_CONTAINER (about_frame), about_logo);
- gtk_misc_set_padding (GTK_MISC (about_logo), 0, 6);
+	/* Create logo widget */
+	gtk_widget_set_name(about_logo, "about_logo");
+	gtk_widget_ref(about_logo);
+	gtk_object_set_data_full(GTK_OBJECT(xs_aboutwin), "about_logo", about_logo,
+				 (GtkDestroyNotify) gtk_widget_unref);
+	gtk_widget_show(about_logo);
+	gtk_container_add(GTK_CONTAINER(about_frame), about_logo);
+	gtk_misc_set_padding(GTK_MISC(about_logo), 0, 6);
 
- about_scrwin = gtk_scrolled_window_new (NULL, NULL);
- gtk_widget_set_name (about_scrwin, "about_scrwin");
- gtk_widget_ref (about_scrwin);
- gtk_object_set_data_full (GTK_OBJECT (xs_aboutwin), "about_scrwin", about_scrwin,
-                          (GtkDestroyNotify) gtk_widget_unref);
- gtk_widget_show (about_scrwin);
- gtk_box_pack_start (GTK_BOX (about_vbox1), about_scrwin, TRUE, TRUE, 0);
- gtk_container_set_border_width (GTK_CONTAINER (about_scrwin), 8);
- gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (about_scrwin), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
+	about_scrwin = gtk_scrolled_window_new(NULL, NULL);
+	gtk_widget_set_name(about_scrwin, "about_scrwin");
+	gtk_widget_ref(about_scrwin);
+	gtk_object_set_data_full(GTK_OBJECT(xs_aboutwin), "about_scrwin", about_scrwin,
+				 (GtkDestroyNotify) gtk_widget_unref);
+	gtk_widget_show(about_scrwin);
+	gtk_box_pack_start(GTK_BOX(about_vbox1), about_scrwin, TRUE, TRUE, 0);
+	gtk_container_set_border_width(GTK_CONTAINER(about_scrwin), 8);
+	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(about_scrwin), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
 
- about_text = gtk_text_new (NULL, NULL);
- gtk_widget_set_name (about_text, "about_text");
- gtk_widget_ref (about_text);
- gtk_object_set_data_full (GTK_OBJECT (xs_aboutwin), "about_text", about_text,
-                          (GtkDestroyNotify) gtk_widget_unref);
- gtk_widget_show (about_text);
- gtk_container_add (GTK_CONTAINER (about_scrwin), about_text);
- gtk_widget_set_usize (about_text, -2, 100);
- gtk_text_insert (GTK_TEXT (about_text), NULL, NULL, NULL,
- 	"\n"
- 	"(C) Copyright 1999-2005\n"
-	"\tTecnic Software productions (TNSP)\n"
-	"\n"
-	"Programming and design\n"
-	"\tMatti 'ccr' Hämäläinen\n"
-	"\n"
+	about_text = gtk_text_new(NULL, NULL);
+	gtk_widget_set_name(about_text, "about_text");
+	gtk_widget_ref(about_text);
+	gtk_object_set_data_full(GTK_OBJECT(xs_aboutwin), "about_text", about_text,
+				 (GtkDestroyNotify) gtk_widget_unref);
+	gtk_widget_show(about_text);
+	gtk_container_add(GTK_CONTAINER(about_scrwin), about_text);
+	gtk_widget_set_usize(about_text, -2, 100);
+	gtk_text_insert(GTK_TEXT(about_text), NULL, NULL, NULL,
+			"\n"
+			"(C) Copyright 1999-2005\n"
+			"\tTecnic Software productions (TNSP)\n"
+			"\n" "Programming and design\n" "\tMatti 'ccr' Hämäläinen\n" "\n"
 #ifdef HAVE_SIDPLAY1
-	"libSIDPlay1 created by\n"
-	"\tMichael Schwendt\n"
-	"\n"
+			"libSIDPlay1 created by\n" "\tMichael Schwendt\n" "\n"
 #endif
 #ifdef HAVE_SIDPLAY2
-	"libSIDPlay2 and reSID created by\n"
-	"\tSimon White, Dag Lem,\n"
-	"\tMichael Schwendt and rest.\n"
-	"\n"
+			"libSIDPlay2 and reSID created by\n"
+			"\tSimon White, Dag Lem,\n" "\tMichael Schwendt and rest.\n" "\n"
 #endif
 #ifdef HAVE_THEMETUNE
-	"\"Kummatti City\", theme of XMMS-SID 0.8\n"
-	"\tby Ari 'Agemixer' Yliaho\n"
-	"\t(C) Copyright 1998 Scallop\n"
-	"\t(Refer to README for license)\n"
-	"\n"
+			"\"Kummatti City\", theme of XMMS-SID 0.8\n"
+			"\tby Ari 'Agemixer' Yliaho\n"
+			"\t(C) Copyright 1998 Scallop\n" "\t(Refer to README for license)\n" "\n"
 #endif
-	"Original XMMS-SID (v0.4) by\n"
-	"\tWillem Monsuwe\n"
-	"\n", -1);
+			"Original XMMS-SID (v0.4) by\n" "\tWillem Monsuwe\n" "\n", -1);
+
+	gtk_text_insert(GTK_TEXT(about_text), NULL, NULL, NULL,
+			"Greetings fly out to ...\n"
+			"\tEveryone at #Linux.Fi, #Fireball,\n"
+			"\t#TNSP and #c-64 of IRCNet, #xmms\n"
+			"\tof Freenode.net.\n"
+			"\n"
+			"\tDekadence, PWP, Byterapers,\n"
+			"\tmfx, Unique, Fairlight, iSO,\n"
+			"\tWrath Designs, Padua, Extend,\n"
+			"\tPHn, Creators, Cosine, tAAt,\n" "\tViruz, Crest and Skalaria.\n" "\n", -1);
+
+	gtk_text_insert(GTK_TEXT(about_text), NULL, NULL, NULL,
+			"Special thanks\n"
+			"\tGerfried 'Alfie' Fuchs\n"
+			"\tAndreas 'mrsid' Varga\n" "\tAll the betatesters.\n" "\tAll the users!\n", -1);
 
- gtk_text_insert (GTK_TEXT (about_text), NULL, NULL, NULL,
-	"Greetings fly out to ...\n"
-	"\tEveryone at #Linux.Fi, #Fireball,\n"
-	"\t#TNSP and #c-64 of IRCNet, #xmms\n"
-	"\tof Freenode.net.\n"
-	"\n"
-	"\tDekadence, PWP, Byterapers,\n"
-	"\tmfx, Unique, Fairlight, iSO,\n"
-	"\tWrath Designs, Padua, Extend,\n"
-	"\tPHn, Creators, Cosine, tAAt,\n"
-	"\tViruz, Crest and Skalaria.\n"
-	"\n", -1);
-	
- gtk_text_insert (GTK_TEXT (about_text), NULL, NULL, NULL,
-	"Special thanks\n"
-	"\tGerfried 'Alfie' Fuchs\n"
-	"\tAndreas 'mrsid' Varga\n"
-	"\tAll the betatesters.\n"
-	"\tAll the users!\n", -1);
+	alignment6 = gtk_alignment_new(0.5, 0.5, 0.18, 1);
+	gtk_widget_set_name(alignment6, "alignment6");
+	gtk_widget_ref(alignment6);
+	gtk_object_set_data_full(GTK_OBJECT(xs_aboutwin), "alignment6", alignment6,
+				 (GtkDestroyNotify) gtk_widget_unref);
+	gtk_widget_show(alignment6);
+	gtk_box_pack_start(GTK_BOX(about_vbox1), alignment6, FALSE, TRUE, 0);
+	gtk_container_set_border_width(GTK_CONTAINER(alignment6), 8);
 
- alignment6 = gtk_alignment_new (0.5, 0.5, 0.18, 1);
- gtk_widget_set_name (alignment6, "alignment6");
- gtk_widget_ref (alignment6);
- gtk_object_set_data_full (GTK_OBJECT (xs_aboutwin), "alignment6", alignment6,
-                          (GtkDestroyNotify) gtk_widget_unref);
- gtk_widget_show (alignment6);
- gtk_box_pack_start (GTK_BOX (about_vbox1), alignment6, FALSE, TRUE, 0);
- gtk_container_set_border_width (GTK_CONTAINER (alignment6), 8);
+	about_close = gtk_button_new_with_label("Close");
+	gtk_widget_set_name(about_close, "about_close");
+	gtk_widget_ref(about_close);
+	gtk_object_set_data_full(GTK_OBJECT(xs_aboutwin), "about_close", about_close,
+				 (GtkDestroyNotify) gtk_widget_unref);
+	gtk_widget_show(about_close);
+	gtk_container_add(GTK_CONTAINER(alignment6), about_close);
+	GTK_WIDGET_SET_FLAGS(about_close, GTK_CAN_DEFAULT);
 
- about_close = gtk_button_new_with_label ("Close");
- gtk_widget_set_name (about_close, "about_close");
- gtk_widget_ref (about_close);
- gtk_object_set_data_full (GTK_OBJECT (xs_aboutwin), "about_close", about_close,
-                          (GtkDestroyNotify) gtk_widget_unref);
- gtk_widget_show (about_close);
- gtk_container_add (GTK_CONTAINER (alignment6), about_close);
- GTK_WIDGET_SET_FLAGS (about_close, GTK_CAN_DEFAULT);
+	gtk_signal_connect(GTK_OBJECT(about_close), "clicked", GTK_SIGNAL_FUNC(xs_about_ok), NULL);
 
- gtk_signal_connect (GTK_OBJECT (about_close), "clicked", GTK_SIGNAL_FUNC (xs_about_ok), NULL);
-
- gtk_widget_show(xs_aboutwin);
+	gtk_widget_show(xs_aboutwin);
 }
-
--- a/src/xs_config.c	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_config.c	Mon Nov 07 09:50:04 2005 +0000
@@ -30,10 +30,8 @@
 /*
  * Global widgets
  */
-static GtkWidget	*xs_configwin = NULL,
-			*xs_sldb_fileselector = NULL,
-			*xs_stil_fileselector = NULL,
-			*xs_hvsc_pathselector = NULL;
+static GtkWidget *xs_configwin = NULL,
+    *xs_sldb_fileselector = NULL, *xs_stil_fileselector = NULL, *xs_hvsc_pathselector = NULL;
 
 #define LUW(x)	lookup_widget(xs_configwin, x)
 
@@ -42,112 +40,157 @@
  * Configuration specific stuff
  */
 XS_MUTEX(xs_cfg);
-struct t_xs_cfg			xs_cfg;
+struct t_xs_cfg xs_cfg;
 
 t_xs_cfg_item xs_cfgtable[] = {
-	{CTYPE_INT,	&xs_cfg.audioBitsPerSample,	"audioBitsPerSample"},
-	{CTYPE_INT,	&xs_cfg.audioChannels,		"audioChannels"},
-	{CTYPE_INT,	&xs_cfg.audioFrequency,		"audioFrequency"},
+	{CTYPE_INT, &xs_cfg.audioBitsPerSample, "audioBitsPerSample"},
+	{CTYPE_INT, &xs_cfg.audioChannels, "audioChannels"},
+	{CTYPE_INT, &xs_cfg.audioFrequency, "audioFrequency"},
 
-	{CTYPE_BOOL,	&xs_cfg.mos8580,		"mos8580"},
-	{CTYPE_BOOL,	&xs_cfg.emulateFilters,		"emulateFilters"},
-	{CTYPE_FLOAT,	&xs_cfg.filterFs,		"filterFs"},
-	{CTYPE_FLOAT,	&xs_cfg.filterFm,		"filterFm"},
-	{CTYPE_FLOAT,	&xs_cfg.filterFt,		"filterFt"},
-	{CTYPE_INT,	&xs_cfg.memoryMode,		"memoryMode"},
-	{CTYPE_INT,	&xs_cfg.clockSpeed,		"clockSpeed"},
-	{CTYPE_BOOL,	&xs_cfg.forceSpeed,		"forceSpeed"},
+	{CTYPE_BOOL, &xs_cfg.mos8580, "mos8580"},
+	{CTYPE_BOOL, &xs_cfg.emulateFilters, "emulateFilters"},
+	{CTYPE_FLOAT, &xs_cfg.filterFs, "filterFs"},
+	{CTYPE_FLOAT, &xs_cfg.filterFm, "filterFm"},
+	{CTYPE_FLOAT, &xs_cfg.filterFt, "filterFt"},
+	{CTYPE_INT, &xs_cfg.memoryMode, "memoryMode"},
+	{CTYPE_INT, &xs_cfg.clockSpeed, "clockSpeed"},
+	{CTYPE_BOOL, &xs_cfg.forceSpeed, "forceSpeed"},
 
-	{CTYPE_INT,	&xs_cfg.playerEngine,		"playerEngine"},
+	{CTYPE_INT, &xs_cfg.playerEngine, "playerEngine"},
 
-	{CTYPE_INT,	&xs_cfg.sid2Builder,		"sid2Builder"},
-	{CTYPE_INT,	&xs_cfg.sid2OptLevel,		"sid2OptLevel"},
+	{CTYPE_INT, &xs_cfg.sid2Builder, "sid2Builder"},
+	{CTYPE_INT, &xs_cfg.sid2OptLevel, "sid2OptLevel"},
 
-	{CTYPE_BOOL,	&xs_cfg.oversampleEnable,	"oversampleEnable"},
-	{CTYPE_INT,	&xs_cfg.oversampleFactor,	"oversampleFactor"},
+	{CTYPE_BOOL, &xs_cfg.oversampleEnable, "oversampleEnable"},
+	{CTYPE_INT, &xs_cfg.oversampleFactor, "oversampleFactor"},
 
-	{CTYPE_BOOL,	&xs_cfg.playMaxTimeEnable,	"playMaxTimeEnable"},
-	{CTYPE_BOOL,	&xs_cfg.playMaxTimeUnknown,	"playMaxTimeUnknown"},
-	{CTYPE_INT,	&xs_cfg.playMaxTime,		"playMaxTime"},
-	{CTYPE_BOOL,	&xs_cfg.playMinTimeEnable,	"playMinTimeEnable"},
-	{CTYPE_INT,	&xs_cfg.playMinTime,		"playMinTime"},
-	{CTYPE_BOOL,	&xs_cfg.songlenDBEnable,	"songlenDBEnable"},
-	{CTYPE_STR,	&xs_cfg.songlenDBPath,		"songlenDBPath"},
+	{CTYPE_BOOL, &xs_cfg.playMaxTimeEnable, "playMaxTimeEnable"},
+	{CTYPE_BOOL, &xs_cfg.playMaxTimeUnknown, "playMaxTimeUnknown"},
+	{CTYPE_INT, &xs_cfg.playMaxTime, "playMaxTime"},
+	{CTYPE_BOOL, &xs_cfg.playMinTimeEnable, "playMinTimeEnable"},
+	{CTYPE_INT, &xs_cfg.playMinTime, "playMinTime"},
+	{CTYPE_BOOL, &xs_cfg.songlenDBEnable, "songlenDBEnable"},
+	{CTYPE_STR, &xs_cfg.songlenDBPath, "songlenDBPath"},
 
-	{CTYPE_BOOL,	&xs_cfg.stilDBEnable,		"stilDBEnable"},
-	{CTYPE_STR,	&xs_cfg.stilDBPath,		"stilDBPath"},
-	{CTYPE_STR,	&xs_cfg.hvscPath,		"hvscPath"},
+	{CTYPE_BOOL, &xs_cfg.stilDBEnable, "stilDBEnable"},
+	{CTYPE_STR, &xs_cfg.stilDBPath, "stilDBPath"},
+	{CTYPE_STR, &xs_cfg.hvscPath, "hvscPath"},
 
-	{CTYPE_INT,	&xs_cfg.subsongControl,		"subsongControl"},
-	{CTYPE_BOOL,	&xs_cfg.detectMagic,		"detectMagic"},
+	{CTYPE_INT, &xs_cfg.subsongControl, "subsongControl"},
+	{CTYPE_BOOL, &xs_cfg.detectMagic, "detectMagic"},
 
-	{CTYPE_BOOL,	&xs_cfg.titleOverride,		"titleOverride"},
-	{CTYPE_STR,	&xs_cfg.titleFormat,		"titleFormat"},
+	{CTYPE_BOOL, &xs_cfg.titleOverride, "titleOverride"},
+	{CTYPE_STR, &xs_cfg.titleFormat, "titleFormat"},
 
-	{CTYPE_BOOL,	&xs_cfg.subAutoEnable,		"subAutoEnable"},
-	{CTYPE_BOOL,	&xs_cfg.subAutoMinOnly,		"subAutoMinOnly"},
-	{CTYPE_INT,	&xs_cfg.subAutoMinTime,		"subAutoMinTime"},
+	{CTYPE_BOOL, &xs_cfg.subAutoEnable, "subAutoEnable"},
+	{CTYPE_BOOL, &xs_cfg.subAutoMinOnly, "subAutoMinOnly"},
+	{CTYPE_INT, &xs_cfg.subAutoMinTime, "subAutoMinTime"},
 };
 
 static const gint xs_cfgtable_max = (sizeof(xs_cfgtable) / sizeof(t_xs_cfg_item));
 
 
 t_xs_wid_item xs_widtable[] = {
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_res_16bit",	&xs_cfg.audioBitsPerSample,	XS_RES_16BIT },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_res_8bit",		&xs_cfg.audioBitsPerSample,	XS_RES_8BIT },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_chn_mono",		&xs_cfg.audioChannels,		XS_CHN_MONO },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_chn_stereo",	&xs_cfg.audioChannels,		XS_CHN_STEREO },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_chn_autopan",	&xs_cfg.audioChannels,		XS_CHN_AUTOPAN },
-{ WTYPE_SPIN,	CTYPE_INT,	"cfg_samplerate",	&xs_cfg.audioFrequency,		0 },
-{ WTYPE_BUTTON,	CTYPE_BOOL,	"cfg_oversample",	&xs_cfg.oversampleEnable,	0 },
-{ WTYPE_SPIN,	CTYPE_INT,	"cfg_oversample_factor",&xs_cfg.oversampleFactor,	0 },
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_res_16bit", &xs_cfg.audioBitsPerSample, XS_RES_16BIT}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_res_8bit", &xs_cfg.audioBitsPerSample, XS_RES_8BIT}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_chn_mono", &xs_cfg.audioChannels, XS_CHN_MONO}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_chn_stereo", &xs_cfg.audioChannels, XS_CHN_STEREO}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_chn_autopan", &xs_cfg.audioChannels, XS_CHN_AUTOPAN}
+	,
+	{WTYPE_SPIN, CTYPE_INT, "cfg_samplerate", &xs_cfg.audioFrequency, 0}
+	,
+	{WTYPE_BUTTON, CTYPE_BOOL, "cfg_oversample", &xs_cfg.oversampleEnable, 0}
+	,
+	{WTYPE_SPIN, CTYPE_INT, "cfg_oversample_factor", &xs_cfg.oversampleFactor, 0}
+	,
 
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_emu_sidplay1",	&xs_cfg.playerEngine,		XS_ENG_SIDPLAY1 },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_emu_sidplay2",	&xs_cfg.playerEngine,		XS_ENG_SIDPLAY2 },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_emu_mem_real",	&xs_cfg.memoryMode,		XS_MPU_REAL },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_emu_mem_banksw",	&xs_cfg.memoryMode,		XS_MPU_BANK_SWITCHING },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_emu_mem_transrom",	&xs_cfg.memoryMode,		XS_MPU_TRANSPARENT_ROM },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_emu_mem_playsid",	&xs_cfg.memoryMode,		XS_MPU_PLAYSID_ENVIRONMENT },
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_emu_sidplay1", &xs_cfg.playerEngine, XS_ENG_SIDPLAY1}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_emu_sidplay2", &xs_cfg.playerEngine, XS_ENG_SIDPLAY2}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_emu_mem_real", &xs_cfg.memoryMode, XS_MPU_REAL}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_emu_mem_banksw", &xs_cfg.memoryMode, XS_MPU_BANK_SWITCHING}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_emu_mem_transrom", &xs_cfg.memoryMode, XS_MPU_TRANSPARENT_ROM}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_emu_mem_playsid", &xs_cfg.memoryMode, XS_MPU_PLAYSID_ENVIRONMENT}
+	,
 
-{ WTYPE_BUTTON,	CTYPE_BOOL,	"cfg_emu_mos8580",	&xs_cfg.mos8580,		0 },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_emu_clock_ntsc",	&xs_cfg.clockSpeed,		XS_CLOCK_NTSC },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_emu_clock_pal",	&xs_cfg.clockSpeed,		XS_CLOCK_PAL },
-{ WTYPE_BUTTON,	CTYPE_BOOL,	"cfg_emu_clock_force",	&xs_cfg.forceSpeed,		0 },
-{ WTYPE_BUTTON,	CTYPE_BOOL,	"cfg_emu_sidplay2_opt",	&xs_cfg.sid2OptLevel,		0 },
+	{WTYPE_BUTTON, CTYPE_BOOL, "cfg_emu_mos8580", &xs_cfg.mos8580, 0}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_emu_clock_ntsc", &xs_cfg.clockSpeed, XS_CLOCK_NTSC}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_emu_clock_pal", &xs_cfg.clockSpeed, XS_CLOCK_PAL}
+	,
+	{WTYPE_BUTTON, CTYPE_BOOL, "cfg_emu_clock_force", &xs_cfg.forceSpeed, 0}
+	,
+	{WTYPE_BUTTON, CTYPE_BOOL, "cfg_emu_sidplay2_opt", &xs_cfg.sid2OptLevel, 0}
+	,
 
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_emu_sidplay2_resid",&xs_cfg.sid2Builder,		XS_BLD_RESID },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_emu_sidplay2_hardsid",&xs_cfg.sid2Builder,		XS_BLD_HARDSID },
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_emu_sidplay2_resid", &xs_cfg.sid2Builder, XS_BLD_RESID}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_emu_sidplay2_hardsid", &xs_cfg.sid2Builder, XS_BLD_HARDSID}
+	,
 
-{ WTYPE_BUTTON,	CTYPE_BOOL,	"cfg_emu_filters",	&xs_cfg.emulateFilters,		0 },
-{ WTYPE_SCALE,	CTYPE_FLOAT,	"cfg_emu_filt_fs",	&xs_cfg.filterFs,		0 },
-{ WTYPE_SCALE,	CTYPE_FLOAT,	"cfg_emu_filt_fm",	&xs_cfg.filterFm,		0 },
-{ WTYPE_SCALE,	CTYPE_FLOAT,	"cfg_emu_filt_ft",	&xs_cfg.filterFt,		0 },
+	{WTYPE_BUTTON, CTYPE_BOOL, "cfg_emu_filters", &xs_cfg.emulateFilters, 0}
+	,
+	{WTYPE_SCALE, CTYPE_FLOAT, "cfg_emu_filt_fs", &xs_cfg.filterFs, 0}
+	,
+	{WTYPE_SCALE, CTYPE_FLOAT, "cfg_emu_filt_fm", &xs_cfg.filterFm, 0}
+	,
+	{WTYPE_SCALE, CTYPE_FLOAT, "cfg_emu_filt_ft", &xs_cfg.filterFt, 0}
+	,
 
-{ WTYPE_BUTTON,	CTYPE_BOOL,	"cfg_maxtime_enable",	&xs_cfg.playMaxTimeEnable,	0 },
-{ WTYPE_BUTTON,	CTYPE_BOOL,	"cfg_maxtime_unknown",	&xs_cfg.playMaxTimeUnknown,	0 },
-{ WTYPE_SPIN,	CTYPE_INT,	"cfg_maxtime",		&xs_cfg.playMaxTime,		0 },
-{ WTYPE_BUTTON,	CTYPE_BOOL,	"cfg_mintime_enable",	&xs_cfg.playMinTimeEnable,	0 },
-{ WTYPE_SPIN,	CTYPE_INT,	"cfg_mintime",		&xs_cfg.playMinTime,		0 },
-{ WTYPE_BUTTON,	CTYPE_BOOL,	"cfg_sld_enable",	&xs_cfg.songlenDBEnable,	0 },
-{ WTYPE_TEXT,	CTYPE_STR,	"cfg_sld_dbpath",	&xs_cfg.songlenDBPath,		0 },
+	{WTYPE_BUTTON, CTYPE_BOOL, "cfg_maxtime_enable", &xs_cfg.playMaxTimeEnable, 0}
+	,
+	{WTYPE_BUTTON, CTYPE_BOOL, "cfg_maxtime_unknown", &xs_cfg.playMaxTimeUnknown, 0}
+	,
+	{WTYPE_SPIN, CTYPE_INT, "cfg_maxtime", &xs_cfg.playMaxTime, 0}
+	,
+	{WTYPE_BUTTON, CTYPE_BOOL, "cfg_mintime_enable", &xs_cfg.playMinTimeEnable, 0}
+	,
+	{WTYPE_SPIN, CTYPE_INT, "cfg_mintime", &xs_cfg.playMinTime, 0}
+	,
+	{WTYPE_BUTTON, CTYPE_BOOL, "cfg_sld_enable", &xs_cfg.songlenDBEnable, 0}
+	,
+	{WTYPE_TEXT, CTYPE_STR, "cfg_sld_dbpath", &xs_cfg.songlenDBPath, 0}
+	,
 
-{ WTYPE_BUTTON,	CTYPE_BOOL,	"cfg_stil_enable",	&xs_cfg.stilDBEnable,		0 },
-{ WTYPE_TEXT,	CTYPE_STR,	"cfg_stil_dbpath",	&xs_cfg.stilDBPath,		0 },
-{ WTYPE_TEXT,	CTYPE_STR,	"cfg_hvsc_path",	&xs_cfg.hvscPath,		0 },
-
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_subctrl_none",	&xs_cfg.subsongControl,		XS_SSC_NONE },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_subctrl_seek",	&xs_cfg.subsongControl,		XS_SSC_SEEK },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_subctrl_popup",	&xs_cfg.subsongControl,		XS_SSC_POPUP },
-{ WTYPE_BGROUP,	CTYPE_INT,	"cfg_subctrl_patch",	&xs_cfg.subsongControl,		XS_SSC_PATCH },
+	{WTYPE_BUTTON, CTYPE_BOOL, "cfg_stil_enable", &xs_cfg.stilDBEnable, 0}
+	,
+	{WTYPE_TEXT, CTYPE_STR, "cfg_stil_dbpath", &xs_cfg.stilDBPath, 0}
+	,
+	{WTYPE_TEXT, CTYPE_STR, "cfg_hvsc_path", &xs_cfg.hvscPath, 0}
+	,
 
-{ WTYPE_BUTTON,	CTYPE_BOOL,	"cfg_detectmagic",	&xs_cfg.detectMagic,		0 },
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_subctrl_none", &xs_cfg.subsongControl, XS_SSC_NONE}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_subctrl_seek", &xs_cfg.subsongControl, XS_SSC_SEEK}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_subctrl_popup", &xs_cfg.subsongControl, XS_SSC_POPUP}
+	,
+	{WTYPE_BGROUP, CTYPE_INT, "cfg_subctrl_patch", &xs_cfg.subsongControl, XS_SSC_PATCH}
+	,
+
+	{WTYPE_BUTTON, CTYPE_BOOL, "cfg_detectmagic", &xs_cfg.detectMagic, 0}
+	,
 
-{ WTYPE_BUTTON,	CTYPE_BOOL,	"cfg_ftitle_override",	&xs_cfg.titleOverride,		0 },
-{ WTYPE_TEXT,	CTYPE_STR,	"cfg_ftitle_format",	&xs_cfg.titleFormat,		0 },
+	{WTYPE_BUTTON, CTYPE_BOOL, "cfg_ftitle_override", &xs_cfg.titleOverride, 0}
+	,
+	{WTYPE_TEXT, CTYPE_STR, "cfg_ftitle_format", &xs_cfg.titleFormat, 0}
+	,
 
-{ WTYPE_BUTTON,	CTYPE_BOOL,	"cfg_subauto_enable",	&xs_cfg.subAutoEnable,		0 },
-{ WTYPE_BUTTON,	CTYPE_BOOL,	"cfg_subauto_min_only",	&xs_cfg.subAutoMinOnly,		0 },
-{ WTYPE_SPIN,	CTYPE_INT,	"cfg_subauto_mintime",	&xs_cfg.subAutoMinTime,		0 },
+	{WTYPE_BUTTON, CTYPE_BOOL, "cfg_subauto_enable", &xs_cfg.subAutoEnable, 0}
+	,
+	{WTYPE_BUTTON, CTYPE_BOOL, "cfg_subauto_min_only", &xs_cfg.subAutoMinOnly, 0}
+	,
+	{WTYPE_SPIN, CTYPE_INT, "cfg_subauto_mintime", &xs_cfg.subAutoMinTime, 0}
+	,
 };
 
 static const gint xs_widtable_max = (sizeof(xs_widtable) / sizeof(t_xs_wid_item));
@@ -163,43 +206,43 @@
  */
 void xs_init_configuration(void)
 {
- /* Lock configuration mutex */
- XSDEBUG("initializing configuration ...\n");
- XS_MUTEX_LOCK(xs_cfg);
+	/* Lock configuration mutex */
+	XSDEBUG("initializing configuration ...\n");
+	XS_MUTEX_LOCK(xs_cfg);
 
- /* Initialize values with sensible defaults */
- xs_cfg.audioBitsPerSample	= XS_RES_16BIT;
- xs_cfg.audioChannels		= XS_CHN_MONO;
- xs_cfg.audioFrequency		= 44100;
+	/* Initialize values with sensible defaults */
+	xs_cfg.audioBitsPerSample = XS_RES_16BIT;
+	xs_cfg.audioChannels = XS_CHN_MONO;
+	xs_cfg.audioFrequency = 44100;
 
- xs_cfg.mos8580			= FALSE;
+	xs_cfg.mos8580 = FALSE;
 
- xs_cfg.emulateFilters		= TRUE;
- xs_cfg.filterFs		= XS_SIDPLAY1_FS;
- xs_cfg.filterFm		= XS_SIDPLAY1_FM;
- xs_cfg.filterFt		= XS_SIDPLAY1_FT;
+	xs_cfg.emulateFilters = TRUE;
+	xs_cfg.filterFs = XS_SIDPLAY1_FS;
+	xs_cfg.filterFm = XS_SIDPLAY1_FM;
+	xs_cfg.filterFt = XS_SIDPLAY1_FT;
 
 #ifdef HAVE_SIDPLAY2
- xs_cfg.playerEngine		= XS_ENG_SIDPLAY2;
- xs_cfg.memoryMode		= XS_MPU_REAL;
+	xs_cfg.playerEngine = XS_ENG_SIDPLAY2;
+	xs_cfg.memoryMode = XS_MPU_REAL;
 #else
 #ifdef HAVE_SIDPLAY1
- xs_cfg.playerEngine		= XS_ENG_SIDPLAY1;
- xs_cfg.memoryMode		= XS_MPU_BANK_SWITCHING;
+	xs_cfg.playerEngine = XS_ENG_SIDPLAY1;
+	xs_cfg.memoryMode = XS_MPU_BANK_SWITCHING;
 #else
 #error This should not happen! No emulator engines configured in!
 #endif
 #endif
 
- xs_cfg.clockSpeed		= XS_CLOCK_PAL;
- xs_cfg.forceSpeed		= FALSE;
+	xs_cfg.clockSpeed = XS_CLOCK_PAL;
+	xs_cfg.forceSpeed = FALSE;
 
- xs_cfg.sid2OptLevel		= FALSE;
+	xs_cfg.sid2OptLevel = FALSE;
 #ifdef HAVE_RESID_BUILDER
- xs_cfg.sid2Builder		= XS_BLD_RESID;
+	xs_cfg.sid2Builder = XS_BLD_RESID;
 #else
 #ifdef HAVE_HARDSID_BUILDER
- xs_cfg.sid2Builder		= XS_BLD_HARDSID;
+	xs_cfg.sid2Builder = XS_BLD_HARDSID;
 #else
 #ifdef HAVE_SIDPLAY2
 #error This should not happen! No supported SIDPlay2 builders configured in!
@@ -207,46 +250,46 @@
 #endif
 #endif
 
- xs_cfg.oversampleEnable	= FALSE;
- xs_cfg.oversampleFactor	= XS_MIN_OVERSAMPLE;
+	xs_cfg.oversampleEnable = FALSE;
+	xs_cfg.oversampleFactor = XS_MIN_OVERSAMPLE;
 
- xs_cfg.playMaxTimeEnable	= FALSE;
- xs_cfg.playMaxTimeUnknown	= FALSE;
- xs_cfg.playMaxTime		= 150;
+	xs_cfg.playMaxTimeEnable = FALSE;
+	xs_cfg.playMaxTimeUnknown = FALSE;
+	xs_cfg.playMaxTime = 150;
 
- xs_cfg.playMinTimeEnable	= FALSE;
- xs_cfg.playMinTime		= 15;
- 
- xs_cfg.songlenDBEnable		= FALSE;
- xs_pstrcpy(&xs_cfg.songlenDBPath, "~/C64Music/Songlengths.txt");
+	xs_cfg.playMinTimeEnable = FALSE;
+	xs_cfg.playMinTime = 15;
 
- xs_cfg.stilDBEnable		= FALSE;
- xs_pstrcpy(&xs_cfg.stilDBPath, "~/C64Music/DOCUMENTS/STIL.txt");
- xs_pstrcpy(&xs_cfg.hvscPath, "~/C64Music");
+	xs_cfg.songlenDBEnable = FALSE;
+	xs_pstrcpy(&xs_cfg.songlenDBPath, "~/C64Music/Songlengths.txt");
+
+	xs_cfg.stilDBEnable = FALSE;
+	xs_pstrcpy(&xs_cfg.stilDBPath, "~/C64Music/DOCUMENTS/STIL.txt");
+	xs_pstrcpy(&xs_cfg.hvscPath, "~/C64Music");
 
 #ifdef HAVE_SONG_POSITION
- xs_cfg.subsongControl		= XS_SSC_PATCH;
+	xs_cfg.subsongControl = XS_SSC_PATCH;
 #else
- xs_cfg.subsongControl		= XS_SSC_POPUP;
+	xs_cfg.subsongControl = XS_SSC_POPUP;
 #endif
 
- xs_cfg.detectMagic		= FALSE;
+	xs_cfg.detectMagic = FALSE;
 
 #ifdef HAVE_XMMSEXTRA
- xs_cfg.titleOverride		= FALSE;
+	xs_cfg.titleOverride = FALSE;
 #else
- xs_cfg.titleOverride		= TRUE;
+	xs_cfg.titleOverride = TRUE;
 #endif
- xs_pstrcpy(&xs_cfg.titleFormat, "%p - %t (%c) [%n]");
+	xs_pstrcpy(&xs_cfg.titleFormat, "%p - %t (%c) [%n]");
 
 
- xs_cfg.subAutoEnable		= FALSE;
- xs_cfg.subAutoMinOnly		= TRUE;
- xs_cfg.subAutoMinTime		= 15;
- 
+	xs_cfg.subAutoEnable = FALSE;
+	xs_cfg.subAutoMinOnly = TRUE;
+	xs_cfg.subAutoMinTime = 15;
 
- /* Unlock the configuration */
- XS_MUTEX_UNLOCK(xs_cfg);
+
+	/* Unlock the configuration */
+	XS_MUTEX_UNLOCK(xs_cfg);
 }
 
 
@@ -256,68 +299,70 @@
 void xs_read_configuration(void)
 {
 #ifdef HAVE_NODEFAULTCFG
- gchar *cfgFilename;
+	gchar *cfgFilename;
 #endif
- gchar *tmpStr;
- ConfigFile *cfgFile;
- gint i;
+	gchar *tmpStr;
+	ConfigFile *cfgFile;
+	gint i;
 
- /* Try to open the XMMS configuration file  */
- XS_MUTEX_LOCK(xs_cfg);
- XSDEBUG("loading from config-file ...\n");
+	/* Try to open the XMMS configuration file  */
+	XS_MUTEX_LOCK(xs_cfg);
+	XSDEBUG("loading from config-file ...\n");
 
 #ifdef HAVE_NODEFAULTCFG
- cfgFilename = g_strconcat(g_get_home_dir(), XS_CONFIG_FILE, NULL);
- cfgFile = xmms_cfg_open_file(cfgFilename);
- g_free(cfgFilename);
+	cfgFilename = g_strconcat(g_get_home_dir(), XS_CONFIG_FILE, NULL);
+	cfgFile = xmms_cfg_open_file(cfgFilename);
+	g_free(cfgFilename);
 #else
- cfgFile = xmms_cfg_open_default_file();
+	cfgFile = xmms_cfg_open_default_file();
 #endif
 
- if (cfgFile == NULL)
-	{
-	XSDEBUG("could not open configuration file, trying to write defaults...\n");
-	xs_write_configuration();
-	return;
+	if (cfgFile == NULL) {
+		XSDEBUG("could not open configuration file, trying to write defaults...\n");
+		xs_write_configuration();
+		return;
 	}
 
- /* Read the new settings from XMMS configuration file */
- for (i = 0; i < xs_cfgtable_max; i++)
- 	{
-	switch (xs_cfgtable[i].itemType) {
-	case CTYPE_INT:
-		xmms_cfg_read_int(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName, (gint *) xs_cfgtable[i].itemData);
-		break;
+	/* Read the new settings from XMMS configuration file */
+	for (i = 0; i < xs_cfgtable_max; i++) {
+		switch (xs_cfgtable[i].itemType) {
+		case CTYPE_INT:
+			xmms_cfg_read_int(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName,
+					  (gint *) xs_cfgtable[i].itemData);
+			break;
 
-	case CTYPE_BOOL:
-		xmms_cfg_read_boolean(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName, (gboolean *) xs_cfgtable[i].itemData);
-		break;
+		case CTYPE_BOOL:
+			xmms_cfg_read_boolean(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName,
+					      (gboolean *) xs_cfgtable[i].itemData);
+			break;
 
-	case CTYPE_FLOAT:
-		xmms_cfg_read_float(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName, (gfloat *) xs_cfgtable[i].itemData);
-		break;
+		case CTYPE_FLOAT:
+			xmms_cfg_read_float(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName,
+					    (gfloat *) xs_cfgtable[i].itemData);
+			break;
 
-	case CTYPE_STR:
-		if (xmms_cfg_read_string(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName, (gchar **) &tmpStr))
-			{
-			/* Read was successfull */
-			xs_pstrcpy((gchar **) xs_cfgtable[i].itemData, tmpStr);
-			g_free(tmpStr);
+		case CTYPE_STR:
+			if (xmms_cfg_read_string
+			    (cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName, (gchar **) & tmpStr)) {
+				/* Read was successfull */
+				xs_pstrcpy((gchar **) xs_cfgtable[i].itemData, tmpStr);
+				g_free(tmpStr);
 			}
-		break;
+			break;
 
-	default:
-		XSERR("Internal: Unsupported setting type found while reading configuration file. Please report to author!\n");
-		break;
-	}
+		default:
+			XSERR
+			    ("Internal: Unsupported setting type found while reading configuration file. Please report to author!\n");
+			break;
+		}
 	}
 
 
- /* Free the config file */
- xmms_cfg_free(cfgFile);
+	/* Free the config file */
+	xmms_cfg_free(cfgFile);
 
- XS_MUTEX_UNLOCK(xs_cfg);
- XSDEBUG("OK\n");
+	XS_MUTEX_UNLOCK(xs_cfg);
+	XSDEBUG("OK\n");
 }
 
 
@@ -328,65 +373,69 @@
 gint xs_write_configuration(void)
 {
 #ifdef HAVE_NODEFAULTCFG
- gchar *cfgFilename;
+	gchar *cfgFilename;
 #endif
- ConfigFile *cfgFile;
- gint i;
+	ConfigFile *cfgFile;
+	gint i;
 
- XSDEBUG("writing configuration ...\n");
- XS_MUTEX_LOCK(xs_cfg);
+	XSDEBUG("writing configuration ...\n");
+	XS_MUTEX_LOCK(xs_cfg);
 
- /* Try to open the XMMS configuration file  */
+	/* Try to open the XMMS configuration file  */
 #ifdef HAVE_NODEFAULTCFG
- cfgFilename = g_strconcat(g_get_home_dir(), XS_CONFIG_FILE, NULL);
- cfgFile = xmms_cfg_open_file(cfgFilename);
+	cfgFilename = g_strconcat(g_get_home_dir(), XS_CONFIG_FILE, NULL);
+	cfgFile = xmms_cfg_open_file(cfgFilename);
 #else
- cfgFile = xmms_cfg_open_default_file();
+	cfgFile = xmms_cfg_open_default_file();
 #endif
 
- if (!cfgFile)
-	cfgFile = xmms_cfg_new();
+	if (!cfgFile)
+		cfgFile = xmms_cfg_new();
 
- /* Write the new settings to XMMS configuration file */
- for (i = 0; i < xs_cfgtable_max; i++)
- 	{
-	switch (xs_cfgtable[i].itemType) {
-	case CTYPE_INT:
-		xmms_cfg_write_int(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName, *(gint *) xs_cfgtable[i].itemData);
-		break;
+	/* Write the new settings to XMMS configuration file */
+	for (i = 0; i < xs_cfgtable_max; i++) {
+		switch (xs_cfgtable[i].itemType) {
+		case CTYPE_INT:
+			xmms_cfg_write_int(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName,
+					   *(gint *) xs_cfgtable[i].itemData);
+			break;
+
+		case CTYPE_BOOL:
+			xmms_cfg_write_boolean(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName,
+					       *(gboolean *) xs_cfgtable[i].itemData);
+			break;
 
-	case CTYPE_BOOL:
-		xmms_cfg_write_boolean(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName, *(gboolean *) xs_cfgtable[i].itemData);
-		break;
-
-	case CTYPE_FLOAT:
-		xmms_cfg_write_float(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName, *(gfloat *) xs_cfgtable[i].itemData);
-		break;
+		case CTYPE_FLOAT:
+			xmms_cfg_write_float(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName,
+					     *(gfloat *) xs_cfgtable[i].itemData);
+			break;
 
-	case CTYPE_STR:
-		xmms_cfg_write_string(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName, *(gchar **) xs_cfgtable[i].itemData);
-		break;
+		case CTYPE_STR:
+			xmms_cfg_write_string(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].itemName,
+					      *(gchar **) xs_cfgtable[i].itemData);
+			break;
 
-	default:
-		XSERR("Internal: Unsupported setting type found while writing configuration file. Please report to author!\n");
-		break;
-	}
+		default:
+			XSERR
+			    ("Internal: Unsupported setting type found while writing configuration file. Please report to author!\n");
+			break;
+		}
 	}
 
- /* Flush the file */
+	/* Flush the file */
 #ifdef HAVE_NODEFAULTCFG
- xmms_cfg_write_file(cfgFile, cfgFilename);
- g_free(cfgFilename);
+	xmms_cfg_write_file(cfgFile, cfgFilename);
+	g_free(cfgFilename);
 #else
- xmms_cfg_write_default_file(cfgFile);
+	xmms_cfg_write_default_file(cfgFile);
 #endif
 
- /* Free the memory areas */
- xmms_cfg_free(cfgFile);
+	/* Free the memory areas */
+	xmms_cfg_free(cfgFile);
 
- XS_MUTEX_UNLOCK(xs_cfg);
- 
- return 0;
+	XS_MUTEX_UNLOCK(xs_cfg);
+
+	return 0;
 }
 
 
@@ -395,8 +444,8 @@
  */
 void xs_cfg_cancel(void)
 {
- gtk_widget_destroy(xs_configwin);
- xs_configwin = NULL;
+	gtk_widget_destroy(xs_configwin);
+	xs_configwin = NULL;
 }
 
 
@@ -405,98 +454,90 @@
  */
 void xs_cfg_ok(void)
 {
- gint i;
- gfloat tmpValue;
+	gint i;
+	gfloat tmpValue;
 
- XSDEBUG("get data from widgets to config...\n");
+	XSDEBUG("get data from widgets to config...\n");
 
- for (i = 0; i < xs_widtable_max; i++)
- 	{
-	switch (xs_widtable[i].widType) {
-	case WTYPE_BGROUP:
-		/* Check if toggle-button is active */
-		if (GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName))->active)
-			{
-			/* Yes, set the constant value */
-			*((gint *) xs_widtable[i].itemData) = xs_widtable[i].itemSet;
+	for (i = 0; i < xs_widtable_max; i++) {
+		switch (xs_widtable[i].widType) {
+		case WTYPE_BGROUP:
+			/* Check if toggle-button is active */
+			if (GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName))->active) {
+				/* Yes, set the constant value */
+				*((gint *) xs_widtable[i].itemData) = xs_widtable[i].itemSet;
 			}
-		break;
-	
-	case WTYPE_SPIN:
-	case WTYPE_SCALE:
-		/* Get the value */
-		switch (xs_widtable[i].widType) {
-		case WTYPE_SPIN:
-			tmpValue = gtk_spin_button_get_adjustment(
-				GTK_SPIN_BUTTON(LUW(xs_widtable[i].widName)))->value;
-			break;
-		
-		case WTYPE_SCALE:
-			tmpValue = gtk_range_get_adjustment(
-				GTK_RANGE(LUW(xs_widtable[i].widName)))->value;
 			break;
 
-		default:
-			tmpValue = -1;
-		}
-		
-		/* Set the value */
-		switch (xs_widtable[i].itemType) {
-		case CTYPE_INT:
-			*((gint *) xs_widtable[i].itemData) = (gint) tmpValue;
+		case WTYPE_SPIN:
+		case WTYPE_SCALE:
+			/* Get the value */
+			switch (xs_widtable[i].widType) {
+			case WTYPE_SPIN:
+				tmpValue =
+				    gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(LUW(xs_widtable[i].widName)))->value;
+				break;
+
+			case WTYPE_SCALE:
+				tmpValue = gtk_range_get_adjustment(GTK_RANGE(LUW(xs_widtable[i].widName)))->value;
+				break;
+
+			default:
+				tmpValue = -1;
+			}
+
+			/* Set the value */
+			switch (xs_widtable[i].itemType) {
+			case CTYPE_INT:
+				*((gint *) xs_widtable[i].itemData) = (gint) tmpValue;
+				break;
+
+			case CTYPE_FLOAT:
+				*((gfloat *) xs_widtable[i].itemData) = tmpValue;
+				break;
+			}
 			break;
 
-		case CTYPE_FLOAT:
-			*((gfloat *) xs_widtable[i].itemData) = tmpValue;
+		case WTYPE_BUTTON:
+			/* Check if toggle-button is active */
+			*((gboolean *) xs_widtable[i].itemData) =
+			    (GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName))->active);
+			break;
+
+		case WTYPE_TEXT:
+			/* Get text from text-widget */
+			xs_pstrcpy((gchar **) xs_widtable[i].itemData,
+				   gtk_entry_get_text(GTK_ENTRY(LUW(xs_widtable[i].widName)))
+			    );
 			break;
 		}
-		break;
-	
-	case WTYPE_BUTTON:
-		/* Check if toggle-button is active */
-		*((gboolean *) xs_widtable[i].itemData) =
-			(GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName))->active);
-		break;
-
-	case WTYPE_TEXT:
-		/* Get text from text-widget */
-		xs_pstrcpy((gchar **) xs_widtable[i].itemData,
-			gtk_entry_get_text(GTK_ENTRY(LUW(xs_widtable[i].widName)))
-			);
-		break;
-	}
 	}
 
- /* Close window */
- gtk_widget_destroy(xs_configwin);
- xs_configwin = NULL;
+	/* Close window */
+	gtk_widget_destroy(xs_configwin);
+	xs_configwin = NULL;
 
- /* Write settings */
- xs_write_configuration();
+	/* Write settings */
+	xs_write_configuration();
 
- /* Re-initialize */
- xs_reinit();
+	/* Re-initialize */
+	xs_reinit();
 }
 
 
 /*
  * Reset filter settings to defaults
  */
-void xs_cfg_filter_reset(GtkButton *button, gpointer user_data)
+void xs_cfg_filter_reset(GtkButton * button, gpointer user_data)
 {
- (void)button; (void)user_data;
-
- gtk_adjustment_set_value(
- 	gtk_range_get_adjustment(GTK_RANGE(LUW("cfg_emu_filt_fs"))),
- 	XS_SIDPLAY1_FS);
+	(void) button;
+	(void) user_data;
 
- gtk_adjustment_set_value(
- 	gtk_range_get_adjustment(GTK_RANGE(LUW("cfg_emu_filt_fm"))),
- 	XS_SIDPLAY1_FM);
+	gtk_adjustment_set_value(gtk_range_get_adjustment(GTK_RANGE(LUW("cfg_emu_filt_fs"))), XS_SIDPLAY1_FS);
 
- gtk_adjustment_set_value(
- 	gtk_range_get_adjustment(GTK_RANGE(LUW("cfg_emu_filt_ft"))),
- 	XS_SIDPLAY1_FT);
+	gtk_adjustment_set_value(gtk_range_get_adjustment(GTK_RANGE(LUW("cfg_emu_filt_fm"))), XS_SIDPLAY1_FM);
+
+	gtk_adjustment_set_value(gtk_range_get_adjustment(GTK_RANGE(LUW("cfg_emu_filt_ft"))), XS_SIDPLAY1_FT);
 }
 
 
@@ -505,322 +546,315 @@
 /*
  * HVSC songlength-database file selector response-functions
  */
-void xs_cfg_sld_dbbrowse(GtkButton *button, gpointer user_data)
+void xs_cfg_sld_dbbrowse(GtkButton * button, gpointer user_data)
 {
- (void)button; (void)user_data;
- 
- if (xs_sldb_fileselector != NULL)
-	{
-	gdk_window_raise(xs_sldb_fileselector->window);
-	return;
+	(void) button;
+	(void) user_data;
+
+	if (xs_sldb_fileselector != NULL) {
+		gdk_window_raise(xs_sldb_fileselector->window);
+		return;
 	}
 
- xs_sldb_fileselector = create_xs_sldbfileselector();
- XS_MUTEX_LOCK(xs_cfg);
- gtk_file_selection_set_filename(
- 	GTK_FILE_SELECTION(xs_sldb_fileselector),
- 	xs_cfg.songlenDBPath);
- XS_MUTEX_UNLOCK(xs_cfg);
- gtk_widget_show(xs_sldb_fileselector);
+	xs_sldb_fileselector = create_xs_sldbfileselector();
+	XS_MUTEX_LOCK(xs_cfg);
+	gtk_file_selection_set_filename(GTK_FILE_SELECTION(xs_sldb_fileselector), xs_cfg.songlenDBPath);
+	XS_MUTEX_UNLOCK(xs_cfg);
+	gtk_widget_show(xs_sldb_fileselector);
 }
 
 
 void xs_cfg_sldb_fs_ok(void)
 {
- /* Selection was accepted! */
- gtk_entry_set_text(GTK_ENTRY(LUW("cfg_sld_dbpath")),
- 	gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_sldb_fileselector)));
+	/* Selection was accepted! */
+	gtk_entry_set_text(GTK_ENTRY(LUW("cfg_sld_dbpath")),
+			   gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_sldb_fileselector)));
 
- /* Close file selector window */
- gtk_widget_destroy(xs_sldb_fileselector);
- xs_sldb_fileselector = NULL;
+	/* Close file selector window */
+	gtk_widget_destroy(xs_sldb_fileselector);
+	xs_sldb_fileselector = NULL;
 }
 
 
 void xs_cfg_sldb_fs_cancel(void)
 {
- /* Close file selector window */
- gtk_widget_destroy(xs_sldb_fileselector);
- xs_sldb_fileselector = NULL;
+	/* Close file selector window */
+	gtk_widget_destroy(xs_sldb_fileselector);
+	xs_sldb_fileselector = NULL;
 }
 
 
 /*
  * STIL-database file selector response-functions
  */
-void xs_cfg_stil_browse(GtkButton *button, gpointer user_data)
+void xs_cfg_stil_browse(GtkButton * button, gpointer user_data)
 {
- (void)button; (void)user_data;
+	(void) button;
+	(void) user_data;
 
- if (xs_stil_fileselector != NULL)
-	{
-	gdk_window_raise(xs_stil_fileselector->window);
-	return;
+	if (xs_stil_fileselector != NULL) {
+		gdk_window_raise(xs_stil_fileselector->window);
+		return;
 	}
 
- xs_stil_fileselector = create_xs_stilfileselector();
- XS_MUTEX_LOCK(xs_cfg);
- gtk_file_selection_set_filename(
- 	GTK_FILE_SELECTION(xs_stil_fileselector),
- 	xs_cfg.stilDBPath);
- XS_MUTEX_UNLOCK(xs_cfg);
- gtk_widget_show(xs_stil_fileselector);
+	xs_stil_fileselector = create_xs_stilfileselector();
+	XS_MUTEX_LOCK(xs_cfg);
+	gtk_file_selection_set_filename(GTK_FILE_SELECTION(xs_stil_fileselector), xs_cfg.stilDBPath);
+	XS_MUTEX_UNLOCK(xs_cfg);
+	gtk_widget_show(xs_stil_fileselector);
 }
 
 
 void xs_cfg_stil_fs_ok(void)
 {
- /* Selection was accepted! */
- gtk_entry_set_text(GTK_ENTRY(LUW("cfg_stil_dbpath")),
- 	gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_stil_fileselector)));
+	/* Selection was accepted! */
+	gtk_entry_set_text(GTK_ENTRY(LUW("cfg_stil_dbpath")),
+			   gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_stil_fileselector)));
 
- /* Close file selector window */
- gtk_widget_destroy(xs_stil_fileselector);
- xs_stil_fileselector = NULL;
+	/* Close file selector window */
+	gtk_widget_destroy(xs_stil_fileselector);
+	xs_stil_fileselector = NULL;
 }
 
 
 void xs_cfg_stil_fs_cancel(void)
 {
- /* Close file selector window */
- gtk_widget_destroy(xs_stil_fileselector);
- xs_stil_fileselector = NULL;
+	/* Close file selector window */
+	gtk_widget_destroy(xs_stil_fileselector);
+	xs_stil_fileselector = NULL;
 }
 
 
 /*
  * HVSC location selector response-functions
  */
-void xs_cfg_hvsc_browse(GtkButton *button, gpointer user_data)
+void xs_cfg_hvsc_browse(GtkButton * button, gpointer user_data)
 {
- (void)button; (void)user_data;
+	(void) button;
+	(void) user_data;
 
- if (xs_hvsc_pathselector != NULL)
-	{
-	gdk_window_raise(xs_hvsc_pathselector->window);
-	return;
+	if (xs_hvsc_pathselector != NULL) {
+		gdk_window_raise(xs_hvsc_pathselector->window);
+		return;
 	}
 
- xs_hvsc_pathselector = create_xs_hvscpathselector();
- XS_MUTEX_LOCK(xs_cfg);
- gtk_file_selection_set_filename(
- 	GTK_FILE_SELECTION(xs_hvsc_pathselector),
- 	xs_cfg.hvscPath);
- XS_MUTEX_UNLOCK(xs_cfg);
- gtk_widget_show(xs_hvsc_pathselector);
+	xs_hvsc_pathselector = create_xs_hvscpathselector();
+	XS_MUTEX_LOCK(xs_cfg);
+	gtk_file_selection_set_filename(GTK_FILE_SELECTION(xs_hvsc_pathselector), xs_cfg.hvscPath);
+	XS_MUTEX_UNLOCK(xs_cfg);
+	gtk_widget_show(xs_hvsc_pathselector);
 }
 
 
 void xs_cfg_hvsc_fs_ok(void)
 {
- /* Selection was accepted! */
- gtk_entry_set_text(GTK_ENTRY(LUW("cfg_hvsc_path")),
- 	gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_hvsc_pathselector)));
+	/* Selection was accepted! */
+	gtk_entry_set_text(GTK_ENTRY(LUW("cfg_hvsc_path")),
+			   gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_hvsc_pathselector)));
 
- /* Close file selector window */
- gtk_widget_destroy(xs_hvsc_pathselector);
- xs_hvsc_pathselector = NULL;
+	/* Close file selector window */
+	gtk_widget_destroy(xs_hvsc_pathselector);
+	xs_hvsc_pathselector = NULL;
 }
 
 
 void xs_cfg_hvsc_fs_cancel(void)
 {
- /* Close file selector window */
- gtk_widget_destroy(xs_hvsc_pathselector);
- xs_hvsc_pathselector = NULL;
+	/* Close file selector window */
+	gtk_widget_destroy(xs_hvsc_pathselector);
+	xs_hvsc_pathselector = NULL;
 }
 
 
 /*
  * Selection toggle handlers
  */
-void xs_cfg_emu_filters_toggled(GtkToggleButton *togglebutton, gpointer user_data)
+void xs_cfg_emu_filters_toggled(GtkToggleButton * togglebutton, gpointer user_data)
 {
- gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
+	gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
 
- (void)user_data;
+	(void) user_data;
 
- gtk_widget_set_sensitive(LUW("cfg_filters_notebook"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_filters_notebook"), isActive);
 }
 
 
-void xs_cfg_ftitle_override_toggled(GtkToggleButton *togglebutton, gpointer user_data)
+void xs_cfg_ftitle_override_toggled(GtkToggleButton * togglebutton, gpointer user_data)
 {
- gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
+	gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
 
- (void)user_data;
+	(void) user_data;
 
- gtk_widget_set_sensitive(LUW("cfg_ftitle_format"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_ftitle_desc1"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_ftitle_desc2"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_ftitle_format"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_ftitle_desc1"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_ftitle_desc2"), isActive);
 }
 
 
-void xs_cfg_emu_sidplay1_toggled(GtkToggleButton *togglebutton, gpointer user_data)
+void xs_cfg_emu_sidplay1_toggled(GtkToggleButton * togglebutton, gpointer user_data)
 {
- (void)togglebutton; (void)user_data;
+	(void) togglebutton;
+	(void) user_data;
 }
 
 
-void xs_cfg_emu_sidplay2_toggled(GtkToggleButton *togglebutton, gpointer user_data)
+void xs_cfg_emu_sidplay2_toggled(GtkToggleButton * togglebutton, gpointer user_data)
 {
- gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
+	gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
 
- (void)user_data;
+	(void) user_data;
 
- gtk_widget_set_sensitive(LUW("cfg_emu_mem_real"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_emu_mem_real"), isActive);
 
- gtk_widget_set_sensitive(LUW("cfg_sidplay2_grp"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_emu_sidplay2_opt"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_sidplay2_grp"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_emu_sidplay2_opt"), isActive);
 
- gtk_widget_set_sensitive(LUW("cfg_chn_autopan"), !isActive);
+	gtk_widget_set_sensitive(LUW("cfg_chn_autopan"), !isActive);
 
 #ifdef HAVE_RESID_BUILDER
- gtk_widget_set_sensitive(LUW("cfg_emu_sidplay2_resid"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_emu_sidplay2_resid"), isActive);
 #else
- gtk_widget_set_sensitive(LUW("cfg_emu_sidplay2_resid"), FALSE);
+	gtk_widget_set_sensitive(LUW("cfg_emu_sidplay2_resid"), FALSE);
 #endif
 
 #ifdef HAVE_HARDSID_BUILDER
- gtk_widget_set_sensitive(LUW("cfg_emu_sidplay2_hardsid"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_emu_sidplay2_hardsid"), isActive);
 #else
- gtk_widget_set_sensitive(LUW("cfg_emu_sidplay2_hardsid"), FALSE);
+	gtk_widget_set_sensitive(LUW("cfg_emu_sidplay2_hardsid"), FALSE);
 #endif
 }
 
 
-void xs_cfg_oversample_toggled(GtkToggleButton *togglebutton, gpointer user_data)
+void xs_cfg_oversample_toggled(GtkToggleButton * togglebutton, gpointer user_data)
 {
- gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
+	gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
 
- (void)user_data;
+	(void) user_data;
 
- gtk_widget_set_sensitive(LUW("cfg_oversample_factor"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_oversample_label1"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_oversample_label2"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_oversample_factor"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_oversample_label1"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_oversample_label2"), isActive);
 }
 
 
-void xs_cfg_mintime_enable_toggled(GtkToggleButton *togglebutton, gpointer user_data)
+void xs_cfg_mintime_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data)
 {
- gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
+	gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
 
- (void)user_data;
+	(void) user_data;
 
- gtk_widget_set_sensitive(LUW("cfg_mintime"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_mintime_label1"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_mintime_label2"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_mintime"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_mintime_label1"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_mintime_label2"), isActive);
 }
 
 
-void xs_cfg_maxtime_enable_toggled(GtkToggleButton *togglebutton, gpointer user_data)
+void xs_cfg_maxtime_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data)
 {
- gboolean isActive = GTK_TOGGLE_BUTTON(LUW("cfg_maxtime_enable"))->active;
+	gboolean isActive = GTK_TOGGLE_BUTTON(LUW("cfg_maxtime_enable"))->active;
 
- (void)togglebutton; (void)user_data;
+	(void) togglebutton;
+	(void) user_data;
 
- gtk_widget_set_sensitive(LUW("cfg_maxtime_unknown"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_maxtime"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_maxtime_label1"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_maxtime_label2"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_maxtime_unknown"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_maxtime"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_maxtime_label1"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_maxtime_label2"), isActive);
 }
 
 
-void xs_cfg_sld_enable_toggled(GtkToggleButton *togglebutton, gpointer user_data)
+void xs_cfg_sld_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data)
 {
- gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
-
- (void)user_data;
-
- gtk_widget_set_sensitive(LUW("cfg_sld_dbpath"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_sld_dbbrowse"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_sld_label1"), isActive);
-}
-
+	gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
 
-void xs_cfg_stil_enable_toggled(GtkToggleButton *togglebutton, gpointer user_data)
-{
- gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
-
- (void)user_data;
+	(void) user_data;
 
- gtk_widget_set_sensitive(LUW("cfg_stil_dbpath"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_stil_browse"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_stil_label1"), isActive);
-
- gtk_widget_set_sensitive(LUW("cfg_hvsc_path"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_hvsc_browse"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_hvsc_label1"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_sld_dbpath"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_sld_dbbrowse"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_sld_label1"), isActive);
 }
 
 
-void xs_cfg_subauto_enable_toggled(GtkToggleButton *togglebutton, gpointer user_data)
+void xs_cfg_stil_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data)
 {
- gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
+	gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
+
+	(void) user_data;
 
- (void)user_data;
+	gtk_widget_set_sensitive(LUW("cfg_stil_dbpath"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_stil_browse"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_stil_label1"), isActive);
 
- gtk_widget_set_sensitive(LUW("cfg_subauto_min_only"), isActive);
- gtk_widget_set_sensitive(LUW("cfg_subauto_mintime"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_hvsc_path"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_hvsc_browse"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_hvsc_label1"), isActive);
 }
 
 
-void xs_cfg_subauto_min_only_toggled(GtkToggleButton *togglebutton, gpointer user_data)
+void xs_cfg_subauto_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data)
 {
- gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active &&
-		GTK_TOGGLE_BUTTON(LUW("cfg_subauto_enable"))->active;
+	gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
+
+	(void) user_data;
+
+	gtk_widget_set_sensitive(LUW("cfg_subauto_min_only"), isActive);
+	gtk_widget_set_sensitive(LUW("cfg_subauto_mintime"), isActive);
+}
+
 
- (void)user_data;
+void xs_cfg_subauto_min_only_toggled(GtkToggleButton * togglebutton, gpointer user_data)
+{
+	gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active &&
+	    GTK_TOGGLE_BUTTON(LUW("cfg_subauto_enable"))->active;
 
- gtk_widget_set_sensitive(LUW("cfg_subauto_mintime"), isActive);
+	(void) user_data;
+
+	gtk_widget_set_sensitive(LUW("cfg_subauto_mintime"), isActive);
 }
 
 
-void xs_cfg_mintime_changed(GtkEditable *editable, gpointer user_data)
+void xs_cfg_mintime_changed(GtkEditable * editable, gpointer user_data)
 {
- gint tmpValue;
- GtkAdjustment *tmpAdj;
+	gint tmpValue;
+	GtkAdjustment *tmpAdj;
+
+	(void) user_data;
 
- (void)user_data;
- 
- tmpAdj = gtk_spin_button_get_adjustment(
- 	GTK_SPIN_BUTTON(LUW("cfg_maxtime")));
- 
- tmpValue = (gint) gtk_spin_button_get_adjustment(
- 	GTK_SPIN_BUTTON(editable))->value;
+	tmpAdj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(LUW("cfg_maxtime")));
 
- if (tmpValue > tmpAdj->value)
- 	gtk_adjustment_set_value(tmpAdj, tmpValue);
+	tmpValue = (gint) gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(editable))->value;
+
+	if (tmpValue > tmpAdj->value)
+		gtk_adjustment_set_value(tmpAdj, tmpValue);
 }
 
 
-void xs_cfg_maxtime_changed(GtkEditable *editable, gpointer user_data)
+void xs_cfg_maxtime_changed(GtkEditable * editable, gpointer user_data)
 {
- gint tmpValue;
- GtkAdjustment *tmpAdj;
+	gint tmpValue;
+	GtkAdjustment *tmpAdj;
+
+	(void) user_data;
 
- (void)user_data;
- 
- tmpAdj = gtk_spin_button_get_adjustment(
- 	GTK_SPIN_BUTTON(LUW("cfg_mintime")));
- 
- tmpValue = (gint) gtk_spin_button_get_adjustment(
- 	GTK_SPIN_BUTTON(editable))->value;
+	tmpAdj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(LUW("cfg_mintime")));
 
- if (tmpValue < tmpAdj->value)
- 	gtk_adjustment_set_value(tmpAdj, tmpValue);
+	tmpValue = (gint) gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(editable))->value;
+
+	if (tmpValue < tmpAdj->value)
+		gtk_adjustment_set_value(tmpAdj, tmpValue);
 }
 
 
-void xs_cfg_filter2_reset(GtkButton *button, gpointer user_data)
+void xs_cfg_filter2_reset(GtkButton * button, gpointer user_data)
 {
- gfloat cv[] = {0, 0, 25, 25, 50, 50, 75, 50, 85, 55, 100, 100};
- GtkCurve *c = GTK_CURVE(LUW("cfg_filter2_curve"));
- 
- (void)button; (void)user_data;
- 
- gtk_curve_set_range(c, 0, 256, 0, 256);
- gtk_curve_set_vector (c, 6, cv);
+	gfloat cv[] = { 0, 0, 25, 25, 50, 50, 75, 50, 85, 55, 100, 100 };
+	GtkCurve *c = GTK_CURVE(LUW("cfg_filter2_curve"));
+
+	(void) button;
+	(void) user_data;
+
+	gtk_curve_set_range(c, 0, 256, 0, 256);
+	gtk_curve_set_vector(c, 6, cv);
 // gtk_curve_set_curve_type(c, GTK_CURVE_TYPE_SPLINE);
 }
 
@@ -829,138 +863,128 @@
  */
 void xs_configure(void)
 {
- gint i;
- gfloat tmpValue;
- GtkWidget *c;
- 
- /* Check if the window already exists */
- if (xs_configwin != NULL)
-	{
-	gdk_window_raise(xs_configwin->window);
-	return;
+	gint i;
+	gfloat tmpValue;
+	GtkWidget *c;
+
+	/* Check if the window already exists */
+	if (xs_configwin != NULL) {
+		gdk_window_raise(xs_configwin->window);
+		return;
 	}
 
- /* Create the window */
- xs_configwin = create_xs_configwin();
+	/* Create the window */
+	xs_configwin = create_xs_configwin();
 
- /* Create the custom filter curve widget for libSIDPlay2 */
- c = gtk_curve_new();
+	/* Create the custom filter curve widget for libSIDPlay2 */
+	c = gtk_curve_new();
 
- gtk_widget_set_name (c, "cfg_filter2_curve");
- gtk_widget_ref (c);
- gtk_object_set_data_full (GTK_OBJECT (xs_configwin),
-   "cfg_filter2_curve", c, (GtkDestroyNotify) gtk_widget_unref);
- gtk_widget_show (c);
- gtk_box_pack_start (GTK_BOX(LUW("cfg_box_sidplay2")), c, TRUE, TRUE, 4);
+	gtk_widget_set_name(c, "cfg_filter2_curve");
+	gtk_widget_ref(c);
+	gtk_object_set_data_full(GTK_OBJECT(xs_configwin), "cfg_filter2_curve", c, (GtkDestroyNotify) gtk_widget_unref);
+	gtk_widget_show(c);
+	gtk_box_pack_start(GTK_BOX(LUW("cfg_box_sidplay2")), c, TRUE, TRUE, 4);
+
+	xs_cfg_filter2_reset(NULL, NULL);
 
- xs_cfg_filter2_reset(NULL, NULL);
-
- /* Get lock on configuration */
- XS_MUTEX_LOCK(xs_cfg);
+	/* Get lock on configuration */
+	XS_MUTEX_LOCK(xs_cfg);
 
- /* Based on available optional parts, gray out options */
+	/* Based on available optional parts, gray out options */
 #ifndef HAVE_SIDPLAY1
- gtk_widget_set_sensitive(LUW("cfg_emu_sidplay1"), FALSE);
- gtk_widget_set_sensitive(LUW("cfg_box_sidplay1"), FALSE);
+	gtk_widget_set_sensitive(LUW("cfg_emu_sidplay1"), FALSE);
+	gtk_widget_set_sensitive(LUW("cfg_box_sidplay1"), FALSE);
 #endif
 
 #ifndef HAVE_SIDPLAY2
- gtk_widget_set_sensitive(LUW("cfg_emu_sidplay2"), FALSE);
- gtk_widget_set_sensitive(LUW("cfg_box_sidplay2"), FALSE);
+	gtk_widget_set_sensitive(LUW("cfg_emu_sidplay2"), FALSE);
+	gtk_widget_set_sensitive(LUW("cfg_box_sidplay2"), FALSE);
 #endif
 
 #ifndef HAVE_XMMSEXTRA
- gtk_widget_set_sensitive(LUW("cfg_ftitle_override"), FALSE);
- xs_cfg.titleOverride = TRUE;
+	gtk_widget_set_sensitive(LUW("cfg_ftitle_override"), FALSE);
+	xs_cfg.titleOverride = TRUE;
 #endif
 
 #ifndef HAVE_SONG_POSITION
- gtk_widget_set_sensitive(LUW("cfg_subctrl_patch"), FALSE);
+	gtk_widget_set_sensitive(LUW("cfg_subctrl_patch"), FALSE);
 #endif
 
- /* Update the widget sensitivities */
- xs_cfg_emu_filters_toggled((GtkToggleButton *) LUW("cfg_emu_filters"), NULL);
- xs_cfg_ftitle_override_toggled((GtkToggleButton *) LUW("cfg_ftitle_override"), NULL);
- xs_cfg_emu_sidplay1_toggled((GtkToggleButton *) LUW("cfg_emu_sidplay1"), NULL);
- xs_cfg_emu_sidplay2_toggled((GtkToggleButton *) LUW("cfg_emu_sidplay2"), NULL);
- xs_cfg_oversample_toggled((GtkToggleButton *) LUW("cfg_oversample"), NULL);
- xs_cfg_mintime_enable_toggled((GtkToggleButton *) LUW("cfg_mintime_enable"), NULL);
- xs_cfg_maxtime_enable_toggled((GtkToggleButton *) LUW("cfg_maxtime_enable"), NULL);
- xs_cfg_sld_enable_toggled((GtkToggleButton *) LUW("cfg_sld_enable"), NULL);
- xs_cfg_stil_enable_toggled((GtkToggleButton *) LUW("cfg_stil_enable"), NULL);
- xs_cfg_subauto_enable_toggled((GtkToggleButton *) LUW("cfg_subauto_enable"), NULL);
- xs_cfg_subauto_min_only_toggled((GtkToggleButton *) LUW("cfg_subauto_min_only"), NULL);
+	/* Update the widget sensitivities */
+	xs_cfg_emu_filters_toggled((GtkToggleButton *) LUW("cfg_emu_filters"), NULL);
+	xs_cfg_ftitle_override_toggled((GtkToggleButton *) LUW("cfg_ftitle_override"), NULL);
+	xs_cfg_emu_sidplay1_toggled((GtkToggleButton *) LUW("cfg_emu_sidplay1"), NULL);
+	xs_cfg_emu_sidplay2_toggled((GtkToggleButton *) LUW("cfg_emu_sidplay2"), NULL);
+	xs_cfg_oversample_toggled((GtkToggleButton *) LUW("cfg_oversample"), NULL);
+	xs_cfg_mintime_enable_toggled((GtkToggleButton *) LUW("cfg_mintime_enable"), NULL);
+	xs_cfg_maxtime_enable_toggled((GtkToggleButton *) LUW("cfg_maxtime_enable"), NULL);
+	xs_cfg_sld_enable_toggled((GtkToggleButton *) LUW("cfg_sld_enable"), NULL);
+	xs_cfg_stil_enable_toggled((GtkToggleButton *) LUW("cfg_stil_enable"), NULL);
+	xs_cfg_subauto_enable_toggled((GtkToggleButton *) LUW("cfg_subauto_enable"), NULL);
+	xs_cfg_subauto_min_only_toggled((GtkToggleButton *) LUW("cfg_subauto_min_only"), NULL);
 
 
- /* Set current data to widgets */
- for (i = 0; i < xs_widtable_max; i++)
- 	{
-	switch (xs_widtable[i].widType) {
-	case WTYPE_BGROUP:
-		/* Check if current value matches the given one */
-		gtk_toggle_button_set_active(
-			GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName)),
-			(*((gint *) xs_widtable[i].itemData) == xs_widtable[i].itemSet)
-			);
-		break;
-	
-
-	case WTYPE_SPIN:
-	case WTYPE_SCALE:
-		/* Get the value */
-		switch (xs_widtable[i].itemType) {
-		case CTYPE_INT:
-			tmpValue = (gfloat) *((gint *) xs_widtable[i].itemData);
-			break;
-
-		case CTYPE_FLOAT:
-			tmpValue = *((gfloat *) xs_widtable[i].itemData);
+	/* Set current data to widgets */
+	for (i = 0; i < xs_widtable_max; i++) {
+		switch (xs_widtable[i].widType) {
+		case WTYPE_BGROUP:
+			/* Check if current value matches the given one */
+			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName)),
+						     (*((gint *) xs_widtable[i].itemData) == xs_widtable[i].itemSet)
+			    );
 			break;
 
-		default:
-			tmpValue = -1;
-		}
-		
-		/* Set the value */
-		switch (xs_widtable[i].widType) {
+
 		case WTYPE_SPIN:
-			gtk_adjustment_set_value(
-			gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(LUW(xs_widtable[i].widName))),
-			tmpValue);
+		case WTYPE_SCALE:
+			/* Get the value */
+			switch (xs_widtable[i].itemType) {
+			case CTYPE_INT:
+				tmpValue = (gfloat) * ((gint *) xs_widtable[i].itemData);
+				break;
+
+			case CTYPE_FLOAT:
+				tmpValue = *((gfloat *) xs_widtable[i].itemData);
+				break;
+
+			default:
+				tmpValue = -1;
+			}
+
+			/* Set the value */
+			switch (xs_widtable[i].widType) {
+			case WTYPE_SPIN:
+				gtk_adjustment_set_value(gtk_spin_button_get_adjustment
+							 (GTK_SPIN_BUTTON(LUW(xs_widtable[i].widName))), tmpValue);
+				break;
+
+			case WTYPE_SCALE:
+				gtk_adjustment_set_value(gtk_range_get_adjustment
+							 (GTK_RANGE(LUW(xs_widtable[i].widName))), tmpValue);
+				break;
+			}
 			break;
-		
-		case WTYPE_SCALE:
-			gtk_adjustment_set_value(
-			gtk_range_get_adjustment(GTK_RANGE(LUW(xs_widtable[i].widName))),
-			tmpValue);
+
+		case WTYPE_BUTTON:
+			/* Set toggle-button */
+			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName)),
+						     *((gboolean *) xs_widtable[i].itemData)
+			    );
+			break;
+
+		case WTYPE_TEXT:
+			/* Set text to text-widget */
+			if (*(gchar **) xs_widtable[i].itemData != NULL) {
+				gtk_entry_set_text(GTK_ENTRY(LUW(xs_widtable[i].widName)),
+						   *(gchar **) xs_widtable[i].itemData);
+			}
 			break;
 		}
-		break;
-	
-	case WTYPE_BUTTON:
-		/* Set toggle-button */
-		gtk_toggle_button_set_active(
-			GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName)),
-			*((gboolean *) xs_widtable[i].itemData)
-			);
-		break;
-
-	case WTYPE_TEXT:
-		/* Set text to text-widget */
-		if (*(gchar **) xs_widtable[i].itemData != NULL)
-			{
-			gtk_entry_set_text(
-				GTK_ENTRY(LUW(xs_widtable[i].widName)),
-				*(gchar **) xs_widtable[i].itemData);
-			}
-		break;
-	}
 	}
 
- /* Release the configuration */
- XS_MUTEX_UNLOCK(xs_cfg);
+	/* Release the configuration */
+	XS_MUTEX_UNLOCK(xs_cfg);
 
- /* Show the widget */ 	
- gtk_widget_show(xs_configwin);
+	/* Show the widget */
+	gtk_widget_show(xs_configwin);
 }
-
--- a/src/xs_curve.c	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_curve.c	Mon Nov 07 09:50:04 2005 +0000
@@ -48,13 +48,14 @@
 			 GDK_BUTTON_RELEASE_MASK |	\
 			 GDK_BUTTON1_MOTION_MASK)
 
-enum {
-  ARG_0,
-  ARG_CURVE_TYPE,
-  ARG_MIN_X,
-  ARG_MAX_X,
-  ARG_MIN_Y,
-  ARG_MAX_Y
+enum
+{
+	ARG_0,
+	ARG_CURVE_TYPE,
+	ARG_MIN_X,
+	ARG_MAX_X,
+	ARG_MIN_Y,
+	ARG_MAX_Y
 };
 
 static GtkDrawingAreaClass *parent_class = NULL;
@@ -62,902 +63,777 @@
 
 
 /* forward declarations: */
-static void gtk_curve_class_init   (GtkCurveClass *class);
-static void gtk_curve_init         (GtkCurve      *curve);
-static void gtk_curve_set_arg     (GtkObject      *object,
-				   GtkArg         *arg,
-				   guint           arg_id);
-static void gtk_curve_get_arg     (GtkObject      *object,
-				   GtkArg         *arg,
-				   guint           arg_id);
-static void gtk_curve_finalize     (GtkObject     *object);
-static gint gtk_curve_graph_events (GtkWidget     *widget, 
-				    GdkEvent      *event, 
-				    GtkCurve      *c);
-static void gtk_curve_size_graph   (GtkCurve      *curve);
+static void gtk_curve_class_init(GtkCurveClass * class);
+static void gtk_curve_init(GtkCurve * curve);
+static void gtk_curve_set_arg(GtkObject * object, GtkArg * arg, guint arg_id);
+static void gtk_curve_get_arg(GtkObject * object, GtkArg * arg, guint arg_id);
+static void gtk_curve_finalize(GtkObject * object);
+static gint gtk_curve_graph_events(GtkWidget * widget, GdkEvent * event, GtkCurve * c);
+static void gtk_curve_size_graph(GtkCurve * curve);
 
-GtkType
-gtk_curve_get_type (void)
+GtkType gtk_curve_get_type(void)
 {
-  static GtkType curve_type = 0;
+	static GtkType curve_type = 0;
 
-  if (!curve_type)
-    {
-      static const GtkTypeInfo curve_info =
-      {
-	"GtkCurve",
-	sizeof (GtkCurve),
-	sizeof (GtkCurveClass),
-	(GtkClassInitFunc) gtk_curve_class_init,
-	(GtkObjectInitFunc) gtk_curve_init,
-	/* reserved_1 */ NULL,
-        /* reserved_2 */ NULL,
-        (GtkClassInitFunc) NULL,
-      };
+	if (!curve_type) {
+		static const GtkTypeInfo curve_info = {
+			"GtkCurve",
+			sizeof(GtkCurve),
+			sizeof(GtkCurveClass),
+			(GtkClassInitFunc) gtk_curve_class_init,
+			(GtkObjectInitFunc) gtk_curve_init,
+			/* reserved_1 */ NULL,
+			/* reserved_2 */ NULL,
+			(GtkClassInitFunc) NULL,
+		};
 
-      curve_type = gtk_type_unique (GTK_TYPE_DRAWING_AREA, &curve_info);
-    }
-  return curve_type;
+		curve_type = gtk_type_unique(GTK_TYPE_DRAWING_AREA, &curve_info);
+	}
+	return curve_type;
 }
 
-static void
-gtk_curve_class_init (GtkCurveClass *class)
+static void gtk_curve_class_init(GtkCurveClass * class)
 {
-  GtkObjectClass *object_class;
-  
-  parent_class = gtk_type_class (GTK_TYPE_DRAWING_AREA);
-  
-  object_class = (GtkObjectClass *) class;
-  
-  object_class->set_arg = gtk_curve_set_arg;
-  object_class->get_arg = gtk_curve_get_arg;
-  object_class->finalize = gtk_curve_finalize;
-  
-  curve_type_changed_signal =
-    gtk_signal_new ("curve_type_changed", GTK_RUN_FIRST, object_class->type,
-		    GTK_SIGNAL_OFFSET (GtkCurveClass, curve_type_changed),
-		    gtk_marshal_NONE__NONE, GTK_TYPE_NONE, 0);
-  gtk_object_class_add_signals (object_class, &curve_type_changed_signal, 1);
-  
-  gtk_object_add_arg_type ("GtkCurve::curve_type", GTK_TYPE_CURVE_TYPE,
-			   GTK_ARG_READWRITE, ARG_CURVE_TYPE);
-  gtk_object_add_arg_type ("GtkCurve::min_x", GTK_TYPE_FLOAT,
-			   GTK_ARG_READWRITE, ARG_MIN_X);
-  gtk_object_add_arg_type ("GtkCurve::max_x", GTK_TYPE_FLOAT,
-			   GTK_ARG_READWRITE, ARG_MAX_X);
-  gtk_object_add_arg_type ("GtkCurve::min_y", GTK_TYPE_FLOAT,
-			   GTK_ARG_READWRITE, ARG_MIN_Y);
-  gtk_object_add_arg_type ("GtkCurve::max_y", GTK_TYPE_FLOAT,
-			   GTK_ARG_READWRITE, ARG_MAX_Y);
+	GtkObjectClass *object_class;
+
+	parent_class = gtk_type_class(GTK_TYPE_DRAWING_AREA);
+
+	object_class = (GtkObjectClass *) class;
+
+	object_class->set_arg = gtk_curve_set_arg;
+	object_class->get_arg = gtk_curve_get_arg;
+	object_class->finalize = gtk_curve_finalize;
+
+	curve_type_changed_signal =
+	    gtk_signal_new("curve_type_changed", GTK_RUN_FIRST, object_class->type,
+			   GTK_SIGNAL_OFFSET(GtkCurveClass, curve_type_changed),
+			   gtk_marshal_NONE__NONE, GTK_TYPE_NONE, 0);
+	gtk_object_class_add_signals(object_class, &curve_type_changed_signal, 1);
+
+	gtk_object_add_arg_type("GtkCurve::curve_type", GTK_TYPE_CURVE_TYPE, GTK_ARG_READWRITE, ARG_CURVE_TYPE);
+	gtk_object_add_arg_type("GtkCurve::min_x", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_MIN_X);
+	gtk_object_add_arg_type("GtkCurve::max_x", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_MAX_X);
+	gtk_object_add_arg_type("GtkCurve::min_y", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_MIN_Y);
+	gtk_object_add_arg_type("GtkCurve::max_y", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_MAX_Y);
 }
 
-static void
-gtk_curve_init (GtkCurve *curve)
+static void gtk_curve_init(GtkCurve * curve)
 {
-  gint old_mask;
+	gint old_mask;
 
-  curve->cursor_type = GDK_TOP_LEFT_ARROW;
-  curve->pixmap = NULL;
-  curve->curve_type = GTK_CURVE_TYPE_SPLINE;
-  curve->height = 0;
-  curve->grab_point = -1;
+	curve->cursor_type = GDK_TOP_LEFT_ARROW;
+	curve->pixmap = NULL;
+	curve->curve_type = GTK_CURVE_TYPE_SPLINE;
+	curve->height = 0;
+	curve->grab_point = -1;
 
-  curve->num_points = 0;
-  curve->point = 0;
+	curve->num_points = 0;
+	curve->point = 0;
 
-  curve->num_ctlpoints = 0;
-  curve->ctlpoint = NULL;
+	curve->num_ctlpoints = 0;
+	curve->ctlpoint = NULL;
 
-  curve->min_x = 0.0;
-  curve->max_x = 1.0;
-  curve->min_y = 0.0;
-  curve->max_y = 1.0;
+	curve->min_x = 0.0;
+	curve->max_x = 1.0;
+	curve->min_y = 0.0;
+	curve->max_y = 1.0;
 
-  old_mask = gtk_widget_get_events (GTK_WIDGET (curve));
-  gtk_widget_set_events (GTK_WIDGET (curve), old_mask | GRAPH_MASK);
-  gtk_signal_connect (GTK_OBJECT (curve), "event",
-		      (GtkSignalFunc) gtk_curve_graph_events, curve);
-  gtk_curve_size_graph (curve);
+	old_mask = gtk_widget_get_events(GTK_WIDGET(curve));
+	gtk_widget_set_events(GTK_WIDGET(curve), old_mask | GRAPH_MASK);
+	gtk_signal_connect(GTK_OBJECT(curve), "event", (GtkSignalFunc) gtk_curve_graph_events, curve);
+	gtk_curve_size_graph(curve);
 }
 
-static void
-gtk_curve_set_arg (GtkObject *object,
-		   GtkArg    *arg,
-		   guint      arg_id)
+static void gtk_curve_set_arg(GtkObject * object, GtkArg * arg, guint arg_id)
 {
-  GtkCurve *curve = GTK_CURVE (object);
-  
-  switch (arg_id)
-    {
-    case ARG_CURVE_TYPE:
-      gtk_curve_set_curve_type (curve, GTK_VALUE_ENUM (*arg));
-      break;
-    case ARG_MIN_X:
-      gtk_curve_set_range (curve, GTK_VALUE_FLOAT (*arg), curve->max_x,
-			   curve->min_y, curve->max_y);
-      break;
-    case ARG_MAX_X:
-      gtk_curve_set_range (curve, curve->min_x, GTK_VALUE_FLOAT (*arg),
-			   curve->min_y, curve->max_y);
-      break;	
-    case ARG_MIN_Y:
-      gtk_curve_set_range (curve, curve->min_x, curve->max_x,
-			   GTK_VALUE_FLOAT (*arg), curve->max_y);
-      break;
-    case ARG_MAX_Y:
-      gtk_curve_set_range (curve, curve->min_x, curve->max_x,
-			   curve->min_y, GTK_VALUE_FLOAT (*arg));
-      break;
-    }
+	GtkCurve *curve = GTK_CURVE(object);
+
+	switch (arg_id) {
+	case ARG_CURVE_TYPE:
+		gtk_curve_set_curve_type(curve, GTK_VALUE_ENUM(*arg));
+		break;
+	case ARG_MIN_X:
+		gtk_curve_set_range(curve, GTK_VALUE_FLOAT(*arg), curve->max_x, curve->min_y, curve->max_y);
+		break;
+	case ARG_MAX_X:
+		gtk_curve_set_range(curve, curve->min_x, GTK_VALUE_FLOAT(*arg), curve->min_y, curve->max_y);
+		break;
+	case ARG_MIN_Y:
+		gtk_curve_set_range(curve, curve->min_x, curve->max_x, GTK_VALUE_FLOAT(*arg), curve->max_y);
+		break;
+	case ARG_MAX_Y:
+		gtk_curve_set_range(curve, curve->min_x, curve->max_x, curve->min_y, GTK_VALUE_FLOAT(*arg));
+		break;
+	}
 }
 
-static void
-gtk_curve_get_arg (GtkObject *object,
-		   GtkArg    *arg,
-		   guint      arg_id)
+static void gtk_curve_get_arg(GtkObject * object, GtkArg * arg, guint arg_id)
 {
-  GtkCurve *curve = GTK_CURVE (object);
+	GtkCurve *curve = GTK_CURVE(object);
 
-  switch (arg_id)
-    {
-    case ARG_CURVE_TYPE:
-      GTK_VALUE_ENUM (*arg) = curve->curve_type;
-      break;
-    case ARG_MIN_X:
-      GTK_VALUE_FLOAT (*arg) = curve->min_x;
-      break;
-    case ARG_MAX_X:
-      GTK_VALUE_FLOAT (*arg) = curve->max_x;
-      break;
-    case ARG_MIN_Y:
-      GTK_VALUE_FLOAT (*arg) = curve->min_y;
-      break;
-    case ARG_MAX_Y:
-      GTK_VALUE_FLOAT (*arg) = curve->max_y;
-      break;
-    default:
-      arg->type = GTK_TYPE_INVALID;
-      break;
-    }
+	switch (arg_id) {
+	case ARG_CURVE_TYPE:
+		GTK_VALUE_ENUM(*arg) = curve->curve_type;
+		break;
+	case ARG_MIN_X:
+		GTK_VALUE_FLOAT(*arg) = curve->min_x;
+		break;
+	case ARG_MAX_X:
+		GTK_VALUE_FLOAT(*arg) = curve->max_x;
+		break;
+	case ARG_MIN_Y:
+		GTK_VALUE_FLOAT(*arg) = curve->min_y;
+		break;
+	case ARG_MAX_Y:
+		GTK_VALUE_FLOAT(*arg) = curve->max_y;
+		break;
+	default:
+		arg->type = GTK_TYPE_INVALID;
+		break;
+	}
 }
 
-static int
-project (gfloat value, gfloat min, gfloat max, int norm)
+static int project(gfloat value, gfloat min, gfloat max, int norm)
 {
-  return (norm - 1) * ((value - min) / (max - min)) + 0.5;
+	return (norm - 1) * ((value - min) / (max - min)) + 0.5;
 }
 
-static gfloat
-unproject (gint value, gfloat min, gfloat max, int norm)
+static gfloat unproject(gint value, gfloat min, gfloat max, int norm)
 {
-  return value / (gfloat) (norm - 1) * (max - min) + min;
+	return value / (gfloat) (norm - 1) * (max - min) + min;
 }
 
 /* Solve the tridiagonal equation system that determines the second
    derivatives for the interpolation points.  (Based on Numerical
    Recipies 2nd Edition.) */
-static void
-spline_solve (int n, gfloat x[], gfloat y[], gfloat y2[])
+static void spline_solve(int n, gfloat x[], gfloat y[], gfloat y2[])
 {
-  gfloat p, sig, *u;
-  gint i, k;
+	gfloat p, sig, *u;
+	gint i, k;
 
-  u = g_malloc ((n - 1) * sizeof (u[0]));
+	u = g_malloc((n - 1) * sizeof(u[0]));
 
-  y2[0] = u[0] = 0.0;	/* set lower boundary condition to "natural" */
+	y2[0] = u[0] = 0.0;	/* set lower boundary condition to "natural" */
 
-  for (i = 1; i < n - 1; ++i)
-    {
-      sig = (x[i] - x[i - 1]) / (x[i + 1] - x[i - 1]);
-      p = sig * y2[i - 1] + 2.0;
-      y2[i] = (sig - 1.0) / p;
-      u[i] = ((y[i + 1] - y[i])
-	      / (x[i + 1] - x[i]) - (y[i] - y[i - 1]) / (x[i] - x[i - 1]));
-      u[i] = (6.0 * u[i] / (x[i + 1] - x[i - 1]) - sig * u[i - 1]) / p;
-    }
+	for (i = 1; i < n - 1; ++i) {
+		sig = (x[i] - x[i - 1]) / (x[i + 1] - x[i - 1]);
+		p = sig * y2[i - 1] + 2.0;
+		y2[i] = (sig - 1.0) / p;
+		u[i] = ((y[i + 1] - y[i])
+			/ (x[i + 1] - x[i]) - (y[i] - y[i - 1]) / (x[i] - x[i - 1]));
+		u[i] = (6.0 * u[i] / (x[i + 1] - x[i - 1]) - sig * u[i - 1]) / p;
+	}
 
-  y2[n - 1] = 0.0;
-  for (k = n - 2; k >= 0; --k)
-    y2[k] = y2[k] * y2[k + 1] + u[k];
+	y2[n - 1] = 0.0;
+	for (k = n - 2; k >= 0; --k)
+		y2[k] = y2[k] * y2[k + 1] + u[k];
 
-  g_free (u);
+	g_free(u);
 }
 
-static gfloat
-spline_eval (int n, gfloat x[], gfloat y[], gfloat y2[], gfloat val)
+static gfloat spline_eval(int n, gfloat x[], gfloat y[], gfloat y2[], gfloat val)
 {
-  gint k_lo, k_hi, k;
-  gfloat h, b, a;
+	gint k_lo, k_hi, k;
+	gfloat h, b, a;
 
-  /* do a binary search for the right interval: */
-  k_lo = 0; k_hi = n - 1;
-  while (k_hi - k_lo > 1)
-    {
-      k = (k_hi + k_lo) / 2;
-      if (x[k] > val)
-	k_hi = k;
-      else
-	k_lo = k;
-    }
+	/* do a binary search for the right interval: */
+	k_lo = 0;
+	k_hi = n - 1;
+	while (k_hi - k_lo > 1) {
+		k = (k_hi + k_lo) / 2;
+		if (x[k] > val)
+			k_hi = k;
+		else
+			k_lo = k;
+	}
 
-  h = x[k_hi] - x[k_lo];
-  g_assert (h > 0.0);
+	h = x[k_hi] - x[k_lo];
+	g_assert(h > 0.0);
 
-  a = (x[k_hi] - val) / h;
-  b = (val - x[k_lo]) / h;
-  return a*y[k_lo] + b*y[k_hi] +
-    ((a*a*a - a)*y2[k_lo] + (b*b*b - b)*y2[k_hi]) * (h*h)/6.0;
+	a = (x[k_hi] - val) / h;
+	b = (val - x[k_lo]) / h;
+	return a * y[k_lo] + b * y[k_hi] + ((a * a * a - a) * y2[k_lo] + (b * b * b - b) * y2[k_hi]) * (h * h) / 6.0;
 }
 
-static void
-gtk_curve_interpolate (GtkCurve *c, gint width, gint height)
+static void gtk_curve_interpolate(GtkCurve * c, gint width, gint height)
 {
-  gfloat *vector;
-  int i;
+	gfloat *vector;
+	int i;
 
-  vector = g_malloc (width * sizeof (vector[0]));
+	vector = g_malloc(width * sizeof(vector[0]));
 
-  gtk_curve_get_vector (c, width, vector);
+	gtk_curve_get_vector(c, width, vector);
 
-  c->height = height;
-  if (c->num_points != width)
-    {
-      c->num_points = width;
-      if (c->point)
-	g_free (c->point);
-      c->point = g_malloc (c->num_points * sizeof (c->point[0]));
-    }
+	c->height = height;
+	if (c->num_points != width) {
+		c->num_points = width;
+		if (c->point)
+			g_free(c->point);
+		c->point = g_malloc(c->num_points * sizeof(c->point[0]));
+	}
 
-  for (i = 0; i < width; ++i)
-    {
-      c->point[i].x = RADIUS + i;
-      c->point[i].y = RADIUS + height
-	- project (vector[i], c->min_y, c->max_y, height);
-    }
+	for (i = 0; i < width; ++i) {
+		c->point[i].x = RADIUS + i;
+		c->point[i].y = RADIUS + height - project(vector[i], c->min_y, c->max_y, height);
+	}
 
-  g_free (vector);
+	g_free(vector);
 }
 
-static void
-gtk_curve_draw (GtkCurve *c, gint width, gint height)
+static void gtk_curve_draw(GtkCurve * c, gint width, gint height)
 {
-  GtkStateType state;
-  GtkStyle *style;
-  gint i;
+	GtkStateType state;
+	GtkStyle *style;
+	gint i;
+
+	if (!c->pixmap)
+		return;
 
-  if (!c->pixmap)
-    return;
-
-  if (c->height != height || c->num_points != width)
-    gtk_curve_interpolate (c, width, height);
+	if (c->height != height || c->num_points != width)
+		gtk_curve_interpolate(c, width, height);
 
-  state = GTK_STATE_NORMAL;
-  if (!GTK_WIDGET_IS_SENSITIVE (GTK_WIDGET (c)))
-    state = GTK_STATE_INSENSITIVE;
+	state = GTK_STATE_NORMAL;
+	if (!GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(c)))
+		state = GTK_STATE_INSENSITIVE;
 
-  style = GTK_WIDGET (c)->style;
+	style = GTK_WIDGET(c)->style;
 
-  /* clear the pixmap: */
-  gtk_paint_flat_box (style, c->pixmap, GTK_STATE_NORMAL, GTK_SHADOW_NONE,
-		      NULL, GTK_WIDGET(c), "curve_bg",
-		      0, 0, width + RADIUS * 2, height + RADIUS * 2);
-  /* draw the grid lines: (XXX make more meaningful) */
-  for (i = 0; i < 5; i++)
-    {
-      gdk_draw_line (c->pixmap, style->dark_gc[state],
-		     RADIUS, i * (height / 4.0) + RADIUS,
-		     width + RADIUS, i * (height / 4.0) + RADIUS);
-      gdk_draw_line (c->pixmap, style->dark_gc[state],
-		     i * (width / 4.0) + RADIUS, RADIUS,
-		     i * (width / 4.0) + RADIUS, height + RADIUS);
-    }
+	/* clear the pixmap: */
+	gtk_paint_flat_box(style, c->pixmap, GTK_STATE_NORMAL, GTK_SHADOW_NONE,
+			   NULL, GTK_WIDGET(c), "curve_bg", 0, 0, width + RADIUS * 2, height + RADIUS * 2);
+	/* draw the grid lines: (XXX make more meaningful) */
+	for (i = 0; i < 5; i++) {
+		gdk_draw_line(c->pixmap, style->dark_gc[state],
+			      RADIUS, i * (height / 4.0) + RADIUS, width + RADIUS, i * (height / 4.0) + RADIUS);
+		gdk_draw_line(c->pixmap, style->dark_gc[state],
+			      i * (width / 4.0) + RADIUS, RADIUS, i * (width / 4.0) + RADIUS, height + RADIUS);
+	}
 
-  gdk_draw_points (c->pixmap, style->fg_gc[state], c->point, c->num_points);
-  if (c->curve_type != GTK_CURVE_TYPE_FREE)
-    for (i = 0; i < c->num_ctlpoints; ++i)
-      {
-	gint x, y;
+	gdk_draw_points(c->pixmap, style->fg_gc[state], c->point, c->num_points);
+	if (c->curve_type != GTK_CURVE_TYPE_FREE)
+		for (i = 0; i < c->num_ctlpoints; ++i) {
+			gint x, y;
 
-	if (c->ctlpoint[i][0] < c->min_x)
-	  continue;
+			if (c->ctlpoint[i][0] < c->min_x)
+				continue;
 
-	x = project (c->ctlpoint[i][0], c->min_x, c->max_x,
-		     width);
-	y = height -
-	  project (c->ctlpoint[i][1], c->min_y, c->max_y,
-		   height);
+			x = project(c->ctlpoint[i][0], c->min_x, c->max_x, width);
+			y = height - project(c->ctlpoint[i][1], c->min_y, c->max_y, height);
 
-	/* draw a bullet: */
-	gdk_draw_arc (c->pixmap, style->fg_gc[state], TRUE, x, y,
-		      RADIUS * 2, RADIUS*2, 0, 360*64);
-      }
-  gdk_draw_pixmap (GTK_WIDGET (c)->window, style->fg_gc[state], c->pixmap,
-		   0, 0, 0, 0, width + RADIUS * 2, height + RADIUS * 2);
+			/* draw a bullet: */
+			gdk_draw_arc(c->pixmap, style->fg_gc[state], TRUE, x, y, RADIUS * 2, RADIUS * 2, 0, 360 * 64);
+		}
+	gdk_draw_pixmap(GTK_WIDGET(c)->window, style->fg_gc[state], c->pixmap,
+			0, 0, 0, 0, width + RADIUS * 2, height + RADIUS * 2);
 }
 
-static gint
-gtk_curve_graph_events (GtkWidget *widget, GdkEvent *event, GtkCurve *c)
+static gint gtk_curve_graph_events(GtkWidget * widget, GdkEvent * event, GtkCurve * c)
 {
-  GdkCursorType new_type = c->cursor_type;
-  gint i, src, dst, leftbound, rightbound;
-  GdkEventButton *bevent;
-  GdkEventMotion *mevent;
-  GtkWidget *w;
-  gint tx, ty;
-  gint cx, x, y, width, height;
-  gint closest_point = 0;
-  gfloat rx, ry, min_x;
-  guint distance;
-  gint x1, x2, y1, y2;
+	GdkCursorType new_type = c->cursor_type;
+	gint i, src, dst, leftbound, rightbound;
+	GdkEventButton *bevent;
+	GdkEventMotion *mevent;
+	GtkWidget *w;
+	gint tx, ty;
+	gint cx, x, y, width, height;
+	gint closest_point = 0;
+	gfloat rx, ry, min_x;
+	guint distance;
+	gint x1, x2, y1, y2;
+
+	w = GTK_WIDGET(c);
+	width = w->allocation.width - RADIUS * 2;
+	height = w->allocation.height - RADIUS * 2;
 
-  w = GTK_WIDGET (c);
-  width = w->allocation.width - RADIUS * 2;
-  height = w->allocation.height - RADIUS * 2;
+	if ((width < 0) || (height < 0))
+		return FALSE;
+
+	/*  get the pointer position  */
+	gdk_window_get_pointer(w->window, &tx, &ty, NULL);
+	x = CLAMP((tx - RADIUS), 0, width - 1);
+	y = CLAMP((ty - RADIUS), 0, height - 1);
+
+	min_x = c->min_x;
+
+	distance = ~0U;
+	for (i = 0; i < c->num_ctlpoints; ++i) {
+		cx = project(c->ctlpoint[i][0], min_x, c->max_x, width);
+		if ((guint) abs(x - cx) < distance) {
+			distance = abs(x - cx);
+			closest_point = i;
+		}
+	}
 
-  if ((width < 0) || (height < 0))
-    return FALSE;
+	switch (event->type) {
+	case GDK_CONFIGURE:
+		if (c->pixmap)
+			gdk_pixmap_unref(c->pixmap);
+		c->pixmap = 0;
+		/* fall through */
+	case GDK_EXPOSE:
+		if (!c->pixmap)
+			c->pixmap = gdk_pixmap_new(w->window, w->allocation.width, w->allocation.height, -1);
+		gtk_curve_draw(c, width, height);
+		break;
 
-  /*  get the pointer position  */
-  gdk_window_get_pointer (w->window, &tx, &ty, NULL);
-  x = CLAMP ((tx - RADIUS), 0, width-1);
-  y = CLAMP ((ty - RADIUS), 0, height-1);
+	case GDK_BUTTON_PRESS:
+		gtk_grab_add(widget);
 
-  min_x = c->min_x;
+		bevent = (GdkEventButton *) event;
+		new_type = GDK_TCROSS;
 
-  distance = ~0U;
-  for (i = 0; i < c->num_ctlpoints; ++i)
-    {
-      cx = project (c->ctlpoint[i][0], min_x, c->max_x, width);
-      if ((guint) abs (x - cx) < distance)
-	{
-	  distance = abs (x - cx);
-	  closest_point = i;
-	}
-    }
+		switch (c->curve_type) {
+		case GTK_CURVE_TYPE_LINEAR:
+		case GTK_CURVE_TYPE_SPLINE:
+			if (distance > MIN_DISTANCE) {
+				/* insert a new control point */
+				if (c->num_ctlpoints > 0) {
+					cx = project(c->ctlpoint[closest_point][0], min_x, c->max_x, width);
+					if (x > cx)
+						++closest_point;
+				}
+				++c->num_ctlpoints;
+				c->ctlpoint = g_realloc(c->ctlpoint, c->num_ctlpoints * sizeof(*c->ctlpoint));
+				for (i = c->num_ctlpoints - 1; i > closest_point; --i)
+					memcpy(c->ctlpoint + i, c->ctlpoint + i - 1, sizeof(*c->ctlpoint));
+			}
+			c->grab_point = closest_point;
+			c->ctlpoint[c->grab_point][0] = unproject(x, min_x, c->max_x, width);
+			c->ctlpoint[c->grab_point][1] = unproject(height - y, c->min_y, c->max_y, height);
+
+			gtk_curve_interpolate(c, width, height);
+			break;
+
+		case GTK_CURVE_TYPE_FREE:
+			c->point[x].x = RADIUS + x;
+			c->point[x].y = RADIUS + y;
+			c->grab_point = x;
+			c->last = y;
+			break;
+		}
+		gtk_curve_draw(c, width, height);
+		break;
+
+	case GDK_BUTTON_RELEASE:
+		gtk_grab_remove(widget);
 
-  switch (event->type)
-    {
-    case GDK_CONFIGURE:
-      if (c->pixmap)
-	gdk_pixmap_unref (c->pixmap);
-      c->pixmap = 0;
-      /* fall through */
-    case GDK_EXPOSE:
-      if (!c->pixmap)
-	c->pixmap = gdk_pixmap_new (w->window,
-				    w->allocation.width,
-				    w->allocation.height, -1);
-      gtk_curve_draw (c, width, height);
-      break;
+		/* delete inactive points: */
+		if (c->curve_type != GTK_CURVE_TYPE_FREE) {
+			for (src = dst = 0; src < c->num_ctlpoints; ++src) {
+				if (c->ctlpoint[src][0] >= min_x) {
+					memcpy(c->ctlpoint + dst, c->ctlpoint + src, sizeof(*c->ctlpoint));
+					++dst;
+				}
+			}
+			if (dst < src) {
+				c->num_ctlpoints -= (src - dst);
+				if (c->num_ctlpoints <= 0) {
+					c->num_ctlpoints = 1;
+					c->ctlpoint[0][0] = min_x;
+					c->ctlpoint[0][1] = c->min_y;
+					gtk_curve_interpolate(c, width, height);
+					gtk_curve_draw(c, width, height);
+				}
+				c->ctlpoint = g_realloc(c->ctlpoint, c->num_ctlpoints * sizeof(*c->ctlpoint));
+			}
+		}
+		new_type = GDK_FLEUR;
+		c->grab_point = -1;
+		break;
 
-    case GDK_BUTTON_PRESS:
-      gtk_grab_add (widget);
+	case GDK_MOTION_NOTIFY:
+		mevent = (GdkEventMotion *) event;
 
-      bevent = (GdkEventButton *) event;
-      new_type = GDK_TCROSS;
+		switch (c->curve_type) {
+		case GTK_CURVE_TYPE_LINEAR:
+		case GTK_CURVE_TYPE_SPLINE:
+			if (c->grab_point == -1) {
+				/* if no point is grabbed...  */
+				if (distance <= MIN_DISTANCE)
+					new_type = GDK_FLEUR;
+				else
+					new_type = GDK_TCROSS;
+			} else {
+				/* drag the grabbed point  */
+				new_type = GDK_TCROSS;
+
+				leftbound = -MIN_DISTANCE;
+				if (c->grab_point > 0)
+					leftbound = project(c->ctlpoint[c->grab_point - 1][0], min_x, c->max_x, width);
+
+				rightbound = width + RADIUS * 2 + MIN_DISTANCE;
+				if (c->grab_point + 1 < c->num_ctlpoints)
+					rightbound = project(c->ctlpoint[c->grab_point + 1][0], min_x, c->max_x, width);
 
-      switch (c->curve_type)
-	{
-	case GTK_CURVE_TYPE_LINEAR:
-	case GTK_CURVE_TYPE_SPLINE:
-	  if (distance > MIN_DISTANCE)
-	    {
-	      /* insert a new control point */
-	      if (c->num_ctlpoints > 0)
-		{
-		  cx = project (c->ctlpoint[closest_point][0], min_x,
-				c->max_x, width);
-		  if (x > cx)
-		    ++closest_point;
+				if (tx <= leftbound || tx >= rightbound
+				    || ty > height + RADIUS * 2 + MIN_DISTANCE || ty < -MIN_DISTANCE)
+					c->ctlpoint[c->grab_point][0] = min_x - 1.0;
+				else {
+					rx = unproject(x, min_x, c->max_x, width);
+					ry = unproject(height - y, c->min_y, c->max_y, height);
+					c->ctlpoint[c->grab_point][0] = rx;
+					c->ctlpoint[c->grab_point][1] = ry;
+				}
+				gtk_curve_interpolate(c, width, height);
+				gtk_curve_draw(c, width, height);
+			}
+			break;
+
+		case GTK_CURVE_TYPE_FREE:
+			if (c->grab_point != -1) {
+				if (c->grab_point > x) {
+					x1 = x;
+					x2 = c->grab_point;
+					y1 = y;
+					y2 = c->last;
+				} else {
+					x1 = c->grab_point;
+					x2 = x;
+					y1 = c->last;
+					y2 = y;
+				}
+
+				if (x2 != x1)
+					for (i = x1; i <= x2; i++) {
+						c->point[i].x = RADIUS + i;
+						c->point[i].y = RADIUS + (y1 + ((y2 - y1) * (i - x1)) / (x2 - x1));
+				} else {
+					c->point[x].x = RADIUS + x;
+					c->point[x].y = RADIUS + y;
+				}
+				c->grab_point = x;
+				c->last = y;
+				gtk_curve_draw(c, width, height);
+			}
+			if (mevent->state & GDK_BUTTON1_MASK)
+				new_type = GDK_TCROSS;
+			else
+				new_type = GDK_PENCIL;
+			break;
 		}
-	      ++c->num_ctlpoints;
-	      c->ctlpoint =
-		g_realloc (c->ctlpoint,
-			   c->num_ctlpoints * sizeof (*c->ctlpoint));
-	      for (i = c->num_ctlpoints - 1; i > closest_point; --i)
-		memcpy (c->ctlpoint + i, c->ctlpoint + i - 1,
-			sizeof (*c->ctlpoint));
-	    }
-	  c->grab_point = closest_point;
-	  c->ctlpoint[c->grab_point][0] =
-	    unproject (x, min_x, c->max_x, width);
-	  c->ctlpoint[c->grab_point][1] =
-	    unproject (height - y, c->min_y, c->max_y, height);
+		if (new_type != (GdkCursorType) c->cursor_type) {
+			GdkCursor *cursor;
+
+			c->cursor_type = new_type;
 
-	  gtk_curve_interpolate (c, width, height);
-	  break;
+			cursor = gdk_cursor_new(c->cursor_type);
+			gdk_window_set_cursor(w->window, cursor);
+			gdk_cursor_destroy(cursor);
+		}
+		break;
 
-	case GTK_CURVE_TYPE_FREE:
-	  c->point[x].x = RADIUS + x;
-	  c->point[x].y = RADIUS + y;
-	  c->grab_point = x;
-	  c->last = y;
-	  break;
+	default:
+		break;
 	}
-      gtk_curve_draw (c, width, height);
-      break;
+	return FALSE;
+}
 
-    case GDK_BUTTON_RELEASE:
-      gtk_grab_remove (widget);
+void gtk_curve_set_curve_type(GtkCurve * c, GtkCurveType new_type)
+{
+	gfloat rx, dx;
+	gint x, i;
+
+	if (new_type != c->curve_type) {
+		gint width, height;
+
+		width = GTK_WIDGET(c)->allocation.width - RADIUS * 2;
+		height = GTK_WIDGET(c)->allocation.height - RADIUS * 2;
 
-      /* delete inactive points: */
-      if (c->curve_type != GTK_CURVE_TYPE_FREE)
-	{
-	  for (src = dst = 0; src < c->num_ctlpoints; ++src)
-	    {
-	      if (c->ctlpoint[src][0] >= min_x)
-		{
-		  memcpy (c->ctlpoint + dst, c->ctlpoint + src,
-			  sizeof (*c->ctlpoint));
-		  ++dst;
+		if (new_type == GTK_CURVE_TYPE_FREE) {
+			gtk_curve_interpolate(c, width, height);
+			c->curve_type = new_type;
+		} else if (c->curve_type == GTK_CURVE_TYPE_FREE) {
+			if (c->ctlpoint)
+				g_free(c->ctlpoint);
+			c->num_ctlpoints = 9;
+			c->ctlpoint = g_malloc(c->num_ctlpoints * sizeof(*c->ctlpoint));
+
+			rx = 0.0;
+			dx = (width - 1) / (gfloat) (c->num_ctlpoints - 1);
+
+			for (i = 0; i < c->num_ctlpoints; ++i, rx += dx) {
+				x = (int) (rx + 0.5);
+				c->ctlpoint[i][0] = unproject(x, c->min_x, c->max_x, width);
+				c->ctlpoint[i][1] =
+				    unproject(RADIUS + height - c->point[x].y, c->min_y, c->max_y, height);
+			}
+			c->curve_type = new_type;
+			gtk_curve_interpolate(c, width, height);
+		} else {
+			c->curve_type = new_type;
+			gtk_curve_interpolate(c, width, height);
 		}
-	    }
-	  if (dst < src)
-	    {
-	      c->num_ctlpoints -= (src - dst);
-	      if (c->num_ctlpoints <= 0)
-		{
-		  c->num_ctlpoints = 1;
-		  c->ctlpoint[0][0] = min_x;
-		  c->ctlpoint[0][1] = c->min_y;
-		  gtk_curve_interpolate (c, width, height);
-		  gtk_curve_draw (c, width, height);
+		gtk_signal_emit(GTK_OBJECT(c), curve_type_changed_signal);
+		gtk_curve_draw(c, width, height);
+	}
+}
+
+static void gtk_curve_size_graph(GtkCurve * curve)
+{
+	gint width, height;
+	gfloat aspect;
+
+	width = (curve->max_x - curve->min_x) + 1;
+	height = (curve->max_y - curve->min_y) + 1;
+	aspect = width / (gfloat) height;
+	if (width > gdk_screen_width() / 4)
+		width = gdk_screen_width() / 4;
+	if (height > gdk_screen_height() / 4)
+		height = gdk_screen_height() / 4;
+
+	if (aspect < 1.0)
+		width = height * aspect;
+	else
+		height = width / aspect;
+
+	gtk_drawing_area_size(GTK_DRAWING_AREA(curve), width + RADIUS * 2, height + RADIUS * 2);
+}
+
+static void gtk_curve_reset_vector(GtkCurve * curve)
+{
+	if (curve->ctlpoint)
+		g_free(curve->ctlpoint);
+
+	curve->num_ctlpoints = 2;
+	curve->ctlpoint = g_malloc(2 * sizeof(curve->ctlpoint[0]));
+	curve->ctlpoint[0][0] = curve->min_x;
+	curve->ctlpoint[0][1] = curve->min_y;
+	curve->ctlpoint[1][0] = curve->max_x;
+	curve->ctlpoint[1][1] = curve->max_y;
+
+	if (curve->pixmap) {
+		gint width, height;
+
+		width = GTK_WIDGET(curve)->allocation.width - RADIUS * 2;
+		height = GTK_WIDGET(curve)->allocation.height - RADIUS * 2;
+
+		if (curve->curve_type == GTK_CURVE_TYPE_FREE) {
+			curve->curve_type = GTK_CURVE_TYPE_LINEAR;
+			gtk_curve_interpolate(curve, width, height);
+			curve->curve_type = GTK_CURVE_TYPE_FREE;
+		} else
+			gtk_curve_interpolate(curve, width, height);
+		gtk_curve_draw(curve, width, height);
+	}
+}
+
+void gtk_curve_reset(GtkCurve * c)
+{
+	GtkCurveType old_type;
+
+	old_type = c->curve_type;
+	c->curve_type = GTK_CURVE_TYPE_SPLINE;
+	gtk_curve_reset_vector(c);
+
+	if (old_type != GTK_CURVE_TYPE_SPLINE)
+		gtk_signal_emit(GTK_OBJECT(c), curve_type_changed_signal);
+}
+
+void gtk_curve_set_gamma(GtkCurve * c, gfloat gamma)
+{
+	gfloat x, one_over_gamma, height, one_over_width;
+	GtkCurveType old_type;
+	gint i;
+
+	if (c->num_points < 2)
+		return;
+
+	old_type = c->curve_type;
+	c->curve_type = GTK_CURVE_TYPE_FREE;
+
+	if (gamma <= 0)
+		one_over_gamma = 1.0;
+	else
+		one_over_gamma = 1.0 / gamma;
+	one_over_width = 1.0 / (c->num_points - 1);
+	height = c->height;
+	for (i = 0; i < c->num_points; ++i) {
+		x = (gfloat) i / (c->num_points - 1);
+		c->point[i].x = RADIUS + i;
+		c->point[i].y = RADIUS + (height * (1.0 - pow(x, one_over_gamma)) + 0.5);
+	}
+
+	if (old_type != GTK_CURVE_TYPE_FREE)
+		gtk_signal_emit(GTK_OBJECT(c), curve_type_changed_signal);
+
+	gtk_curve_draw(c, c->num_points, c->height);
+}
+
+void gtk_curve_set_range(GtkCurve * curve, gfloat min_x, gfloat max_x, gfloat min_y, gfloat max_y)
+{
+	curve->min_x = min_x;
+	curve->max_x = max_x;
+	curve->min_y = min_y;
+	curve->max_y = max_y;
+
+	gtk_curve_size_graph(curve);
+	gtk_curve_reset_vector(curve);
+}
+
+void gtk_curve_set_vector(GtkCurve * c, int veclen, gfloat vector[])
+{
+	GtkCurveType old_type;
+	gfloat rx, dx, ry;
+	gint i, height;
+
+	old_type = c->curve_type;
+	c->curve_type = GTK_CURVE_TYPE_FREE;
+
+	if (c->point)
+		height = GTK_WIDGET(c)->allocation.height - RADIUS * 2;
+	else {
+		height = (c->max_y - c->min_y);
+		if (height > gdk_screen_height() / 4)
+			height = gdk_screen_height() / 4;
+
+		c->height = height;
+		c->num_points = veclen;
+		c->point = g_malloc(c->num_points * sizeof(c->point[0]));
+	}
+	rx = 0;
+	dx = (veclen - 1.0) / (c->num_points - 1.0);
+
+	for (i = 0; i < c->num_points; ++i, rx += dx) {
+		ry = vector[(int) (rx + 0.5)];
+		if (ry > c->max_y)
+			ry = c->max_y;
+		if (ry < c->min_y)
+			ry = c->min_y;
+		c->point[i].x = RADIUS + i;
+		c->point[i].y = RADIUS + height - project(ry, c->min_y, c->max_y, height);
+	}
+	if (old_type != GTK_CURVE_TYPE_FREE)
+		gtk_signal_emit(GTK_OBJECT(c), curve_type_changed_signal);
+
+	gtk_curve_draw(c, c->num_points, height);
+}
+
+void gtk_curve_get_vector(GtkCurve * c, int veclen, gfloat vector[])
+{
+	gfloat rx, ry, dx, dy, min_x, delta_x, *mem, *xv, *yv, *y2v, prev;
+	gint dst, i, x, next, num_active_ctlpoints = 0, first_active = -1;
+
+	min_x = c->min_x;
+
+	if (c->curve_type != GTK_CURVE_TYPE_FREE) {
+		/* count active points: */
+		prev = min_x - 1.0;
+		for (i = num_active_ctlpoints = 0; i < c->num_ctlpoints; ++i)
+			if (c->ctlpoint[i][0] > prev) {
+				if (first_active < 0)
+					first_active = i;
+				prev = c->ctlpoint[i][0];
+				++num_active_ctlpoints;
+			}
+
+		/* handle degenerate case: */
+		if (num_active_ctlpoints < 2) {
+			if (num_active_ctlpoints > 0)
+				ry = c->ctlpoint[first_active][1];
+			else
+				ry = c->min_y;
+			if (ry < c->min_y)
+				ry = c->min_y;
+			if (ry > c->max_y)
+				ry = c->max_y;
+			for (x = 0; x < veclen; ++x)
+				vector[x] = ry;
+			return;
 		}
-	      c->ctlpoint =
-		g_realloc (c->ctlpoint,
-			   c->num_ctlpoints * sizeof (*c->ctlpoint));
-	    }
 	}
-      new_type = GDK_FLEUR;
-      c->grab_point = -1;
-      break;
 
-    case GDK_MOTION_NOTIFY:
-      mevent = (GdkEventMotion *) event;
-
-      switch (c->curve_type)
-	{
-	case GTK_CURVE_TYPE_LINEAR:
+	switch (c->curve_type) {
 	case GTK_CURVE_TYPE_SPLINE:
-	  if (c->grab_point == -1)
-	    {
-	      /* if no point is grabbed...  */
-	      if (distance <= MIN_DISTANCE)
-		new_type = GDK_FLEUR;
-	      else
-		new_type = GDK_TCROSS;
-	    }
-	  else
-	    {
-	      /* drag the grabbed point  */
-	      new_type = GDK_TCROSS;
-
-	      leftbound = -MIN_DISTANCE;
-	      if (c->grab_point > 0)
-		leftbound = project (c->ctlpoint[c->grab_point - 1][0],
-				     min_x, c->max_x, width);
-
-	      rightbound = width + RADIUS * 2 + MIN_DISTANCE;
-	      if (c->grab_point + 1 < c->num_ctlpoints)
-		rightbound = project (c->ctlpoint[c->grab_point + 1][0],
-				      min_x, c->max_x, width);
+		mem = g_malloc(3 * num_active_ctlpoints * sizeof(gfloat));
+		xv = mem;
+		yv = mem + num_active_ctlpoints;
+		y2v = mem + 2 * num_active_ctlpoints;
 
-	      if (tx <= leftbound || tx >= rightbound
-		  || ty > height + RADIUS * 2 + MIN_DISTANCE
-		  || ty < -MIN_DISTANCE)
-		c->ctlpoint[c->grab_point][0] = min_x - 1.0;
-	      else
-		{
-		  rx = unproject (x, min_x, c->max_x, width);
-		  ry = unproject (height - y, c->min_y, c->max_y, height);
-		  c->ctlpoint[c->grab_point][0] = rx;
-		  c->ctlpoint[c->grab_point][1] = ry;
-		}
-	      gtk_curve_interpolate (c, width, height);
-	      gtk_curve_draw (c, width, height);
-	    }
-	  break;
+		prev = min_x - 1.0;
+		for (i = dst = 0; i < c->num_ctlpoints; ++i)
+			if (c->ctlpoint[i][0] > prev) {
+				prev = c->ctlpoint[i][0];
+				xv[dst] = c->ctlpoint[i][0];
+				yv[dst] = c->ctlpoint[i][1];
+				++dst;
+			}
 
-	case GTK_CURVE_TYPE_FREE:
-	  if (c->grab_point != -1)
-	    {
-	      if (c->grab_point > x)
-		{
-		  x1 = x;
-		  x2 = c->grab_point;
-		  y1 = y;
-		  y2 = c->last;
-		}
-	      else
-		{
-		  x1 = c->grab_point;
-		  x2 = x;
-		  y1 = c->last;
-		  y2 = y;
+		spline_solve(num_active_ctlpoints, xv, yv, y2v);
+
+		rx = min_x;
+		dx = (c->max_x - min_x) / (veclen - 1);
+		for (x = 0; x < veclen; ++x, rx += dx) {
+			ry = spline_eval(num_active_ctlpoints, xv, yv, y2v, rx);
+			if (ry < c->min_y)
+				ry = c->min_y;
+			if (ry > c->max_y)
+				ry = c->max_y;
+			vector[x] = ry;
 		}
 
-	      if (x2 != x1)
-		for (i = x1; i <= x2; i++)
-		  {
-		    c->point[i].x = RADIUS + i;
-		    c->point[i].y = RADIUS +
-		      (y1 + ((y2 - y1) * (i - x1)) / (x2 - x1));
-		  }
-	      else
-		{
-		  c->point[x].x = RADIUS + x;
-		  c->point[x].y = RADIUS + y;
-		}
-	      c->grab_point = x;
-	      c->last = y;
-	      gtk_curve_draw (c, width, height);
-	    }
-	  if (mevent->state & GDK_BUTTON1_MASK)
-	    new_type = GDK_TCROSS;
-	  else
-	    new_type = GDK_PENCIL;
-	  break;
-	}
-      if (new_type != (GdkCursorType) c->cursor_type)
-	{
-	  GdkCursor *cursor;
-
-	  c->cursor_type = new_type;
-
-	  cursor = gdk_cursor_new (c->cursor_type);
-	  gdk_window_set_cursor (w->window, cursor);
-	  gdk_cursor_destroy (cursor);
-	}
-      break;
-
-    default:
-      break;
-    }
-  return FALSE;
-}
-
-void
-gtk_curve_set_curve_type (GtkCurve *c, GtkCurveType new_type)
-{
-  gfloat rx, dx;
-  gint x, i;
-
-  if (new_type != c->curve_type)
-    {
-      gint width, height;
-
-      width  = GTK_WIDGET(c)->allocation.width - RADIUS * 2;
-      height = GTK_WIDGET(c)->allocation.height - RADIUS * 2;
-
-      if (new_type == GTK_CURVE_TYPE_FREE)
-	{
-	  gtk_curve_interpolate (c, width, height);
-	  c->curve_type = new_type;
-	}
-      else if (c->curve_type == GTK_CURVE_TYPE_FREE)
-	{
-	  if (c->ctlpoint)
-	    g_free (c->ctlpoint);
-	  c->num_ctlpoints = 9;
-	  c->ctlpoint = g_malloc (c->num_ctlpoints * sizeof (*c->ctlpoint));
-
-	  rx = 0.0;
-	  dx = (width - 1) / (gfloat) (c->num_ctlpoints - 1);
-
-	  for (i = 0; i < c->num_ctlpoints; ++i, rx += dx)
-	    {
-	      x = (int) (rx + 0.5);
-	      c->ctlpoint[i][0] =
-		unproject (x, c->min_x, c->max_x, width);
-	      c->ctlpoint[i][1] =
-		unproject (RADIUS + height - c->point[x].y,
-			   c->min_y, c->max_y, height);
-	    }
-	  c->curve_type = new_type;
-	  gtk_curve_interpolate (c, width, height);
-	}
-      else
-	{
-	  c->curve_type = new_type;
-	  gtk_curve_interpolate (c, width, height);
-	}
-      gtk_signal_emit (GTK_OBJECT (c), curve_type_changed_signal);
-      gtk_curve_draw (c, width, height);
-    }
-}
+		g_free(mem);
+		break;
 
-static void
-gtk_curve_size_graph (GtkCurve *curve)
-{
-  gint width, height;
-  gfloat aspect;
-
-  width  = (curve->max_x - curve->min_x) + 1;
-  height = (curve->max_y - curve->min_y) + 1;
-  aspect = width / (gfloat) height;
-  if (width > gdk_screen_width () / 4)
-    width  = gdk_screen_width () / 4;
-  if (height > gdk_screen_height () / 4)
-    height = gdk_screen_height () / 4;
-
-  if (aspect < 1.0)
-    width  = height * aspect;
-  else
-    height = width / aspect;
-
-  gtk_drawing_area_size (GTK_DRAWING_AREA (curve),
-			 width + RADIUS * 2, height + RADIUS * 2);
-}
+	case GTK_CURVE_TYPE_LINEAR:
+		dx = (c->max_x - min_x) / (veclen - 1);
+		rx = min_x;
+		ry = c->min_y;
+		dy = 0.0;
+		i = first_active;
+		for (x = 0; x < veclen; ++x, rx += dx) {
+			if (rx >= c->ctlpoint[i][0]) {
+				if (rx > c->ctlpoint[i][0])
+					ry = c->min_y;
+				dy = 0.0;
+				next = i + 1;
+				while (next < c->num_ctlpoints && c->ctlpoint[next][0] <= c->ctlpoint[i][0])
+					++next;
+				if (next < c->num_ctlpoints) {
+					delta_x = c->ctlpoint[next][0] - c->ctlpoint[i][0];
+					dy = ((c->ctlpoint[next][1] - c->ctlpoint[i][1])
+					      / delta_x);
+					dy *= dx;
+					ry = c->ctlpoint[i][1];
+					i = next;
+				}
+			}
+			vector[x] = ry;
+			ry += dy;
+		}
+		break;
 
-static void
-gtk_curve_reset_vector (GtkCurve *curve)
-{
-  if (curve->ctlpoint)
-    g_free (curve->ctlpoint);
-
-  curve->num_ctlpoints = 2;
-  curve->ctlpoint = g_malloc (2 * sizeof (curve->ctlpoint[0]));
-  curve->ctlpoint[0][0] = curve->min_x;
-  curve->ctlpoint[0][1] = curve->min_y;
-  curve->ctlpoint[1][0] = curve->max_x;
-  curve->ctlpoint[1][1] = curve->max_y;
-
-  if (curve->pixmap)
-    {
-      gint width, height;
-
-      width = GTK_WIDGET (curve)->allocation.width - RADIUS * 2;
-      height = GTK_WIDGET (curve)->allocation.height - RADIUS * 2;
-
-      if (curve->curve_type == GTK_CURVE_TYPE_FREE)
-	{
-	  curve->curve_type = GTK_CURVE_TYPE_LINEAR;
-	  gtk_curve_interpolate (curve, width, height);
-	  curve->curve_type = GTK_CURVE_TYPE_FREE;
+	case GTK_CURVE_TYPE_FREE:
+		if (c->point) {
+			rx = 0.0;
+			dx = c->num_points / (double) veclen;
+			for (x = 0; x < veclen; ++x, rx += dx)
+				vector[x] = unproject(RADIUS + c->height - c->point[(int) rx].y,
+						      c->min_y, c->max_y, c->height);
+		} else
+			memset(vector, 0, veclen * sizeof(vector[0]));
+		break;
 	}
-      else
-	gtk_curve_interpolate (curve, width, height);
-      gtk_curve_draw (curve, width, height);
-    }
-}
-
-void
-gtk_curve_reset (GtkCurve *c)
-{
-  GtkCurveType old_type;
-
-  old_type = c->curve_type;
-  c->curve_type = GTK_CURVE_TYPE_SPLINE;
-  gtk_curve_reset_vector (c);
-
-  if (old_type != GTK_CURVE_TYPE_SPLINE)
-    gtk_signal_emit (GTK_OBJECT (c), curve_type_changed_signal);
-}
-
-void
-gtk_curve_set_gamma (GtkCurve *c, gfloat gamma)
-{
-  gfloat x, one_over_gamma, height, one_over_width;
-  GtkCurveType old_type;
-  gint i;
-
-  if (c->num_points < 2)
-    return;
-
-  old_type = c->curve_type;
-  c->curve_type = GTK_CURVE_TYPE_FREE;
-
-  if (gamma <= 0)
-    one_over_gamma = 1.0;
-  else
-    one_over_gamma = 1.0 / gamma;
-  one_over_width = 1.0 / (c->num_points - 1);
-  height = c->height;
-  for (i = 0; i < c->num_points; ++i)
-    {
-      x = (gfloat) i / (c->num_points - 1);
-      c->point[i].x = RADIUS + i;
-      c->point[i].y =
-	RADIUS + (height * (1.0 - pow (x, one_over_gamma)) + 0.5);
-    }
-
-  if (old_type != GTK_CURVE_TYPE_FREE)
-    gtk_signal_emit (GTK_OBJECT (c), curve_type_changed_signal);
-
-  gtk_curve_draw (c, c->num_points, c->height);
 }
 
-void
-gtk_curve_set_range (GtkCurve *curve,
-		     gfloat min_x, gfloat max_x, gfloat min_y, gfloat max_y)
-{
-  curve->min_x = min_x;
-  curve->max_x = max_x;
-  curve->min_y = min_y;
-  curve->max_y = max_y;
-
-  gtk_curve_size_graph (curve);
-  gtk_curve_reset_vector (curve);
-}
-
-void
-gtk_curve_set_vector (GtkCurve *c, int veclen, gfloat vector[])
+GtkWidget *gtk_curve_new(void)
 {
-  GtkCurveType old_type;
-  gfloat rx, dx, ry;
-  gint i, height;
-
-  old_type = c->curve_type;
-  c->curve_type = GTK_CURVE_TYPE_FREE;
-
-  if (c->point)
-    height = GTK_WIDGET (c)->allocation.height - RADIUS * 2;
-  else
-    {
-      height = (c->max_y - c->min_y);
-      if (height > gdk_screen_height () / 4)
-	height = gdk_screen_height () / 4;
-
-      c->height = height;
-      c->num_points = veclen;
-      c->point = g_malloc (c->num_points * sizeof (c->point[0]));
-    }
-  rx = 0;
-  dx = (veclen - 1.0) / (c->num_points - 1.0);
-
-  for (i = 0; i < c->num_points; ++i, rx += dx)
-    {
-      ry = vector[(int) (rx + 0.5)];
-      if (ry > c->max_y) ry = c->max_y;
-      if (ry < c->min_y) ry = c->min_y;
-      c->point[i].x = RADIUS + i;
-      c->point[i].y =
-	RADIUS + height - project (ry, c->min_y, c->max_y, height);
-    }
-  if (old_type != GTK_CURVE_TYPE_FREE)
-    gtk_signal_emit (GTK_OBJECT (c), curve_type_changed_signal);
-
-  gtk_curve_draw (c, c->num_points, height);
+	return gtk_type_new(gtk_curve_get_type());
 }
 
-void
-gtk_curve_get_vector (GtkCurve *c, int veclen, gfloat vector[])
+static void gtk_curve_finalize(GtkObject * object)
 {
-  gfloat rx, ry, dx, dy, min_x, delta_x, *mem, *xv, *yv, *y2v, prev;
-  gint dst, i, x, next, num_active_ctlpoints = 0, first_active = -1;
-
-  min_x = c->min_x;
-
-  if (c->curve_type != GTK_CURVE_TYPE_FREE)
-    {
-      /* count active points: */
-      prev = min_x - 1.0;
-      for (i = num_active_ctlpoints = 0; i < c->num_ctlpoints; ++i)
-	if (c->ctlpoint[i][0] > prev)
-	  {
-	    if (first_active < 0)
-	      first_active = i;
-	    prev = c->ctlpoint[i][0];
-	    ++num_active_ctlpoints;
-	  }
+	GtkCurve *curve;
 
-      /* handle degenerate case: */
-      if (num_active_ctlpoints < 2)
-	{
-	  if (num_active_ctlpoints > 0)
-	    ry = c->ctlpoint[first_active][1];
-	  else
-	    ry = c->min_y;
-	  if (ry < c->min_y) ry = c->min_y;
-	  if (ry > c->max_y) ry = c->max_y;
-	  for (x = 0; x < veclen; ++x)
-	    vector[x] = ry;
-	  return;
-	}
-    }
-
-  switch (c->curve_type)
-    {
-    case GTK_CURVE_TYPE_SPLINE:
-      mem = g_malloc (3 * num_active_ctlpoints * sizeof (gfloat));
-      xv  = mem;
-      yv  = mem + num_active_ctlpoints;
-      y2v = mem + 2*num_active_ctlpoints;
-
-      prev = min_x - 1.0;
-      for (i = dst = 0; i < c->num_ctlpoints; ++i)
-	if (c->ctlpoint[i][0] > prev)
-	  {
-	    prev    = c->ctlpoint[i][0];
-	    xv[dst] = c->ctlpoint[i][0];
-	    yv[dst] = c->ctlpoint[i][1];
-	    ++dst;
-	  }
-
-      spline_solve (num_active_ctlpoints, xv, yv, y2v);
-
-      rx = min_x;
-      dx = (c->max_x - min_x) / (veclen - 1);
-      for (x = 0; x < veclen; ++x, rx += dx)
-	{
-	  ry = spline_eval (num_active_ctlpoints, xv, yv, y2v, rx);
-	  if (ry < c->min_y) ry = c->min_y;
-	  if (ry > c->max_y) ry = c->max_y;
-	  vector[x] = ry;
-	}
-
-      g_free (mem);
-      break;
+	g_return_if_fail(object != NULL);
+	g_return_if_fail(GTK_IS_CURVE(object));
 
-    case GTK_CURVE_TYPE_LINEAR:
-      dx = (c->max_x - min_x) / (veclen - 1);
-      rx = min_x;
-      ry = c->min_y;
-      dy = 0.0;
-      i  = first_active;
-      for (x = 0; x < veclen; ++x, rx += dx)
-	{
-	  if (rx >= c->ctlpoint[i][0])
-	    {
-	      if (rx > c->ctlpoint[i][0])
-		ry = c->min_y;
-	      dy = 0.0;
-	      next = i + 1;
-	      while (next < c->num_ctlpoints
-		     && c->ctlpoint[next][0] <= c->ctlpoint[i][0])
-		++next;
-	      if (next < c->num_ctlpoints)
-		{
-		  delta_x = c->ctlpoint[next][0] - c->ctlpoint[i][0];
-		  dy = ((c->ctlpoint[next][1] - c->ctlpoint[i][1])
-			/ delta_x);
-		  dy *= dx;
-		  ry = c->ctlpoint[i][1];
-		  i = next;
-		}
-	    }
-	  vector[x] = ry;
-	  ry += dy;
-	}
-      break;
+	curve = GTK_CURVE(object);
+	if (curve->pixmap)
+		gdk_pixmap_unref(curve->pixmap);
+	if (curve->point)
+		g_free(curve->point);
+	if (curve->ctlpoint)
+		g_free(curve->ctlpoint);
 
-    case GTK_CURVE_TYPE_FREE:
-      if (c->point)
-	{
-	  rx = 0.0;
-	  dx = c->num_points / (double) veclen;
-	  for (x = 0; x < veclen; ++x, rx += dx)
-	    vector[x] = unproject (RADIUS + c->height - c->point[(int) rx].y,
-				   c->min_y, c->max_y,
-				   c->height);
-	}
-      else
-	memset (vector, 0, veclen * sizeof (vector[0]));
-      break;
-    }
+	(*GTK_OBJECT_CLASS(parent_class)->finalize) (object);
 }
-
-GtkWidget*
-gtk_curve_new (void)
-{
-  return gtk_type_new (gtk_curve_get_type ());
-}
-
-static void
-gtk_curve_finalize (GtkObject *object)
-{
-  GtkCurve *curve;
-
-  g_return_if_fail (object != NULL);
-  g_return_if_fail (GTK_IS_CURVE (object));
-
-  curve = GTK_CURVE (object);
-  if (curve->pixmap)
-    gdk_pixmap_unref (curve->pixmap);
-  if (curve->point)
-    g_free (curve->point);
-  if (curve->ctlpoint)
-    g_free (curve->ctlpoint);
-
-  (*GTK_OBJECT_CLASS (parent_class)->finalize) (object);
-}
--- a/src/xs_fileinfo.c	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_fileinfo.c	Mon Nov 07 09:50:04 2005 +0000
@@ -30,8 +30,8 @@
 #include "xs_interface.h"
 #include "xs_glade.h"
 
-static GtkWidget		*xs_fileinfowin = NULL;
-static t_xs_stil_node		*xs_fileinfostil = NULL;
+static GtkWidget *xs_fileinfowin = NULL;
+static t_xs_stil_node *xs_fileinfostil = NULL;
 XS_MUTEX(xs_fileinfowin);
 
 #define LUW(x)	lookup_widget(xs_fileinfowin, x)
@@ -39,232 +39,218 @@
 
 void xs_fileinfo_update(void)
 {
- gboolean isEnabled;
- GtkAdjustment *tmpAdj;
- 
- XS_MUTEX_LOCK(xs_status);
- XS_MUTEX_LOCK(xs_fileinfowin);
- 
- /* Check if control window exists, we are currently playing and have a tune */
- if (xs_fileinfowin)
-	{
-	if (xs_status.tuneInfo && xs_status.isPlaying && (xs_status.tuneInfo->nsubTunes > 1))
-		{
-		tmpAdj = gtk_range_get_adjustment(GTK_RANGE(LUW("fileinfo_subctrl_adj")));
- 	
- 		tmpAdj->value = xs_status.currSong;
- 		tmpAdj->lower = 1;
-		tmpAdj->upper = xs_status.tuneInfo->nsubTunes;
-		XS_MUTEX_UNLOCK(xs_status);
-		XS_MUTEX_UNLOCK(xs_fileinfowin);
- 		gtk_adjustment_value_changed(tmpAdj);
-		XS_MUTEX_LOCK(xs_status);
-		XS_MUTEX_LOCK(xs_fileinfowin); 		
- 		isEnabled = TRUE;
- 		} else
- 		isEnabled = FALSE;
+	gboolean isEnabled;
+	GtkAdjustment *tmpAdj;
+
+	XS_MUTEX_LOCK(xs_status);
+	XS_MUTEX_LOCK(xs_fileinfowin);
+
+	/* Check if control window exists, we are currently playing and have a tune */
+	if (xs_fileinfowin) {
+		if (xs_status.tuneInfo && xs_status.isPlaying && (xs_status.tuneInfo->nsubTunes > 1)) {
+			tmpAdj = gtk_range_get_adjustment(GTK_RANGE(LUW("fileinfo_subctrl_adj")));
 
-	/* Enable or disable subtune-control in fileinfo window */
-	gtk_widget_set_sensitive(LUW("fileinfo_subctrl_prev"), isEnabled);
-	gtk_widget_set_sensitive(LUW("fileinfo_subctrl_adj"), isEnabled);
-	gtk_widget_set_sensitive(LUW("fileinfo_subctrl_next"), isEnabled); 		
- 	}
+			tmpAdj->value = xs_status.currSong;
+			tmpAdj->lower = 1;
+			tmpAdj->upper = xs_status.tuneInfo->nsubTunes;
+			XS_MUTEX_UNLOCK(xs_status);
+			XS_MUTEX_UNLOCK(xs_fileinfowin);
+			gtk_adjustment_value_changed(tmpAdj);
+			XS_MUTEX_LOCK(xs_status);
+			XS_MUTEX_LOCK(xs_fileinfowin);
+			isEnabled = TRUE;
+		} else
+			isEnabled = FALSE;
 
- XS_MUTEX_UNLOCK(xs_status);
- XS_MUTEX_UNLOCK(xs_fileinfowin);
+		/* Enable or disable subtune-control in fileinfo window */
+		gtk_widget_set_sensitive(LUW("fileinfo_subctrl_prev"), isEnabled);
+		gtk_widget_set_sensitive(LUW("fileinfo_subctrl_adj"), isEnabled);
+		gtk_widget_set_sensitive(LUW("fileinfo_subctrl_next"), isEnabled);
+	}
+
+	XS_MUTEX_UNLOCK(xs_status);
+	XS_MUTEX_UNLOCK(xs_fileinfowin);
 }
 
 
 void xs_fileinfo_setsong(void)
 {
- gint n;
- 
- XS_MUTEX_LOCK(xs_status);
- XS_MUTEX_LOCK(xs_fileinfowin);
- 
- if (xs_status.tuneInfo && xs_status.isPlaying)
- 	{
- 	n = (gint) gtk_range_get_adjustment(GTK_RANGE(LUW("fileinfo_subctrl_adj")))->value;
- 	if ((n >= 1) && (n <= xs_status.tuneInfo->nsubTunes))
- 		xs_status.currSong = n;
+	gint n;
+
+	XS_MUTEX_LOCK(xs_status);
+	XS_MUTEX_LOCK(xs_fileinfowin);
+
+	if (xs_status.tuneInfo && xs_status.isPlaying) {
+		n = (gint) gtk_range_get_adjustment(GTK_RANGE(LUW("fileinfo_subctrl_adj")))->value;
+		if ((n >= 1) && (n <= xs_status.tuneInfo->nsubTunes))
+			xs_status.currSong = n;
 	}
 
- XS_MUTEX_UNLOCK(xs_fileinfowin);
- XS_MUTEX_UNLOCK(xs_status);
+	XS_MUTEX_UNLOCK(xs_fileinfowin);
+	XS_MUTEX_UNLOCK(xs_status);
 }
 
 
 void xs_fileinfo_ok(void)
 {
- XS_MUTEX_LOCK(xs_fileinfowin);
- if (xs_fileinfowin)
- 	{
- 	gtk_widget_destroy(xs_fileinfowin);
- 	xs_fileinfowin = NULL;
- 	}
- XS_MUTEX_UNLOCK(xs_fileinfowin);
+	XS_MUTEX_LOCK(xs_fileinfowin);
+	if (xs_fileinfowin) {
+		gtk_widget_destroy(xs_fileinfowin);
+		xs_fileinfowin = NULL;
+	}
+	XS_MUTEX_UNLOCK(xs_fileinfowin);
 }
 
 
-gboolean xs_fileinfo_delete(GtkWidget *widget, GdkEvent *event, gpointer user_data)
+gboolean xs_fileinfo_delete(GtkWidget * widget, GdkEvent * event, gpointer user_data)
 {
- (void)widget; (void)event; (void)user_data;
- 
- XSDEBUG("delete_event\n");
- xs_fileinfo_ok();
- return FALSE;
+	(void) widget;
+	(void) event;
+	(void) user_data;
+
+	XSDEBUG("delete_event\n");
+	xs_fileinfo_ok();
+	return FALSE;
 }
 
 
 
-void xs_fileinfo_subtune(GtkWidget *widget, void *data)
+void xs_fileinfo_subtune(GtkWidget * widget, void *data)
 {
- t_xs_stil_subnode *tmpNode;
- GtkWidget *tmpItem, *tmpText;
- gint tmpIndex;
- gchar *subName, *subAuthor;
+	t_xs_stil_subnode *tmpNode;
+	GtkWidget *tmpItem, *tmpText;
+	gint tmpIndex;
+	gchar *subName, *subAuthor;
 
- (void)widget; (void)data;
- 
- /* Freeze text-widget and delete the old text */
- tmpText = LUW("fileinfo_sub_info");
- gtk_text_freeze(GTK_TEXT(tmpText));
- gtk_text_set_point(GTK_TEXT(tmpText), 0);
- gtk_text_forward_delete(GTK_TEXT(tmpText),
- gtk_text_get_length(GTK_TEXT(tmpText)));
+	(void) widget;
+	(void) data;
 
- if (xs_fileinfostil)
- 	{
-	/* Get subtune number */
-	tmpItem  = gtk_menu_get_active(GTK_MENU(data));
-	tmpIndex = g_list_index(GTK_MENU_SHELL(data)->children, tmpItem);
+	/* Freeze text-widget and delete the old text */
+	tmpText = LUW("fileinfo_sub_info");
+	gtk_text_freeze(GTK_TEXT(tmpText));
+	gtk_text_set_point(GTK_TEXT(tmpText), 0);
+	gtk_text_forward_delete(GTK_TEXT(tmpText), gtk_text_get_length(GTK_TEXT(tmpText)));
 
-	/* Get subtune information */
-	tmpNode = &xs_fileinfostil->subTunes[tmpIndex];
-	subName = tmpNode->pName;
-	subAuthor = tmpNode->pAuthor;
+	if (xs_fileinfostil) {
+		/* Get subtune number */
+		tmpItem = gtk_menu_get_active(GTK_MENU(data));
+		tmpIndex = g_list_index(GTK_MENU_SHELL(data)->children, tmpItem);
 
-	/* Put in the new text, if available */
-	if (tmpNode->pInfo)
-		{
-		gtk_text_insert (GTK_TEXT (tmpText), NULL, NULL, NULL,
-		tmpNode->pInfo, strlen(tmpNode->pInfo));
+		/* Get subtune information */
+		tmpNode = &xs_fileinfostil->subTunes[tmpIndex];
+		subName = tmpNode->pName;
+		subAuthor = tmpNode->pAuthor;
+
+		/* Put in the new text, if available */
+		if (tmpNode->pInfo) {
+			gtk_text_insert(GTK_TEXT(tmpText), NULL, NULL, NULL, tmpNode->pInfo, strlen(tmpNode->pInfo));
 		}
 	} else {
-	/* We don't have any information */
-	subName = NULL;
-	subAuthor = NULL;
+		/* We don't have any information */
+		subName = NULL;
+		subAuthor = NULL;
 	}
 
- /* Get and set subtune information */
- gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_sub_name")), subName ? subName : "");
- gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_sub_author")), subAuthor ? subAuthor : "");
+	/* Get and set subtune information */
+	gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_sub_name")), subName ? subName : "");
+	gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_sub_author")), subAuthor ? subAuthor : "");
 
- /* Un-freeze the widget */
- gtk_text_thaw(GTK_TEXT(tmpText));
+	/* Un-freeze the widget */
+	gtk_text_thaw(GTK_TEXT(tmpText));
 }
 
 
-void xs_fileinfo(gchar *pcFilename)
+void xs_fileinfo(gchar * pcFilename)
 {
- GtkWidget *tmpMenuItem, *tmpMenu, *tmpOptionMenu;
- t_xs_tuneinfo *tmpInfo;
- t_xs_stil_subnode *tmpNode;
- gchar tmpStr[64];
- gint n;
+	GtkWidget *tmpMenuItem, *tmpMenu, *tmpOptionMenu;
+	t_xs_tuneinfo *tmpInfo;
+	t_xs_stil_subnode *tmpNode;
+	gchar tmpStr[64];
+	gint n;
 
- /* Current implementation leaves old fileinfo window untouched if
-  * no information can be found for the new file. Hmm...
-  */
+	/* Current implementation leaves old fileinfo window untouched if
+	 * no information can be found for the new file. Hmm...
+	 */
 
- /* Get new tune information */
- XS_MUTEX_LOCK(xs_fileinfowin);
- XS_MUTEX_LOCK(xs_status);
- if ((tmpInfo = xs_status.sidPlayer->plrGetSIDInfo(pcFilename)) == NULL)
- 	{
- 	XS_MUTEX_UNLOCK(xs_fileinfowin);
- 	XS_MUTEX_UNLOCK(xs_status);
- 	return;
- 	}
- XS_MUTEX_UNLOCK(xs_status);
+	/* Get new tune information */
+	XS_MUTEX_LOCK(xs_fileinfowin);
+	XS_MUTEX_LOCK(xs_status);
+	if ((tmpInfo = xs_status.sidPlayer->plrGetSIDInfo(pcFilename)) == NULL) {
+		XS_MUTEX_UNLOCK(xs_fileinfowin);
+		XS_MUTEX_UNLOCK(xs_status);
+		return;
+	}
+	XS_MUTEX_UNLOCK(xs_status);
 
- xs_fileinfostil = xs_stil_get(pcFilename);
+	xs_fileinfostil = xs_stil_get(pcFilename);
 
- /* Check if there already is an open fileinfo window */
- if (xs_fileinfowin)
-	{
-	/* Raise old window */
-	gdk_window_raise(xs_fileinfowin->window);
+	/* Check if there already is an open fileinfo window */
+	if (xs_fileinfowin) {
+		/* Raise old window */
+		gdk_window_raise(xs_fileinfowin->window);
 
-	/* Delete items */
-	tmpOptionMenu = LUW("fileinfo_sub_tune");
-	gtk_widget_destroy(GTK_OPTION_MENU(tmpOptionMenu)->menu);
-	GTK_OPTION_MENU(tmpOptionMenu)->menu = gtk_menu_new();	
+		/* Delete items */
+		tmpOptionMenu = LUW("fileinfo_sub_tune");
+		gtk_widget_destroy(GTK_OPTION_MENU(tmpOptionMenu)->menu);
+		GTK_OPTION_MENU(tmpOptionMenu)->menu = gtk_menu_new();
 	} else {
-	/* If not, create a new one */
-	xs_fileinfowin = create_xs_fileinfowin();
-	
-	/* Connect additional signals */
-	gtk_signal_connect(GTK_OBJECT(
-		gtk_range_get_adjustment(GTK_RANGE(LUW("fileinfo_subctrl_adj")))),
-		"value_changed", GTK_SIGNAL_FUNC (xs_fileinfo_setsong), NULL);
+		/* If not, create a new one */
+		xs_fileinfowin = create_xs_fileinfowin();
+
+		/* Connect additional signals */
+		gtk_signal_connect(GTK_OBJECT(gtk_range_get_adjustment(GTK_RANGE(LUW("fileinfo_subctrl_adj")))),
+				   "value_changed", GTK_SIGNAL_FUNC(xs_fileinfo_setsong), NULL);
 	}
 
 
- /* Set the generic song information */
- gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_filename")), pcFilename);
- gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_songname")), tmpInfo->sidName);
- gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_composer")), tmpInfo->sidComposer);
- gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_copyright")), tmpInfo->sidCopyright);
+	/* Set the generic song information */
+	gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_filename")), pcFilename);
+	gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_songname")), tmpInfo->sidName);
+	gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_composer")), tmpInfo->sidComposer);
+	gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_copyright")), tmpInfo->sidCopyright);
 
 
- /* Main tune - the pseudo tune */
- tmpOptionMenu = LUW("fileinfo_sub_tune");
- tmpMenu = GTK_OPTION_MENU(tmpOptionMenu)->menu;
+	/* Main tune - the pseudo tune */
+	tmpOptionMenu = LUW("fileinfo_sub_tune");
+	tmpMenu = GTK_OPTION_MENU(tmpOptionMenu)->menu;
 
- tmpMenuItem = gtk_menu_item_new_with_label ("General info");
- gtk_widget_show (tmpMenuItem);
- gtk_menu_append (GTK_MENU(tmpMenu), tmpMenuItem);
- gtk_signal_connect (GTK_OBJECT (tmpMenuItem), "activate",
-		GTK_SIGNAL_FUNC (xs_fileinfo_subtune), tmpMenu);
+	tmpMenuItem = gtk_menu_item_new_with_label("General info");
+	gtk_widget_show(tmpMenuItem);
+	gtk_menu_append(GTK_MENU(tmpMenu), tmpMenuItem);
+	gtk_signal_connect(GTK_OBJECT(tmpMenuItem), "activate", GTK_SIGNAL_FUNC(xs_fileinfo_subtune), tmpMenu);
 
- /* Other menu items */
- for (n = 1; n <= tmpInfo->nsubTunes; n++)
-	{
-	if (xs_fileinfostil)
-		{
-		snprintf(tmpStr, sizeof(tmpStr), "Tune #%i: ", n);
-		tmpNode = &xs_fileinfostil->subTunes[n];
-		if (tmpNode->pName)
-			xs_pnstrcat(tmpStr, sizeof(tmpStr), tmpNode->pName);
+	/* Other menu items */
+	for (n = 1; n <= tmpInfo->nsubTunes; n++) {
+		if (xs_fileinfostil) {
+			snprintf(tmpStr, sizeof(tmpStr), "Tune #%i: ", n);
+			tmpNode = &xs_fileinfostil->subTunes[n];
+			if (tmpNode->pName)
+				xs_pnstrcat(tmpStr, sizeof(tmpStr), tmpNode->pName);
+			else if (tmpNode->pInfo)
+				xs_pnstrcat(tmpStr, sizeof(tmpStr), tmpNode->pInfo);
 			else
-		if (tmpNode->pInfo)
-			xs_pnstrcat(tmpStr, sizeof(tmpStr), tmpNode->pInfo);
-			else
-			xs_pnstrcat(tmpStr, sizeof(tmpStr), "---");
+				xs_pnstrcat(tmpStr, sizeof(tmpStr), "---");
 		} else {
-		snprintf(tmpStr, sizeof(tmpStr), "Tune #%i", n);
+			snprintf(tmpStr, sizeof(tmpStr), "Tune #%i", n);
 		}
 
-	tmpMenuItem = gtk_menu_item_new_with_label(tmpStr);
-	gtk_widget_show (tmpMenuItem);
-	gtk_menu_append (GTK_MENU(tmpMenu), tmpMenuItem);
+		tmpMenuItem = gtk_menu_item_new_with_label(tmpStr);
+		gtk_widget_show(tmpMenuItem);
+		gtk_menu_append(GTK_MENU(tmpMenu), tmpMenuItem);
 
-	gtk_signal_connect (GTK_OBJECT(tmpMenuItem), "activate",
-			GTK_SIGNAL_FUNC(xs_fileinfo_subtune), tmpMenu);
+		gtk_signal_connect(GTK_OBJECT(tmpMenuItem), "activate", GTK_SIGNAL_FUNC(xs_fileinfo_subtune), tmpMenu);
 	}
 
- /* Set the subtune information */
- xs_fileinfo_subtune(NULL, tmpMenu);
+	/* Set the subtune information */
+	xs_fileinfo_subtune(NULL, tmpMenu);
 
- /* Free temporary tuneinfo */
- xs_tuneinfo_free(tmpInfo);
+	/* Free temporary tuneinfo */
+	xs_tuneinfo_free(tmpInfo);
 
- /* Show the window */
- gtk_widget_show(xs_fileinfowin);
+	/* Show the window */
+	gtk_widget_show(xs_fileinfowin);
 
- XS_MUTEX_UNLOCK(xs_fileinfowin);
+	XS_MUTEX_UNLOCK(xs_fileinfowin);
 
- xs_fileinfo_update();
+	xs_fileinfo_update();
 }
-
--- a/src/xs_filter.c	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_filter.c	Mon Nov 07 09:50:04 2005 +0000
@@ -40,45 +40,45 @@
 static gint32 xs_filter_mbn = 0;
 
 
-gint xs_filter_rateconv(void *destBuf, void *srcBuf, const AFormat audioFormat, const gint oversampleFactor, const gint bufSize)
+gint xs_filter_rateconv(void *destBuf, void *srcBuf, const AFormat audioFormat, const gint oversampleFactor,
+			const gint bufSize)
 {
- static gint32 tmp;
- XS_FVAR(s,8,);
- XS_FVAR(u,8,u);
- XS_FVAR(s,16,);
- XS_FVAR(u,16,u);
- gint i;
- gint dataSize = bufSize;
- 
- if (dataSize <= 0)
- 	return dataSize;
+	static gint32 tmp;
+	XS_FVAR(s, 8,);
+	XS_FVAR(u, 8, u);
+	XS_FVAR(s, 16,);
+	XS_FVAR(u, 16, u);
+	gint i;
+	gint dataSize = bufSize;
+
+	if (dataSize <= 0)
+		return dataSize;
+
+	switch (audioFormat) {
+	case FMT_U8:
+		XS_FILTER1(u, 8, u, ^0x80)
+		    break;
 
- switch (audioFormat) {
- case FMT_U8:
- 	XS_FILTER1(u,8,u, ^ 0x80)
-	break;
-	
- case FMT_S8:
- 	XS_FILTER1(s,8,,)
- 	break;
- 	
+	case FMT_S8:
+		XS_FILTER1(s, 8,,)
+		    break;
+
+
+	case FMT_U16_BE:
+	case FMT_U16_LE:
+	case FMT_U16_NE:
+		XS_FILTER1(u, 16, u, ^0x8000)
+		    break;
 
- case FMT_U16_BE:
- case FMT_U16_LE:
- case FMT_U16_NE:
- 	XS_FILTER1(u,16,u, ^ 0x8000)
- 	break;
- 	
- case FMT_S16_BE:
- case FMT_S16_LE:
- case FMT_S16_NE:
- 	XS_FILTER1(s,16,,)
- 	break;
+	case FMT_S16_BE:
+	case FMT_S16_LE:
+	case FMT_S16_NE:
+		XS_FILTER1(s, 16,,)
+		    break;
 
- default:
- 	return -1;
- }
+	default:
+		return -1;
+	}
 
- return 0;
+	return 0;
 }
-
--- a/src/xs_genui.c	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_genui.c	Mon Nov 07 09:50:04 2005 +0000
@@ -8,27 +8,19 @@
 #include "xs_interface.h"
 #include "xs_glade.h"
 
-void
-xs_cfg_samplerate_menu_clicked         (GtkButton       *button,
-                                        gpointer         user_data)
+void xs_cfg_samplerate_menu_clicked(GtkButton * button, gpointer user_data)
 {
 
 }
 
 
-void
-xs_cfg_filter_sync_clicked             (GtkButton       *button,
-                                        gpointer         user_data)
+void xs_cfg_filter_sync_clicked(GtkButton * button, gpointer user_data)
 {
 
 }
 
 
-void
-xs_cfg_filter2_sync_clicked            (GtkButton       *button,
-                                        gpointer         user_data)
+void xs_cfg_filter2_sync_clicked(GtkButton * button, gpointer user_data)
 {
 
 }
-
-
--- a/src/xs_init.c	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_init.c	Mon Nov 07 09:50:04 2005 +0000
@@ -58,6 +58,5 @@
  */
 InputPlugin *get_iplugin_info(void)
 {
- return &xs_plugin_ip;
+	return &xs_plugin_ip;
 }
-
--- a/src/xs_length.c	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_length.c	Mon Nov 07 09:50:04 2005 +0000
@@ -33,193 +33,179 @@
  */
 static t_xs_sldb_node *xs_sldb_node_new(void)
 {
- t_xs_sldb_node *pResult;
- 
- /* Allocate memory for new node */
- pResult = (t_xs_sldb_node *) g_malloc0(sizeof(t_xs_sldb_node));
- if (!pResult) return NULL;
- 
- return pResult;
+	t_xs_sldb_node *pResult;
+
+	/* Allocate memory for new node */
+	pResult = (t_xs_sldb_node *) g_malloc0(sizeof(t_xs_sldb_node));
+	if (!pResult)
+		return NULL;
+
+	return pResult;
 }
 
 
-static void xs_sldb_node_free(t_xs_sldb_node *pNode)
+static void xs_sldb_node_free(t_xs_sldb_node * pNode)
 {
- if (pNode)
- 	{
- 	/* Nothing much to do here ... */
- 	g_free(pNode);
- 	}
+	if (pNode) {
+		/* Nothing much to do here ... */
+		g_free(pNode);
+	}
 }
 
 
 /* Insert given node to db linked list
  */
-static void xs_sldb_node_insert(t_xs_sldb *db, t_xs_sldb_node *pNode)
+static void xs_sldb_node_insert(t_xs_sldb * db, t_xs_sldb_node * pNode)
 {
- assert(db);
- 
- if (db->pNodes)
- 	{
- 	/* The first node's pPrev points to last node */
-	LPREV = db->pNodes->pPrev;		/* New node's prev = Previous last node */
-	db->pNodes->pPrev->pNext = pNode;	/* Previous last node's next = New node */
-	db->pNodes->pPrev = pNode;		/* New last node = New node */
-	LNEXT = NULL;				/* But next is NULL! */
- 	} else {
- 	db->pNodes = pNode;			/* First node ... */
- 	LPREV = pNode;				/* ... it's also last */
- 	LNEXT = NULL;				/* But next is NULL! */
- 	}
+	assert(db);
+
+	if (db->pNodes) {
+		/* The first node's pPrev points to last node */
+		LPREV = db->pNodes->pPrev;	/* New node's prev = Previous last node */
+		db->pNodes->pPrev->pNext = pNode;	/* Previous last node's next = New node */
+		db->pNodes->pPrev = pNode;	/* New last node = New node */
+		LNEXT = NULL;	/* But next is NULL! */
+	} else {
+		db->pNodes = pNode;	/* First node ... */
+		LPREV = pNode;	/* ... it's also last */
+		LNEXT = NULL;	/* But next is NULL! */
+	}
 }
 
 
 /* Parses a time-entry in SLDB format
  */
-static gint32 xs_sldb_gettime(gchar *pcStr, size_t *piPos)
+static gint32 xs_sldb_gettime(gchar * pcStr, size_t * piPos)
 {
- gint32 iResult, iTemp;
+	gint32 iResult, iTemp;
 
- /* Check if it starts with a digit */ 
- if (isdigit(pcStr[*piPos]))
-	{
-	/* Get minutes-field */
-	iResult = 0;
-	while (isdigit(pcStr[*piPos]))
-		iResult = (iResult * 10) + (pcStr[(*piPos)++] - '0');
-		
-	iResult *= 60;
+	/* Check if it starts with a digit */
+	if (isdigit(pcStr[*piPos])) {
+		/* Get minutes-field */
+		iResult = 0;
+		while (isdigit(pcStr[*piPos]))
+			iResult = (iResult * 10) + (pcStr[(*piPos)++] - '0');
+
+		iResult *= 60;
 
-	/* Check the field separator char */
-	if (pcStr[*piPos] == ':')
-		{
-		/* Get seconds-field */
-		(*piPos)++;
-		iTemp = 0;
-		while (isdigit(pcStr[*piPos]))
-			iTemp = (iTemp * 10) + (pcStr[(*piPos)++] - '0');
+		/* Check the field separator char */
+		if (pcStr[*piPos] == ':') {
+			/* Get seconds-field */
+			(*piPos)++;
+			iTemp = 0;
+			while (isdigit(pcStr[*piPos]))
+				iTemp = (iTemp * 10) + (pcStr[(*piPos)++] - '0');
 
-		iResult += iTemp;
+			iResult += iTemp;
 		} else
-		iResult = -2;
+			iResult = -2;
 	} else
-	iResult = -1;
+		iResult = -1;
 
- /* Ignore and skip the possible attributes */
- while (pcStr[*piPos] && !isspace(pcStr[*piPos])) (*piPos)++;
- 
- return iResult;
+	/* Ignore and skip the possible attributes */
+	while (pcStr[*piPos] && !isspace(pcStr[*piPos]))
+		(*piPos)++;
+
+	return iResult;
 }
 
 
 /* Read database to memory
  */
-gint xs_sldb_read(t_xs_sldb *db, gchar *dbFilename)
+gint xs_sldb_read(t_xs_sldb * db, gchar * dbFilename)
 {
- FILE *inFile;
- gchar inLine[XS_BUF_SIZE];
- size_t lineNum, linePos;
- gboolean iOK;
- t_xs_sldb_node *tmpNode;
- assert(db);
- 
- /* Try to open the file */
- if ((inFile = fopen(dbFilename, "ra")) == NULL)
- 	{
- 	XSERR("Could not open SongLengthDB '%s'\n", dbFilename);
- 	return -1;
- 	}
- 
- /* Read and parse the data */
- lineNum = 0;
+	FILE *inFile;
+	gchar inLine[XS_BUF_SIZE];
+	size_t lineNum, linePos;
+	gboolean iOK;
+	t_xs_sldb_node *tmpNode;
+	assert(db);
+
+	/* Try to open the file */
+	if ((inFile = fopen(dbFilename, "ra")) == NULL) {
+		XSERR("Could not open SongLengthDB '%s'\n", dbFilename);
+		return -1;
+	}
+
+	/* Read and parse the data */
+	lineNum = 0;
 
- while (!feof(inFile))
- {
- fgets(inLine, XS_BUF_SIZE, inFile);
- inLine[XS_BUF_SIZE-1] = 0;
- lineNum++;
-
- /* Check if it is datafield */
- if (isxdigit(inLine[0])) 
- {
- /* Check the length of the hash */
- linePos = 0;
- while (isxdigit(inLine[linePos])) linePos++;
+	while (!feof(inFile)) {
+		fgets(inLine, XS_BUF_SIZE, inFile);
+		inLine[XS_BUF_SIZE - 1] = 0;
+		lineNum++;
 
- if (linePos != XS_MD5HASH_LENGTH_CH)
-	{
-	XSERR("Invalid hash in SongLengthDB file '%s' line #%d!\n",
-	dbFilename, lineNum);
-	} else {
-	/* Allocate new node */
-	if ((tmpNode = xs_sldb_node_new()) == NULL)
-		{
-		XSERR("Error allocating new node. Fatal error.\n");
-		exit(5);
-		}
-			
-	/* Get hash value */
+		/* Check if it is datafield */
+		if (isxdigit(inLine[0])) {
+			/* Check the length of the hash */
+			linePos = 0;
+			while (isxdigit(inLine[linePos]))
+				linePos++;
+
+			if (linePos != XS_MD5HASH_LENGTH_CH) {
+				XSERR("Invalid hash in SongLengthDB file '%s' line #%d!\n", dbFilename, lineNum);
+			} else {
+				/* Allocate new node */
+				if ((tmpNode = xs_sldb_node_new()) == NULL) {
+					XSERR("Error allocating new node. Fatal error.\n");
+					exit(5);
+				}
+
+				/* Get hash value */
 #if (XS_MD5HASH_LENGTH != 16)
 #error Mismatch in hashcode length. Fix here.
 #endif
-	sscanf(&inLine[0], "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
-	(guint *) &(tmpNode->md5Hash[0]), (guint *) &(tmpNode->md5Hash[1]),
-	(guint *) &(tmpNode->md5Hash[2]), (guint *) &(tmpNode->md5Hash[3]),
-	(guint *) &(tmpNode->md5Hash[4]), (guint *) &(tmpNode->md5Hash[5]),
-	(guint *) &(tmpNode->md5Hash[6]), (guint *) &(tmpNode->md5Hash[7]),
-	(guint *) &(tmpNode->md5Hash[8]), (guint *) &(tmpNode->md5Hash[9]),
-	(guint *) &(tmpNode->md5Hash[10]), (guint *) &(tmpNode->md5Hash[11]),
-	(guint *) &(tmpNode->md5Hash[12]), (guint *) &(tmpNode->md5Hash[13]),
-	(guint *) &(tmpNode->md5Hash[14]), (guint *) &(tmpNode->md5Hash[15]));
+				sscanf(&inLine[0], "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
+				       (guint *) & (tmpNode->md5Hash[0]), (guint *) & (tmpNode->md5Hash[1]),
+				       (guint *) & (tmpNode->md5Hash[2]), (guint *) & (tmpNode->md5Hash[3]),
+				       (guint *) & (tmpNode->md5Hash[4]), (guint *) & (tmpNode->md5Hash[5]),
+				       (guint *) & (tmpNode->md5Hash[6]), (guint *) & (tmpNode->md5Hash[7]),
+				       (guint *) & (tmpNode->md5Hash[8]), (guint *) & (tmpNode->md5Hash[9]),
+				       (guint *) & (tmpNode->md5Hash[10]), (guint *) & (tmpNode->md5Hash[11]),
+				       (guint *) & (tmpNode->md5Hash[12]), (guint *) & (tmpNode->md5Hash[13]),
+				       (guint *) & (tmpNode->md5Hash[14]), (guint *) & (tmpNode->md5Hash[15]));
 
-	/* Get playtimes */
-	if (inLine[linePos] != 0)
-	{
-	if (inLine[linePos] != '=')
-		{
-		XSERR("'=' expected in SongLengthDB file '%s' line #%d, column #%d\n",
-		dbFilename, lineNum, linePos);
+				/* Get playtimes */
+				if (inLine[linePos] != 0) {
+					if (inLine[linePos] != '=') {
+						XSERR("'=' expected in SongLengthDB file '%s' line #%d, column #%d\n",
+						      dbFilename, lineNum, linePos);
 
-		xs_sldb_node_free(tmpNode);
-		} else {
-		/* First playtime is after '=' */
-		linePos++;
-		iOK = TRUE;
+						xs_sldb_node_free(tmpNode);
+					} else {
+						/* First playtime is after '=' */
+						linePos++;
+						iOK = TRUE;
 
-		while ((linePos < strlen(inLine)) && iOK)
-			{
-			xs_findnext(inLine, &linePos);
+						while ((linePos < strlen(inLine)) && iOK) {
+							xs_findnext(inLine, &linePos);
 
-			if (tmpNode->nLengths < XS_STIL_MAXENTRY)
-				{
-				tmpNode->sLengths[tmpNode->nLengths] =
-				xs_sldb_gettime(inLine, &linePos);
-				tmpNode->nLengths++;
-				} else
-				iOK = FALSE;
+							if (tmpNode->nLengths < XS_STIL_MAXENTRY) {
+								tmpNode->sLengths[tmpNode->nLengths] =
+								    xs_sldb_gettime(inLine, &linePos);
+								tmpNode->nLengths++;
+							} else
+								iOK = FALSE;
+						}
+
+						/* Add an node to db in memory */
+						if (iOK)
+							xs_sldb_node_insert(db, tmpNode);
+						else
+							xs_sldb_node_free(tmpNode);
+					}
+				}
 			}
-
-		/* Add an node to db in memory */
-		if (iOK)
-			xs_sldb_node_insert(db, tmpNode);
-			else
-			xs_sldb_node_free(tmpNode);
+		} else if ((inLine[0] != ';') && (inLine[0] != '[')) {
+			XSERR("Invalid line in SongLengthDB file '%s' line #%d\n", dbFilename, lineNum);
 		}
-	}
-	}
- } else
- if ((inLine[0] != ';') && (inLine[0] != '['))
- 	{
-	XSERR("Invalid line in SongLengthDB file '%s' line #%d\n", 
-	dbFilename, lineNum);
-	}
+
+	}			/* while */
 
- } /* while */
+	/* Close the file */
+	fclose(inFile);
 
- /* Close the file */  
- fclose(inFile);
- 
- return 0;
+	return 0;
 }
 
 
@@ -230,77 +216,71 @@
  */
 static gint xs_sldb_cmphash(t_xs_md5hash testHash1, t_xs_md5hash testHash2)
 {
- register gint i, res = 0;
-  
- /* Compute difference of hashes */
- for (i = 0; (i < XS_MD5HASH_LENGTH) && (!res); i++)
- 	res = (testHash1[i] - testHash2[i]);
+	register gint i, res = 0;
 
- return res;
+	/* Compute difference of hashes */
+	for (i = 0; (i < XS_MD5HASH_LENGTH) && (!res); i++)
+		res = (testHash1[i] - testHash2[i]);
+
+	return res;
 }
 
 
 /* Get node from db index via binary search
  */
-static t_xs_sldb_node * xs_sldb_get_node(t_xs_sldb *db, t_xs_md5hash pHash)
+static t_xs_sldb_node *xs_sldb_get_node(t_xs_sldb * db, t_xs_md5hash pHash)
 {
- gint iStartNode, iEndNode, iQNode, r, i;
- gboolean iFound;
- t_xs_sldb_node *pResult;
- 
- /* Check the database pointers */
- if (!db || !db->pNodes || !db->ppIndex)
- 	return NULL;
- 	
- /* Look-up via index using binary search */
- pResult = NULL;
- iStartNode = 0;
- iEndNode = (db->n - 1);
- iQNode = (iEndNode / 2);
- iFound = FALSE;
+	gint iStartNode, iEndNode, iQNode, r, i;
+	gboolean iFound;
+	t_xs_sldb_node *pResult;
+
+	/* Check the database pointers */
+	if (!db || !db->pNodes || !db->ppIndex)
+		return NULL;
 
- while ((!iFound) && ((iEndNode - iStartNode) > 128))
- 	{
- 	r = xs_sldb_cmphash(pHash, db->ppIndex[iQNode]->md5Hash);
- 	if (r < 0)
- 		{
- 		/* Hash was in the <- LEFT side */
- 		iEndNode = iQNode;
- 		iQNode = iStartNode + ((iEndNode - iStartNode) / 2);
- 		} else
- 	if (r > 0)
- 		{
- 		/* Hash was in the RIGHT -> side */
- 		iStartNode = iQNode;
- 		iQNode = iStartNode + ((iEndNode - iStartNode) / 2);
- 		} else
- 		iFound = TRUE;
- 	}
+	/* Look-up via index using binary search */
+	pResult = NULL;
+	iStartNode = 0;
+	iEndNode = (db->n - 1);
+	iQNode = (iEndNode / 2);
+	iFound = FALSE;
 
- /* If not found already */
- if (!iFound)
- 	{
-	/* Search the are linearly */
-	iFound = FALSE;
-	i = iStartNode;
-	while ((i <= iEndNode) && (!iFound))
-		{
-		if (xs_sldb_cmphash(pHash, db->ppIndex[i]->md5Hash) == 0)
+	while ((!iFound) && ((iEndNode - iStartNode) > 128)) {
+		r = xs_sldb_cmphash(pHash, db->ppIndex[iQNode]->md5Hash);
+		if (r < 0) {
+			/* Hash was in the <- LEFT side */
+			iEndNode = iQNode;
+			iQNode = iStartNode + ((iEndNode - iStartNode) / 2);
+		} else if (r > 0) {
+			/* Hash was in the RIGHT -> side */
+			iStartNode = iQNode;
+			iQNode = iStartNode + ((iEndNode - iStartNode) / 2);
+		} else
 			iFound = TRUE;
-			else
-			i++;
-		}
-	
-	/* Check the result */
-	if (iFound)
-		pResult = db->ppIndex[i];
-
- 	} else {
-	/* Found via binary search */
- 	pResult = db->ppIndex[iQNode];
 	}
 
- return pResult;
+	/* If not found already */
+	if (!iFound) {
+		/* Search the are linearly */
+		iFound = FALSE;
+		i = iStartNode;
+		while ((i <= iEndNode) && (!iFound)) {
+			if (xs_sldb_cmphash(pHash, db->ppIndex[i]->md5Hash) == 0)
+				iFound = TRUE;
+			else
+				i++;
+		}
+
+		/* Check the result */
+		if (iFound)
+			pResult = db->ppIndex[i];
+
+	} else {
+		/* Found via binary search */
+		pResult = db->ppIndex[iQNode];
+	}
+
+	return pResult;
 }
 
 
@@ -308,334 +288,316 @@
  */
 static gint xs_sldb_cmp(const void *pNode1, const void *pNode2)
 {
- /* We assume here that we never ever get NULL-pointers or similar */
- return xs_sldb_cmphash((*(t_xs_sldb_node **) pNode1)->md5Hash,
-                      (*(t_xs_sldb_node **) pNode2)->md5Hash);
+	/* We assume here that we never ever get NULL-pointers or similar */
+	return xs_sldb_cmphash((*(t_xs_sldb_node **) pNode1)->md5Hash, (*(t_xs_sldb_node **) pNode2)->md5Hash);
 }
 
 
 /* (Re)create index
  */
-gint xs_sldb_index(t_xs_sldb *db)
+gint xs_sldb_index(t_xs_sldb * db)
 {
- t_xs_sldb_node *pCurr;
- gint i;
- assert(db);
- 
- /* Free old index */
- if (db->ppIndex)
- 	{
- 	g_free(db->ppIndex);
- 	db->ppIndex = NULL;
- 	}
- 
- /* Get size of db */
- pCurr = db->pNodes;
- db->n = 0;
- while (pCurr)
- 	{
- 	db->n++;
- 	pCurr = pCurr->pNext;
- 	}
+	t_xs_sldb_node *pCurr;
+	gint i;
+	assert(db);
+
+	/* Free old index */
+	if (db->ppIndex) {
+		g_free(db->ppIndex);
+		db->ppIndex = NULL;
+	}
 
- /* Check number of nodes */
- if (db->n > 0)
-	{
-	/* Allocate memory for index-table */
-	db->ppIndex = (t_xs_sldb_node **) g_malloc(sizeof(t_xs_sldb_node *) * db->n);
-	if (!db->ppIndex) return -1;
+	/* Get size of db */
+	pCurr = db->pNodes;
+	db->n = 0;
+	while (pCurr) {
+		db->n++;
+		pCurr = pCurr->pNext;
+	}
 
-	/* Get node-pointers to table */
-	i = 0;
-	pCurr = db->pNodes;
-	while (pCurr && (i < db->n))
-		{
-		db->ppIndex[i++] = pCurr;
-		pCurr = pCurr->pNext;
+	/* Check number of nodes */
+	if (db->n > 0) {
+		/* Allocate memory for index-table */
+		db->ppIndex = (t_xs_sldb_node **) g_malloc(sizeof(t_xs_sldb_node *) * db->n);
+		if (!db->ppIndex)
+			return -1;
+
+		/* Get node-pointers to table */
+		i = 0;
+		pCurr = db->pNodes;
+		while (pCurr && (i < db->n)) {
+			db->ppIndex[i++] = pCurr;
+			pCurr = pCurr->pNext;
 		}
 
-	/* Sort the indexes */
-	qsort(db->ppIndex, db->n, sizeof(t_xs_sldb_node *), xs_sldb_cmp);
+		/* Sort the indexes */
+		qsort(db->ppIndex, db->n, sizeof(t_xs_sldb_node *), xs_sldb_cmp);
 	}
 
- return 0;
+	return 0;
 }
 
 
 /* Free a given song-length database
  */
-void xs_sldb_free(t_xs_sldb *db)
+void xs_sldb_free(t_xs_sldb * db)
 {
- t_xs_sldb_node *pCurr, *pNext;
- 
- if (!db) return;
- 
- /* Free the memory allocated for nodes */
- pCurr = db->pNodes;
- while (pCurr)
- 	{
- 	pNext = pCurr->pNext;
-	xs_sldb_node_free(pCurr);
- 	pCurr = pNext;
- 	}
+	t_xs_sldb_node *pCurr, *pNext;
+
+	if (!db)
+		return;
 
- db->pNodes = NULL;
- 
- /* Free memory allocated for index */
- if (db->ppIndex)
- 	{
- 	g_free(db->ppIndex);
- 	db->ppIndex = NULL;
- 	}
+	/* Free the memory allocated for nodes */
+	pCurr = db->pNodes;
+	while (pCurr) {
+		pNext = pCurr->pNext;
+		xs_sldb_node_free(pCurr);
+		pCurr = pNext;
+	}
+
+	db->pNodes = NULL;
 
- /* Free structure */
- db->n = 0;
- g_free(db);
+	/* Free memory allocated for index */
+	if (db->ppIndex) {
+		g_free(db->ppIndex);
+		db->ppIndex = NULL;
+	}
+
+	/* Free structure */
+	db->n = 0;
+	g_free(db);
 }
 
 
 /* Compute md5hash of given SID-file
  */
-typedef struct {
-	gchar	magicID[4];	/* "PSID" / "RSID" magic identifier */
-	guint16	version,	/* Version number */
-		dataOffset,	/* Start of actual c64 data in file */
-		loadAddress,	/* Loading address */
-		initAddress,	/* Initialization address */
-		playAddress,	/* Play one frame */
-		nSongs,		/* Number of subsongs */
-		startSong;	/* Default starting song */
-	guint32	speed;		/* Speed */
-	gchar	sidName[32];	/* Descriptive text-fields, ASCIIZ */
-	gchar	sidAuthor[32];
-	gchar	sidCopyright[32];
+typedef struct
+{
+	gchar magicID[4];	/* "PSID" / "RSID" magic identifier */
+	guint16 version,	/* Version number */
+	 dataOffset,		/* Start of actual c64 data in file */
+	 loadAddress,		/* Loading address */
+	 initAddress,		/* Initialization address */
+	 playAddress,		/* Play one frame */
+	 nSongs,		/* Number of subsongs */
+	 startSong;		/* Default starting song */
+	guint32 speed;		/* Speed */
+	gchar sidName[32];	/* Descriptive text-fields, ASCIIZ */
+	gchar sidAuthor[32];
+	gchar sidCopyright[32];
 } t_xs_psidv1_header;
 
 
-typedef struct {
-	guint16	flags;		/* Flags */
-	guint8	startPage,
-		pageLength;
+typedef struct
+{
+	guint16 flags;		/* Flags */
+	guint8 startPage, pageLength;
 	guint16 reserved;
 } t_xs_psidv2_header;
 
 
-static gint xs_get_sid_hash(gchar *pcFilename, t_xs_md5hash hash)
+static gint xs_get_sid_hash(gchar * pcFilename, t_xs_md5hash hash)
 {
- FILE *inFile;
- t_xs_md5state inState;
- t_xs_psidv1_header psidH;
- t_xs_psidv2_header psidH2;
+	FILE *inFile;
+	t_xs_md5state inState;
+	t_xs_psidv1_header psidH;
+	t_xs_psidv2_header psidH2;
 #ifdef XS_BUF_DYNAMIC
- guint8 *songData;
+	guint8 *songData;
 #else
- guint8 songData[XS_SIDBUF_SIZE];
+	guint8 songData[XS_SIDBUF_SIZE];
 #endif
- guint8 ib8[2], i8;
- gint iIndex, iRes;
-
- /* Try to open the file */
- if ((inFile = fopen(pcFilename, "rb")) == NULL)
- 	return -1;
+	guint8 ib8[2], i8;
+	gint iIndex, iRes;
 
- /* Read PSID header in */
- xs_rd_str(inFile, psidH.magicID, sizeof(psidH.magicID));
- if ((psidH.magicID[0] != 'P' && psidH.magicID[0] != 'R') ||
-     (psidH.magicID[1] != 'S') || (psidH.magicID[2] != 'I') || (psidH.magicID[3] != 'D'))
-     {
-     fclose(inFile);
-     return -2;
-     }
- 
- psidH.version		= xs_rd_be16(inFile);
- psidH.dataOffset	= xs_rd_be16(inFile);
- psidH.loadAddress	= xs_rd_be16(inFile);
- psidH.initAddress	= xs_rd_be16(inFile);
- psidH.playAddress	= xs_rd_be16(inFile);
- psidH.nSongs		= xs_rd_be16(inFile);
- psidH.startSong	= xs_rd_be16(inFile);
- psidH.speed		= xs_rd_be32(inFile);
+	/* Try to open the file */
+	if ((inFile = fopen(pcFilename, "rb")) == NULL)
+		return -1;
+
+	/* Read PSID header in */
+	xs_rd_str(inFile, psidH.magicID, sizeof(psidH.magicID));
+	if ((psidH.magicID[0] != 'P' && psidH.magicID[0] != 'R') ||
+	    (psidH.magicID[1] != 'S') || (psidH.magicID[2] != 'I') || (psidH.magicID[3] != 'D')) {
+		fclose(inFile);
+		return -2;
+	}
 
- xs_rd_str(inFile, psidH.sidName, sizeof(psidH.sidName));
- xs_rd_str(inFile, psidH.sidAuthor, sizeof(psidH.sidAuthor));
- xs_rd_str(inFile, psidH.sidCopyright, sizeof(psidH.sidCopyright));
- 
- /* Check if we need to load PSIDv2NG header ... */
- if (psidH.version == 2)
- 	{
- 	/* Yes, we need to */
- 	psidH2.flags		= xs_rd_be16(inFile);
- 	psidH2.startPage	= fgetc(inFile);
- 	psidH2.pageLength	= fgetc(inFile);
- 	psidH2.reserved		= xs_rd_be16(inFile);
- 	}
+	psidH.version = xs_rd_be16(inFile);
+	psidH.dataOffset = xs_rd_be16(inFile);
+	psidH.loadAddress = xs_rd_be16(inFile);
+	psidH.initAddress = xs_rd_be16(inFile);
+	psidH.playAddress = xs_rd_be16(inFile);
+	psidH.nSongs = xs_rd_be16(inFile);
+	psidH.startSong = xs_rd_be16(inFile);
+	psidH.speed = xs_rd_be32(inFile);
 
+	xs_rd_str(inFile, psidH.sidName, sizeof(psidH.sidName));
+	xs_rd_str(inFile, psidH.sidAuthor, sizeof(psidH.sidAuthor));
+	xs_rd_str(inFile, psidH.sidCopyright, sizeof(psidH.sidCopyright));
+
+	/* Check if we need to load PSIDv2NG header ... */
+	if (psidH.version == 2) {
+		/* Yes, we need to */
+		psidH2.flags = xs_rd_be16(inFile);
+		psidH2.startPage = fgetc(inFile);
+		psidH2.pageLength = fgetc(inFile);
+		psidH2.reserved = xs_rd_be16(inFile);
+	}
 #ifdef XS_BUF_DYNAMIC
- /* Allocate buffer */
- songData = (guint8 *) g_malloc(XS_SIDBUF_SIZE * sizeof(guint8));
- if (!songData)
- 	{
- 	fclose(inFile);
- 	return -3;
- 	}
+	/* Allocate buffer */
+	songData = (guint8 *) g_malloc(XS_SIDBUF_SIZE * sizeof(guint8));
+	if (!songData) {
+		fclose(inFile);
+		return -3;
+	}
 #endif
- 
- /* Read data to buffer */
- iRes = fread(songData, sizeof(guint8), XS_SIDBUF_SIZE, inFile);
- fclose(inFile);
+
+	/* Read data to buffer */
+	iRes = fread(songData, sizeof(guint8), XS_SIDBUF_SIZE, inFile);
+	fclose(inFile);
 
- /* Initialize and start MD5-hash calculation */
- xs_md5_init(&inState);
- if (psidH.loadAddress == 0)
- 	{
- 	/* Strip load address (2 first bytes) */
-	xs_md5_append(&inState, &songData[2], iRes-2);
+	/* Initialize and start MD5-hash calculation */
+	xs_md5_init(&inState);
+	if (psidH.loadAddress == 0) {
+		/* Strip load address (2 first bytes) */
+		xs_md5_append(&inState, &songData[2], iRes - 2);
 	} else {
-	/* Append "as is" */
-	xs_md5_append(&inState, songData, iRes);
+		/* Append "as is" */
+		xs_md5_append(&inState, songData, iRes);
 	}
 
 
 #ifdef XS_BUF_DYNAMIC
- /* Free buffer */
- g_free(songData);
+	/* Free buffer */
+	g_free(songData);
 #endif
 
- /* Append header data to hash */
+	/* Append header data to hash */
 #define XSADDHASH(QDATAB) { ib8[0] = (QDATAB & 0xff); ib8[1] = (QDATAB >> 8); xs_md5_append(&inState, (guint8 *) &ib8, sizeof(ib8)); }
- 
- XSADDHASH(psidH.initAddress)
- XSADDHASH(psidH.playAddress)
- XSADDHASH(psidH.nSongs)
-
-#undef XSADDHASH
 
- /* Append song speed data to hash */ 
- i8 = 0;
- for (iIndex = 0; (iIndex < psidH.nSongs) && (iIndex < 32); iIndex++)
- 	{
- 	i8 = (psidH.speed & (1 << iIndex)) ? 60 : 0;
- 	xs_md5_append(&inState, &i8, sizeof(i8));
- 	}
- 
- /* Rest of songs (more than 32) */
- for (iIndex = 32; iIndex < psidH.nSongs; iIndex++)
- 	{
- 	xs_md5_append(&inState, &i8, sizeof(i8));
- 	}
-
-
- /* PSIDv2NG specific */ 
- if (psidH.version == 2)
- 	{
- 	/* SEE SIDPLAY HEADERS FOR INFO */
- 	i8 = (psidH2.flags >> 2) & 3;
-	if (i8 == 2)
+	XSADDHASH(psidH.initAddress)
+	    XSADDHASH(psidH.playAddress)
+	    XSADDHASH(psidH.nSongs)
+#undef XSADDHASH
+	    /* Append song speed data to hash */
+	    i8 = 0;
+	for (iIndex = 0; (iIndex < psidH.nSongs) && (iIndex < 32); iIndex++) {
+		i8 = (psidH.speed & (1 << iIndex)) ? 60 : 0;
 		xs_md5_append(&inState, &i8, sizeof(i8));
 	}
 
- /* Calculate the hash */
- xs_md5_finish(&inState, hash);
- 
- return 0; 
+	/* Rest of songs (more than 32) */
+	for (iIndex = 32; iIndex < psidH.nSongs; iIndex++) {
+		xs_md5_append(&inState, &i8, sizeof(i8));
+	}
+
+
+	/* PSIDv2NG specific */
+	if (psidH.version == 2) {
+		/* SEE SIDPLAY HEADERS FOR INFO */
+		i8 = (psidH2.flags >> 2) & 3;
+		if (i8 == 2)
+			xs_md5_append(&inState, &i8, sizeof(i8));
+	}
+
+	/* Calculate the hash */
+	xs_md5_finish(&inState, hash);
+
+	return 0;
 }
 
 
 /* Get song lengths
  */
-t_xs_sldb_node * xs_sldb_get(t_xs_sldb *db, gchar *pcFilename)
+t_xs_sldb_node *xs_sldb_get(t_xs_sldb * db, gchar * pcFilename)
 {
- t_xs_sldb_node *pResult;
- t_xs_md5hash dbHash;
+	t_xs_sldb_node *pResult;
+	t_xs_md5hash dbHash;
 
- /* Get the hash and then look up from db */
- if (xs_get_sid_hash(pcFilename, dbHash) == 0)
-	pResult = xs_sldb_get_node(db, dbHash);
+	/* Get the hash and then look up from db */
+	if (xs_get_sid_hash(pcFilename, dbHash) == 0)
+		pResult = xs_sldb_get_node(db, dbHash);
 	else
-	pResult = NULL;
- 
- return pResult;
+		pResult = NULL;
+
+	return pResult;
 }
 
 
 /*
  * These should be moved out of this module some day ...
  */
-static t_xs_sldb	*xs_sldb_db = NULL;
+static t_xs_sldb *xs_sldb_db = NULL;
 XS_MUTEX(xs_sldb_db);
 
 gint xs_songlen_init(void)
 {
- XS_MUTEX_LOCK(xs_cfg);
- 
- if (!xs_cfg.songlenDBPath)
- 	{
- 	XS_MUTEX_UNLOCK(xs_cfg);
- 	return -1;
- 	}
+	XS_MUTEX_LOCK(xs_cfg);
+
+	if (!xs_cfg.songlenDBPath) {
+		XS_MUTEX_UNLOCK(xs_cfg);
+		return -1;
+	}
+
+	XS_MUTEX_LOCK(xs_sldb_db);
+
+	/* Check if already initialized */
+	if (xs_sldb_db)
+		xs_sldb_free(xs_sldb_db);
+
+	/* Allocate database */
+	xs_sldb_db = (t_xs_sldb *) g_malloc0(sizeof(t_xs_sldb));
+	if (!xs_sldb_db) {
+		XS_MUTEX_UNLOCK(xs_cfg);
+		XS_MUTEX_UNLOCK(xs_sldb_db);
+		return -2;
+	}
 
- XS_MUTEX_LOCK(xs_sldb_db);
- 
- /* Check if already initialized */
- if (xs_sldb_db) xs_sldb_free(xs_sldb_db);
- 
- /* Allocate database */
- xs_sldb_db = (t_xs_sldb *) g_malloc0(sizeof(t_xs_sldb));
- if (!xs_sldb_db)
- 	{
- 	XS_MUTEX_UNLOCK(xs_cfg);
- 	XS_MUTEX_UNLOCK(xs_sldb_db);
- 	return -2;
- 	}
- 
- /* Read the database */
- if (xs_sldb_read(xs_sldb_db, xs_cfg.songlenDBPath) != 0)
- 	{
- 	xs_sldb_free(xs_sldb_db);
- 	xs_sldb_db = NULL;
- 	XS_MUTEX_UNLOCK(xs_cfg);
- 	XS_MUTEX_UNLOCK(xs_sldb_db);
- 	return -3;
- 	}
+	/* Read the database */
+	if (xs_sldb_read(xs_sldb_db, xs_cfg.songlenDBPath) != 0) {
+		xs_sldb_free(xs_sldb_db);
+		xs_sldb_db = NULL;
+		XS_MUTEX_UNLOCK(xs_cfg);
+		XS_MUTEX_UNLOCK(xs_sldb_db);
+		return -3;
+	}
 
- /* Create index */
- if (xs_sldb_index(xs_sldb_db) != 0)
- 	{
- 	xs_sldb_free(xs_sldb_db);
- 	xs_sldb_db = NULL;
- 	XS_MUTEX_UNLOCK(xs_cfg);
- 	XS_MUTEX_UNLOCK(xs_sldb_db);
- 	return -4;
- 	}
+	/* Create index */
+	if (xs_sldb_index(xs_sldb_db) != 0) {
+		xs_sldb_free(xs_sldb_db);
+		xs_sldb_db = NULL;
+		XS_MUTEX_UNLOCK(xs_cfg);
+		XS_MUTEX_UNLOCK(xs_sldb_db);
+		return -4;
+	}
 
- XS_MUTEX_UNLOCK(xs_cfg);
- XS_MUTEX_UNLOCK(xs_sldb_db);
- return 0;
+	XS_MUTEX_UNLOCK(xs_cfg);
+	XS_MUTEX_UNLOCK(xs_sldb_db);
+	return 0;
 }
 
 
 void xs_songlen_close(void)
 {
- XS_MUTEX_LOCK(xs_sldb_db);
- xs_sldb_free(xs_sldb_db);
- xs_sldb_db = NULL;
- XS_MUTEX_UNLOCK(xs_sldb_db);
+	XS_MUTEX_LOCK(xs_sldb_db);
+	xs_sldb_free(xs_sldb_db);
+	xs_sldb_db = NULL;
+	XS_MUTEX_UNLOCK(xs_sldb_db);
 }
 
 
-t_xs_sldb_node * xs_songlen_get(gchar *pcFilename)
+t_xs_sldb_node *xs_songlen_get(gchar * pcFilename)
 {
- t_xs_sldb_node *pResult;
+	t_xs_sldb_node *pResult;
 
- XS_MUTEX_LOCK(xs_sldb_db);
+	XS_MUTEX_LOCK(xs_sldb_db);
 
- if (xs_cfg.songlenDBEnable && xs_sldb_db)
- 	pResult = xs_sldb_get(xs_sldb_db, pcFilename);
- 	else
- 	pResult = NULL;
+	if (xs_cfg.songlenDBEnable && xs_sldb_db)
+		pResult = xs_sldb_get(xs_sldb_db, pcFilename);
+	else
+		pResult = NULL;
 
- XS_MUTEX_UNLOCK(xs_sldb_db);
- 
- return pResult;
+	XS_MUTEX_UNLOCK(xs_sldb_db);
+
+	return pResult;
 }
-
--- a/src/xs_md5.c	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_md5.c	Mon Nov 07 09:50:04 2005 +0000
@@ -119,217 +119,215 @@
 
 static void xs_md5_process(t_xs_md5state * pms, const guint8 * data)
 {
- guint32 a = pms->abcd[0], b = pms->abcd[1], c = pms->abcd[2], d = pms->abcd[3];
- guint32 t;
- guint32 X[16];
- const guint8 *xp = data;
- gint i;
+	guint32 a = pms->abcd[0], b = pms->abcd[1], c = pms->abcd[2], d = pms->abcd[3];
+	guint32 t;
+	guint32 X[16];
+	const guint8 *xp = data;
+	gint i;
 
- for (i = 0; i < 16; ++i, xp += 4)
-	X[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
+	for (i = 0; i < 16; ++i, xp += 4)
+		X[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
 
 
- /*
-  * Round 1. Let [abcd k s i] denote the operation
-  * a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s).
-  */
+	/*
+	 * Round 1. Let [abcd k s i] denote the operation
+	 * a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s).
+	 */
 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
 #define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
 #define SET(a, b, c, d, k, s, Ti)\
   t = a + F(b,c,d) + X[k] + Ti;\
   a = ROTATE_LEFT(t, s) + b
 
- /* Do the following 16 operations. */
- SET(a, b, c, d, 0, 7, T1);
- SET(d, a, b, c, 1, 12, T2);
- SET(c, d, a, b, 2, 17, T3);
- SET(b, c, d, a, 3, 22, T4);
- SET(a, b, c, d, 4, 7, T5);
- SET(d, a, b, c, 5, 12, T6);
- SET(c, d, a, b, 6, 17, T7);
- SET(b, c, d, a, 7, 22, T8);
- SET(a, b, c, d, 8, 7, T9);
- SET(d, a, b, c, 9, 12, T10);
- SET(c, d, a, b, 10, 17, T11);
- SET(b, c, d, a, 11, 22, T12);
- SET(a, b, c, d, 12, 7, T13);
- SET(d, a, b, c, 13, 12, T14);
- SET(c, d, a, b, 14, 17, T15);
- SET(b, c, d, a, 15, 22, T16);
+	/* Do the following 16 operations. */
+	SET(a, b, c, d, 0, 7, T1);
+	SET(d, a, b, c, 1, 12, T2);
+	SET(c, d, a, b, 2, 17, T3);
+	SET(b, c, d, a, 3, 22, T4);
+	SET(a, b, c, d, 4, 7, T5);
+	SET(d, a, b, c, 5, 12, T6);
+	SET(c, d, a, b, 6, 17, T7);
+	SET(b, c, d, a, 7, 22, T8);
+	SET(a, b, c, d, 8, 7, T9);
+	SET(d, a, b, c, 9, 12, T10);
+	SET(c, d, a, b, 10, 17, T11);
+	SET(b, c, d, a, 11, 22, T12);
+	SET(a, b, c, d, 12, 7, T13);
+	SET(d, a, b, c, 13, 12, T14);
+	SET(c, d, a, b, 14, 17, T15);
+	SET(b, c, d, a, 15, 22, T16);
 
 #undef SET
 
- /*
-  * Round 2. Let [abcd k s i] denote the operation
-  * a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s).
-  */
+	/*
+	 * Round 2. Let [abcd k s i] denote the operation
+	 * a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s).
+	 */
 #define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
 #define SET(a, b, c, d, k, s, Ti)\
   t = a + G(b,c,d) + X[k] + Ti;\
   a = ROTATE_LEFT(t, s) + b
 
- /* Do the following 16 operations. */
- SET(a, b, c, d, 1, 5, T17);
- SET(d, a, b, c, 6, 9, T18);
- SET(c, d, a, b, 11, 14, T19);
- SET(b, c, d, a, 0, 20, T20);
- SET(a, b, c, d, 5, 5, T21);
- SET(d, a, b, c, 10, 9, T22);
- SET(c, d, a, b, 15, 14, T23);
- SET(b, c, d, a, 4, 20, T24);
- SET(a, b, c, d, 9, 5, T25);
- SET(d, a, b, c, 14, 9, T26);
- SET(c, d, a, b, 3, 14, T27);
- SET(b, c, d, a, 8, 20, T28);
- SET(a, b, c, d, 13, 5, T29);
- SET(d, a, b, c, 2, 9, T30);
- SET(c, d, a, b, 7, 14, T31);
- SET(b, c, d, a, 12, 20, T32);
+	/* Do the following 16 operations. */
+	SET(a, b, c, d, 1, 5, T17);
+	SET(d, a, b, c, 6, 9, T18);
+	SET(c, d, a, b, 11, 14, T19);
+	SET(b, c, d, a, 0, 20, T20);
+	SET(a, b, c, d, 5, 5, T21);
+	SET(d, a, b, c, 10, 9, T22);
+	SET(c, d, a, b, 15, 14, T23);
+	SET(b, c, d, a, 4, 20, T24);
+	SET(a, b, c, d, 9, 5, T25);
+	SET(d, a, b, c, 14, 9, T26);
+	SET(c, d, a, b, 3, 14, T27);
+	SET(b, c, d, a, 8, 20, T28);
+	SET(a, b, c, d, 13, 5, T29);
+	SET(d, a, b, c, 2, 9, T30);
+	SET(c, d, a, b, 7, 14, T31);
+	SET(b, c, d, a, 12, 20, T32);
 
 #undef SET
 
- /*
-  * Round 3. Let [abcd k s t] denote the operation
-  * a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s).
-  */
+	/*
+	 * Round 3. Let [abcd k s t] denote the operation
+	 * a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s).
+	 */
 #define H(x, y, z) ((x) ^ (y) ^ (z))
 #define SET(a, b, c, d, k, s, Ti)\
   t = a + H(b,c,d) + X[k] + Ti;\
   a = ROTATE_LEFT(t, s) + b
 
- /* Do the following 16 operations. */
- SET(a, b, c, d, 5, 4, T33);
- SET(d, a, b, c, 8, 11, T34);
- SET(c, d, a, b, 11, 16, T35);
- SET(b, c, d, a, 14, 23, T36);
- SET(a, b, c, d, 1, 4, T37);
- SET(d, a, b, c, 4, 11, T38);
- SET(c, d, a, b, 7, 16, T39);
- SET(b, c, d, a, 10, 23, T40);
- SET(a, b, c, d, 13, 4, T41);
- SET(d, a, b, c, 0, 11, T42);
- SET(c, d, a, b, 3, 16, T43);
- SET(b, c, d, a, 6, 23, T44);
- SET(a, b, c, d, 9, 4, T45);
- SET(d, a, b, c, 12, 11, T46);
- SET(c, d, a, b, 15, 16, T47);
- SET(b, c, d, a, 2, 23, T48);
+	/* Do the following 16 operations. */
+	SET(a, b, c, d, 5, 4, T33);
+	SET(d, a, b, c, 8, 11, T34);
+	SET(c, d, a, b, 11, 16, T35);
+	SET(b, c, d, a, 14, 23, T36);
+	SET(a, b, c, d, 1, 4, T37);
+	SET(d, a, b, c, 4, 11, T38);
+	SET(c, d, a, b, 7, 16, T39);
+	SET(b, c, d, a, 10, 23, T40);
+	SET(a, b, c, d, 13, 4, T41);
+	SET(d, a, b, c, 0, 11, T42);
+	SET(c, d, a, b, 3, 16, T43);
+	SET(b, c, d, a, 6, 23, T44);
+	SET(a, b, c, d, 9, 4, T45);
+	SET(d, a, b, c, 12, 11, T46);
+	SET(c, d, a, b, 15, 16, T47);
+	SET(b, c, d, a, 2, 23, T48);
 
 #undef SET
 
- /*
-  * Round 4. Let [abcd k s t] denote the operation
-  * a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s).
-  */
+	/*
+	 * Round 4. Let [abcd k s t] denote the operation
+	 * a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s).
+	 */
 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
 #define SET(a, b, c, d, k, s, Ti)\
   t = a + I(b,c,d) + X[k] + Ti;\
   a = ROTATE_LEFT(t, s) + b
 
- /* Do the following 16 operations. */
- SET(a, b, c, d, 0, 6, T49);
- SET(d, a, b, c, 7, 10, T50);
- SET(c, d, a, b, 14, 15, T51);
- SET(b, c, d, a, 5, 21, T52);
- SET(a, b, c, d, 12, 6, T53);
- SET(d, a, b, c, 3, 10, T54);
- SET(c, d, a, b, 10, 15, T55);
- SET(b, c, d, a, 1, 21, T56);
- SET(a, b, c, d, 8, 6, T57);
- SET(d, a, b, c, 15, 10, T58);
- SET(c, d, a, b, 6, 15, T59);
- SET(b, c, d, a, 13, 21, T60);
- SET(a, b, c, d, 4, 6, T61);
- SET(d, a, b, c, 11, 10, T62);
- SET(c, d, a, b, 2, 15, T63);
- SET(b, c, d, a, 9, 21, T64);
+	/* Do the following 16 operations. */
+	SET(a, b, c, d, 0, 6, T49);
+	SET(d, a, b, c, 7, 10, T50);
+	SET(c, d, a, b, 14, 15, T51);
+	SET(b, c, d, a, 5, 21, T52);
+	SET(a, b, c, d, 12, 6, T53);
+	SET(d, a, b, c, 3, 10, T54);
+	SET(c, d, a, b, 10, 15, T55);
+	SET(b, c, d, a, 1, 21, T56);
+	SET(a, b, c, d, 8, 6, T57);
+	SET(d, a, b, c, 15, 10, T58);
+	SET(c, d, a, b, 6, 15, T59);
+	SET(b, c, d, a, 13, 21, T60);
+	SET(a, b, c, d, 4, 6, T61);
+	SET(d, a, b, c, 11, 10, T62);
+	SET(c, d, a, b, 2, 15, T63);
+	SET(b, c, d, a, 9, 21, T64);
 
 #undef SET
 
- /*
-  * Then perform the following additions. (That is increment each
-  * of the four registers by the value it had before this block was started.)
-  */
- pms->abcd[0] += a;
- pms->abcd[1] += b;
- pms->abcd[2] += c;
- pms->abcd[3] += d;
+	/*
+	 * Then perform the following additions. (That is increment each
+	 * of the four registers by the value it had before this block was started.)
+	 */
+	pms->abcd[0] += a;
+	pms->abcd[1] += b;
+	pms->abcd[2] += c;
+	pms->abcd[3] += d;
 }
 
 
 void xs_md5_init(t_xs_md5state * pms)
 {
- pms->count[0] = pms->count[1] = 0;
- pms->abcd[0] = 0x67452301;
- pms->abcd[1] = 0xefcdab89;
- pms->abcd[2] = 0x98badcfe;
- pms->abcd[3] = 0x10325476;
+	pms->count[0] = pms->count[1] = 0;
+	pms->abcd[0] = 0x67452301;
+	pms->abcd[1] = 0xefcdab89;
+	pms->abcd[2] = 0x98badcfe;
+	pms->abcd[3] = 0x10325476;
 }
 
 
 void xs_md5_append(t_xs_md5state * pms, const guint8 * data, int nbytes)
 {
- const guint8 *p = data;
- gint left = nbytes;
- gint offset = (pms->count[0] >> 3) & 63;
- guint32 nbits = (guint32) (nbytes << 3);
-
- if (nbytes <= 0)
-	return;
+	const guint8 *p = data;
+	gint left = nbytes;
+	gint offset = (pms->count[0] >> 3) & 63;
+	guint32 nbits = (guint32) (nbytes << 3);
 
- /* Update the message length. */
- pms->count[1] += nbytes >> 29;
- pms->count[0] += nbits;
- if (pms->count[0] < nbits)
-	pms->count[1]++;
-
- /* Process an initial partial block. */
- if (offset)
- 	{
-	int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
-
-	memcpy(pms->buf + offset, p, copy);
-
-	if (offset + copy < 64)
+	if (nbytes <= 0)
 		return;
 
-	p += copy;
-	left -= copy;
-	xs_md5_process(pms, pms->buf);
+	/* Update the message length. */
+	pms->count[1] += nbytes >> 29;
+	pms->count[0] += nbits;
+	if (pms->count[0] < nbits)
+		pms->count[1]++;
+
+	/* Process an initial partial block. */
+	if (offset) {
+		int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
+
+		memcpy(pms->buf + offset, p, copy);
+
+		if (offset + copy < 64)
+			return;
+
+		p += copy;
+		left -= copy;
+		xs_md5_process(pms, pms->buf);
 	}
 
- /* Process full blocks. */
- for (; left >= 64; p += 64, left -= 64)
-	xs_md5_process(pms, p);
+	/* Process full blocks. */
+	for (; left >= 64; p += 64, left -= 64)
+		xs_md5_process(pms, p);
 
- /* Process a final partial block. */
- if (left)
-	memcpy(pms->buf, p, left);
+	/* Process a final partial block. */
+	if (left)
+		memcpy(pms->buf, p, left);
 }
 
 
 void xs_md5_finish(t_xs_md5state * pms, t_xs_md5hash digest)
 {
- static const guint8 pad[64] = {
-	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
- };
+	static const guint8 pad[64] = {
+		0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+	};
 
- guint8 data[8];
- gint i;
+	guint8 data[8];
+	gint i;
 
- /* Save the length before padding. */
- for (i = 0; i < 8; ++i)
-	data[i] = (guint8) (pms->count[i >> 2] >> ((i & 3) << 3));
-
- /* Pad to 56 bytes mod 64. */
- xs_md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
+	/* Save the length before padding. */
+	for (i = 0; i < 8; ++i)
+		data[i] = (guint8) (pms->count[i >> 2] >> ((i & 3) << 3));
 
- /* Append the length. */
- xs_md5_append(pms, data, 8);
- for (i = 0; i < XS_MD5HASH_LENGTH; ++i)
-	digest[i] = (guint8) (pms->abcd[i >> 2] >> ((i & 3) << 3));
+	/* Pad to 56 bytes mod 64. */
+	xs_md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
+
+	/* Append the length. */
+	xs_md5_append(pms, data, 8);
+	for (i = 0; i < XS_MD5HASH_LENGTH; ++i)
+		digest[i] = (guint8) (pms->abcd[i >> 2] >> ((i & 3) << 3));
 }
-
--- a/src/xs_sidplay.h	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_sidplay.h	Mon Nov 07 09:50:04 2005 +0000
@@ -3,73 +3,68 @@
  * Get all SID-tune information (for all sub-tunes)
  * including name, length, etc.
  */
-t_xs_tuneinfo * TFUNCTION(gchar *pcFilename)
+t_xs_tuneinfo *TFUNCTION(gchar * pcFilename)
 {
- t_xs_sldb_node *tuneLength = NULL;
- t_xs_tuneinfo *pResult;
- TTUNEINFO tuneInfo;
- TTUNE *testTune;
- gboolean haveInfo = TRUE;
- gint i;
+	t_xs_sldb_node *tuneLength = NULL;
+	t_xs_tuneinfo *pResult;
+	TTUNEINFO tuneInfo;
+	TTUNE *testTune;
+	gboolean haveInfo = TRUE;
+	gint i;
 
- /* Check if the tune exists and is readable */
- if ((testTune = new TTUNE(pcFilename)) == NULL)
-	return NULL;
+	/* Check if the tune exists and is readable */
+	if ((testTune = new TTUNE(pcFilename)) == NULL)
+		return NULL;
 
- if (!testTune->getStatus())
-	{
-	delete testTune;
-	return NULL;
+	if (!testTune->getStatus()) {
+		delete testTune;
+		return NULL;
 	}
 
- /* Get general tune information */
+	/* Get general tune information */
 #ifdef _XS_SIDPLAY1_H
- haveInfo = testTune->getInfo(tuneInfo);
+	haveInfo = testTune->getInfo(tuneInfo);
 #endif
 #ifdef _XS_SIDPLAY2_H
- testTune->getInfo(tuneInfo);
- haveInfo = TRUE;
+	testTune->getInfo(tuneInfo);
+	haveInfo = TRUE;
 #endif
 
- /* Get length information (NOTE: Do not free this!) */
- tuneLength = xs_songlen_get(pcFilename);
+	/* Get length information (NOTE: Do not free this!) */
+	tuneLength = xs_songlen_get(pcFilename);
 
- /* Allocate tuneinfo structure */
- pResult = xs_tuneinfo_new(pcFilename,
- 	tuneInfo.songs, tuneInfo.startSong,
- 	tuneInfo.infoString[0], tuneInfo.infoString[1], tuneInfo.infoString[2],
- 	tuneInfo.loadAddr, tuneInfo.initAddr, tuneInfo.playAddr,
- 	tuneInfo.dataFileLen);
+	/* Allocate tuneinfo structure */
+	pResult = xs_tuneinfo_new(pcFilename,
+				  tuneInfo.songs, tuneInfo.startSong,
+				  tuneInfo.infoString[0], tuneInfo.infoString[1], tuneInfo.infoString[2],
+				  tuneInfo.loadAddr, tuneInfo.initAddr, tuneInfo.playAddr, tuneInfo.dataFileLen);
 
- if (!pResult)
- 	{
- 	delete testTune;
-	return NULL;
+	if (!pResult) {
+		delete testTune;
+		return NULL;
 	}
 
- /* Get information for subtunes */
- for (i = 0; i < pResult->nsubTunes; i++)
-	{
-	/* Make the title */
-	if (haveInfo)
-		{
-		pResult->subTunes[i].tuneTitle =
-		xs_make_titlestring(pcFilename, i+1, tuneInfo.sidModel,
-		tuneInfo.formatString, tuneInfo.infoString[0],
-		tuneInfo.infoString[1], tuneInfo.infoString[2]);
+	/* Get information for subtunes */
+	for (i = 0; i < pResult->nsubTunes; i++) {
+		/* Make the title */
+		if (haveInfo) {
+			pResult->subTunes[i].tuneTitle =
+			    xs_make_titlestring(pcFilename, i + 1, tuneInfo.sidModel,
+						tuneInfo.formatString, tuneInfo.infoString[0],
+						tuneInfo.infoString[1], tuneInfo.infoString[2]);
 		} else
-		pResult->subTunes[i].tuneTitle = g_strdup(pcFilename);
+			pResult->subTunes[i].tuneTitle = g_strdup(pcFilename);
 
-	/* Get song length */
-	if (tuneLength && (i < tuneLength->nLengths))
-		pResult->subTunes[i].tuneLength = tuneLength->sLengths[i];
+		/* Get song length */
+		if (tuneLength && (i < tuneLength->nLengths))
+			pResult->subTunes[i].tuneLength = tuneLength->sLengths[i];
 		else
-		pResult->subTunes[i].tuneLength = -1;
+			pResult->subTunes[i].tuneLength = -1;
 	}
 
- delete testTune;
+	delete testTune;
 
- return pResult;
+	return pResult;
 }
 
 /* Undefine these */
--- a/src/xs_sidplay1.cc	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_sidplay1.cc	Mon Nov 07 09:50:04 2005 +0000
@@ -37,310 +37,303 @@
 /* Maximum audio frequency supported by libSIDPlay v1 */
 #define SIDPLAY1_MAX_FREQ	(48000)
 
-typedef struct {
-	emuEngine	*currEng;
-	emuConfig	currConfig;
-	sidTune		*currTune;
+typedef struct
+{
+	emuEngine *currEng;
+	emuConfig currConfig;
+	sidTune *currTune;
 } t_xs_sidplay1;
 
 
 /* We need to 'export' all this pseudo-C++ crap */
-extern "C" {
+extern "C"
+{
 
 
 /* Check if we can play the given file
  */
-gboolean xs_sidplay1_isourfile(gchar *pcFilename)
-{
- sidTune *testTune = new sidTune(pcFilename);
-
- if (!testTune) return FALSE;
- if (!testTune->getStatus())
+	gboolean xs_sidplay1_isourfile(gchar * pcFilename)
 	{
-	delete testTune;
-	return FALSE;
-	}
+		sidTune *testTune = new sidTune(pcFilename);
 
- delete testTune;
- return TRUE;
-}
+		if (!testTune)
+			 return FALSE;
+		if (!testTune->getStatus())
+		{
+			delete testTune;
+			 return FALSE;
+		}
+
+		delete testTune;
+		return TRUE;
+	}
 
 
 /* Initialize SIDPlay1
  */
-gboolean xs_sidplay1_init(t_xs_status *myStatus)
-{
- gint tmpFreq;
- t_xs_sidplay1 *myEngine;
- assert(myStatus);
-
- /* Allocate internal structures */
- myEngine = (t_xs_sidplay1 *) g_malloc0(sizeof(t_xs_sidplay1));
- if (!myEngine) return FALSE;
-
- /* Initialize engine */
- myEngine->currEng = new emuEngine();
- if (!myEngine->currEng)
+	gboolean xs_sidplay1_init(t_xs_status * myStatus)
 	{
-	XSERR("Could not initialize libSIDPlay1 emulation engine\n");
-	g_free(myEngine);
-	return FALSE;
-	}
+		gint tmpFreq;
+		t_xs_sidplay1 *myEngine;
+		assert(myStatus);
+
+		/* Allocate internal structures */
+		myEngine = (t_xs_sidplay1 *) g_malloc0(sizeof(t_xs_sidplay1));
+		if (!myEngine)
+			return FALSE;
 
- /* Verify endianess */
- if (!myEngine->currEng->verifyEndianess())
-	{
-	XSERR("Endianess verification failed\n");
-	delete myEngine->currEng;
-	g_free(myEngine);
-	return FALSE;
-	}
+		/* Initialize engine */
+		myEngine->currEng = new emuEngine();
+		if (!myEngine->currEng) {
+			XSERR("Could not initialize libSIDPlay1 emulation engine\n");
+			g_free(myEngine);
+			return FALSE;
+		}
+
+		/* Verify endianess */
+		if (!myEngine->currEng->verifyEndianess()) {
+			XSERR("Endianess verification failed\n");
+			delete myEngine->currEng;
+			g_free(myEngine);
+			return FALSE;
+		}
 
- myStatus->sidEngine = myEngine;
+		myStatus->sidEngine = myEngine;
 
- /* Get current configuration */
- myEngine->currEng->getConfig(myEngine->currConfig);
+		/* Get current configuration */
+		myEngine->currEng->getConfig(myEngine->currConfig);
 
- /* Configure channel parameters */
- switch (myStatus->audioChannels) {
+		/* Configure channel parameters */
+		switch (myStatus->audioChannels) {
 
-	case XS_CHN_AUTOPAN:
-		myEngine->currConfig.channels = SIDEMU_STEREO;
-		myEngine->currConfig.autoPanning = SIDEMU_CENTEREDAUTOPANNING;
-		myEngine->currConfig.volumeControl = SIDEMU_FULLPANNING;
-		break;
+		case XS_CHN_AUTOPAN:
+			myEngine->currConfig.channels = SIDEMU_STEREO;
+			myEngine->currConfig.autoPanning = SIDEMU_CENTEREDAUTOPANNING;
+			myEngine->currConfig.volumeControl = SIDEMU_FULLPANNING;
+			break;
 
-	case XS_CHN_STEREO:
-		myEngine->currConfig.channels = SIDEMU_STEREO;
-		myEngine->currConfig.autoPanning = SIDEMU_NONE;
-		myEngine->currConfig.volumeControl = SIDEMU_NONE;
-		break;
+		case XS_CHN_STEREO:
+			myEngine->currConfig.channels = SIDEMU_STEREO;
+			myEngine->currConfig.autoPanning = SIDEMU_NONE;
+			myEngine->currConfig.volumeControl = SIDEMU_NONE;
+			break;
 
-	case XS_CHN_MONO:
-	default:
-		myEngine->currConfig.channels = SIDEMU_MONO;
-		myEngine->currConfig.autoPanning = SIDEMU_NONE;
-		myEngine->currConfig.volumeControl = SIDEMU_NONE;
-		myStatus->audioChannels = XS_CHN_MONO;
-		break;
- }
+		case XS_CHN_MONO:
+		default:
+			myEngine->currConfig.channels = SIDEMU_MONO;
+			myEngine->currConfig.autoPanning = SIDEMU_NONE;
+			myEngine->currConfig.volumeControl = SIDEMU_NONE;
+			myStatus->audioChannels = XS_CHN_MONO;
+			break;
+		}
 
 
- /* Memory mode settings */
- switch (xs_cfg.memoryMode) {
-	case XS_MPU_TRANSPARENT_ROM:
-		myEngine->currConfig.memoryMode = MPU_TRANSPARENT_ROM;
-		break;
+		/* Memory mode settings */
+		switch (xs_cfg.memoryMode) {
+		case XS_MPU_TRANSPARENT_ROM:
+			myEngine->currConfig.memoryMode = MPU_TRANSPARENT_ROM;
+			break;
 
-	case XS_MPU_PLAYSID_ENVIRONMENT:
-		myEngine->currConfig.memoryMode = MPU_PLAYSID_ENVIRONMENT;
-		break;
+		case XS_MPU_PLAYSID_ENVIRONMENT:
+			myEngine->currConfig.memoryMode = MPU_PLAYSID_ENVIRONMENT;
+			break;
 
-	case XS_MPU_BANK_SWITCHING:
-	default:
-		myEngine->currConfig.memoryMode = MPU_BANK_SWITCHING;
-		xs_cfg.memoryMode = XS_MPU_BANK_SWITCHING;
-		break;
- }
+		case XS_MPU_BANK_SWITCHING:
+		default:
+			myEngine->currConfig.memoryMode = MPU_BANK_SWITCHING;
+			xs_cfg.memoryMode = XS_MPU_BANK_SWITCHING;
+			break;
+		}
 
 
- /* Clockspeed settings */
- switch (xs_cfg.clockSpeed) {
-	case XS_CLOCK_NTSC:
-		myEngine->currConfig.clockSpeed = SIDTUNE_CLOCK_NTSC;
-		break;
+		/* Clockspeed settings */
+		switch (xs_cfg.clockSpeed) {
+		case XS_CLOCK_NTSC:
+			myEngine->currConfig.clockSpeed = SIDTUNE_CLOCK_NTSC;
+			break;
 
-	case XS_CLOCK_PAL:
-	default:
-		myEngine->currConfig.clockSpeed = SIDTUNE_CLOCK_PAL;
-		xs_cfg.clockSpeed = XS_CLOCK_PAL;
-		break;
- }
+		case XS_CLOCK_PAL:
+		default:
+			myEngine->currConfig.clockSpeed = SIDTUNE_CLOCK_PAL;
+			xs_cfg.clockSpeed = XS_CLOCK_PAL;
+			break;
+		}
 
 
- /* Configure rest of the emulation */
- myEngine->currConfig.mos8580		= xs_cfg.mos8580;
- myEngine->currConfig.emulateFilter	= xs_cfg.emulateFilters;
- myEngine->currConfig.filterFs		= xs_cfg.filterFs;
- myEngine->currConfig.filterFm		= xs_cfg.filterFm;
- myEngine->currConfig.filterFt		= xs_cfg.filterFt;
+		/* Configure rest of the emulation */
+		myEngine->currConfig.mos8580 = xs_cfg.mos8580;
+		myEngine->currConfig.emulateFilter = xs_cfg.emulateFilters;
+		myEngine->currConfig.filterFs = xs_cfg.filterFs;
+		myEngine->currConfig.filterFm = xs_cfg.filterFm;
+		myEngine->currConfig.filterFt = xs_cfg.filterFt;
 
 
- /* Audio parameters sanity checking and setup */
- myEngine->currConfig.bitsPerSample = myStatus->audioBitsPerSample;
- tmpFreq = myStatus->audioFrequency;
+		/* Audio parameters sanity checking and setup */
+		myEngine->currConfig.bitsPerSample = myStatus->audioBitsPerSample;
+		tmpFreq = myStatus->audioFrequency;
 
- if (myStatus->oversampleEnable)
-	{
-	if ((tmpFreq * myStatus->oversampleFactor) > SIDPLAY1_MAX_FREQ)
-		{
-		myStatus->oversampleEnable = FALSE;
+		if (myStatus->oversampleEnable) {
+			if ((tmpFreq * myStatus->oversampleFactor) > SIDPLAY1_MAX_FREQ) {
+				myStatus->oversampleEnable = FALSE;
+			} else {
+				tmpFreq = (tmpFreq * myStatus->oversampleFactor);
+			}
 		} else {
-		tmpFreq = (tmpFreq * myStatus->oversampleFactor);
+			if (tmpFreq > SIDPLAY1_MAX_FREQ)
+				tmpFreq = SIDPLAY1_MAX_FREQ;
 		}
-	} else {
-	if (tmpFreq > SIDPLAY1_MAX_FREQ)
-		tmpFreq = SIDPLAY1_MAX_FREQ;
-	}
+
+		myEngine->currConfig.frequency = tmpFreq;
 
- myEngine->currConfig.frequency = tmpFreq;
+		switch (myStatus->audioBitsPerSample) {
+		case XS_RES_8BIT:
+			switch (myStatus->audioFormat) {
+			case FMT_S8:
+				myStatus->audioFormat = FMT_S8;
+				myEngine->currConfig.sampleFormat = SIDEMU_SIGNED_PCM;
+				break;
+
+			case FMT_U8:
+			default:
+				myStatus->audioFormat = FMT_U8;
+				myEngine->currConfig.sampleFormat = SIDEMU_UNSIGNED_PCM;
+				break;
+			}
+			break;
 
- switch (myStatus->audioBitsPerSample) {
- case XS_RES_8BIT:
-	switch (myStatus->audioFormat) {
-	case FMT_S8:
-		myStatus->audioFormat			= FMT_S8;
-		myEngine->currConfig.sampleFormat	= SIDEMU_SIGNED_PCM;
-		break;
+		case XS_RES_16BIT:
+		default:
+			switch (myStatus->audioFormat) {
+			case FMT_U16_NE:
+			case FMT_U16_LE:
+			case FMT_U16_BE:
+				myStatus->audioFormat = FMT_U16_NE;
+				myEngine->currConfig.sampleFormat = SIDEMU_UNSIGNED_PCM;
+				break;
 
-	case FMT_U8:
-	default:
-		myStatus->audioFormat			= FMT_U8;
-		myEngine->currConfig.sampleFormat	= SIDEMU_UNSIGNED_PCM;
-		break;
+			case FMT_S16_NE:
+			case FMT_S16_LE:
+			case FMT_S16_BE:
+			default:
+				myStatus->audioFormat = FMT_S16_NE;
+				myEngine->currConfig.sampleFormat = SIDEMU_SIGNED_PCM;
+				break;
+			}
+			break;
+		}
+
+		/* Now set the emulator configuration */
+		if (!myEngine->currEng->setConfig(myEngine->currConfig)) {
+			XSERR("Emulator engine configuration failed!\n");
+			return FALSE;
+		}
+
+		return TRUE;
 	}
-	break;
-
- case XS_RES_16BIT:
- default:
-	switch (myStatus->audioFormat) {
-	case FMT_U16_NE:
-	case FMT_U16_LE:
-	case FMT_U16_BE:
-		myStatus->audioFormat			= FMT_U16_NE;
-		myEngine->currConfig.sampleFormat       = SIDEMU_UNSIGNED_PCM;
-		break;
-
-	case FMT_S16_NE:
-	case FMT_S16_LE:
-	case FMT_S16_BE:
-	default:
-		myStatus->audioFormat			= FMT_S16_NE;
-		myEngine->currConfig.sampleFormat       = SIDEMU_SIGNED_PCM;
-		break;
-	}
-	break;
- }
-
- /* Now set the emulator configuration */
- if (!myEngine->currEng->setConfig(myEngine->currConfig))
-	{
-	XSERR("Emulator engine configuration failed!\n");
-	return FALSE;
-	}
-
- return TRUE;
-}
 
 
 /* Close SIDPlay1 engine
  */
-void xs_sidplay1_close(t_xs_status *myStatus)
-{
- t_xs_sidplay1 *myEngine;
- assert(myStatus);
+	void xs_sidplay1_close(t_xs_status * myStatus)
+	{
+		t_xs_sidplay1 *myEngine;
+		assert(myStatus);
 
- myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;
+		myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;
 
- /* Free internals */
- if (myEngine->currEng)
-	{
-	delete myEngine->currEng;
-	myEngine->currEng = NULL;	
+		/* Free internals */
+		if (myEngine->currEng) {
+			delete myEngine->currEng;
+			myEngine->currEng = NULL;
+		}
+
+		g_free(myEngine);
+		myStatus->sidEngine = NULL;
 	}
 
- g_free(myEngine);
- myStatus->sidEngine = NULL;
-}
-
 
 /* Initialize current song and sub-tune
  */
-gboolean xs_sidplay1_initsong(t_xs_status *myStatus)
-{
- t_xs_sidplay1 *myEngine;
- assert(myStatus);
+	gboolean xs_sidplay1_initsong(t_xs_status * myStatus)
+	{
+		t_xs_sidplay1 *myEngine;
+		assert(myStatus);
+
+		myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;
+		if (!myEngine)
+			return FALSE;
 
- myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;
- if (!myEngine) return FALSE;
+		if (!myEngine->currTune) {
+			XSERR("Tune was NULL\n");
+			return FALSE;
+		}
 
- if (!myEngine->currTune)
-	{
-	XSERR("Tune was NULL\n");
-	return FALSE;
+		if (!myEngine->currTune->getStatus()) {
+			XSERR("Tune status check failed\n");
+			return FALSE;
+		}
+
+		return sidEmuInitializeSong(*myEngine->currEng, *myEngine->currTune, myStatus->currSong);
 	}
 
- if (!myEngine->currTune->getStatus())
-	{
-	XSERR("Tune status check failed\n");
-	return FALSE;
-	}
-
- return sidEmuInitializeSong(
-	*myEngine->currEng,
-	*myEngine->currTune,
-	myStatus->currSong);
-}
-
 
 /* Emulate and render audio data to given buffer
  */
-guint xs_sidplay1_fillbuffer(t_xs_status *myStatus, gchar *audioBuffer, guint audioBufSize)
-{
- t_xs_sidplay1 *myEngine;
- assert(myStatus);
-
- myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;
- if (!myEngine) return 0;
+	guint xs_sidplay1_fillbuffer(t_xs_status * myStatus, gchar * audioBuffer, guint audioBufSize)
+	{
+		t_xs_sidplay1 *myEngine;
+		assert(myStatus);
 
- sidEmuFillBuffer(
-	*myEngine->currEng,
-	*myEngine->currTune,
-	audioBuffer,
-	audioBufSize);
+		myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;
+		if (!myEngine)
+			return 0;
 
- return audioBufSize;
-}
+		sidEmuFillBuffer(*myEngine->currEng, *myEngine->currTune, audioBuffer, audioBufSize);
+
+		return audioBufSize;
+	}
 
 
 /* Load a given SID-tune file
  */
-gboolean xs_sidplay1_loadsid(t_xs_status *myStatus, gchar *pcFilename)
-{
- t_xs_sidplay1 *myEngine;
- sidTune *newTune;
- assert(myStatus);
+	gboolean xs_sidplay1_loadsid(t_xs_status * myStatus, gchar * pcFilename)
+	{
+		t_xs_sidplay1 *myEngine;
+		sidTune *newTune;
+		assert(myStatus);
 
- myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;
+		myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;
 
- /* Try to get the tune */
- if (!pcFilename) return FALSE;
+		/* Try to get the tune */
+		if (!pcFilename)
+			return FALSE;
 
- newTune = new sidTune(pcFilename);
- if (!newTune) return FALSE;
+		newTune = new sidTune(pcFilename);
+		if (!newTune)
+			return FALSE;
 
- myEngine->currTune = newTune;
+		myEngine->currTune = newTune;
 
- return TRUE;
-}
+		return TRUE;
+	}
 
 
 /* Delete INTERNAL information
  */
-void xs_sidplay1_deletesid(t_xs_status *myStatus)
-{
- t_xs_sidplay1 *myEngine;
- assert(myStatus);
+	void xs_sidplay1_deletesid(t_xs_status * myStatus)
+	{
+		t_xs_sidplay1 *myEngine;
+		assert(myStatus);
 
- myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;
- if (!myEngine) return;
+		myEngine = (t_xs_sidplay1 *) myStatus->sidEngine;
+		if (!myEngine)
+			return;
 
- if (myEngine->currTune)
-	{
-	delete myEngine->currTune;
-	myEngine->currTune = NULL;
+		if (myEngine->currTune) {
+			delete myEngine->currTune;
+			myEngine->currTune = NULL;
+		}
 	}
-}
 
 
 /* Return song information
@@ -350,5 +343,5 @@
 #define TTUNE		sidTune
 #include "xs_sidplay.h"
 
-}	/* extern "C" */
-#endif	/* HAVE_SIDPLAY1 */
+}				/* extern "C" */
+#endif				/* HAVE_SIDPLAY1 */
--- a/src/xs_sidplay2.cc	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_sidplay2.cc	Mon Nov 07 09:50:04 2005 +0000
@@ -40,378 +40,367 @@
 #endif
 
 
-typedef struct {
-	sidplay2	*currEng;
-	sidbuilder	*currBuilder;
-	sid2_config_t	currConfig;
-	SidTune		*currTune;
+typedef struct
+{
+	sidplay2 *currEng;
+	sidbuilder *currBuilder;
+	sid2_config_t currConfig;
+	SidTune *currTune;
 } t_xs_sidplay2;
 
 
 /* We need to 'export' all this pseudo-C++ crap */
-extern "C" {
+extern "C"
+{
 
 
 /* Check if we can play the given file
  */
-gboolean xs_sidplay2_isourfile(gchar *pcFilename)
-{
- SidTune *testTune = new SidTune(pcFilename);
-
- if (!testTune) return FALSE;
- if (!testTune->getStatus())
+	gboolean xs_sidplay2_isourfile(gchar * pcFilename)
 	{
-	delete testTune;
-	return FALSE;
-	}
+		SidTune *testTune = new SidTune(pcFilename);
 
- delete testTune;
- return TRUE;
-}
+		if (!testTune)
+			 return FALSE;
+		if (!testTune->getStatus())
+		{
+			delete testTune;
+			 return FALSE;
+		}
+
+		delete testTune;
+		return TRUE;
+	}
 
 
 
 /* Initialize SIDPlay2
  */
-gboolean xs_sidplay2_init(t_xs_status *myStatus)
-{
- gint tmpFreq;
- t_xs_sidplay2 *myEngine;
- assert(myStatus);
+	gboolean xs_sidplay2_init(t_xs_status * myStatus)
+	{
+		gint tmpFreq;
+		t_xs_sidplay2 *myEngine;
+		assert(myStatus);
 
- /* Allocate internal structures */
- myEngine = (t_xs_sidplay2 *) g_malloc0(sizeof(t_xs_sidplay2));
- myStatus->sidEngine = myEngine;
- if (!myEngine) return FALSE;
+		/* Allocate internal structures */
+		myEngine = (t_xs_sidplay2 *) g_malloc0(sizeof(t_xs_sidplay2));
+		myStatus->sidEngine = myEngine;
+		if (!myEngine)
+			return FALSE;
 
 
- /* Initialize the engine */
- myEngine->currEng = new sidplay2;
- if (!myEngine->currEng)
-	{
-	XSERR("Could not initialize libSIDPlay2 emulation engine\n");
-	return FALSE;
-	}
+		/* Initialize the engine */
+		myEngine->currEng = new sidplay2;
+		if (!myEngine->currEng) {
+			XSERR("Could not initialize libSIDPlay2 emulation engine\n");
+			return FALSE;
+		}
 
- /* Get current configuration */
- myEngine->currConfig = myEngine->currEng->config();
+		/* Get current configuration */
+		myEngine->currConfig = myEngine->currEng->config();
 
- /* Configure channels and stuff */
- switch (myStatus->audioChannels) {
+		/* Configure channels and stuff */
+		switch (myStatus->audioChannels) {
 
-	case XS_CHN_AUTOPAN:
-		myEngine->currConfig.playback = sid2_stereo;
-		break;
+		case XS_CHN_AUTOPAN:
+			myEngine->currConfig.playback = sid2_stereo;
+			break;
 
-	case XS_CHN_STEREO:
-		myEngine->currConfig.playback = sid2_stereo;
-		break;
+		case XS_CHN_STEREO:
+			myEngine->currConfig.playback = sid2_stereo;
+			break;
 
-	case XS_CHN_MONO:
-	default:
-		myEngine->currConfig.playback = sid2_mono;
-		myStatus->audioChannels = XS_CHN_MONO;
-		break;
- }
+		case XS_CHN_MONO:
+		default:
+			myEngine->currConfig.playback = sid2_mono;
+			myStatus->audioChannels = XS_CHN_MONO;
+			break;
+		}
 
 
- /* Memory mode settings */
- switch (xs_cfg.memoryMode) {
-	case XS_MPU_BANK_SWITCHING:
-		myEngine->currConfig.environment = sid2_envBS;
-		break;
+		/* Memory mode settings */
+		switch (xs_cfg.memoryMode) {
+		case XS_MPU_BANK_SWITCHING:
+			myEngine->currConfig.environment = sid2_envBS;
+			break;
 
-	case XS_MPU_TRANSPARENT_ROM:
-		myEngine->currConfig.environment = sid2_envTP;
-		break;
+		case XS_MPU_TRANSPARENT_ROM:
+			myEngine->currConfig.environment = sid2_envTP;
+			break;
 
-	case XS_MPU_PLAYSID_ENVIRONMENT:
-		myEngine->currConfig.environment = sid2_envPS;
-		break;
+		case XS_MPU_PLAYSID_ENVIRONMENT:
+			myEngine->currConfig.environment = sid2_envPS;
+			break;
 
-	case XS_MPU_REAL:
-	default:
-		myEngine->currConfig.environment = sid2_envR;
-		xs_cfg.memoryMode = XS_MPU_REAL;
-		break;
- }
+		case XS_MPU_REAL:
+		default:
+			myEngine->currConfig.environment = sid2_envR;
+			xs_cfg.memoryMode = XS_MPU_REAL;
+			break;
+		}
 
 
- /* Clockspeed settings */
- switch (xs_cfg.clockSpeed) {
-	case XS_CLOCK_NTSC:
-		myEngine->currConfig.clockSpeed = myEngine->currConfig.clockDefault = SID2_CLOCK_NTSC;
-		break;
+		/* Clockspeed settings */
+		switch (xs_cfg.clockSpeed) {
+		case XS_CLOCK_NTSC:
+			myEngine->currConfig.clockSpeed = myEngine->currConfig.clockDefault = SID2_CLOCK_NTSC;
+			break;
 
-	case XS_CLOCK_PAL:
-	default:
-		myEngine->currConfig.clockSpeed = myEngine->currConfig.clockDefault = SID2_CLOCK_PAL;
-		xs_cfg.clockSpeed = XS_CLOCK_PAL;
-		break;
- }
+		case XS_CLOCK_PAL:
+		default:
+			myEngine->currConfig.clockSpeed = myEngine->currConfig.clockDefault = SID2_CLOCK_PAL;
+			xs_cfg.clockSpeed = XS_CLOCK_PAL;
+			break;
+		}
 
 
- /* Audio parameters sanity checking and setup */
- myEngine->currConfig.precision = myStatus->audioBitsPerSample;
- tmpFreq = myStatus->audioFrequency;
-
- if (myStatus->oversampleEnable)
-	tmpFreq = (tmpFreq * myStatus->oversampleFactor);
-
- myEngine->currConfig.frequency = tmpFreq;
+		/* Audio parameters sanity checking and setup */
+		myEngine->currConfig.precision = myStatus->audioBitsPerSample;
+		tmpFreq = myStatus->audioFrequency;
 
- switch (myStatus->audioBitsPerSample) {
- case XS_RES_8BIT:
-	myStatus->audioFormat 			= FMT_U8;
-	myEngine->currConfig.sampleFormat	= SID2_LITTLE_UNSIGNED;
-	break;
+		if (myStatus->oversampleEnable)
+			tmpFreq = (tmpFreq * myStatus->oversampleFactor);
 
- case XS_RES_16BIT:
- default:
-	switch (myStatus->audioFormat) {
-	case FMT_U16_LE:
-		myEngine->currConfig.sampleFormat	= SID2_LITTLE_UNSIGNED;
-		break;
+		myEngine->currConfig.frequency = tmpFreq;
 
-	case FMT_U16_BE:
-		myEngine->currConfig.sampleFormat	= SID2_BIG_UNSIGNED;
-		break;
+		switch (myStatus->audioBitsPerSample) {
+		case XS_RES_8BIT:
+			myStatus->audioFormat = FMT_U8;
+			myEngine->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED;
+			break;
 
-	case FMT_U16_NE:
-#ifdef WORDS_BIGENDIAN
-		myEngine->currConfig.sampleFormat	= SID2_BIG_UNSIGNED;
-#else
-		myEngine->currConfig.sampleFormat	= SID2_LITTLE_UNSIGNED;
-#endif
-		break;
+		case XS_RES_16BIT:
+		default:
+			switch (myStatus->audioFormat) {
+			case FMT_U16_LE:
+				myEngine->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED;
+				break;
 
-	case FMT_S16_LE:
-		myEngine->currConfig.sampleFormat	= SID2_LITTLE_SIGNED;
-		break;
+			case FMT_U16_BE:
+				myEngine->currConfig.sampleFormat = SID2_BIG_UNSIGNED;
+				break;
 
-	case FMT_S16_BE:
-		myEngine->currConfig.sampleFormat	= SID2_BIG_SIGNED;
-		break;
-
-	default:
-		myStatus->audioFormat			= FMT_S16_NE;
+			case FMT_U16_NE:
 #ifdef WORDS_BIGENDIAN
-		myEngine->currConfig.sampleFormat	= SID2_BIG_SIGNED;
+				myEngine->currConfig.sampleFormat = SID2_BIG_UNSIGNED;
 #else
-		myEngine->currConfig.sampleFormat	= SID2_LITTLE_SIGNED;
+				myEngine->currConfig.sampleFormat = SID2_LITTLE_UNSIGNED;
 #endif
-		break;
+				break;
+
+			case FMT_S16_LE:
+				myEngine->currConfig.sampleFormat = SID2_LITTLE_SIGNED;
+				break;
+
+			case FMT_S16_BE:
+				myEngine->currConfig.sampleFormat = SID2_BIG_SIGNED;
+				break;
 
-	}
-	break;
- }
+			default:
+				myStatus->audioFormat = FMT_S16_NE;
+#ifdef WORDS_BIGENDIAN
+				myEngine->currConfig.sampleFormat = SID2_BIG_SIGNED;
+#else
+				myEngine->currConfig.sampleFormat = SID2_LITTLE_SIGNED;
+#endif
+				break;
 
- /* Initialize builder object */
- XSDEBUG("init builder #%i, maxsids=%i\n", xs_cfg.sid2Builder, (myEngine->currEng->info()).maxsids);
+			}
+			break;
+		}
+
+		/* Initialize builder object */
+		XSDEBUG("init builder #%i, maxsids=%i\n", xs_cfg.sid2Builder, (myEngine->currEng->info()).maxsids);
 #ifdef HAVE_RESID_BUILDER
- if (xs_cfg.sid2Builder == XS_BLD_RESID)
-	{
-	ReSIDBuilder *rs = new ReSIDBuilder("ReSID builder");
-	myEngine->currBuilder = (sidbuilder *) rs;
-	if (rs)
-		{
-		/* Builder object created, initialize it */
-		rs->create((myEngine->currEng->info()).maxsids);
-		if (!*rs)
-			{
-			XSERR("rs->create() failed. SIDPlay2 suxx again.\n");
-			return FALSE;
-			}
+		if (xs_cfg.sid2Builder == XS_BLD_RESID) {
+			ReSIDBuilder *rs = new ReSIDBuilder("ReSID builder");
+			myEngine->currBuilder = (sidbuilder *) rs;
+			if (rs) {
+				/* Builder object created, initialize it */
+				rs->create((myEngine->currEng->info()).maxsids);
+				if (!*rs) {
+					XSERR("rs->create() failed. SIDPlay2 suxx again.\n");
+					return FALSE;
+				}
 
-		rs->filter(xs_cfg.emulateFilters);
-		if (!*rs)
-			{
-			XSERR("rs->filter(%d) failed.\n", xs_cfg.emulateFilters);
-			return FALSE;
-			}
-		
-		rs->sampling(tmpFreq);
-		if (!*rs)
-			{
-			XSERR("rs->sampling(%d) failed.\n", tmpFreq);
-			return FALSE;
-			}
-			
-		rs->filter((sid_filter_t *) NULL);
-		if (!*rs)
-			{
-			XSERR("rs->filter(NULL) failed.\n");
-			return FALSE;
+				rs->filter(xs_cfg.emulateFilters);
+				if (!*rs) {
+					XSERR("rs->filter(%d) failed.\n", xs_cfg.emulateFilters);
+					return FALSE;
+				}
+
+				rs->sampling(tmpFreq);
+				if (!*rs) {
+					XSERR("rs->sampling(%d) failed.\n", tmpFreq);
+					return FALSE;
+				}
+
+				rs->filter((sid_filter_t *) NULL);
+				if (!*rs) {
+					XSERR("rs->filter(NULL) failed.\n");
+					return FALSE;
+				}
 			}
 		}
-	}
 #endif
 #ifdef HAVE_HARDSID_BUILDER
- if (xs_cfg.sid2Builder == XS_BLD_HARDSID)
-	{
-	HardSIDBuilder *hs = new HardSIDBuilder("HardSID builder");
-	myEngine->currBuilder = (sidbuilder *) hs;
-	if (hs)
-		{
-		/* Builder object created, initialize it */
-		hs->create((myEngine->currEng->info()).maxsids);
-		if (!*hs)
-			{
-			XSERR("hs->create() failed. SIDPlay2 suxx again.\n");
-			return FALSE;
+		if (xs_cfg.sid2Builder == XS_BLD_HARDSID) {
+			HardSIDBuilder *hs = new HardSIDBuilder("HardSID builder");
+			myEngine->currBuilder = (sidbuilder *) hs;
+			if (hs) {
+				/* Builder object created, initialize it */
+				hs->create((myEngine->currEng->info()).maxsids);
+				if (!*hs) {
+					XSERR("hs->create() failed. SIDPlay2 suxx again.\n");
+					return FALSE;
+				}
+
+				hs->filter(xs_cfg.emulateFilters);
+				if (!*hs) {
+					XSERR("hs->filter(%d) failed.\n", xs_cfg.emulateFilters);
+					return FALSE;
+				}
 			}
-		
-		hs->filter(xs_cfg.emulateFilters);
-		if (!*hs)
-			{
-			XSERR("hs->filter(%d) failed.\n", xs_cfg.emulateFilters);
-			return FALSE;
-			}
-		}		
-	}
+		}
 #endif
 
- if (!myEngine->currBuilder)
-	{
-	XSERR("Could not initialize SIDBuilder object.\n");
-	return FALSE;
-	}
+		if (!myEngine->currBuilder) {
+			XSERR("Could not initialize SIDBuilder object.\n");
+			return FALSE;
+		}
 
- XSDEBUG("%s\n", myEngine->currBuilder->credits());
+		XSDEBUG("%s\n", myEngine->currBuilder->credits());
 
 
- /* Configure rest of the emulation */
- myEngine->currConfig.sidEmulation	= myEngine->currBuilder;
- myEngine->currConfig.clockForced	= xs_cfg.forceSpeed;
- myEngine->currConfig.optimisation	= (xs_cfg.sid2OptLevel) ? 1 : 0;
- if (xs_cfg.mos8580)
-	myEngine->currConfig.sidDefault = SID2_MOS8580;
-	else
-        myEngine->currConfig.sidDefault = SID2_MOS6581;
+		/* Configure rest of the emulation */
+		myEngine->currConfig.sidEmulation = myEngine->currBuilder;
+		myEngine->currConfig.clockForced = xs_cfg.forceSpeed;
+		myEngine->currConfig.optimisation = (xs_cfg.sid2OptLevel) ? 1 : 0;
+		if (xs_cfg.mos8580)
+			myEngine->currConfig.sidDefault = SID2_MOS8580;
+		else
+			myEngine->currConfig.sidDefault = SID2_MOS6581;
 
- myEngine->currConfig.sidModel		= myEngine->currConfig.sidDefault;
- myEngine->currConfig.sidSamples	= TRUE;	// FIXME FIX ME, make configurable!
+		myEngine->currConfig.sidModel = myEngine->currConfig.sidDefault;
+		myEngine->currConfig.sidSamples = TRUE;	// FIXME FIX ME, make configurable!
 
 
- /* Now set the emulator configuration */
- if (myEngine->currEng->config(myEngine->currConfig) < 0)
-	{
-	XSERR("Emulator engine configuration failed!\n");
-	return FALSE;
-	}
+		/* Now set the emulator configuration */
+		if (myEngine->currEng->config(myEngine->currConfig) < 0) {
+			XSERR("Emulator engine configuration failed!\n");
+			return FALSE;
+		}
 
- /* Create the sidtune */
- myEngine->currTune = new SidTune(0);
- if (!myEngine->currTune)
-	{
-	XSERR("Could not initialize SIDTune object.\n");
-	return FALSE;
+		/* Create the sidtune */
+		myEngine->currTune = new SidTune(0);
+		if (!myEngine->currTune) {
+			XSERR("Could not initialize SIDTune object.\n");
+			return FALSE;
+		}
+
+		return TRUE;
 	}
- 
- return TRUE;
-}
 
 
 /* Close SIDPlay2 engine
  */
-void xs_sidplay2_close(t_xs_status *myStatus)
-{
- t_xs_sidplay2 *myEngine;
- assert(myStatus);
-
- myEngine = (t_xs_sidplay2 *) myStatus->sidEngine;
-
- /* Free internals */
- if (myEngine->currBuilder)
-	{
-	delete myEngine->currBuilder;
-	myEngine->currBuilder = NULL;
-	}
-
- if (myEngine->currEng)
+	void xs_sidplay2_close(t_xs_status * myStatus)
 	{
-	delete myEngine->currEng;
-	myEngine->currEng = NULL;
-	}
+		t_xs_sidplay2 *myEngine;
+		assert(myStatus);
+
+		myEngine = (t_xs_sidplay2 *) myStatus->sidEngine;
+
+		/* Free internals */
+		if (myEngine->currBuilder) {
+			delete myEngine->currBuilder;
+			myEngine->currBuilder = NULL;
+		}
 
- if (myEngine->currTune)
-	{
-	delete myEngine->currTune;
-	myEngine->currTune = NULL;
-	}
+		if (myEngine->currEng) {
+			delete myEngine->currEng;
+			myEngine->currEng = NULL;
+		}
 
- xs_sidplay2_deletesid(myStatus);
+		if (myEngine->currTune) {
+			delete myEngine->currTune;
+			myEngine->currTune = NULL;
+		}
 
- g_free(myEngine);
- myStatus->sidEngine = NULL;
-}
+		xs_sidplay2_deletesid(myStatus);
+
+		g_free(myEngine);
+		myStatus->sidEngine = NULL;
+	}
 
 
 /* Initialize current song and sub-tune
  */
-gboolean xs_sidplay2_initsong(t_xs_status *myStatus)
-{
- t_xs_sidplay2 *myEngine;
- assert(myStatus);
-
- myEngine = (t_xs_sidplay2 *) myStatus->sidEngine;
- if (!myEngine) return FALSE;
-
- if (!myEngine->currTune->selectSong(myStatus->currSong))
+	gboolean xs_sidplay2_initsong(t_xs_status * myStatus)
 	{
-	XSERR("currTune->selectSong() failed\n");
-	return FALSE;
-	}
+		t_xs_sidplay2 *myEngine;
+		assert(myStatus);
+
+		myEngine = (t_xs_sidplay2 *) myStatus->sidEngine;
+		if (!myEngine)
+			return FALSE;
 
- if (myEngine->currEng->load(myEngine->currTune) < 0)
-	{
-	XSERR("currEng->load() failed\n");
-	return FALSE;
+		if (!myEngine->currTune->selectSong(myStatus->currSong)) {
+			XSERR("currTune->selectSong() failed\n");
+			return FALSE;
+		}
+
+		if (myEngine->currEng->load(myEngine->currTune) < 0) {
+			XSERR("currEng->load() failed\n");
+			return FALSE;
+		}
+
+		return TRUE;
 	}
 
- return TRUE;
-}
-
 
 /* Emulate and render audio data to given buffer
  */
-guint xs_sidplay2_fillbuffer(t_xs_status *myStatus, gchar *audioBuffer, guint audioBufSize)
-{
- t_xs_sidplay2 *myEngine;
- assert(myStatus);
+	guint xs_sidplay2_fillbuffer(t_xs_status * myStatus, gchar * audioBuffer, guint audioBufSize)
+	{
+		t_xs_sidplay2 *myEngine;
+		assert(myStatus);
 
- myEngine = (t_xs_sidplay2 *) myStatus->sidEngine;
- if (!myEngine) return 0;
+		myEngine = (t_xs_sidplay2 *) myStatus->sidEngine;
+		if (!myEngine)
+			return 0;
 
- return myEngine->currEng->play(audioBuffer, audioBufSize);
-}
+		return myEngine->currEng->play(audioBuffer, audioBufSize);
+	}
 
 
 /* Load a given SID-tune file
  */
-gboolean xs_sidplay2_loadsid(t_xs_status *myStatus, gchar *pcFilename)
-{
- t_xs_sidplay2 *myEngine;
- assert(myStatus);
+	gboolean xs_sidplay2_loadsid(t_xs_status * myStatus, gchar * pcFilename)
+	{
+		t_xs_sidplay2 *myEngine;
+		assert(myStatus);
 
- myEngine = (t_xs_sidplay2 *) myStatus->sidEngine;
+		myEngine = (t_xs_sidplay2 *) myStatus->sidEngine;
 
- /* Try to get the tune */
- if (!pcFilename) return FALSE;
- if (!myEngine->currTune->load(pcFilename)) return FALSE;
+		/* Try to get the tune */
+		if (!pcFilename)
+			return FALSE;
+		if (!myEngine->currTune->load(pcFilename))
+			return FALSE;
 
- return TRUE;
-}
+		return TRUE;
+	}
 
 
 /* Delete INTERNAL information
  */
-void xs_sidplay2_deletesid(t_xs_status *myStatus)
-{
- assert(myStatus);
+	void xs_sidplay2_deletesid(t_xs_status * myStatus)
+	{
+		assert(myStatus);
 
- /* With the current scheme of handling sidtune-loading, we don't do anything here. */
-}
+		/* With the current scheme of handling sidtune-loading, we don't do anything here. */
+	}
 
 
 /* Return song information
@@ -421,5 +410,5 @@
 #define TTUNE		SidTune
 #include "xs_sidplay.h"
 
-}	/* extern "C" */
-#endif	/* HAVE_SIDPLAY2 */
+}				/* extern "C" */
+#endif				/* HAVE_SIDPLAY2 */
--- a/src/xs_stil.c	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_stil.c	Mon Nov 07 09:50:04 2005 +0000
@@ -30,63 +30,60 @@
 
 /* Database handling functions
  */
-static t_xs_stil_node *xs_stildb_node_new(gchar *pcFilename)
+static t_xs_stil_node *xs_stildb_node_new(gchar * pcFilename)
 {
- t_xs_stil_node *pResult;
- 
- /* Allocate memory for new node */
- pResult = (t_xs_stil_node *) g_malloc0(sizeof(t_xs_stil_node));
- if (!pResult) return NULL;
+	t_xs_stil_node *pResult;
 
- pResult->pcFilename = g_strdup(pcFilename);
- if (!pResult->pcFilename)
- 	{
- 	g_free(pResult);
- 	return NULL;
- 	}
+	/* Allocate memory for new node */
+	pResult = (t_xs_stil_node *) g_malloc0(sizeof(t_xs_stil_node));
+	if (!pResult)
+		return NULL;
 
- return pResult;
+	pResult->pcFilename = g_strdup(pcFilename);
+	if (!pResult->pcFilename) {
+		g_free(pResult);
+		return NULL;
+	}
+
+	return pResult;
 }
 
 
-static void xs_stildb_node_free(t_xs_stil_node *pNode)
+static void xs_stildb_node_free(t_xs_stil_node * pNode)
 {
- gint i;
- 
- if (pNode)
- 	{
- 	/* Free subtune information */
- 	for (i = 0; i <= XS_STIL_MAXENTRY; i++)
- 		{
- 		g_free(pNode->subTunes[i].pName);
- 		g_free(pNode->subTunes[i].pAuthor);
- 		g_free(pNode->subTunes[i].pInfo);
- 		}
- 	
- 	g_free(pNode->pcFilename);
- 	g_free(pNode);
- 	}
+	gint i;
+
+	if (pNode) {
+		/* Free subtune information */
+		for (i = 0; i <= XS_STIL_MAXENTRY; i++) {
+			g_free(pNode->subTunes[i].pName);
+			g_free(pNode->subTunes[i].pAuthor);
+			g_free(pNode->subTunes[i].pInfo);
+		}
+
+		g_free(pNode->pcFilename);
+		g_free(pNode);
+	}
 }
 
 
 /* Insert given node to db linked list
  */
-static void xs_stildb_node_insert(t_xs_stildb *db, t_xs_stil_node *pNode)
+static void xs_stildb_node_insert(t_xs_stildb * db, t_xs_stil_node * pNode)
 {
- assert(db);
- 
- if (db->pNodes)
- 	{
- 	/* The first node's pPrev points to last node */
-	LPREV = db->pNodes->pPrev;		/* New node's prev = Previous last node */
-	db->pNodes->pPrev->pNext = pNode;	/* Previous last node's next = New node */
-	db->pNodes->pPrev = pNode;		/* New last node = New node */
-	LNEXT = NULL;				/* But next is NULL! */
- 	} else {
- 	db->pNodes = pNode;			/* First node ... */
- 	LPREV = pNode;				/* ... it's also last */
- 	LNEXT = NULL;				/* But next is NULL! */
- 	}
+	assert(db);
+
+	if (db->pNodes) {
+		/* The first node's pPrev points to last node */
+		LPREV = db->pNodes->pPrev;	/* New node's prev = Previous last node */
+		db->pNodes->pPrev->pNext = pNode;	/* Previous last node's next = New node */
+		db->pNodes->pPrev = pNode;	/* New last node = New node */
+		LNEXT = NULL;	/* But next is NULL! */
+	} else {
+		db->pNodes = pNode;	/* First node ... */
+		LPREV = pNode;	/* ... it's also last */
+		LNEXT = NULL;	/* But next is NULL! */
+	}
 }
 
 
@@ -95,163 +92,134 @@
 #define XS_STILDB_MULTI if (isMulti) { isMulti = FALSE; xs_pstrcat(&(tmpNode->subTunes[subEntry].pInfo), "\n"); }
 
 
-gint xs_stildb_read(t_xs_stildb *db, gchar *dbFilename)
+gint xs_stildb_read(t_xs_stildb * db, gchar * dbFilename)
 {
- FILE *inFile;
- gchar inLine[XS_BUF_SIZE + 16]; /* Since we add some chars here and there */
- guint lineNum, linePos, eolPos;
- t_xs_stil_node *tmpNode;
- gboolean isError, isMulti;
- gint subEntry;
- assert(db);
- 
- /* Try to open the file */
- if ((inFile = fopen(dbFilename, "ra")) == NULL)
- 	{
- 	XSERR("Could not open STILDB '%s'\n", dbFilename);
- 	return -1;
- 	}
- 
- /* Read and parse the data */
- lineNum = 0;
- isError = FALSE;
- isMulti = FALSE;
- tmpNode = NULL;
- subEntry = 0;
-  
- while (!feof(inFile) && !isError)
- {
- fgets(inLine, XS_BUF_SIZE, inFile);
- inLine[XS_BUF_SIZE-1] = 0;
- linePos = eolPos = 0;
- xs_findeol(inLine, &eolPos);
- inLine[eolPos] = 0;
- lineNum++;
+	FILE *inFile;
+	gchar inLine[XS_BUF_SIZE + 16];	/* Since we add some chars here and there */
+	guint lineNum, linePos, eolPos;
+	t_xs_stil_node *tmpNode;
+	gboolean isError, isMulti;
+	gint subEntry;
+	assert(db);
+
+	/* Try to open the file */
+	if ((inFile = fopen(dbFilename, "ra")) == NULL) {
+		XSERR("Could not open STILDB '%s'\n", dbFilename);
+		return -1;
+	}
+
+	/* Read and parse the data */
+	lineNum = 0;
+	isError = FALSE;
+	isMulti = FALSE;
+	tmpNode = NULL;
+	subEntry = 0;
+
+	while (!feof(inFile) && !isError) {
+		fgets(inLine, XS_BUF_SIZE, inFile);
+		inLine[XS_BUF_SIZE - 1] = 0;
+		linePos = eolPos = 0;
+		xs_findeol(inLine, &eolPos);
+		inLine[eolPos] = 0;
+		lineNum++;
 
- switch (inLine[0]) {
- case '/':
- 	/* Check if we are already parsing entry */
- 	isMulti = FALSE;
- 	if (tmpNode)
- 		{
- 		XSERR("New entry ('%s') before end of current ('%s')! Possibly malformed STIL-file!\n",
- 			inLine, tmpNode->pcFilename);
+		switch (inLine[0]) {
+		case '/':
+			/* Check if we are already parsing entry */
+			isMulti = FALSE;
+			if (tmpNode) {
+				XSERR("New entry ('%s') before end of current ('%s')! Possibly malformed STIL-file!\n",
+				      inLine, tmpNode->pcFilename);
+
+				xs_stildb_node_free(tmpNode);
+			}
 
- 		xs_stildb_node_free(tmpNode);
- 		}
- 
- 	/* A new node */
- 	subEntry = 0;
- 	tmpNode = xs_stildb_node_new(inLine);
- 	if (!tmpNode)
- 		{
- 		/* Allocation failed */
- 		XSERR("Could not allocate new STILdb-node for '%s'!\n", inLine);
- 		isError = TRUE;
- 		}
-	break;
+			/* A new node */
+			subEntry = 0;
+			tmpNode = xs_stildb_node_new(inLine);
+			if (!tmpNode) {
+				/* Allocation failed */
+				XSERR("Could not allocate new STILdb-node for '%s'!\n", inLine);
+				isError = TRUE;
+			}
+			break;
 
- case '(':
- 	/* A new sub-entry */
- 	isMulti = FALSE;
- 	linePos++;
- 	if (inLine[linePos] == '#')
- 		{
- 		linePos++;
- 		if (inLine[linePos])
- 			{
-		 	xs_findnum(inLine, &linePos);
-		 	inLine[linePos] = 0;
-	 		subEntry = atol(&inLine[2]);
+		case '(':
+			/* A new sub-entry */
+			isMulti = FALSE;
+			linePos++;
+			if (inLine[linePos] == '#') {
+				linePos++;
+				if (inLine[linePos]) {
+					xs_findnum(inLine, &linePos);
+					inLine[linePos] = 0;
+					subEntry = atol(&inLine[2]);
 
-		 	/* Sanity check */
-		 	if ((subEntry < 1) || (subEntry > XS_STIL_MAXENTRY))
- 				{
- 				XSERR("Number of subEntry (%i) for '%s' is invalid\n", subEntry, tmpNode->pcFilename);
- 				subEntry = 0;
- 				}
-	 		}
-	 	}
- 	
- 	break;
+					/* Sanity check */
+					if ((subEntry < 1) || (subEntry > XS_STIL_MAXENTRY)) {
+						XSERR("Number of subEntry (%i) for '%s' is invalid\n", subEntry,
+						      tmpNode->pcFilename);
+						subEntry = 0;
+					}
+				}
+			}
+
+			break;
 
- case 0:
- case '#':
- case '\n':
- case '\r':
- 	/* End of entry/field */
- 	isMulti = FALSE;
- 	if (tmpNode)
- 		{
- 		/* Insert to database */
- 		xs_stildb_node_insert(db, tmpNode);
-		tmpNode = NULL;
-		}
- 	break;
- 
- default:
- 	/* Check if we are parsing an entry */
- 	if (!tmpNode)
- 		{
- 		XSERR("Entry data encountered outside of entry!\n");
- 		break;
- 		}
+		case 0:
+		case '#':
+		case '\n':
+		case '\r':
+			/* End of entry/field */
+			isMulti = FALSE;
+			if (tmpNode) {
+				/* Insert to database */
+				xs_stildb_node_insert(db, tmpNode);
+				tmpNode = NULL;
+			}
+			break;
+
+		default:
+			/* Check if we are parsing an entry */
+			if (!tmpNode) {
+				XSERR("Entry data encountered outside of entry!\n");
+				break;
+			}
 
- 	/* Some other type */
- 	if (strncmp(inLine, "   NAME:", 8) == 0)
- 		{
-		XS_STILDB_MULTI
-		
- 		g_free(tmpNode->subTunes[subEntry].pName);
- 		tmpNode->subTunes[subEntry].pName = g_strdup(&inLine[9]);
- 		} else
- 	if (strncmp(inLine, " AUTHOR:", 8) == 0)
- 		{
-		XS_STILDB_MULTI
-
- 		g_free(tmpNode->subTunes[subEntry].pAuthor);
- 		tmpNode->subTunes[subEntry].pAuthor = g_strdup(&inLine[9]);
- 		} else
- 	if (strncmp(inLine, "  TITLE:", 8) == 0)
- 		{
-		XS_STILDB_MULTI
+			/* Some other type */
+			if (strncmp(inLine, "   NAME:", 8) == 0) {
+				XS_STILDB_MULTI g_free(tmpNode->subTunes[subEntry].pName);
+				tmpNode->subTunes[subEntry].pName = g_strdup(&inLine[9]);
+			} else if (strncmp(inLine, " AUTHOR:", 8) == 0) {
+				XS_STILDB_MULTI g_free(tmpNode->subTunes[subEntry].pAuthor);
+				tmpNode->subTunes[subEntry].pAuthor = g_strdup(&inLine[9]);
+			} else if (strncmp(inLine, "  TITLE:", 8) == 0) {
+				XS_STILDB_MULTI inLine[eolPos++] = '\n';
+				inLine[eolPos++] = 0;
+				xs_pstrcat(&(tmpNode->subTunes[subEntry].pInfo), &inLine[2]);
+			} else if (strncmp(inLine, " ARTIST:", 8) == 0) {
+				XS_STILDB_MULTI inLine[eolPos++] = '\n';
+				inLine[eolPos++] = 0;
+				xs_pstrcat(&(tmpNode->subTunes[subEntry].pInfo), &inLine[1]);
+			} else if (strncmp(inLine, "COMMENT:", 8) == 0) {
+				XS_STILDB_MULTI isMulti = TRUE;
+				xs_pstrcat(&(tmpNode->subTunes[subEntry].pInfo), inLine);
+			} else if (strncmp(inLine, "        ", 8) == 0) {
+				xs_pstrcat(&(tmpNode->subTunes[subEntry].pInfo), &inLine[8]);
+			}
+			break;
+		}
 
- 		inLine[eolPos++] = '\n';
- 		inLine[eolPos++] = 0;
- 		xs_pstrcat(&(tmpNode->subTunes[subEntry].pInfo), &inLine[2]);
-		} else
- 	if (strncmp(inLine, " ARTIST:", 8) == 0)
- 		{
-		XS_STILDB_MULTI
- 			
- 		inLine[eolPos++] = '\n';
- 		inLine[eolPos++] = 0;
- 		xs_pstrcat(&(tmpNode->subTunes[subEntry].pInfo), &inLine[1]);
- 		} else
- 	if (strncmp(inLine, "COMMENT:", 8) == 0)
- 		{
-		XS_STILDB_MULTI
+	}			/* while */
 
- 		isMulti = TRUE;
- 		xs_pstrcat(&(tmpNode->subTunes[subEntry].pInfo), inLine);
- 		} else
- 	if (strncmp(inLine, "        ", 8) == 0)
- 		{
- 		xs_pstrcat(&(tmpNode->subTunes[subEntry].pInfo), &inLine[8]);
- 		}
- 	break;
- }
- 
- } /* while */
+	/* Check if there is one remaining node */
+	if (tmpNode)
+		xs_stildb_node_insert(db, tmpNode);
 
- /* Check if there is one remaining node */
- if (tmpNode)
-	xs_stildb_node_insert(db, tmpNode);
+	/* Close the file */
+	fclose(inFile);
 
- /* Close the file */  
- fclose(inFile);
-
- return 0;
+	return 0;
 }
 
 
@@ -259,252 +227,235 @@
  */
 static gint xs_stildb_cmp(const void *pNode1, const void *pNode2)
 {
- /* We assume here that we never ever get NULL-pointers or similar */
- return strcmp((*(t_xs_stil_node **) pNode1)->pcFilename,
- 		(*(t_xs_stil_node **) pNode2)->pcFilename);
+	/* We assume here that we never ever get NULL-pointers or similar */
+	return strcmp((*(t_xs_stil_node **) pNode1)->pcFilename, (*(t_xs_stil_node **) pNode2)->pcFilename);
 }
 
 
 /* (Re)create index
  */
-gint xs_stildb_index(t_xs_stildb *db)
+gint xs_stildb_index(t_xs_stildb * db)
 {
- t_xs_stil_node *pCurr;
- gint i;
+	t_xs_stil_node *pCurr;
+	gint i;
+
+	/* Free old index */
+	if (db->ppIndex) {
+		g_free(db->ppIndex);
+		db->ppIndex = NULL;
+	}
 
- /* Free old index */
- if (db->ppIndex)
- 	{
- 	g_free(db->ppIndex);
- 	db->ppIndex = NULL;
- 	}
- 
- /* Get size of db */
- pCurr = db->pNodes;
- db->n = 0;
- while (pCurr)
- 	{
- 	db->n++;
- 	pCurr = pCurr->pNext;
- 	}
+	/* Get size of db */
+	pCurr = db->pNodes;
+	db->n = 0;
+	while (pCurr) {
+		db->n++;
+		pCurr = pCurr->pNext;
+	}
 
- /* Check number of nodes */
- if (db->n > 0)
-	{
-	/* Allocate memory for index-table */
-	db->ppIndex = (t_xs_stil_node **) g_malloc(sizeof(t_xs_stil_node *) * db->n);
-	if (!db->ppIndex) return -1;
+	/* Check number of nodes */
+	if (db->n > 0) {
+		/* Allocate memory for index-table */
+		db->ppIndex = (t_xs_stil_node **) g_malloc(sizeof(t_xs_stil_node *) * db->n);
+		if (!db->ppIndex)
+			return -1;
 
-	/* Get node-pointers to table */
-	i = 0;
-	pCurr = db->pNodes;
-	while (pCurr && (i < db->n))
-		{
-		db->ppIndex[i++] = pCurr;
-		pCurr = pCurr->pNext;
+		/* Get node-pointers to table */
+		i = 0;
+		pCurr = db->pNodes;
+		while (pCurr && (i < db->n)) {
+			db->ppIndex[i++] = pCurr;
+			pCurr = pCurr->pNext;
 		}
 
-	/* Sort the indexes */
-	qsort(db->ppIndex, db->n, sizeof(t_xs_stil_node *), xs_stildb_cmp);
+		/* Sort the indexes */
+		qsort(db->ppIndex, db->n, sizeof(t_xs_stil_node *), xs_stildb_cmp);
 	}
 
- return 0;
+	return 0;
 }
 
 /* Free a given STIL database
  */
-void xs_stildb_free(t_xs_stildb *db)
+void xs_stildb_free(t_xs_stildb * db)
 {
- t_xs_stil_node *pCurr, *pNext;
- 
- if (!db) return;
- 
- /* Free the memory allocated for nodes */
- pCurr = db->pNodes;
- while (pCurr)
- 	{
- 	pNext = pCurr->pNext;
-	xs_stildb_node_free(pCurr);
- 	pCurr = pNext;
- 	}
+	t_xs_stil_node *pCurr, *pNext;
+
+	if (!db)
+		return;
 
- db->pNodes = NULL;
- 
- /* Free memory allocated for index */
- if (db->ppIndex)
- 	{
- 	g_free(db->ppIndex);
- 	db->ppIndex = NULL;
- 	}
+	/* Free the memory allocated for nodes */
+	pCurr = db->pNodes;
+	while (pCurr) {
+		pNext = pCurr->pNext;
+		xs_stildb_node_free(pCurr);
+		pCurr = pNext;
+	}
+
+	db->pNodes = NULL;
 
- /* Free structure */
- db->n = 0;
- g_free(db);
+	/* Free memory allocated for index */
+	if (db->ppIndex) {
+		g_free(db->ppIndex);
+		db->ppIndex = NULL;
+	}
+
+	/* Free structure */
+	db->n = 0;
+	g_free(db);
 }
 
 
 /* Get STIL information node from database
  */
-static t_xs_stil_node * xs_stildb_get_node(t_xs_stildb *db, gchar *pcFilename)
+static t_xs_stil_node *xs_stildb_get_node(t_xs_stildb * db, gchar * pcFilename)
 {
- gint iStartNode, iEndNode, iQNode, r, i;
- gboolean iFound;
- t_xs_stil_node *pResult;
+	gint iStartNode, iEndNode, iQNode, r, i;
+	gboolean iFound;
+	t_xs_stil_node *pResult;
 
- /* Check the database pointers */
- if (!db || !db->pNodes || !db->ppIndex)
- 	return NULL;
- 
- /* Look-up via index using binary search */
- pResult = NULL;
- iStartNode = 0;
- iEndNode = (db->n - 1);
- iQNode = (iEndNode / 2);
- iFound = FALSE;
+	/* Check the database pointers */
+	if (!db || !db->pNodes || !db->ppIndex)
+		return NULL;
 
- while ((!iFound) && ((iEndNode - iStartNode) > 128))
- 	{
- 	r = strcmp(pcFilename, db->ppIndex[iQNode]->pcFilename);
- 	if (r < 0)
- 		{
- 		/* Hash was in the <- LEFT side */
- 		iEndNode = iQNode;
- 		iQNode = iStartNode + ((iEndNode - iStartNode) / 2);
- 		} else
- 	if (r > 0)
- 		{
- 		/* Hash was in the RIGHT -> side */
- 		iStartNode = iQNode;
- 		iQNode = iStartNode + ((iEndNode - iStartNode) / 2);
- 		} else
- 		iFound = TRUE;
- 	}
+	/* Look-up via index using binary search */
+	pResult = NULL;
+	iStartNode = 0;
+	iEndNode = (db->n - 1);
+	iQNode = (iEndNode / 2);
+	iFound = FALSE;
 
- /* If not found already */
- if (!iFound)
- 	{
-	/* Search the are linearly */
-	iFound = FALSE;
-	i = iStartNode;
-	while ((i <= iEndNode) && (!iFound))
-		{
-		if (strcmp(pcFilename, db->ppIndex[i]->pcFilename) == 0)
+	while ((!iFound) && ((iEndNode - iStartNode) > 128)) {
+		r = strcmp(pcFilename, db->ppIndex[iQNode]->pcFilename);
+		if (r < 0) {
+			/* Hash was in the <- LEFT side */
+			iEndNode = iQNode;
+			iQNode = iStartNode + ((iEndNode - iStartNode) / 2);
+		} else if (r > 0) {
+			/* Hash was in the RIGHT -> side */
+			iStartNode = iQNode;
+			iQNode = iStartNode + ((iEndNode - iStartNode) / 2);
+		} else
 			iFound = TRUE;
-			else
-			i++;
-		}
-	
-	/* Check the result */
-	if (iFound)
-		pResult = db->ppIndex[i];
-
- 	} else {
-	/* Found via binary search */
- 	pResult = db->ppIndex[iQNode];
 	}
 
- return pResult;
+	/* If not found already */
+	if (!iFound) {
+		/* Search the are linearly */
+		iFound = FALSE;
+		i = iStartNode;
+		while ((i <= iEndNode) && (!iFound)) {
+			if (strcmp(pcFilename, db->ppIndex[i]->pcFilename) == 0)
+				iFound = TRUE;
+			else
+				i++;
+		}
+
+		/* Check the result */
+		if (iFound)
+			pResult = db->ppIndex[i];
+
+	} else {
+		/* Found via binary search */
+		pResult = db->ppIndex[iQNode];
+	}
+
+	return pResult;
 }
 
 
 /*
  * These should be moved out of this module some day ...
  */
-static t_xs_stildb	*xs_stildb_db = NULL;
+static t_xs_stildb *xs_stildb_db = NULL;
 XS_MUTEX(xs_stildb_db);
 
 gint xs_stil_init(void)
 {
- XS_MUTEX_LOCK(xs_cfg);
+	XS_MUTEX_LOCK(xs_cfg);
+
+	if (!xs_cfg.stilDBPath) {
+		XS_MUTEX_UNLOCK(xs_cfg);
+		return -1;
+	}
+
+	XS_MUTEX_LOCK(xs_stildb_db);
 
- if (!xs_cfg.stilDBPath)
- 	{
- 	XS_MUTEX_UNLOCK(xs_cfg);
- 	return -1;
- 	}
+	/* Check if already initialized */
+	if (xs_stildb_db)
+		xs_stildb_free(xs_stildb_db);
+
+	/* Allocate database */
+	xs_stildb_db = (t_xs_stildb *) g_malloc0(sizeof(t_xs_stildb));
+	if (!xs_stildb_db) {
+		XS_MUTEX_UNLOCK(xs_cfg);
+		XS_MUTEX_UNLOCK(xs_stildb_db);
+		return -2;
+	}
 
- XS_MUTEX_LOCK(xs_stildb_db);
- 
- /* Check if already initialized */
- if (xs_stildb_db) xs_stildb_free(xs_stildb_db);
- 
- /* Allocate database */
- xs_stildb_db = (t_xs_stildb *) g_malloc0(sizeof(t_xs_stildb));
- if (!xs_stildb_db)
- 	{
- 	XS_MUTEX_UNLOCK(xs_cfg);
- 	XS_MUTEX_UNLOCK(xs_stildb_db);
- 	return -2;
- 	}
- 
- /* Read the database */
- if (xs_stildb_read(xs_stildb_db, xs_cfg.stilDBPath) != 0)
- 	{
- 	xs_stildb_free(xs_stildb_db);
- 	xs_stildb_db = NULL;
- 	XS_MUTEX_UNLOCK(xs_cfg);
- 	XS_MUTEX_UNLOCK(xs_stildb_db);
- 	return -3;
- 	}
+	/* Read the database */
+	if (xs_stildb_read(xs_stildb_db, xs_cfg.stilDBPath) != 0) {
+		xs_stildb_free(xs_stildb_db);
+		xs_stildb_db = NULL;
+		XS_MUTEX_UNLOCK(xs_cfg);
+		XS_MUTEX_UNLOCK(xs_stildb_db);
+		return -3;
+	}
 
- /* Create index */
- if (xs_stildb_index(xs_stildb_db) != 0)
- 	{
- 	xs_stildb_free(xs_stildb_db);
- 	xs_stildb_db = NULL;
- 	XS_MUTEX_UNLOCK(xs_cfg);
- 	XS_MUTEX_UNLOCK(xs_stildb_db);
- 	return -4;
- 	}
+	/* Create index */
+	if (xs_stildb_index(xs_stildb_db) != 0) {
+		xs_stildb_free(xs_stildb_db);
+		xs_stildb_db = NULL;
+		XS_MUTEX_UNLOCK(xs_cfg);
+		XS_MUTEX_UNLOCK(xs_stildb_db);
+		return -4;
+	}
 
- XS_MUTEX_UNLOCK(xs_cfg);
- XS_MUTEX_UNLOCK(xs_stildb_db);
- return 0;
+	XS_MUTEX_UNLOCK(xs_cfg);
+	XS_MUTEX_UNLOCK(xs_stildb_db);
+	return 0;
 }
 
 
 void xs_stil_close(void)
 {
- XS_MUTEX_LOCK(xs_stildb_db);
- xs_stildb_free(xs_stildb_db);
- xs_stildb_db = NULL;
- XS_MUTEX_UNLOCK(xs_stildb_db);
+	XS_MUTEX_LOCK(xs_stildb_db);
+	xs_stildb_free(xs_stildb_db);
+	xs_stildb_db = NULL;
+	XS_MUTEX_UNLOCK(xs_stildb_db);
 }
 
 
-t_xs_stil_node * xs_stil_get(gchar *pcFilename)
+t_xs_stil_node *xs_stil_get(gchar * pcFilename)
 {
- t_xs_stil_node *pResult;
- gchar *tmpFilename;
+	t_xs_stil_node *pResult;
+	gchar *tmpFilename;
+
+	XS_MUTEX_LOCK(xs_stildb_db);
+	XS_MUTEX_LOCK(xs_cfg);
 
- XS_MUTEX_LOCK(xs_stildb_db);
- XS_MUTEX_LOCK(xs_cfg);
+	if (xs_cfg.stilDBEnable && xs_stildb_db) {
+		if (xs_cfg.hvscPath) {
+			/* Remove postfixed directory separator from HVSC-path */
+			tmpFilename = xs_strrchr(xs_cfg.hvscPath, '/');
+			if (tmpFilename && (tmpFilename[1] == 0))
+				tmpFilename[0] = 0;
 
- if (xs_cfg.stilDBEnable && xs_stildb_db)
- 	{
-	if (xs_cfg.hvscPath)
- 		{
- 		/* Remove postfixed directory separator from HVSC-path */
- 		tmpFilename = xs_strrchr(xs_cfg.hvscPath, '/');
- 		if (tmpFilename && (tmpFilename[1] == 0))
- 			tmpFilename[0] = 0;
- 
-		/* Remove HVSC location-prefix from filename */
-		tmpFilename = strstr(pcFilename, xs_cfg.hvscPath);
-		if (tmpFilename)
-			tmpFilename += strlen(xs_cfg.hvscPath);
+			/* Remove HVSC location-prefix from filename */
+			tmpFilename = strstr(pcFilename, xs_cfg.hvscPath);
+			if (tmpFilename)
+				tmpFilename += strlen(xs_cfg.hvscPath);
 			else
-			tmpFilename = pcFilename; 
+				tmpFilename = pcFilename;
 		} else
-		tmpFilename = pcFilename;
-	
-	pResult = xs_stildb_get_node(xs_stildb_db, tmpFilename);
+			tmpFilename = pcFilename;
+
+		pResult = xs_stildb_get_node(xs_stildb_db, tmpFilename);
 	} else
-	pResult = NULL;
+		pResult = NULL;
 
- XS_MUTEX_UNLOCK(xs_stildb_db);
- XS_MUTEX_UNLOCK(xs_cfg);
- 
- return pResult;
+	XS_MUTEX_UNLOCK(xs_stildb_db);
+	XS_MUTEX_UNLOCK(xs_cfg);
+
+	return pResult;
 }
-
--- a/src/xs_support.c	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_support.c	Mon Nov 07 09:50:04 2005 +0000
@@ -27,168 +27,191 @@
 
 /* Bigendian file reading functions
  */
-guint16 xs_rd_be16(FILE *f)
+guint16 xs_rd_be16(FILE * f)
 {
- return (((guint16) fgetc(f)) << 8) |
- 	 ((guint16) fgetc(f));
+	return (((guint16) fgetc(f)) << 8) | ((guint16) fgetc(f));
 }
 
 
-guint32 xs_rd_be32(FILE *f)
+guint32 xs_rd_be32(FILE * f)
 {
- return (((guint32) fgetc(f)) << 24) |
- 	(((guint32) fgetc(f)) << 16) |
- 	(((guint32) fgetc(f)) << 8) |
- 	 ((guint32) fgetc(f));
+	return (((guint32) fgetc(f)) << 24) |
+	    (((guint32) fgetc(f)) << 16) | (((guint32) fgetc(f)) << 8) | ((guint32) fgetc(f));
 }
 
 
-size_t xs_rd_str(FILE *f, gchar *s, size_t l)
+size_t xs_rd_str(FILE * f, gchar * s, size_t l)
 {
- return fread(s, sizeof(gchar), l, f);
+	return fread(s, sizeof(gchar), l, f);
 }
 
 
 /* Copy a string
  */
-gchar *xs_strncpy(gchar *pDest, gchar *pSource, size_t n)
+gchar *xs_strncpy(gchar * pDest, gchar * pSource, size_t n)
 {
- gchar *s, *d;
- size_t i;
- 
- /* Check the string pointers */
- if (!pSource || !pDest) return pDest;
+	gchar *s, *d;
+	size_t i;
+
+	/* Check the string pointers */
+	if (!pSource || !pDest)
+		return pDest;
 
- /* Copy to the destination */
- i = n; s = pSource; d = pDest;
- while (*s && (i > 0)) { *(d++) = *(s++); i--; }
+	/* Copy to the destination */
+	i = n;
+	s = pSource;
+	d = pDest;
+	while (*s && (i > 0)) {
+		*(d++) = *(s++);
+		i--;
+	}
 
- /* Fill rest of space with zeros */
- while (i > 0) { *(d++) = 0; i--; }
- 
- /* Ensure that last is always zero */
- pDest[n - 1] = 0;
+	/* Fill rest of space with zeros */
+	while (i > 0) {
+		*(d++) = 0;
+		i--;
+	}
 
- return pDest;
+	/* Ensure that last is always zero */
+	pDest[n - 1] = 0;
+
+	return pDest;
 }
 
 
 /* Copy a given string over in *ppResult.
  */
-gint xs_pstrcpy(gchar **ppResult, const gchar *pStr)
+gint xs_pstrcpy(gchar ** ppResult, const gchar * pStr)
 {
- /* Check the string pointers */
- if (!ppResult || !pStr) return -1;
+	/* Check the string pointers */
+	if (!ppResult || !pStr)
+		return -1;
 
- /* Allocate memory for destination */
- if (*ppResult) g_free(*ppResult);
- *ppResult = (gchar *) g_malloc(strlen(pStr) + 1);
- if (!*ppResult) return -2;
+	/* Allocate memory for destination */
+	if (*ppResult)
+		g_free(*ppResult);
+	*ppResult = (gchar *) g_malloc(strlen(pStr) + 1);
+	if (!*ppResult)
+		return -2;
 
- /* Copy to the destination */
- strcpy(*ppResult, pStr);
+	/* Copy to the destination */
+	strcpy(*ppResult, pStr);
 
- return 0;
+	return 0;
 }
 
 
 /* Concatenates a given string into string pointed by *ppResult.
  */
-gint xs_pstrcat(gchar **ppResult, const gchar *pStr)
+gint xs_pstrcat(gchar ** ppResult, const gchar * pStr)
 {
- /* Check the string pointers */
- if (!ppResult || !pStr) return -1;
+	/* Check the string pointers */
+	if (!ppResult || !pStr)
+		return -1;
 
- if (*ppResult != NULL)
- 	{
- 	*ppResult = (gchar *) g_realloc(*ppResult, strlen(*ppResult) + strlen(pStr) + 1);
-	if (*ppResult == NULL) return -1;
-	strcat(*ppResult, pStr);
-	} else
-	{
-	*ppResult = (gchar *) g_malloc(strlen(pStr) + 1);
-	if (*ppResult == NULL) return -1;
-	strcpy(*ppResult, pStr);
+	if (*ppResult != NULL) {
+		*ppResult = (gchar *) g_realloc(*ppResult, strlen(*ppResult) + strlen(pStr) + 1);
+		if (*ppResult == NULL)
+			return -1;
+		strcat(*ppResult, pStr);
+	} else {
+		*ppResult = (gchar *) g_malloc(strlen(pStr) + 1);
+		if (*ppResult == NULL)
+			return -1;
+		strcpy(*ppResult, pStr);
 	}
 
- return 0;
+	return 0;
 }
 
 
 /* Concatenate a given string up to given dest size or \n.
  * If size max is reached, change the end to "..."
  */
-void xs_pnstrcat(gchar *pDest, size_t iSize, gchar *pStr)
+void xs_pnstrcat(gchar * pDest, size_t iSize, gchar * pStr)
 {
- size_t i, n;
- gchar *s, *d;
- 
- d = pDest; i = 0;
- while (*d && (i < iSize)) { i++; d++; }
- 
- s = pStr;
- while (*s && (*s != '\n') && (i < iSize))
- 	{
- 	*d = *s;
- 	d++; s++; i++;
- 	}
+	size_t i, n;
+	gchar *s, *d;
+
+	d = pDest;
+	i = 0;
+	while (*d && (i < iSize)) {
+		i++;
+		d++;
+	}
 
- *d = 0;
+	s = pStr;
+	while (*s && (*s != '\n') && (i < iSize)) {
+		*d = *s;
+		d++;
+		s++;
+		i++;
+	}
+
+	*d = 0;
 
- if (i >= iSize)
- 	{
- 	i--; d--; n = 3;
- 	while ((i > 0) && (n > 0))
-		{
-		*d = '.';
-		d--; i--; n--;
+	if (i >= iSize) {
+		i--;
+		d--;
+		n = 3;
+		while ((i > 0) && (n > 0)) {
+			*d = '.';
+			d--;
+			i--;
+			n--;
 		}
- 	}
+	}
 }
 
 
 /* Locate character in string
  */
-gchar *xs_strrchr(gchar *pcStr, gchar ch)
+gchar *xs_strrchr(gchar * pcStr, gchar ch)
 {
- gchar *lastPos = NULL;
+	gchar *lastPos = NULL;
 
- while (*pcStr)
- 	{
- 	if (*pcStr == ch) lastPos = pcStr;
- 	pcStr++;
- 	}
+	while (*pcStr) {
+		if (*pcStr == ch)
+			lastPos = pcStr;
+		pcStr++;
+	}
 
- return lastPos;
+	return lastPos;
 }
 
 
-void xs_findnext(gchar *pcStr, guint *piPos)
+void xs_findnext(gchar * pcStr, guint * piPos)
 {
- while (pcStr[*piPos] && isspace(pcStr[*piPos])) (*piPos)++;
+	while (pcStr[*piPos] && isspace(pcStr[*piPos]))
+		(*piPos)++;
 }
 
 
-void xs_findeol(gchar *pcStr, guint *piPos)
+void xs_findeol(gchar * pcStr, guint * piPos)
 {
- while (pcStr[*piPos] && (pcStr[*piPos] != '\n') && (pcStr[*piPos] != '\r')) (*piPos)++;
+	while (pcStr[*piPos] && (pcStr[*piPos] != '\n') && (pcStr[*piPos] != '\r'))
+		(*piPos)++;
 }
 
 
-void xs_findnum(gchar *pcStr, guint *piPos)
+void xs_findnum(gchar * pcStr, guint * piPos)
 {
- while (pcStr[*piPos] && isdigit(pcStr[*piPos])) (*piPos)++;
+	while (pcStr[*piPos] && isdigit(pcStr[*piPos]))
+		(*piPos)++;
 }
 
 
 #ifndef HAVE_MEMSET
 void *xs_memset(void *p, int c, size_t n)
 {
- gchar *dp;
- 
- dp = (gchar *) p;
- while (n--) { *dp = (gchar) c; n--; }
+	gchar *dp;
 
- return p;
+	dp = (gchar *) p;
+	while (n--) {
+		*dp = (gchar) c;
+		n--;
+	}
+
+	return p;
 }
 #endif
--- a/src/xs_title.c	Mon Nov 07 09:49:04 2005 +0000
+++ b/src/xs_title.c	Mon Nov 07 09:50:04 2005 +0000
@@ -43,124 +43,141 @@
 	}
 
 
-gchar *xs_make_titlestring(gchar *pcFilename,
-				gint iSubTune,
-				gint iSidModel,
-				const gchar *formatString, const gchar *infoString0,
-				const gchar *infoString1, const gchar *infoString2)
+gchar *xs_make_titlestring(gchar * pcFilename,
+			   gint iSubTune,
+			   gint iSidModel,
+			   const gchar * formatString, const gchar * infoString0,
+			   const gchar * infoString1, const gchar * infoString2)
 {
- gchar *tmpFilename, *tmpFilePath, *tmpFileExt, *pcStr, *pcResult,
- 	tmpStr[VBUFSIZE], tmpBuf[VBUFSIZE];
- gint iIndex;
+	gchar *tmpFilename, *tmpFilePath, *tmpFileExt, *pcStr, *pcResult, tmpStr[VBUFSIZE], tmpBuf[VBUFSIZE];
+	gint iIndex;
 #ifdef HAVE_XMMSEXTRA
- TitleInput *ptInput;
+	TitleInput *ptInput;
 #endif
 
- /* Split the filename into path */
- tmpFilePath = g_strdup(pcFilename);
- tmpFilename = xs_strrchr(tmpFilePath, '/');
- if (tmpFilename)
-	tmpFilename[1] = 0;
-		
- /* Filename */
- tmpFilename = xs_strrchr(pcFilename, '/');
- if (tmpFilename)
-	tmpFilename = g_strdup(tmpFilename + 1);
+	/* Split the filename into path */
+	tmpFilePath = g_strdup(pcFilename);
+	tmpFilename = xs_strrchr(tmpFilePath, '/');
+	if (tmpFilename)
+		tmpFilename[1] = 0;
+
+	/* Filename */
+	tmpFilename = xs_strrchr(pcFilename, '/');
+	if (tmpFilename)
+		tmpFilename = g_strdup(tmpFilename + 1);
 	else
-	tmpFilename = g_strdup(pcFilename);
+		tmpFilename = g_strdup(pcFilename);
 
- tmpFileExt = xs_strrchr(tmpFilename, '.');
- tmpFileExt[0] = 0;
+	tmpFileExt = xs_strrchr(tmpFilename, '.');
+	tmpFileExt[0] = 0;
 
- /* Extension */
- tmpFileExt = xs_strrchr(pcFilename, '.');
+	/* Extension */
+	tmpFileExt = xs_strrchr(pcFilename, '.');
 
 
 #ifdef HAVE_XMMSEXTRA
- /* Check if the titles are overridden or not */
- if (!xs_cfg.titleOverride)
-	{
-	/* Use generic XMMS titles */
-	/* XMMS_NEW_TITLEINPUT(ptInput);
-	 * We duplicate and add typecast to the code here due to XMMS's braindead headers
-	 */
-	ptInput = (TitleInput *) g_malloc0(sizeof(TitleInput));
-	ptInput->__size = XMMS_TITLEINPUT_SIZE;
-	ptInput->__version = XMMS_TITLEINPUT_VERSION;
+	/* Check if the titles are overridden or not */
+	if (!xs_cfg.titleOverride) {
+		/* Use generic XMMS titles */
+		/* XMMS_NEW_TITLEINPUT(ptInput);
+		 * We duplicate and add typecast to the code here due to XMMS's braindead headers
+		 */
+		ptInput = (TitleInput *) g_malloc0(sizeof(TitleInput));
+		ptInput->__size = XMMS_TITLEINPUT_SIZE;
+		ptInput->__version = XMMS_TITLEINPUT_VERSION;
 
-	/* Create the input fields */
-	ptInput->file_name	= tmpFilename;
-	ptInput->file_ext	= tmpFileExt;
-	ptInput->file_path	= tmpFilePath;
+		/* Create the input fields */
+		ptInput->file_name = tmpFilename;
+		ptInput->file_ext = tmpFileExt;
+		ptInput->file_path = tmpFilePath;
 
-	ptInput->track_name	= g_strdup(infoString0);
-	ptInput->track_number	= iSubTune;
-	ptInput->album_name	= NULL;
-	ptInput->performer	= g_strdup(infoString1);
-	ptInput->date		= g_strdup((iSidModel == XS_SIDMODEL_6581) ? "SID6581" : "SID8580");
+		ptInput->track_name = g_strdup(infoString0);
+		ptInput->track_number = iSubTune;
+		ptInput->album_name = NULL;
+		ptInput->performer = g_strdup(infoString1);
+		ptInput->date = g_strdup((iSidModel == XS_SIDMODEL_6581) ? "SID6581" : "SID8580");
 
-	ptInput->year		= 0;
-	ptInput->genre		= g_strdup("SID-tune");
-	ptInput->comment	= g_strdup(infoString2);
+		ptInput->year = 0;
+		ptInput->genre = g_strdup("SID-tune");
+		ptInput->comment = g_strdup(infoString2);
 
-	/* Create the string */
-	pcResult = xmms_get_titlestring(xmms_get_gentitle_format(), ptInput);
+		/* Create the string */
+		pcResult = xmms_get_titlestring(xmms_get_gentitle_format(), ptInput);
 
-	/* Dispose all allocated memory */
-	g_free(ptInput->track_name);
-	g_free(ptInput->performer);
-	g_free(ptInput->comment);
-	g_free(ptInput->date);
-	g_free(ptInput->genre);
-	g_free(ptInput);
-	}
-	else
+		/* Dispose all allocated memory */
+		g_free(ptInput->track_name);
+		g_free(ptInput->performer);
+		g_free(ptInput->comment);
+		g_free(ptInput->date);
+		g_free(ptInput->genre);
+		g_free(ptInput);
+	} else
 #endif
 	{
-	/* Create the string */
-	pcStr = xs_cfg.titleFormat;
-	iIndex = 0;
-	while (*pcStr && (iIndex < VBUFSIZE))
-	{
-	if (*pcStr == '%')
-		{
-		pcStr++;
-		switch (*pcStr) {
-		case '%': VPUTCH('%'); break;
-		case 'f': VPUTSTR(tmpFilename); break;
-		case 'F': VPUTSTR(tmpFilePath); break;
-		case 'e': VPUTSTR(tmpFileExt); break;
-		case 'p': VPUTSTR(infoString1); break;
-		case 't': VPUTSTR(infoString0); break;
-		case 'c': VPUTSTR(infoString2); break;
-		case 's': VPUTSTR(formatString); break;
-		case 'm':
-			switch (iSidModel) {
-			case XS_SIDMODEL_6581: VPUTSTR("SID6581"); break;
-			case XS_SIDMODEL_8580: VPUTSTR("SID8580"); break;
-			default: VPUTSTR("Unknown SID"); break;
+		/* Create the string */
+		pcStr = xs_cfg.titleFormat;
+		iIndex = 0;
+		while (*pcStr && (iIndex < VBUFSIZE)) {
+			if (*pcStr == '%') {
+				pcStr++;
+				switch (*pcStr) {
+				case '%':
+					VPUTCH('%');
+					break;
+				case 'f':
+					VPUTSTR(tmpFilename);
+					break;
+				case 'F':
+					VPUTSTR(tmpFilePath);
+					break;
+				case 'e':
+					VPUTSTR(tmpFileExt);
+					break;
+				case 'p':
+					VPUTSTR(infoString1);
+					break;
+				case 't':
+					VPUTSTR(infoString0);
+					break;
+				case 'c':
+					VPUTSTR(infoString2);
+					break;
+				case 's':
+					VPUTSTR(formatString);
+					break;
+				case 'm':
+					switch (iSidModel) {
+					case XS_SIDMODEL_6581:
+						VPUTSTR("SID6581");
+						break;
+					case XS_SIDMODEL_8580:
+						VPUTSTR("SID8580");
+						break;
+					default:
+						VPUTSTR("Unknown SID");
+						break;
+					}
+					break;
+				case 'n':
+					snprintf(tmpStr, VBUFSIZE, "%i", iSubTune);
+					VPUTSTR(tmpStr);
+					break;
+				}
+			} else {
+				VPUTCH(*pcStr);
 			}
-			break;
-		case 'n':
-			snprintf(tmpStr, VBUFSIZE, "%i", iSubTune);
-			VPUTSTR(tmpStr);
-			break;
+			pcStr++;
 		}
-		} else {
-		VPUTCH(*pcStr);
-		}
-	pcStr++;
+
+		tmpBuf[iIndex] = 0;
+
+		/* Make resulting string */
+		pcResult = g_strdup(tmpBuf);
 	}
 
-	tmpBuf[iIndex] = 0;
-
-	/* Make resulting string */
-	pcResult = g_strdup(tmpBuf);
-	}
+	/* Free temporary strings */
+	g_free(tmpFilename);
+	g_free(tmpFilePath);
 
- /* Free temporary strings */
- g_free(tmpFilename);
- g_free(tmpFilePath);
-	
- return pcResult;
+	return pcResult;
 }