/* FIXME: reference the monitors in self->priv so that we can clean them up later */
static void
monitor_subprocess_creation (GstSandboxedDecodebin *self)
{
GFile *audio_file, *video_file;
GST_DEBUG_OBJECT (self, "Putting monitors on %s and %s",
self->priv->shm_audio_socket_path,
self->priv->shm_video_socket_path);
self->priv->monitor_cancellable = g_cancellable_new ();
audio_file = g_file_new_for_path (self->priv->shm_audio_socket_path);
self->priv->audio_monitor =
g_file_monitor_file (audio_file, G_FILE_MONITOR_NONE,
self->priv->monitor_cancellable, NULL);
video_file = g_file_new_for_path (self->priv->shm_video_socket_path);
self->priv->video_monitor =
g_file_monitor_file (video_file, G_FILE_MONITOR_NONE,
self->priv->monitor_cancellable, NULL);
g_signal_connect (self->priv->audio_monitor, "changed",
G_CALLBACK (on_file_changed), self);
g_signal_connect (self->priv->video_monitor, "changed",
G_CALLBACK (on_file_changed), self);
if (g_file_query_exists (audio_file, self->priv->monitor_cancellable)
|| g_file_query_exists (video_file, self->priv->monitor_cancellable)) {
GST_WARNING_OBJECT (self,
"Some of the files we are monitoring for creation already exist!");
}
g_object_unref (audio_file);
g_object_unref (video_file);
}
static gboolean
git_status_command_start_automatic_monitor (AnjutaCommand *command)
{
GitStatusCommand *self;
gchar *working_directory;
gchar *git_head_path;
gchar *git_index_path;
GFile *git_head_file;
GFile *git_index_file;
self = GIT_STATUS_COMMAND (command);
g_object_get (self, "working-directory", &working_directory, NULL);
/* Watch for changes to the HEAD file and the index file, so that we can
* at least detect commits and index changes. */
git_head_path = g_strjoin (G_DIR_SEPARATOR_S,
working_directory,
".git",
"HEAD",
NULL);
git_index_path = g_strjoin (G_DIR_SEPARATOR_S,
working_directory,
".git",
"index",
NULL);
git_head_file = g_file_new_for_path (git_head_path);
git_index_file = g_file_new_for_path (git_index_path);
self->priv->head_monitor = g_file_monitor_file (git_head_file, 0, NULL,
NULL);
self->priv->index_monitor = g_file_monitor_file (git_index_file, 0, NULL,
NULL);
g_signal_connect (G_OBJECT (self->priv->head_monitor), "changed",
G_CALLBACK (on_file_monitor_changed),
command);
g_signal_connect (G_OBJECT (self->priv->index_monitor), "changed",
G_CALLBACK (on_file_monitor_changed),
command);
g_free (git_head_path);
g_free (git_index_path);
g_object_unref (git_head_file);
g_object_unref (git_index_file);
return TRUE;
}
static GFileMonitor *
setup_monitor (Daemon *daemon,
const gchar *path,
FileChangeCallback *callback)
{
GError *error = NULL;
GFile *file;
GFileMonitor *monitor;
if (!path) {
return NULL;
}
file = g_file_new_for_path (path);
monitor = g_file_monitor_file (file,
G_FILE_MONITOR_NONE,
NULL,
&error);
if (monitor != NULL) {
g_signal_connect (monitor,
"changed",
G_CALLBACK (callback),
daemon);
} else {
g_warning ("Unable to monitor %s: %s", path, error->message);
g_error_free (error);
}
g_object_unref (file);
return monitor;
}
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 gboolean
git_stash_list_command_start_automatic_monitor (AnjutaCommand *command)
{
GitStashListCommand *self;
gchar *working_directory;
gchar *git_stash_path;
GFile *git_stash_file;
self = GIT_STASH_LIST_COMMAND (command);
g_object_get (G_OBJECT (self), "working-directory", &working_directory,
NULL);
git_stash_path = g_strjoin (G_DIR_SEPARATOR_S,
working_directory,
".git",
"refs",
"stash",
NULL);
git_stash_file = g_file_new_for_path (git_stash_path);
self->priv->file_monitor = g_file_monitor_file (git_stash_file, 0, NULL,
NULL);
g_signal_connect (G_OBJECT (self->priv->file_monitor), "changed",
G_CALLBACK (on_file_monitor_changed),
command);
g_free (working_directory);
g_free (git_stash_path);
g_object_unref (git_stash_file);
return TRUE;
}
static void
trash_applet_init (TrashApplet *applet)
{
const GtkTargetEntry drop_types[] = { { "text/uri-list" } };
/* needed to clamp ourselves to the panel size */
panel_applet_set_flags (PANEL_APPLET (applet), PANEL_APPLET_EXPAND_MINOR);
/* setup the image */
applet->image = g_object_ref_sink (gtk_image_new ());
gtk_container_add (GTK_CONTAINER (applet),
GTK_WIDGET (applet->image));
gtk_widget_show (GTK_WIDGET (applet->image));
/* setup the trash backend */
applet->trash = g_file_new_for_uri ("trash:/");
applet->trash_monitor = g_file_monitor_file (applet->trash, 0, NULL, NULL);
g_signal_connect_swapped (applet->trash_monitor, "changed",
G_CALLBACK (trash_applet_monitor_changed),
applet);
/* setup drag and drop */
gtk_drag_dest_set (GTK_WIDGET (applet), GTK_DEST_DEFAULT_ALL,
drop_types, G_N_ELEMENTS (drop_types),
GDK_ACTION_MOVE);
/* synthesise the first update */
applet->items = -1;
trash_applet_monitor_changed (applet);
}
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);
}
static GFileMonitor *
monitor_file_changes (const char *filename,
FileChangedFn callback, gpointer user_data)
{
GFile *file;
GFileMonitor *monitor;
FileMonitorInfo *info;
GError **error = NULL;
if (!g_file_test (filename, G_FILE_TEST_IS_REGULAR))
return NULL;
file = g_file_new_for_path (filename);
monitor = g_file_monitor_file (file, G_FILE_MONITOR_NONE, NULL, error);
g_object_unref (file);
if (monitor) {
info = g_new0 (FileMonitorInfo, 1);
info->callback = callback;
info->user_data = user_data;
g_object_weak_ref (G_OBJECT (monitor), (GWeakNotify) g_free,
info);
g_signal_connect (monitor, "changed", G_CALLBACK (file_changed),
info);
PLUGIN_PRINT (IFNET_PLUGIN_NAME, "Monitoring %s", filename);
} else
PLUGIN_WARN (IFNET_PLUGIN_NAME,
"Monitoring %s failed, error: %s", filename,
error == NULL ? "nothing" : (*error)->message);
return monitor;
}
/**
* pk_offline_get_action_monitor:
* @cancellable: A #GCancellable or %NULL
* @error: A #GError or %NULL
*
* Gets a file monitor for the trigger.
*
* Return value: (transfer full): A #GFileMonitor, or %NULL
*
* Since: 0.9.6
**/
GFileMonitor *
pk_offline_get_action_monitor (GCancellable *cancellable, GError **error)
{
g_autoptr(GFile) file = NULL;
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
file = g_file_new_for_path (PK_OFFLINE_ACTION_FILENAME);
return g_file_monitor_file (file, G_FILE_MONITOR_NONE, NULL, error);
}
static inline void _cfg_monitor_add(FmConfig *cfg, const char *path)
{
GFile *gf = g_file_new_for_path(path);
cfg->_cfg_mon = g_file_monitor_file(gf, G_FILE_MONITOR_NONE, NULL, NULL);
g_object_unref(gf);
if (cfg->_cfg_mon)
g_signal_connect(cfg->_cfg_mon, "changed", G_CALLBACK(_on_cfg_file_changed), cfg);
}
void gtodo_client_unblock_changed_callback(GTodoClient *cl)
{
if(cl->timeout == NULL)
{
cl->timeout = g_file_monitor_file (cl->xml_file, G_FILE_MONITOR_NONE, NULL, NULL);
g_signal_connect (G_OBJECT (cl->timeout), "changed", G_CALLBACK (check_item_changed), cl);
}
}
/**
* pk_offline_get_prepared_upgrade_monitor:
* @cancellable: A #GCancellable or %NULL
* @error: A #GError or %NULL
*
* Gets a file monitor for the prepared system upgrade transaction.
*
* Return value: (transfer full): A #GFileMonitor, or %NULL
*
* Since: 1.0.12
**/
GFileMonitor *
pk_offline_get_prepared_upgrade_monitor (GCancellable *cancellable, GError **error)
{
g_autoptr(GFile) file = NULL;
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
file = g_file_new_for_path (PK_OFFLINE_PREPARED_UPGRADE_FILENAME);
return g_file_monitor_file (file, G_FILE_MONITOR_NONE, NULL, error);
}
static void
manager_constructed (GObject *object)
{
Manager *manager = MANAGER (object);
GError *error = NULL;
gs_unref_object GFile *etc_os_release = g_file_new_for_path ("/etc/os-release");
gs_free gchar *hostname;
manager->etc_os_release_monitor = g_file_monitor (etc_os_release, G_FILE_MONITOR_NONE, NULL, &error);
if (!manager->etc_os_release_monitor)
{
g_warning ("Error monitoring /etc/os-release: %s", error->message);
g_error_free (error);
}
else
{
g_signal_connect (manager->etc_os_release_monitor, "changed",
G_CALLBACK (on_etc_os_release_changed), manager);
reread_os_release (manager);
}
hostname = g_malloc0 (HOST_NAME_MAX + 1);
gethostname (hostname, HOST_NAME_MAX);
hostname[HOST_NAME_MAX] = '\0';
cockpit_manager_set_hostname (COCKPIT_MANAGER (manager), hostname);
g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES,
NULL, /* GDBusInterfaceInfo* */
"org.freedesktop.hostname1",
"/org/freedesktop/hostname1",
"org.freedesktop.hostname1",
manager->cancellable,
on_hostname_proxy_ready,
g_object_ref (manager));
update_dmi (manager);
error = NULL;
gs_unref_object GFile *f = g_file_new_for_path ("/run/systemd/shutdown/scheduled");
manager->systemd_shutdown_schedule_monitor = g_file_monitor_file (f, 0, NULL, &error);
if (error)
{
g_warning ("Can't watch: %s", error->message);
g_error_free (error);
}
else
{
g_signal_connect (manager->systemd_shutdown_schedule_monitor,
"changed",
G_CALLBACK (on_systemd_shutdown_scheduled_changed),
manager);
}
if (G_OBJECT_CLASS (manager_parent_class)->constructed != NULL)
G_OBJECT_CLASS (manager_parent_class)->constructed (object);
}
void
amp_group_node_update_node (AmpGroupNode *group, AmpGroupNode *new_group)
{
gint i;
GHashTable *hash;
if (group->monitor != NULL)
{
g_object_unref (group->monitor);
group->monitor = NULL;
}
if (group->makefile != NULL)
{
g_object_unref (group->makefile);
group->monitor = NULL;
}
if (group->preset_token != NULL)
{
anjuta_token_free (group->preset_token);
group->preset_token = NULL;
}
if (group->tfile) anjuta_token_file_free (group->tfile);
for (i = 0; i < AM_GROUP_TOKEN_LAST; i++)
{
if (group->tokens[i] != NULL) g_list_free (group->tokens[i]);
}
if (group->variables) g_hash_table_remove_all (group->variables);
group->dist_only = new_group->dist_only;
group->makefile = new_group->makefile;
new_group->makefile = NULL;
group->tfile = new_group->tfile;
new_group->tfile = NULL;
group->make_token = new_group->make_token;
new_group->make_token = NULL;
group->preset_token = new_group->preset_token;
new_group->preset_token = NULL;
memcpy (group->tokens, new_group->tokens, sizeof (group->tokens));
memset (new_group->tokens, 0, sizeof (new_group->tokens));
hash = group->variables;
group->variables = new_group->variables;
new_group->variables = hash;
if (group->makefile != NULL)
{
group->monitor = g_file_monitor_file (group->makefile,
G_FILE_MONITOR_NONE,
NULL,
NULL);
if (group->monitor != NULL)
{
g_signal_connect (G_OBJECT (group->monitor),
"changed",
G_CALLBACK (on_group_monitor_changed),
group);
}
}
}
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
config_load (TrackerConfigFile *file)
{
TrackerConfigFilePrivate *priv;
GError *error = NULL;
gchar *basename;
gchar *filename;
gchar *directory;
/* Check we have a config file and if not, create it based on
* the default settings.
*/
directory = config_dir_ensure_exists_and_return ();
if (!directory) {
return;
}
priv = TRACKER_CONFIG_FILE_GET_PRIVATE (file);
basename = g_strdup_printf ("%s.cfg", priv->domain);
filename = g_build_filename (directory, basename, NULL);
g_free (basename);
g_free (directory);
/* Add file monitoring for changes */
if (!file->file) {
file->file = g_file_new_for_path (filename);
}
if (!file->monitor) {
file->monitor = g_file_monitor_file (file->file,
G_FILE_MONITOR_NONE,
NULL,
NULL);
g_signal_connect (file->monitor, "changed",
G_CALLBACK (config_changed_cb),
file);
}
/* Load options */
g_key_file_load_from_file (file->key_file,
filename,
G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS,
&error);
/* We force an overwrite in cases of error */
file->file_exists = error ? FALSE : TRUE;
if (error) {
g_error_free (error);
}
g_free (filename);
}
/* function should be of type void functionname(GTodoType *cl, gpointer data); */
void gtodo_client_set_changed_callback(GTodoClient *cl, void *(*function)(gpointer cl, gpointer data), gpointer data)
{
cl->function = function;
if(cl->timeout != NULL)
{
g_file_monitor_cancel (cl->timeout);
g_object_unref (cl->timeout);
}
cl->timeout = g_file_monitor_file (cl->xml_file, G_FILE_MONITOR_NONE, NULL, NULL);
g_signal_connect (G_OBJECT (cl->timeout), "changed", G_CALLBACK (check_item_changed), cl);
cl->data = data;
}
static void fm_bookmarks_init(FmBookmarks *self)
{
GList* items = NULL;
char* fpath = get_bookmarks_file();
GFile* gf = g_file_new_for_path(fpath);
self->mon = g_file_monitor_file(gf, 0, NULL, NULL);
g_object_unref(gf);
g_signal_connect(self->mon, "changed", G_CALLBACK(on_changed), self);
self->items = load_bookmarks(fpath);
g_free(fpath);
}
static void
ensure_monitor_for_file (StTextureCache *cache,
GFile *file)
{
StTextureCachePrivate *priv = cache->priv;
if (g_hash_table_lookup (priv->file_monitors, file) == NULL)
{
GFileMonitor *monitor = g_file_monitor_file (file, G_FILE_MONITOR_NONE,
NULL, NULL);
g_signal_connect (monitor, "changed",
G_CALLBACK (file_changed_cb), cache);
g_hash_table_insert (priv->file_monitors, g_object_ref (file), monitor);
}
}
AnjutaTokenFile*
amp_group_node_set_makefile (AmpGroupNode *group, GFile *makefile, AmpProject *project)
{
if (group->makefile != NULL) g_object_unref (group->makefile);
if (group->tfile != NULL) anjuta_token_file_free (group->tfile);
if (makefile != NULL)
{
AnjutaToken *token;
AmpAmScanner *scanner;
AnjutaProjectNode *source;
group->makefile = g_object_ref (makefile);
group->tfile = anjuta_token_file_new (makefile);
source = amp_source_node_new (makefile, ANJUTA_PROJECT_PROJECT | ANJUTA_PROJECT_FRAME | ANJUTA_PROJECT_READ_ONLY);
anjuta_project_node_append (ANJUTA_PROJECT_NODE (group), source);
token = anjuta_token_file_load (group->tfile, NULL);
amp_project_add_file (project, makefile, group->tfile);
amp_group_node_update_preset_variable (group);
scanner = amp_am_scanner_new (project, group);
group->make_token = amp_am_scanner_parse_token (scanner, anjuta_token_new_static (ANJUTA_TOKEN_FILE, NULL), token, makefile, NULL);
amp_am_scanner_free (scanner);
group->monitor = g_file_monitor_file (makefile,
G_FILE_MONITOR_NONE,
NULL,
NULL);
if (group->monitor != NULL)
{
g_signal_connect (G_OBJECT (group->monitor),
"changed",
G_CALLBACK (on_group_monitor_changed),
group);
}
}
else
{
group->makefile = NULL;
group->tfile = NULL;
group->make_token = NULL;
if (group->monitor) g_object_unref (group->monitor);
group->monitor = NULL;
}
return group->tfile;
}
static void
ensure_monitor_for_uri (StTextureCache *cache,
const gchar *uri)
{
StTextureCachePrivate *priv = cache->priv;
GFile *file = g_file_new_for_uri (uri);
if (g_hash_table_lookup (priv->file_monitors, uri) == NULL)
{
GFileMonitor *monitor = g_file_monitor_file (file, G_FILE_MONITOR_NONE,
NULL, NULL);
g_signal_connect (monitor, "changed",
G_CALLBACK (file_changed_cb), cache);
g_hash_table_insert (priv->file_monitors, g_strdup (uri), monitor);
}
g_object_unref (file);
}
// 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
gnome_wall_clock_init (GnomeWallClock *self)
{
GFile *tz;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GNOME_TYPE_WALL_CLOCK, GnomeWallClockPrivate);
self->priv->clock_string = NULL;
tz = g_file_new_for_path ("/etc/localtime");
self->priv->tz_monitor = g_file_monitor_file (tz, 0, NULL, NULL);
g_object_unref (tz);
g_signal_connect (self->priv->tz_monitor, "changed", G_CALLBACK (on_tz_changed), self);
update_clock (self);
}
static void
update_xdg_dir_cache (void)
{
GFile *file;
char *config_file, *uri;
int i;
free_xdg_dir_cache ();
g_reload_user_special_dirs_cache ();
schedule_user_dirs_changed ();
desktop_dir_changed ();
cached_xdg_dirs = parse_xdg_dirs (NULL);
for (i = 0 ; cached_xdg_dirs[i].type != NULL; i++)
{
cached_xdg_dirs[i].file = NULL;
if (strcmp (cached_xdg_dirs[i].path, g_get_home_dir ()) != 0)
{
uri = g_filename_to_uri (cached_xdg_dirs[i].path, NULL, NULL);
cached_xdg_dirs[i].file = caja_file_get_by_uri (uri);
caja_file_monitor_add (cached_xdg_dirs[i].file,
&cached_xdg_dirs[i],
CAJA_FILE_ATTRIBUTE_INFO);
g_signal_connect (cached_xdg_dirs[i].file,
"changed", G_CALLBACK (xdg_dir_changed), &cached_xdg_dirs[i]);
g_free (uri);
}
}
if (cached_xdg_dirs_monitor == NULL)
{
config_file = g_build_filename (g_get_user_config_dir (),
"user-dirs.dirs", NULL);
file = g_file_new_for_path (config_file);
cached_xdg_dirs_monitor = g_file_monitor_file (file, 0, NULL, NULL);
g_signal_connect (cached_xdg_dirs_monitor, "changed",
G_CALLBACK (xdg_dir_cache_changed_cb), NULL);
g_object_unref (file);
g_free (config_file);
eel_debug_call_at_shutdown (destroy_xdg_dir_cache);
}
}
/**
* pk_backend_watch_file:
* @func: (scope call):
*/
gboolean
pk_backend_watch_file (PkBackend *backend,
const gchar *filename,
PkBackendFileChanged func,
gpointer data)
{
gboolean ret = FALSE;
GError *error = NULL;
GFile *file = NULL;
g_return_val_if_fail (PK_IS_BACKEND (backend), FALSE);
g_return_val_if_fail (filename != NULL, FALSE);
g_return_val_if_fail (func != NULL, FALSE);
if (backend->priv->file_changed_func != NULL) {
g_warning ("already set");
goto out;
}
/* monitor config files for changes */
file = g_file_new_for_path (filename);
backend->priv->monitor = g_file_monitor_file (file,
G_FILE_MONITOR_NONE,
NULL,
&error);
if (backend->priv->monitor == NULL) {
g_warning ("Failed to set watch on %s: %s",
filename,
error->message);
g_error_free (error);
goto out;
}
/* success */
ret = TRUE;
g_signal_connect (backend->priv->monitor, "changed",
G_CALLBACK (pk_backend_file_monitor_changed_cb), backend);
backend->priv->file_changed_func = func;
backend->priv->file_changed_data = data;
out:
if (file != NULL)
g_object_unref (file);
return ret;
}
static gboolean
setup_monitor_idle(gpointer data)
{
SourceviewIO* sio = SOURCEVIEW_IO(data);
sio->monitor_idle = 0;
if (sio->monitor != NULL)
g_object_unref (sio->monitor);
sio->monitor = g_file_monitor_file (sio->file,
G_FILE_MONITOR_NONE,
NULL,
NULL);
if (sio->monitor)
{
g_signal_connect (sio->monitor, "changed",
G_CALLBACK(on_file_changed), sio);
g_file_monitor_set_rate_limit (sio->monitor, RATE_LIMIT);
}
return FALSE;
}
static void
ibus_bus_init (IBusBus *bus)
{
struct stat buf;
gchar *path;
GFile *file;
IBusBusPrivate *priv;
priv = IBUS_BUS_GET_PRIVATE (bus);
priv->config = NULL;
priv->connection = NULL;
priv->watch_dbus_signal = FALSE;
path = g_path_get_dirname (ibus_get_socket_path ());
if (stat (path, &buf) == 0) {
if (buf.st_uid != ibus_get_daemon_uid ()) {
g_warning ("The owner of %s is not %s!", path, ibus_get_user_name ());
return;
}
}
#if 0
else {
if (getuid () == ibus_get_daemon_uid ()) {
mkdir (path, 0700);
chmod (path, 0700);
}
}
#endif
ibus_bus_connect (bus);
file = g_file_new_for_path (ibus_get_socket_path ());
priv->monitor = g_file_monitor_file (file, 0, NULL, NULL);
g_signal_connect (priv->monitor, "changed", (GCallback) _changed_cb, bus);
g_object_unref (file);
g_free (path);
}
static GFileMonitor *
location_file_monitor_new (void)
{
g_autoptr (GFile) file = g_file_new_for_path (LOCATION_CONF_FILE);
g_autoptr (GError) err = NULL;
g_autoptr (GFileMonitor) monitor = g_file_monitor_file (file, G_FILE_MONITOR_NONE,
NULL, &err);
if (err != NULL)
{
g_warning ("Couldn't set up file monitor for " LOCATION_CONF_FILE ": %s",
err->message);
return NULL;
}
g_signal_connect (monitor, "changed", G_CALLBACK (on_location_file_changed),
NULL);
return g_steal_pointer (&monitor);
}
static void
nm_session_monitor_init (NMSessionMonitor *self)
{
GError *error = NULL;
GFile *file;
#if NO_CONSOLEKIT
return;
#endif
/* Sessions-by-user is responsible for destroying the Session objects */
self->sessions_by_user = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL, (GDestroyNotify) session_free);
self->sessions_by_uid = g_hash_table_new (g_direct_hash, g_direct_equal);
error = NULL;
if (!ensure_database (self, &error)) {
/* Ignore the first error if the CK database isn't found yet */
if (g_error_matches (error,
NM_SESSION_MONITOR_ERROR,
NM_SESSION_MONITOR_ERROR_NO_DATABASE) == FALSE) {
nm_log_err (LOGD_CORE, "Error loading " CKDB_PATH ": %s", error->message);
}
g_error_free (error);
}
error = NULL;
file = g_file_new_for_path (CKDB_PATH);
self->database_monitor = g_file_monitor_file (file, G_FILE_MONITOR_NONE, NULL, &error);
g_object_unref (file);
if (self->database_monitor == NULL) {
nm_log_err (LOGD_CORE, "Error monitoring " CKDB_PATH ": %s", error->message);
g_error_free (error);
} else {
g_signal_connect (self->database_monitor,
"changed",
G_CALLBACK (on_file_monitor_changed),
self);
}
}
static void
ensure_monitor_for_file (StTextureCache *cache,
GFile *file)
{
StTextureCachePrivate *priv = cache->priv;
/* No point in trying to monitor files that are part of a
* GResource, since it does not support file monitoring.
*/
if (g_file_has_uri_scheme (file, "resource"))
return;
if (g_hash_table_lookup (priv->file_monitors, file) == NULL)
{
GFileMonitor *monitor = g_file_monitor_file (file, G_FILE_MONITOR_NONE,
NULL, NULL);
g_signal_connect (monitor, "changed",
G_CALLBACK (file_changed_cb), cache);
g_hash_table_insert (priv->file_monitors, g_object_ref (file), monitor);
}
}
