Attachment #519085 for bug #796055

View | Details | Raw Unified | Return to bug 796055
Collapse All | Expand All

Lines 94-100 PKG_CHECK_MODULES(LIBSHORTCUTS, $COMMON_MODULES x11) Link Here

(-)a/configure.ac (-1 / +1 lines)
94	PKG_CHECK_MODULES(SHELL, $COMMON_MODULES libgnome-menu-3.0 gio-unix-2.0 x11)	94	PKG_CHECK_MODULES(SHELL, $COMMON_MODULES libgnome-menu-3.0 gio-unix-2.0 x11)
95	PKG_CHECK_MODULES(BACKGROUND_PANEL, $COMMON_MODULES libxml-2.0 gnome-desktop-3.0	95	PKG_CHECK_MODULES(BACKGROUND_PANEL, $COMMON_MODULES libxml-2.0 gnome-desktop-3.0
96	gdk-pixbuf-2.0 >= $GDKPIXBUF_REQUIRED_VERSION)	96	gdk-pixbuf-2.0 >= $GDKPIXBUF_REQUIRED_VERSION)
97	PKG_CHECK_MODULES(DATETIME_PANEL, $COMMON_MODULES	97	PKG_CHECK_MODULES(DATETIME_PANEL, $COMMON_MODULES dbus-glib-1
98	gnome-desktop-3.0 >= $GNOME_DESKTOP_REQUIRED_VERSION	98	gnome-desktop-3.0 >= $GNOME_DESKTOP_REQUIRED_VERSION
99	polkit-gobject-1 >= $POLKIT_REQUIRED_VERSION	99	polkit-gobject-1 >= $POLKIT_REQUIRED_VERSION
100	gdk-pixbuf-2.0 >= $GDKPIXBUF_REQUIRED_VERSION)	100	gdk-pixbuf-2.0 >= $GDKPIXBUF_REQUIRED_VERSION)




ccpanelsdir = $(PANELS_DIR)
ccpanels_LTLIBRARIES = libdate_time.la

# FIXME add a way to regenerate the dtm.[ch]
# gdbus-codegen --generate-c-code dtm  --interface-prefix org.gnome.SettingsDaemon  /path/to/gnome-settings-daemon/plugins/datetime/gsd-datetime-mechanism.xml
# See also:
# https://bugzilla.gnome.org/show_bug.cgi?id=650875
# https://bugzilla.gnome.org/show_bug.cgi?id=650874
#		--xml						\
#		--system					\
#		--dest org.freedesktop.timedate1		\
#		--object-path /org/freedesktop/timedate1	\
#		 > timedated1-interface.xml

dbus_built_sources = timedated.c timedated.h
timedated.c: timedated.h
timedated.h: Makefile.am timedated1-interface.xml
	gdbus-codegen						\
		--interface-prefix org.freedesktop.		\
		--generate-c-code timedated			\
		$(srcdir)/timedated1-interface.xml

libdate_time_la_SOURCES =	\
	datetime-module.c	\

	cc-datetime-panel.h	\
	cc-timezone-map.c	\
	cc-timezone-map.h	\
	dtm.c			\
	dtm.h			\
	date-endian.c		\
	date-endian.h		\
	tz.c tz.h
	$(dbus_built_sources)	\
	$(NULL)

libdate_time_la_LIBADD = $(PANEL_LIBS) $(DATETIME_PANEL_LIBS)
libdate_time_la_LDFLAGS = $(PANEL_LDFLAGS)


polkitdir = $(datadir)/polkit-1/actions
polkit_in_files = org.gnome.controlcenter.datetime.policy.in

@INTLTOOL_POLICY_RULE@
polkit_DATA = $(polkit_in_files:.policy.in=.policy)


@INTLTOOL_DESKTOP_RULE@

desktopdir = $(datadir)/applications
desktop_in_files = gnome-datetime-panel.desktop.in
desktop_DATA = $(desktop_in_files:.desktop.in=.desktop)

CLEANFILES = $(desktop_in_files) $(desktop_DATA)
	$(desktop_in_files)			\
	$(desktop_DATA)				\
	$(dbus_built_sources)			\
	org.gnome.controlcenter.datetime.policy

EXTRA_DIST =				\
	timedated1-interface.xml	\
	$(polkit_in_files)

BUILT_SOURCES = $(dbus_built_sources)

-include $(top_srcdir)/git.mk






#include <sys/time.h>
#include "cc-timezone-map.h"
#include "dtm.h"
#include "date-endian.h"
#define GNOME_DESKTOP_USE_UNSTABLE_API



  GnomeWallClock *clock_tracker;

  DateTimeMechanism *dtm;
  GCancellable *cancellable;

  GPermission *permission;

  GError *error;

  error = NULL;
  if (!date_time_mechanism_call_set_time_finish (self->priv->dtm,
                                                 res,
                                                 &error))
    {
      /* TODO: display any error in a user friendly way */
      g_warning ("Could not set system time: %s", error->message);

  GError *error;

  error = NULL;
  if (!date_time_mechanism_call_set_timezone_finish (self->priv->dtm,
                                                     res,
                                                     &error))
    {
      /* TODO: display any error in a user friendly way */
      g_warning ("Could not set system timezone: %s", error->message);

  GError *error;

  error = NULL;
  if (!date_time_mechanism_call_set_using_ntp_finish (self->priv->dtm,
                                                      res,
                                                      &error))
    {
      /* TODO: display any error in a user friendly way */
      g_warning ("Could not set system to use NTP: %s", error->message);

{
  gint64 unixtime;

  /* for now just do it */
  unixtime = g_date_time_to_unix (self->priv->date);

  date_time_mechanism_call_set_time (self->priv->dtm,
                                     unixtime,
                                     self->priv->cancellable,
                                     set_time_cb,
                                     self);
                           set_time_cb,
                           self);
}

static void

  /* for now just do it */
  using_ntp = gtk_switch_get_active (GTK_SWITCH (W("network_time_switch")));

  date_time_mechanism_call_set_using_ntp (self->priv->dtm,
                                          using_ntp,
                                          self->priv->cancellable,
                                          set_using_ntp_cb,
                                          self);
                          self);
}

static void

  /* for now just do it */
  if (self->priv->current_location)
    {
      date_time_mechanism_call_set_timezone (self->priv->dtm,
                                             self->priv->current_location->zone,
                                             self->priv->cancellable,
                                             set_timezone_cb,
                                             self);
                                   self);
    }
}


}

static void
get_timezone_cb (GObject      *source,
                 GAsyncResult *res,
                 gpointer      user_data)
{
  CcDateTimePanel *self = user_data;
  GtkWidget *widget;
  gchar *timezone;
  GError *error;

  error = NULL;
  if (!date_time_mechanism_call_get_timezone_finish (self->priv->dtm, &timezone, res, &error))
    {
      g_warning ("Could not get current timezone: %s", error->message);
      g_error_free (error);
    }
  else
    timezone = NULL;

  if (timezone == NULL ||
      !cc_timezone_map_set_timezone (CC_TIMEZONE_MAP (self->priv->map), timezone))
    {
      if (!cc_timezone_map_set_timezone (CC_TIMEZONE_MAP (self->priv->map), timezone))
        {
          g_warning ("Timezone '%s' is unhandled, setting %s as default", timezone, DEFAULT_TZ);
          cc_timezone_map_set_timezone (CC_TIMEZONE_MAP (self->priv->map), DEFAULT_TZ);
        }
      self->priv->current_location = cc_timezone_map_get_location (CC_TIMEZONE_MAP (self->priv->map));
      update_timezone (self);
    }

  /* now that the initial state is loaded set connect the signals */
  widget = (GtkWidget*) gtk_builder_get_object (self->priv->builder,
                                                "region_combobox");
  g_signal_connect (widget, "changed", G_CALLBACK (region_changed_cb), self);

  widget = (GtkWidget*) gtk_builder_get_object (self->priv->builder,
                                                "city_combobox");
  g_signal_connect (widget, "changed", G_CALLBACK (city_changed_cb), self);

  g_signal_connect (self->priv->map, "location-changed",
                    G_CALLBACK (location_changed_cb), self);


  g_free (timezone);
}

/* load region and city tree models */

                             gboolean         using_ntp)
{
  CcDateTimePanelPrivate *priv = panel->priv;
  gboolean allowed;

  /* need to check polkit before revealing to user */
  allowed = (! priv->permission || g_permission_get_allowed (priv->permission));

  gtk_widget_set_sensitive (W("table1"), !using_ntp);
  gtk_widget_set_sensitive (W("table2"), !using_ntp);
}

static void

  gtk_widget_set_sensitive (W("map-vbox"), allowed);
  gtk_widget_set_sensitive (W("hbox2"), allowed);
  gtk_widget_set_sensitive (W("alignment2"), allowed);
  gtk_widget_set_sensitive (W("table1"), allowed && !using_ntp);
}

static void
update_ntp_switch_from_system (CcDateTimePanel *self)
{
  CcDateTimePanelPrivate *priv = self->priv;
  gboolean using_ntp;
  GtkWidget *switch_widget;

  using_ntp = timedate1_get_ntp (self->priv->dtm);

  switch_widget = W("network_time_switch");
  g_signal_handlers_block_by_func (switch_widget, change_ntp, self);
  gtk_switch_set_active (GTK_SWITCH (switch_widget), using_ntp);
  update_widget_state_for_ntp (self, using_ntp);
  g_signal_handlers_unblock_by_func (switch_widget, change_ntp, self);
}

static void
on_ntp_changed (CcDateTimePanel *self)
{
  update_ntp_switch_from_system (self);
}

static void
on_timezone_changed (CcDateTimePanel *self)
{
  CcDateTimePanelPrivate *priv = self->priv;
  GtkWidget *region_combo, *city_combo;

  region_combo = W("region_combobox");
  city_combo = W("city_combobox");

  g_signal_handlers_block_by_func (region_combo, region_changed_cb, self);
  g_signal_handlers_block_by_func (city_combo, city_changed_cb, self);
  g_signal_handlers_block_by_func (self->priv->map, location_changed_cb, self);

  get_initial_timezone (self);

  g_signal_handlers_unblock_by_func (region_combo, region_changed_cb, self);
  g_signal_handlers_unblock_by_func (city_combo, city_changed_cb, self);
  g_signal_handlers_unblock_by_func (self->priv->map, location_changed_cb, self);
}

static void
on_timedated_properties_changed (GDBusProxy       *proxy,
                                 GVariant         *changed_properties,
                                 const gchar     **invalidated_properties,
                                 CcDateTimePanel  *self)
{
  GError *error;
  GVariant *variant;
  GVariant *v;
  guint i;

  if (invalidated_properties != NULL)
    for (i = 0; invalidated_properties[i] != NULL; i++) {
        error = NULL;
        /* See https://bugs.freedesktop.org/show_bug.cgi?id=37632 for the reason why we're doing this */
        variant = g_dbus_proxy_call_sync (proxy,
                                          "org.freedesktop.DBus.Properties.Get",
                                          g_variant_new ("(ss)", "org.freedesktop.timedate1", invalidated_properties[i]),
                                          G_DBUS_CALL_FLAGS_NONE,
                                          -1,
                                          NULL,
                                          &error);
        if (variant == NULL) {
                g_warning ("Failed to get property '%s': %s", invalidated_properties[i], error->message);
                g_error_free (error);
        } else {
                g_variant_get (variant, "(v)", &v);
                g_dbus_proxy_set_cached_property (proxy, invalidated_properties[i], v);
                g_variant_unref (variant);
        }
    }
}

static void

  GtkTreeModelFilter *city_modelfilter;
  GtkTreeModelSort *city_modelsort;
  guint i, num_days;
  gboolean using_ntp;
  gboolean can_use_ntp;
  int ret;
  DateEndianess endianess;
  GError *error;


  priv->cancellable = g_cancellable_new ();
  error = NULL;
  priv->dtm = date_time_mechanism_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
                                                          G_DBUS_PROXY_FLAGS_NONE,
                                                          "org.gnome.SettingsDaemon.DateTimeMechanism",
                                                          "/",
                                                          priv->cancellable,
                                                          &error);
  if (priv->dtm == NULL) {
        g_warning ("could not get proxy for DateTimeMechanism: %s", error->message);
        g_error_free (error);

    }

  /* set up network time button */
  error = NULL;
  using_ntp = can_use_ntp = FALSE;
  if (!date_time_mechanism_call_get_using_ntp_sync (priv->dtm,
                                                    &can_use_ntp,
                                                    &using_ntp,
                                                    priv->cancellable,
                                                    &error))
    {
      g_warning ("Failed to get using ntp: %s", error->message);
      g_error_free (error);
    }

  gtk_switch_set_active (GTK_SWITCH (W("network_time_switch")), using_ntp);
  update_widget_state_for_ntp (self, using_ntp);
  g_signal_connect (W("network_time_switch"), "notify::active",
                    G_CALLBACK (change_ntp), self);



  /* After the initial setup, so we can be sure that
   * the model is filled up */
  date_time_mechanism_call_get_timezone (priv->dtm,
                                         priv->cancellable,
                                         get_timezone_cb,
                                         self);
  g_signal_connect (widget, "changed", G_CALLBACK (region_changed_cb), self);

  widget = (GtkWidget*) gtk_builder_get_object (self->priv->builder,
                                                "city_combobox");
  g_signal_connect (widget, "changed", G_CALLBACK (city_changed_cb), self);

  g_signal_connect (self->priv->map, "location-changed",
                    G_CALLBACK (location_changed_cb), self);

  /* Watch changes of timedated remote service properties */
  if (priv->dtm)
    {
      g_signal_connect (priv->dtm, "g-properties-changed",
                        G_CALLBACK (on_timedated_properties_changed), self);
      g_signal_connect_swapped (priv->dtm, "notify::ntp",
                                G_CALLBACK (on_ntp_changed), self);
      g_signal_connect_swapped (priv->dtm, "notify::timezone",
                                G_CALLBACK (on_timezone_changed), self);
    }
  /* We ignore UTC <--> LocalRTC changes at the moment */

  /* add the lock button */
  priv->permission = polkit_permission_new_sync ("org.gnome.settingsdaemon.datetimemechanism.configure", NULL, NULL, NULL);
  if (priv->permission == NULL)
    {
      g_warning ("Your system does not have the '%s' PolicyKit files installed. Please check your installation",
                 "org.gnome.settingsdaemon.datetimemechanism.configure");
      return;
    }





/*
 * Generated by gdbus-codegen 2.29.5. DO NOT EDIT.
 *
 * The license of this code is the same as for the source it was derived from.
 */

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif

#include "dtm.h"

typedef struct
{
  GDBusArgInfo parent_struct;
  gboolean use_gvariant;
} _ExtendedGDBusArgInfo;

typedef struct
{
  GDBusMethodInfo parent_struct;
  const gchar *signal_name;
} _ExtendedGDBusMethodInfo;

typedef struct
{
  GDBusSignalInfo parent_struct;
  const gchar *signal_name;
} _ExtendedGDBusSignalInfo;

typedef struct
{
  GDBusPropertyInfo parent_struct;
  const gchar *hyphen_name;
  gboolean use_gvariant;
} _ExtendedGDBusPropertyInfo;

typedef struct
{
  GDBusInterfaceInfo parent_struct;
  const gchar *hyphen_name;
} _ExtendedGDBusInterfaceInfo;

typedef struct
{
  const _ExtendedGDBusPropertyInfo *info;
  guint prop_id;
  GValue orig_value; /* the value before the change */
} ChangedProperty;

static void
_changed_property_free (ChangedProperty *data)
{
  g_value_unset (&data->orig_value);
  g_free (data);
}

static gboolean
_g_strv_equal0 (gchar **a, gchar **b)
{
  gboolean ret = FALSE;
  guint n;
  if (a == NULL && b == NULL)
    {
      ret = TRUE;
      goto out;
    }
  if (a == NULL || b == NULL)
    goto out;
  if (g_strv_length (a) != g_strv_length (b))
    goto out;
  for (n = 0; a[n] != NULL; n++)
    if (g_strcmp0 (a[n], b[n]) != 0)
      goto out;
  ret = TRUE;
out:
  return ret;
}

static gboolean
_g_variant_equal0 (GVariant *a, GVariant *b)
{
  gboolean ret = FALSE;
  if (a == NULL && b == NULL)
    {
      ret = TRUE;
      goto out;
    }
  if (a == NULL || b == NULL)
    goto out;
  ret = g_variant_equal (a, b);
out:
  return ret;
}

G_GNUC_UNUSED static gboolean
_g_value_equal (const GValue *a, const GValue *b)
{
  gboolean ret = FALSE;
  g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b));
  switch (G_VALUE_TYPE (a))
    {
      case G_TYPE_BOOLEAN:
        ret = (g_value_get_boolean (a) == g_value_get_boolean (b));
        break;
      case G_TYPE_UCHAR:
        ret = (g_value_get_uchar (a) == g_value_get_uchar (b));
        break;
      case G_TYPE_INT:
        ret = (g_value_get_int (a) == g_value_get_int (b));
        break;
      case G_TYPE_UINT:
        ret = (g_value_get_uint (a) == g_value_get_uint (b));
        break;
      case G_TYPE_INT64:
        ret = (g_value_get_int64 (a) == g_value_get_int64 (b));
        break;
      case G_TYPE_UINT64:
        ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b));
        break;
      case G_TYPE_DOUBLE:
        ret = (g_value_get_double (a) == g_value_get_double (b));
        break;
      case G_TYPE_STRING:
        ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0);
        break;
      case G_TYPE_VARIANT:
        ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b));
        break;
      default:
        if (G_VALUE_TYPE (a) == G_TYPE_STRV)
          ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b));
        else
          g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a)));
        break;
    }
  return ret;
}

/* ------------------------------------------------------------------------
 * Code for interface org.gnome.SettingsDaemon.DateTimeMechanism
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:DateTimeMechanism
 * @title: DateTimeMechanism
 * @short_description: Generated C code for the org.gnome.SettingsDaemon.DateTimeMechanism D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-gnome-SettingsDaemon-DateTimeMechanism.top_of_page">org.gnome.SettingsDaemon.DateTimeMechanism</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.gnome.SettingsDaemon.DateTimeMechanism ---- */

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_set_timezone_IN_ARG_tz =
{
  {
    -1,
    "tz",
    "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo * const _date_time_mechanism_method_info_set_timezone_IN_ARG_pointers[] =
{
  &_date_time_mechanism_method_info_set_timezone_IN_ARG_tz,
  NULL
};

static const GDBusAnnotationInfo _date_time_mechanism_method_set_timezone_annotation_info_0 =
{
  -1,
  "org.freedesktop.DBus.GLib.Async",
  "",
  NULL
};

static const GDBusAnnotationInfo * const _date_time_mechanism_method_set_timezone_annotation_info_pointers[] =
{
  &_date_time_mechanism_method_set_timezone_annotation_info_0,
  NULL
};

static const _ExtendedGDBusMethodInfo _date_time_mechanism_method_info_set_timezone =
{
  {
    -1,
    "SetTimezone",
    (GDBusArgInfo **) &_date_time_mechanism_method_info_set_timezone_IN_ARG_pointers,
    NULL,
    (GDBusAnnotationInfo **) &_date_time_mechanism_method_set_timezone_annotation_info_pointers
  },
  "handle-set-timezone"
};

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_get_timezone_OUT_ARG_timezone =
{
  {
    -1,
    "timezone",
    "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo * const _date_time_mechanism_method_info_get_timezone_OUT_ARG_pointers[] =
{
  &_date_time_mechanism_method_info_get_timezone_OUT_ARG_timezone,
  NULL
};

static const GDBusAnnotationInfo _date_time_mechanism_method_get_timezone_annotation_info_0 =
{
  -1,
  "org.freedesktop.DBus.GLib.Async",
  "",
  NULL
};

static const GDBusAnnotationInfo * const _date_time_mechanism_method_get_timezone_annotation_info_pointers[] =
{
  &_date_time_mechanism_method_get_timezone_annotation_info_0,
  NULL
};

static const _ExtendedGDBusMethodInfo _date_time_mechanism_method_info_get_timezone =
{
  {
    -1,
    "GetTimezone",
    NULL,
    (GDBusArgInfo **) &_date_time_mechanism_method_info_get_timezone_OUT_ARG_pointers,
    (GDBusAnnotationInfo **) &_date_time_mechanism_method_get_timezone_annotation_info_pointers
  },
  "handle-get-timezone"
};

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_can_set_timezone_OUT_ARG_value =
{
  {
    -1,
    "value",
    "i",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo * const _date_time_mechanism_method_info_can_set_timezone_OUT_ARG_pointers[] =
{
  &_date_time_mechanism_method_info_can_set_timezone_OUT_ARG_value,
  NULL
};

static const GDBusAnnotationInfo _date_time_mechanism_method_can_set_timezone_annotation_info_0 =
{
  -1,
  "org.freedesktop.DBus.GLib.Async",
  "",
  NULL
};

static const GDBusAnnotationInfo * const _date_time_mechanism_method_can_set_timezone_annotation_info_pointers[] =
{
  &_date_time_mechanism_method_can_set_timezone_annotation_info_0,
  NULL
};

static const _ExtendedGDBusMethodInfo _date_time_mechanism_method_info_can_set_timezone =
{
  {
    -1,
    "CanSetTimezone",
    NULL,
    (GDBusArgInfo **) &_date_time_mechanism_method_info_can_set_timezone_OUT_ARG_pointers,
    (GDBusAnnotationInfo **) &_date_time_mechanism_method_can_set_timezone_annotation_info_pointers
  },
  "handle-can-set-timezone"
};

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_set_date_IN_ARG_day =
{
  {
    -1,
    "day",
    "u",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_set_date_IN_ARG_month =
{
  {
    -1,
    "month",
    "u",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_set_date_IN_ARG_year =
{
  {
    -1,
    "year",
    "u",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo * const _date_time_mechanism_method_info_set_date_IN_ARG_pointers[] =
{
  &_date_time_mechanism_method_info_set_date_IN_ARG_day,
  &_date_time_mechanism_method_info_set_date_IN_ARG_month,
  &_date_time_mechanism_method_info_set_date_IN_ARG_year,
  NULL
};

static const GDBusAnnotationInfo _date_time_mechanism_method_set_date_annotation_info_0 =
{
  -1,
  "org.freedesktop.DBus.GLib.Async",
  "",
  NULL
};

static const GDBusAnnotationInfo * const _date_time_mechanism_method_set_date_annotation_info_pointers[] =
{
  &_date_time_mechanism_method_set_date_annotation_info_0,
  NULL
};

static const _ExtendedGDBusMethodInfo _date_time_mechanism_method_info_set_date =
{
  {
    -1,
    "SetDate",
    (GDBusArgInfo **) &_date_time_mechanism_method_info_set_date_IN_ARG_pointers,
    NULL,
    (GDBusAnnotationInfo **) &_date_time_mechanism_method_set_date_annotation_info_pointers
  },
  "handle-set-date"
};

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_set_time_IN_ARG_seconds_since_epoch =
{
  {
    -1,
    "seconds_since_epoch",
    "x",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo * const _date_time_mechanism_method_info_set_time_IN_ARG_pointers[] =
{
  &_date_time_mechanism_method_info_set_time_IN_ARG_seconds_since_epoch,
  NULL
};

static const GDBusAnnotationInfo _date_time_mechanism_method_set_time_annotation_info_0 =
{
  -1,
  "org.freedesktop.DBus.GLib.Async",
  "",
  NULL
};

static const GDBusAnnotationInfo * const _date_time_mechanism_method_set_time_annotation_info_pointers[] =
{
  &_date_time_mechanism_method_set_time_annotation_info_0,
  NULL
};

static const _ExtendedGDBusMethodInfo _date_time_mechanism_method_info_set_time =
{
  {
    -1,
    "SetTime",
    (GDBusArgInfo **) &_date_time_mechanism_method_info_set_time_IN_ARG_pointers,
    NULL,
    (GDBusAnnotationInfo **) &_date_time_mechanism_method_set_time_annotation_info_pointers
  },
  "handle-set-time"
};

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_can_set_time_OUT_ARG_value =
{
  {
    -1,
    "value",
    "i",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo * const _date_time_mechanism_method_info_can_set_time_OUT_ARG_pointers[] =
{
  &_date_time_mechanism_method_info_can_set_time_OUT_ARG_value,
  NULL
};

static const GDBusAnnotationInfo _date_time_mechanism_method_can_set_time_annotation_info_0 =
{
  -1,
  "org.freedesktop.DBus.GLib.Async",
  "",
  NULL
};

static const GDBusAnnotationInfo * const _date_time_mechanism_method_can_set_time_annotation_info_pointers[] =
{
  &_date_time_mechanism_method_can_set_time_annotation_info_0,
  NULL
};

static const _ExtendedGDBusMethodInfo _date_time_mechanism_method_info_can_set_time =
{
  {
    -1,
    "CanSetTime",
    NULL,
    (GDBusArgInfo **) &_date_time_mechanism_method_info_can_set_time_OUT_ARG_pointers,
    (GDBusAnnotationInfo **) &_date_time_mechanism_method_can_set_time_annotation_info_pointers
  },
  "handle-can-set-time"
};

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_adjust_time_IN_ARG_seconds_to_add =
{
  {
    -1,
    "seconds_to_add",
    "x",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo * const _date_time_mechanism_method_info_adjust_time_IN_ARG_pointers[] =
{
  &_date_time_mechanism_method_info_adjust_time_IN_ARG_seconds_to_add,
  NULL
};

static const GDBusAnnotationInfo _date_time_mechanism_method_adjust_time_annotation_info_0 =
{
  -1,
  "org.freedesktop.DBus.GLib.Async",
  "",
  NULL
};

static const GDBusAnnotationInfo * const _date_time_mechanism_method_adjust_time_annotation_info_pointers[] =
{
  &_date_time_mechanism_method_adjust_time_annotation_info_0,
  NULL
};

static const _ExtendedGDBusMethodInfo _date_time_mechanism_method_info_adjust_time =
{
  {
    -1,
    "AdjustTime",
    (GDBusArgInfo **) &_date_time_mechanism_method_info_adjust_time_IN_ARG_pointers,
    NULL,
    (GDBusAnnotationInfo **) &_date_time_mechanism_method_adjust_time_annotation_info_pointers
  },
  "handle-adjust-time"
};

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_get_hardware_clock_using_utc_OUT_ARG_is_using_utc =
{
  {
    -1,
    "is_using_utc",
    "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo * const _date_time_mechanism_method_info_get_hardware_clock_using_utc_OUT_ARG_pointers[] =
{
  &_date_time_mechanism_method_info_get_hardware_clock_using_utc_OUT_ARG_is_using_utc,
  NULL
};

static const GDBusAnnotationInfo _date_time_mechanism_method_get_hardware_clock_using_utc_annotation_info_0 =
{
  -1,
  "org.freedesktop.DBus.GLib.Async",
  "",
  NULL
};

static const GDBusAnnotationInfo * const _date_time_mechanism_method_get_hardware_clock_using_utc_annotation_info_pointers[] =
{
  &_date_time_mechanism_method_get_hardware_clock_using_utc_annotation_info_0,
  NULL
};

static const _ExtendedGDBusMethodInfo _date_time_mechanism_method_info_get_hardware_clock_using_utc =
{
  {
    -1,
    "GetHardwareClockUsingUtc",
    NULL,
    (GDBusArgInfo **) &_date_time_mechanism_method_info_get_hardware_clock_using_utc_OUT_ARG_pointers,
    (GDBusAnnotationInfo **) &_date_time_mechanism_method_get_hardware_clock_using_utc_annotation_info_pointers
  },
  "handle-get-hardware-clock-using-utc"
};

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_set_hardware_clock_using_utc_IN_ARG_is_using_utc =
{
  {
    -1,
    "is_using_utc",
    "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo * const _date_time_mechanism_method_info_set_hardware_clock_using_utc_IN_ARG_pointers[] =
{
  &_date_time_mechanism_method_info_set_hardware_clock_using_utc_IN_ARG_is_using_utc,
  NULL
};

static const GDBusAnnotationInfo _date_time_mechanism_method_set_hardware_clock_using_utc_annotation_info_0 =
{
  -1,
  "org.freedesktop.DBus.GLib.Async",
  "",
  NULL
};

static const GDBusAnnotationInfo * const _date_time_mechanism_method_set_hardware_clock_using_utc_annotation_info_pointers[] =
{
  &_date_time_mechanism_method_set_hardware_clock_using_utc_annotation_info_0,
  NULL
};

static const _ExtendedGDBusMethodInfo _date_time_mechanism_method_info_set_hardware_clock_using_utc =
{
  {
    -1,
    "SetHardwareClockUsingUtc",
    (GDBusArgInfo **) &_date_time_mechanism_method_info_set_hardware_clock_using_utc_IN_ARG_pointers,
    NULL,
    (GDBusAnnotationInfo **) &_date_time_mechanism_method_set_hardware_clock_using_utc_annotation_info_pointers
  },
  "handle-set-hardware-clock-using-utc"
};

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_get_using_ntp_OUT_ARG_can_use_ntp =
{
  {
    -1,
    "can_use_ntp",
    "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_get_using_ntp_OUT_ARG_is_using_ntp =
{
  {
    -1,
    "is_using_ntp",
    "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo * const _date_time_mechanism_method_info_get_using_ntp_OUT_ARG_pointers[] =
{
  &_date_time_mechanism_method_info_get_using_ntp_OUT_ARG_can_use_ntp,
  &_date_time_mechanism_method_info_get_using_ntp_OUT_ARG_is_using_ntp,
  NULL
};

static const GDBusAnnotationInfo _date_time_mechanism_method_get_using_ntp_annotation_info_0 =
{
  -1,
  "org.freedesktop.DBus.GLib.Async",
  "",
  NULL
};

static const GDBusAnnotationInfo * const _date_time_mechanism_method_get_using_ntp_annotation_info_pointers[] =
{
  &_date_time_mechanism_method_get_using_ntp_annotation_info_0,
  NULL
};

static const _ExtendedGDBusMethodInfo _date_time_mechanism_method_info_get_using_ntp =
{
  {
    -1,
    "GetUsingNtp",
    NULL,
    (GDBusArgInfo **) &_date_time_mechanism_method_info_get_using_ntp_OUT_ARG_pointers,
    (GDBusAnnotationInfo **) &_date_time_mechanism_method_get_using_ntp_annotation_info_pointers
  },
  "handle-get-using-ntp"
};

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_set_using_ntp_IN_ARG_is_using_ntp =
{
  {
    -1,
    "is_using_ntp",
    "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo * const _date_time_mechanism_method_info_set_using_ntp_IN_ARG_pointers[] =
{
  &_date_time_mechanism_method_info_set_using_ntp_IN_ARG_is_using_ntp,
  NULL
};

static const GDBusAnnotationInfo _date_time_mechanism_method_set_using_ntp_annotation_info_0 =
{
  -1,
  "org.freedesktop.DBus.GLib.Async",
  "",
  NULL
};

static const GDBusAnnotationInfo * const _date_time_mechanism_method_set_using_ntp_annotation_info_pointers[] =
{
  &_date_time_mechanism_method_set_using_ntp_annotation_info_0,
  NULL
};

static const _ExtendedGDBusMethodInfo _date_time_mechanism_method_info_set_using_ntp =
{
  {
    -1,
    "SetUsingNtp",
    (GDBusArgInfo **) &_date_time_mechanism_method_info_set_using_ntp_IN_ARG_pointers,
    NULL,
    (GDBusAnnotationInfo **) &_date_time_mechanism_method_set_using_ntp_annotation_info_pointers
  },
  "handle-set-using-ntp"
};

static const _ExtendedGDBusArgInfo _date_time_mechanism_method_info_can_set_using_ntp_OUT_ARG_value =
{
  {
    -1,
    "value",
    "i",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo * const _date_time_mechanism_method_info_can_set_using_ntp_OUT_ARG_pointers[] =
{
  &_date_time_mechanism_method_info_can_set_using_ntp_OUT_ARG_value,
  NULL
};

static const GDBusAnnotationInfo _date_time_mechanism_method_can_set_using_ntp_annotation_info_0 =
{
  -1,
  "org.freedesktop.DBus.GLib.Async",
  "",
  NULL
};

static const GDBusAnnotationInfo * const _date_time_mechanism_method_can_set_using_ntp_annotation_info_pointers[] =
{
  &_date_time_mechanism_method_can_set_using_ntp_annotation_info_0,
  NULL
};

static const _ExtendedGDBusMethodInfo _date_time_mechanism_method_info_can_set_using_ntp =
{
  {
    -1,
    "CanSetUsingNtp",
    NULL,
    (GDBusArgInfo **) &_date_time_mechanism_method_info_can_set_using_ntp_OUT_ARG_pointers,
    (GDBusAnnotationInfo **) &_date_time_mechanism_method_can_set_using_ntp_annotation_info_pointers
  },
  "handle-can-set-using-ntp"
};

static const _ExtendedGDBusMethodInfo * const _date_time_mechanism_method_info_pointers[] =
{
  &_date_time_mechanism_method_info_set_timezone,
  &_date_time_mechanism_method_info_get_timezone,
  &_date_time_mechanism_method_info_can_set_timezone,
  &_date_time_mechanism_method_info_set_date,
  &_date_time_mechanism_method_info_set_time,
  &_date_time_mechanism_method_info_can_set_time,
  &_date_time_mechanism_method_info_adjust_time,
  &_date_time_mechanism_method_info_get_hardware_clock_using_utc,
  &_date_time_mechanism_method_info_set_hardware_clock_using_utc,
  &_date_time_mechanism_method_info_get_using_ntp,
  &_date_time_mechanism_method_info_set_using_ntp,
  &_date_time_mechanism_method_info_can_set_using_ntp,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _date_time_mechanism_interface_info =
{
  {
    -1,
    "org.gnome.SettingsDaemon.DateTimeMechanism",
    (GDBusMethodInfo **) &_date_time_mechanism_method_info_pointers,
    NULL,
    NULL,
    NULL
  },
  "date-time-mechanism",
};


/**
 * date_time_mechanism_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-gnome-SettingsDaemon-DateTimeMechanism.top_of_page">org.gnome.SettingsDaemon.DateTimeMechanism</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
date_time_mechanism_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_date_time_mechanism_interface_info;
}



/**
 * DateTimeMechanism:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-gnome-SettingsDaemon-DateTimeMechanism.top_of_page">org.gnome.SettingsDaemon.DateTimeMechanism</link>.
 */

/**
 * DateTimeMechanismIface:
 * @parent_iface: The parent interface.
 * @handle_adjust_time: Handler for the #DateTimeMechanism::handle-adjust-time signal.
 * @handle_can_set_time: Handler for the #DateTimeMechanism::handle-can-set-time signal.
 * @handle_can_set_timezone: Handler for the #DateTimeMechanism::handle-can-set-timezone signal.
 * @handle_can_set_using_ntp: Handler for the #DateTimeMechanism::handle-can-set-using-ntp signal.
 * @handle_get_hardware_clock_using_utc: Handler for the #DateTimeMechanism::handle-get-hardware-clock-using-utc signal.
 * @handle_get_timezone: Handler for the #DateTimeMechanism::handle-get-timezone signal.
 * @handle_get_using_ntp: Handler for the #DateTimeMechanism::handle-get-using-ntp signal.
 * @handle_set_date: Handler for the #DateTimeMechanism::handle-set-date signal.
 * @handle_set_hardware_clock_using_utc: Handler for the #DateTimeMechanism::handle-set-hardware-clock-using-utc signal.
 * @handle_set_time: Handler for the #DateTimeMechanism::handle-set-time signal.
 * @handle_set_timezone: Handler for the #DateTimeMechanism::handle-set-timezone signal.
 * @handle_set_using_ntp: Handler for the #DateTimeMechanism::handle-set-using-ntp signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-gnome-SettingsDaemon-DateTimeMechanism.top_of_page">org.gnome.SettingsDaemon.DateTimeMechanism</link>.
 */

static void
date_time_mechanism_default_init (DateTimeMechanismIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * DateTimeMechanism::handle-set-timezone:
   * @object: A #DateTimeMechanism.
   * @invocation: A #GDBusMethodInvocation.
   * @tz: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetTimezone">SetTimezone()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call date_time_mechanism_complete_set_timezone() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-set-timezone",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (DateTimeMechanismIface, handle_set_timezone),
    g_signal_accumulator_true_handled,
    NULL,
    g_cclosure_marshal_generic,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);

  /**
   * DateTimeMechanism::handle-get-timezone:
   * @object: A #DateTimeMechanism.
   * @invocation: A #GDBusMethodInvocation.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.GetTimezone">GetTimezone()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call date_time_mechanism_complete_get_timezone() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-get-timezone",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (DateTimeMechanismIface, handle_get_timezone),
    g_signal_accumulator_true_handled,
    NULL,
    g_cclosure_marshal_generic,
    G_TYPE_BOOLEAN,
    1,
    G_TYPE_DBUS_METHOD_INVOCATION);

  /**
   * DateTimeMechanism::handle-can-set-timezone:
   * @object: A #DateTimeMechanism.
   * @invocation: A #GDBusMethodInvocation.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.CanSetTimezone">CanSetTimezone()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call date_time_mechanism_complete_can_set_timezone() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-can-set-timezone",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (DateTimeMechanismIface, handle_can_set_timezone),
    g_signal_accumulator_true_handled,
    NULL,
    g_cclosure_marshal_generic,
    G_TYPE_BOOLEAN,
    1,
    G_TYPE_DBUS_METHOD_INVOCATION);

  /**
   * DateTimeMechanism::handle-set-date:
   * @object: A #DateTimeMechanism.
   * @invocation: A #GDBusMethodInvocation.
   * @day: Argument passed by remote caller.
   * @month: Argument passed by remote caller.
   * @year: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetDate">SetDate()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call date_time_mechanism_complete_set_date() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-set-date",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (DateTimeMechanismIface, handle_set_date),
    g_signal_accumulator_true_handled,
    NULL,
    g_cclosure_marshal_generic,
    G_TYPE_BOOLEAN,
    4,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);

  /**
   * DateTimeMechanism::handle-set-time:
   * @object: A #DateTimeMechanism.
   * @invocation: A #GDBusMethodInvocation.
   * @seconds_since_epoch: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetTime">SetTime()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call date_time_mechanism_complete_set_time() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-set-time",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (DateTimeMechanismIface, handle_set_time),
    g_signal_accumulator_true_handled,
    NULL,
    g_cclosure_marshal_generic,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_INT64);

  /**
   * DateTimeMechanism::handle-can-set-time:
   * @object: A #DateTimeMechanism.
   * @invocation: A #GDBusMethodInvocation.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.CanSetTime">CanSetTime()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call date_time_mechanism_complete_can_set_time() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-can-set-time",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (DateTimeMechanismIface, handle_can_set_time),
    g_signal_accumulator_true_handled,
    NULL,
    g_cclosure_marshal_generic,
    G_TYPE_BOOLEAN,
    1,
    G_TYPE_DBUS_METHOD_INVOCATION);

  /**
   * DateTimeMechanism::handle-adjust-time:
   * @object: A #DateTimeMechanism.
   * @invocation: A #GDBusMethodInvocation.
   * @seconds_to_add: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.AdjustTime">AdjustTime()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call date_time_mechanism_complete_adjust_time() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-adjust-time",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (DateTimeMechanismIface, handle_adjust_time),
    g_signal_accumulator_true_handled,
    NULL,
    g_cclosure_marshal_generic,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_INT64);

  /**
   * DateTimeMechanism::handle-get-hardware-clock-using-utc:
   * @object: A #DateTimeMechanism.
   * @invocation: A #GDBusMethodInvocation.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.GetHardwareClockUsingUtc">GetHardwareClockUsingUtc()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call date_time_mechanism_complete_get_hardware_clock_using_utc() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-get-hardware-clock-using-utc",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (DateTimeMechanismIface, handle_get_hardware_clock_using_utc),
    g_signal_accumulator_true_handled,
    NULL,
    g_cclosure_marshal_generic,
    G_TYPE_BOOLEAN,
    1,
    G_TYPE_DBUS_METHOD_INVOCATION);

  /**
   * DateTimeMechanism::handle-set-hardware-clock-using-utc:
   * @object: A #DateTimeMechanism.
   * @invocation: A #GDBusMethodInvocation.
   * @is_using_utc: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetHardwareClockUsingUtc">SetHardwareClockUsingUtc()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call date_time_mechanism_complete_set_hardware_clock_using_utc() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-set-hardware-clock-using-utc",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (DateTimeMechanismIface, handle_set_hardware_clock_using_utc),
    g_signal_accumulator_true_handled,
    NULL,
    g_cclosure_marshal_generic,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_BOOLEAN);

  /**
   * DateTimeMechanism::handle-get-using-ntp:
   * @object: A #DateTimeMechanism.
   * @invocation: A #GDBusMethodInvocation.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.GetUsingNtp">GetUsingNtp()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call date_time_mechanism_complete_get_using_ntp() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-get-using-ntp",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (DateTimeMechanismIface, handle_get_using_ntp),
    g_signal_accumulator_true_handled,
    NULL,
    g_cclosure_marshal_generic,
    G_TYPE_BOOLEAN,
    1,
    G_TYPE_DBUS_METHOD_INVOCATION);

  /**
   * DateTimeMechanism::handle-set-using-ntp:
   * @object: A #DateTimeMechanism.
   * @invocation: A #GDBusMethodInvocation.
   * @is_using_ntp: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetUsingNtp">SetUsingNtp()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call date_time_mechanism_complete_set_using_ntp() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-set-using-ntp",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (DateTimeMechanismIface, handle_set_using_ntp),
    g_signal_accumulator_true_handled,
    NULL,
    g_cclosure_marshal_generic,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_BOOLEAN);

  /**
   * DateTimeMechanism::handle-can-set-using-ntp:
   * @object: A #DateTimeMechanism.
   * @invocation: A #GDBusMethodInvocation.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.CanSetUsingNtp">CanSetUsingNtp()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call date_time_mechanism_complete_can_set_using_ntp() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-can-set-using-ntp",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (DateTimeMechanismIface, handle_can_set_using_ntp),
    g_signal_accumulator_true_handled,
    NULL,
    g_cclosure_marshal_generic,
    G_TYPE_BOOLEAN,
    1,
    G_TYPE_DBUS_METHOD_INVOCATION);

}

typedef DateTimeMechanismIface DateTimeMechanismInterface;
G_DEFINE_INTERFACE (DateTimeMechanism, date_time_mechanism, G_TYPE_OBJECT);

/**
 * date_time_mechanism_call_set_timezone:
 * @proxy: A #DateTimeMechanismProxy.
 * @tz: Argument to pass with the method invocation.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetTimezone">SetTimezone()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 * You can then call date_time_mechanism_call_set_timezone_finish() to get the result of the operation.
 *
 * See date_time_mechanism_call_set_timezone_sync() for the synchronous, blocking version of this method.
 */
void
date_time_mechanism_call_set_timezone (
    DateTimeMechanism *proxy,
    const gchar *tz,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetTimezone",
    g_variant_new ("(s)",
                   tz),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * date_time_mechanism_call_set_timezone_finish:
 * @proxy: A #DateTimeMechanismProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to date_time_mechanism_call_set_timezone().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with date_time_mechanism_call_set_timezone().
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_set_timezone_finish (
    DateTimeMechanism *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_set_timezone_sync:
 * @proxy: A #DateTimeMechanismProxy.
 * @tz: Argument to pass with the method invocation.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetTimezone">SetTimezone()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See date_time_mechanism_call_set_timezone() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_set_timezone_sync (
    DateTimeMechanism *proxy,
    const gchar *tz,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetTimezone",
    g_variant_new ("(s)",
                   tz),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_get_timezone:
 * @proxy: A #DateTimeMechanismProxy.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.GetTimezone">GetTimezone()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 * You can then call date_time_mechanism_call_get_timezone_finish() to get the result of the operation.
 *
 * See date_time_mechanism_call_get_timezone_sync() for the synchronous, blocking version of this method.
 */
void
date_time_mechanism_call_get_timezone (
    DateTimeMechanism *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "GetTimezone",
    g_variant_new ("()"),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * date_time_mechanism_call_get_timezone_finish:
 * @proxy: A #DateTimeMechanismProxy.
 * @out_timezone: (out): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to date_time_mechanism_call_get_timezone().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with date_time_mechanism_call_get_timezone().
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_get_timezone_finish (
    DateTimeMechanism *proxy,
    gchar **out_timezone,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(s)",
                 out_timezone);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_get_timezone_sync:
 * @proxy: A #DateTimeMechanismProxy.
 * @out_timezone: (out): Return location for return parameter or %NULL to ignore.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.GetTimezone">GetTimezone()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See date_time_mechanism_call_get_timezone() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_get_timezone_sync (
    DateTimeMechanism *proxy,
    gchar **out_timezone,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "GetTimezone",
    g_variant_new ("()"),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(s)",
                 out_timezone);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_can_set_timezone:
 * @proxy: A #DateTimeMechanismProxy.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.CanSetTimezone">CanSetTimezone()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 * You can then call date_time_mechanism_call_can_set_timezone_finish() to get the result of the operation.
 *
 * See date_time_mechanism_call_can_set_timezone_sync() for the synchronous, blocking version of this method.
 */
void
date_time_mechanism_call_can_set_timezone (
    DateTimeMechanism *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CanSetTimezone",
    g_variant_new ("()"),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * date_time_mechanism_call_can_set_timezone_finish:
 * @proxy: A #DateTimeMechanismProxy.
 * @out_value: (out): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to date_time_mechanism_call_can_set_timezone().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with date_time_mechanism_call_can_set_timezone().
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_can_set_timezone_finish (
    DateTimeMechanism *proxy,
    gint *out_value,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(i)",
                 out_value);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_can_set_timezone_sync:
 * @proxy: A #DateTimeMechanismProxy.
 * @out_value: (out): Return location for return parameter or %NULL to ignore.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.CanSetTimezone">CanSetTimezone()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See date_time_mechanism_call_can_set_timezone() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_can_set_timezone_sync (
    DateTimeMechanism *proxy,
    gint *out_value,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CanSetTimezone",
    g_variant_new ("()"),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(i)",
                 out_value);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_set_date:
 * @proxy: A #DateTimeMechanismProxy.
 * @day: Argument to pass with the method invocation.
 * @month: Argument to pass with the method invocation.
 * @year: Argument to pass with the method invocation.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetDate">SetDate()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 * You can then call date_time_mechanism_call_set_date_finish() to get the result of the operation.
 *
 * See date_time_mechanism_call_set_date_sync() for the synchronous, blocking version of this method.
 */
void
date_time_mechanism_call_set_date (
    DateTimeMechanism *proxy,
    guint day,
    guint month,
    guint year,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetDate",
    g_variant_new ("(uuu)",
                   day,
                   month,
                   year),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * date_time_mechanism_call_set_date_finish:
 * @proxy: A #DateTimeMechanismProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to date_time_mechanism_call_set_date().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with date_time_mechanism_call_set_date().
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_set_date_finish (
    DateTimeMechanism *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_set_date_sync:
 * @proxy: A #DateTimeMechanismProxy.
 * @day: Argument to pass with the method invocation.
 * @month: Argument to pass with the method invocation.
 * @year: Argument to pass with the method invocation.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetDate">SetDate()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See date_time_mechanism_call_set_date() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_set_date_sync (
    DateTimeMechanism *proxy,
    guint day,
    guint month,
    guint year,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetDate",
    g_variant_new ("(uuu)",
                   day,
                   month,
                   year),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_set_time:
 * @proxy: A #DateTimeMechanismProxy.
 * @seconds_since_epoch: Argument to pass with the method invocation.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetTime">SetTime()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 * You can then call date_time_mechanism_call_set_time_finish() to get the result of the operation.
 *
 * See date_time_mechanism_call_set_time_sync() for the synchronous, blocking version of this method.
 */
void
date_time_mechanism_call_set_time (
    DateTimeMechanism *proxy,
    gint64 seconds_since_epoch,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetTime",
    g_variant_new ("(x)",
                   seconds_since_epoch),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * date_time_mechanism_call_set_time_finish:
 * @proxy: A #DateTimeMechanismProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to date_time_mechanism_call_set_time().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with date_time_mechanism_call_set_time().
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_set_time_finish (
    DateTimeMechanism *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_set_time_sync:
 * @proxy: A #DateTimeMechanismProxy.
 * @seconds_since_epoch: Argument to pass with the method invocation.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetTime">SetTime()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See date_time_mechanism_call_set_time() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_set_time_sync (
    DateTimeMechanism *proxy,
    gint64 seconds_since_epoch,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetTime",
    g_variant_new ("(x)",
                   seconds_since_epoch),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_can_set_time:
 * @proxy: A #DateTimeMechanismProxy.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.CanSetTime">CanSetTime()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 * You can then call date_time_mechanism_call_can_set_time_finish() to get the result of the operation.
 *
 * See date_time_mechanism_call_can_set_time_sync() for the synchronous, blocking version of this method.
 */
void
date_time_mechanism_call_can_set_time (
    DateTimeMechanism *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CanSetTime",
    g_variant_new ("()"),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * date_time_mechanism_call_can_set_time_finish:
 * @proxy: A #DateTimeMechanismProxy.
 * @out_value: (out): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to date_time_mechanism_call_can_set_time().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with date_time_mechanism_call_can_set_time().
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_can_set_time_finish (
    DateTimeMechanism *proxy,
    gint *out_value,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(i)",
                 out_value);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_can_set_time_sync:
 * @proxy: A #DateTimeMechanismProxy.
 * @out_value: (out): Return location for return parameter or %NULL to ignore.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.CanSetTime">CanSetTime()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See date_time_mechanism_call_can_set_time() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_can_set_time_sync (
    DateTimeMechanism *proxy,
    gint *out_value,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CanSetTime",
    g_variant_new ("()"),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(i)",
                 out_value);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_adjust_time:
 * @proxy: A #DateTimeMechanismProxy.
 * @seconds_to_add: Argument to pass with the method invocation.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.AdjustTime">AdjustTime()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 * You can then call date_time_mechanism_call_adjust_time_finish() to get the result of the operation.
 *
 * See date_time_mechanism_call_adjust_time_sync() for the synchronous, blocking version of this method.
 */
void
date_time_mechanism_call_adjust_time (
    DateTimeMechanism *proxy,
    gint64 seconds_to_add,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "AdjustTime",
    g_variant_new ("(x)",
                   seconds_to_add),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * date_time_mechanism_call_adjust_time_finish:
 * @proxy: A #DateTimeMechanismProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to date_time_mechanism_call_adjust_time().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with date_time_mechanism_call_adjust_time().
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_adjust_time_finish (
    DateTimeMechanism *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_adjust_time_sync:
 * @proxy: A #DateTimeMechanismProxy.
 * @seconds_to_add: Argument to pass with the method invocation.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.AdjustTime">AdjustTime()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See date_time_mechanism_call_adjust_time() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_adjust_time_sync (
    DateTimeMechanism *proxy,
    gint64 seconds_to_add,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "AdjustTime",
    g_variant_new ("(x)",
                   seconds_to_add),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_get_hardware_clock_using_utc:
 * @proxy: A #DateTimeMechanismProxy.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.GetHardwareClockUsingUtc">GetHardwareClockUsingUtc()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 * You can then call date_time_mechanism_call_get_hardware_clock_using_utc_finish() to get the result of the operation.
 *
 * See date_time_mechanism_call_get_hardware_clock_using_utc_sync() for the synchronous, blocking version of this method.
 */
void
date_time_mechanism_call_get_hardware_clock_using_utc (
    DateTimeMechanism *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "GetHardwareClockUsingUtc",
    g_variant_new ("()"),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * date_time_mechanism_call_get_hardware_clock_using_utc_finish:
 * @proxy: A #DateTimeMechanismProxy.
 * @out_is_using_utc: (out): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to date_time_mechanism_call_get_hardware_clock_using_utc().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with date_time_mechanism_call_get_hardware_clock_using_utc().
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_get_hardware_clock_using_utc_finish (
    DateTimeMechanism *proxy,
    gboolean *out_is_using_utc,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(b)",
                 out_is_using_utc);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_get_hardware_clock_using_utc_sync:
 * @proxy: A #DateTimeMechanismProxy.
 * @out_is_using_utc: (out): Return location for return parameter or %NULL to ignore.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.GetHardwareClockUsingUtc">GetHardwareClockUsingUtc()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See date_time_mechanism_call_get_hardware_clock_using_utc() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_get_hardware_clock_using_utc_sync (
    DateTimeMechanism *proxy,
    gboolean *out_is_using_utc,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "GetHardwareClockUsingUtc",
    g_variant_new ("()"),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(b)",
                 out_is_using_utc);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_set_hardware_clock_using_utc:
 * @proxy: A #DateTimeMechanismProxy.
 * @is_using_utc: Argument to pass with the method invocation.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetHardwareClockUsingUtc">SetHardwareClockUsingUtc()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 * You can then call date_time_mechanism_call_set_hardware_clock_using_utc_finish() to get the result of the operation.
 *
 * See date_time_mechanism_call_set_hardware_clock_using_utc_sync() for the synchronous, blocking version of this method.
 */
void
date_time_mechanism_call_set_hardware_clock_using_utc (
    DateTimeMechanism *proxy,
    gboolean is_using_utc,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetHardwareClockUsingUtc",
    g_variant_new ("(b)",
                   is_using_utc),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * date_time_mechanism_call_set_hardware_clock_using_utc_finish:
 * @proxy: A #DateTimeMechanismProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to date_time_mechanism_call_set_hardware_clock_using_utc().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with date_time_mechanism_call_set_hardware_clock_using_utc().
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_set_hardware_clock_using_utc_finish (
    DateTimeMechanism *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_set_hardware_clock_using_utc_sync:
 * @proxy: A #DateTimeMechanismProxy.
 * @is_using_utc: Argument to pass with the method invocation.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetHardwareClockUsingUtc">SetHardwareClockUsingUtc()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See date_time_mechanism_call_set_hardware_clock_using_utc() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_set_hardware_clock_using_utc_sync (
    DateTimeMechanism *proxy,
    gboolean is_using_utc,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetHardwareClockUsingUtc",
    g_variant_new ("(b)",
                   is_using_utc),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_get_using_ntp:
 * @proxy: A #DateTimeMechanismProxy.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.GetUsingNtp">GetUsingNtp()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 * You can then call date_time_mechanism_call_get_using_ntp_finish() to get the result of the operation.
 *
 * See date_time_mechanism_call_get_using_ntp_sync() for the synchronous, blocking version of this method.
 */
void
date_time_mechanism_call_get_using_ntp (
    DateTimeMechanism *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "GetUsingNtp",
    g_variant_new ("()"),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * date_time_mechanism_call_get_using_ntp_finish:
 * @proxy: A #DateTimeMechanismProxy.
 * @out_can_use_ntp: (out): Return location for return parameter or %NULL to ignore.
 * @out_is_using_ntp: (out): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to date_time_mechanism_call_get_using_ntp().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with date_time_mechanism_call_get_using_ntp().
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_get_using_ntp_finish (
    DateTimeMechanism *proxy,
    gboolean *out_can_use_ntp,
    gboolean *out_is_using_ntp,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(bb)",
                 out_can_use_ntp,
                 out_is_using_ntp);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_get_using_ntp_sync:
 * @proxy: A #DateTimeMechanismProxy.
 * @out_can_use_ntp: (out): Return location for return parameter or %NULL to ignore.
 * @out_is_using_ntp: (out): Return location for return parameter or %NULL to ignore.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.GetUsingNtp">GetUsingNtp()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See date_time_mechanism_call_get_using_ntp() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_get_using_ntp_sync (
    DateTimeMechanism *proxy,
    gboolean *out_can_use_ntp,
    gboolean *out_is_using_ntp,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "GetUsingNtp",
    g_variant_new ("()"),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(bb)",
                 out_can_use_ntp,
                 out_is_using_ntp);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_set_using_ntp:
 * @proxy: A #DateTimeMechanismProxy.
 * @is_using_ntp: Argument to pass with the method invocation.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetUsingNtp">SetUsingNtp()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 * You can then call date_time_mechanism_call_set_using_ntp_finish() to get the result of the operation.
 *
 * See date_time_mechanism_call_set_using_ntp_sync() for the synchronous, blocking version of this method.
 */
void
date_time_mechanism_call_set_using_ntp (
    DateTimeMechanism *proxy,
    gboolean is_using_ntp,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetUsingNtp",
    g_variant_new ("(b)",
                   is_using_ntp),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * date_time_mechanism_call_set_using_ntp_finish:
 * @proxy: A #DateTimeMechanismProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to date_time_mechanism_call_set_using_ntp().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with date_time_mechanism_call_set_using_ntp().
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_set_using_ntp_finish (
    DateTimeMechanism *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_set_using_ntp_sync:
 * @proxy: A #DateTimeMechanismProxy.
 * @is_using_ntp: Argument to pass with the method invocation.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetUsingNtp">SetUsingNtp()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See date_time_mechanism_call_set_using_ntp() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_set_using_ntp_sync (
    DateTimeMechanism *proxy,
    gboolean is_using_ntp,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetUsingNtp",
    g_variant_new ("(b)",
                   is_using_ntp),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_can_set_using_ntp:
 * @proxy: A #DateTimeMechanismProxy.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.CanSetUsingNtp">CanSetUsingNtp()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 * You can then call date_time_mechanism_call_can_set_using_ntp_finish() to get the result of the operation.
 *
 * See date_time_mechanism_call_can_set_using_ntp_sync() for the synchronous, blocking version of this method.
 */
void
date_time_mechanism_call_can_set_using_ntp (
    DateTimeMechanism *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CanSetUsingNtp",
    g_variant_new ("()"),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * date_time_mechanism_call_can_set_using_ntp_finish:
 * @proxy: A #DateTimeMechanismProxy.
 * @out_value: (out): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to date_time_mechanism_call_can_set_using_ntp().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with date_time_mechanism_call_can_set_using_ntp().
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_can_set_using_ntp_finish (
    DateTimeMechanism *proxy,
    gint *out_value,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(i)",
                 out_value);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_call_can_set_using_ntp_sync:
 * @proxy: A #DateTimeMechanismProxy.
 * @out_value: (out): Return location for return parameter or %NULL to ignore.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.CanSetUsingNtp">CanSetUsingNtp()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See date_time_mechanism_call_can_set_using_ntp() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 */
gboolean
date_time_mechanism_call_can_set_using_ntp_sync (
    DateTimeMechanism *proxy,
    gint *out_value,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CanSetUsingNtp",
    g_variant_new ("()"),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(i)",
                 out_value);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * date_time_mechanism_complete_set_timezone:
 * @object: A #DateTimeMechanism.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetTimezone">SetTimezone()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
date_time_mechanism_complete_set_timezone (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * date_time_mechanism_complete_get_timezone:
 * @object: A #DateTimeMechanism.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @timezone: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.GetTimezone">GetTimezone()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
date_time_mechanism_complete_get_timezone (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    const gchar *timezone)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(s)",
                   timezone));
}

/**
 * date_time_mechanism_complete_can_set_timezone:
 * @object: A #DateTimeMechanism.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @value: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.CanSetTimezone">CanSetTimezone()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
date_time_mechanism_complete_can_set_timezone (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    gint value)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(i)",
                   value));
}

/**
 * date_time_mechanism_complete_set_date:
 * @object: A #DateTimeMechanism.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetDate">SetDate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
date_time_mechanism_complete_set_date (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * date_time_mechanism_complete_set_time:
 * @object: A #DateTimeMechanism.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetTime">SetTime()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
date_time_mechanism_complete_set_time (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * date_time_mechanism_complete_can_set_time:
 * @object: A #DateTimeMechanism.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @value: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.CanSetTime">CanSetTime()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
date_time_mechanism_complete_can_set_time (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    gint value)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(i)",
                   value));
}

/**
 * date_time_mechanism_complete_adjust_time:
 * @object: A #DateTimeMechanism.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.AdjustTime">AdjustTime()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
date_time_mechanism_complete_adjust_time (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * date_time_mechanism_complete_get_hardware_clock_using_utc:
 * @object: A #DateTimeMechanism.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @is_using_utc: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.GetHardwareClockUsingUtc">GetHardwareClockUsingUtc()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
date_time_mechanism_complete_get_hardware_clock_using_utc (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    gboolean is_using_utc)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(b)",
                   is_using_utc));
}

/**
 * date_time_mechanism_complete_set_hardware_clock_using_utc:
 * @object: A #DateTimeMechanism.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetHardwareClockUsingUtc">SetHardwareClockUsingUtc()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
date_time_mechanism_complete_set_hardware_clock_using_utc (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * date_time_mechanism_complete_get_using_ntp:
 * @object: A #DateTimeMechanism.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @can_use_ntp: Parameter to return.
 * @is_using_ntp: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.GetUsingNtp">GetUsingNtp()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
date_time_mechanism_complete_get_using_ntp (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    gboolean can_use_ntp,
    gboolean is_using_ntp)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(bb)",
                   can_use_ntp,
                   is_using_ntp));
}

/**
 * date_time_mechanism_complete_set_using_ntp:
 * @object: A #DateTimeMechanism.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.SetUsingNtp">SetUsingNtp()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
date_time_mechanism_complete_set_using_ntp (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * date_time_mechanism_complete_can_set_using_ntp:
 * @object: A #DateTimeMechanism.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @value: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-gnome-SettingsDaemon-DateTimeMechanism.CanSetUsingNtp">CanSetUsingNtp()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
date_time_mechanism_complete_can_set_using_ntp (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    gint value)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(i)",
                   value));
}

/* ------------------------------------------------------------------------ */

/**
 * DateTimeMechanismProxy:
 *
 * The #DateTimeMechanismProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * DateTimeMechanismProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #DateTimeMechanismProxy.
 */

static void
date_time_mechanism_proxy_iface_init (DateTimeMechanismIface *iface)
{
}

#define date_time_mechanism_proxy_get_type date_time_mechanism_proxy_get_type
G_DEFINE_TYPE_WITH_CODE (DateTimeMechanismProxy, date_time_mechanism_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (TYPE_DATE_TIME_MECHANISM, date_time_mechanism_proxy_iface_init));
#undef date_time_mechanism_proxy_get_type

static void
date_time_mechanism_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec)
{
}

static void
date_time_mechanism_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
}

static void
date_time_mechanism_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  guint num_params;
  guint n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_date_time_mechanism_interface_info, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], TYPE_DATE_TIME_MECHANISM);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, TYPE_DATE_TIME_MECHANISM);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
date_time_mechanism_proxy_g_properties_changed (GDBusProxy *proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_date_time_mechanism_interface_info, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_date_time_mechanism_interface_info, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static void
date_time_mechanism_proxy_init (DateTimeMechanismProxy *proxy)
{
  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), date_time_mechanism_interface_info ());
}

static void
date_time_mechanism_proxy_class_init (DateTimeMechanismProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->get_property = date_time_mechanism_proxy_get_property;
  gobject_class->set_property = date_time_mechanism_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = date_time_mechanism_proxy_g_signal;
  proxy_class->g_properties_changed = date_time_mechanism_proxy_g_properties_changed;

}

/**
 * date_time_mechanism_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-gnome-SettingsDaemon-DateTimeMechanism.top_of_page">org.gnome.SettingsDaemon.DateTimeMechanism</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 * You can then call date_time_mechanism_proxy_new_finish() to get the result of the operation.
 *
 * See date_time_mechanism_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
date_time_mechanism_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (TYPE_DATE_TIME_MECHANISM_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.gnome.SettingsDaemon.DateTimeMechanism", NULL);
}

/**
 * date_time_mechanism_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to date_time_mechanism_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with date_time_mechanism_proxy_new().
 *
 * Returns: (transfer full) (type DateTimeMechanismProxy): The constructed proxy object or %NULL if @error is set.
 */
DateTimeMechanism *
date_time_mechanism_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return DATE_TIME_MECHANISM (ret);
  else
    return NULL;
}

/**
 * date_time_mechanism_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-gnome-SettingsDaemon-DateTimeMechanism.top_of_page">org.gnome.SettingsDaemon.DateTimeMechanism</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See date_time_mechanism_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type DateTimeMechanismProxy): The constructed proxy object or %NULL if @error is set.
 */
DateTimeMechanism *
date_time_mechanism_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (TYPE_DATE_TIME_MECHANISM_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.gnome.SettingsDaemon.DateTimeMechanism", NULL);
  if (ret != NULL)
    return DATE_TIME_MECHANISM (ret);
  else
    return NULL;
}


/**
 * date_time_mechanism_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like date_time_mechanism_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 * You can then call date_time_mechanism_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See date_time_mechanism_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
date_time_mechanism_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (TYPE_DATE_TIME_MECHANISM_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.gnome.SettingsDaemon.DateTimeMechanism", NULL);
}

/**
 * date_time_mechanism_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to date_time_mechanism_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with date_time_mechanism_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type DateTimeMechanismProxy): The constructed proxy object or %NULL if @error is set.
 */
DateTimeMechanism *
date_time_mechanism_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return DATE_TIME_MECHANISM (ret);
  else
    return NULL;
}

/**
 * date_time_mechanism_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (allow-none): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like date_time_mechanism_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See date_time_mechanism_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type DateTimeMechanismProxy): The constructed proxy object or %NULL if @error is set.
 */
DateTimeMechanism *
date_time_mechanism_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (TYPE_DATE_TIME_MECHANISM_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.gnome.SettingsDaemon.DateTimeMechanism", NULL);
  if (ret != NULL)
    return DATE_TIME_MECHANISM (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * DateTimeMechanismSkeleton:
 *
 * The #DateTimeMechanismSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * DateTimeMechanismSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #DateTimeMechanismSkeleton.
 */

struct _DateTimeMechanismSkeletonPrivate
{
  GValueArray *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex *lock;
};

static void
_date_time_mechanism_skeleton_handle_method_call (
  GDBusConnection *connection,
  const gchar *sender,
  const gchar *object_path,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  DateTimeMechanismSkeleton *skeleton = DATE_TIME_MECHANISM_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  guint num_params;
  guint n;
  guint signal_id;
  GValue return_value = {0};
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 2);
  g_value_init (&paramv[0], TYPE_DATE_TIME_MECHANISM);
  g_value_set_object (&paramv[0], skeleton);
  g_value_init (&paramv[1], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[1], invocation);
  g_variant_iter_init (&iter, parameters);
  n = 2;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - 2];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, TYPE_DATE_TIME_MECHANISM);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + 2; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_date_time_mechanism_skeleton_handle_get_property (
  GDBusConnection *connection,
  const gchar *sender,
  const gchar *object_path,
  const gchar *interface_name,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  DateTimeMechanismSkeleton *skeleton = DATE_TIME_MECHANISM_SKELETON (user_data);
  GValue value = {0};
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_date_time_mechanism_interface_info, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_date_time_mechanism_skeleton_handle_set_property (
  GDBusConnection *connection,
  const gchar *sender,
  const gchar *object_path,
  const gchar *interface_name,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  DateTimeMechanismSkeleton *skeleton = DATE_TIME_MECHANISM_SKELETON (user_data);
  GValue value = {0};
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_date_time_mechanism_interface_info, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _date_time_mechanism_skeleton_vtable =
{
  _date_time_mechanism_skeleton_handle_method_call,
  _date_time_mechanism_skeleton_handle_get_property,
  _date_time_mechanism_skeleton_handle_set_property
};

static GDBusInterfaceInfo *
date_time_mechanism_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton)
{
  return date_time_mechanism_interface_info ();
}

static GDBusInterfaceVTable *
date_time_mechanism_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton)
{
  return (GDBusInterfaceVTable *) &_date_time_mechanism_skeleton_vtable;
}

static GVariant *
date_time_mechanism_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  DateTimeMechanismSkeleton *skeleton = DATE_TIME_MECHANISM_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  if (_date_time_mechanism_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _date_time_mechanism_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _date_time_mechanism_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _date_time_mechanism_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.gnome.SettingsDaemon.DateTimeMechanism", info->name, NULL, skeleton);
          if (value != NULL)
            {
              if (g_variant_is_floating (value))
                g_variant_ref_sink (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static void
date_time_mechanism_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
}

static void
date_time_mechanism_skeleton_iface_init (DateTimeMechanismIface *iface)
{
}

#define date_time_mechanism_skeleton_get_type date_time_mechanism_skeleton_get_type
G_DEFINE_TYPE_WITH_CODE (DateTimeMechanismSkeleton, date_time_mechanism_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (TYPE_DATE_TIME_MECHANISM, date_time_mechanism_skeleton_iface_init));
#undef date_time_mechanism_skeleton_get_type

static void
date_time_mechanism_skeleton_finalize (GObject *object)
{
  DateTimeMechanismSkeleton *skeleton = DATE_TIME_MECHANISM_SKELETON (object);
  g_list_foreach (skeleton->priv->changed_properties, (GFunc) _changed_property_free, NULL);
  g_list_free (skeleton->priv->changed_properties);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
  if (skeleton->priv->context != NULL)
    g_main_context_unref (skeleton->priv->context);
  g_mutex_free (skeleton->priv->lock);
  G_OBJECT_CLASS (date_time_mechanism_skeleton_parent_class)->finalize (object);
}

static void
date_time_mechanism_skeleton_init (DateTimeMechanismSkeleton *skeleton)
{
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_DATE_TIME_MECHANISM_SKELETON, DateTimeMechanismSkeletonPrivate);
  skeleton->priv->lock = g_mutex_new ();
  skeleton->priv->context = g_main_context_get_thread_default ();
  if (skeleton->priv->context != NULL)
    g_main_context_ref (skeleton->priv->context);
}

static void
date_time_mechanism_skeleton_class_init (DateTimeMechanismSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  g_type_class_add_private (klass, sizeof (DateTimeMechanismSkeletonPrivate));

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = date_time_mechanism_skeleton_finalize;

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = date_time_mechanism_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = date_time_mechanism_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = date_time_mechanism_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = date_time_mechanism_skeleton_dbus_interface_get_vtable;
}

/**
 * date_time_mechanism_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-gnome-SettingsDaemon-DateTimeMechanism.top_of_page">org.gnome.SettingsDaemon.DateTimeMechanism</link>.
 *
 * Returns: (transfer full) (type DateTimeMechanismSkeleton): The skeleton object.
 */
DateTimeMechanism *
date_time_mechanism_skeleton_new (void)
{
  return DATE_TIME_MECHANISM (g_object_new (TYPE_DATE_TIME_MECHANISM_SKELETON, NULL));
}





/*
 * Generated by gdbus-codegen 2.29.5. DO NOT EDIT.
 *
 * The license of this code is the same as for the source it was derived from.
 */

#ifndef __DTM_H__
#define __DTM_H__

#include <gio/gio.h>

G_BEGIN_DECLS


/* ------------------------------------------------------------------------ */
/* Declarations for org.gnome.SettingsDaemon.DateTimeMechanism */

#define TYPE_DATE_TIME_MECHANISM (date_time_mechanism_get_type ())
#define DATE_TIME_MECHANISM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_DATE_TIME_MECHANISM, DateTimeMechanism))
#define IS_DATE_TIME_MECHANISM(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_DATE_TIME_MECHANISM))
#define DATE_TIME_MECHANISM_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_DATE_TIME_MECHANISM, DateTimeMechanism))

struct _DateTimeMechanism;
typedef struct _DateTimeMechanism DateTimeMechanism;
typedef struct _DateTimeMechanismIface DateTimeMechanismIface;

struct _DateTimeMechanismIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_adjust_time) (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    gint64 seconds_to_add);

  gboolean (*handle_can_set_time) (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_can_set_timezone) (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_can_set_using_ntp) (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_get_hardware_clock_using_utc) (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_get_timezone) (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_get_using_ntp) (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_set_date) (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    guint day,
    guint month,
    guint year);

  gboolean (*handle_set_hardware_clock_using_utc) (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    gboolean is_using_utc);

  gboolean (*handle_set_time) (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    gint64 seconds_since_epoch);

  gboolean (*handle_set_timezone) (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    const gchar *tz);

  gboolean (*handle_set_using_ntp) (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    gboolean is_using_ntp);

};

GType date_time_mechanism_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *date_time_mechanism_interface_info (void);


/* D-Bus method call completion functions: */
void date_time_mechanism_complete_set_timezone (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation);

void date_time_mechanism_complete_get_timezone (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    const gchar *timezone);

void date_time_mechanism_complete_can_set_timezone (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    gint value);

void date_time_mechanism_complete_set_date (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation);

void date_time_mechanism_complete_set_time (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation);

void date_time_mechanism_complete_can_set_time (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    gint value);

void date_time_mechanism_complete_adjust_time (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation);

void date_time_mechanism_complete_get_hardware_clock_using_utc (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    gboolean is_using_utc);

void date_time_mechanism_complete_set_hardware_clock_using_utc (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation);

void date_time_mechanism_complete_get_using_ntp (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    gboolean can_use_ntp,
    gboolean is_using_ntp);

void date_time_mechanism_complete_set_using_ntp (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation);

void date_time_mechanism_complete_can_set_using_ntp (
    DateTimeMechanism *object,
    GDBusMethodInvocation *invocation,
    gint value);



/* D-Bus method calls: */
void date_time_mechanism_call_set_timezone (
    DateTimeMechanism *proxy,
    const gchar *tz,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean date_time_mechanism_call_set_timezone_finish (
    DateTimeMechanism *proxy,
    GAsyncResult *res,
    GError **error);

gboolean date_time_mechanism_call_set_timezone_sync (
    DateTimeMechanism *proxy,
    const gchar *tz,
    GCancellable *cancellable,
    GError **error);

void date_time_mechanism_call_get_timezone (
    DateTimeMechanism *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean date_time_mechanism_call_get_timezone_finish (
    DateTimeMechanism *proxy,
    gchar **out_timezone,
    GAsyncResult *res,
    GError **error);

gboolean date_time_mechanism_call_get_timezone_sync (
    DateTimeMechanism *proxy,
    gchar **out_timezone,
    GCancellable *cancellable,
    GError **error);

void date_time_mechanism_call_can_set_timezone (
    DateTimeMechanism *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean date_time_mechanism_call_can_set_timezone_finish (
    DateTimeMechanism *proxy,
    gint *out_value,
    GAsyncResult *res,
    GError **error);

gboolean date_time_mechanism_call_can_set_timezone_sync (
    DateTimeMechanism *proxy,
    gint *out_value,
    GCancellable *cancellable,
    GError **error);

void date_time_mechanism_call_set_date (
    DateTimeMechanism *proxy,
    guint day,
    guint month,
    guint year,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean date_time_mechanism_call_set_date_finish (
    DateTimeMechanism *proxy,
    GAsyncResult *res,
    GError **error);

gboolean date_time_mechanism_call_set_date_sync (
    DateTimeMechanism *proxy,
    guint day,
    guint month,
    guint year,
    GCancellable *cancellable,
    GError **error);

void date_time_mechanism_call_set_time (
    DateTimeMechanism *proxy,
    gint64 seconds_since_epoch,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean date_time_mechanism_call_set_time_finish (
    DateTimeMechanism *proxy,
    GAsyncResult *res,
    GError **error);

gboolean date_time_mechanism_call_set_time_sync (
    DateTimeMechanism *proxy,
    gint64 seconds_since_epoch,
    GCancellable *cancellable,
    GError **error);

void date_time_mechanism_call_can_set_time (
    DateTimeMechanism *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean date_time_mechanism_call_can_set_time_finish (
    DateTimeMechanism *proxy,
    gint *out_value,
    GAsyncResult *res,
    GError **error);

gboolean date_time_mechanism_call_can_set_time_sync (
    DateTimeMechanism *proxy,
    gint *out_value,
    GCancellable *cancellable,
    GError **error);

void date_time_mechanism_call_adjust_time (
    DateTimeMechanism *proxy,
    gint64 seconds_to_add,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean date_time_mechanism_call_adjust_time_finish (
    DateTimeMechanism *proxy,
    GAsyncResult *res,
    GError **error);

gboolean date_time_mechanism_call_adjust_time_sync (
    DateTimeMechanism *proxy,
    gint64 seconds_to_add,
    GCancellable *cancellable,
    GError **error);

void date_time_mechanism_call_get_hardware_clock_using_utc (
    DateTimeMechanism *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean date_time_mechanism_call_get_hardware_clock_using_utc_finish (
    DateTimeMechanism *proxy,
    gboolean *out_is_using_utc,
    GAsyncResult *res,
    GError **error);

gboolean date_time_mechanism_call_get_hardware_clock_using_utc_sync (
    DateTimeMechanism *proxy,
    gboolean *out_is_using_utc,
    GCancellable *cancellable,
    GError **error);

void date_time_mechanism_call_set_hardware_clock_using_utc (
    DateTimeMechanism *proxy,
    gboolean is_using_utc,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean date_time_mechanism_call_set_hardware_clock_using_utc_finish (
    DateTimeMechanism *proxy,
    GAsyncResult *res,
    GError **error);

gboolean date_time_mechanism_call_set_hardware_clock_using_utc_sync (
    DateTimeMechanism *proxy,
    gboolean is_using_utc,
    GCancellable *cancellable,
    GError **error);

void date_time_mechanism_call_get_using_ntp (
    DateTimeMechanism *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean date_time_mechanism_call_get_using_ntp_finish (
    DateTimeMechanism *proxy,
    gboolean *out_can_use_ntp,
    gboolean *out_is_using_ntp,
    GAsyncResult *res,
    GError **error);

gboolean date_time_mechanism_call_get_using_ntp_sync (
    DateTimeMechanism *proxy,
    gboolean *out_can_use_ntp,
    gboolean *out_is_using_ntp,
    GCancellable *cancellable,
    GError **error);

void date_time_mechanism_call_set_using_ntp (
    DateTimeMechanism *proxy,
    gboolean is_using_ntp,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean date_time_mechanism_call_set_using_ntp_finish (
    DateTimeMechanism *proxy,
    GAsyncResult *res,
    GError **error);

gboolean date_time_mechanism_call_set_using_ntp_sync (
    DateTimeMechanism *proxy,
    gboolean is_using_ntp,
    GCancellable *cancellable,
    GError **error);

void date_time_mechanism_call_can_set_using_ntp (
    DateTimeMechanism *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean date_time_mechanism_call_can_set_using_ntp_finish (
    DateTimeMechanism *proxy,
    gint *out_value,
    GAsyncResult *res,
    GError **error);

gboolean date_time_mechanism_call_can_set_using_ntp_sync (
    DateTimeMechanism *proxy,
    gint *out_value,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define TYPE_DATE_TIME_MECHANISM_PROXY (date_time_mechanism_proxy_get_type ())
#define DATE_TIME_MECHANISM_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_DATE_TIME_MECHANISM_PROXY, DateTimeMechanismProxy))
#define DATE_TIME_MECHANISM_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_DATE_TIME_MECHANISM_PROXY, DateTimeMechanismProxyClass))
#define DATE_TIME_MECHANISM_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_DATE_TIME_MECHANISM_PROXY, DateTimeMechanismProxyClass))
#define IS_DATE_TIME_MECHANISM_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_DATE_TIME_MECHANISM_PROXY))
#define IS_DATE_TIME_MECHANISM_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_DATE_TIME_MECHANISM_PROXY))

typedef struct _DateTimeMechanismProxy DateTimeMechanismProxy;
typedef struct _DateTimeMechanismProxyClass DateTimeMechanismProxyClass;
typedef struct _DateTimeMechanismProxyPrivate DateTimeMechanismProxyPrivate;

struct _DateTimeMechanismProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  DateTimeMechanismProxyPrivate *priv;
};

struct _DateTimeMechanismProxyClass
{
  GDBusProxyClass parent_class;
};

GType date_time_mechanism_proxy_get_type (void) G_GNUC_CONST;

void date_time_mechanism_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
DateTimeMechanism *date_time_mechanism_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
DateTimeMechanism *date_time_mechanism_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void date_time_mechanism_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
DateTimeMechanism *date_time_mechanism_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
DateTimeMechanism *date_time_mechanism_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define TYPE_DATE_TIME_MECHANISM_SKELETON (date_time_mechanism_skeleton_get_type ())
#define DATE_TIME_MECHANISM_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_DATE_TIME_MECHANISM_SKELETON, DateTimeMechanismSkeleton))
#define DATE_TIME_MECHANISM_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_DATE_TIME_MECHANISM_SKELETON, DateTimeMechanismSkeletonClass))
#define DATE_TIME_MECHANISM_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_DATE_TIME_MECHANISM_SKELETON, DateTimeMechanismSkeletonClass))
#define IS_DATE_TIME_MECHANISM_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_DATE_TIME_MECHANISM_SKELETON))
#define IS_DATE_TIME_MECHANISM_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_DATE_TIME_MECHANISM_SKELETON))

typedef struct _DateTimeMechanismSkeleton DateTimeMechanismSkeleton;
typedef struct _DateTimeMechanismSkeletonClass DateTimeMechanismSkeletonClass;
typedef struct _DateTimeMechanismSkeletonPrivate DateTimeMechanismSkeletonPrivate;

struct _DateTimeMechanismSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  DateTimeMechanismSkeletonPrivate *priv;
};

struct _DateTimeMechanismSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType date_time_mechanism_skeleton_get_type (void) G_GNUC_CONST;

DateTimeMechanism *date_time_mechanism_skeleton_new (void);


G_END_DECLS

#endif /* __DTM_H__ */




<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE policyconfig PUBLIC
 "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
 "http://www.freedesktop.org/standards/PolicyKit/1.0/policyconfig.dtd">

<policyconfig>
  <vendor>The GNOME Project</vendor>
  <vendor_url>http://www.gnome.org/</vendor_url>

  <action id="org.gnome.controlcenter.datetime.configure">
    <_description>Change system time and date settings</_description>
    <_message>To change time or date settings, you need to authenticate.</_message>
    <defaults>
      <allow_any>no</allow_any>
      <allow_inactive>no</allow_inactive>
      <allow_active>auth_admin_keep</allow_active>
    </defaults>
    <annotate key="org.freedesktop.policykit.imply">org.freedesktop.timedate1.set-time org.freedesktop.timedate1.set-timezone org.freedesktop.timedate1.set-local-rtc org.freedesktop.timedate1.set-ntp</annotate>
  </action>

</policyconfig>




/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2007 David Zeuthen <david@fubar.dk>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif

#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>

#include <dbus/dbus-glib.h>
#include <dbus/dbus-glib-lowlevel.h>

#include "set-timezone.h"


static DBusGConnection *
get_system_bus (GError **err)
{
        GError          *error;
        static DBusGConnection *bus = NULL;

	if (bus == NULL) {
        	error = NULL;
        	bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
        	if (bus == NULL) {
			g_propagate_error (err, error);
		}
        }

        return bus;
}

#define CACHE_VALIDITY_SEC 2

typedef  void (*CanDoFunc) (gint value);

static void
notify_can_do (DBusGProxy     *proxy,
	       DBusGProxyCall *call,
	       void           *user_data)
{
	CanDoFunc callback = user_data;
	GError *error = NULL;
	gint value;

	if (dbus_g_proxy_end_call (proxy, call,
				   &error,
				   G_TYPE_INT, &value,
				   G_TYPE_INVALID)) {
		callback (value);
	}
}

static void
refresh_can_do (const gchar *action, CanDoFunc callback)
{
        DBusGConnection *bus;
        DBusGProxy      *proxy;

        bus = get_system_bus (NULL);
        if (bus == NULL)
                return;

	proxy = dbus_g_proxy_new_for_name (bus,
					   "org.gnome.SettingsDaemon.DateTimeMechanism",
					   "/",
					   "org.gnome.SettingsDaemon.DateTimeMechanism");

	dbus_g_proxy_begin_call_with_timeout (proxy,
					      action,
					      notify_can_do,
					      callback, NULL,
					      INT_MAX,
					      G_TYPE_INVALID);
}

static gint   settimezone_cache = 0;
static time_t settimezone_stamp = 0;

static void
update_can_settimezone (gint res)
{
	settimezone_cache = res;
	time (&settimezone_stamp);
}

gint
can_set_system_timezone (void)
{
	time_t          now;

	time (&now);
	if (ABS (now - settimezone_stamp) > CACHE_VALIDITY_SEC) {
		refresh_can_do ("CanSetTimezone", update_can_settimezone);
		settimezone_stamp = now;
	}

	return settimezone_cache;
}

static gint   settime_cache = 0;
static time_t settime_stamp = 0;

static void
update_can_settime (gint res)
{
	settime_cache = res;
	time (&settime_stamp);
}

gint
can_set_system_time (void)
{
	time_t now;

	time (&now);
	if (ABS (now - settime_stamp) > CACHE_VALIDITY_SEC) {
		refresh_can_do ("CanSetTime", update_can_settime);
		settime_stamp = now;
	}

	return settime_cache;
}

static gint   usingntp_cache = 0;
static time_t usingntp_stamp = 0;

static void
update_can_usingntp (gint res)
{
	usingntp_cache = res;
	time (&usingntp_stamp);
}

gint
can_set_using_ntp (void)
{
	time_t now;

	time (&now);
	if (ABS (now - usingntp_stamp) > CACHE_VALIDITY_SEC) {
		refresh_can_do ("CanSetUsingNtp", update_can_usingntp);
		settime_stamp = now;
	}

	return usingntp_cache;
}

typedef struct {
	gint ref_count;
        gchar *call;
	gint64 time;
	gchar *tz;
	gboolean using_ntp;
	GFunc callback;
	gpointer data;
	GDestroyNotify notify;
} SetTimeCallbackData;

static void
free_data (gpointer d)
{
	SetTimeCallbackData *data = d;

	data->ref_count--;
	if (data->ref_count == 0) {
		if (data->notify)
			data->notify (data->data);
		g_free (data->tz);
		g_free (data);
	}
}

static void
set_time_notify (DBusGProxy     *proxy,
		 DBusGProxyCall *call,
		 void           *user_data)
{
	SetTimeCallbackData *data = user_data;
	GError *error = NULL;

	if (dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID)) {
		if (data->callback)
			data->callback (data->data, NULL);
	}
	else {
		if (error->domain == DBUS_GERROR &&
		    error->code == DBUS_GERROR_NO_REPLY) {
			/* these errors happen because dbus doesn't
			 * use monotonic clocks
			 */	
			g_warning ("ignoring no-reply error when setting time");
			g_error_free (error);
			if (data->callback)
				data->callback (data->data, NULL);
		}
		else {
			if (data->callback)
				data->callback (data->data, error);
			else
				g_error_free (error);
		}		
	}
}

static void
set_time_async (SetTimeCallbackData *data)
{
        DBusGConnection *bus;
        DBusGProxy      *proxy;
	GError          *err = NULL;

        bus = get_system_bus (&err);
        if (bus == NULL) {
		if (err) {
			if (data->callback)
				data->callback (data->data, err);
			g_clear_error (&err);
		}
		return;
	}

	proxy = dbus_g_proxy_new_for_name (bus,
					   "org.gnome.SettingsDaemon.DateTimeMechanism",
					   "/",
					   "org.gnome.SettingsDaemon.DateTimeMechanism");

	data->ref_count++;
	if (strcmp (data->call, "SetTime") == 0)
		dbus_g_proxy_begin_call_with_timeout (proxy,
						      "SetTime",
						      set_time_notify,
						      data, free_data,
						      INT_MAX,
						      /* parameters: */
						      G_TYPE_INT64, data->time,
						      G_TYPE_INVALID,
						      /* return values: */
						      G_TYPE_INVALID);
	else if (strcmp (data->call, "SetTimezone") == 0)
		dbus_g_proxy_begin_call_with_timeout (proxy,
						      "SetTimezone",
						      set_time_notify,
						      data, free_data,
						      INT_MAX,
						      /* parameters: */
						      G_TYPE_STRING, data->tz,
						      G_TYPE_INVALID,
						      /* return values: */
						      G_TYPE_INVALID);
	else if (strcmp (data->call, "SetUsingNtp") == 0)
		dbus_g_proxy_begin_call_with_timeout (proxy,
						      "SetUsingNtp",
						      set_time_notify,
						      data, free_data,
						      INT_MAX,
						      /* parameters: */
						      G_TYPE_BOOLEAN, data->using_ntp,
						      G_TYPE_INVALID,
						      /* return values: */
						      G_TYPE_INVALID);
}

void
set_system_time_async (gint64         time,
		       GFunc          callback,
		       gpointer       d,
		       GDestroyNotify notify)
{
	SetTimeCallbackData *data;

	if (time == -1)
		return;

	data = g_new0 (SetTimeCallbackData, 1);
	data->ref_count = 1;
	data->call = "SetTime";
	data->time = time;
	data->tz = NULL;
	data->callback = callback;
	data->data = d;
	data->notify = notify;

	set_time_async (data);
	free_data (data);
}

void
set_system_timezone_async (const gchar    *tz,
			   GFunc           callback,
			   gpointer        d,
			   GDestroyNotify  notify)
{
	SetTimeCallbackData *data;

	g_return_if_fail (tz != NULL);

	data = g_new0 (SetTimeCallbackData, 1);
	data->ref_count = 1;
	data->call = "SetTimezone";
	data->time = -1;
	data->tz = g_strdup (tz);
	data->callback = callback;
	data->data = d;
	data->notify = notify;

	set_time_async (data);
	free_data (data);
}

/* get timezone */

typedef struct
{
  GetTimezoneFunc callback;
  GDestroyNotify notify;

  gpointer data;

} GetTimezoneData;

static void
get_timezone_destroy_notify (GetTimezoneData *data)
{
	if (data->notify && data->data)
		data->notify (data);

	g_free (data);
}

static void
get_timezone_notify (DBusGProxy     *proxy,
		     DBusGProxyCall *call,
		     void           *user_data)
{
	GError *error = NULL;
	gboolean retval;
	gchar *string = NULL;
	GetTimezoneData *data = user_data;

	retval = dbus_g_proxy_end_call (proxy, call, &error,
					G_TYPE_STRING, &string,
					G_TYPE_INVALID);

	if (data->callback) {
		if (!retval) {
			data->callback (data->data, NULL, error);
			g_error_free (error);
		}
		else {
			data->callback (data->data, string, NULL);
			g_free (string);
		}
	}
}

void
get_system_timezone_async (GetTimezoneFunc callback,
			   gpointer        user_data,
			   GDestroyNotify  notify)
{
	DBusGConnection *bus;
	DBusGProxy      *proxy;
	GetTimezoneData *data;
	GError          *error = NULL;

	bus = get_system_bus (&error);
	if (bus == NULL) {
		if (error) {
			if (callback)
				callback (user_data, NULL, error);
			g_clear_error (&error);
		}
		return;

        }

	data = g_new0 (GetTimezoneData, 1);
	data->data = user_data;
	data->notify = notify;
	data->callback = callback;

	proxy = dbus_g_proxy_new_for_name (bus,
					   "org.gnome.SettingsDaemon.DateTimeMechanism",
					   "/",
					   "org.gnome.SettingsDaemon.DateTimeMechanism");

	dbus_g_proxy_begin_call (proxy,
				 "GetTimezone",
				 get_timezone_notify,
				 data,
				 (GDestroyNotify) get_timezone_destroy_notify,
				 /* parameters: */
				 G_TYPE_INVALID,
				 /* return values: */
				 G_TYPE_STRING,
				 G_TYPE_INVALID);

}

gboolean
get_using_ntp (void)
{
	static gboolean is_using_cache = FALSE;
	static time_t   last_refreshed = 0;
	time_t          now;
        DBusGConnection *bus;
        DBusGProxy      *proxy;

	time (&now);
	if (ABS (now - last_refreshed) > CACHE_VALIDITY_SEC) {
		gboolean cu, iu;
		bus = get_system_bus (NULL);
		if (bus == NULL)
			return FALSE;

		proxy = dbus_g_proxy_new_for_name (bus,
						   "org.gnome.SettingsDaemon.DateTimeMechanism",
						   "/",
						   "org.gnome.SettingsDaemon.DateTimeMechanism");


		if (dbus_g_proxy_call (proxy,
				       "GetUsingNtp",
				       NULL,
				       G_TYPE_INVALID,
				       G_TYPE_BOOLEAN, &cu,
				       G_TYPE_BOOLEAN, &iu,
				       G_TYPE_INVALID)) {
			is_using_cache = iu;
			last_refreshed = now;
		}
	}

	return is_using_cache;
}

void
set_using_ntp_async (gboolean        using_ntp,
	             GFunc           callback,
	             gpointer        d,
	             GDestroyNotify  notify)
{
	SetTimeCallbackData *data;

	data = g_new0 (SetTimeCallbackData, 1);
	data->ref_count = 1;
	data->call = "SetUsingNtp";
	data->time = -1;
	data->using_ntp = using_ntp;
	data->callback = callback;
	data->data = d;
	data->notify = notify;

	set_time_async (data);
	free_data (data);
}




/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2007 David Zeuthen <david@fubar.dk>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#ifndef __SET_SYSTEM_TIMEZONE_H__

#include <config.h>

#include <glib.h>
#include <time.h>

typedef void (*GetTimezoneFunc) (gpointer     data,
                                 const gchar *timezone,
                                 GError      *error);
void     get_system_timezone_async   (GetTimezoneFunc callback,
                                      gpointer        data,
                                      GDestroyNotify  notify);

gint     can_set_system_timezone (void);

gint     can_set_system_time     (void);

gint     can_set_using_ntp       (void);

void     set_system_time_async   (gint64         time,
                                  GFunc          callback,
                                  gpointer       data,
                                  GDestroyNotify notify);

void     set_system_timezone_async   (const gchar    *tz,
                                      GFunc           callback,
                                      gpointer        data,
                                      GDestroyNotify  notify);

gboolean get_using_ntp               (void);

void     set_using_ntp_async         (gboolean        using_ntp,
                                      GFunc           callback,
                                      gpointer        data,
                                      GDestroyNotify  notify);
#endif




<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
<node>
 <interface name="org.freedesktop.timedate1">
  <property name="Timezone" type="s" access="read"/>
  <property name="LocalRTC" type="b" access="read"/>
  <property name="NTP" type="b" access="read"/>
  <method name="SetTime">
   <arg name="usec_utc" type="x" direction="in"/>
   <arg name="relative" type="b" direction="in"/>
   <arg name="user_interaction" type="b" direction="in"/>
  </method>
  <method name="SetTimezone">
   <arg name="timezone" type="s" direction="in"/>
   <arg name="user_interaction" type="b" direction="in"/>
  </method>
  <method name="SetLocalRTC">
   <arg name="local_rtc" type="b" direction="in"/>
   <arg name="fix_system" type="b" direction="in"/>
   <arg name="user_interaction" type="b" direction="in"/>
  </method>
  <method name="SetNTP">
   <arg name="use_ntp" type="b" direction="in"/>
   <arg name="user_interaction" type="b" direction="in"/>
  </method>
 </interface>
</node>

Lines 18-24 panels/common/gdm-languages.c Link Here

(-)a/po/POTFILES.in (-2 lines)
18	[type: gettext/glade]panels/common/language-chooser.ui	18	[type: gettext/glade]panels/common/language-chooser.ui
19	[type: gettext/glade]panels/datetime/datetime.ui	19	[type: gettext/glade]panels/datetime/datetime.ui
20	panels/datetime/gnome-datetime-panel.desktop.in.in	20	panels/datetime/gnome-datetime-panel.desktop.in.in
21	panels/datetime/org.gnome.controlcenter.datetime.policy.in
22	panels/display/cc-display-panel.c	21	panels/display/cc-display-panel.c
23	[type: gettext/glade]panels/display/display-capplet.ui	22	[type: gettext/glade]panels/display/display-capplet.ui
24	panels/display/gnome-display-panel.desktop.in.in	23	panels/display/gnome-display-panel.desktop.in.in
25	-

Return to bug 796055

Lines 98-121 check-local: test-timezone-gfx test-endianess test-timezone Link Here

(-)a/panels/datetime/Makefile.am (-40 / +10 lines)
98	ccpanelsdir = $(PANELS_DIR)	98	ccpanelsdir = $(PANELS_DIR)
99	ccpanels_LTLIBRARIES = libdate_time.la	99	ccpanels_LTLIBRARIES = libdate_time.la
100		100
101		101	# FIXME add a way to regenerate the dtm.[ch]
102	# This requires running d-bus session and accessible timedate1 daemon	102	# gdbus-codegen --generate-c-code dtm --interface-prefix org.gnome.SettingsDaemon /path/to/gnome-settings-daemon/plugins/datetime/gsd-datetime-mechanism.xml
103	# FIXME: need to find a way how to filter out unnecessary d-bus stuff (introspectable, properties)	103	# See also:
104	#timedated1-interface.xml:	104	# https://bugzilla.gnome.org/show_bug.cgi?id=650875
105	# gdbus introspect \	105	# https://bugzilla.gnome.org/show_bug.cgi?id=650874
106	# --xml \
107	# --system \
108	# --dest org.freedesktop.timedate1 \
109	# --object-path /org/freedesktop/timedate1 \
110	# > timedated1-interface.xml
111
112	dbus_built_sources = timedated.c timedated.h
113	timedated.c: timedated.h
114	timedated.h: Makefile.am timedated1-interface.xml
115	gdbus-codegen \
116	--interface-prefix org.freedesktop. \
117	--generate-c-code timedated \
118	$(srcdir)/timedated1-interface.xml
119		106
120	libdate_time_la_SOURCES = \	107	libdate_time_la_SOURCES = \
121	datetime-module.c \	108	datetime-module.c \
Lines 123-161 libdate_time_la_SOURCES = \ Link Here
123	cc-datetime-panel.h \	110	cc-datetime-panel.h \
124	cc-timezone-map.c \	111	cc-timezone-map.c \
125	cc-timezone-map.h \	112	cc-timezone-map.h \
		113	dtm.c \
		114	dtm.h \
126	date-endian.c \	115	date-endian.c \
127	date-endian.h \	116	date-endian.h \
128	tz.c tz.h \	117	tz.c tz.h
129	$(dbus_built_sources) \
130	$(NULL)
131		118
132	libdate_time_la_LIBADD = $(PANEL_LIBS) $(DATETIME_PANEL_LIBS)	119	libdate_time_la_LIBADD = $(PANEL_LIBS) $(DATETIME_PANEL_LIBS)
133	libdate_time_la_LDFLAGS = $(PANEL_LDFLAGS)	120	libdate_time_la_LDFLAGS = $(PANEL_LDFLAGS)
134		121
135
136	polkitdir = $(datadir)/polkit-1/actions
137	polkit_in_files = org.gnome.controlcenter.datetime.policy.in
138
139	@INTLTOOL_POLICY_RULE@
140	polkit_DATA = $(polkit_in_files:.policy.in=.policy)
141
142
143	@INTLTOOL_DESKTOP_RULE@	122	@INTLTOOL_DESKTOP_RULE@
144		123
145	desktopdir = $(datadir)/applications	124	desktopdir = $(datadir)/applications
146	desktop_in_files = gnome-datetime-panel.desktop.in	125	desktop_in_files = gnome-datetime-panel.desktop.in
147	desktop_DATA = $(desktop_in_files:.desktop.in=.desktop)	126	desktop_DATA = $(desktop_in_files:.desktop.in=.desktop)
148		127
149	CLEANFILES = \	128	CLEANFILES = $(desktop_in_files) $(desktop_DATA)
150	$(desktop_in_files) \
151	$(desktop_DATA) \
152	$(dbus_built_sources) \
153	org.gnome.controlcenter.datetime.policy
154
155	EXTRA_DIST = \
156	timedated1-interface.xml \
157	$(polkit_in_files)
158
159	BUILT_SOURCES = $(dbus_built_sources)
160		129
161	-include $(top_srcdir)/git.mk	130	-include $(top_srcdir)/git.mk
		131

Lines 24-30 Link Here

(-)a/panels/datetime/cc-datetime-panel.c (-159 / +93 lines)
24		24
25	#include <sys/time.h>	25	#include <sys/time.h>
26	#include "cc-timezone-map.h"	26	#include "cc-timezone-map.h"
27	#include "timedated.h"	27	#include "dtm.h"
28	#include "date-endian.h"	28	#include "date-endian.h"
29	#define GNOME_DESKTOP_USE_UNSTABLE_API	29	#define GNOME_DESKTOP_USE_UNSTABLE_API
30		30
Lines 82-88 struct _CcDateTimePanelPrivate Link Here
82		82
83	GnomeWallClock *clock_tracker;	83	GnomeWallClock *clock_tracker;
84		84
85	Timedate1 *dtm;	85	DateTimeMechanism *dtm;
86	GCancellable *cancellable;	86	GCancellable *cancellable;
87		87
88	GPermission *permission;	88	GPermission *permission;
Lines 300-308 set_time_cb (GObject *source, Link Here
300	GError *error;	300	GError *error;
301		301
302	error = NULL;	302	error = NULL;
303	if (!timedate1_call_set_time_finish (self->priv->dtm,	303	if (!date_time_mechanism_call_set_time_finish (self->priv->dtm,
304	res,	304	res,
305	&error))	305	&error))
306	{	306	{
307	/* TODO: display any error in a user friendly way */	307	/* TODO: display any error in a user friendly way */
308	g_warning ("Could not set system time: %s", error->message);	308	g_warning ("Could not set system time: %s", error->message);
Lines 323-331 set_timezone_cb (GObject *source, Link Here
323	GError *error;	323	GError *error;
324		324
325	error = NULL;	325	error = NULL;
326	if (!timedate1_call_set_timezone_finish (self->priv->dtm,	326	if (!date_time_mechanism_call_set_timezone_finish (self->priv->dtm,
327	res,	327	res,
328	&error))	328	&error))
329	{	329	{
330	/* TODO: display any error in a user friendly way */	330	/* TODO: display any error in a user friendly way */
331	g_warning ("Could not set system timezone: %s", error->message);	331	g_warning ("Could not set system timezone: %s", error->message);
Lines 342-350 set_using_ntp_cb (GObject *source, Link Here
342	GError *error;	342	GError *error;
343		343
344	error = NULL;	344	error = NULL;
345	if (!timedate1_call_set_ntp_finish (self->priv->dtm,	345	if (!date_time_mechanism_call_set_using_ntp_finish (self->priv->dtm,
346	res,	346	res,
347	&error))	347	&error))
348	{	348	{
349	/* TODO: display any error in a user friendly way */	349	/* TODO: display any error in a user friendly way */
350	g_warning ("Could not set system to use NTP: %s", error->message);	350	g_warning ("Could not set system to use NTP: %s", error->message);
Lines 357-372 queue_set_datetime (CcDateTimePanel *self) Link Here
357	{	357	{
358	gint64 unixtime;	358	gint64 unixtime;
359		359
360	/* timedated expects number of microseconds since 1 Jan 1970 UTC */	360	/* for now just do it */
361	unixtime = g_date_time_to_unix (self->priv->date);	361	unixtime = g_date_time_to_unix (self->priv->date);
362		362
363	timedate1_call_set_time (self->priv->dtm,	363	date_time_mechanism_call_set_time (self->priv->dtm,
364	unixtime * 1000000,	364	unixtime,
365	FALSE,	365	self->priv->cancellable,
366	TRUE,	366	set_time_cb,
367	self->priv->cancellable,	367	self);
368	set_time_cb,
369	self);
370	}	368	}
371		369
372	static void	370	static void
Lines 377-388 queue_set_ntp (CcDateTimePanel *self) Link Here
377	/* for now just do it */	375	/* for now just do it */
378	using_ntp = gtk_switch_get_active (GTK_SWITCH (W("network_time_switch")));	376	using_ntp = gtk_switch_get_active (GTK_SWITCH (W("network_time_switch")));
379		377
380	timedate1_call_set_ntp (self->priv->dtm,	378	date_time_mechanism_call_set_using_ntp (self->priv->dtm,
381	using_ntp,	379	using_ntp,
382	TRUE,	380	self->priv->cancellable,
383	self->priv->cancellable,	381	set_using_ntp_cb,
384	set_using_ntp_cb,	382	self);
385	self);
386	}	383	}
387		384
388	static void	385	static void
Lines 391-402 queue_set_timezone (CcDateTimePanel *self) Link Here
391	/* for now just do it */	388	/* for now just do it */
392	if (self->priv->current_location)	389	if (self->priv->current_location)
393	{	390	{
394	timedate1_call_set_timezone (self->priv->dtm,	391	date_time_mechanism_call_set_timezone (self->priv->dtm,
395	self->priv->current_location->zone,	392	self->priv->current_location->zone,
396	TRUE,	393	self->priv->cancellable,
397	self->priv->cancellable,	394	set_timezone_cb,
398	set_timezone_cb,	395	self);
399	self);
400	}	396	}
401	}	397	}
402		398
Lines 553-575 location_changed_cb (CcTimezoneMap *map, Link Here
553	}	549	}
554		550
555	static void	551	static void
556	get_initial_timezone (CcDateTimePanel *self)	552	get_timezone_cb (GObject *source,
		553	GAsyncResult *res,
		554	gpointer user_data)
557	{	555	{
558	const gchar *timezone;	556	CcDateTimePanel *self = user_data;
		557	GtkWidget *widget;
		558	gchar *timezone;
		559	GError *error;
559		560
560	if (self->priv->dtm)	561	error = NULL;
561	timezone = timedate1_get_timezone (self->priv->dtm);	562	if (!date_time_mechanism_call_get_timezone_finish (self->priv->dtm, &timezone, res, &error))
		563	{
		564	g_warning ("Could not get current timezone: %s", error->message);
		565	g_error_free (error);
		566	}
562	else	567	else
563	timezone = NULL;
564
565	if (timezone == NULL \|\|
566	!cc_timezone_map_set_timezone (CC_TIMEZONE_MAP (self->priv->map), timezone))
567	{	568	{
568	g_warning ("Timezone '%s' is unhandled, setting %s as default", timezone ? timezone : "(null)", DEFAULT_TZ);	569	if (!cc_timezone_map_set_timezone (CC_TIMEZONE_MAP (self->priv->map), timezone))
569	cc_timezone_map_set_timezone (CC_TIMEZONE_MAP (self->priv->map), DEFAULT_TZ);	570	{
		571	g_warning ("Timezone '%s' is unhandled, setting %s as default", timezone, DEFAULT_TZ);
		572	cc_timezone_map_set_timezone (CC_TIMEZONE_MAP (self->priv->map), DEFAULT_TZ);
		573	}
		574	self->priv->current_location = cc_timezone_map_get_location (CC_TIMEZONE_MAP (self->priv->map));
		575	update_timezone (self);
570	}	576	}
571	self->priv->current_location = cc_timezone_map_get_location (CC_TIMEZONE_MAP (self->priv->map));	577
572	update_timezone (self);	578	/* now that the initial state is loaded set connect the signals */
		579	widget = (GtkWidget*) gtk_builder_get_object (self->priv->builder,
		580	"region_combobox");
		581	g_signal_connect (widget, "changed", G_CALLBACK (region_changed_cb), self);
		582
		583	widget = (GtkWidget*) gtk_builder_get_object (self->priv->builder,
		584	"city_combobox");
		585	g_signal_connect (widget, "changed", G_CALLBACK (city_changed_cb), self);
		586
		587	g_signal_connect (self->priv->map, "location-changed",
		588	G_CALLBACK (location_changed_cb), self);
		589
		590
		591	g_free (timezone);
573	}	592	}
574		593
575	/* load region and city tree models */	594	/* load region and city tree models */
Lines 700-712 update_widget_state_for_ntp (CcDateTimePanel *panel, Link Here
700	gboolean using_ntp)	719	gboolean using_ntp)
701	{	720	{
702	CcDateTimePanelPrivate *priv = panel->priv;	721	CcDateTimePanelPrivate *priv = panel->priv;
703	gboolean allowed;
704
705	/* need to check polkit before revealing to user */
706	allowed = (! priv->permission \|\| g_permission_get_allowed (priv->permission));
707		722
708	gtk_widget_set_sensitive (W("table1"), !using_ntp && allowed);	723	gtk_widget_set_sensitive (W("table1"), !using_ntp);
709	gtk_widget_set_sensitive (W("table2"), !using_ntp && allowed);	724	gtk_widget_set_sensitive (W("table2"), !using_ntp);
710	}	725	}
711		726
712	static void	727	static void
Lines 815-896 on_permission_changed (GPermission *permission, Link Here
815	gtk_widget_set_sensitive (W("map-vbox"), allowed);	830	gtk_widget_set_sensitive (W("map-vbox"), allowed);
816	gtk_widget_set_sensitive (W("hbox2"), allowed);	831	gtk_widget_set_sensitive (W("hbox2"), allowed);
817	gtk_widget_set_sensitive (W("alignment2"), allowed);	832	gtk_widget_set_sensitive (W("alignment2"), allowed);
818	update_widget_state_for_ntp (data, using_ntp);	833	gtk_widget_set_sensitive (W("table1"), allowed && !using_ntp);
819	}
820
821	static void
822	update_ntp_switch_from_system (CcDateTimePanel *self)
823	{
824	CcDateTimePanelPrivate *priv = self->priv;
825	gboolean using_ntp;
826	GtkWidget *switch_widget;
827
828	using_ntp = timedate1_get_ntp (self->priv->dtm);
829
830	switch_widget = W("network_time_switch");
831	g_signal_handlers_block_by_func (switch_widget, change_ntp, self);
832	gtk_switch_set_active (GTK_SWITCH (switch_widget), using_ntp);
833	update_widget_state_for_ntp (self, using_ntp);
834	g_signal_handlers_unblock_by_func (switch_widget, change_ntp, self);
835	}
836
837	static void
838	on_ntp_changed (CcDateTimePanel *self)
839	{
840	update_ntp_switch_from_system (self);
841	}
842
843	static void
844	on_timezone_changed (CcDateTimePanel *self)
845	{
846	CcDateTimePanelPrivate *priv = self->priv;
847	GtkWidget region_combo, city_combo;
848
849	region_combo = W("region_combobox");
850	city_combo = W("city_combobox");
851
852	g_signal_handlers_block_by_func (region_combo, region_changed_cb, self);
853	g_signal_handlers_block_by_func (city_combo, city_changed_cb, self);
854	g_signal_handlers_block_by_func (self->priv->map, location_changed_cb, self);
855
856	get_initial_timezone (self);
857
858	g_signal_handlers_unblock_by_func (region_combo, region_changed_cb, self);
859	g_signal_handlers_unblock_by_func (city_combo, city_changed_cb, self);
860	g_signal_handlers_unblock_by_func (self->priv->map, location_changed_cb, self);
861	}
862
863	static void
864	on_timedated_properties_changed (GDBusProxy *proxy,
865	GVariant *changed_properties,
866	const gchar **invalidated_properties,
867	CcDateTimePanel *self)
868	{
869	GError *error;
870	GVariant *variant;
871	GVariant *v;
872	guint i;
873
874	if (invalidated_properties != NULL)
875	for (i = 0; invalidated_properties[i] != NULL; i++) {
876	error = NULL;
877	/* See https://bugs.freedesktop.org/show_bug.cgi?id=37632 for the reason why we're doing this */
878	variant = g_dbus_proxy_call_sync (proxy,
879	"org.freedesktop.DBus.Properties.Get",
880	g_variant_new ("(ss)", "org.freedesktop.timedate1", invalidated_properties[i]),
881	G_DBUS_CALL_FLAGS_NONE,
882	-1,
883	NULL,
884	&error);
885	if (variant == NULL) {
886	g_warning ("Failed to get property '%s': %s", invalidated_properties[i], error->message);
887	g_error_free (error);
888	} else {
889	g_variant_get (variant, "(v)", &v);
890	g_dbus_proxy_set_cached_property (proxy, invalidated_properties[i], v);
891	g_variant_unref (variant);
892	}
893	}
894	}	834	}
895		835
896	static void	836	static void
Lines 941-946 cc_date_time_panel_init (CcDateTimePanel *self) Link Here
941	GtkTreeModelFilter *city_modelfilter;	881	GtkTreeModelFilter *city_modelfilter;
942	GtkTreeModelSort *city_modelsort;	882	GtkTreeModelSort *city_modelsort;
943	guint i, num_days;	883	guint i, num_days;
		884	gboolean using_ntp;
		885	gboolean can_use_ntp;
944	int ret;	886	int ret;
945	DateEndianess endianess;	887	DateEndianess endianess;
946	GError *error;	888	GError *error;
Lines 949-960 cc_date_time_panel_init (CcDateTimePanel *self) Link Here
949		891
950	priv->cancellable = g_cancellable_new ();	892	priv->cancellable = g_cancellable_new ();
951	error = NULL;	893	error = NULL;
952	priv->dtm = timedate1_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,	894	priv->dtm = date_time_mechanism_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
953	G_DBUS_PROXY_FLAGS_NONE,	895	G_DBUS_PROXY_FLAGS_NONE,
954	"org.freedesktop.timedate1",	896	"org.gnome.SettingsDaemon.DateTimeMechanism",
955	"/org/freedesktop/timedate1",	897	"/",
956	priv->cancellable,	898	priv->cancellable,
957	&error);	899	&error);
958	if (priv->dtm == NULL) {	900	if (priv->dtm == NULL) {
959	g_warning ("could not get proxy for DateTimeMechanism: %s", error->message);	901	g_warning ("could not get proxy for DateTimeMechanism: %s", error->message);
960	g_error_free (error);	902	g_error_free (error);
Lines 974-981 cc_date_time_panel_init (CcDateTimePanel *self) Link Here
974	}	916	}
975		917
976	/* set up network time button */	918	/* set up network time button */
977	if (priv->dtm != NULL)	919	error = NULL;
978	update_ntp_switch_from_system (self);	920	using_ntp = can_use_ntp = FALSE;
		921	if (!date_time_mechanism_call_get_using_ntp_sync (priv->dtm,
		922	&can_use_ntp,
		923	&using_ntp,
		924	priv->cancellable,
		925	&error))
		926	{
		927	g_warning ("Failed to get using ntp: %s", error->message);
		928	g_error_free (error);
		929	}
		930
		931	gtk_switch_set_active (GTK_SWITCH (W("network_time_switch")), using_ntp);
		932	update_widget_state_for_ntp (self, using_ntp);
979	g_signal_connect (W("network_time_switch"), "notify::active",	933	g_signal_connect (W("network_time_switch"), "notify::active",
980	G_CALLBACK (change_ntp), self);	934	G_CALLBACK (change_ntp), self);
981		935
Lines 1066-1102 cc_date_time_panel_init (CcDateTimePanel *self) Link Here
1066		1020
1067	/* After the initial setup, so we can be sure that	1021	/* After the initial setup, so we can be sure that
1068	* the model is filled up */	1022	* the model is filled up */
1069	get_initial_timezone (self);	1023	date_time_mechanism_call_get_timezone (priv->dtm,
1070		1024	priv->cancellable,
1071	widget = (GtkWidget*) gtk_builder_get_object (self->priv->builder,	1025	get_timezone_cb,
1072	"region_combobox");	1026	self);
1073	g_signal_connect (widget, "changed", G_CALLBACK (region_changed_cb), self);
1074
1075	widget = (GtkWidget*) gtk_builder_get_object (self->priv->builder,
1076	"city_combobox");
1077	g_signal_connect (widget, "changed", G_CALLBACK (city_changed_cb), self);
1078
1079	g_signal_connect (self->priv->map, "location-changed",
1080	G_CALLBACK (location_changed_cb), self);
1081
1082	/* Watch changes of timedated remote service properties */
1083	if (priv->dtm)
1084	{
1085	g_signal_connect (priv->dtm, "g-properties-changed",
1086	G_CALLBACK (on_timedated_properties_changed), self);
1087	g_signal_connect_swapped (priv->dtm, "notify::ntp",
1088	G_CALLBACK (on_ntp_changed), self);
1089	g_signal_connect_swapped (priv->dtm, "notify::timezone",
1090	G_CALLBACK (on_timezone_changed), self);
1091	}
1092	/* We ignore UTC <--> LocalRTC changes at the moment */
1093		1027
1094	/* add the lock button */	1028	/* add the lock button */
1095	priv->permission = polkit_permission_new_sync ("org.gnome.controlcenter.datetime.configure", NULL, NULL, NULL);	1029	priv->permission = polkit_permission_new_sync ("org.gnome.settingsdaemon.datetimemechanism.configure", NULL, NULL, NULL);
1096	if (priv->permission == NULL)	1030	if (priv->permission == NULL)
1097	{	1031	{
1098	g_warning ("Your system does not have the '%s' PolicyKit files installed. Please check your installation",	1032	g_warning ("Your system does not have the '%s' PolicyKit files installed. Please check your installation",
1099	"org.gnome.controlcenter.datetime.configure");	1033	"org.gnome.settingsdaemon.datetimemechanism.configure");
1100	return;	1034	return;
1101	}	1035	}
1102		1036

Line 0 Link Here

(-)a/panels/datetime/dtm.h (+475 lines)
		1	/*
		2	* Generated by gdbus-codegen 2.29.5. DO NOT EDIT.
		3	*
		4	* The license of this code is the same as for the source it was derived from.
		5	*/
		6
		7	#ifndef __DTM_H__
		8	#define __DTM_H__
		9
		10	#include <gio/gio.h>
		11
		12	G_BEGIN_DECLS
		13
		14
		15	/* ------------------------------------------------------------------------ */
		16	/* Declarations for org.gnome.SettingsDaemon.DateTimeMechanism */
		17
		18	#define TYPE_DATE_TIME_MECHANISM (date_time_mechanism_get_type ())
		19	#define DATE_TIME_MECHANISM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_DATE_TIME_MECHANISM, DateTimeMechanism))
		20	#define IS_DATE_TIME_MECHANISM(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_DATE_TIME_MECHANISM))
		21	#define DATE_TIME_MECHANISM_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_DATE_TIME_MECHANISM, DateTimeMechanism))
		22
		23	struct _DateTimeMechanism;
		24	typedef struct _DateTimeMechanism DateTimeMechanism;
		25	typedef struct _DateTimeMechanismIface DateTimeMechanismIface;
		26
		27	struct _DateTimeMechanismIface
		28	{
		29	GTypeInterface parent_iface;
		30
		31	gboolean (*handle_adjust_time) (
		32	DateTimeMechanism *object,
		33	GDBusMethodInvocation *invocation,
		34	gint64 seconds_to_add);
		35
		36	gboolean (*handle_can_set_time) (
		37	DateTimeMechanism *object,
		38	GDBusMethodInvocation *invocation);
		39
		40	gboolean (*handle_can_set_timezone) (
		41	DateTimeMechanism *object,
		42	GDBusMethodInvocation *invocation);
		43
		44	gboolean (*handle_can_set_using_ntp) (
		45	DateTimeMechanism *object,
		46	GDBusMethodInvocation *invocation);
		47
		48	gboolean (*handle_get_hardware_clock_using_utc) (
		49	DateTimeMechanism *object,
		50	GDBusMethodInvocation *invocation);
		51
		52	gboolean (*handle_get_timezone) (
		53	DateTimeMechanism *object,
		54	GDBusMethodInvocation *invocation);
		55
		56	gboolean (*handle_get_using_ntp) (
		57	DateTimeMechanism *object,
		58	GDBusMethodInvocation *invocation);
		59
		60	gboolean (*handle_set_date) (
		61	DateTimeMechanism *object,
		62	GDBusMethodInvocation *invocation,
		63	guint day,
		64	guint month,
65	guint year);
66
67	gboolean (*handle_set_hardware_clock_using_utc) (
68	DateTimeMechanism *object,
69	GDBusMethodInvocation *invocation,
70	gboolean is_using_utc);
71
72	gboolean (*handle_set_time) (
73	DateTimeMechanism *object,
74	GDBusMethodInvocation *invocation,
75	gint64 seconds_since_epoch);
76
77	gboolean (*handle_set_timezone) (
78	DateTimeMechanism *object,
79	GDBusMethodInvocation *invocation,
80	const gchar *tz);
81
82	gboolean (*handle_set_using_ntp) (
83	DateTimeMechanism *object,
84	GDBusMethodInvocation *invocation,
85	gboolean is_using_ntp);
86
87	};
88
89	GType date_time_mechanism_get_type (void) G_GNUC_CONST;
90
91	GDBusInterfaceInfo *date_time_mechanism_interface_info (void);
92
93
94	/* D-Bus method call completion functions: */
95	void date_time_mechanism_complete_set_timezone (
96	DateTimeMechanism *object,
97	GDBusMethodInvocation *invocation);
98
99	void date_time_mechanism_complete_get_timezone (
100	DateTimeMechanism *object,
101	GDBusMethodInvocation *invocation,
102	const gchar *timezone);
103
104	void date_time_mechanism_complete_can_set_timezone (
105	DateTimeMechanism *object,
106	GDBusMethodInvocation *invocation,
107	gint value);
108
109	void date_time_mechanism_complete_set_date (
110	DateTimeMechanism *object,
111	GDBusMethodInvocation *invocation);
112
113	void date_time_mechanism_complete_set_time (
114	DateTimeMechanism *object,
115	GDBusMethodInvocation *invocation);
116
117	void date_time_mechanism_complete_can_set_time (
118	DateTimeMechanism *object,
119	GDBusMethodInvocation *invocation,
120	gint value);
121
122	void date_time_mechanism_complete_adjust_time (
123	DateTimeMechanism *object,
124	GDBusMethodInvocation *invocation);
125
126	void date_time_mechanism_complete_get_hardware_clock_using_utc (
127	DateTimeMechanism *object,
128	GDBusMethodInvocation *invocation,
129	gboolean is_using_utc);
130
131	void date_time_mechanism_complete_set_hardware_clock_using_utc (
132	DateTimeMechanism *object,
133	GDBusMethodInvocation *invocation);
134
135	void date_time_mechanism_complete_get_using_ntp (
136	DateTimeMechanism *object,
137	GDBusMethodInvocation *invocation,
138	gboolean can_use_ntp,
139	gboolean is_using_ntp);
140
141	void date_time_mechanism_complete_set_using_ntp (
142	DateTimeMechanism *object,
143	GDBusMethodInvocation *invocation);
144
145	void date_time_mechanism_complete_can_set_using_ntp (
146	DateTimeMechanism *object,
147	GDBusMethodInvocation *invocation,
148	gint value);
149
150
151
152	/* D-Bus method calls: */
153	void date_time_mechanism_call_set_timezone (
154	DateTimeMechanism *proxy,
155	const gchar *tz,
156	GCancellable *cancellable,
157	GAsyncReadyCallback callback,
158	gpointer user_data);
159
160	gboolean date_time_mechanism_call_set_timezone_finish (
161	DateTimeMechanism *proxy,
162	GAsyncResult *res,
163	GError **error);
164
165	gboolean date_time_mechanism_call_set_timezone_sync (
166	DateTimeMechanism *proxy,
167	const gchar *tz,
168	GCancellable *cancellable,
169	GError **error);
170
171	void date_time_mechanism_call_get_timezone (
172	DateTimeMechanism *proxy,
173	GCancellable *cancellable,
174	GAsyncReadyCallback callback,
175	gpointer user_data);
176
177	gboolean date_time_mechanism_call_get_timezone_finish (
178	DateTimeMechanism *proxy,
179	gchar **out_timezone,
180	GAsyncResult *res,
181	GError **error);
182
183	gboolean date_time_mechanism_call_get_timezone_sync (
184	DateTimeMechanism *proxy,
185	gchar **out_timezone,
186	GCancellable *cancellable,
187	GError **error);
188
189	void date_time_mechanism_call_can_set_timezone (
190	DateTimeMechanism *proxy,
191	GCancellable *cancellable,
192	GAsyncReadyCallback callback,
193	gpointer user_data);
194
195	gboolean date_time_mechanism_call_can_set_timezone_finish (
196	DateTimeMechanism *proxy,
197	gint *out_value,
198	GAsyncResult *res,
199	GError **error);
200
201	gboolean date_time_mechanism_call_can_set_timezone_sync (
202	DateTimeMechanism *proxy,
203	gint *out_value,
204	GCancellable *cancellable,
205	GError **error);
206
207	void date_time_mechanism_call_set_date (
208	DateTimeMechanism *proxy,
209	guint day,
210	guint month,
211	guint year,
212	GCancellable *cancellable,
213	GAsyncReadyCallback callback,
214	gpointer user_data);
215
216	gboolean date_time_mechanism_call_set_date_finish (
217	DateTimeMechanism *proxy,
218	GAsyncResult *res,
219	GError **error);
220
221	gboolean date_time_mechanism_call_set_date_sync (
222	DateTimeMechanism *proxy,
223	guint day,
224	guint month,
225	guint year,
226	GCancellable *cancellable,
227	GError **error);
228
229	void date_time_mechanism_call_set_time (
230	DateTimeMechanism *proxy,
231	gint64 seconds_since_epoch,
232	GCancellable *cancellable,
233	GAsyncReadyCallback callback,
234	gpointer user_data);
235
236	gboolean date_time_mechanism_call_set_time_finish (
237	DateTimeMechanism *proxy,
238	GAsyncResult *res,
239	GError **error);
240
241	gboolean date_time_mechanism_call_set_time_sync (
242	DateTimeMechanism *proxy,
243	gint64 seconds_since_epoch,
244	GCancellable *cancellable,
245	GError **error);
246
247	void date_time_mechanism_call_can_set_time (
248	DateTimeMechanism *proxy,
249	GCancellable *cancellable,
250	GAsyncReadyCallback callback,
251	gpointer user_data);
252
253	gboolean date_time_mechanism_call_can_set_time_finish (
254	DateTimeMechanism *proxy,
255	gint *out_value,
256	GAsyncResult *res,
257	GError **error);
258
259	gboolean date_time_mechanism_call_can_set_time_sync (
260	DateTimeMechanism *proxy,
261	gint *out_value,
262	GCancellable *cancellable,
263	GError **error);
264
265	void date_time_mechanism_call_adjust_time (
266	DateTimeMechanism *proxy,
267	gint64 seconds_to_add,
268	GCancellable *cancellable,
269	GAsyncReadyCallback callback,
270	gpointer user_data);
271
272	gboolean date_time_mechanism_call_adjust_time_finish (
273	DateTimeMechanism *proxy,
274	GAsyncResult *res,
275	GError **error);
276
277	gboolean date_time_mechanism_call_adjust_time_sync (
278	DateTimeMechanism *proxy,
279	gint64 seconds_to_add,
280	GCancellable *cancellable,
281	GError **error);
282
283	void date_time_mechanism_call_get_hardware_clock_using_utc (
284	DateTimeMechanism *proxy,
285	GCancellable *cancellable,
286	GAsyncReadyCallback callback,
287	gpointer user_data);
288
289	gboolean date_time_mechanism_call_get_hardware_clock_using_utc_finish (
290	DateTimeMechanism *proxy,
291	gboolean *out_is_using_utc,
292	GAsyncResult *res,
293	GError **error);
294
295	gboolean date_time_mechanism_call_get_hardware_clock_using_utc_sync (
296	DateTimeMechanism *proxy,
297	gboolean *out_is_using_utc,
298	GCancellable *cancellable,
299	GError **error);
300
301	void date_time_mechanism_call_set_hardware_clock_using_utc (
302	DateTimeMechanism *proxy,
303	gboolean is_using_utc,
304	GCancellable *cancellable,
305	GAsyncReadyCallback callback,
306	gpointer user_data);
307
308	gboolean date_time_mechanism_call_set_hardware_clock_using_utc_finish (
309	DateTimeMechanism *proxy,
310	GAsyncResult *res,
311	GError **error);
312
313	gboolean date_time_mechanism_call_set_hardware_clock_using_utc_sync (
314	DateTimeMechanism *proxy,
315	gboolean is_using_utc,
316	GCancellable *cancellable,
317	GError **error);
318
319	void date_time_mechanism_call_get_using_ntp (
320	DateTimeMechanism *proxy,
321	GCancellable *cancellable,
322	GAsyncReadyCallback callback,
323	gpointer user_data);
324
325	gboolean date_time_mechanism_call_get_using_ntp_finish (
326	DateTimeMechanism *proxy,
327	gboolean *out_can_use_ntp,
328	gboolean *out_is_using_ntp,
329	GAsyncResult *res,
330	GError **error);
331
332	gboolean date_time_mechanism_call_get_using_ntp_sync (
333	DateTimeMechanism *proxy,
334	gboolean *out_can_use_ntp,
335	gboolean *out_is_using_ntp,
336	GCancellable *cancellable,
337	GError **error);
338
339	void date_time_mechanism_call_set_using_ntp (
340	DateTimeMechanism *proxy,
341	gboolean is_using_ntp,
342	GCancellable *cancellable,
343	GAsyncReadyCallback callback,
344	gpointer user_data);
345
346	gboolean date_time_mechanism_call_set_using_ntp_finish (
347	DateTimeMechanism *proxy,
348	GAsyncResult *res,
349	GError **error);
350
351	gboolean date_time_mechanism_call_set_using_ntp_sync (
352	DateTimeMechanism *proxy,
353	gboolean is_using_ntp,
354	GCancellable *cancellable,
355	GError **error);
356
357	void date_time_mechanism_call_can_set_using_ntp (
358	DateTimeMechanism *proxy,
359	GCancellable *cancellable,
360	GAsyncReadyCallback callback,
361	gpointer user_data);
362
363	gboolean date_time_mechanism_call_can_set_using_ntp_finish (
364	DateTimeMechanism *proxy,
365	gint *out_value,
366	GAsyncResult *res,
367	GError **error);
368
369	gboolean date_time_mechanism_call_can_set_using_ntp_sync (
370	DateTimeMechanism *proxy,
371	gint *out_value,
372	GCancellable *cancellable,
373	GError **error);
374
375
376
377	/* ---- */
378
379	#define TYPE_DATE_TIME_MECHANISM_PROXY (date_time_mechanism_proxy_get_type ())
380	#define DATE_TIME_MECHANISM_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_DATE_TIME_MECHANISM_PROXY, DateTimeMechanismProxy))
381	#define DATE_TIME_MECHANISM_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_DATE_TIME_MECHANISM_PROXY, DateTimeMechanismProxyClass))
382	#define DATE_TIME_MECHANISM_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_DATE_TIME_MECHANISM_PROXY, DateTimeMechanismProxyClass))
383	#define IS_DATE_TIME_MECHANISM_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_DATE_TIME_MECHANISM_PROXY))
384	#define IS_DATE_TIME_MECHANISM_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_DATE_TIME_MECHANISM_PROXY))
385
386	typedef struct _DateTimeMechanismProxy DateTimeMechanismProxy;
387	typedef struct _DateTimeMechanismProxyClass DateTimeMechanismProxyClass;
388	typedef struct _DateTimeMechanismProxyPrivate DateTimeMechanismProxyPrivate;
389
390	struct _DateTimeMechanismProxy
391	{
392	/< private >/
393	GDBusProxy parent_instance;
394	DateTimeMechanismProxyPrivate *priv;
395	};
396
397	struct _DateTimeMechanismProxyClass
398	{
399	GDBusProxyClass parent_class;
400	};
401
402	GType date_time_mechanism_proxy_get_type (void) G_GNUC_CONST;
403
404	void date_time_mechanism_proxy_new (
405	GDBusConnection *connection,
406	GDBusProxyFlags flags,
407	const gchar *name,
408	const gchar *object_path,
409	GCancellable *cancellable,
410	GAsyncReadyCallback callback,
411	gpointer user_data);
412	DateTimeMechanism *date_time_mechanism_proxy_new_finish (
413	GAsyncResult *res,
414	GError **error);
415	DateTimeMechanism *date_time_mechanism_proxy_new_sync (
416	GDBusConnection *connection,
417	GDBusProxyFlags flags,
418	const gchar *name,
419	const gchar *object_path,
420	GCancellable *cancellable,
421	GError **error);
422
423	void date_time_mechanism_proxy_new_for_bus (
424	GBusType bus_type,
425	GDBusProxyFlags flags,
426	const gchar *name,
427	const gchar *object_path,
428	GCancellable *cancellable,
429	GAsyncReadyCallback callback,
430	gpointer user_data);
431	DateTimeMechanism *date_time_mechanism_proxy_new_for_bus_finish (
432	GAsyncResult *res,
433	GError **error);
434	DateTimeMechanism *date_time_mechanism_proxy_new_for_bus_sync (
435	GBusType bus_type,
436	GDBusProxyFlags flags,
437	const gchar *name,
438	const gchar *object_path,
439	GCancellable *cancellable,
440	GError **error);
441
442
443	/* ---- */
444
445	#define TYPE_DATE_TIME_MECHANISM_SKELETON (date_time_mechanism_skeleton_get_type ())
446	#define DATE_TIME_MECHANISM_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_DATE_TIME_MECHANISM_SKELETON, DateTimeMechanismSkeleton))
447	#define DATE_TIME_MECHANISM_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_DATE_TIME_MECHANISM_SKELETON, DateTimeMechanismSkeletonClass))
448	#define DATE_TIME_MECHANISM_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_DATE_TIME_MECHANISM_SKELETON, DateTimeMechanismSkeletonClass))
449	#define IS_DATE_TIME_MECHANISM_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_DATE_TIME_MECHANISM_SKELETON))
450	#define IS_DATE_TIME_MECHANISM_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_DATE_TIME_MECHANISM_SKELETON))
451
452	typedef struct _DateTimeMechanismSkeleton DateTimeMechanismSkeleton;
453	typedef struct _DateTimeMechanismSkeletonClass DateTimeMechanismSkeletonClass;
454	typedef struct _DateTimeMechanismSkeletonPrivate DateTimeMechanismSkeletonPrivate;
455
456	struct _DateTimeMechanismSkeleton
457	{
458	/< private >/
459	GDBusInterfaceSkeleton parent_instance;
460	DateTimeMechanismSkeletonPrivate *priv;
461	};
462
463	struct _DateTimeMechanismSkeletonClass
464	{
465	GDBusInterfaceSkeletonClass parent_class;
466	};
467
468	GType date_time_mechanism_skeleton_get_type (void) G_GNUC_CONST;
469
470	DateTimeMechanism *date_time_mechanism_skeleton_new (void);
471
472
473	G_END_DECLS
474
475	#endif /* __DTM_H__ */

Lines 1-21 Link Here

(-)a/panels/datetime/org.gnome.controlcenter.datetime.policy.in (-21 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<!DOCTYPE policyconfig PUBLIC
3	"-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
4	"http://www.freedesktop.org/standards/PolicyKit/1.0/policyconfig.dtd">
5
6	<policyconfig>
7	<vendor>The GNOME Project</vendor>
8	<vendor_url>http://www.gnome.org/</vendor_url>
9
10	<action id="org.gnome.controlcenter.datetime.configure">
11	<_description>Change system time and date settings</_description>
12	<_message>To change time or date settings, you need to authenticate.</_message>
13	<defaults>
14	<allow_any>no</allow_any>
15	<allow_inactive>no</allow_inactive>
16	<allow_active>auth_admin_keep</allow_active>
17	</defaults>
18	<annotate key="org.freedesktop.policykit.imply">org.freedesktop.timedate1.set-time org.freedesktop.timedate1.set-timezone org.freedesktop.timedate1.set-local-rtc org.freedesktop.timedate1.set-ntp</annotate>
19	</action>
20
21	</policyconfig>

Line 0 Link Here

(-)a/panels/datetime/set-timezone.c (+479 lines)
		1	/* -- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 --
		2	*
		3	* Copyright (C) 2007 David Zeuthen <david@fubar.dk>
		4	*
		5	* This program is free software; you can redistribute it and/or modify
		6	* it under the terms of the GNU General Public License as published by
		7	* the Free Software Foundation; either version 2 of the License, or
		8	* (at your option) any later version.
		9	*
		10	* This program 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
		13	* GNU General Public License for more details.
		14	*
		15	* You should have received a copy of the GNU General Public License
		16	* along with this program; if not, write to the Free Software
		17	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
		18	*
		19	*/
		20
		21	#ifdef HAVE_CONFIG_H
		22	# include "config.h"
		23	#endif
		24
		25	#include <stdlib.h>
		26	#include <stdio.h>
		27	#include <fcntl.h>
		28	#include <unistd.h>
		29	#include <string.h>
		30	#include <sys/wait.h>
		31
		32	#include <dbus/dbus-glib.h>
		33	#include <dbus/dbus-glib-lowlevel.h>
		34
		35	#include "set-timezone.h"
		36
		37
		38	static DBusGConnection *
		39	get_system_bus (GError **err)
		40	{
		41	GError *error;
		42	static DBusGConnection *bus = NULL;
		43
		44	if (bus == NULL) {
		45	error = NULL;
		46	bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
		47	if (bus == NULL) {
		48	g_propagate_error (err, error);
		49	}
		50	}
		51
		52	return bus;
		53	}
		54
		55	#define CACHE_VALIDITY_SEC 2
		56
		57	typedef void (*CanDoFunc) (gint value);
		58
		59	static void
		60	notify_can_do (DBusGProxy *proxy,
		61	DBusGProxyCall *call,
		62	void *user_data)
		63	{
		64	CanDoFunc callback = user_data;
65	GError *error = NULL;
66	gint value;
67
68	if (dbus_g_proxy_end_call (proxy, call,
69	&error,
70	G_TYPE_INT, &value,
71	G_TYPE_INVALID)) {
72	callback (value);
73	}
74	}
75
76	static void
77	refresh_can_do (const gchar *action, CanDoFunc callback)
78	{
79	DBusGConnection *bus;
80	DBusGProxy *proxy;
81
82	bus = get_system_bus (NULL);
83	if (bus == NULL)
84	return;
85
86	proxy = dbus_g_proxy_new_for_name (bus,
87	"org.gnome.SettingsDaemon.DateTimeMechanism",
88	"/",
89	"org.gnome.SettingsDaemon.DateTimeMechanism");
90
91	dbus_g_proxy_begin_call_with_timeout (proxy,
92	action,
93	notify_can_do,
94	callback, NULL,
95	INT_MAX,
96	G_TYPE_INVALID);
97	}
98
99	static gint settimezone_cache = 0;
100	static time_t settimezone_stamp = 0;
101
102	static void
103	update_can_settimezone (gint res)
104	{
105	settimezone_cache = res;
106	time (&settimezone_stamp);
107	}
108
109	gint
110	can_set_system_timezone (void)
111	{
112	time_t now;
113
114	time (&now);
115	if (ABS (now - settimezone_stamp) > CACHE_VALIDITY_SEC) {
116	refresh_can_do ("CanSetTimezone", update_can_settimezone);
117	settimezone_stamp = now;
118	}
119
120	return settimezone_cache;
121	}
122
123	static gint settime_cache = 0;
124	static time_t settime_stamp = 0;
125
126	static void
127	update_can_settime (gint res)
128	{
129	settime_cache = res;
130	time (&settime_stamp);
131	}
132
133	gint
134	can_set_system_time (void)
135	{
136	time_t now;
137
138	time (&now);
139	if (ABS (now - settime_stamp) > CACHE_VALIDITY_SEC) {
140	refresh_can_do ("CanSetTime", update_can_settime);
141	settime_stamp = now;
142	}
143
144	return settime_cache;
145	}
146
147	static gint usingntp_cache = 0;
148	static time_t usingntp_stamp = 0;
149
150	static void
151	update_can_usingntp (gint res)
152	{
153	usingntp_cache = res;
154	time (&usingntp_stamp);
155	}
156
157	gint
158	can_set_using_ntp (void)
159	{
160	time_t now;
161
162	time (&now);
163	if (ABS (now - usingntp_stamp) > CACHE_VALIDITY_SEC) {
164	refresh_can_do ("CanSetUsingNtp", update_can_usingntp);
165	settime_stamp = now;
166	}
167
168	return usingntp_cache;
169	}
170
171	typedef struct {
172	gint ref_count;
173	gchar *call;
174	gint64 time;
175	gchar *tz;
176	gboolean using_ntp;
177	GFunc callback;
178	gpointer data;
179	GDestroyNotify notify;
180	} SetTimeCallbackData;
181
182	static void
183	free_data (gpointer d)
184	{
185	SetTimeCallbackData *data = d;
186
187	data->ref_count--;
188	if (data->ref_count == 0) {
189	if (data->notify)
190	data->notify (data->data);
191	g_free (data->tz);
192	g_free (data);
193	}
194	}
195
196	static void
197	set_time_notify (DBusGProxy *proxy,
198	DBusGProxyCall *call,
199	void *user_data)
200	{
201	SetTimeCallbackData *data = user_data;
202	GError *error = NULL;
203
204	if (dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID)) {
205	if (data->callback)
206	data->callback (data->data, NULL);
207	}
208	else {
209	if (error->domain == DBUS_GERROR &&
210	error->code == DBUS_GERROR_NO_REPLY) {
211	/* these errors happen because dbus doesn't
212	* use monotonic clocks
213	*/
214	g_warning ("ignoring no-reply error when setting time");
215	g_error_free (error);
216	if (data->callback)
217	data->callback (data->data, NULL);
218	}
219	else {
220	if (data->callback)
221	data->callback (data->data, error);
222	else
223	g_error_free (error);
224	}
225	}
226	}
227
228	static void
229	set_time_async (SetTimeCallbackData *data)
230	{
231	DBusGConnection *bus;
232	DBusGProxy *proxy;
233	GError *err = NULL;
234
235	bus = get_system_bus (&err);
236	if (bus == NULL) {
237	if (err) {
238	if (data->callback)
239	data->callback (data->data, err);
240	g_clear_error (&err);
241	}
242	return;
243	}
244
245	proxy = dbus_g_proxy_new_for_name (bus,
246	"org.gnome.SettingsDaemon.DateTimeMechanism",
247	"/",
248	"org.gnome.SettingsDaemon.DateTimeMechanism");
249
250	data->ref_count++;
251	if (strcmp (data->call, "SetTime") == 0)
252	dbus_g_proxy_begin_call_with_timeout (proxy,
253	"SetTime",
254	set_time_notify,
255	data, free_data,
256	INT_MAX,
257	/* parameters: */
258	G_TYPE_INT64, data->time,
259	G_TYPE_INVALID,
260	/* return values: */
261	G_TYPE_INVALID);
262	else if (strcmp (data->call, "SetTimezone") == 0)
263	dbus_g_proxy_begin_call_with_timeout (proxy,
264	"SetTimezone",
265	set_time_notify,
266	data, free_data,
267	INT_MAX,
268	/* parameters: */
269	G_TYPE_STRING, data->tz,
270	G_TYPE_INVALID,
271	/* return values: */
272	G_TYPE_INVALID);
273	else if (strcmp (data->call, "SetUsingNtp") == 0)
274	dbus_g_proxy_begin_call_with_timeout (proxy,
275	"SetUsingNtp",
276	set_time_notify,
277	data, free_data,
278	INT_MAX,
279	/* parameters: */
280	G_TYPE_BOOLEAN, data->using_ntp,
281	G_TYPE_INVALID,
282	/* return values: */
283	G_TYPE_INVALID);
284	}
285
286	void
287	set_system_time_async (gint64 time,
288	GFunc callback,
289	gpointer d,
290	GDestroyNotify notify)
291	{
292	SetTimeCallbackData *data;
293
294	if (time == -1)
295	return;
296
297	data = g_new0 (SetTimeCallbackData, 1);
298	data->ref_count = 1;
299	data->call = "SetTime";
300	data->time = time;
301	data->tz = NULL;
302	data->callback = callback;
303	data->data = d;
304	data->notify = notify;
305
306	set_time_async (data);
307	free_data (data);
308	}
309
310	void
311	set_system_timezone_async (const gchar *tz,
312	GFunc callback,
313	gpointer d,
314	GDestroyNotify notify)
315	{
316	SetTimeCallbackData *data;
317
318	g_return_if_fail (tz != NULL);
319
320	data = g_new0 (SetTimeCallbackData, 1);
321	data->ref_count = 1;
322	data->call = "SetTimezone";
323	data->time = -1;
324	data->tz = g_strdup (tz);
325	data->callback = callback;
326	data->data = d;
327	data->notify = notify;
328
329	set_time_async (data);
330	free_data (data);
331	}
332
333	/* get timezone */
334
335	typedef struct
336	{
337	GetTimezoneFunc callback;
338	GDestroyNotify notify;
339
340	gpointer data;
341
342	} GetTimezoneData;
343
344	static void
345	get_timezone_destroy_notify (GetTimezoneData *data)
346	{
347	if (data->notify && data->data)
348	data->notify (data);
349
350	g_free (data);
351	}
352
353	static void
354	get_timezone_notify (DBusGProxy *proxy,
355	DBusGProxyCall *call,
356	void *user_data)
357	{
358	GError *error = NULL;
359	gboolean retval;
360	gchar *string = NULL;
361	GetTimezoneData *data = user_data;
362
363	retval = dbus_g_proxy_end_call (proxy, call, &error,
364	G_TYPE_STRING, &string,
365	G_TYPE_INVALID);
366
367	if (data->callback) {
368	if (!retval) {
369	data->callback (data->data, NULL, error);
370	g_error_free (error);
371	}
372	else {
373	data->callback (data->data, string, NULL);
374	g_free (string);
375	}
376	}
377	}
378
379	void
380	get_system_timezone_async (GetTimezoneFunc callback,
381	gpointer user_data,
382	GDestroyNotify notify)
383	{
384	DBusGConnection *bus;
385	DBusGProxy *proxy;
386	GetTimezoneData *data;
387	GError *error = NULL;
388
389	bus = get_system_bus (&error);
390	if (bus == NULL) {
391	if (error) {
392	if (callback)
393	callback (user_data, NULL, error);
394	g_clear_error (&error);
395	}
396	return;
397
398	}
399
400	data = g_new0 (GetTimezoneData, 1);
401	data->data = user_data;
402	data->notify = notify;
403	data->callback = callback;
404
405	proxy = dbus_g_proxy_new_for_name (bus,
406	"org.gnome.SettingsDaemon.DateTimeMechanism",
407	"/",
408	"org.gnome.SettingsDaemon.DateTimeMechanism");
409
410	dbus_g_proxy_begin_call (proxy,
411	"GetTimezone",
412	get_timezone_notify,
413	data,
414	(GDestroyNotify) get_timezone_destroy_notify,
415	/* parameters: */
416	G_TYPE_INVALID,
417	/* return values: */
418	G_TYPE_STRING,
419	G_TYPE_INVALID);
420
421	}
422
423	gboolean
424	get_using_ntp (void)
425	{
426	static gboolean is_using_cache = FALSE;
427	static time_t last_refreshed = 0;
428	time_t now;
429	DBusGConnection *bus;
430	DBusGProxy *proxy;
431
432	time (&now);
433	if (ABS (now - last_refreshed) > CACHE_VALIDITY_SEC) {
434	gboolean cu, iu;
435	bus = get_system_bus (NULL);
436	if (bus == NULL)
437	return FALSE;
438
439	proxy = dbus_g_proxy_new_for_name (bus,
440	"org.gnome.SettingsDaemon.DateTimeMechanism",
441	"/",
442	"org.gnome.SettingsDaemon.DateTimeMechanism");
443
444
445	if (dbus_g_proxy_call (proxy,
446	"GetUsingNtp",
447	NULL,
448	G_TYPE_INVALID,
449	G_TYPE_BOOLEAN, &cu,
450	G_TYPE_BOOLEAN, &iu,
451	G_TYPE_INVALID)) {
452	is_using_cache = iu;
453	last_refreshed = now;
454	}
455	}
456
457	return is_using_cache;
458	}
459
460	void
461	set_using_ntp_async (gboolean using_ntp,
462	GFunc callback,
463	gpointer d,
464	GDestroyNotify notify)
465	{
466	SetTimeCallbackData *data;
467
468	data = g_new0 (SetTimeCallbackData, 1);
469	data->ref_count = 1;
470	data->call = "SetUsingNtp";
471	data->time = -1;
472	data->using_ntp = using_ntp;
473	data->callback = callback;
474	data->data = d;
475	data->notify = notify;
476
477	set_time_async (data);
478	free_data (data);
479	}

Line 0 Link Here

(-)a/panels/datetime/set-timezone.h (+57 lines)
	1	/* -- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 --
	2	*
	3	* Copyright (C) 2007 David Zeuthen <david@fubar.dk>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program 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
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	18	*
	19	*/
	20
	21	#ifndef __SET_SYSTEM_TIMEZONE_H__
	22
	23	#include <config.h>
	24
	25	#include <glib.h>
	26	#include <time.h>
	27
	28	typedef void (*GetTimezoneFunc) (gpointer data,
	29	const gchar *timezone,
	30	GError *error);
	31	void get_system_timezone_async (GetTimezoneFunc callback,
	32	gpointer data,
	33	GDestroyNotify notify);
	34
	35	gint can_set_system_timezone (void);
	36
	37	gint can_set_system_time (void);
	38
	39	gint can_set_using_ntp (void);
	40
	41	void set_system_time_async (gint64 time,
	42	GFunc callback,
	43	gpointer data,
	44	GDestroyNotify notify);
	45
	46	void set_system_timezone_async (const gchar *tz,
	47	GFunc callback,
	48	gpointer data,
	49	GDestroyNotify notify);
	50
	51	gboolean get_using_ntp (void);
	52
	53	void set_using_ntp_async (gboolean using_ntp,
	54	GFunc callback,
	55	gpointer data,
	56	GDestroyNotify notify);
	57	#endif

Lines 1-27 Link Here

(-)a/panels/datetime/timedated1-interface.xml (-27 lines)
1	<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
2	"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
3	<node>
4	<interface name="org.freedesktop.timedate1">
5	<property name="Timezone" type="s" access="read"/>
6	<property name="LocalRTC" type="b" access="read"/>
7	<property name="NTP" type="b" access="read"/>
8	<method name="SetTime">
9	<arg name="usec_utc" type="x" direction="in"/>
10	<arg name="relative" type="b" direction="in"/>
11	<arg name="user_interaction" type="b" direction="in"/>
12	</method>
13	<method name="SetTimezone">
14	<arg name="timezone" type="s" direction="in"/>
15	<arg name="user_interaction" type="b" direction="in"/>
16	</method>
17	<method name="SetLocalRTC">
18	<arg name="local_rtc" type="b" direction="in"/>
19	<arg name="fix_system" type="b" direction="in"/>
20	<arg name="user_interaction" type="b" direction="in"/>
21	</method>
22	<method name="SetNTP">
23	<arg name="use_ntp" type="b" direction="in"/>
24	<arg name="user_interaction" type="b" direction="in"/>
25	</method>
26	</interface>
27	</node>