skin.c

xmms-1.2.10.tar.gz学习使用的就下吧

	skin_free_pixmap(&skin->shufrep);
	skin_free_pixmap(&skin->text);
	skin_free_pixmap(&skin->volume);
	skin_free_pixmap(&skin->balance);
	skin_free_pixmap(&skin->monostereo);
	skin_free_pixmap(&skin->playpause);
	skin_free_pixmap(&skin->numbers);
	skin_free_pixmap(&skin->posbar);
	skin_free_pixmap(&skin->pledit);
	skin_free_pixmap(&skin->eqmain);
	skin_free_pixmap(&skin->eq_ex);

	if (skin->mask_main)
		gdk_bitmap_unref(skin->mask_main);
	if (skin->mask_main_ds)
		gdk_bitmap_unref(skin->mask_main_ds);
	if (skin->mask_shade)
		gdk_bitmap_unref(skin->mask_shade);
	if (skin->mask_shade_ds)
		gdk_bitmap_unref(skin->mask_shade_ds);
	if (skin->mask_eq)
		gdk_bitmap_unref(skin->mask_eq);
	if (skin->mask_eq_ds)
		gdk_bitmap_unref(skin->mask_eq_ds);
	if (skin->mask_eq_shade)
		gdk_bitmap_unref(skin->mask_eq_shade);
	if (skin->mask_eq_shade_ds)
		gdk_bitmap_unref(skin->mask_eq_shade_ds);

	skin->mask_main = NULL;
	skin->mask_main_ds = NULL;
	skin->mask_shade = NULL;
	skin->mask_shade_ds = NULL;
	skin->mask_eq = NULL;
	skin->mask_eq_ds = NULL;
	skin->mask_eq_shade = NULL;
	skin->mask_eq_shade_ds = NULL;

	if (skin->pledit_normal)
		g_free(skin->pledit_normal);
	if (skin->pledit_current)
		g_free(skin->pledit_current);
	if (skin->pledit_normalbg)
		g_free(skin->pledit_normalbg);
	if (skin->pledit_selectedbg)
		g_free(skin->pledit_selectedbg);

	skin->pledit_normal = NULL;
	skin->pledit_current = NULL;
	skin->pledit_normalbg = NULL;
	skin->pledit_selectedbg = NULL;
	for (i = 0; i < 24; i++)
	{
		skin->vis_color[i][0] = skin_default_viscolor[i][0];
		skin->vis_color[i][1] = skin_default_viscolor[i][1];
		skin->vis_color[i][2] = skin_default_viscolor[i][2];
	}
}

static void skin_load_pixmaps(const char *path)
{
	load_skin_pixmap(&skin->main, path, "main.bmp");
	load_skin_pixmap(&skin->cbuttons, path, "cbuttons.bmp");
	load_skin_pixmap(&skin->titlebar, path, "titlebar.bmp");
	load_skin_pixmap(&skin->shufrep, path, "shufrep.bmp");
	load_skin_pixmap(&skin->text, path, "text.bmp");
	if (skin->text.current_width < 152 || skin->text.current_height < 6)
		skin_get_textcolors(skin->text.def_pixmap,
				    skin->textbg, skin->textfg);
	else
		skin_get_textcolors(skin->text.pixmap,
				    skin->textbg, skin->textfg);
	load_skin_pixmap(&skin->volume, path, "volume.bmp");
	load_skin_pixmap(&skin->balance, path, "balance.bmp");
	if (skin->balance.pixmap == NULL)
		load_skin_pixmap(&skin->balance, path, "volume.bmp");
	load_skin_pixmap(&skin->monostereo, path, "monoster.bmp");
	load_skin_pixmap(&skin->playpause, path, "playpaus.bmp");
	load_skin_pixmap(&skin->numbers, path, "nums_ex.bmp");
	if (skin->numbers.pixmap == NULL)
	{
		load_skin_pixmap(&skin->numbers, path, "numbers.bmp");
		skin_numbers_generate_dash(&skin->numbers);
	}
	load_skin_pixmap(&skin->posbar, path, "posbar.bmp");
	load_skin_pixmap(&skin->pledit, path, "pledit.bmp");
	load_skin_pixmap(&skin->eqmain, path, "eqmain.bmp");
	load_skin_pixmap(&skin->eq_ex, path, "eq_ex.bmp");
	skin->pledit_normal = load_skin_color(path, "pledit.txt", "text", "normal");
	skin->pledit_current = load_skin_color(path, "pledit.txt", "text", "current");
	skin->pledit_normalbg = load_skin_color(path, "pledit.txt", "text", "normalbg");
	skin->pledit_selectedbg = load_skin_color(path, "pledit.txt", "text", "selectedbg");
	skin->mask_main = skin_create_transparent_mask(path, "region.txt", "Normal", mainwin->window, 275, 116, FALSE);
	skin->mask_main_ds = skin_create_transparent_mask(path, "region.txt", "Normal", mainwin->window, 550, 232, TRUE);
	skin->mask_shade = skin_create_transparent_mask(path, "region.txt", "WindowShade", mainwin->window, 275, 14, FALSE);
	skin->mask_shade_ds = skin_create_transparent_mask(path, "region.txt", "WindowShade", mainwin->window, 550, 28, TRUE);
	skin->mask_eq = skin_create_transparent_mask(path, "region.txt", "Equalizer", equalizerwin->window, 275, 116, FALSE);
	skin->mask_eq_ds = skin_create_transparent_mask(path, "region.txt", "Equalizer", equalizerwin->window, 550, 232, TRUE);
	skin->mask_eq_shade = skin_create_transparent_mask(path, "region.txt", "EqualizerWS", equalizerwin->window, 275, 14, FALSE);
	skin->mask_eq_shade_ds = skin_create_transparent_mask(path, "region.txt", "EqualizerWS", equalizerwin->window, 550, 28, TRUE);
	
	load_skin_viscolor(path, "viscolor.txt");
}

/*
 * escape_shell_chars()
 *
 * Escapes characters that are special to the shell inside double quotes.
 */

static char * escape_shell_chars(const char *string)
{
	const char *special = "$`\"\\"; /* Characters to escape */
	const char *in = string;
	char *out, *escaped;
	int num = 0;

	while (*in != '\0')
		if (strchr(special, *in++))
			num++;

	escaped = g_malloc(strlen(string) + num + 1);

	in = string;
	out = escaped;

	while (*in != '\0')
	{
		if (strchr(special, *in))
			*out++ = '\\';
		*out++ = *in++;
	}
	*out = '\0';

	return escaped;
}

static char * skin_decompress_skin(const char* path)
{
	char *tmp = NULL, *tempdir, *unzip, *tar, *ending, *escaped;

	unzip = getenv("UNZIPCMD");
	if (!unzip)
		unzip = "unzip";
	tar = getenv("TARCMD");
	if (!tar)
		tar = "tar";

	if ((ending = strrchr(path, '.')) == NULL)
		return NULL;

	tempdir = g_strconcat(g_get_tmp_dir(), "/xmmsskin.XXXXXXXX", NULL);
	if (!mkdtemp(tempdir))
	{
		g_free(tempdir);
		g_message("Failed to create temporary directory: %s.  Unable to load skin.", strerror(errno));
		return NULL;
	}

	escaped = escape_shell_chars(path);

	if (!strcasecmp(ending, ".zip") || !strcasecmp(ending, ".wsz"))
		tmp = g_strdup_printf("%s >/dev/null -o -j \"%s\" -d %s", unzip, escaped, tempdir);
	if (!strcasecmp(ending, ".tgz") || !strcasecmp(ending, ".gz"))
		tmp = g_strdup_printf("%s >/dev/null xzf \"%s\" -C %s", tar, escaped, tempdir);
	if (!strcasecmp(ending, ".bz2"))
		tmp = g_strdup_printf("bzip2 -dc \"%s\" | %s >/dev/null xf - -C %s", escaped, tar, tempdir);
	if (!strcasecmp(ending, ".tar"))
		tmp = g_strdup_printf("%s >/dev/null xf \"%s\" -C %s", tar, escaped, tempdir);

	system(tmp);
	g_free(escaped);
	g_free(tmp);
	return tempdir;
}
	

static void _load_skin(const gchar * path, gboolean force)
{
	char *ending;

	if (!force)
	{
		if (skin->path && path)
			if (!strcmp(skin->path, path))
				return;
		if (!skin->path && !path)
			return;
		free_skin();
	}
	skin_current_num++;
	if (path)
	{
		skin->path = g_realloc(skin->path, strlen(path) + 1);
		strcpy(skin->path, path);

		ending = strrchr(path, '.');
		if (ending &&
		    (!strcasecmp(ending, ".zip") || !strcasecmp(ending, ".wsz") ||
		     !strcasecmp(ending, ".tgz") || !strcasecmp(ending, ".gz") ||
		     !strcasecmp(ending, ".bz2") || !strcasecmp(ending, ".tar")))
		{
			char *cpath = skin_decompress_skin(path);
			if (cpath != NULL)
			{
				skin_load_pixmaps(cpath);
				del_directory(cpath);
				g_free(cpath);
			}
		}
		else
			skin_load_pixmaps(path);
	}
	else
	{
		if (skin->path)
			g_free(skin->path);
		skin->path = NULL;
	}

	setup_skin_masks();

	draw_main_window(TRUE);
	draw_playlist_window(TRUE);
	draw_equalizer_window(TRUE);
	playlistwin_update_list();
}

void load_skin(const gchar * path)
{
	_load_skin(path, FALSE);
}

void reload_skin(void)
{
	_load_skin(skin->path, TRUE);
}

void cleanup_skins(void)
{
	free_skin();
}

static SkinPixmap *get_skin_pixmap(SkinIndex si)
{
	switch (si)
	{
		case SKIN_MAIN:
			return &skin->main;
		case SKIN_CBUTTONS:
			return &skin->cbuttons;
		case SKIN_TITLEBAR:
			return &skin->titlebar;
		case SKIN_SHUFREP:
			return &skin->shufrep;
		case SKIN_TEXT:
			return &skin->text;
		case SKIN_VOLUME:
			return &skin->volume;
		case SKIN_BALANCE:
			return &skin->balance;
		case SKIN_MONOSTEREO:
			return &skin->monostereo;
		case SKIN_PLAYPAUSE:
			return &skin->playpause;
		case SKIN_NUMBERS:
			return &skin->numbers;
		case SKIN_POSBAR:
			return &skin->posbar;
		case SKIN_PLEDIT:
			return &skin->pledit;
		case SKIN_EQMAIN:
			return &skin->eqmain;
		case SKIN_EQ_EX:
			return &skin->eq_ex;
	}
	g_error("Unable to find skin pixmap");

	return NULL;
}

GdkBitmap* skin_get_mask(MaskIndex mi, gboolean doublesize, gboolean shaded)
{
	GdkBitmap *ret = NULL;
	
	switch (mi)
	{
		case SKIN_MASK_MAIN:
			if (!shaded)
			{
				if (!doublesize)
				{
					ret = skin->mask_main;
					if (!ret)
						ret = skin->def_mask;
				}
				else
				{
					ret = skin->mask_main_ds;
					if (!ret)
						ret = skin->def_mask_ds;
					break;
				}
			}
			else
			{
				if (!doublesize)
				{
					ret = skin->mask_shade;
					if (!ret)
						ret = skin->def_mask_shade;
				}
				else
				{
					ret = skin->mask_shade_ds;
					if (!ret)
						ret = skin->def_mask_shade_ds;
					break;
				}
			}
			break;
		case SKIN_MASK_EQ:
			if (!shaded)
			{
				if (!doublesize)
				{
					ret = skin->mask_eq;
					if (!ret)
						ret = skin->def_mask;
				}
				else
				{
					ret = skin->mask_eq_ds;
					if (!ret)
						ret = skin->def_mask_ds;
				}
			}
			else
			{
				if (!doublesize)
				{
					ret = skin->mask_eq_shade;
					if (!ret)
						ret = skin->def_mask_shade;
				}
				else
				{
					ret = skin->mask_eq_shade_ds;
					if (!ret)
						ret = skin->def_mask_shade_ds;
				}
			}
			break;
	}
	return ret;
}

GdkColor *get_skin_color(SkinColorIndex si)
{
	GdkColor *ret = NULL;

	switch (si)
	{
		case SKIN_PLEDIT_NORMAL:
			ret = skin->pledit_normal;
			if (!ret)
				ret = &skin->def_pledit_normal;
			break;
		case SKIN_PLEDIT_CURRENT:
			ret = skin->pledit_current;
			if (!ret)
				ret = &skin->def_pledit_current;
			break;
		case SKIN_PLEDIT_NORMALBG:
			ret = skin->pledit_normalbg;
			if (!ret)
				ret = &skin->def_pledit_normalbg;
			break;
		case SKIN_PLEDIT_SELECTEDBG:
			ret = skin->pledit_selectedbg;
			if (!ret)
				ret = &skin->def_pledit_selectedbg;
			break;
	        case SKIN_TEXTBG:
			if (skin->text.pixmap)
				ret = skin->textbg;
			else
				ret = skin->def_textbg;
			break;
	        case SKIN_TEXTFG:
			if (skin->text.pixmap)
				ret = skin->textfg;
			else
				ret = skin->def_textfg;
			break;
	}
	return ret;
}

void get_skin_viscolor(guchar vis_color[24][3])
{
	gint i;

	for (i = 0; i < 24; i++)
	{
		vis_color[i][0] = skin->vis_color[i][0];
		vis_color[i][1] = skin->vis_color[i][1];
		vis_color[i][2] = skin->vis_color[i][2];
	}
}

int skin_get_id(void)
{
	return skin_current_num;
}

void skin_draw_pixmap(GdkDrawable *drawable, GdkGC *gc, SkinIndex si,
		      gint xsrc, gint ysrc, gint xdest, gint ydest,
		      gint width, gint height)
{
	SkinPixmap *pixmap = get_skin_pixmap(si);
	GdkPixmap *tmp;

	if (pixmap->pixmap != NULL)
	{
		if (xsrc > pixmap->current_width || ysrc > pixmap->current_height)
			return;

		tmp = pixmap->pixmap;
		width = MIN(width, pixmap->current_width - xsrc);
		height = MIN(height, pixmap->current_height - ysrc);
	}
	else
		tmp = pixmap->def_pixmap;

	gdk_draw_pixmap(drawable, gc, tmp, xsrc, ysrc, xdest, ydest, width, height);
}

void skin_get_eq_spline_colors(guint32 (*colors)[19])
{
	gint i;
	GdkPixmap *pixmap;
	GdkImage *img;

	if (skin->eqmain.pixmap != NULL &&
	    skin->eqmain.current_width >= 116 &&
	    skin->eqmain.current_height >= 313)
		pixmap = skin->eqmain.pixmap;
	else
		pixmap = skin->eqmain.def_pixmap;

	img = gdk_image_get(pixmap, 115, 294, 1, 19);
	
	for (i = 0; i < 19; i++)
		(*colors)[i] = gdk_image_get_pixel(img, 0, i);

	gdk_image_destroy(img);
}