gio/gfilemonitor.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2006-2007 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  17  *
  18  * Author: Alexander Larsson <alexl@redhat.com>
  19  */
  20
  21 #include "config.h"
  22 #include <string.h>
  23
  24 #include "gfilemonitor.h"
  25 #include "gioenumtypes.h"
  26 #include "gmarshal-internal.h"
  27 #include "gfile.h"
  28 #include "gvfs.h"
  29 #include "glibintl.h"
  30
  31 /**
  32  * SECTION:gfilemonitor
  33  * @short_description: File Monitor
  34  * @include: gio/gio.h
  35  *
  36  * Monitors a file or directory for changes.
  37  *
  38  * To obtain a #GFileMonitor for a file or directory, use
  39  * g_file_monitor(), g_file_monitor_file(), or
  40  * g_file_monitor_directory().
  41  *
  42  * To get informed about changes to the file or directory you are
  43  * monitoring, connect to the #GFileMonitor::changed signal. The
  44  * signal will be emitted in the
  45  * [thread-default main context][g-main-context-push-thread-default]
  46  * of the thread that the monitor was created in
  47  * (though if the global default main context is blocked, this may
  48  * cause notifications to be blocked even if the thread-default
  49  * context is still running).
  50  **/
  51
  52 #define DEFAULT_RATE_LIMIT_MSECS 800
  53
  54 struct _GFileMonitorPrivate
  55 {
  56   gboolean cancelled;
  57 };
  58
  59 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GFileMonitor, g_file_monitor, G_TYPE_OBJECT)
  60
  61 enum
  62 {
  63   PROP_0,
  64   PROP_RATE_LIMIT,
  65   PROP_CANCELLED
  66 };
  67
  68 static guint g_file_monitor_changed_signal;
  69
  70 static void
  71 g_file_monitor_set_property (GObject      *object,
  72                              guint         prop_id,
  73                              const GValue *value,
  74                              GParamSpec   *pspec)
  75 {
  76   //GFileMonitor *monitor;
  77
  78   //monitor = G_FILE_MONITOR (object);
  79
  80   switch (prop_id)
  81     {
  82     case PROP_RATE_LIMIT:
  83       /* not supported by default */
  84       break;
  85
  86     default:
  87       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  88       break;
  89     }
  90 }
  91
  92 static void
  93 g_file_monitor_get_property (GObject    *object,
  94                              guint       prop_id,
  95                              GValue     *value,
  96                              GParamSpec *pspec)
  97 {
  98   switch (prop_id)
  99     {
 100     case PROP_RATE_LIMIT:
 101       /* we expect this to be overridden... */
 102       g_value_set_int (value, DEFAULT_RATE_LIMIT_MSECS);
 103       break;
 104
 105     case PROP_CANCELLED:
 106       //g_mutex_lock (&fms->lock);
 107       g_value_set_boolean (value, FALSE);//fms->cancelled);
 108       //g_mutex_unlock (&fms->lock);
 109       break;
 110
 111     default:
 112       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 113       break;
 114     }
 115 }
 116
 117 static void
 118 g_file_monitor_dispose (GObject *object)
 119 {
 120   GFileMonitor *monitor = G_FILE_MONITOR (object);
 121
 122   /* Make sure we cancel on last unref */
 123   g_file_monitor_cancel (monitor);
 124
 125   G_OBJECT_CLASS (g_file_monitor_parent_class)->dispose (object);
 126 }
 127
 128 static void
 129 g_file_monitor_init (GFileMonitor *monitor)
 130 {
 131   monitor->priv = g_file_monitor_get_instance_private (monitor);
 132 }
 133
 134 static void
 135 g_file_monitor_class_init (GFileMonitorClass *klass)
 136 {
 137   GObjectClass *object_class;
 138
 139   object_class = G_OBJECT_CLASS (klass);
 140   object_class->dispose = g_file_monitor_dispose;
 141   object_class->get_property = g_file_monitor_get_property;
 142   object_class->set_property = g_file_monitor_set_property;
 143
 144   /**
 145    * GFileMonitor::changed:
 146    * @monitor: a #GFileMonitor.
 147    * @file: a #GFile.
 148    * @other_file: (nullable): a #GFile or #NULL.
 149    * @event_type: a #GFileMonitorEvent.
 150    *
 151    * Emitted when @file has been changed.
 152    *
 153    * If using %G_FILE_MONITOR_WATCH_MOVES on a directory monitor, and
 154    * the information is available (and if supported by the backend),
 155    * @event_type may be %G_FILE_MONITOR_EVENT_RENAMED,
 156    * %G_FILE_MONITOR_EVENT_MOVED_IN or %G_FILE_MONITOR_EVENT_MOVED_OUT.
 157    *
 158    * In all cases @file will be a child of the monitored directory.  For
 159    * renames, @file will be the old name and @other_file is the new
 160    * name.  For "moved in" events, @file is the name of the file that
 161    * appeared and @other_file is the old name that it was moved from (in
 162    * another directory).  For "moved out" events, @file is the name of
 163    * the file that used to be in this directory and @other_file is the
 164    * name of the file at its new location.
 165    *
 166    * It makes sense to treat %G_FILE_MONITOR_EVENT_MOVED_IN as
 167    * equivalent to %G_FILE_MONITOR_EVENT_CREATED and
 168    * %G_FILE_MONITOR_EVENT_MOVED_OUT as equivalent to
 169    * %G_FILE_MONITOR_EVENT_DELETED, with extra information.
 170    * %G_FILE_MONITOR_EVENT_RENAMED is equivalent to a delete/create
 171    * pair.  This is exactly how the events will be reported in the case
 172    * that the %G_FILE_MONITOR_WATCH_MOVES flag is not in use.
 173    *
 174    * If using the deprecated flag %G_FILE_MONITOR_SEND_MOVED flag and @event_type is
 175    * #G_FILE_MONITOR_EVENT_MOVED, @file will be set to a #GFile containing the
 176    * old path, and @other_file will be set to a #GFile containing the new path.
 177    *
 178    * In all the other cases, @other_file will be set to #NULL.
 179    **/
 180   g_file_monitor_changed_signal = g_signal_new (I_("changed"),
 181                                                 G_TYPE_FILE_MONITOR,
 182                                                 G_SIGNAL_RUN_LAST,
 183                                                 G_STRUCT_OFFSET (GFileMonitorClass, changed),
 184                                                 NULL, NULL,
 185                                                 _g_cclosure_marshal_VOID__OBJECT_OBJECT_ENUM,
 186                                                 G_TYPE_NONE, 3,
 187                                                 G_TYPE_FILE, G_TYPE_FILE, G_TYPE_FILE_MONITOR_EVENT);
 188   g_signal_set_va_marshaller (g_file_monitor_changed_signal,
 189                               G_TYPE_FROM_CLASS (klass),
 190                               _g_cclosure_marshal_VOID__OBJECT_OBJECT_ENUMv);
 191
 192   g_object_class_install_property (object_class, PROP_RATE_LIMIT,
 193                                    g_param_spec_int ("rate-limit",
 194                                                      P_("Rate limit"),
 195                                                      P_("The limit of the monitor to watch for changes, in milliseconds"),
 196                                                      0, G_MAXINT, DEFAULT_RATE_LIMIT_MSECS, G_PARAM_READWRITE |
 197                                                      G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS));
 198
 199   g_object_class_install_property (object_class, PROP_CANCELLED,
 200                                    g_param_spec_boolean ("cancelled",
 201                                                          P_("Cancelled"),
 202                                                          P_("Whether the monitor has been cancelled"),
 203                                                          FALSE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 204 }
 205
 206 /**
 207  * g_file_monitor_is_cancelled:
 208  * @monitor: a #GFileMonitor
 209  *
 210  * Returns whether the monitor is canceled.
 211  *
 212  * Returns: %TRUE if monitor is canceled. %FALSE otherwise.
 213  **/
 214 gboolean
 215 g_file_monitor_is_cancelled (GFileMonitor *monitor)
 216 {
 217   gboolean res;
 218
 219   g_return_val_if_fail (G_IS_FILE_MONITOR (monitor), FALSE);
 220
 221   res = monitor->priv->cancelled;
 222
 223   return res;
 224 }
 225
 226 /**
 227  * g_file_monitor_cancel:
 228  * @monitor: a #GFileMonitor.
 229  *
 230  * Cancels a file monitor.
 231  *
 232  * Returns: always %TRUE
 233  **/
 234 gboolean
 235 g_file_monitor_cancel (GFileMonitor *monitor)
 236 {
 237   g_return_val_if_fail (G_IS_FILE_MONITOR (monitor), FALSE);
 238
 239   if (!monitor->priv->cancelled)
 240     {
 241       G_FILE_MONITOR_GET_CLASS (monitor)->cancel (monitor);
 242
 243       monitor->priv->cancelled = TRUE;
 244       g_object_notify (G_OBJECT (monitor), "cancelled");
 245     }
 246
 247   return TRUE;
 248 }
 249
 250 /**
 251  * g_file_monitor_set_rate_limit:
 252  * @monitor: a #GFileMonitor.
 253  * @limit_msecs: a non-negative integer with the limit in milliseconds
 254  *     to poll for changes
 255  *
 256  * Sets the rate limit to which the @monitor will report
 257  * consecutive change events to the same file.
 258  */
 259 void
 260 g_file_monitor_set_rate_limit (GFileMonitor *monitor,
 261                                gint          limit_msecs)
 262 {
 263   g_object_set (monitor, "rate-limit", limit_msecs, NULL);
 264 }
 265
 266 /**
 267  * g_file_monitor_emit_event:
 268  * @monitor: a #GFileMonitor.
 269  * @child: a #GFile.
 270  * @other_file: a #GFile.
 271  * @event_type: a set of #GFileMonitorEvent flags.
 272  *
 273  * Emits the #GFileMonitor::changed signal if a change
 274  * has taken place. Should be called from file monitor
 275  * implementations only.
 276  *
 277  * Implementations are responsible to call this method from the
 278  * [thread-default main context][g-main-context-push-thread-default] of the
 279  * thread that the monitor was created in.
 280  **/
 281 void
 282 g_file_monitor_emit_event (GFileMonitor      *monitor,
 283                            GFile             *child,
 284                            GFile             *other_file,
 285                            GFileMonitorEvent  event_type)
 286 {
 287   g_return_if_fail (G_IS_FILE_MONITOR (monitor));
 288   g_return_if_fail (G_IS_FILE (child));
 289   g_return_if_fail (!other_file || G_IS_FILE (other_file));
 290
 291   if (monitor->priv->cancelled)
 292     return;
 293
 294   g_signal_emit (monitor, g_file_monitor_changed_signal, 0, child, other_file, event_type);
 295 }