Back to index

indicator-power  12.10.0
Classes | Defines | Enumerations | Functions | Variables
device.c File Reference
#include <glib/gi18n.h>
#include "device.h"

Go to the source code of this file.

Classes

struct  _IndicatorPowerDevicePrivate

Defines

#define INDICATOR_POWER_DEVICE_GET_PRIVATE(o)   (INDICATOR_POWER_DEVICE(o)->priv)

Enumerations

enum  {
  PROP_0, PROP_KIND, PROP_STATE, PROP_OBJECT_PATH,
  PROP_PERCENTAGE, PROP_TIME, N_PROPERTIES
}

Functions

static void indicator_power_device_class_init (IndicatorPowerDeviceClass *klass)
static void indicator_power_device_init (IndicatorPowerDevice *self)
static void indicator_power_device_dispose (GObject *object)
static void indicator_power_device_finalize (GObject *object)
static void set_property (GObject *, guint prop_id, const GValue *, GParamSpec *)
static void get_property (GObject *, guint prop_id, GValue *, GParamSpec *)
 G_DEFINE_TYPE (IndicatorPowerDevice, indicator_power_device, G_TYPE_OBJECT)
UpDeviceKind indicator_power_device_get_kind (const IndicatorPowerDevice *device)
UpDeviceState indicator_power_device_get_state (const IndicatorPowerDevice *device)
const gchar * indicator_power_device_get_object_path (const IndicatorPowerDevice *device)
gdouble indicator_power_device_get_percentage (const IndicatorPowerDevice *device)
time_t indicator_power_device_get_time (const IndicatorPowerDevice *device)
static const gchar * get_device_icon_suffix (gdouble percentage)
static const gchar * get_device_icon_index (gdouble percentage)
GStrv indicator_power_device_get_icon_names (const IndicatorPowerDevice *device)
 indicator_power_device_get_icon_names: : #IndicatorPowerDevice from which to generate the icon names
GIcon * indicator_power_device_get_gicon (const IndicatorPowerDevice *device)
 indicator_power_device_get_gicon: : #IndicatorPowerDevice to generate the icon names from
static void get_timestring (guint64 time_secs, gchar **short_timestring, gchar **detailed_timestring)
static const gchar * device_kind_to_localised_string (UpDeviceKind kind)
void indicator_power_device_get_time_details (const IndicatorPowerDevice *device, gchar **short_details, gchar **details, gchar **accessible_name)
IndicatorPowerDevice * indicator_power_device_new (const gchar *object_path, UpDeviceKind kind, gdouble percentage, UpDeviceState state, time_t timestamp)
IndicatorPowerDevice * indicator_power_device_new_from_variant (GVariant *v)
 Convenience wrapper around indicator_power_device_new() holds the same args as indicator_power_device_new() in "(susdut)".

Variables

static GParamSpec * properties [N_PROPERTIES]

Class Documentation

struct _IndicatorPowerDevicePrivate

Definition at line 32 of file device.c.

Class Members
UpDeviceKind kind
gchar * object_path
gdouble percentage
UpDeviceState state
time_t time

Define Documentation

Definition at line 41 of file device.c.


Enumeration Type Documentation

anonymous enum
Enumerator:
PROP_0 
PROP_KIND 
PROP_STATE 
PROP_OBJECT_PATH 
PROP_PERCENTAGE 
PROP_TIME 
N_PROPERTIES 

Definition at line 45 of file device.c.


Function Documentation

static const gchar* device_kind_to_localised_string ( UpDeviceKind  kind) [static]

Definition at line 481 of file device.c.

{
  const gchar *text = NULL;

  switch (kind) {
    case UP_DEVICE_KIND_LINE_POWER:
      /* TRANSLATORS: system power cord */
      text = _("AC Adapter");
      break;
    case UP_DEVICE_KIND_BATTERY:
      /* TRANSLATORS: laptop primary battery */
      text = _("Battery");
      break;
    case UP_DEVICE_KIND_UPS:
      /* TRANSLATORS: battery-backed AC power source */
      text = _("UPS");
      break;
    case UP_DEVICE_KIND_MONITOR:
      /* TRANSLATORS: a monitor is a device to measure voltage and current */
      text = _("Monitor");
      break;
    case UP_DEVICE_KIND_MOUSE:
      /* TRANSLATORS: wireless mice with internal batteries */
      text = _("Mouse");
      break;
    case UP_DEVICE_KIND_KEYBOARD:
      /* TRANSLATORS: wireless keyboard with internal battery */
      text = _("Keyboard");
      break;
    case UP_DEVICE_KIND_PDA:
      /* TRANSLATORS: portable device */
      text = _("PDA");
      break;
    case UP_DEVICE_KIND_PHONE:
      /* TRANSLATORS: cell phone (mobile...) */
      text = _("Cell phone");
      break;
    case UP_DEVICE_KIND_MEDIA_PLAYER:
      /* TRANSLATORS: media player, mp3 etc */
      text = _("Media player");
      break;
    case UP_DEVICE_KIND_TABLET:
      /* TRANSLATORS: tablet device */
      text = _("Tablet");
      break;
    case UP_DEVICE_KIND_COMPUTER:
      /* TRANSLATORS: tablet device */
      text = _("Computer");
      break;
    default:
      g_warning ("enum unrecognised: %i", kind);
      text = up_device_kind_to_string (kind);
    }

  return text;
}

Here is the caller graph for this function:

G_DEFINE_TYPE ( IndicatorPowerDevice  ,
indicator_power_device  ,
G_TYPE_OBJECT   
)
static const gchar* get_device_icon_index ( gdouble  percentage) [static]

Definition at line 294 of file device.c.

{
  if (percentage >= 90) return "100";
  if (percentage >= 70) return "080";
  if (percentage >= 50) return "060";
  if (percentage >= 30) return "040";
  if (percentage >= 10) return "020";
  return "000";
}

Here is the caller graph for this function:

static const gchar* get_device_icon_suffix ( gdouble  percentage) [static]

Definition at line 285 of file device.c.

{
  if (percentage >= 60) return "full";
  if (percentage >= 30) return "good";
  if (percentage >= 10) return "low";
  return "caution";
}

Here is the caller graph for this function:

static void get_property ( GObject *  o,
guint  prop_id,
GValue *  value,
GParamSpec *  pspec 
) [static]

Definition at line 157 of file device.c.

{
  IndicatorPowerDevice * self = INDICATOR_POWER_DEVICE(o);
  IndicatorPowerDevicePrivate * priv = self->priv;

  switch (prop_id)
    {
      case PROP_KIND:
        g_value_set_int (value, priv->kind);
        break;

      case PROP_STATE:
        g_value_set_int (value, priv->state);
        break;

      case PROP_OBJECT_PATH:
        g_value_set_string (value, priv->object_path);
        break;

      case PROP_PERCENTAGE:
        g_value_set_double (value, priv->percentage);
        break;

      case PROP_TIME:
        g_value_set_uint64 (value, priv->time);
        break;

      default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID(o, prop_id, pspec);
        break;
    }
}

Here is the caller graph for this function:

static void get_timestring ( guint64  time_secs,
gchar **  short_timestring,
gchar **  detailed_timestring 
) [static]

Definition at line 431 of file device.c.

{
  gint  hours;
  gint  minutes;

  /* Add 0.5 to do rounding */
  minutes = (int) ( ( time_secs / 60.0 ) + 0.5 );

  if (minutes == 0)
    {
      *short_timestring = g_strdup (_("Unknown time"));
      *detailed_timestring = g_strdup (_("Unknown time"));

      return;
    }

  if (minutes < 60)
    {
      *short_timestring = g_strdup_printf ("0:%.2i", minutes);
      *detailed_timestring = g_strdup_printf (g_dngettext (GETTEXT_PACKAGE, "%i minute",
                                              "%i minutes",
                                              minutes), minutes);
      return;
    }

  hours = minutes / 60;
  minutes = minutes % 60;

  *short_timestring = g_strdup_printf ("%i:%.2i", hours, minutes);

  if (minutes == 0)
    {
      *detailed_timestring = g_strdup_printf (g_dngettext (GETTEXT_PACKAGE, 
                                              "%i hour",
                                              "%i hours",
                                              hours), hours);
    }
  else
    {
      /* TRANSLATOR: "%i %s %i %s" are "%i hours %i minutes"
       * Swap order with "%2$s %2$i %1$s %1$i if needed */
      *detailed_timestring = g_strdup_printf (_("%i %s %i %s"),
                                              hours, g_dngettext (GETTEXT_PACKAGE, "hour", "hours", hours),
                                              minutes, g_dngettext (GETTEXT_PACKAGE, "minute", "minutes", minutes));
    }
}

Here is the caller graph for this function:

static void indicator_power_device_class_init ( IndicatorPowerDeviceClass *  klass) [static]

Definition at line 70 of file device.c.

{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  g_type_class_add_private (klass, sizeof (IndicatorPowerDevicePrivate));

  object_class->dispose = indicator_power_device_dispose;
  object_class->finalize = indicator_power_device_finalize;
  object_class->set_property = set_property;
  object_class->get_property = get_property;

  properties[PROP_KIND] = g_param_spec_int (INDICATOR_POWER_DEVICE_KIND,
                                            "kind",
                                            "The device's UpDeviceKind",
                                            UP_DEVICE_KIND_UNKNOWN, UP_DEVICE_KIND_LAST,
                                            UP_DEVICE_KIND_UNKNOWN,
                                            G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);

  properties[PROP_STATE] = g_param_spec_int (INDICATOR_POWER_DEVICE_STATE,
                                             "state",
                                             "The device's UpDeviceState",
                                             UP_DEVICE_STATE_UNKNOWN, UP_DEVICE_STATE_LAST,
                                             UP_DEVICE_STATE_UNKNOWN,
                                             G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);

  properties[PROP_OBJECT_PATH] = g_param_spec_string (INDICATOR_POWER_DEVICE_OBJECT_PATH,
                                                      "object path",
                                                      "The device's DBus object path",
                                                      NULL,
                                                      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);

  properties[PROP_PERCENTAGE] = g_param_spec_double (INDICATOR_POWER_DEVICE_PERCENTAGE,
                                                     "percentage",
                                                     "percent charged",
                                                     0.0, 100.0,
                                                     0.0,
                                                     G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);

  properties[PROP_TIME] = g_param_spec_uint64 (INDICATOR_POWER_DEVICE_TIME,
                                               "time",
                                               "time left",
                                               0, G_MAXUINT64,
                                               0,
                                               G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);

  g_object_class_install_properties (object_class, N_PROPERTIES, properties);
}

Here is the call graph for this function:

static void indicator_power_device_dispose ( GObject *  object) [static]

Definition at line 136 of file device.c.

{
  G_OBJECT_CLASS (indicator_power_device_parent_class)->dispose (object);
}

Here is the caller graph for this function:

static void indicator_power_device_finalize ( GObject *  object) [static]

Definition at line 142 of file device.c.

{
  IndicatorPowerDevice * self = INDICATOR_POWER_DEVICE(object);
  IndicatorPowerDevicePrivate * priv = self->priv;

  g_clear_pointer (&priv->object_path, g_free);

  G_OBJECT_CLASS (indicator_power_device_parent_class)->finalize (object);
}

Here is the caller graph for this function:

GIcon* indicator_power_device_get_gicon ( const IndicatorPowerDevice *  device)

indicator_power_device_get_gicon: : #IndicatorPowerDevice to generate the icon names from

A convenience function to call g_themed_icon_new_from_names() with the names returned by indicator_power_device_get_icon_names()

Return value: (transfer full): A themed GIcon

Definition at line 418 of file device.c.

{
  GStrv names = indicator_power_device_get_icon_names (device);
  GIcon * icon = g_themed_icon_new_from_names (names, -1);
  g_strfreev (names);
  return icon;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GStrv indicator_power_device_get_icon_names ( const IndicatorPowerDevice *  device)

indicator_power_device_get_icon_names: : #IndicatorPowerDevice from which to generate the icon names

This function's logic differs from GSD's power plugin in some ways:

  1. All charging batteries use the same icon regardless of progress. https://bugs.launchpad.net/indicator-power/+bug/824629/comments/7
  1. For discharging batteries, we decide whether or not to use the 'caution' icon based on whether or not we have <= 30 minutes remaining, rather than looking at the battery's percentage left. https://bugs.launchpad.net/indicator-power/+bug/743823

See also indicator_power_device_get_gicon().

Return value: (array zero-terminated=1) (transfer full): A GStrv of icon names suitable for passing to g_themed_icon_new_from_names(). Free with g_strfreev() when done.

Definition at line 325 of file device.c.

{
  const gchar *suffix_str;
  const gchar *index_str;

  /* LCOV_EXCL_START */
  g_return_val_if_fail (INDICATOR_IS_POWER_DEVICE(device), NULL);
  /* LCOV_EXCL_STOP */

  gdouble percentage = indicator_power_device_get_percentage (device);
  const UpDeviceKind kind = indicator_power_device_get_kind (device);
  const UpDeviceState state = indicator_power_device_get_state (device);
  const gchar * kind_str = kind_str = up_device_kind_to_string (kind);

  GPtrArray * names = g_ptr_array_new ();

  if (kind == UP_DEVICE_KIND_LINE_POWER)
    {
      g_ptr_array_add (names, g_strdup("ac-adapter-symbolic"));
      g_ptr_array_add (names, g_strdup("ac-adapter"));
    }
  else if (kind == UP_DEVICE_KIND_MONITOR)
    {
      g_ptr_array_add (names, g_strdup("gpm-monitor-symbolic"));
      g_ptr_array_add (names, g_strdup("gpm-monitor"));
    }
  else switch (state)
    {
      case UP_DEVICE_STATE_EMPTY:
        g_ptr_array_add (names, g_strdup("battery-empty-symbolic"));
        g_ptr_array_add (names, g_strdup_printf("gpm-%s-empty", kind_str));
        g_ptr_array_add (names, g_strdup_printf("gpm-%s-000", kind_str));
        g_ptr_array_add (names, g_strdup("battery-empty"));
        break;

      case UP_DEVICE_STATE_FULLY_CHARGED:
        g_ptr_array_add (names, g_strdup("battery-full-charged-symbolic"));
        g_ptr_array_add (names, g_strdup("battery-full-charging-symbolic"));
        g_ptr_array_add (names, g_strdup_printf("gpm-%s-full", kind_str));
        g_ptr_array_add (names, g_strdup_printf("gpm-%s-100", kind_str));
        g_ptr_array_add (names, g_strdup("battery-full-charged"));
        g_ptr_array_add (names, g_strdup("battery-full-charging"));
        break;

      case UP_DEVICE_STATE_CHARGING:
      case UP_DEVICE_STATE_PENDING_CHARGE:
        /* When charging, always use the same icon regardless of percentage.
           <http://bugs.launchpad.net/indicator-power/+bug/824629> */
        percentage = 0;

        suffix_str = get_device_icon_suffix (percentage);
        index_str = get_device_icon_index (percentage);
        g_ptr_array_add (names, g_strdup_printf ("battery-%s-charging-symbolic", suffix_str));
        g_ptr_array_add (names, g_strdup_printf ("gpm-%s-%s-charging", kind_str, index_str));
        g_ptr_array_add (names, g_strdup_printf ("battery-%s-charging", suffix_str));
        break;

      case UP_DEVICE_STATE_DISCHARGING:
      case UP_DEVICE_STATE_PENDING_DISCHARGE:
        /* Don't show the caution/red icons unless we have <=30 min left.
           <https://bugs.launchpad.net/indicator-power/+bug/743823>
           Themes use the caution color when the percentage is 0% or 20%,
           so if we have >30 min left, use 30% as the icon's percentage floor */
        if (indicator_power_device_get_time (device) > (30*60))
          percentage = MAX(percentage, 30);

        suffix_str = get_device_icon_suffix (percentage);
        index_str = get_device_icon_index (percentage);
        g_ptr_array_add (names, g_strdup_printf ("battery-%s-symbolic", suffix_str));
        g_ptr_array_add (names, g_strdup_printf ("gpm-%s-%s", kind_str, index_str));
        g_ptr_array_add (names, g_strdup_printf ("battery-%s", suffix_str));
        break;

      default:
        g_ptr_array_add (names, g_strdup("battery-missing-symbolic"));
        g_ptr_array_add (names, g_strdup("gpm-battery-missing"));
        g_ptr_array_add (names, g_strdup("battery-missing"));
    }

    g_ptr_array_add (names, NULL); /* terminates the strv */
    return (GStrv) g_ptr_array_free (names, FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

UpDeviceKind indicator_power_device_get_kind ( const IndicatorPowerDevice *  device)

Definition at line 230 of file device.c.

{
  /* LCOV_EXCL_START */
  g_return_val_if_fail (INDICATOR_IS_POWER_DEVICE(device), UP_DEVICE_KIND_UNKNOWN);
  /* LCOV_EXCL_STOP */

  return device->priv->kind;
}

Here is the caller graph for this function:

const gchar* indicator_power_device_get_object_path ( const IndicatorPowerDevice *  device)

Definition at line 250 of file device.c.

{
  /* LCOV_EXCL_START */
  g_return_val_if_fail (INDICATOR_IS_POWER_DEVICE(device), NULL);
  /* LCOV_EXCL_STOP */

  return device->priv->object_path;
}

Here is the caller graph for this function:

gdouble indicator_power_device_get_percentage ( const IndicatorPowerDevice *  device)

Definition at line 260 of file device.c.

{
  /* LCOV_EXCL_START */
  g_return_val_if_fail (INDICATOR_IS_POWER_DEVICE(device), 0.0);
  /* LCOV_EXCL_STOP */

  return device->priv->percentage;
}

Here is the caller graph for this function:

UpDeviceState indicator_power_device_get_state ( const IndicatorPowerDevice *  device)

Definition at line 240 of file device.c.

{
  /* LCOV_EXCL_START */
  g_return_val_if_fail (INDICATOR_IS_POWER_DEVICE(device), UP_DEVICE_STATE_UNKNOWN);
  /* LCOV_EXCL_STOP */

  return device->priv->state;
}

Here is the caller graph for this function:

time_t indicator_power_device_get_time ( const IndicatorPowerDevice *  device)

Definition at line 270 of file device.c.

{
  /* LCOV_EXCL_START */
  g_return_val_if_fail (INDICATOR_IS_POWER_DEVICE(device), (time_t)0);
  /* LCOV_EXCL_STOP */

  return device->priv->time;
}

Here is the caller graph for this function:

void indicator_power_device_get_time_details ( const IndicatorPowerDevice *  device,
gchar **  short_details,
gchar **  details,
gchar **  accessible_name 
)

Definition at line 539 of file device.c.

{
  if (!INDICATOR_IS_POWER_DEVICE(device))
    {
      *short_details = NULL;
      *details = NULL;
      *accessible_name = NULL;
      g_warning ("%s: %p is not an IndicatorPowerDevice", G_STRFUNC, device);
      return;
    }

  const time_t time = indicator_power_device_get_time (device);
  const UpDeviceState state = indicator_power_device_get_state (device);
  const gdouble percentage = indicator_power_device_get_percentage (device);
  const UpDeviceKind kind = indicator_power_device_get_kind (device);
  const gchar * device_name = device_kind_to_localised_string (kind);

  if (time > 0)
    {
      gchar *short_timestring = NULL;
      gchar *detailed_timestring = NULL;

      get_timestring (time,
                      &short_timestring,
                      &detailed_timestring);

      if (state == UP_DEVICE_STATE_CHARGING)
        {
          /* TRANSLATORS: %2 is a time string, e.g. "1 hour 5 minutes" */
          *accessible_name = g_strdup_printf (_("%s (%s to charge (%.0lf%%))"), device_name, detailed_timestring, percentage);
          *details = g_strdup_printf (_("%s (%s to charge)"), device_name, short_timestring);
          *short_details = g_strdup_printf ("(%s)", short_timestring);
        }
      else if ((state == UP_DEVICE_STATE_DISCHARGING) && (time > (60*60*12)))
        {
          *accessible_name = g_strdup_printf (_("%s"), device_name);
          *details = g_strdup_printf (_("%s"), device_name);
          *short_details = g_strdup (short_timestring);
        }
      else
        {
          /* TRANSLATORS: %2 is a time string, e.g. "1 hour 5 minutes" */
          *accessible_name = g_strdup_printf (_("%s (%s left (%.0lf%%))"), device_name, detailed_timestring, percentage);
          *details = g_strdup_printf (_("%s (%s left)"), device_name, short_timestring);
          *short_details = g_strdup (short_timestring);
        }

      g_free (short_timestring);
      g_free (detailed_timestring);
    }
  else if (state == UP_DEVICE_STATE_FULLY_CHARGED)
    {
      *details = g_strdup_printf (_("%s (charged)"), device_name);
      *accessible_name = g_strdup (*details);
      *short_details = g_strdup ("");
    }
  else if (percentage > 0)
    {
      /* TRANSLATORS: %2 is a percentage value. Note: this string is only
       * used when we don't have a time value */
      *details = g_strdup_printf (_("%s (%.0lf%%)"), device_name, percentage);
      *accessible_name = g_strdup (*details);
      *short_details = g_strdup_printf (_("(%.0lf%%)"), percentage);
    }
  else if (kind == UP_DEVICE_KIND_LINE_POWER)
    {
      *details         = g_strdup (device_name);
      *accessible_name = g_strdup (device_name);
      *short_details   = g_strdup (device_name);
    }
  else
    {
      *details = g_strdup_printf (_("%s (not present)"), device_name);
      *accessible_name = g_strdup (*details);
      *short_details = g_strdup (_("(not present)"));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void indicator_power_device_init ( IndicatorPowerDevice *  self) [static]

Definition at line 120 of file device.c.

{
  IndicatorPowerDevicePrivate * priv;

  priv = G_TYPE_INSTANCE_GET_PRIVATE (self, INDICATOR_POWER_DEVICE_TYPE,
                                            IndicatorPowerDevicePrivate);
  priv->kind = UP_DEVICE_KIND_UNKNOWN;
  priv->state = UP_DEVICE_STATE_UNKNOWN;
  priv->object_path = NULL;
  priv->percentage = 0.0;
  priv->time = 0;

  self->priv = priv;
}
IndicatorPowerDevice* indicator_power_device_new ( const gchar *  object_path,
UpDeviceKind  kind,
gdouble  percentage,
UpDeviceState  state,
time_t  timestamp 
)

Definition at line 625 of file device.c.

Here is the caller graph for this function:

IndicatorPowerDevice* indicator_power_device_new_from_variant ( GVariant *  v)

Convenience wrapper around indicator_power_device_new() holds the same args as indicator_power_device_new() in "(susdut)".

Definition at line 642 of file device.c.

{
  g_return_val_if_fail (g_variant_is_of_type (v, G_VARIANT_TYPE("(susdut)")), NULL);

  UpDeviceKind kind = UP_DEVICE_KIND_UNKNOWN;
  UpDeviceState state = UP_DEVICE_STATE_UNKNOWN;
  const gchar * icon = NULL;
  const gchar * object_path = NULL;
  gdouble percentage = 0;
  guint64 time = 0;

  g_variant_get (v, "(&su&sdut)",
                 &object_path,
                 &kind,
                 &icon,
                 &percentage,
                 &state,
                 &time);

  return indicator_power_device_new (object_path,
                                     kind,
                                     percentage,
                                     state,
                                     time);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void set_property ( GObject *  o,
guint  prop_id,
const GValue *  value,
GParamSpec *  pspec 
) [static]

Definition at line 191 of file device.c.

{
  IndicatorPowerDevice * self = INDICATOR_POWER_DEVICE(o);
  IndicatorPowerDevicePrivate * priv = self->priv;

  switch (prop_id)
    {
      case PROP_KIND:
        priv->kind = g_value_get_int (value);
        break;

      case PROP_STATE:
        priv->state = g_value_get_int (value);
        break;

      case PROP_OBJECT_PATH:
        g_free (priv->object_path);
        priv->object_path = g_value_dup_string (value);
        break;

      case PROP_PERCENTAGE:
        priv->percentage = g_value_get_double (value);
        break;

      case PROP_TIME:
        priv->time = g_value_get_uint64(value);
        break;

      default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID(o, prop_id, pspec);
        break;
    }
}

Here is the caller graph for this function:


Variable Documentation

GParamSpec* properties[N_PROPERTIES] [static]

Definition at line 55 of file device.c.