build_store.c

Aqualung is an advanced music player primarily targeted for the GNU/Linux operating system, but als

			if ((err = regcomp(&fs_compiled, fs_regexp, REG_EXTENDED))) {

				char msg[MAXLEN];
				char * utf8;

				regerror(err, &fs_compiled, msg, MAXLEN);
				utf8 = g_locale_to_utf8(msg, -1, NULL, NULL, NULL);
				gtk_label_set_text(GTK_LABEL(fs_label_error), utf8);
				gtk_widget_show(fs_label_error);
				g_free(utf8);

				regfree(&fs_compiled);

				gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 3);
				gtk_widget_grab_focus(fs_entry_regexp1);

				goto display;
			}

			if (!regexec(&fs_compiled, "", 0, NULL, 0)) {
				gtk_label_set_text(GTK_LABEL(fs_label_error),
						   _("Regexp matches empty string"));
				gtk_widget_show(fs_label_error);
				regfree(&fs_compiled);

				gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 3);
				gtk_widget_grab_focus(fs_entry_regexp1);

				goto display;
			}
		}

		ret = 1;

        } else {
                ret = 0;
        }

        gtk_widget_destroy(dialog);

        return ret;
}


void
prog_window_close(GtkWidget * widget, gpointer data) {

	build_cancelled = 1;

	if (build_prog_window) {
		gtk_widget_destroy(build_prog_window);
		build_prog_window = NULL;
	}
}

void
cancel_build(GtkWidget * widget, gpointer data) {

	prog_window_close(NULL, NULL);
}

gboolean
finish_build(gpointer data) {

	if (build_prog_window) {
		gtk_widget_destroy(build_prog_window);
		build_prog_window = NULL;
	}

	g_strfreev(cap_pre_stringv);
	cap_pre_stringv = NULL;

	g_strfreev(excl_patternv);
	excl_patternv = NULL;

	g_strfreev(incl_patternv);
	incl_patternv = NULL;

	if (!fs_preset) {
		regfree(&fs_compiled);
	}

	build_thread_state = BUILD_THREAD_FREE;

	return FALSE;
}


void
progress_window(void) {

	GtkWidget * table;
	GtkWidget * label;
	GtkWidget * vbox;
	GtkWidget * hbox;
	GtkWidget * hbuttonbox;
	GtkWidget * hseparator;

	char * title = NULL;

	if (build_type == BUILD_STORE) {
		title = _("Building store from filesystem");
	} else {
		title = _("Building artist from filesystem");
	}

	build_prog_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
        gtk_window_set_title(GTK_WINDOW(build_prog_window), title);
        gtk_window_set_position(GTK_WINDOW(build_prog_window), GTK_WIN_POS_CENTER);
        gtk_window_resize(GTK_WINDOW(build_prog_window), 430, 110);
        g_signal_connect(G_OBJECT(build_prog_window), "delete_event",
                         G_CALLBACK(prog_window_close), NULL);
        gtk_container_set_border_width(GTK_CONTAINER(build_prog_window), 5);

        vbox = gtk_vbox_new(FALSE, 0);
        gtk_container_add(GTK_CONTAINER(build_prog_window), vbox);

	table = gtk_table_new(2, 2, FALSE);
        gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);

        hbox = gtk_hbox_new(FALSE, 0);
	label = gtk_label_new(_("Directory:"));
        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
	gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 0, 1,
			 GTK_FILL, GTK_FILL, 5, 5);

        prog_file_entry = gtk_entry_new();
        gtk_editable_set_editable(GTK_EDITABLE(prog_file_entry), FALSE);
	gtk_table_attach(GTK_TABLE(table), prog_file_entry, 1, 2, 0, 1,
			 GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 5);

        hbox = gtk_hbox_new(FALSE, 0);
	label = gtk_label_new(_("Action:"));
        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
	gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 1, 2,
			 GTK_FILL, GTK_FILL, 5, 5);

        hbox = gtk_hbox_new(FALSE, 0);
	prog_action_label = gtk_label_new("");
        gtk_box_pack_start(GTK_BOX(hbox), prog_action_label, FALSE, TRUE, 0);
	gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 1, 2,
			 GTK_FILL, GTK_FILL, 5, 5);

        hseparator = gtk_hseparator_new();
        gtk_box_pack_start(GTK_BOX(vbox), hseparator, FALSE, TRUE, 5);

	hbuttonbox = gtk_hbutton_box_new();
	gtk_box_pack_end(GTK_BOX(vbox), hbuttonbox, FALSE, TRUE, 0);
	gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox), GTK_BUTTONBOX_END);

        prog_cancel_button = gui_stock_label_button (_("Abort"), GTK_STOCK_CANCEL); 
        g_signal_connect(prog_cancel_button, "clicked", G_CALLBACK(cancel_build), NULL);
  	gtk_container_add(GTK_CONTAINER(hbuttonbox), prog_cancel_button);   

        gtk_widget_grab_focus(prog_cancel_button);

        gtk_widget_show_all(build_prog_window);
}

gboolean
set_prog_file_entry(gpointer data) {

	if (build_prog_window) {

		char * utf8 = g_filename_display_name((char *)data);
		gtk_entry_set_text(GTK_ENTRY(prog_file_entry), utf8);
		gtk_widget_grab_focus(prog_cancel_button);
		g_free(utf8);
	}

	return FALSE;
}


gboolean
set_prog_action_label(gpointer data) {

	if (build_prog_window) {
		gtk_label_set_text(GTK_LABEL(prog_action_label), (char *)data);
	}

	return FALSE;
}


static int
filter(const struct dirent * de) {

	return de->d_name[0] != '.';
}


int
is_dir(char * name) {

	struct stat st_file;

	if (stat(name, &st_file) == -1) {
		return 0;
	}

	return S_ISDIR(st_file.st_mode);
}


int
is_reg(char * name) {

	struct stat st_file;

	if (stat(name, &st_file) == -1) {
		return 0;
	}

	return S_ISREG(st_file.st_mode);
}


int
is_all_wspace(char * str) {

	int i;

	for (i = 0; str[i]; i++) {
		if (str[i] != ' ' && str[i] != '\t') {
			return 0;
		}
	}

	return 1;
}

int
is_valid_year(long y) {

	return y > YEAR_MIN && y < YEAR_MAX;
}

int
num_invalid_tracks(build_record_t * record) {

	int invalid = 0;
	build_track_t * ptrack;

	for (ptrack = record->tracks; ptrack; ptrack = ptrack->next) {
		if (!ptrack->valid) {
			invalid++;
		}
	}

	return invalid;
}

void
transform_filename(char * dest, char * src) {

	if (fs_preset) {

		int i;
		char tmp[MAXLEN];
		char * ptmp = tmp;
		
		strncpy(tmp, src, MAXLEN-1);

		if (fs_rm_number) {
			while (*ptmp && (isdigit(*ptmp) || *ptmp == ' ' ||
					 *ptmp == '_' || *ptmp == '-')) {
				ptmp++;
			}
		}

		if (fs_rm_ext) {
			char * c = NULL;
			if ((c = strrchr(tmp, '.')) != NULL) {
				*c = '\0';
			}
		}

		if (fs_underscore) {
			for (i = 0; ptmp[i]; i++) {
				if (ptmp[i] == '_') {
					ptmp[i] = ' ';
				}
			}
		}

		strncpy(dest, ptmp, MAXLEN-1);

	} else {

		int offs = 0;
		regmatch_t regmatch[10];

		dest[0] = '\0';

		while (!regexec(&fs_compiled, src + offs, 10, regmatch, 0)) {
		
			int i = 0;
			int b = strlen(fs_replacement) - 1;

			strncat(dest, src + offs, regmatch[0].rm_so);

			for (i = 0; i < b; i++) {

				if (fs_replacement[i] == '\\' && isdigit(fs_replacement[i+1])) {

					int j = fs_replacement[i+1] - '0';
				
					if (j == 0 || j > fs_compiled.re_nsub) {
						i++;
						continue;
					}
				
					strncat(dest, src + offs + regmatch[j].rm_so,
						regmatch[j].rm_eo - regmatch[j].rm_so);
					i++;
				} else {
					strncat(dest, fs_replacement + i, 1);
				}
			}
			
			strncat(dest, fs_replacement + i, 1);
			offs += regmatch[0].rm_eo;
		}

		if (!*dest) {
			strncpy(dest, src + offs, MAXLEN-1);
		} else {
			strcat(dest, src + offs);
		}
	}
}


void
cap_pre(char * str) {

	int i = 0;
	int len_str = 0;
	gchar * sub = NULL;
	gchar * haystack = NULL;

	if (cap_pre_stringv[0] == NULL) {
		return;
	}

	len_str = strlen(str);
	haystack = g_utf8_strdown(str, -1);

	for (i = 0; cap_pre_stringv[i]; i++) {
		int len_cap = 0;
		int off = 0;
		gchar * needle = NULL;
		gchar * p = NULL;

		if (*(cap_pre_stringv[i]) == '\0') {
			continue;
		}

		len_cap = strlen(cap_pre_stringv[i]);
		needle = g_utf8_strdown(cap_pre_stringv[i], -1);

		while ((sub = strstr(haystack + off, needle)) != NULL) {
			int len_sub = strlen(sub);

			if (((p = g_utf8_find_prev_char(haystack, sub)) == NULL ||
			     !g_unichar_isalpha(g_utf8_get_char(p))) &&
			    ((p = g_utf8_find_next_char(sub + len_cap - 1, NULL)) == NULL ||
			     !g_unichar_isalpha(g_utf8_get_char(p)))) {
				strncpy(str + len_str - len_sub, cap_pre_stringv[i], len_cap);
			}

			off = len_str - len_sub + len_cap;
		}

		g_free(needle);
	}

	g_free(haystack);
}


int
cap_after(gunichar ch) {

	static gunichar * chars = NULL;
	static int chars_set = 0;

	if (!chars_set) {
		chars = (gunichar *)malloc(6 * sizeof(gunichar));
		chars[0] = g_utf8_get_char(" ");
		chars[1] = g_utf8_get_char("\t");
		chars[2] = g_utf8_get_char("(");
		chars[3] = g_utf8_get_char("[");
		chars[4] = g_utf8_get_char("/");
		chars[5] = g_utf8_get_char("\"");
		chars_set = 1;
	}

	int i;

	for (i = 0; i < 6; i++) {
		if (chars[i] == ch) {
			return 1;
		}
	}

	return 0;
}


void
capitalize(char * str) {

	int n;
	gchar * p = str;
	gchar * result = NULL;

	gunichar prev = 0;

	gchar ** stringv = NULL;

	for (n = 0; *p; p = g_utf8_next_char(p)) {
		gunichar ch = g_utf8_get_char(p);
		gunichar new_ch;
		int len;

		if (prev == 0 || (cap_mode == CAP_ALL_WORDS && cap_after(prev))) {
			new_ch = g_unichar_totitle(ch);
		} else {
			if (cap_low_enabled) {
				new_ch = g_unichar_tolower(ch);
			} else {
				new_ch = ch;
			}
		}

		if ((stringv = (gchar **)realloc(stringv, (n + 2) * sizeof(gchar *))) == NULL) {
			fprintf(stderr, "build_store.c: capitalize(): realloc error\n");
			return;
		}

		len = g_unichar_to_utf8(new_ch, NULL);

		if ((*(stringv + n) = (gchar *)malloc((len + 1) * sizeof(gchar))) == NULL) {
			fprintf(stderr, "build_store.c: capitalize(): malloc error\n");
			return;
		}

		g_unichar_to_utf8(new_ch, *(stringv + n));
		*(*(stringv + n) + len) = '\0';

		prev = ch;
		++n;
	}

	if (stringv == NULL) {
		return;
	}

	*(stringv + n) = NULL;

	result = g_strjoinv(NULL, stringv);
	strncpy(str, result, MAXLEN-1);
	g_free(result);

	while (n >= 0) {
		free(*(stringv + n--));
	}

	free(stringv);

	if (cap_pre_enabled) {
		cap_pre(str);
	}
}


void
remove_spaces(char * str) {

	char tmp[MAXLEN];
	int i = 0;
	int j = 0;
	int len = strlen(str);

	for (i = 0; i < len; i++) {
		if (j == 0 && str[i] == ' ') {
			continue;
		}

		if (str[i] != ' ') {