gboolean rs_has_enfuse (gint major, gint minor)
{
FILE *fp;
char line1[128];
char line2[128];
int _major = 0, _minor = 0;
gboolean retval = FALSE;
fp = popen("enfuse -V","r"); /* enfuse 4.0-753b534c819d */
if (fgets(line1, sizeof line1, fp) == NULL)
{
g_warning("fgets returned: %d\n", retval);
return FALSE;
}
pclose(fp);
fp = popen("enfuse -h","r"); /* ==== enfuse, version 3.2 ==== */
if (fgets(line2, sizeof line2, fp) == NULL)
{
g_warning("fgets returned: %d\n", retval);
return FALSE;
}
pclose(fp);
GRegex *regex;
gchar **tokens;
regex = g_regex_new("(enfuse|.* enfuse, version) ([0-9])\x2E([0-9]+).*", 0, 0, NULL);
tokens = g_regex_split(regex, line1, 0);
if (tokens)
{
g_regex_unref(regex);
}
else
{
tokens = g_regex_split(regex, line2, 0);
g_regex_unref(regex);
if (!tokens)
return FALSE;
}
_major = atoi(tokens[2]);
_minor = atoi(tokens[3]);
if (_major > major) {
retval = TRUE;
} else if (_major == major) {
if (_minor >= minor) {
retval = TRUE;
}
}
g_free(tokens);
return retval;
}
char *
gth_script_get_requested_attributes (GthScript *script)
{
GRegex *re;
char **a;
int i, n, j;
char **b;
char *attributes;
re = g_regex_new ("%attr\\{([^}]+)\\}", 0, 0, NULL);
a = g_regex_split (re, script->priv->command, 0);
for (i = 0, n = 0; a[i] != NULL; i++)
if ((i > 0) && (i % 2 == 0))
n++;
if (n == 0)
return NULL;
b = g_new (char *, n + 1);
for (i = 1, j = 0; a[i] != NULL; i += 2, j++) {
b[j] = g_strstrip (a[i]);
}
b[j] = NULL;
attributes = g_strjoinv (",", b);
g_free (b);
g_strfreev (a);
g_regex_unref (re);
return attributes;
}
static char *
create_attribute_list (GList *file_list,
char *match,
gboolean quote_value)
{
GRegex *re;
char **a;
char *attribute = NULL;
gboolean first_value = TRUE;
GString *s;
GList *scan;
re = g_regex_new ("%attr\\{([^}]+)\\}", 0, 0, NULL);
a = g_regex_split (re, match, 0);
if (g_strv_length (a) >= 2)
attribute = g_strstrip (a[1]);
if (attribute == NULL) {
g_strfreev (a);
g_regex_unref (re);
return NULL;
}
s = g_string_new ("");
for (scan = file_list; scan; scan = scan->next) {
GthFileData *file_data = scan->data;
char *value;
char *quoted;
value = gth_file_data_get_attribute_as_string (file_data, attribute);
if (value == NULL)
continue;
if (value != NULL) {
char *tmp_value;
tmp_value = _g_utf8_replace (value, "[\r\n]", " ");
g_free (value);
value = tmp_value;
}
if (quote_value)
quoted = g_shell_quote (value);
else
quoted = g_strdup (value);
if (! first_value)
g_string_append (s, " ");
g_string_append (s, quoted);
first_value = FALSE;
g_free (quoted);
g_free (value);
}
g_strfreev (a);
g_regex_unref (re);
return g_string_free (s, FALSE);
}
static gchar *
normalise_whitespace (const gchar *orig)
{
/* We normalise by the same rules as in intltool:
*
* sub cleanup {
* s/^\s+//;
* s/\s+$//;
* s/\s+/ /g;
* return $_;
* }
*
* $message = join "\n\n", map &cleanup, split/\n\s*\n+/, $message;
*
* Where \s is an ascii space character.
*
* We aim for ease of implementation over efficiency -- this code is
* not run in normal applications.
*/
static GRegex *cleanup[3];
static GRegex *splitter;
gchar **lines;
gchar *result;
gint i;
if (g_once_init_enter (&splitter))
{
GRegex *s;
cleanup[0] = g_regex_new ("^\\s+", 0, 0, 0);
cleanup[1] = g_regex_new ("\\s+$", 0, 0, 0);
cleanup[2] = g_regex_new ("\\s+", 0, 0, 0);
s = g_regex_new ("\\n\\s*\\n+", 0, 0, 0);
g_once_init_leave (&splitter, s);
}
lines = g_regex_split (splitter, orig, 0);
for (i = 0; lines[i]; i++)
{
gchar *a, *b, *c;
a = g_regex_replace_literal (cleanup[0], lines[i], -1, 0, "", 0, 0);
b = g_regex_replace_literal (cleanup[1], a, -1, 0, "", 0, 0);
c = g_regex_replace_literal (cleanup[2], b, -1, 0, " ", 0, 0);
g_free (lines[i]);
g_free (a);
g_free (b);
lines[i] = c;
}
result = g_strjoinv ("\n\n", lines);
g_strfreev (lines);
return result;
}
static char *
get_first_volume_name (const char *name,
const char *pattern,
FirstVolumeExtension extension_type)
{
char *volume_name = NULL;
GRegex *re;
re = g_regex_new (pattern, G_REGEX_CASELESS, 0, NULL);
if (g_regex_match (re, name, 0, NULL)) {
char **parts;
int l, i;
parts = g_regex_split (re, name, 0);
l = strlen (parts[2]);
switch (extension_type) {
case FIRST_VOLUME_IS_000:
for (i = 0; i < l; i++)
parts[2][i] = '0';
break;
case FIRST_VOLUME_IS_001:
for (i = 0; i < l; i++)
parts[2][i] = (i < l - 1) ? '0' : '1';
break;
case FIRST_VOLUME_IS_RAR:
if (g_str_has_suffix (parts[1], "r")) {
parts[2][0] = 'a';
parts[2][1] = 'r';
}
else {
parts[2][0] = 'A';
parts[2][1] = 'R';
}
break;
}
volume_name = g_strjoinv ("", parts);
g_strfreev (parts);
}
g_regex_unref (re);
if (volume_name != NULL) {
char *tmp;
tmp = volume_name;
volume_name = g_filename_from_utf8 (tmp, -1, NULL, NULL, NULL);
g_free (tmp);
}
return volume_name;
}
static gchar * init_dir(char *argv[], gchar *localdir, gchar *fullinstalldir) {
gchar *progname;
gchar *newdir = NULL;
GRegex *regex;
GMatchInfo *match_info;
progname = g_find_program_in_path(argv[0]);
if (progname) {
if (!g_path_is_absolute(progname)) {
gchar *cur_dir = g_get_current_dir();
gchar *prog_absolute;
if (g_str_has_prefix(progname, "." G_DIR_SEPARATOR_S))
prog_absolute = g_build_filename(cur_dir, progname + 2, NULL);
else
prog_absolute = g_build_filename(cur_dir, progname, NULL);
g_free(progname);
g_free(cur_dir);
progname = prog_absolute;
}
static const gchar *gtkpodSEPsrcSEP = "(gtkpod[\x20-\x7E]*)([\\\\/]src[\\\\/])";
regex = g_regex_new (gtkpodSEPsrcSEP, 0, 0, NULL);
if (g_regex_match (regex, progname, 0, &match_info)) {
/* Find the gtkpod* parathesis pattern */
gchar *gtkpoddir = g_match_info_fetch (match_info, 1);
/* Get the base directory by splitting the regex on the pattern */
gchar **tokens = g_regex_split (regex, progname, 0);
newdir = g_build_filename(tokens[0], gtkpoddir, localdir, NULL);
g_free(gtkpoddir);
g_strfreev(tokens);
}
g_match_info_free (match_info);
g_regex_unref (regex);
g_free(progname);
if (newdir && !g_file_test(newdir, G_FILE_TEST_EXISTS)) {
g_free(newdir);
newdir = NULL;
}
}
if (!newdir)
newdir = g_strdup(fullinstalldir);
else {
USING_LOCAL = TRUE;
g_printf(_("Using local %s directory since program was started from source directory:\n%s\n"), localdir, newdir);
}
return newdir;
}
char *
gth_script_get_command_line (GthScript *script,
GtkWindow *parent,
GList *file_list /* GthFileData */,
GError **error)
{
ReplaceData *replace_data;
GRegex *qre;
GRegex *re;
char **a;
GString *command_line;
int i;
char *result;
replace_data = g_new0 (ReplaceData, 1);
replace_data->parent = parent;
replace_data->script = script;
replace_data->file_list = file_list;
replace_data->error = error;
re = g_regex_new ("%U|%F|%B|%N|%E|%P|%ask(\\{[^}]+\\}(\\{[^}]+\\})?)?|%attr\\{[^}]+\\}", 0, 0, NULL);
replace_data->quote_values = FALSE;
command_line = g_string_new ("");
qre = g_regex_new ("%quote\\{([^}]+)\\}", 0, 0, NULL);
a = g_regex_split (qre, script->priv->command, 0);
for (i = 0; a[i] != NULL; i++) {
if (i % 2 == 1) {
char *sub_result;
char *quoted;
sub_result = g_regex_replace_eval (re, a[i], -1, 0, 0, command_line_eval_cb, replace_data, error);
quoted = g_shell_quote (g_strstrip (sub_result));
g_string_append (command_line, quoted);
g_free (quoted);
g_free (sub_result);
}
else
g_string_append (command_line, a[i]);
}
replace_data->quote_values = TRUE;
result = g_regex_replace_eval (re, command_line->str, -1, 0, 0, command_line_eval_cb, replace_data, error);
g_free (replace_data);
g_string_free (command_line, TRUE);
g_regex_unref (qre);
g_regex_unref (re);
return result;
}
static gboolean
rs_has_gimp(gint major, gint minor, gint micro) {
FILE *fp;
char line[128];
int _major, _minor, _micro;
gboolean retval = FALSE;
fp = popen("gimp -v","r");
if (fgets( line, sizeof line, fp) == NULL)
{
g_warning("fgets returned: %d\n", retval);
return FALSE;
}
pclose(fp);
GRegex *regex;
gchar **tokens;
regex = g_regex_new(".*([0-9])\x2E([0-9]+)\x2E([0-9]+).*", 0, 0, NULL);
tokens = g_regex_split(regex, line, 0);
g_regex_unref(regex);
if (tokens[1])
_major = atoi(tokens[1]);
else
{
g_strfreev(tokens);
return FALSE;
}
if (_major > major) {
retval = TRUE;
} else if (_major == major) {
if (tokens[2])
_minor = atoi(tokens[2]);
else
{
g_strfreev(tokens);
return FALSE;
}
if (_minor > minor) {
retval = TRUE;
} else if (_minor == minor) {
if (tokens[3])
_micro = atoi(tokens[3]);
else
{
g_strfreev(tokens);
return FALSE;
}
if (_micro >= micro) {
retval = TRUE;
}
}
}
g_strfreev(tokens);
return retval;
}
int biblio_parse_entries (GuBiblio* bc, gchar *bib_content) {
int entry_total = 0;
GtkTreeIter iter;
GRegex* regex_entry;
GRegex* subregex_ident;
GRegex* subregex_title;
GRegex* subregex_author;
GRegex* subregex_year;
GRegex* regex_formatting;
gchar* author_out = NULL;
gchar* title_out = NULL;
GMatchInfo *match_entry;
regex_entry = g_regex_new (
"(@article|@book|@booklet|@conference|@inbook|@incollection|"
"@inproceedings|@manual|@mastersthesis|@misc|@phdthesis|"
"@proceedings|@techreport|@unpublished)([^@]*)",
(G_REGEX_CASELESS | G_REGEX_DOTALL), 0, NULL);
subregex_ident = g_regex_new ("@.+{([^,]+),", 0, 0, NULL);
subregex_title = g_regex_new
("[^book]title[\\s]*=[\\s]*(.*)", G_REGEX_CASELESS, 0, NULL);
subregex_author = g_regex_new
("author[\\s]*=[\\s]*(.*)", G_REGEX_CASELESS, 0, NULL);
subregex_year = g_regex_new
("year[\\s]*=[\\s]*[{|\"]?([1|2][0-9]{3})", G_REGEX_CASELESS, 0, NULL);
regex_formatting = g_regex_new ("[{|}|\"|,|\\$]", 0, 0, NULL);
g_regex_match (regex_entry, bib_content, 0, &match_entry);
while (g_match_info_matches (match_entry)) {
gchar *entry = g_match_info_fetch (match_entry, 0);
gchar **ident_res = g_regex_split (subregex_ident, entry, 0);
gchar **title_res = g_regex_split (subregex_title, entry, 0);
gchar **author_res = g_regex_split (subregex_author, entry, 0);
gchar **year_res = g_regex_split (subregex_year, entry, 0);
if (author_res[1])
author_out = g_regex_replace (regex_formatting, author_res[1],
-1, 0, "", 0, 0);
else author_out = NULL;
if (title_res[1])
title_out = g_regex_replace (regex_formatting, title_res[1],
-1, 0, "", 0, 0);
else title_out = NULL;
gtk_list_store_append (bc->list_biblios, &iter);
gtk_list_store_set (bc->list_biblios, &iter, 0, ident_res[1],
1, title_out,
2, author_out,
3, year_res[1], -1);
g_free (author_out);
g_free (title_out);
g_strfreev (ident_res);
g_strfreev (title_res);
g_strfreev (author_res);
g_strfreev (year_res);
g_free (entry);
++entry_total;
g_match_info_next (match_entry, NULL);
}
g_match_info_free (match_entry);
g_regex_unref (regex_entry);
g_regex_unref (subregex_ident);
g_regex_unref (subregex_title);
g_regex_unref (subregex_author);
g_regex_unref (subregex_year);
g_regex_unref (regex_formatting);
return entry_total;
}
gboolean rs_has_enfuse (gint major, gint minor)
{
FILE *fp;
char line1[128];
char line2[128];
int _major = 0, _minor = 0;
/* We ignore thread safety here, the worst that can happen is that we check multiple times */
static gboolean cached = FALSE;
static gboolean retval = FALSE;
if (cached)
return retval;
fp = popen("enfuse -V","r"); /* enfuse 4.0-753b534c819d */
if (fp == NULL)
{
cached = TRUE;
retval = FALSE;
return retval;
}
if ((fp == NULL) || (fgets(line1, sizeof line1, fp) == NULL))
{
cached = TRUE;
retval = FALSE;
pclose(fp);
return retval;
}
pclose(fp);
fp = popen("enfuse -h","r"); /* ==== enfuse, version 3.2 ==== */
if (fp == NULL)
{
cached = TRUE;
retval = FALSE;
return retval;
}
if (fgets(line2, sizeof line2, fp) == NULL)
{
cached = TRUE;
retval = FALSE;
pclose(fp);
return retval;
}
pclose(fp);
GRegex *regex;
gchar **tokens;
regex = g_regex_new("(enfuse|.* enfuse, version) ([0-9])\x2E([0-9]+).*", 0, 0, NULL);
tokens = g_regex_split(regex, line1, 0);
if (tokens)
{
g_regex_unref(regex);
}
else
{
tokens = g_regex_split(regex, line2, 0);
g_regex_unref(regex);
if (!tokens)
{
cached = TRUE;
retval = FALSE;
return retval;
}
}
_major = atoi(tokens[2]);
_minor = atoi(tokens[3]);
if (_major > major) {
retval = TRUE;
} else if (_major == major) {
if (_minor >= minor) {
retval = TRUE;
}
}
g_free(tokens);
cached = TRUE;
return retval;
}
static char *
ask_value (ReplaceData *replace_data,
char *match,
GError **error)
{
GthFileData *file_data;
GRegex *re;
char **a;
int len;
char *prompt;
char *default_value;
GtkBuilder *builder;
GtkWidget *dialog;
GthThumbLoader *thumb_loader;
int result;
char *value;
file_data = (GthFileData *) replace_data->file_list->data;
re = g_regex_new ("%ask(\\{([^}]+)\\}(\\{([^}]+)\\})?)?", 0, 0, NULL);
a = g_regex_split (re, match, 0);
len = g_strv_length (a);
if (len >= 3)
prompt = g_strstrip (a[2]);
else
prompt = _("Enter a value:");
if (len >= 5)
default_value = g_strstrip (a[4]);
else
default_value = "";
builder = gtk_builder_new_from_resource ("/org/gnome/gThumb/list_tools/data/ui/ask-value.ui");
dialog = g_object_new (GTK_TYPE_DIALOG,
"title", "",
"transient-for", GTK_WINDOW (replace_data->parent),
"modal", TRUE,
"destroy-with-parent", FALSE,
"use-header-bar", _gtk_settings_get_dialogs_use_header (),
"resizable", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), _gtk_builder_get_widget (builder, "dialog_content"));
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL,
_GTK_LABEL_EXECUTE, GTK_RESPONSE_OK,
(gth_script_for_each_file (replace_data->script) ? _("_Skip") : NULL), GTK_RESPONSE_NO,
NULL);
_gtk_dialog_add_class_to_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_STYLE_CLASS_SUGGESTED_ACTION);
gtk_label_set_text (GTK_LABEL (_gtk_builder_get_widget (builder, "title_label")), gth_script_get_display_name (replace_data->script));
gtk_label_set_text (GTK_LABEL (_gtk_builder_get_widget (builder, "filename_label")), g_file_info_get_display_name (file_data->info));
gtk_label_set_text (GTK_LABEL (_gtk_builder_get_widget (builder, "request_label")), prompt);
gtk_entry_set_text (GTK_ENTRY (_gtk_builder_get_widget (builder, "request_entry")), default_value);
g_object_ref (builder);
thumb_loader = gth_thumb_loader_new (128);
gth_thumb_loader_load (thumb_loader,
file_data,
NULL,
thumb_loader_ready_cb,
builder);
result = gtk_dialog_run (GTK_DIALOG (dialog));
if (result == GTK_RESPONSE_OK) {
value = g_utf8_normalize (gtk_entry_get_text (GTK_ENTRY (_gtk_builder_get_widget (builder, "request_entry"))), -1, G_NORMALIZE_NFC);
}
else {
if (result == GTK_RESPONSE_NO)
*error = g_error_new_literal (GTH_TASK_ERROR, GTH_TASK_ERROR_SKIP_TO_NEXT_FILE, "");
else
*error = g_error_new_literal (GTH_TASK_ERROR, GTH_TASK_ERROR_CANCELLED, "");
value = NULL;
}
gtk_widget_destroy (dialog);
g_object_unref (builder);
g_strfreev (a);
g_regex_unref (re);
return value;
}
/**
* Execute query.
* @param query the query to execute.
* @param playlist set to TRUE to search only songs in the playlist.
*
* @returns the search result in a #MpdData list.
*/
MpdData *advanced_search(const gchar * query, int in_playlist)
{
MpdData *data_return = NULL;
gchar **text = g_regex_split(search_regex, query, 0);
int i = 0;
gboolean found = FALSE;
for (i = 0; text && text[i]; i++)
{
int type;
/* Or sign, if hit, a new query is started */
if (strcmp(text[i], "||") == 0)
{
MpdData *data;
/* Commit the currently in active search and append the results */
if (in_playlist)
data = mpd_playlist_search_commit(connection);
else
data = mpd_database_search_commit(connection);
data_return = mpd_data_concatenate(data_return, data);
found = FALSE;
continue;
}
/* empty element */
if (text[i][0] == '\0')
continue;
/* Parse the tag name. */
type = mpd_misc_get_tag_by_name(g_strstrip(text[i]));
if (type != MPD_TAG_NOT_FOUND && text[i + 1])
{
gchar **split = tokenize_string(text[i + 1]);
int j;
for (j = 0; split && split[j]; j++)
{
if (!found)
{
if (in_playlist)
mpd_playlist_search_start(connection, FALSE);
else
mpd_database_search_start(connection, FALSE);
found = TRUE;
}
if (in_playlist)
mpd_playlist_search_add_constraint(connection, type, g_strstrip(split[j]));
else
mpd_database_search_add_constraint(connection, type, g_strstrip(split[j]));
}
if (split)
g_strfreev(split);
i++;
} else
{
gchar **split = tokenize_string(text[i]);
int j;
for (j = 0; split && split[j]; j++)
{
if (!found)
{
if (in_playlist)
mpd_playlist_search_start(connection, FALSE);
else
mpd_database_search_start(connection, FALSE);
found = TRUE;
}
if (in_playlist)
mpd_playlist_search_add_constraint(connection, MPD_TAG_ITEM_ANY, split[j]);
else
mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ANY, split[j]);
}
if (split)
g_strfreev(split);
}
}
if (text)
g_strfreev(text);
/* Execute the active search and append the results */
if (found)
{
MpdData *data;
if (in_playlist)
data = mpd_playlist_search_commit(connection);
else
data = mpd_database_search_commit(connection);
data_return = mpd_data_concatenate(data_return, data);
}
/* remove possible duplicates (because of concatenating queries) */
return misc_mpddata_remove_duplicate_songs(data_return);
}
void
GStreamerFilter::setCommandProperties (string rest_token)
{
std::vector<std::string> words;
std::vector<std::string>::iterator it;
gchar **elements;
GRegex *regex;
gint i;
GObjectClass *elementClass;
regex = g_regex_new ("([a-zA-Z0-9\\- ]*=[ ]*[a-zA-Z0-9\\-\\/\",=]+)",
G_REGEX_ANCHORED, G_REGEX_MATCH_ANCHORED, NULL);
elements = g_regex_split (regex, rest_token.c_str(),
G_REGEX_MATCH_NOTEMPTY_ATSTART);
g_regex_unref (regex);
i = 0;
while (elements[i] != NULL) {
if (g_strcmp0 (elements [i], "") == 0) {
i++;
continue;
}
std::string aux (elements[i]);
std::string::iterator end_pos = std::remove (aux.begin(), aux.end(), ' ');
aux.erase (end_pos, aux.end() );
words.push_back (aux);
i++;
}
g_strfreev (elements);
elementClass = G_OBJECT_GET_CLASS (this->filter);
regex = g_regex_new ("^([a-zA-Z0-9\\-]+)",
G_REGEX_OPTIMIZE, G_REGEX_MATCH_ANCHORED, NULL);
for (std::string aux : words) {
int i;
GParamSpec *pspec;
elements = g_regex_split (regex, aux.c_str(), G_REGEX_MATCH_NOTEMPTY_ATSTART);
i = 0;
while (elements[i] != NULL) {
i++;
}
if ( i != 3) {
g_strfreev (elements);
continue;
}
pspec = g_object_class_find_property (elementClass, elements[1]);
if (pspec == NULL) {
GST_ERROR ("Property %s not found", elements[1]);
g_strfreev (elements);
continue;
}
if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_STRING) {
g_object_set (G_OBJECT (this->filter), elements[1], (elements[2] + 1), NULL);
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( (G_PARAM_SPEC_VALUE_TYPE (pspec) ) == G_TYPE_BOOLEAN) {
if (g_ascii_strcasecmp ( (elements[2] + 1), "true") == 0 ) {
g_object_set (G_OBJECT (this->filter), elements[1], TRUE, NULL);
}
if (g_ascii_strcasecmp ( (elements[2] + 1), "false") == 0 ) {
g_object_set (G_OBJECT (this->filter), elements[1], FALSE, NULL);
}
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_INT) {
gint aux;
sscanf (elements[2] + 1, "%d", &aux);
g_object_set (G_OBJECT (this->filter), elements[1], aux, NULL);
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_UINT) {
guint aux;
sscanf (elements[2] + 1, "%d", &aux);
g_object_set (G_OBJECT (this->filter), elements[1], aux, NULL);
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_FLOAT) {
gfloat aux;
sscanf (elements[2] + 1, "%f", &aux);
g_object_set (G_OBJECT (this->filter), elements[1], aux, NULL);
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_DOUBLE) {
gdouble aux;
sscanf (elements[2] + 1, "%lf", &aux);
g_object_set (G_OBJECT (this->filter), elements[1], aux, NULL);
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_INT64) {
gint64 aux;
sscanf (elements[2] + 1, "%" G_GINT64_FORMAT, &aux);
g_object_set (G_OBJECT (this->filter), elements[1], aux, NULL);
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_UINT64) {
guint64 aux;
sscanf (elements[2] + 1, "%" G_GUINT64_FORMAT, &aux);
g_object_set (G_OBJECT (this->filter), elements[1], aux, NULL);
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( G_TYPE_IS_ENUM (G_PARAM_SPEC_VALUE_TYPE (pspec) ) ) {
GEnumValue *value;
GEnumClass *enumClass;
gint aux;
enumClass = G_ENUM_CLASS (g_type_class_ref (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
if (enumClass == NULL) {
g_strfreev (elements);
continue;
}
//try to get the enum value from its integer value.
sscanf (elements[2] + 1, "%d", &aux);
value = g_enum_get_value (enumClass, aux);
if (value != NULL) {
g_object_set (G_OBJECT (this->filter), elements[1], value->value, NULL);
GST_DEBUG ("Setting %s = %s as %s, %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ), value->value_nick);
} else {
//try to get the enum value from its name.
value = g_enum_get_value_by_nick (enumClass, elements[2] + 1);
if (value != NULL) {
g_object_set (G_OBJECT (this->filter), elements[1], value->value, NULL);
GST_DEBUG ("Setting %s = %s as %s, %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ), value->value_nick);
} else {
GST_ERROR ("Enum value not found");
}
}
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == GST_TYPE_CAPS) {
GstCaps *caps = gst_caps_from_string ( (elements[2] + 1) );
g_object_set (G_OBJECT (this->filter), elements[1], caps, NULL);
GST_DEBUG ("Setting %s = %" GST_PTR_FORMAT " as %s", elements[1], caps,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
gst_caps_unref (caps);
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == GST_TYPE_STRUCTURE) {
GstStructure *st = gst_structure_new_from_string ( (elements[2] + 1) );
g_object_set (G_OBJECT (this->filter), elements[1], st, NULL);
GST_DEBUG ("Setting %s = %" GST_PTR_FORMAT " as %s", elements[1], st,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
gst_structure_free (st);
} else {
GST_DEBUG ("Unknown param %s = %s as type %s", elements[1],
(elements[2] + 1), g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
}
g_strfreev (elements);
}
g_regex_unref (regex);
words.clear ();
}
static char *
_load_genicam (ArvGvDevice *gv_device, guint32 address, size_t *size)
{
char filename[ARV_GVBS_XML_URL_SIZE];
char **tokens;
char *genicam = NULL;
g_return_val_if_fail (size != NULL, NULL);
*size = 0;
if (!arv_device_read_memory (ARV_DEVICE (gv_device), address, ARV_GVBS_XML_URL_SIZE, filename, NULL))
return NULL;
filename[ARV_GVBS_XML_URL_SIZE - 1] = '\0';
arv_debug_device ("[GvDevice::load_genicam] xml url = '%s' at 0x%x", filename, address);
tokens = g_regex_split (arv_gv_device_get_url_regex (), filename, 0);
if (tokens[0] != NULL) {
if (g_strcmp0 (tokens[1], "File:") == 0)
g_file_get_contents (filename, &genicam, NULL, NULL);
else if (g_strcmp0 (tokens[1], "Local:") == 0 &&
tokens[2] != NULL &&
tokens[3] != NULL &&
tokens[4] != NULL) {
guint32 file_address;
guint32 file_size;
file_address = strtoul (tokens[3], NULL, 16);
file_size = strtoul (tokens[4], NULL, 16);
arv_debug_device ("[GvDevice::load_genicam] Xml address = 0x%x - size = 0x%x - %s",
file_address, file_size, tokens[2]);
if (file_size > 0) {
genicam = g_malloc (file_size);
if (arv_device_read_memory (ARV_DEVICE (gv_device), file_address, file_size,
genicam, NULL)) {
genicam [file_size - 1] = '\0';
if (g_str_has_suffix (tokens[2], ".zip")) {
ArvZip *zip;
const GSList *zip_files;
arv_debug_device ("[GvDevice::load_genicam] Zipped xml data");
zip = arv_zip_new (genicam, file_size);
zip_files = arv_zip_get_file_list (zip);
if (zip_files != NULL) {
const char *zip_filename;
void *tmp_buffer;
size_t tmp_buffer_size;
zip_filename = arv_zip_file_get_name (zip_files->data);
tmp_buffer = arv_zip_get_file (zip, zip_filename,
&tmp_buffer_size);
g_free (genicam);
file_size = tmp_buffer_size;
genicam = tmp_buffer;
} else
arv_warning_device ("[GvDevice::load_genicam] Invalid format");
arv_zip_free (zip);
}
*size = file_size;
} else {
g_free (genicam);
genicam = NULL;
*size = 0;
}
}
}
}
g_strfreev (tokens);
return genicam;
}
static gchar* plank_services_logger_format_message (const gchar* msg) {
gchar* result = NULL;
gboolean _tmp0_ = FALSE;
GRegex* _tmp1_ = NULL;
const gchar* _tmp16_ = NULL;
gchar* _tmp17_ = NULL;
g_return_val_if_fail (msg != NULL, NULL);
_tmp1_ = plank_services_logger_re;
if (_tmp1_ != NULL) {
GRegex* _tmp2_ = NULL;
const gchar* _tmp3_ = NULL;
gboolean _tmp4_ = FALSE;
_tmp2_ = plank_services_logger_re;
_tmp3_ = msg;
_tmp4_ = g_regex_match (_tmp2_, _tmp3_, 0, NULL);
_tmp0_ = _tmp4_;
} else {
_tmp0_ = FALSE;
}
if (_tmp0_) {
gchar** parts = NULL;
GRegex* _tmp5_ = NULL;
const gchar* _tmp6_ = NULL;
gchar** _tmp7_ = NULL;
gchar** _tmp8_ = NULL;
gint parts_length1 = 0;
gint _parts_size_ = 0;
gchar** _tmp9_ = NULL;
gint _tmp9__length1 = 0;
const gchar* _tmp10_ = NULL;
gchar** _tmp11_ = NULL;
gint _tmp11__length1 = 0;
const gchar* _tmp12_ = NULL;
gchar** _tmp13_ = NULL;
gint _tmp13__length1 = 0;
const gchar* _tmp14_ = NULL;
gchar* _tmp15_ = NULL;
_tmp5_ = plank_services_logger_re;
_tmp6_ = msg;
_tmp8_ = _tmp7_ = g_regex_split (_tmp5_, _tmp6_, 0);
parts = _tmp8_;
parts_length1 = _vala_array_length (_tmp7_);
_parts_size_ = parts_length1;
_tmp9_ = parts;
_tmp9__length1 = parts_length1;
_tmp10_ = _tmp9_[1];
_tmp11_ = parts;
_tmp11__length1 = parts_length1;
_tmp12_ = _tmp11_[3];
_tmp13_ = parts;
_tmp13__length1 = parts_length1;
_tmp14_ = _tmp13_[4];
_tmp15_ = g_strdup_printf ("[%s%s] %s", _tmp10_, _tmp12_, _tmp14_);
result = _tmp15_;
parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
return result;
}
_tmp16_ = msg;
_tmp17_ = g_strdup (_tmp16_);
result = _tmp17_;
return result;
}
