static GFileMonitor *
create_monitor (const gchar *path, gboolean is_dir)
{
GFile *file;
GFileMonitor *monitor;
GError *error;
error = NULL;
file = g_file_new_for_path (path);
if (is_dir)
monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, NULL, &error);
else
monitor = g_file_monitor_file (file, G_FILE_MONITOR_NONE, NULL, &error);
if (monitor == NULL)
{
g_warning ("Error monitoring %s at %s: %s (%s, %d)",
is_dir ? "directory" : "file",
path,
error->message, g_quark_to_string (error->domain), error->code);
g_error_free (error);
}
g_object_unref (file);
return monitor;
}
static void
actually_add_monitor (RhythmDB *db, GFile *directory, GError **error)
{
GFileMonitor *monitor;
if (directory == NULL) {
return;
}
g_mutex_lock (&db->priv->monitor_mutex);
if (g_hash_table_lookup (db->priv->monitored_directories, directory)) {
g_mutex_unlock (&db->priv->monitor_mutex);
return;
}
monitor = g_file_monitor_directory (directory, G_FILE_MONITOR_SEND_MOVED, db->priv->exiting, error);
if (monitor != NULL) {
g_signal_connect_object (G_OBJECT (monitor),
"changed",
G_CALLBACK (rhythmdb_directory_change_cb),
db, 0);
g_hash_table_insert (db->priv->monitored_directories,
g_object_ref (directory),
monitor);
}
g_mutex_unlock (&db->priv->monitor_mutex);
}
static gboolean
updater_add_watcher (updater_t *updater, GFile *file)
{
GFileMonitor *monitor;
GError *err = NULL;
gchar *path;
g_return_val_if_fail (updater, FALSE);
g_return_val_if_fail (file, FALSE);
if (!updater_is_dir (file)) {
return FALSE;
}
path = g_file_get_path (file);
monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, NULL, &err);
if (err) {
g_printerr ("Unable to monitor '%s', %s\n", path, err->message);
g_error_free (err);
g_free (monitor);
g_free (path);
return FALSE;
}
g_signal_connect (monitor, "changed", (gpointer) on_directory_event, updater);
/* path ownership transfered to the hash */
g_hash_table_insert (updater->watchers, path, monitor);
updater_find_sub_directories (updater, file);
return TRUE;
}
void watch_dir(const gchar * uri)
{
if(!watches)
watches = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, watch_free);
if(!g_hash_table_lookup(watches, uri))
{
GError * error = NULL;
DirWatch * watch = g_new(DirWatch, 1);
GFile * f = g_file_new_for_uri(uri);
watch->monitor = g_file_monitor_directory(f, G_FILE_MONITOR_NONE, NULL, &error);
g_object_unref(f);
if(error)
{
g_printerr("Unable to monitor directory %s (%s).\n", uri, error->message);
g_error_free(error);
g_free(watch);
}
else
{
g_debug("Monitor directory %s", uri);
// connect to signal
g_signal_connect(watch->monitor, "changed", (gpointer)changed_callback, NULL);
g_hash_table_insert(watches, g_strdup(uri), watch);
}
}
}
AnjutaProjectNode*
dir_group_node_new (GFile *file, GObject *emitter)
{
AnjutaDirGroupNode *group = NULL;
group = g_object_new (ANJUTA_TYPE_DIR_GROUP_NODE, NULL);
group->base.type = ANJUTA_PROJECT_GROUP;
group->base.native_properties = NULL;
group->base.custom_properties = NULL;
group->base.file = g_object_ref (file);
group->base.name = NULL;
group->base.state = ANJUTA_PROJECT_CAN_ADD_GROUP |
ANJUTA_PROJECT_CAN_ADD_SOURCE |
ANJUTA_PROJECT_CAN_REMOVE |
ANJUTA_PROJECT_REMOVE_FILE;
group->emitter = emitter;
/* Connect monitor if file exist */
if (g_file_query_exists (file, NULL))
{
group->monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, NULL, NULL);
g_signal_connect (G_OBJECT (group->monitor),
"changed",
G_CALLBACK (on_file_changed),
group);
}
return ANJUTA_PROJECT_NODE (group);
}
gboolean
caja_monitor_active (void)
{
static gboolean tried_monitor = FALSE;
static gboolean monitor_success;
GFileMonitor *dir_monitor;
GFile *file;
if (tried_monitor == FALSE)
{
file = g_file_new_for_path (g_get_home_dir ());
dir_monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, NULL, NULL);
g_object_unref (file);
monitor_success = (dir_monitor != NULL);
if (dir_monitor)
{
g_object_unref (dir_monitor);
}
tried_monitor = TRUE;
}
return monitor_success;
}
void locke_appmanager_init(LockeAppManager *lam, gchar *folder, GError **err) {
gchar deployFolder[1024];
strcpy(deployFolder, folder);
if (deployFolder[strlen(deployFolder) - 1] != '/') {
deployFolder[strlen(deployFolder) + 1] = '\0';
deployFolder[strlen(deployFolder)] = '/';
}
g_log(LSVR_DOMAIN, G_LOG_LEVEL_INFO, "Will be looking for deploys in folder %s", deployFolder);
lam->deployFolder = g_file_new_for_path(deployFolder);
/* Firstly, perform an initial scan on this folder, to add the applications
* that are already there*/
locke_appmanager_scan_for_deploys(lam, lam->deployFolder);
/* Monitor deploy dir, to receive events whenever a file is created,
* deleted, moved, etc on this folder */
lam->deployDirMonitor = g_file_monitor_directory(lam->deployFolder,
G_FILE_MONITOR_NONE, NULL, err);
if (*err != NULL) {
/* Report error to user, and free error */
g_log(LSVR_DOMAIN, G_LOG_LEVEL_ERROR, "Unable to monitor directory '%s': %s", deployFolder,
(*err)->message);
return;
}
/* Sets the monitor check rate */
g_file_monitor_set_rate_limit(lam->deployDirMonitor, 3000/* 3 secs*/);
/* Connects to the "changed" signal, to be able to receive the events */
g_signal_connect(lam->deployDirMonitor, "changed",
G_CALLBACK (locke_appmanager_file_changed), lam);
}
static void
nm_vpn_manager_init (NMVPNManager *self)
{
NMVPNManagerPrivate *priv = NM_VPN_MANAGER_GET_PRIVATE (self);
GFile *file;
GDir *dir;
const char *fn;
char *path;
priv->services = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL, g_object_unref);
/* Watch the VPN directory for changes */
file = g_file_new_for_path (VPN_NAME_FILES_DIR "/");
priv->monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, NULL, NULL);
g_object_unref (file);
if (priv->monitor) {
priv->monitor_id = g_signal_connect (priv->monitor, "changed",
G_CALLBACK (vpn_dir_changed), self);
}
/* Load VPN service files */
dir = g_dir_open (VPN_NAME_FILES_DIR, 0, NULL);
if (dir) {
while ((fn = g_dir_read_name (dir))) {
/* only parse filenames that end with .name */
if (g_str_has_suffix (fn, ".name")) {
path = g_build_filename (VPN_NAME_FILES_DIR, fn, NULL);
try_add_service (self, path);
g_free (path);
}
}
g_dir_close (dir);
}
}
void vfs_backend_add_monitor (const gchar *cURI, gboolean bDirectory, CairoDockFMMonitorCallback pCallback, gpointer user_data)
{
g_return_if_fail (cURI != NULL);
GError *erreur = NULL;
GFileMonitor *pMonitor;
GFile *pFile = (*cURI == '/' ? g_file_new_for_path (cURI) : g_file_new_for_uri (cURI));
if (bDirectory)
pMonitor = g_file_monitor_directory (pFile,
G_FILE_MONITOR_WATCH_MOUNTS,
NULL,
&erreur);
else
pMonitor = g_file_monitor_file (pFile,
G_FILE_MONITOR_WATCH_MOUNTS,
NULL,
&erreur);
//g_object_unref (pFile);
if (erreur != NULL)
{
cd_warning ("Attention : couldn't add monitor on '%s' (%d) [%s]", cURI, bDirectory, erreur->message);
g_error_free (erreur);
return ;
}
gpointer *data = g_new0 (gpointer, 3);
data[0] = pCallback;
data[1] = user_data;
data[2] = pMonitor;
g_signal_connect (G_OBJECT (pMonitor), "changed", G_CALLBACK (_on_monitor_changed), data);
g_hash_table_insert (s_hMonitorHandleTable, g_strdup (cURI), data);
cd_message (">>> moniteur ajoute sur %s (%x)", cURI, user_data);
}
void
nm_dispatcher_init (void)
{
GFile *file;
guint i;
GError *error = NULL;
for (i = 0; i < G_N_ELEMENTS (monitors); i++) {
file = g_file_new_for_path (monitors[i].dir);
monitors[i].monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, NULL, NULL);
if (monitors[i].monitor) {
g_signal_connect (monitors[i].monitor, "changed", G_CALLBACK (dispatcher_dir_changed), &monitors[i]);
dispatcher_dir_changed (monitors[i].monitor, file, NULL, 0, &monitors[i]);
}
g_object_unref (file);
}
dispatcher_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES |
G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
NULL,
NM_DISPATCHER_DBUS_SERVICE,
NM_DISPATCHER_DBUS_PATH,
NM_DISPATCHER_DBUS_INTERFACE,
NULL, &error);
if (!dispatcher_proxy) {
_LOGE ("could not get dispatcher proxy! %s", error->message);
g_clear_error (&error);
}
}
NautilusMonitor *
nautilus_monitor_directory (GFile *location)
{
GFileMonitor *dir_monitor;
NautilusMonitor *ret;
ret = g_slice_new0 (NautilusMonitor);
dir_monitor = g_file_monitor_directory (location, G_FILE_MONITOR_WATCH_MOUNTS, NULL, NULL);
if (dir_monitor != NULL) {
ret->monitor = dir_monitor;
} else if (!g_file_is_native (location)) {
ret->location = g_object_ref (location);
ret->volume_monitor = g_volume_monitor_get ();
}
if (ret->monitor != NULL) {
g_signal_connect (ret->monitor, "changed",
G_CALLBACK (dir_changed), ret);
}
if (ret->volume_monitor != NULL) {
g_signal_connect (ret->volume_monitor, "mount-removed",
G_CALLBACK (mount_removed), ret);
}
/* We return a monitor even on failure, so we can avoid later trying again */
return ret;
}
GFileMonitor* monitor_trash()
{
atexit(destroy_monitor);
trash_can = g_file_new_for_uri("trash:///");
m = g_file_monitor_directory(trash_can, G_FILE_MONITOR_SEND_MOVED, NULL, NULL);
g_signal_connect(m, "changed", G_CALLBACK(trash_changed), NULL);
return m;
}
/**
* pk_backend_initialize:
* This should only be run once per backend load, i.e. not every transaction
*/
void
pk_backend_initialize (GKeyFile *conf, PkBackend *backend)
{
gboolean ret;
GFile *file = NULL;
GError *error = NULL;
GKeyFile *key_file = NULL;
gchar *config_file = NULL;
GList *mounts;
/* use logging */
pk_debug_add_log_domain (G_LOG_DOMAIN);
pk_debug_add_log_domain ("Yum");
/* create private area */
priv = g_new0 (PkBackendYumPrivate, 1);
g_debug ("backend: initialize");
priv->spawn = pk_backend_spawn_new (conf);
pk_backend_spawn_set_filter_stderr (priv->spawn, pk_backend_stderr_cb);
pk_backend_spawn_set_filter_stdout (priv->spawn, pk_backend_stdout_cb);
pk_backend_spawn_set_name (priv->spawn, "yum");
pk_backend_spawn_set_allow_sigkill (priv->spawn, FALSE);
/* coldplug the mounts */
priv->volume_monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (priv->volume_monitor);
g_list_foreach (mounts, (GFunc) pk_backend_mount_add, NULL);
g_list_foreach (mounts, (GFunc) g_object_unref, NULL);
g_list_free (mounts);
/* setup a file monitor on the repos directory */
file = g_file_new_for_path (YUM_REPOS_DIRECTORY);
priv->monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, NULL, &error);
if (priv->monitor != NULL) {
g_signal_connect (priv->monitor, "changed", G_CALLBACK (pk_backend_yum_repos_changed_cb), backend);
} else {
g_warning ("failed to setup monitor: %s", error->message);
g_error_free (error);
}
/* read the config file */
key_file = g_key_file_new ();
config_file = g_build_filename (SYSCONFDIR, "PackageKit", "Yum.conf", NULL);
g_debug ("loading configuration from %s", config_file);
ret = g_key_file_load_from_file (key_file, config_file, G_KEY_FILE_NONE, &error);
if (!ret) {
g_warning ("failed to load Yum.conf: %s", error->message);
g_error_free (error);
goto out;
}
out:
g_free (config_file);
if (key_file != NULL)
g_key_file_free (key_file);
if (file != NULL)
g_object_unref (file);
}
static MenuMonitor *
register_monitor (const char *path,
gboolean is_directory)
{
#if !GLIB_CHECK_VERSION(2, 36, 0)
static gboolean initted = FALSE;
#endif
MenuMonitor *retval;
GFile *file;
#if !GLIB_CHECK_VERSION(2, 36, 0)
if (!initted)
{
/* This is the only place where we're using GObject and the app can't
* know we're using it, so we need to init the type system ourselves. */
g_type_init ();
initted = TRUE;
}
#endif
retval = g_new0 (MenuMonitor, 1);
retval->path = g_strdup (path);
retval->refcount = 1;
retval->is_directory = is_directory != FALSE;
file = g_file_new_for_path (retval->path);
if (file == NULL)
{
menu_verbose ("Not adding monitor on '%s', failed to create GFile\n",
retval->path);
return retval;
}
if (retval->is_directory)
retval->monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE,
NULL, NULL);
else
retval->monitor = g_file_monitor_file (file, G_FILE_MONITOR_NONE,
NULL, NULL);
g_object_unref (G_OBJECT (file));
if (retval->monitor == NULL)
{
menu_verbose ("Not adding monitor on '%s', failed to create monitor\n",
retval->path);
return retval;
}
g_signal_connect (retval->monitor, "changed",
G_CALLBACK (monitor_callback), retval);
return retval;
}
static void
nm_vpn_manager_init (NMVpnManager *self)
{
NMVpnManagerPrivate *priv = NM_VPN_MANAGER_GET_PRIVATE (self);
GFile *file;
GSList *infos, *info;
const char *conf_dir_etc = _nm_vpn_plugin_info_get_default_dir_etc ();
const char *conf_dir_lib = _nm_vpn_plugin_info_get_default_dir_lib ();
/* Watch the VPN directory for changes */
file = g_file_new_for_path (conf_dir_lib);
priv->monitor_lib = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, NULL, NULL);
g_object_unref (file);
if (priv->monitor_lib) {
priv->monitor_id_lib = g_signal_connect (priv->monitor_lib, "changed",
G_CALLBACK (vpn_dir_changed), self);
}
file = g_file_new_for_path (conf_dir_etc);
priv->monitor_etc = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, NULL, NULL);
g_object_unref (file);
if (priv->monitor_etc) {
priv->monitor_id_etc = g_signal_connect (priv->monitor_etc, "changed",
G_CALLBACK (vpn_dir_changed), self);
}
/* first read conf_dir_lib. The name files are not really user configuration, but
* plugin configuration. Hence we expect ~newer~ plugins to install their files
* in /usr/lib/NetworkManager. We want to prefer those files.
* In case of no-conflict, the order doesn't matter. */
infos = _nm_vpn_plugin_info_list_load_dir (conf_dir_lib, TRUE, 0, NULL, NULL);
for (info = infos; info; info = info->next)
try_add_plugin (self, info->data);
g_slist_free_full (infos, g_object_unref);
infos = _nm_vpn_plugin_info_list_load_dir (conf_dir_etc, TRUE, 0, NULL, NULL);
for (info = infos; info; info = info->next)
try_add_plugin (self, info->data);
g_slist_free_full (infos, g_object_unref);
priv->active_services = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
}
/* Buids a file watcher for the directory so that when it
changes we can check to see if our reboot-required is
there. */
static void
setup_restart_watch (void)
{
GFile * filedir = g_file_new_for_path("/var/run");
GFileMonitor * filemon = g_file_monitor_directory(filedir, G_FILE_MONITOR_NONE, NULL, NULL);
if (filemon != NULL) {
g_signal_connect(G_OBJECT(filemon), "changed", G_CALLBACK(restart_dir_changed), NULL);
}
restart_dir_changed();
return;
}
static void
try_monitor_path (NemoActionConfigWidget *widget, const gchar *path)
{
GFile *dir = g_file_new_for_path (path);
GFileMonitor *mon = g_file_monitor_directory (dir, G_FILE_MONITOR_SEND_MOVED, NULL, NULL);
g_object_unref (dir);
if (mon != NULL) {
g_signal_connect (mon, "changed", G_CALLBACK (on_dir_changed), widget);
widget->dir_monitors = g_list_append (widget->dir_monitors, mon);
}
}
void
monitor_create (GList **list, const char *path, void *data)
{
static struct state state;
state.list = list;
state.data = data;
dir = g_file_new_for_path(path);
if (!(monitor = g_file_monitor_directory(dir, G_FILE_MONITOR_NONE, NULL, NULL)))
return;
g_signal_connect(monitor, "changed", G_CALLBACK(on_changed), &state);
}
static void
webapp_monitor_init (WebappMonitor *monitor)
{
gchar *path = g_strdup_printf ("%s/.local/share/applications", g_get_home_dir ());
GFile *file = g_file_new_for_path (path);
GError *error = NULL;
monitor->instance = NULL;
monitor->icon_loader_callback = NULL;
monitor->file_monitor = g_file_monitor_directory (file, 0, NULL, &error);
if (monitor->file_monitor) {
GDir *dir;
/* Check already existing files on startup */
dir = g_dir_open (path, 0, &error);
if (dir) {
const gchar *name;
while (name = g_dir_read_name (dir)) {
if (g_str_has_prefix (name, "chrome-")) {
gchar *full_path = g_strdup_printf ("%s/%s", path, name);
GFile *file_to_check = g_file_new_for_path (full_path);
on_directory_changed (monitor->file_monitor, file_to_check, NULL, G_FILE_MONITOR_EVENT_CREATED, monitor);
g_free (full_path);
g_object_unref (file_to_check);
}
}
g_dir_close (dir);
} else {
g_error ("Error opening directory %s: %s\n", path, error->message);
g_error_free (error);
}
/* Listen to changes in the ~/.local/share/applications directory */
g_signal_connect (monitor->file_monitor, "changed", G_CALLBACK (on_directory_changed), monitor);
} else {
g_error ("Error monitoring directory: %s\n", error->message);
g_error_free (error);
}
g_free (path);
g_object_unref (file);
}
GFileMonitor* fm_monitor_directory(GFile* gf, GError** err)
{
GFileMonitor* ret = NULL;
G_LOCK(hash);
ret = (GFileMonitor*)g_hash_table_lookup(hash, gf);
if(!ret && !g_file_is_native(gf))
ret = (GFileMonitor*)g_hash_table_lookup(dummy_hash, gf);
if(ret)
g_object_ref(ret);
else
{
GError* e = NULL;
ret = g_file_monitor_directory(gf, G_FILE_MONITOR_WATCH_MOUNTS, NULL, &e);
if(ret)
{
g_object_weak_ref(G_OBJECT(ret), (GWeakNotify)on_monitor_destroy, gf);
g_file_monitor_set_rate_limit(ret, MONITOR_RATE_LIMIT);
g_hash_table_insert(hash, g_object_ref(gf), ret);
}
else
{
if(e)
{
if(e->domain == G_IO_ERROR && e->code == G_IO_ERROR_NOT_SUPPORTED)
{
/* create a fake file monitor */
ret = fm_dummy_monitor_new();
g_error_free(e);
g_object_weak_ref(G_OBJECT(ret), (GWeakNotify)on_dummy_monitor_destroy, gf);
g_hash_table_insert(dummy_hash, g_object_ref(gf), ret);
}
else
{
g_debug("error creating file monitor: %S", e->message);
G_UNLOCK(hash);
if(err)
*err = e;
else
g_error_free(e);
return NULL;
}
}
}
}
G_UNLOCK(hash);
return ret;
}
static gboolean
add_watch (const gchar *cmdline,
WatchType watch_type,
GFileMonitorFlags flags,
gboolean connect_handler)
{
GFileMonitor *monitor = NULL;
GError *error = NULL;
GFile *file;
file = g_file_new_for_commandline_arg (cmdline);
if (watch_type == WATCH_AUTO)
{
GFileInfo *info;
guint32 type;
info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_TYPE, G_FILE_QUERY_INFO_NONE, NULL, &error);
if (!info)
goto err;
type = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE);
watch_type = (type == G_FILE_TYPE_DIRECTORY) ? WATCH_DIR : WATCH_FILE;
}
if (watch_type == WATCH_DIR)
monitor = g_file_monitor_directory (file, flags, NULL, &error);
else
monitor = g_file_monitor (file, flags, NULL, &error);
if (!monitor)
goto err;
if (connect_handler)
g_signal_connect (monitor, "changed", G_CALLBACK (watch_callback), g_strdup (cmdline));
monitor = NULL; /* leak */
return TRUE;
err:
g_printerr ("error: %s: %s", cmdline, error->message);
g_error_free (error);
return FALSE;
}
// FIXME: get the apt directories with apt-config or something
static gboolean
monitor_init(UpgradeNotifier *un)
{
int i;
GFileMonitor *monitor_handle;
// monitor these dirs
static const char *monitor_dirs[] = {
"/var/lib/apt/lists/", "/var/lib/apt/lists/partial/",
"/var/cache/apt/archives/", "/var/cache/apt/archives/partial/",
HOOKS_DIR,
CRASHREPORT_DIR,
NULL};
for(i=0;monitor_dirs[i] != NULL;i++) {
GError *error = NULL;
GFile *gf = g_file_new_for_path(monitor_dirs[i]);
monitor_handle = g_file_monitor_directory(gf, 0, NULL, &error);
if(monitor_handle)
g_signal_connect(monitor_handle, "changed", (GCallback)monitor_cb, un);
else
g_warning("can not add '%s'", monitor_dirs[i]);
}
// and those files
static const char *monitor_files[] = {
"/var/lib/dpkg/status",
"/var/lib/update-notifier/dpkg-run-stamp",
"/var/lib/apt/periodic/update-success-stamp",
REBOOT_FILE,
UNICAST_LOCAL_AVAHI_FILE,
NULL};
for(i=0;monitor_files[i] != NULL;i++) {
GError *error = NULL;
GFile *gf = g_file_new_for_path(monitor_files[i]);
monitor_handle = g_file_monitor_file(gf, 0, NULL, &error);
if(monitor_handle)
g_signal_connect(monitor_handle, "changed", (GCallback)monitor_cb, un);
else
g_warning("can not add '%s'", monitor_dirs[i]);
}
g_timeout_add (TIMEOUT_FAM, (GSourceFunc)file_monitor_periodic_check, un);
return TRUE;
}
static void
setup_ifcfg_monitoring (SCPluginIfcfg *plugin)
{
SCPluginIfcfgPrivate *priv = SC_PLUGIN_IFCFG_GET_PRIVATE (plugin);
GFile *file;
GFileMonitor *monitor;
file = g_file_new_for_path (IFCFG_DIR "/");
monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, NULL, NULL);
g_object_unref (file);
if (monitor) {
priv->ifcfg_monitor_id = g_signal_connect (monitor, "changed",
G_CALLBACK (ifcfg_dir_changed), plugin);
priv->ifcfg_monitor = monitor;
}
}
void
cheese_thumb_view_start_monitoring_video_path (CheeseThumbView *thumb_view, const char *path_videos)
{
CheeseThumbViewPrivate *priv = cheese_thumb_view_get_instance_private (thumb_view);
if (priv->video_file_monitor != NULL)
return;
GFile *file;
/* connect signal to video path */
file = g_file_new_for_path (path_videos);
priv->video_file_monitor = g_file_monitor_directory (file, G_FILE_MONITOR_SEND_MOVED, NULL, NULL);
g_signal_connect (priv->video_file_monitor, "changed", G_CALLBACK (cheese_thumb_view_monitor_cb), thumb_view);
g_object_unref (file);
}
AthenaMonitor *
athena_monitor_directory (GFile *location)
{
GFileMonitor *dir_monitor;
AthenaMonitor *ret;
dir_monitor = g_file_monitor_directory (location, G_FILE_MONITOR_WATCH_MOUNTS, NULL, NULL);
ret = g_new0 (AthenaMonitor, 1);
ret->monitor = dir_monitor;
if (ret->monitor) {
g_signal_connect (ret->monitor, "changed", (GCallback)dir_changed, ret);
}
/* We return a monitor even on failure, so we can avoid later trying again */
return ret;
}
gboolean
gs_plugin_setup (GsPlugin *plugin, GCancellable *cancellable, GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(GFile) file = g_file_new_for_path (priv->reposdir);
/* watch for changes */
priv->monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, cancellable, error);
if (priv->monitor == NULL) {
gs_utils_error_convert_gio (error);
return FALSE;
}
g_signal_connect (priv->monitor, "changed",
G_CALLBACK (gs_plugin_repos_changed_cb), plugin);
/* unconditionally at startup */
return gs_plugin_repos_setup (plugin, cancellable, error);
}
int
main (int argc,
char **argv)
{
GFileMonitor *monitor;
GFile *curdir;
GError *error = NULL;
GPtrArray *new_argv;
int i;
struct TmpdirLifecyleData data;
g_type_init ();
memset (&data, 0, sizeof (data));
data.loop = g_main_loop_new (NULL, TRUE);
curdir = g_file_new_for_path (".");
monitor = g_file_monitor_directory (curdir, 0, NULL, &error);
if (!monitor)
exit (1);
g_signal_connect (monitor, "changed",
G_CALLBACK (on_dir_changed), &data);
new_argv = g_ptr_array_new ();
for (i = 1; i < argc; i++)
g_ptr_array_add (new_argv, argv[i]);
g_ptr_array_add (new_argv, NULL);
if (!g_spawn_async (NULL, (char**)new_argv->pdata, NULL, G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
NULL, NULL, &data.pid, &error))
{
g_printerr ("%s\n", error->message);
return 1;
}
g_child_watch_add (data.pid, on_child_exited, &data);
g_main_loop_run (data.loop);
if (!data.exited)
kill (data.pid, SIGTERM);
return 0;
}
static gboolean
pk_alpm_initialize_monitor (PkBackend *backend, GError **error)
{
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
_cleanup_free_ gchar * path = NULL;
_cleanup_object_unref_ GFile *directory = NULL;
path = g_strconcat (alpm_option_get_dbpath (priv->alpm) ,"/local", NULL);
directory = g_file_new_for_path (path);
priv->monitor = g_file_monitor_directory (directory, 0, NULL, error);
if (priv->monitor == NULL)
return FALSE;
g_signal_connect (priv->monitor, "changed",
G_CALLBACK (pk_backend_context_invalidate_cb), backend);
return TRUE;
}
static void
udisks_linux_provider_init (UDisksLinuxProvider *provider)
{
const gchar *subsystems[] = {"block", "iscsi_connection", "scsi", NULL};
GFile *file;
GError *error = NULL;
/* get ourselves an udev client */
provider->gudev_client = g_udev_client_new (subsystems);
g_signal_connect (provider->gudev_client,
"uevent",
G_CALLBACK (on_uevent),
provider);
provider->probe_request_queue = g_async_queue_new ();
provider->probe_request_thread = g_thread_new ("probing-thread",
probe_request_thread_func,
provider);
file = g_file_new_for_path (PACKAGE_SYSCONF_DIR "/udisks2");
provider->etc_udisks2_dir_monitor = g_file_monitor_directory (file,
G_FILE_MONITOR_NONE,
NULL,
&error);
if (provider->etc_udisks2_dir_monitor != NULL)
{
g_signal_connect (provider->etc_udisks2_dir_monitor,
"changed",
G_CALLBACK (on_etc_udisks2_dir_monitor_changed),
provider);
}
else
{
udisks_warning ("Error monitoring directory %s: %s (%s, %d)",
PACKAGE_SYSCONF_DIR "/udisks2",
error->message, g_quark_to_string (error->domain), error->code);
g_clear_error (&error);
}
g_object_unref (file);
}
static gboolean
ide_git_vcs_load_monitor_locked (IdeGitVcs *self,
GError **error)
{
gboolean ret = TRUE;
g_assert (IDE_IS_GIT_VCS (self));
if (self->monitor == NULL)
{
g_autoptr(GFile) location = NULL;
g_autoptr(GFileMonitor) monitor = NULL;
GError *local_error = NULL;
location = ggit_repository_get_location (self->repository);
monitor = g_file_monitor_directory (location,
G_FILE_MONITOR_NONE,
NULL,
&local_error);
if (monitor == NULL)
{
g_warning ("Failed to establish git monitor: %s", local_error->message);
g_propagate_error (error, local_error);
ret = FALSE;
}
else
{
IDE_TRACE_MSG ("Git index monitor registered.");
g_signal_connect_object (monitor,
"changed",
G_CALLBACK (ide_git_vcs__monitor_changed_cb),
self,
G_CONNECT_SWAPPED);
self->monitor = g_steal_pointer (&monitor);
}
}
return ret;
}
