main.c

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

	gtk_box_pack_start(GTK_BOX(vbox), bbox, TRUE, TRUE, 0);
	gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
	gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
	gtk_widget_show(bbox);
	jump = gtk_button_new_with_label(_("Jump"));
	GTK_WIDGET_SET_FLAGS(jump, GTK_CAN_DEFAULT);
	gtk_container_add(GTK_CONTAINER(bbox), jump);
	gtk_signal_connect(GTK_OBJECT(jump), "clicked", GTK_SIGNAL_FUNC(mainwin_jump_to_time_cb), time_entry);
	gtk_widget_show(jump);
	cancel = gtk_button_new_with_label(_("Cancel"));
	GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
	gtk_container_add(GTK_CONTAINER(bbox), cancel);
	gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(mainwin_jtt));
	gtk_widget_show(cancel);

	tindex = input_get_time() / 1000;
	sprintf(timestr, "%u:%2.2u", tindex / 60, tindex % 60);
	gtk_entry_set_text(GTK_ENTRY(time_entry), timestr);
	gtk_entry_select_region(GTK_ENTRY(time_entry), 0, strlen(timestr));

	gtk_window_set_modal(GTK_WINDOW(mainwin_jtt), 1);
	gtk_widget_show(mainwin_jtt);
	gtk_widget_grab_focus(time_entry);
	gtk_widget_grab_default(jump);
}

static void mainwin_jump_to_file_real_cb(GtkCList* clist)
{
	if (clist->selection)
	{
		int *pos;

		if (get_input_playing())
			input_stop();
		pos = gtk_clist_get_row_data(clist, GPOINTER_TO_INT(clist->selection->data));
		playlist_set_position(*pos);
		playlist_play();
		gtk_widget_destroy(mainwin_jtf);
	}
}

static void mainwin_jtf_set_qbtn_label(GtkCList *clist, GtkWidget *button)
{
	char *label = _("Queue");

	if (clist->selection)
	{
		int *pos, lpos = GPOINTER_TO_INT(clist->selection->data);
		pos = gtk_clist_get_row_data(clist, lpos);
		if (pos)
		{
			if (playlist_is_position_queued(*pos))
				label = _("Unqueue");
		}
	}
	gtk_widget_set(GTK_WIDGET(button), "label", label, NULL);
}

static void mainwin_jump_to_file_select_row_cb(GtkCList * widget, gint row, gint column, GdkEventButton * event, gpointer cb_data)
{
	if (event && event->button == 1 && event->type == GDK_2BUTTON_PRESS)
		mainwin_jump_to_file_real_cb(widget);
	else
		mainwin_jtf_set_qbtn_label(widget, GTK_WIDGET(cb_data));
}

static void mainwin_jump_to_file_keypress_cb(GtkWidget * widget, GdkEventKey * event, gpointer userdata)
{
	if (event && (event->keyval == GDK_Return))
		mainwin_jump_to_file_real_cb(GTK_CLIST(widget));
	else if (event && (event->keyval == GDK_Escape))
		gtk_widget_destroy(mainwin_jtf);
}

static gboolean mainwin_jump_to_file_entry_keypress_cb(GtkWidget * widget, GdkEventKey * event, gpointer userdata)
{
	GtkCList* clist = GTK_CLIST(userdata);
	gboolean stop = FALSE;

	if (!event)
		return FALSE;
	
	switch (event->keyval)
	{
		case GDK_Return:
			mainwin_jump_to_file_real_cb(clist);
			break;
		case GDK_Escape:
			gtk_widget_destroy(mainwin_jtf);
			break;
		case GDK_Up:
		case GDK_Down:
		case GDK_Page_Up:
		case GDK_Page_Down:
			gtk_widget_event(GTK_WIDGET(clist), (GdkEvent *)event);
			/* Stop the signal or we might lose focus */
			stop = TRUE;
			break;
		case GDK_BackSpace:
		case GDK_Delete:
			if (strlen(gtk_entry_get_text(GTK_ENTRY(widget))) == 0)
				/* Optimization: Ignore delete keys if
                                   the string already is empty */
				stop = TRUE;
			break;
		default:
			return FALSE;
	}

	if (stop)
		gtk_signal_emit_stop_by_name(GTK_OBJECT(widget),
					     "key_press_event");

	return TRUE;
}

static void mainwin_jump_to_file_jump_cb(GtkButton * widget, gpointer userdata)
{
	mainwin_jump_to_file_real_cb(GTK_CLIST(userdata));
}

static void mainwin_jump_to_file_queue_cb(GtkButton * widget, gpointer userdata)
{
	GtkCList *clist = GTK_CLIST(userdata);
	int *pos;

	if (clist->selection)
	{
		int lpos = GPOINTER_TO_INT(clist->selection->data);
		pos = gtk_clist_get_row_data(clist, lpos);
		playlist_queue_position(*pos);
	}	
	mainwin_jtf_set_qbtn_label(clist, GTK_WIDGET(widget));
}

static int mainwin_jump_to_file_match(gchar* song, gchar * keys[], gint nw)
{
	gint i;

	for (i = 0; i < nw; i++)
	{
		if (!strstr(song, keys[i]))
			return 0;
	}

	return 1;
}

static void mainwin_jump_to_file_edit_cb(GtkWidget * widget, gpointer userdata)
{
	char* key;
	GtkCList* clist;
	GList *playlist;
	char *desc_buf;
	int songnr = 0;

	char *words[20];
	int nw = 0, i;
	char* ptr;
	
	PL_LOCK();
	playlist = get_playlist();
	key = g_strdup(gtk_entry_get_text(GTK_ENTRY(widget)));
	clist = GTK_CLIST(userdata);

	/* lowercase the key string */
	g_strdown(key);
	
	/* Chop the key string into ' '-separeted key words */
	for (ptr = key; nw < 20; ptr = strchr(ptr, ' '))
	{
	        if (!ptr)
			break;
		else if (*ptr == ' ')
		{
			while (*ptr == ' ')
			{
		        	*ptr = '\0';
				ptr++;
			}
			words[nw++] = ptr;			
		}
		else
		{
			words[nw++] = ptr;
		}
	}
	
	gtk_clist_freeze(clist);
	gtk_clist_clear(clist);

	while (playlist)
	{
		int match = 0;
		char *title, *filename;

		title = ((PlaylistEntry *) playlist->data)->title;
		filename = ((PlaylistEntry *) playlist->data)->filename;

		if (title)
			desc_buf = title;
		else if (strchr(filename, '/'))
			desc_buf = strrchr(filename, '/') + 1;
		else
                        desc_buf = filename;
		
		/*
		 * Optimize a little since the delay when beginning to
		 * type is annoying.  We'll drop through if the key is
		 * zero length, and if it is a single letter, we'll
		 * take a shortcut and use strchr. This'll save us
		 * from constructing the lowercased song name to
		 * compare. (Note that we cheat and do not compare the
		 * one letter key case-insensitively, but I don't
		 * think anybody notices (or wants to search by one
		 * letter anyway.))
		 *
		 * These (admittedly ugly) hacks help noticeably.
		 *
		 * A further optimization would be to save the
		 * lowercased versions of the filenames rather than
		 * constructing them everytime. This'd take memory, so
		 * I won't do it this time.
		 */
		   
		if (nw == 0 ||                           /* zero char key */
		    (nw == 1 && words[0][0] == '\0') ||  /* zero char key */
		    (nw == 1 && strlen(words[0]) == 1 && /* one char key */
		     ((title && strchr(title, words[0][0])) ||
		      strchr(filename, words[0][0]))))
			match = 1;
		else if (nw == 1 && strlen(words[0]) == 1)
			match = 0;
		else
                {
			char song[256];

			/* Cook up a lowercased string that contains
                           the filename and the (possible) title */
			for (ptr = title, i = 0; ptr && *ptr && i < 254; i++, ptr++)
    				song[i] = tolower(*ptr);
			for (ptr = filename; *ptr && i < 254; i++, ptr++)
				song[i] = tolower(*ptr);
 			song[i] = '\0';

			/* Compare the key words to the string - if
                           all the words match, add to the clist */
			match = mainwin_jump_to_file_match(song, words, nw);
		}

		if (match)
		{
			int row, *data_buf;
			row = gtk_clist_append(clist, &desc_buf);
			data_buf = g_malloc(sizeof (int));
			*data_buf = songnr;
			gtk_clist_set_row_data_full(clist, row, data_buf, g_free);
		}

		songnr++;
		playlist = playlist->next;
	}

	PL_UNLOCK();

	if (cfg.sort_jump_to_file)
	{
		gtk_clist_set_sort_column(clist, 0);
		gtk_clist_set_sort_type(clist, GTK_SORT_ASCENDING);
		gtk_clist_sort(clist);
	}
	gtk_clist_select_row(clist, 0, 0);
	gtk_clist_thaw(clist);

	g_free(key);
}

static void mainwin_jump_to_file(void)
{
	GtkWidget *vbox, *scrollwin, *clist, *sep, *bbox, *jump, *queue, *cancel, *edit, *search_label, *hbox;
	GList *playlist;
	char *title[1];
	gchar *desc_buf;
	gint *data_buf;
	gint row;

	PL_LOCK();
	playlist = get_playlist();

	if (!playlist)
	{
		PL_UNLOCK();
		return;
	}

	mainwin_jtf = gtk_window_new(GTK_WINDOW_DIALOG);
	gtk_window_set_title(GTK_WINDOW(mainwin_jtf), _("Jump to file"));
	gtk_window_set_transient_for(GTK_WINDOW(mainwin_jtf), GTK_WINDOW(mainwin));
	gtk_signal_connect(GTK_OBJECT(mainwin_jtf), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &mainwin_jtf);
	gtk_container_border_width(GTK_CONTAINER(mainwin_jtf), 10);
	gtk_window_set_default_size(GTK_WINDOW(mainwin_jtf), 300, 350);

	vbox = gtk_vbox_new(FALSE, 5);
	gtk_container_add(GTK_CONTAINER(mainwin_jtf), vbox);
	gtk_widget_show(vbox);

	queue = gtk_button_new_with_label(_("Queue"));

	title[0] = _("Files");
	clist = gtk_clist_new_with_titles(1, title);
	gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_BROWSE);
	gtk_signal_connect(GTK_OBJECT(clist), "select_row", GTK_SIGNAL_FUNC(mainwin_jump_to_file_select_row_cb), queue);
	gtk_signal_connect(GTK_OBJECT(clist), "key_press_event", GTK_SIGNAL_FUNC(mainwin_jump_to_file_keypress_cb), NULL);
	hbox = gtk_hbox_new(FALSE, 3);
 	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
 	gtk_widget_show(hbox);
 
 	search_label = gtk_label_new(_("Search: "));
 	gtk_box_pack_start(GTK_BOX(hbox), search_label, FALSE, FALSE, 0);
 	gtk_widget_show(search_label);
 
 	edit = gtk_entry_new();
 	gtk_entry_set_editable(GTK_ENTRY(edit), TRUE);
 	gtk_signal_connect(GTK_OBJECT(edit), "changed", GTK_SIGNAL_FUNC(mainwin_jump_to_file_edit_cb), clist);
 	gtk_signal_connect(GTK_OBJECT(edit), "key_press_event", GTK_SIGNAL_FUNC(mainwin_jump_to_file_entry_keypress_cb), clist);
 	gtk_box_pack_start(GTK_BOX(hbox), edit, TRUE, TRUE, 3);
 	gtk_widget_show(edit);
	
	scrollwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_container_add(GTK_CONTAINER(scrollwin), clist);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
	gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0);
	gtk_widget_set_usize(scrollwin, 330, 200);
	gtk_widget_show(clist);
	gtk_widget_show(scrollwin);

	sep = gtk_hseparator_new();
	gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, FALSE, 0);
	gtk_widget_show(sep);

	bbox = gtk_hbutton_box_new();
	gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
	gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
	gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);

	jump = gtk_button_new_with_label(_("Jump"));
	gtk_box_pack_start(GTK_BOX(bbox), jump, FALSE, FALSE, 0);
	gtk_signal_connect(GTK_OBJECT(jump), "clicked", GTK_SIGNAL_FUNC(mainwin_jump_to_file_jump_cb), clist);
	GTK_WIDGET_SET_FLAGS(jump, GTK_CAN_DEFAULT);
	gtk_widget_show(jump);
	gtk_widget_grab_default(jump);

	gtk_box_pack_start(GTK_BOX(bbox), queue, FALSE, FALSE, 0);
	gtk_signal_connect(GTK_OBJECT(queue), "clicked", GTK_SIGNAL_FUNC(mainwin_jump_to_file_queue_cb), clist);
	GTK_WIDGET_SET_FLAGS(queue, GTK_CAN_DEFAULT);
	gtk_widget_show(queue);

	cancel = gtk_button_new_with_label(_("Close"));
	gtk_box_pack_start(GTK_BOX(bbox), cancel, FALSE, FALSE, 0);
	gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(mainwin_jtf));
	GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
	gtk_widget_show(cancel);
	gtk_widget_show(bbox);

	gtk_clist_clear(GTK_CLIST(clist));

	while (playlist)
	{
		if (((PlaylistEntry *) playlist->data)->ti