char * construct_uri (const char * path, const char * reference)
{
/* URI */
if (strstr (path, "://"))
return str_get (path);
/* absolute filename */
#ifdef _WIN32
if (path[0] && path[1] == ':' && path[2] == '\\')
#else
if (path[0] == '/')
#endif
return filename_to_uri (path);
/* relative path */
const char * slash = strrchr (reference, '/');
if (! slash)
return NULL;
char * utf8 = str_to_utf8 (path, -1);
if (! utf8)
return NULL;
int pathlen = slash + 1 - reference;
char buf[pathlen + 3 * strlen (utf8) + 1];
memcpy (buf, reference, pathlen);
if (get_bool (NULL, "convert_backslash"))
{
SCOPY (tmp, utf8);
str_replace_char (tmp, '\\', '/');
str_encode_percent (tmp, -1, buf + pathlen);
}
else
str_encode_percent (utf8, -1, buf + pathlen);
str_unref (utf8);
return str_get (buf);
}
static void free_lameid3(lameid3_t *p)
{
str_unref (p->track_name);
str_unref (p->album_name);
str_unref (p->performer);
str_unref (p->genre);
str_unref (p->year);
str_unref (p->track_number);
p->track_name = NULL;
p->album_name = NULL;
p->performer = NULL;
p->genre = NULL;
p->year = NULL;
p->track_number = NULL;
}
static void configure_response_cb (void)
{
fileext = gtk_combo_box_get_active(GTK_COMBO_BOX(fileext_combo));
char * temp = gtk_file_chooser_get_uri ((GtkFileChooser *) path_dirbrowser);
str_unref (file_path);
file_path = str_get (temp);
g_free (temp);
use_suffix =
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(use_suffix_toggle));
prependnumber =
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(prependnumber_toggle));
aud_set_int ("filewriter", "fileext", fileext);
aud_set_bool ("filewriter", "filenamefromtags", filenamefromtags);
aud_set_str ("filewriter", "file_path", file_path);
aud_set_bool ("filewriter", "prependnumber", prependnumber);
aud_set_bool ("filewriter", "save_original", save_original);
aud_set_bool ("filewriter", "use_suffix", use_suffix);
}
static void list_get_value (void * user, int row, int column, GValue * value)
{
g_return_if_fail (search_matches);
g_return_if_fail (column >= 0 && column < 2);
g_return_if_fail (row >= 0 && row < search_matches->len);
int playlist = mlp_playlist_get_active ();
int entry = g_array_index (search_matches, int, row);
switch (column)
{
case 0:
g_value_set_int (value, 1 + entry);
break;
case 1:;
char * title = mlp_playlist_entry_get_title (playlist, entry, TRUE);
g_return_if_fail (title);
g_value_set_string (value, title);
str_unref (title);
break;
}
}
static bool_t search_cb (GtkTreeModel * model, int column, const char * key,
GtkTreeIter * iter, void * user)
{
GtkTreePath * path = gtk_tree_model_get_path (model, iter);
g_return_val_if_fail (path, TRUE);
int row = gtk_tree_path_get_indices (path)[0];
gtk_tree_path_free (path);
char * temp = aud_playlist_get_title (row);
g_return_val_if_fail (temp, TRUE);
char * title = g_utf8_strdown (temp, -1);
str_unref (temp);
temp = g_utf8_strdown (key, -1);
char * * keys = g_strsplit (temp, " ", 0);
g_free (temp);
bool_t match = FALSE;
for (int i = 0; keys[i]; i ++)
{
if (! keys[i][0])
continue;
if (strstr (title, keys[i]))
match = TRUE;
else
{
match = FALSE;
break;
}
}
g_free (title);
g_strfreev (keys);
return ! match; /* TRUE == not matched, FALSE == matched */
}
static char * strdup_tuple_field (const Tuple * tuple, int field)
{
char * sval, * dup;
int ival;
switch (tuple_get_value_type (tuple, field, NULL))
{
case TUPLE_INT:
ival = tuple_get_int (tuple, field, NULL);
dup = g_strdup_printf ("%d", ival);
break;
case TUPLE_STRING:
sval = tuple_get_str (tuple, field, NULL);
dup = g_strdup (sval);
str_unref (sval);
break;
default:
dup = NULL;
break;
}
return dup;
}
static void cleanup (void)
{
if (config_win)
gtk_widget_destroy (config_win);
pthread_mutex_lock (& mutex);
aud_set_str ("ladspa", "module_path", module_path);
save_enabled_to_config ();
close_modules ();
index_free (modules);
modules = NULL;
index_free (plugins);
plugins = NULL;
index_free (loadeds);
loadeds = NULL;
str_unref (module_path);
module_path = NULL;
pthread_mutex_unlock (& mutex);
}
bool_t dir_foreach (const char * path, DirForeachFunc func, void * user)
{
DIR * dir = opendir (path);
if (! dir)
return FALSE;
struct dirent * entry;
while ((entry = readdir (dir)))
{
if (entry->d_name[0] == '.')
continue;
char * full = filename_build (path, entry->d_name);
bool_t stop = func (full, entry->d_name, user);
str_unref (full);
if (stop)
break;
}
closedir (dir);
return TRUE;
}
EXPORT void event_queue_cancel_all (void)
{
pthread_mutex_lock (& mutex);
GList * node = events;
while (node)
{
Event * event = node->data;
GList * next = node->next;
g_source_remove (event->source);
events = g_list_delete_link (events, node);
str_unref (event->name);
if (event->destroy)
event->destroy (event->data);
g_slice_free (Event, event);
node = next;
}
pthread_mutex_unlock (& mutex);
}
void ui_playlist_notebook_edit_tab_title(GtkWidget *ebox)
{
if (!gtk_notebook_get_show_tabs(UI_PLAYLIST_NOTEBOOK))
return;
if (ebox == NULL || !GTK_IS_EVENT_BOX(ebox))
{
GtkWidget *page = gtk_notebook_get_nth_page(UI_PLAYLIST_NOTEBOOK, aud_playlist_get_active());
ebox = gtk_notebook_get_tab_label(UI_PLAYLIST_NOTEBOOK, page);
}
GtkWidget *label = g_object_get_data(G_OBJECT(ebox), "label");
GtkWidget *entry = g_object_get_data(G_OBJECT(ebox), "entry");
gtk_widget_hide(label);
gchar * title = aud_playlist_get_title (aud_playlist_get_active ());
gtk_entry_set_text ((GtkEntry *) entry, title);
str_unref (title);
gtk_widget_grab_focus(entry);
gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
gtk_widget_show(entry);
ui_playlist_notebook_tab_title_editing = ebox;
}
void eq_preset_save_auto (void)
{
if (equalizerwin_save_auto_window)
gtk_window_present(GTK_WINDOW(equalizerwin_save_auto_window));
else
equalizerwin_create_list_window(equalizer_auto_presets,
_("Save auto-preset"),
&equalizerwin_save_auto_window,
GTK_SELECTION_SINGLE,
&equalizerwin_save_auto_entry,
audgui_button_new (_("Save"), "document-save", NULL, NULL),
G_CALLBACK(equalizerwin_save_auto_ok),
G_CALLBACK(equalizerwin_save_auto_select));
char * name = aud_drct_get_filename ();
if (name != NULL)
{
char * base = g_path_get_basename (name);
gtk_entry_set_text ((GtkEntry *) equalizerwin_save_auto_entry, base);
g_free (base);
str_unref (name);
}
}
static gboolean file_init (void)
{
aud_config_set_defaults ("filewriter", filewriter_defaults);
fileext = aud_get_int ("filewriter", "fileext");
filenamefromtags = aud_get_bool ("filewriter", "filenamefromtags");
file_path = aud_get_str ("filewriter", "file_path");
prependnumber = aud_get_bool ("filewriter", "prependnumber");
save_original = aud_get_bool ("filewriter", "save_original");
use_suffix = aud_get_bool ("filewriter", "use_suffix");
if (! file_path[0])
{
str_unref (file_path);
file_path = filename_to_uri (g_get_home_dir ());
g_return_val_if_fail (file_path != NULL, FALSE);
}
set_plugin();
if (plugin->init)
plugin->init(&file_write_output);
return TRUE;
}
void
action_equ_save_preset_file(void)
{
GtkWidget *dialog;
gchar *file_uri;
gint i;
dialog = make_filebrowser(_("Save equalizer preset"), TRUE);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
file_uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(dialog));
EqualizerPreset *preset = g_new0(EqualizerPreset, 1);
preset->name = g_strdup(file_uri);
preset->preamp = equalizerwin_get_preamp();
for (i = 0; i < AUD_EQUALIZER_NBANDS; i++)
preset->bands[i] = equalizerwin_get_band(i);
aud_save_preset_file(preset, file_uri);
equalizer_preset_free(preset);
g_free(file_uri);
}
char * songname = aud_drct_get_filename ();
if (songname != NULL)
{
gchar * ext = aud_get_string (NULL, "eqpreset_extension");
gchar * eqname = g_strdup_printf ("%s.%s", songname, ext);
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
eqname);
g_free (eqname);
g_free (ext);
str_unref (songname);
}
gtk_widget_destroy(dialog);
}
static void file_cleanup (void)
{
str_unref (file_path);
file_path = NULL;
}
/* the main alarm thread */
static gboolean alarm_timeout (void * unused)
{
struct tm *currtime;
time_t timenow;
guint today;
AUDDBG("Getting time\n");
timenow = time(NULL);
currtime = localtime(&timenow);
today = currtime->tm_wday;
AUDDBG("Today is %d\n", today);
/* already went off? */
if (timenow < play_start + 60)
return TRUE;
if(alarm_conf.day[today].flags & ALARM_OFF)
return TRUE;
else
{
/* set the alarm_h and alarm_m for today, if not default */
if(!(alarm_conf.day[today].flags & ALARM_DEFAULT))
{
alarm_h = alarm_conf.day[today].hour;
alarm_m = alarm_conf.day[today].min;
}
else
{
alarm_h = alarm_conf.default_hour;
alarm_m = alarm_conf.default_min;
}
}
AUDDBG("Alarm time is %d:%d (def: %d:%d)\n", alarm_h, alarm_m,
alarm_conf.default_hour, alarm_conf.default_min);
AUDDBG("Checking time (%d:%d)\n", currtime->tm_hour, currtime->tm_min);
if((currtime->tm_hour != alarm_h) || (currtime->tm_min != alarm_m))
return TRUE;
if(cmd_on == TRUE)
{
char * cmdstr = aud_get_str ("alarm", "cmdstr");
AUDDBG("Executing %s, cmd_on is true\n", cmdstr);
if(system(cmdstr) == -1)
AUDDBG("Executing %s failed\n",cmdstr);
str_unref (cmdstr);
}
bool_t started = FALSE;
char * playlist = aud_get_str ("alarm", "playlist");
if (playlist[0])
{
aud_drct_pl_open (playlist);
started = TRUE;
}
str_unref (playlist);
if(fading)
{
fader fade_vols;
AUDDBG("Fading is true\n");
aud_drct_set_volume_main(quietvol);
/* start playing */
play_start = time(NULL);
if (! started)
aud_drct_play ();
/* fade volume */
fade_vols.start = quietvol;
fade_vols.end = volume;
//alarm_fade(quietvol, volume);
alarm_thread_create(alarm_fade, &fade_vols, 0);
}
else
{
/* no fading */
/* set volume */
aud_drct_set_volume_main(volume);
/* start playing */
play_start = time(NULL);
aud_drct_play();
}
if(alarm_conf.reminder_on == TRUE)
{
char * reminder_msg = aud_get_str ("alarm", "reminder_msg");
GtkWidget *reminder_dialog;
AUDDBG("Showing reminder '%s'\n", reminder_msg);
reminder_dialog = (GtkWidget*) create_reminder_dialog(reminder_msg);
gtk_widget_show_all(reminder_dialog);
str_unref (reminder_msg);
}
/* bring up the wakeup call dialog if stop_on is set TRUE, this
* has been moved to after making Audacious play so that it doesnt
* get in the way for people with manual window placement turned on
*
* this means that the dialog doesnt get shown until the volume has
* finished fading though !, so thats something else to fix
*/
if(stop_on == TRUE)
{
alarm_dialog = create_alarm_dialog();
AUDDBG("now starting stop thread\n");
stop = alarm_thread_create(alarm_stop_thread, NULL, 0);
AUDDBG("Created wakeup dialog and started stop thread\n");
}
return TRUE;
}
/*
* displays the configuration window and opens the config file.
*/
static void alarm_configure(void)
{
int daynum = 0; // used to loop days
GtkWidget *w;
if (config_dialog)
{
gtk_window_present(GTK_WINDOW(config_dialog));
return;
}
alarm_read_config();
/*
* Create the widgets
*/
config_dialog = create_config_dialog();
w = lookup_widget(config_dialog, "alarm_h_spin");
alarm_conf.alarm_h = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.alarm_h, alarm_h);
w = lookup_widget(config_dialog, "alarm_m_spin");
alarm_conf.alarm_m = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.alarm_m, alarm_m);
w = lookup_widget(config_dialog, "stop_h_spin");
alarm_conf.stop_h = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.stop_h, stop_h);
w = lookup_widget(config_dialog, "stop_m_spin");
alarm_conf.stop_m = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.stop_m, stop_m);
w = lookup_widget(config_dialog, "stop_checkb");
alarm_conf.stop_on = GTK_TOGGLE_BUTTON(w);
gtk_toggle_button_set_active(alarm_conf.stop_on, stop_on);
w = lookup_widget(config_dialog, "vol_scale");
alarm_conf.volume = GTK_RANGE(w);
gtk_range_set_adjustment(alarm_conf.volume,
GTK_ADJUSTMENT(gtk_adjustment_new(volume, 0, 100, 1, 5, 0)));
w = lookup_widget(config_dialog, "quiet_vol_scale");
alarm_conf.quietvol = GTK_RANGE(w);
gtk_range_set_adjustment(alarm_conf.quietvol,
GTK_ADJUSTMENT(gtk_adjustment_new(quietvol, 0, 100, 1, 5, 0)));
/* days of week */
for(; daynum < 7; daynum++)
{
w = lookup_widget(config_dialog, day_cb[daynum]);
alarm_conf.day[daynum].cb = GTK_CHECK_BUTTON(w);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(alarm_conf.day[daynum].cb),
!(alarm_conf.day[daynum].flags & ALARM_OFF));
w = lookup_widget(config_dialog, day_def[daynum]);
alarm_conf.day[daynum].cb_def = GTK_CHECK_BUTTON(w);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(alarm_conf.day[daynum].cb_def),
alarm_conf.day[daynum].flags & ALARM_DEFAULT);
/* Changed to show default time instead of set time when ALARM_DEFAULT set,
* as suggested by Mark Brown
*/
/* w = lookup_widget(config_dialog, day_h[daynum]);
alarm_conf.day[daynum].spin_hr = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.day[daynum].spin_hr, alarm_conf.day[daynum].hour);
w = lookup_widget(config_dialog, day_m[daynum]);
alarm_conf.day[daynum].spin_min = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.day[daynum].spin_min, alarm_conf.day[daynum].min);
*/
if(alarm_conf.day[daynum].flags & ALARM_DEFAULT)
{
w = lookup_widget(config_dialog, day_h[daynum]);
alarm_conf.day[daynum].spin_hr = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.day[daynum].spin_hr, alarm_conf.default_hour);
w = lookup_widget(config_dialog, day_m[daynum]);
alarm_conf.day[daynum].spin_min = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.day[daynum].spin_min, alarm_conf.default_min);
gtk_widget_set_sensitive((GtkWidget *)alarm_conf.day[daynum].spin_hr, FALSE);
gtk_widget_set_sensitive((GtkWidget *)alarm_conf.day[daynum].spin_min, FALSE);
}
else
{
w = lookup_widget(config_dialog, day_h[daynum]);
alarm_conf.day[daynum].spin_hr = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.day[daynum].spin_hr, alarm_conf.day[daynum].hour);
w = lookup_widget(config_dialog, day_m[daynum]);
alarm_conf.day[daynum].spin_min = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.day[daynum].spin_min, alarm_conf.day[daynum].min);
gtk_widget_set_sensitive((GtkWidget *)alarm_conf.day[daynum].spin_hr, TRUE);
gtk_widget_set_sensitive((GtkWidget *)alarm_conf.day[daynum].spin_min, TRUE);
}
}
/* END: days of week */
w = lookup_widget(config_dialog,"fading_spin");
alarm_conf.fading = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.fading, fading);
char * cmdstr = aud_get_str ("alarm", "cmdstr");
w = lookup_widget(config_dialog, "cmd_entry");
alarm_conf.cmdstr = GTK_ENTRY(w);
gtk_entry_set_text(alarm_conf.cmdstr, cmdstr);
str_unref (cmdstr);
w = lookup_widget(config_dialog, "cmd_checkb");
alarm_conf.cmd_on = GTK_TOGGLE_BUTTON(w);
gtk_toggle_button_set_active(alarm_conf.cmd_on, cmd_on);
char * playlist = aud_get_str ("alarm", "playlist");
w = lookup_widget(config_dialog, "playlist");
alarm_conf.playlist = GTK_ENTRY(w);
gtk_entry_set_text(alarm_conf.playlist, playlist);
str_unref (playlist);
char * reminder_msg = aud_get_str ("alarm", "reminder_msg");
w = lookup_widget(config_dialog, "reminder_text");
alarm_conf.reminder = GTK_ENTRY(w);
gtk_entry_set_text(alarm_conf.reminder, reminder_msg);
str_unref (reminder_msg);
w = lookup_widget(config_dialog, "reminder_cb");
alarm_conf.reminder_cb = GTK_TOGGLE_BUTTON(w);
gtk_toggle_button_set_active(alarm_conf.reminder_cb, alarm_conf.reminder_on);
g_signal_connect (config_dialog, "destroy", (GCallback) gtk_widget_destroyed,
& config_dialog);
AUDDBG("END alarm_configure\n");
}
static void
document_finish_read (YelpDocument *document,
const gchar *contents)
{
str_unref (contents);
}
EXPORT void audgui_confirm_playlist_delete (int playlist)
{
GtkWidget * window, * vbox, * hbox, * label, * button;
char * message;
if (aud_get_bool ("audgui", "no_confirm_playlist_delete"))
{
aud_playlist_delete (playlist);
if (playlist > 0)
aud_playlist_set_active (playlist - 1);
return;
}
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint ((GtkWindow *) window,
GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_title ((GtkWindow *) window, _("Close Playlist"));
gtk_window_set_resizable ((GtkWindow *) window, FALSE);
gtk_container_set_border_width ((GtkContainer *) window, 6);
audgui_destroy_on_escape (window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add ((GtkContainer *) window, vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox, hbox, FALSE, FALSE, 0);
gtk_box_pack_start ((GtkBox *) hbox, gtk_image_new_from_stock
(GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG), FALSE, FALSE, 0);
char * title = aud_playlist_get_title (playlist);
message = g_strdup_printf (_("Are you sure you want to close %s? If you "
"do, any changes made since the playlist was exported will be lost."),
title);
str_unref (title);
label = gtk_label_new (message);
g_free (message);
gtk_label_set_line_wrap ((GtkLabel *) label, TRUE);
gtk_widget_set_size_request (label, 320, -1);
gtk_box_pack_start ((GtkBox *) hbox, label, TRUE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox, hbox, FALSE, FALSE, 0);
button = gtk_check_button_new_with_mnemonic (_("_Don't show this message again"));
gtk_box_pack_start ((GtkBox *) hbox, button, FALSE, FALSE, 0);
g_signal_connect (button, "toggled", (GCallback) no_confirm_cb, NULL);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox, hbox, FALSE, FALSE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_NO);
gtk_box_pack_end ((GtkBox *) hbox, button, FALSE, FALSE, 0);
g_signal_connect_swapped (button, "clicked", (GCallback)
gtk_widget_destroy, window);
button = gtk_button_new_from_stock (GTK_STOCK_YES);
gtk_box_pack_end ((GtkBox *) hbox, button, FALSE, FALSE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_grab_focus (button);
g_signal_connect ((GObject *) button, "clicked", (GCallback)
confirm_delete_cb, GINT_TO_POINTER (aud_playlist_get_unique_id (playlist)));
g_signal_connect_swapped ((GObject *) button, "clicked", (GCallback)
gtk_widget_destroy, window);
gtk_widget_show_all (window);
}
static void get_value (void * user, gint row, gint column, GValue * value)
{
PlaylistWidgetData * data = user;
g_return_if_fail (column >= 0 && column < pw_num_cols);
g_return_if_fail (row >= 0 && row < aud_playlist_entry_count (data->list));
column = pw_cols[column];
gchar * title = NULL, * artist = NULL, * album = NULL;
Tuple * tuple = NULL;
if (column == PW_COL_TITLE || column == PW_COL_ARTIST || column ==
PW_COL_ALBUM)
aud_playlist_entry_describe (data->list, row, & title, & artist,
& album, TRUE);
else if (column == PW_COL_YEAR || column == PW_COL_TRACK || column ==
PW_COL_GENRE || column == PW_COL_FILENAME || column == PW_COL_PATH ||
column == PW_COL_BITRATE)
tuple = aud_playlist_entry_get_tuple (data->list, row, TRUE);
switch (column)
{
case PW_COL_NUMBER:
g_value_set_int (value, 1 + row);
break;
case PW_COL_TITLE:
g_value_set_string (value, title);
break;
case PW_COL_ARTIST:
g_value_set_string (value, artist);
break;
case PW_COL_YEAR:
set_int_from_tuple (value, tuple, FIELD_YEAR);
break;
case PW_COL_ALBUM:
g_value_set_string (value, album);
break;
case PW_COL_TRACK:
set_int_from_tuple (value, tuple, FIELD_TRACK_NUMBER);
break;
case PW_COL_GENRE:
set_string_from_tuple (value, tuple, FIELD_GENRE);
break;
case PW_COL_QUEUED:
set_queued (value, data->list, row);
break;
case PW_COL_LENGTH:
set_length (value, data->list, row);
break;
case PW_COL_FILENAME:
set_string_from_tuple (value, tuple, FIELD_FILE_NAME);
break;
case PW_COL_PATH:
set_string_from_tuple (value, tuple, FIELD_FILE_PATH);
break;
case PW_COL_CUSTOM:;
gchar * custom = aud_playlist_entry_get_title (data->list, row, TRUE);
g_value_set_string (value, custom);
str_unref (custom);
break;
case PW_COL_BITRATE:
set_int_from_tuple (value, tuple, FIELD_BITRATE);
break;
}
str_unref (title);
str_unref (artist);
str_unref (album);
if (tuple)
tuple_unref (tuple);
}
void try_init(void) {
bool_t init_success = TRUE;
char *md5_file = aud_get_str (PLUGIN_NAME, MODLAND_ALLMODS_MD5_FILE);
str_unref(md5_file);
char line[LINE_MAX];
if (!strncmp(previous_md5_file, md5_file, FILENAME_MAX)) {
return;
}
DEBUG("Modland allmods_md5.txt location changed\n");
previous_md5_file = md5_file;
initialized = FALSE;
modland_cleanup();
if (!strnlen(md5_file, FILENAME_MAX)) {
DEBUG("Modland allmods_md5.txt location not defined\n");
return;
}
FILE *file = fopen(md5_file, "r");
if (!file) {
ERROR("Could not open modland file %s\n", md5_file);
return;
}
while(fgets(line, LINE_MAX, file)) {
char md5[33];
char path[LINE_MAX];
// sanity check
if (strnlen(line, LINE_MAX) <= 34) {
ERROR("Too short line %s\n", line);
init_success = FALSE;
goto out;
}
strlcpy(md5, line, sizeof(md5));
if (modland_internal_lookup(md5)) {
DEBUG("Duplicate md5: %s", line);
continue;
}
strlcpy(path, line + 33, sizeof(path));
modland_data_t *item = calloc(1, sizeof(modland_data_t));
switch (parse_modland_path(path, item)) {
case 0:
multihash_lookup (&ml_table, str_get(md5), md5_hash(md5), add_cb, NULL, item);
break;
case 1:
continue;
default:
init_success = FALSE;
goto out;
}
TRACE("%s -> format = %s, author = %s, album = %s\n", line, item->format, item->author, item->album);
}
out:
fclose(file);
if (init_success) {
initialized = TRUE;
} else {
modland_cleanup();
}
return;
}
/* do_command(): do @cmd after replacing the format codes
@cmd: command to run */
static void do_command (char * cmd)
{
int playlist = aud_playlist_get_playing ();
int pos = aud_playlist_get_position (playlist);
char *shstring = NULL, *temp, numbuf[32];
gboolean playing;
Formatter *formatter;
if (cmd && strlen(cmd) > 0)
{
formatter = formatter_new();
char * ctitle = aud_playlist_entry_get_title (playlist, pos, FALSE);
if (ctitle)
{
temp = escape_shell_chars (ctitle);
formatter_associate(formatter, 's', temp);
formatter_associate(formatter, 'n', temp);
g_free(temp);
str_unref (ctitle);
}
else
{
formatter_associate(formatter, 's', "");
formatter_associate(formatter, 'n', "");
}
char * filename = aud_playlist_entry_get_filename (playlist, pos);
if (filename)
{
temp = escape_shell_chars (filename);
formatter_associate(formatter, 'f', temp);
g_free(temp);
str_unref (filename);
}
else
formatter_associate(formatter, 'f', "");
g_snprintf(numbuf, sizeof(numbuf), "%02d", pos + 1);
formatter_associate(formatter, 't', numbuf);
int length = aud_playlist_entry_get_length (playlist, pos, FALSE);
if (length > 0)
{
g_snprintf(numbuf, sizeof(numbuf), "%d", length);
formatter_associate(formatter, 'l', numbuf);
}
else
formatter_associate(formatter, 'l', "0");
playing = aud_drct_get_playing();
g_snprintf(numbuf, sizeof(numbuf), "%d", playing);
formatter_associate(formatter, 'p', numbuf);
if (playing)
{
int brate, srate, chans;
aud_drct_get_info (& brate, & srate, & chans);
snprintf (numbuf, sizeof numbuf, "%d", brate);
formatter_associate (formatter, 'r', numbuf);
snprintf (numbuf, sizeof numbuf, "%d", srate);
formatter_associate (formatter, 'F', numbuf);
snprintf (numbuf, sizeof numbuf, "%d", chans);
formatter_associate (formatter, 'c', numbuf);
}
Tuple * tuple = aud_playlist_entry_get_tuple
(aud_playlist_get_active (), pos, 0);
char * artist = tuple ? tuple_get_str (tuple, FIELD_ARTIST, NULL) : NULL;
if (artist)
{
formatter_associate(formatter, 'a', artist);
str_unref(artist);
}
else
formatter_associate(formatter, 'a', "");
char * album = tuple ? tuple_get_str (tuple, FIELD_ALBUM, NULL) : NULL;
if (album)
{
formatter_associate(formatter, 'b', album);
str_unref(album);
}
else
formatter_associate(formatter, 'b', "");
char * title = tuple ? tuple_get_str (tuple, FIELD_TITLE, NULL) : NULL;
if (title)
{
formatter_associate(formatter, 'T', title);
str_unref(title);
}
else
formatter_associate(formatter, 'T', "");
if (tuple)
tuple_unref (tuple);
shstring = formatter_format(formatter, cmd);
formatter_destroy(formatter);
if (shstring)
{
execute_command(shstring);
/* FIXME: This can possibly be freed too early */
g_free(shstring);
}
}
}
static void send_now_playing() {
gchar *error_code = NULL;
gchar *error_detail = NULL;
/*
* now_playing_track can be set to something else while we this method is
* running. Creating a local variable avoids to get data for different tracks,
* while now_playing_track was updated concurrently.
*/
Tuple *curr_track = now_playing_track;
gchar *tab_remover;
gchar *artist = tuple_get_str(curr_track, FIELD_ARTIST, NULL);
gchar *album = tuple_get_str(curr_track, FIELD_ALBUM, NULL);
gchar *title = tuple_get_str(curr_track, FIELD_TITLE, NULL);
tab_remover = remove_tabs(artist);
str_unref(artist);
artist = tab_remover;
tab_remover = remove_tabs(album);
str_unref(album);
album = tab_remover;
tab_remover = remove_tabs(title);
str_unref(title);
title = tab_remover;
tab_remover = NULL;
gchar *number = g_strdup_printf("%i", tuple_get_int(curr_track, FIELD_TRACK_NUMBER, NULL));
gchar *length = g_strdup_printf("%i", tuple_get_int(curr_track, FIELD_LENGTH, NULL) / 1000);
tuple_unref(curr_track);
if (artist != NULL && strlen(artist) > 0 &&
title != NULL && strlen(title) > 0) {
gchar *playingmsg = create_message_to_lastfm("track.updateNowPlaying",
7,
"artist", artist,
"album", (album == NULL ? "" : album),
"track", title,
"trackNumber", number,
"duration", length,
"api_key", SCROBBLER_API_KEY,
"sk", session_key);
g_free(artist);
g_free(album);
g_free(title);
g_free(number);
g_free(length);
bool_t success = send_message_to_lastfm(playingmsg);
g_free(playingmsg);
if (success == FALSE) {
AUDDBG("Network problems. Could not send \"now playing\" to last.fm\n");
scrobbling_enabled = FALSE;
return;
}
if (read_scrobble_result(&error_code, &error_detail) == TRUE) {
//see scrobble_cached_queue()
AUDDBG("NOW PLAYING OK.\n");
} else {
AUDDBG("NOW PLAYING NOT OK. Error code: %s. Error detail: %s.\n", error_code, error_detail);
//From the API: Now Playing requests that fail should not be retried.
if (g_strcmp0(error_code, "9") == 0) {
//Bad Session. Reauth.
//We don't really care about any other errors.
scrobbling_enabled = FALSE;
g_free(session_key);
session_key = NULL;
aud_set_string("scrobbler", "session_key", "");
}
}
g_free(error_code);
g_free(error_detail);
//We don't care if the now playing was not accepted, no need to read the result from the server.
}
}
void describe_song (const char * name, const Tuple * tuple, char * * _title,
char * * _artist, char * * _album)
{
/* Common folder names to skip */
static const char * const skip[] = {"music"};
char * title = get_nonblank_field (tuple, FIELD_TITLE);
char * artist = get_nonblank_field (tuple, FIELD_ARTIST);
char * album = get_nonblank_field (tuple, FIELD_ALBUM);
if (title && artist && album)
{
DONE:
* _title = title;
* _artist = artist;
* _album = album;
return;
}
if (! strncmp (name, "file:///", 8))
{
char * filename = uri_to_display (name);
if (! filename)
goto DONE;
SCOPY (buf, filename);
char * base, * first, * second;
split_filename (skip_top_folders (buf), & base, & first, & second);
if (! title)
title = str_get (base);
for (int i = 0; i < ARRAY_LEN (skip); i ++)
{
if (first && ! g_ascii_strcasecmp (first, skip[i]))
first = NULL;
if (second && ! g_ascii_strcasecmp (second, skip[i]))
second = NULL;
}
if (first)
{
if (second && ! artist && ! album)
{
artist = str_get (second);
album = str_get (first);
}
else if (! artist)
artist = str_get (first);
else if (! album)
album = str_get (first);
}
str_unref (filename);
}
else
{
SCOPY (buf, name);
if (! title)
{
title = str_get_decoded (stream_name (buf));
if (! title)
title = str_get_decoded (buf);
}
else if (! artist)
artist = str_get_decoded (stream_name (buf));
else if (! album)
album = str_get_decoded (stream_name (buf));
}
goto DONE;
}
static int open_handle (struct neon_handle * handle, uint64_t startbyte)
{
int ret;
char * proxy_host = NULL;
int proxy_port = 0;
bool_t use_proxy = aud_get_bool (NULL, "use_proxy");
bool_t use_proxy_auth = aud_get_bool (NULL, "use_proxy_auth");
if (use_proxy)
{
proxy_host = aud_get_str (NULL, "proxy_host");
proxy_port = aud_get_int (NULL, "proxy_port");
}
handle->redircount = 0;
_DEBUG ("<%p> Parsing URL", handle);
if (ne_uri_parse (handle->url, handle->purl) != 0)
{
_ERROR ("<%p> Could not parse URL '%s'", (void *) handle, handle->url);
return -1;
}
while (handle->redircount < 10)
{
if (! handle->purl->port)
handle->purl->port = ne_uri_defaultport (handle->purl->scheme);
_DEBUG ("<%p> Creating session to %s://%s:%d", handle,
handle->purl->scheme, handle->purl->host, handle->purl->port);
handle->session = ne_session_create (handle->purl->scheme,
handle->purl->host, handle->purl->port);
ne_redirect_register (handle->session);
ne_add_server_auth (handle->session, NE_AUTH_BASIC, server_auth_callback, (void *) handle);
ne_set_session_flag (handle->session, NE_SESSFLAG_ICYPROTO, 1);
ne_set_session_flag (handle->session, NE_SESSFLAG_PERSIST, 0);
#ifdef HAVE_NE_SET_CONNECT_TIMEOUT
ne_set_connect_timeout (handle->session, 10);
#endif
ne_set_read_timeout (handle->session, 10);
ne_set_useragent (handle->session, "Audacious/" PACKAGE_VERSION);
if (use_proxy)
{
_DEBUG ("<%p> Using proxy: %s:%d", handle, proxy_host, proxy_port);
ne_session_proxy (handle->session, proxy_host, proxy_port);
if (use_proxy_auth)
{
_DEBUG ("<%p> Using proxy authentication", handle);
ne_add_proxy_auth (handle->session, NE_AUTH_BASIC,
neon_proxy_auth_cb, (void *) handle);
}
}
if (! strcmp ("https", handle->purl->scheme))
{
ne_ssl_trust_default_ca (handle->session);
ne_ssl_set_verify (handle->session,
neon_vfs_verify_environment_ssl_certs, handle->session);
}
_DEBUG ("<%p> Creating request", handle);
ret = open_request (handle, startbyte);
if (! ret)
{
str_unref (proxy_host);
return 0;
}
if (ret == -1)
{
ne_session_destroy (handle->session);
handle->session = NULL;
str_unref (proxy_host);
return -1;
}
_DEBUG ("<%p> Following redirect...", handle);
ne_session_destroy (handle->session);
handle->session = NULL;
}
/* If we get here, our redirect count exceeded */
_ERROR ("<%p> Redirect count exceeded for URL %s", (void *) handle, handle->url);
str_unref (proxy_host);
return 1;
}
static bool_t playlist_load_cue (const char * cue_filename, VFSFile * file,
char * * title, Index * filenames, Index * tuples)
{
void * buffer = NULL;
vfs_file_read_all (file, & buffer, NULL);
if (! buffer)
return FALSE;
* title = NULL;
Cd * cd = cue_parse_string (buffer);
g_free (buffer);
if (cd == NULL)
return FALSE;
int tracks = cd_get_ntrack (cd);
if (tracks == 0)
return FALSE;
Track * current = cd_get_track (cd, 1);
if (current == NULL)
return FALSE;
char * track_filename = track_get_filename (current);
if (track_filename == NULL)
return FALSE;
char * filename = uri_construct (track_filename, cue_filename);
Tuple * base_tuple = NULL;
bool_t base_tuple_scanned = FALSE;
for (int track = 1; track <= tracks; track ++)
{
if (current == NULL || filename == NULL)
return FALSE;
if (base_tuple == NULL && ! base_tuple_scanned)
{
base_tuple_scanned = TRUE;
PluginHandle * decoder = aud_file_find_decoder (filename, FALSE);
if (decoder != NULL)
base_tuple = aud_file_read_tuple (filename, decoder);
}
Track * next = (track + 1 <= tracks) ? cd_get_track (cd, track + 1) : NULL;
char * next_filename = (next != NULL) ? uri_construct
(track_get_filename (next), cue_filename) : NULL;
bool_t last_track = (next_filename == NULL || strcmp (next_filename, filename));
Tuple * tuple = (base_tuple != NULL) ? tuple_copy (base_tuple) :
tuple_new_from_filename (filename);
tuple_set_int (tuple, FIELD_TRACK_NUMBER, track);
int begin = (int64_t) track_get_start (current) * 1000 / 75;
tuple_set_int (tuple, FIELD_SEGMENT_START, begin);
if (last_track)
{
if (base_tuple != NULL && tuple_get_value_type (base_tuple,
FIELD_LENGTH) == TUPLE_INT)
tuple_set_int (tuple, FIELD_LENGTH, tuple_get_int
(base_tuple, FIELD_LENGTH) - begin);
}
else
{
int length = (int64_t) track_get_length (current) * 1000 / 75;
tuple_set_int (tuple, FIELD_LENGTH, length);
tuple_set_int (tuple, FIELD_SEGMENT_END, begin + length);
}
for (int i = 0; i < ARRAY_LEN (pti_map); i ++)
tuple_attach_cdtext (tuple, current, pti_map[i].tuple_type, pti_map[i].pti);
index_insert (filenames, -1, str_get (filename));
index_insert (tuples, -1, tuple);
current = next;
str_unref (filename);
filename = next_filename;
if (last_track && base_tuple != NULL)
{
tuple_unref (base_tuple);
base_tuple = NULL;
base_tuple_scanned = FALSE;
}
}
return TRUE;
}
/* str_unref() may be a macro */
static void str_unref_cb (void * str)
{
str_unref (str);
}
static gint file_open(gint fmt, gint rate, gint nch)
{
gchar *filename = NULL, *temp = NULL;
gchar * directory;
gint pos;
gint rv;
gint playlist;
input.format = fmt;
input.frequency = rate;
input.channels = nch;
playlist = aud_playlist_get_playing ();
if (playlist < 0)
return 0;
pos = aud_playlist_get_position(playlist);
tuple = aud_playlist_entry_get_tuple (playlist, pos, FALSE);
if (tuple == NULL)
return 0;
if (filenamefromtags)
{
gchar * utf8 = aud_playlist_entry_get_title (playlist, pos, FALSE);
string_replace_char (utf8, '/', ' ');
gchar buf[3 * strlen (utf8) + 1];
str_encode_percent (utf8, -1, buf);
str_unref (utf8);
filename = g_strdup (buf);
}
else
{
temp = aud_playlist_entry_get_filename (playlist, pos);
gchar * original = strrchr (temp, '/');
g_return_val_if_fail (original != NULL, 0);
filename = g_strdup (original + 1);
str_unref (temp);
if (!use_suffix)
if ((temp = strrchr(filename, '.')) != NULL)
*temp = '\0';
}
if (prependnumber)
{
gint number = tuple_get_int(tuple, FIELD_TRACK_NUMBER, NULL);
if (!tuple || !number)
number = pos + 1;
temp = g_strdup_printf ("%d%%20%s", number, filename);
g_free(filename);
filename = temp;
}
if (save_original)
{
temp = aud_playlist_entry_get_filename (playlist, pos);
directory = g_strdup (temp);
str_unref (temp);
temp = strrchr (directory, '/');
g_return_val_if_fail (temp != NULL, 0);
temp[1] = 0;
}
else
{
g_return_val_if_fail (file_path[0], 0);
if (file_path[strlen (file_path) - 1] == '/')
directory = g_strdup (file_path);
else
directory = g_strdup_printf ("%s/", file_path);
}
temp = g_strdup_printf ("%s%s.%s", directory, filename, fileext_str[fileext]);
g_free (directory);
g_free (filename);
filename = temp;
output_file = safe_create (filename);
g_free (filename);
if (output_file == NULL)
return 0;
convert_init (fmt, plugin->format_required (fmt), nch);
rv = (plugin->open)();
samples_written = 0;
return rv;
}
static void update_metadata (void * data, GObject * object)
{
char * title = NULL, * artist = NULL, * album = NULL, * file = NULL;
int length = 0;
int playlist = aud_playlist_get_playing ();
int entry = (playlist >= 0) ? aud_playlist_get_position (playlist) : -1;
if (entry >= 0)
{
aud_playlist_entry_describe (playlist, entry, & title, & artist, & album, TRUE);
file = aud_playlist_entry_get_filename (playlist, entry);
length = aud_playlist_entry_get_length (playlist, entry, TRUE);
}
/* pointer comparison works for pooled strings */
if (title == last_title && artist == last_artist && album == last_album &&
file == last_file && length == last_length)
{
str_unref (title);
str_unref (artist);
str_unref (album);
str_unref (file);
return;
}
if (file != last_file)
{
if (image_file)
aud_art_unref (last_file);
image_file = file ? aud_art_get_file (file) : NULL;
}
str_unref (last_title);
str_unref (last_artist);
str_unref (last_album);
str_unref (last_file);
last_title = title;
last_artist = artist;
last_album = album;
last_file = file;
last_length = length;
GVariant * elems[7];
int nelems = 0;
if (title)
{
GVariant * key = g_variant_new_string ("xesam:title");
GVariant * str = g_variant_new_string (title);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (artist)
{
GVariant * key = g_variant_new_string ("xesam:artist");
GVariant * str = g_variant_new_string (artist);
GVariant * array = g_variant_new_array (G_VARIANT_TYPE_STRING, & str, 1);
GVariant * var = g_variant_new_variant (array);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (album)
{
GVariant * key = g_variant_new_string ("xesam:album");
GVariant * str = g_variant_new_string (album);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (file)
{
GVariant * key = g_variant_new_string ("xesam:url");
GVariant * str = g_variant_new_string (file);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (length > 0)
{
GVariant * key = g_variant_new_string ("mpris:length");
GVariant * val = g_variant_new_int64 ((int64_t) length * 1000);
GVariant * var = g_variant_new_variant (val);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (image_file)
{
GVariant * key = g_variant_new_string ("mpris:artUrl");
GVariant * str = g_variant_new_string (image_file);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
GVariant * key = g_variant_new_string ("mpris:trackid");
GVariant * str = g_variant_new_string ("/org/mpris/MediaPlayer2/CurrentTrack");
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
if (! metadata_type)
metadata_type = g_variant_type_new ("{sv}");
GVariant * array = g_variant_new_array (metadata_type, elems, nelems);
g_object_set (object, "metadata", array, NULL);
}
static gboolean xspf_playlist_save (const gchar * filename, VFSFile * file,
const gchar * title, Index * filenames, Index * tuples)
{
gint entries = index_count (filenames);
xmlDocPtr doc;
xmlNodePtr rootnode, tracklist;
gint count;
doc = xmlNewDoc((xmlChar *)"1.0");
doc->charset = XML_CHAR_ENCODING_UTF8;
doc->encoding = xmlStrdup((xmlChar *)"UTF-8");
rootnode = xmlNewNode(NULL, (xmlChar *)XSPF_ROOT_NODE_NAME);
xmlSetProp(rootnode, (xmlChar *)"version", (xmlChar *)"1");
xmlSetProp(rootnode, (xmlChar *)"xmlns", (xmlChar *)XSPF_XMLNS);
/* common */
xmlDocSetRootElement(doc, rootnode);
if (title)
xspf_add_node (rootnode, TUPLE_STRING, FALSE, "title", title, 0);
tracklist = xmlNewNode(NULL, (xmlChar *)"trackList");
xmlAddChild(rootnode, tracklist);
for (count = 0; count < entries; count ++)
{
const gchar * filename = index_get (filenames, count);
const Tuple * tuple = index_get (tuples, count);
xmlNodePtr track, location;
gchar *scratch = NULL;
gint scratchi = 0;
track = xmlNewNode(NULL, (xmlChar *)"track");
location = xmlNewNode(NULL, (xmlChar *)"location");
xmlAddChild(location, xmlNewText((xmlChar *)filename));
xmlAddChild(track, location);
xmlAddChild(tracklist, track);
if (tuple != NULL)
{
gint i;
for (i = 0; i < xspf_nentries; i++) {
const xspf_entry_t *xs = &xspf_entries[i];
gboolean isOK = (tuple_get_value_type (tuple, xs->tupleField,
NULL) == xs->type);
switch (xs->type) {
case TUPLE_STRING:
scratch = tuple_get_str (tuple, xs->tupleField, NULL);
if (! scratch)
isOK = FALSE;
str_unref(scratch);
break;
case TUPLE_INT:
scratchi = tuple_get_int (tuple, xs->tupleField, NULL);
break;
default:
break;
}
if (isOK)
xspf_add_node(track, xs->type, xs->isMeta, xs->xspfName, scratch, scratchi);
}
}
}
xmlSaveCtxt * save = xmlSaveToIO (write_cb, close_cb, file, NULL,
XML_SAVE_FORMAT);
if (! save)
goto ERR;
if (xmlSaveDoc (save, doc) < 0 || xmlSaveClose (save) < 0)
goto ERR;
xmlFreeDoc(doc);
return TRUE;
ERR:
xmlFreeDoc (doc);
return FALSE;
}
static char * fileinfo_recursive_get_image (const char * path,
const SearchParams * params, int depth)
{
DIR * d = opendir (path);
if (! d)
return NULL;
struct dirent * entry;
if (get_bool (NULL, "use_file_cover") && ! depth)
{
/* Look for images matching file name */
while ((entry = readdir (d)))
{
if (entry->d_name[0] == '.')
continue;
char * newpath = filename_build (path, entry->d_name);
if (! g_file_test (newpath, G_FILE_TEST_IS_DIR) &&
has_front_cover_extension (entry->d_name) &&
is_file_image (entry->d_name, params->basename))
{
closedir (d);
return newpath;
}
str_unref (newpath);
}
rewinddir (d);
}
/* Search for files using filter */
while ((entry = readdir (d)))
{
if (entry->d_name[0] == '.')
continue;
char * newpath = filename_build (path, entry->d_name);
if (! g_file_test (newpath, G_FILE_TEST_IS_DIR) &&
has_front_cover_extension (entry->d_name) &&
cover_name_filter (entry->d_name, params->include, TRUE) &&
! cover_name_filter (entry->d_name, params->exclude, FALSE))
{
closedir (d);
return newpath;
}
str_unref (newpath);
}
rewinddir (d);
if (get_bool (NULL, "recurse_for_cover") && depth < get_int (NULL, "recurse_for_cover_depth"))
{
/* Descend into directories recursively. */
while ((entry = readdir (d)))
{
if (entry->d_name[0] == '.')
continue;
char * newpath = filename_build (path, entry->d_name);
if (g_file_test (newpath, G_FILE_TEST_IS_DIR))
{
char * tmp = fileinfo_recursive_get_image (newpath, params, depth + 1);
if (tmp)
{
str_unref (newpath);
closedir (d);
return tmp;
}
}
str_unref (newpath);
}
}
closedir (d);
return NULL;
}
