static gboolean
dir_pattern_stack_is_match (GList *stack, GFile *file)
{
gboolean match;
GList *list;
GList *name_list;
gboolean directory;
/* Create name list from file */
name_list = dir_cut_filename (file);
directory = g_file_query_file_type (file, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL) == G_FILE_TYPE_DIRECTORY;
/* Include directories by default */
match = directory;
/* Check all valid patterns */
for (list = g_list_last (stack); list != NULL; list = g_list_previous (list))
{
DirPatternList *pat_list = (DirPatternList *)list->data;
GList *node;
/* Mark parent level */
for (node = g_list_first (name_list); node != NULL; node = g_list_next (node))
{
DirMatchString *str = (DirMatchString *)node->data;
str->parent = g_file_equal (pat_list->directory, str->file);
}
for (node = g_list_first (pat_list->pattern); node != NULL; node = g_list_next (node))
{
DirPattern *pat = (DirPattern *)node->data;
GList *pat_part;
GList *name_part;
gboolean match_part;
if (pat->directory && !directory)
continue;
name_part = g_list_first (name_list);
for (pat_part = g_list_first (pat->names); pat_part != NULL; pat_part = g_list_next (pat_part))
{
DirMatchString *part = (DirMatchString *)name_part->data;
match_part = g_pattern_match ((GPatternSpec *)pat_part->data, part->length, part->string, part->reverse);
if (!match_part) break;
name_part = g_list_next (name_part);
}
/* Local match are relative to parent directory only */
if (match_part && pat->local && (!((DirMatchString *)name_part->data)->parent)) match_part = FALSE;
if (match_part) match = pat->match;
}
}
dir_filename_free (name_list);
return match;
}
static void
_eog_util_show_file_in_filemanager_fallback (GFile *file, GdkScreen *screen)
{
gchar *uri = NULL;
GError *error = NULL;
guint32 timestamp = gtk_get_current_event_time ();
if (g_file_query_file_type (file, 0, NULL) == G_FILE_TYPE_DIRECTORY) {
uri = g_file_get_uri (file);
} else {
/* If input file is not a directory we must open it's
folder/parent to avoid opening the file itself */
GFile *parent_file;
parent_file = g_file_get_parent (file);
if (G_LIKELY (parent_file))
uri = g_file_get_uri (parent_file);
g_object_unref (parent_file);
}
if (uri && !gtk_show_uri (screen, uri, timestamp, &error)) {
g_warning ("Couldn't show containing folder \"%s\": %s", uri,
error->message);
g_error_free (error);
}
g_free (uri);
}
static ExtractTest*
extract_test_new (const char *test_name)
{
ExtractTest *extract_test;
g_autoptr (GFile) work_directory = NULL;
GFile *input;
GFile *output;
GFile *reference;
work_directory = g_file_get_child (extract_tests_dir, test_name);
if (g_file_query_file_type (work_directory, G_FILE_QUERY_INFO_NONE, NULL) != G_FILE_TYPE_DIRECTORY) {
g_printerr ("%s: work directory does not exist", test_name);
return NULL;
}
input = g_file_get_child (work_directory, "input");
reference = g_file_get_child (work_directory, "reference");
if (g_file_query_file_type (input, G_FILE_QUERY_INFO_NONE, NULL) != G_FILE_TYPE_DIRECTORY ||
g_file_query_file_type (reference, G_FILE_QUERY_INFO_NONE, NULL) != G_FILE_TYPE_DIRECTORY) {
g_printerr ("%s: input or output directory does not exist\n", test_name);
g_object_unref (input);
return NULL;
}
output = g_file_get_child (work_directory, "output");
remove_directory (output);
g_file_make_directory_with_parents (output, NULL, NULL);
extract_test = g_new0 (ExtractTest, 1);
extract_test->input = input;
extract_test->reference = reference;
extract_test->output = output;
extract_test->unmatched_files = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
g_object_unref);
return extract_test;
}
void
test_utils_add_test_for_all_files (const gchar *prefix,
GFile *base,
GFile *file,
GTestDataFunc test_func,
AddTestFunc add_test_func)
{
GFileEnumerator *enumerator;
GFileInfo *info;
GList *l, *files;
GError *error = NULL;
if (g_file_query_file_type (file, 0, NULL) != G_FILE_TYPE_DIRECTORY)
{
gchar *test_path;
gchar *relative_path;
if (base)
relative_path = g_file_get_relative_path (base, file);
else
relative_path = g_file_get_path (file);
test_path = g_strconcat (prefix, "/", relative_path, NULL);
g_test_add_data_func_full (test_path, g_object_ref (file), test_func, g_object_unref);
return;
}
enumerator = g_file_enumerate_children (file, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &error);
g_assert_no_error (error);
files = NULL;
while ((info = g_file_enumerator_next_file (enumerator, NULL, &error)))
{
GFile *next_file = g_file_get_child (file, g_file_info_get_name (info));
if (add_test_func == NULL || add_test_func (next_file))
{
files = g_list_prepend (files, g_object_ref (next_file));
}
g_object_unref (next_file);
g_object_unref (info);
}
g_assert_no_error (error);
g_object_unref (enumerator);
files = g_list_sort (files, compare_files);
for (l = files; l; l = l->next)
{
test_utils_add_test_for_all_files (prefix, base, l->data, test_func, add_test_func);
}
g_list_free_full (files, g_object_unref);
}
gboolean locke_appmanager_is_valid_application(LockeAppManager *lam,
const gchar *baseDir, const gchar *filename) {
gchar fullpath[2048];
gchar appfolder[2048];
/* calculates app folder*/
strcpy(appfolder, baseDir);
if (appfolder[strlen(baseDir) - 1] != G_DIR_SEPARATOR)
strcat(appfolder, G_DIR_SEPARATOR_S);
strcat(appfolder, filename);
strcat(appfolder, G_DIR_SEPARATOR_S);
/* check for .so existence */
strcpy(fullpath, appfolder);
strcat(fullpath, "lib");
strcat(fullpath, filename);
strcat(fullpath, ".");
strcat(fullpath, DLL_EXT);
GFile *file = g_file_new_for_path(fullpath);
if (g_file_query_file_type(file, G_FILE_QUERY_INFO_NONE, NULL)
!= G_FILE_TYPE_REGULAR) {
g_log(LSVR_DOMAIN, G_LOG_LEVEL_WARNING,
"Application path '%s' doesn't exist or is not a regular file. \nWon't try to deploy it. ",
fullpath);
return FALSE;
}
g_object_unref(file);
/* check for .ini existence */
strcpy(fullpath, appfolder);
strcat(fullpath, filename);
strcat(fullpath, ".ini");
file = g_file_new_for_path(fullpath);
if (g_file_query_file_type(file, G_FILE_QUERY_INFO_NONE, NULL)
!= G_FILE_TYPE_REGULAR) {
g_log(LSVR_DOMAIN, G_LOG_LEVEL_WARNING,
"App config file path '%s' doesn't exist or is not a regular file. \nWon't try to deploy it. ",
fullpath);
return FALSE;
}
g_object_unref(file);
/* All checks completed, app is valid */
g_log(LSVR_DOMAIN, G_LOG_LEVEL_INFO, "Application path '%s' is valid. \nWill try to deploy it. ",
fullpath);
return TRUE;
}
void locke_appmanager_scan_for_deploys(LockeAppManager *lam, GFile *deployDir) {
if (g_file_query_file_type(deployDir, G_FILE_QUERY_INFO_NONE, NULL)
!= G_FILE_TYPE_DIRECTORY) {
g_log(LSVR_DOMAIN, G_LOG_LEVEL_WARNING,
"Hey, autodeploy dir '%s' does not exist!! Create it to be able to make deploys. ",
g_file_get_path(deployDir));
return;
}
g_log(LSVR_DOMAIN, G_LOG_LEVEL_INFO, "Scanning folder '%s' for application deployments",
g_file_get_path(deployDir));
/* Get file enumerator */
GError *err = NULL;
GFileEnumerator *files = g_file_enumerate_children(deployDir, "*",
G_FILE_QUERY_INFO_NONE, NULL, &err);
if (err != NULL) {
/* Report error to user, and free error */
g_log(LSVR_DOMAIN, G_LOG_LEVEL_ERROR, "Unable to get file list for directory '%s': %s",
g_file_get_path(deployDir), err->message);
g_error_free(err);
goto scan_for_deploys_finally;
}
/* process each file individually */
GFileInfo *fileInfo = NULL;
do {
fileInfo = g_file_enumerator_next_file(files, NULL, &err);
if (err != NULL) {
/* Report error to user, and free error */
g_log(LSVR_DOMAIN, G_LOG_LEVEL_ERROR, "Unable to get file for directory '%s': %s",
g_file_get_path(deployDir), err->message);
g_error_free(err);
goto scan_for_deploys_finally;
}
/* stop condition */
if (fileInfo == NULL)
break;
/* finally, process the file */
g_log(LSVR_DOMAIN, G_LOG_LEVEL_INFO, " =========> Processing file '%s'",
g_file_info_get_display_name(fileInfo));
locke_appmanager_add_application(lam, g_file_get_path(deployDir),
g_file_info_get_name(fileInfo));
} while (TRUE);
/* Close open things */
g_file_enumerator_close(files, NULL, &err);
if (err != NULL) {
/* Report error to user, and free error */
g_log(LSVR_DOMAIN, G_LOG_LEVEL_ERROR,
"Error closing file enumerator for directory '%s': %s",
g_file_get_path(deployDir), err->message);
g_error_free(err);
goto scan_for_deploys_finally;
}
/* Free allocated memory */
scan_for_deploys_finally: g_object_unref(files);
}
gboolean
fileops_move (GFile* file_list[], guint num, GFile* dest_dir, gboolean prompt)
{
g_prompt = prompt;
g_move_response = NULL;
gboolean retval = TRUE;
g_debug ("fileops_move: Begin moving files");
GCancellable* move_cancellable = g_cancellable_new ();
TDData* data = g_malloc0 (sizeof (TDData));
data->cancellable = move_cancellable;
for (guint i = 0; i < num; i++)
{
GFile* src = file_list[i];
#if 1
char* src_uri = g_file_get_uri (src);
char* dest_dir_uri = g_file_get_uri (dest_dir);
g_debug ("fileops_move: file %d: %s to dest: %s", i, src_uri, dest_dir_uri);
g_free (src_uri);
g_free (dest_dir_uri);
#endif
//make sure dest_dir is a directory before proceeding.
GFileType type = g_file_query_file_type (dest_dir, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL);
if (type != G_FILE_TYPE_DIRECTORY)
{
//TODO: symbolic links
g_debug ("dest type is not directory");
return FALSE;
}
char* src_basename= g_file_get_basename (src);
GFile* move_dest_file = g_file_get_child (dest_dir, src_basename);
g_free (src_basename);
data->dest_file = move_dest_file;
//retval &= _move_files_async (src, data);
//traverse_directory (dir, _move_files_async, _dummy_func, move_dest_gfile);
retval &= traverse_directory (src, _move_files_async, _dummy_func, data);
// here i must check out if dest has the same file or directory ,if true , fileops_delete,else, nothing do
if (retval)
fileops_delete (&src, 1);//ensure original file is removed.
g_object_unref (move_dest_file);
}
g_object_unref (data->cancellable);
g_free (data);
fileops_response_free (g_move_response);
g_debug ("fileops_move: End moving files");
return retval;
}
static gboolean
get_is_dir_hack (NemoFile *file)
{
gboolean ret = FALSE;
GFile *f = nemo_file_get_location (file);
GFileType type = g_file_query_file_type (f, 0, NULL);
ret = type == G_FILE_TYPE_DIRECTORY;
return ret;
}
static gboolean
dir_project_list_directory (DirProject *project, DirGroup* parent, GError **error)
{
gboolean ok;
GFileEnumerator *enumerator;
enumerator = g_file_enumerate_children (DIR_GROUP_DATA (parent)->base.directory,
G_FILE_ATTRIBUTE_STANDARD_NAME,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL,
error);
ok = enumerator != NULL;
if (ok)
{
GFileInfo *info;
while ((info = g_file_enumerator_next_file (enumerator, NULL, error)) != NULL)
{
const gchar *name;
GFile *file;
name = g_file_info_get_name (info);
file = g_file_get_child (DIR_GROUP_DATA (parent)->base.directory, name);
g_object_unref (info);
/* Check if file is a source */
if (!dir_pattern_stack_is_match (project->sources, file)) continue;
if (g_file_query_file_type (file, G_FILE_QUERY_INFO_NONE, NULL) == G_FILE_TYPE_DIRECTORY)
{
/* Create a group for directory */
DirGroup *group;
group = dir_group_new (file);
g_hash_table_insert (project->groups, g_file_get_uri (file), group);
anjuta_project_node_append (parent, group);
ok = dir_project_list_directory (project, group, error);
if (!ok) break;
}
else
{
/* Create a source for files */
DirSource *source;
source = dir_source_new (file);
anjuta_project_node_append (parent, source);
}
}
g_file_enumerator_close (enumerator, NULL, NULL);
g_object_unref (enumerator);
}
return ok;
}
static void locke_appmanager_file_changed(GFileMonitor *file_monitor,
GFile *child, GFile *other_file, GFileMonitorEvent event_type,
gpointer user_data) {
LockeAppManager *lam = (LockeAppManager *) user_data;
g_log(LSVR_DOMAIN, G_LOG_LEVEL_INFO, "\n-----------------------------------------------------\n");
g_log(LSVR_DOMAIN, G_LOG_LEVEL_INFO, "PID=%d Something has changed at '%s'. \nChecking...", getpid(),
g_file_get_path(lam->deployFolder));
switch (event_type) {
case G_FILE_MONITOR_EVENT_DELETED:
g_log(LSVR_DOMAIN, G_LOG_LEVEL_INFO, "'%s' removed", g_file_get_basename(child));
if (g_file_has_parent(child, lam->deployFolder)) {
char *path = g_file_get_path(child);
g_log(LSVR_DOMAIN, G_LOG_LEVEL_INFO,
" =========> I am going to try to remove the application at path '%s' ",
path);
locke_appmanager_remove_application(lam,
g_file_get_basename(child));
}
break;
case G_FILE_MONITOR_EVENT_CREATED:
g_log(LSVR_DOMAIN, G_LOG_LEVEL_INFO, "'%s' added\n", g_file_get_basename(child));
if (g_file_has_parent(child, lam->deployFolder)) {
char *path = g_file_get_path(child);
g_log(LSVR_DOMAIN, G_LOG_LEVEL_INFO,
" =========> I am going to try to create an application for path '%s' ",
path);
locke_appmanager_add_application(lam,
g_file_get_path(lam->deployFolder),
g_file_get_basename(child));
}
break;
case G_FILE_MONITOR_EVENT_CHANGED:
/* g_log(LSVR_DOMAIN, G_LOG_LEVEL_DEBUG, "'%s' started changing\n", g_file_get_basename(child)); */
break;
case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
/* g_log(LSVR_DOMAIN, G_LOG_LEVEL_DEBUG, "'%s' finished changing\n", g_file_get_basename(child)); */
break;
case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED:
g_log(LSVR_DOMAIN, G_LOG_LEVEL_DEBUG, "'%s' attributes changed\n", g_file_get_basename(child));
/* Process only directories. Files are just ignored. */
if (g_file_query_file_type(child, G_FILE_QUERY_INFO_NONE, NULL)
!= G_FILE_TYPE_DIRECTORY) {
break;
}
locke_appmanager_file_changed(file_monitor, child, other_file,
G_FILE_MONITOR_EVENT_DELETED, user_data);
locke_appmanager_file_changed(file_monitor, child, other_file,
G_FILE_MONITOR_EVENT_CREATED, user_data);
break;
default:
g_log(LSVR_DOMAIN, G_LOG_LEVEL_DEBUG, "'%s' received event %d ", g_file_get_basename(child),
event_type);
break;
}
}
static gboolean
_ostree_bootloader_syslinux_query (OstreeBootloader *bootloader,
gboolean *out_is_active,
GCancellable *cancellable,
GError **error)
{
OstreeBootloaderSyslinux *self = OSTREE_BOOTLOADER_SYSLINUX (bootloader);
*out_is_active = g_file_query_file_type (self->config_path, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL) == G_FILE_TYPE_SYMBOLIC_LINK;
return TRUE;
}
static gboolean
_ostree_bootloader_uboot_query (OstreeBootloader *bootloader,
gboolean *out_is_active,
GCancellable *cancellable,
GError **error)
{
OstreeBootloaderUboot *self = OSTREE_BOOTLOADER_UBOOT (bootloader);
*out_is_active = g_file_query_file_type (self->config_path, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL) == G_FILE_TYPE_REGULAR;
return TRUE;
}
static gboolean dl_sync_dir(mega_node* node, GFile* file, const gchar* remote_path)
{
GError *local_err = NULL;
gchar* local_path = g_file_get_path(file);
if (!g_file_query_exists(file, NULL))
{
g_print("D %s\n", local_path);
if (!opt_dryrun)
{
if (!g_file_make_directory(file, NULL, &local_err))
{
g_printerr("ERROR: Can't create local directory %s: %s\n", local_path, local_err->message);
g_clear_error(&local_err);
return FALSE;
}
}
}
else
{
if (g_file_query_file_type(file, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL) != G_FILE_TYPE_DIRECTORY)
{
g_printerr("ERROR: Can't create local directory %s: file exists\n", local_path);
return FALSE;
}
}
// sync children
GSList* children = mega_session_get_node_chilren(s, node), *i;
for (i = children; i; i = i->next)
{
mega_node* child = i->data;
gchar* child_remote_path = g_strconcat(remote_path, "/", child->name, NULL);
GFile* child_file = g_file_get_child(file, child->name);
if (child->type == MEGA_NODE_FILE)
{
dl_sync_file(child, child_file, child_remote_path);
}
else
{
dl_sync_dir(child, child_file, child_remote_path);
}
g_object_unref(child_file);
g_free(child_remote_path);
}
g_slist_free(children);
return TRUE;
}
static gboolean
thunar_file_info_is_directory (ThunarxFileInfo *file_info)
{
GFileType ftype;
ftype = g_file_query_file_type(THUNAR_PLUGGER_FILE (file_info)->gfile,
G_FILE_QUERY_INFO_NONE,
NULL);
if (G_FILE_TYPE_DIRECTORY == ftype) {
return TRUE;
} else {
return FALSE;
}
}
static void
add_test_for_file (GFile *file)
{
GFileEnumerator *enumerator;
GFileInfo *info;
GList *files;
GError *error = NULL;
if (g_file_query_file_type (file, 0, NULL) != G_FILE_TYPE_DIRECTORY)
{
g_test_add_vtable (g_file_get_path (file),
0,
g_object_ref (file),
NULL,
(GTestFixtureFunc) test_ui_file,
(GTestFixtureFunc) g_object_unref);
return;
}
enumerator = g_file_enumerate_children (file, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &error);
g_assert_no_error (error);
files = NULL;
while ((info = g_file_enumerator_next_file (enumerator, NULL, &error)))
{
const char *filename;
filename = g_file_info_get_name (info);
if (!g_str_has_suffix (filename, ".ui") ||
g_str_has_suffix (filename, ".ref.ui"))
{
g_object_unref (info);
continue;
}
files = g_list_prepend (files, g_file_get_child (file, filename));
g_object_unref (info);
}
g_assert_no_error (error);
g_object_unref (enumerator);
files = g_list_sort (files, compare_files);
g_list_foreach (files, (GFunc) add_test_for_file, NULL);
g_list_free_full (files, g_object_unref);
}
/* Release->Open Materials Folder */
void
action_open_materials_folder(GtkAction *action, I7Story *story)
{
GError *error = NULL;
gchar *uri;
GFile *materials_file = i7_story_get_materials_file(story);
/* Prompt the user to create the folder if it doesn't exist */
if(!g_file_query_exists(materials_file, NULL)) {
/* TRANSLATORS: Release->Open Materials Folder */
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(story),
GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION,
GTK_BUTTONS_OK_CANCEL, _("Could not find Materials folder"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
_("At the moment, this project has no Materials folder - a "
"convenient place to put figures, sounds, manuals, hints or other "
"matter to be packaged up with a release.\n\nWould you like to "
"create one?"));
gint response = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
if(response == GTK_RESPONSE_OK) {
if(!g_file_make_directory_with_parents(materials_file, NULL, &error)) {
/* shouldn't already exist, so don't ignore G_IO_ERROR_EXISTS */
IO_ERROR_DIALOG(GTK_WINDOW(story), materials_file, error, _("creating Materials folder"));
goto finally;
}
file_set_custom_icon(materials_file, "application-x-inform-materials");
} else
goto finally;
}
if(g_file_query_file_type(materials_file, G_FILE_QUERY_INFO_NONE, NULL) != G_FILE_TYPE_DIRECTORY) {
/* Odd; the Materials folder is a file. We open the containing path so
the user can see this and correct it if they like. */
GFile *parent = g_file_get_parent(materials_file);
uri = g_file_get_uri(parent);
g_object_unref(parent);
} else {
uri = g_file_get_uri(materials_file);
}
/* TRANSLATORS: this string is used in error messages and should fit in the
pattern "We couldn't open a program to show ___" */
show_uri_externally(uri, GTK_WINDOW(story), _("the Materials folder"));
g_free(uri);
finally:
g_object_unref(materials_file);
}
AnjutaProjectNode*
amp_source_node_new_valid (GFile *file, AnjutaProjectNodeType type, GError **error)
{
/* Validate source name */
if (g_file_query_file_type (file, G_FILE_QUERY_INFO_NONE, NULL) == G_FILE_TYPE_DIRECTORY)
{
amp_set_error (error, IANJUTA_PROJECT_ERROR_VALIDATION_FAILED,
_("Source file must be a regular file, not a directory"));
return NULL;
}
return amp_source_node_new (file, type);
}
static gboolean
updater_is_dir (GFile *file)
{
GFileType type;
g_return_val_if_fail (file, FALSE);
type = g_file_query_file_type (file, G_FILE_QUERY_INFO_NONE, NULL);
if (type != G_FILE_TYPE_DIRECTORY) {
return FALSE;
}
return TRUE;
}
static void
run_file (GFile* file, GFile* _file_arg)
{
char* cmd_line = NULL;
char* file_path = NULL;
//here we should check the file type
// if the src is symbolink we should set the file_path as the path for it's value
GFileType type = g_file_query_file_type (file, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL);
if (type == G_FILE_TYPE_SYMBOLIC_LINK)
{
//TODO: symbolic links
g_debug("the src file type is G_FILE_TYPE_SYMBOLIC_LINK");
GFileInfo* info = g_file_query_info(file, "standard::*", G_FILE_QUERY_INFO_NONE, NULL, NULL);
if (info != NULL) {
const char * link_target_path = g_file_info_get_symlink_target(info);
g_debug("symbolic link target is :%s",link_target_path);
file_path = g_strdup(link_target_path);
}
g_object_unref(info);
}
else{
file_path = g_file_get_path (file);
}
g_debug("run file_path :%s",file_path);
if (_file_arg != NULL)
{
char* _file_arg_uri = g_file_get_uri (_file_arg);
cmd_line = g_strdup_printf ("%s %s", file_path, _file_arg_uri);
g_free (_file_arg_uri);
}
else
{
cmd_line = g_strdup (file_path);
}
g_free (file_path);
if(cmd_line != NULL)
{
g_spawn_command_line_async (cmd_line, NULL);
}
else
{
g_warning("run file_path is null");
}
g_free (cmd_line);
}
void search_directory(const gchar *path, GSList **list, int n_params, const gchar **mimes)
{
GFile *file = NULL;
GFileInfo *next_file;
GFileType type;
GFileEnumerator *listing;
const gchar *next_path;
const gchar *file_mime;
gchar *full_path = NULL;
MediaInfo *media;
guint i;
file = g_file_new_for_path(path);
type = g_file_query_file_type(file, G_FILE_QUERY_INFO_NONE, NULL);
if (type == G_FILE_TYPE_DIRECTORY) {
/* Enumerate children (needs less query flags!) */
listing = g_file_enumerate_children(file, "standard::*", G_FILE_QUERY_INFO_NONE,
NULL, NULL);
/* Lets go through them */
while ((next_file = g_file_enumerator_next_file(listing, NULL, NULL)) != NULL) {
next_path = g_file_info_get_name(next_file);
full_path = g_strdup_printf("%s/%s", path, next_path);
/* Recurse if its a directory */
if (g_file_info_get_file_type(next_file) == G_FILE_TYPE_DIRECTORY) {
search_directory(full_path, list, n_params, mimes);
} else {
/* Not exactly a regex but it'll do for now */
file_mime = g_file_info_get_content_type(next_file);
for (i=0; i < n_params; i++) {
if (g_str_has_prefix(file_mime, mimes[i])) {
media = media_from_file(full_path, next_file, file_mime);
/* Probably switch to a new struct in the future */
*list = g_slist_append(*list, media);
}
}
}
g_free(full_path);
g_object_unref(next_file);
full_path = NULL;
}
g_file_enumerator_close(listing, NULL, NULL);
g_object_unref(listing);
}
g_object_unref(file);
}
void handle_update(GFile* f)
{
// g_message("handle_update");
if (g_file_query_file_type(f, G_FILE_QUERY_INFO_NONE ,NULL) != G_FILE_TYPE_UNKNOWN) {
char* path = g_file_get_path(f);
Entry* entry = dentry_create_by_path(path);
g_free(path);
JSObjectRef json = json_create();
json_append_nobject(json, "entry", entry, g_object_ref, g_object_unref);
js_post_message("item_update", json);
desktop_item_update();
g_object_unref(entry);
}
}
gint
dir_project_probe (GFile *file,
GError **error)
{
gint probe;
probe = g_file_query_file_type (file, G_FILE_QUERY_INFO_NONE, NULL) == G_FILE_TYPE_DIRECTORY;
if (!probe)
{
g_set_error (error, IANJUTA_PROJECT_ERROR,
IANJUTA_PROJECT_ERROR_DOESNT_EXIST,
_("Project doesn't exist or invalid path"));
}
return probe ? IANJUTA_PROJECT_PROBE_FILES : 0;
}
static void
on_entity_changed (updater_t *updater, GFile *entity)
{
GFileType type;
g_return_if_fail (updater);
g_return_if_fail (entity);
type = g_file_query_file_type (entity, G_FILE_QUERY_INFO_NONE, NULL);
switch (type) {
case G_FILE_TYPE_REGULAR:
updater_rehash_file (updater, entity);
break;
default:
g_debug ("something else changed: %d", (int) type);
break;
}
}
int
ddb_gvfs_is_container (const char *fname)
{
const char **sn = scheme_names;
while (*sn)
{
if (g_str_has_prefix (fname, *sn))
break;
sn++;
}
if (*sn == NULL)
return 0;
GFile *file = g_file_new_for_uri (fname);
GFileType type = g_file_query_file_type (file, G_FILE_QUERY_INFO_NONE, NULL);
g_object_unref (file);
return type == G_FILE_TYPE_DIRECTORY;
}
gboolean
dir_project_reload (DirProject *project, GError **error)
{
GFile *root_file;
GFile *source_file;
DirGroup *group;
gboolean ok = TRUE;
/* Unload current project */
root_file = g_object_ref (project->root_file);
dir_project_unload (project);
project->root_file = root_file;
DEBUG_PRINT ("reload project %p root file %p", project, project->root_file);
/* shortcut hash tables */
project->groups = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
if (g_file_query_file_type (root_file, G_FILE_QUERY_INFO_NONE, NULL) != G_FILE_TYPE_DIRECTORY)
{
g_set_error (error, IANJUTA_PROJECT_ERROR,
IANJUTA_PROJECT_ERROR_DOESNT_EXIST,
_("Project doesn't exist or invalid path"));
return FALSE;
}
group = dir_group_new (root_file);
g_hash_table_insert (project->groups, g_file_get_uri (root_file), group);
project->root_node = group;
/* Load source pattern */
source_file = g_file_new_for_path (SOURCES_FILE);
project->sources = dir_push_pattern_list (NULL, g_object_ref (root_file), source_file, FALSE, NULL);
g_object_unref (source_file);
dir_project_list_directory (project, group, NULL);
monitors_setup (project);
return ok;
}
static NautilusWindowSlot *
get_window_slot_for_location (NautilusApplication *application, GFile *location)
{
NautilusWindowSlot *slot;
GList *l, *sl;
slot = NULL;
if (g_file_query_file_type (location, G_FILE_QUERY_INFO_NONE, NULL) != G_FILE_TYPE_DIRECTORY) {
location = g_file_get_parent (location);
} else {
g_object_ref (location);
}
for (l = gtk_application_get_windows (GTK_APPLICATION (application)); l; l = l->next) {
NautilusWindow *win = NAUTILUS_WINDOW (l->data);
if (NAUTILUS_IS_DESKTOP_WINDOW (win))
continue;
for (sl = nautilus_window_get_slots (win); sl; sl = sl->next) {
NautilusWindowSlot *current = NAUTILUS_WINDOW_SLOT (sl->data);
GFile *slot_location = nautilus_window_slot_get_location (current);
if (g_file_equal (slot_location, location)) {
slot = current;
break;
}
}
if (slot) {
break;
}
}
g_object_unref (location);
return slot;
}
static void
giggle_plugin_manager_init (GigglePluginManager *manager)
{
GigglePluginManagerPriv *priv = GET_PRIV (manager);
priv->cancellable = g_cancellable_new ();
priv->plugin_dir = g_file_new_for_path ("plugins");
if (G_FILE_TYPE_DIRECTORY != g_file_query_file_type
(priv->plugin_dir, G_FILE_QUERY_INFO_NONE, NULL)) {
g_object_unref (priv->plugin_dir);
priv->plugin_dir = g_file_new_for_path (PLUGINDIR);
}
if (!g_file_query_exists (priv->plugin_dir, priv->cancellable))
return;
g_file_enumerate_children_async (priv->plugin_dir,
G_FILE_ATTRIBUTE_STANDARD_NAME,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT, priv->cancellable,
plugin_manager_children_ready, manager);
}
static void
on_entity_created (updater_t *updater, GFile *entity)
{
GFileType type;
g_return_if_fail (updater);
g_return_if_fail (entity);
type = g_file_query_file_type (entity, G_FILE_QUERY_INFO_NONE, NULL);
switch (type) {
case G_FILE_TYPE_DIRECTORY:
g_debug ("directory created");
updater_add_watcher_and_import (updater, entity);
break;
case G_FILE_TYPE_REGULAR:
g_debug ("file created");
updater_add_file (updater, entity);
break;
default:
g_debug ("something else created: %d", (int) type);
break;
}
}
static void
reader_libpcapfile_monitor_changed (GFileMonitor *UNUSED(monitor),
GFile *file,
GFile *UNUSED(other_file),
GFileMonitorEvent event_type,
gpointer UNUSED(user_data))
{
// Monitor new directories?
if (config.pcapRecursive &&
event_type == G_FILE_MONITOR_EVENT_CREATED &&
g_file_query_file_type(file, G_FILE_QUERY_INFO_NONE, NULL) == G_FILE_TYPE_DIRECTORY) {
gchar *path = g_file_get_path(file);
reader_libpcapfile_monitor_dir(path);
g_free(path);
return;
}
if (event_type != G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT)
return;
gchar *basename = g_file_get_path(file);
if (!g_regex_match(config.offlineRegex, basename, 0, NULL)) {
g_free(basename);
return;
}
g_free(basename);
gchar *path = g_file_get_path(file);
MolochString_t *string = MOLOCH_TYPE_ALLOC0(MolochString_t);
string->str = path;
if (config.debug)
LOG("Monitor enqueing %s", string->str);
DLL_PUSH_TAIL(s_, &monitorQ, string);
}
static GTokenType
gimp_color_profile_store_load_profile (GimpColorProfileStore *store,
GScanner *scanner,
gint index)
{
GtkTreeIter iter;
gchar *label = NULL;
gchar *uri = NULL;
if (gimp_scanner_parse_string (scanner, &label) &&
gimp_scanner_parse_string (scanner, &uri))
{
GFile *file = g_file_new_for_uri (uri);
if (file)
{
if (g_file_query_file_type (file, 0, NULL) == G_FILE_TYPE_REGULAR)
{
gimp_color_profile_store_history_insert (store, &iter,
file, label, index);
}
g_object_unref (file);
}
g_free (label);
g_free (uri);
return G_TOKEN_RIGHT_PAREN;
}
g_free (label);
g_free (uri);
return G_TOKEN_STRING;
}
