playlistwin.c

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

		GtkWidget *w;
		pos = playlist_list_get_playlist_position(playlistwin_list,
							  event->x, event->y);
		if (pos != -1)
			pos++;
		sensitive = pos != -1;
		w = gtk_item_factory_get_widget(playlistwin_popup_menu,
						"/View File Info");
		gtk_widget_set_sensitive(w, sensitive);

		w = gtk_item_factory_get_widget(playlistwin_popup_menu,
						"/Queue - Unqueue");
		gtk_widget_set_sensitive(w, sensitive);

		playlistwin_set_sensitive_sortmenu();
		playlistwin_set_sensitive_popupmenu();
	
		util_item_factory_popup_with_data(playlistwin_popup_menu,
						  GINT_TO_POINTER(pos), NULL,
						  event->x_root,
						  event->y_root + 5,
						  3, event->time);
		grab = FALSE;
	}
	else if (event->button == 4) /* Scrollwheel up */
		playlistwin_scroll(-3);
	else if(event->button == 5) /* Scrollwheel down */
		playlistwin_scroll(3);
	else
	{
		handle_press_cb(playlistwin_wlist, widget, event);
		draw_playlist_window(FALSE);
	}
	if (grab)
		gdk_pointer_grab(playlistwin->window, FALSE,
				 GDK_BUTTON_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
				 GDK_NONE, GDK_NONE, GDK_CURRENT_TIME);

}

static void playlistwin_focus_in(GtkWidget * widget, GdkEvent * event, gpointer callback_data)
{
	playlistwin_close->pb_allow_draw = TRUE;
	playlistwin_shade->pb_allow_draw = TRUE;
	playlistwin_focus = TRUE;
	draw_playlist_window(TRUE);
}

static void playlistwin_focus_out(GtkWidget * widget, GdkEventButton * event, gpointer callback_data)
{
	playlistwin_close->pb_allow_draw = FALSE;
	playlistwin_shade->pb_allow_draw = FALSE;
	playlistwin_focus = FALSE;
	draw_playlist_window(TRUE);
}

static gboolean playlistwin_configure(GtkWidget * window, GdkEventConfigure *event, gpointer data)
{
	if (!GTK_WIDGET_VISIBLE(window))
		return FALSE;

	if (cfg.show_wm_decorations || hint_move_resize_available())
	{
		if (event->width != cfg.playlist_width ||
		    (event->height != cfg.playlist_height && event->height != 14))
			playlistwin_queue_resize(event->width, event->height);
	}
	
	if (cfg.show_wm_decorations)
		gdk_window_get_root_origin(window->window,
					   &cfg.playlist_x, &cfg.playlist_y);
	else
		gdk_window_get_deskrelative_origin(window->window,
						   &cfg.playlist_x,
						   &cfg.playlist_y);

	return FALSE;
}

void playlistwin_set_back_pixmap()
{
	gdk_window_set_back_pixmap(playlistwin->window, playlistwin_bg, 0);
	gdk_window_clear(playlistwin->window);
}

static int playlistwin_client_event(GtkWidget *w, GdkEventClient *event, gpointer data)
{
	static GdkAtom atom_rcfiles = GDK_NONE;

	if (!atom_rcfiles)
		atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
	if(event->message_type == atom_rcfiles)
	{
		mainwin_set_back_pixmap();
		equalizerwin_set_back_pixmap();
		playlistwin_set_back_pixmap();
		return TRUE;
		
	}
	return FALSE;
}

static int playlistwin_delete(GtkWidget * w, gpointer data)
{
	playlistwin_show(FALSE);
	return TRUE;
}

static void playlistwin_set_hints(void)
{
	GdkGeometry geometry;
	GdkWindowHints mask;

	if (!cfg.show_wm_decorations && !hint_move_resize_available())
		return;

	geometry.min_width = 275;
	geometry.base_width = 275;
	geometry.width_inc = 25;
	geometry.height_inc = 29;
	geometry.max_width = (1 << 16) - 1;
	geometry.max_height = (1 << 16) - 1;
	mask = GDK_HINT_MIN_SIZE | GDK_HINT_RESIZE_INC |
		GDK_HINT_MAX_SIZE | GDK_HINT_BASE_SIZE;
	if (cfg.playlist_shaded)
	{
		geometry.min_height = 14;
		geometry.max_height = 14;
		geometry.base_height = 14;
	}
	else
	{
		geometry.min_height = 116;
		geometry.base_height = 116;
	}

	gtk_window_set_geometry_hints(GTK_WINDOW(playlistwin),
				      playlistwin, &geometry, mask);
}

static void playlistwin_physically_delete_cb(GtkWidget *widget, gpointer data)
{
	GList *node, *selected_list = data;
	int deleted = 0, length;
	char *message = NULL;

	length = g_list_length(selected_list);
	node = selected_list;
	while (node)
	{
		GList *next = g_list_next(node);
		if (unlink(node->data) == 0)
			deleted++;
		else
		{
			if (length == 1)
				message = g_strdup_printf(_("Failed to delete \"%s\": %s."), (char *) selected_list->data, strerror(errno));

			/* The unlink failed, we dont want to remove
			   the file from the playlist either */
			selected_list = g_list_remove_link(selected_list, node);
			g_free(node->data);
			g_list_free_1(node);
		}
		node = next;
	}

	playlist_delete_filenames(selected_list);
	g_list_foreach(selected_list, (GFunc)g_free, NULL);
	g_list_free(selected_list);

	if (length > 1 && deleted < length)
		message = g_strdup_printf(_("%d of %d files successfully deleted."), deleted, length);

	if (message)
	{
		xmms_show_message(_("XMMS: Files deleted"), message, _("Ok"), FALSE, NULL, NULL);
		g_free(message);
	}
}
	
static void playlistwin_physically_delete(void)
{
	GtkWidget *dialog, *vbox, *label, *bbox, *ok, *cancel;
	GList *node, *selected_list = NULL;
	char *text;
	int length;

	PL_LOCK();
	for (node = get_playlist(); node != NULL; node = g_list_next(node))
	{
		PlaylistEntry *entry = node->data;
		/*
		 * We do not want to try to unlink url's
		 */
		if (entry->selected && !strstr(entry->filename, ":/"))
			selected_list = g_list_prepend(selected_list,
						       g_strdup(entry->filename));
	}
	PL_UNLOCK();
	selected_list = g_list_reverse(selected_list);


	if (!selected_list)
		return;

	dialog = gtk_dialog_new();
	gtk_window_set_title(GTK_WINDOW(dialog), _("XMMS: Delete files?"));
	gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);

	vbox = gtk_vbox_new(FALSE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(vbox), 15);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox, TRUE, TRUE, 0);

	length = g_list_length(selected_list);
	if (length > 1)
		text = g_strdup_printf(_("Really delete %d files?"), length);
	else
		text = g_strdup_printf(_("Really delete: \"%s\"?"), (char *) selected_list->data);

	label = gtk_label_new(text);
	g_free(text);
	gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);

	bbox = gtk_hbutton_box_new();
	gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_SPREAD);
	gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), bbox, FALSE, FALSE, 0);

	ok = gtk_button_new_with_label(_("Ok"));
	cancel = gtk_button_new_with_label(_("Cancel"));
	gtk_signal_connect(GTK_OBJECT(ok), "clicked", playlistwin_physically_delete_cb, selected_list);
	gtk_signal_connect_object(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(dialog));
	gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(dialog));
	gtk_box_pack_start(GTK_BOX(bbox), ok, FALSE, FALSE, 0);
	GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
	gtk_box_pack_start(GTK_BOX(bbox), cancel, FALSE, FALSE, 0);
	GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
	gtk_widget_grab_default(ok);

	gtk_widget_show_all(dialog);
}

static void playlistwin_keypress_up_down_handler(PlayList_List *pl, gboolean up, guint state)
{
	if ((state & GDK_MOD1_MASK) && (state & GDK_SHIFT_MASK))
		return;
	if (!(state & GDK_MOD1_MASK))
		playlist_select_all(FALSE);
	
	if (pl->pl_prev_selected == -1 ||
	    (!playlistwin_item_visible(pl->pl_prev_selected) &&
	     !(state & GDK_SHIFT_MASK && pl->pl_prev_min != -1)))
	{
		pl->pl_prev_selected = pl->pl_first;
	}
	else if (state & GDK_SHIFT_MASK)
	{
		if (pl->pl_prev_min == -1)
		{
			pl->pl_prev_max = pl->pl_prev_selected;
			pl->pl_prev_min = pl->pl_prev_selected;
		}
		pl->pl_prev_max += (up ? -1 : 1);
		pl->pl_prev_max =
			CLAMP(pl->pl_prev_max, 0, get_playlist_length() - 1);
		
		pl->pl_first = MIN(pl->pl_first, pl->pl_prev_max);
		pl->pl_first = MAX(pl->pl_first, pl->pl_prev_max -
				   pl->pl_num_visible + 1);
		playlist_select_range(pl->pl_prev_min, pl->pl_prev_max, TRUE);
		return;
	}
	else if (state & GDK_MOD1_MASK)
	{
		if (up)
			playlist_list_move_up(pl);
		else
			playlist_list_move_down(pl);
		
		if (pl->pl_prev_min != -1)
		{
			if (pl->pl_prev_min < pl->pl_first)
				pl->pl_first = pl->pl_prev_min;
			else if (pl->pl_prev_max >= (pl->pl_first + pl->pl_num_visible))
				pl->pl_first = pl->pl_prev_max - pl->pl_num_visible + 1;
		}
		return;
	}
	else if (up)
		pl->pl_prev_selected--;
	else
		pl->pl_prev_selected++;
	
	pl->pl_prev_selected =
		CLAMP(pl->pl_prev_selected, 0, get_playlist_length() - 1);
	
	if (pl->pl_prev_selected < pl->pl_first)
		pl->pl_first--;
	else if (pl->pl_prev_selected >= (pl->pl_first + pl->pl_num_visible))
		pl->pl_first++;
	
	playlist_select_range(pl->pl_prev_selected, pl->pl_prev_selected, TRUE);
	pl->pl_prev_min = -1;

}

static gboolean playlistwin_keypress(GtkWidget * w, GdkEventKey * event, gpointer data)
{
	guint keyval;
	gboolean refresh = TRUE;

	if (cfg.playlist_shaded)
	{
		gtk_widget_event(mainwin, (GdkEvent *) event);
		return TRUE;
	}
	
	switch (keyval = event->keyval)
	{
		case GDK_KP_Up:
		case GDK_KP_Down:
		case GDK_Up:
		case GDK_Down:
			playlistwin_keypress_up_down_handler(
				playlistwin_list,
				keyval == GDK_Up || keyval == GDK_KP_Up,
				event->state);
			break;
		case GDK_Page_Up:
			playlistwin_scroll(-playlistwin_list->pl_num_visible);
			break;
		case GDK_Page_Down:
			playlistwin_scroll(playlistwin_list->pl_num_visible);
			break;
		case GDK_Home:
			playlistwin_list->pl_first = 0;
			break;
		case GDK_End:
			playlistwin_list->pl_first = get_playlist_length() - playlistwin_list->pl_num_visible;
			break;
		case GDK_Return:
			if (playlistwin_list->pl_prev_selected > -1 && playlistwin_item_visible(playlistwin_list->pl_prev_selected))
			{
				playlist_set_position(playlistwin_list->pl_prev_selected);
				if (!get_input_playing())
					playlist_play();
			}
			refresh = FALSE;
			break;
		case GDK_Delete:
			if (event->state & GDK_CONTROL_MASK)
				playlist_delete(TRUE);
			else
				playlist_delete(FALSE);
			refresh = FALSE;
			break;
		case GDK_Insert:
			if(event->state & GDK_SHIFT_MASK)
				playlistwin_show_dirbrowser();
			else if(event->state & GDK_MOD1_MASK)
				playlistwin_show_add_url_window();
			else
				playlistwin_show_filebrowser();
			refresh=FALSE;
			break;
		default:
			if (!gtk_accel_group_activate(playlistwin_accel, event->keyval, event->state))
				gtk_widget_event(mainwin, (GdkEvent *) event);
			refresh = FALSE;
			break;
	}
	if (refresh)
		playlistwin_update_list();

	return TRUE;
}

static void playlistwin_draw_frame(void)
{
	int w, h, y, i, c;
	SkinIndex src;

	w = cfg.playlist_width;
	h = cfg.playlist_height;
	src = SKIN_PLEDIT;

	if (cfg.playlist_shaded)
	{
		skin_draw_pixmap(playlistwin_bg, playlistwin_gc, src, 72, 42, 0, 0, 25, 14);
		c = (w - 75) / 25;
		for (i = 0; i < c; i++)
			skin_draw_pixmap(playlistwin_bg, playlistwin_gc, src, 72, 57, (i * 25) + 25, 0, 25, 14);
		skin_draw_pixmap(playlistwin_bg, playlistwin_gc, src, 99, (!playlistwin_focus && cfg.dim_titlebar) ? 57 : 42, w - 50, 0, 50, 14);
	}
	else
	{
		if (playlistwin_focus || !cfg.dim_titlebar)
			y = 0;
		else
			y = 21;
		/* Titlebar left corner */
		skin_draw_pixmap(playlistwin_bg, playlistwin_gc, src, 0, y, 0, 0, 25, 20);
		c = (w - 150) / 25;
		/* Titlebar, left and right of the title */
		for (i = 0; i < c / 2; i++)
		{
			skin_draw_pixmap(playlistwin_bg, playlistwin_gc, src, 127, y, (i * 25) + 25, 0, 25, 20);
			skin_draw_pixmap(playlistwin_bg, playlistwin_gc, src, 127, y, (i * 25) + (w / 2) + 50, 0, 25, 20);
		}
		if (c & 1)
		{
			skin_draw_pixmap(playlistwin_bg, playlistwin_gc, src, 127, y, ((c / 2) * 25) + 25, 0, 12, 20);
			skin_draw_pixmap(playlistwin_bg, playlistwin_gc, src, 127, y, (w / 2) + ((c / 2) * 25) + 50, 0, 13, 20);
		}

		/* Titlebar title */