static void
gd_tagged_entry_tag_get_property (GObject      *object,
                                  guint         property_id,
                                  GValue       *value,
                                  GParamSpec   *pspec)
{
    GdTaggedEntryTag *self = GD_TAGGED_ENTRY_TAG (object);

    switch (property_id)
    {
    case PROP_TAG_LABEL:
        g_value_set_string (value, gd_tagged_entry_tag_get_label (self));
        break;
    case PROP_TAG_HAS_CLOSE_BUTTON:
        g_value_set_boolean (value, gd_tagged_entry_tag_get_has_close_button (self));
        break;
    case PROP_TAG_STYLE:
        g_value_set_string (value, gd_tagged_entry_tag_get_style (self));
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
    }
}
Example #2
0
static void
gsk_zlib_deflator_get_property	      (GObject        *object,
				       guint           property_id,
				       GValue         *value,
				       GParamSpec     *pspec)
{
  GskZlibDeflator *deflator = GSK_ZLIB_DEFLATOR (object);
  switch (property_id)
    {
    case PROP_LEVEL:
      g_value_set_int (value, deflator->level);
      break;
    case PROP_FLUSH_TIMEOUT:
      g_value_set_int (value, deflator->flush_millis);
      break;
    case PROP_USE_GZIP:
      g_value_set_boolean (value, deflator->use_gzip);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
      break;
    }
}
Example #3
0
static void
exo_tree_view_get_property (GObject    *object,
                            guint       prop_id,
                            GValue     *value,
                            GParamSpec *pspec)
{
  ExoTreeView *tree_view = EXO_TREE_VIEW (object);

  switch (prop_id)
    {
    case PROP_SINGLE_CLICK:
      g_value_set_boolean (value, exo_tree_view_get_single_click (tree_view));
      break;

    case PROP_SINGLE_CLICK_TIMEOUT:
      g_value_set_uint (value, exo_tree_view_get_single_click_timeout (tree_view));
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}
static void
nautilus_floating_bar_get_property (GObject *object,
				    guint property_id,
				    GValue *value,
				    GParamSpec *pspec)
{
	NautilusFloatingBar *self = NAUTILUS_FLOATING_BAR (object);

	switch (property_id) {
	case PROP_LABEL:
		g_value_set_string (value, self->priv->label);
		break;
	case PROP_SHOW_SPINNER:
		g_value_set_boolean (value, self->priv->show_spinner);
		break;
	case PROP_ESCAPING_DISTANCE:
		g_value_set_uint (value, self->priv->escaping_distance);
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}
static void _xfdashboard_window_tracker_monitor_get_property(GObject *inObject,
																guint inPropID,
																GValue *outValue,
																GParamSpec *inSpec)
{
	XfdashboardWindowTrackerMonitor			*self=XFDASHBOARD_WINDOW_TRACKER_MONITOR(inObject);
	XfdashboardWindowTrackerMonitorPrivate	*priv=self->priv;

	switch(inPropID)
	{
		case PROP_IS_PRIMARY:
			g_value_set_boolean(outValue, priv->isPrimary);
			break;

		case PROP_MONITOR_INDEX:
			g_value_set_uint(outValue, priv->monitorIndex);
			break;

		default:
			G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec);
			break;
	}
}
static void
gimp_rectangle_select_options_get_property (GObject    *object,
                                            guint       property_id,
                                            GValue     *value,
                                            GParamSpec *pspec)
{
  GimpRectangleSelectOptions *options = GIMP_RECTANGLE_SELECT_OPTIONS (object);

  switch (property_id)
    {
    case PROP_ROUND_CORNERS:
      g_value_set_boolean (value, options->round_corners);
      break;

    case PROP_CORNER_RADIUS:
      g_value_set_double (value, options->corner_radius);
      break;

    default:
      gimp_rectangle_options_get_property (object, property_id, value, pspec);
      break;
    }
}
static void
carrick_connman_manager_get_property (GObject    *object,
                                      guint       property_id,
                                      GValue     *value,
                                      GParamSpec *pspec)
{
  CarrickConnmanManager *self = CARRICK_CONNMAN_MANAGER (object);

  switch (property_id)
    {
    case PROP_ENABLED_TECHNOLOGIES:
      g_value_set_boxed (value, self->priv->enabled_techs);
      break;
    case PROP_AVAILABLE_TECHNOLOGIES:
      g_value_set_boxed (value, self->priv->available_techs);
      break;
    case PROP_OFFLINE_MODE:
      g_value_set_boolean (value, self->priv->offline_mode);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
    }
}
/* forwards the event to all sinkpads, takes ownership of the
 * event
 *
 * Returns: TRUE if the event could be forwarded on all
 * sinkpads.
 */
static gboolean
forward_event (GstLiveAdder * adder, GstEvent * event)
{
    gboolean ret;
    GstIterator *it;
    GValue vret = { 0 };

    GST_LOG_OBJECT (adder, "Forwarding event %p (%s)", event,
                    GST_EVENT_TYPE_NAME (event));

    ret = TRUE;

    g_value_init (&vret, G_TYPE_BOOLEAN);
    g_value_set_boolean (&vret, TRUE);
    it = gst_element_iterate_sink_pads (GST_ELEMENT_CAST (adder));
    gst_iterator_fold (it, (GstIteratorFoldFunction) forward_event_func, &vret,
                       event);
    gst_iterator_free (it);

    ret = g_value_get_boolean (&vret);

    return ret;
}
static void
gst_cel_video_src_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec)
{
  GstCelVideoSrc *self = GST_CEL_VIDEO_SRC_CAST (object);

  switch (prop_id) {
    case PROP_DEVICE_INDEX:
      g_value_set_int (value, self->device_index);
      break;
    case PROP_DO_STATS:
      g_value_set_boolean (value, self->do_stats);
      break;
    case PROP_FPS:
      GST_OBJECT_LOCK (object);
      g_value_set_int (value, self->fps);
      GST_OBJECT_UNLOCK (object);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}
Example #10
0
static void
gsf_outfile_open_pkg_get_property (GObject     *object,
				   guint        property_id,
				   GValue      *value,
				   GParamSpec  *pspec)
{
	GsfOutfileOpenPkg *open_pkg = (GsfOutfileOpenPkg *)object;

	switch (property_id) {
	case PROP_SINK:
		g_value_set_object (value, open_pkg->sink);
		break;
	case PROP_CONTENT_TYPE:
		g_value_set_string (value, open_pkg->content_type);
		break;
	case PROP_IS_DIR:
		g_value_set_boolean (value, open_pkg->is_dir);
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}
Example #11
0
static void
gsf_input_gzip_get_property (GObject     *object,
			     guint        property_id,
			     GValue      *value,
			     GParamSpec  *pspec)
{
	GsfInputGZip *gzip = (GsfInputGZip *)object;

	switch (property_id) {
	case PROP_RAW:
		g_value_set_boolean (value, gzip->raw);
		break;
	case PROP_SOURCE:
		g_value_set_object (value, gzip->source);
		break;
	case PROP_UNCOMPRESSED_SIZE:
		g_value_set_int64 (value, gzip->uncompressed_size);
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}
Example #12
0
static void
swatch_get_property (GObject    *object,
                     guint       prop_id,
                     GValue     *value,
                     GParamSpec *pspec)
{
  GtkColorSwatch *swatch = GTK_COLOR_SWATCH (object);
  GdkRGBA color;

  switch (prop_id)
    {
    case PROP_RGBA:
      gtk_color_swatch_get_rgba (swatch, &color);
      g_value_set_boxed (value, &color);
      break;
    case PROP_SELECTABLE:
      g_value_set_boolean (value, gtk_color_swatch_get_selectable (swatch));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}
static void
nautilus_floating_bar_get_property (GObject *object,
                                    guint property_id,
                                    GValue *value,
                                    GParamSpec *pspec)
{
    NautilusFloatingBar *self = NAUTILUS_FLOATING_BAR (object);

    switch (property_id) {
    case PROP_PRIMARY_LABEL:
        g_value_set_string (value, self->priv->primary_label);
        break;
    case PROP_DETAILS_LABEL:
        g_value_set_string (value, self->priv->details_label);
        break;
    case PROP_SHOW_SPINNER:
        g_value_set_boolean (value, self->priv->show_spinner);
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
        break;
    }
}
static void
gda_tree_manager_get_property (GObject *object,
                               guint param_id,
                               GValue *value,
                               GParamSpec *pspec)
{
    GdaTreeManager *manager;

    manager = GDA_TREE_MANAGER (object);
    if (manager->priv) {
        switch (param_id) {
        case PROP_RECURS:
            g_value_set_boolean (value, manager->priv->recursive);
            break;
        case PROP_FUNC:
            g_value_set_pointer (value, manager->priv->update_func);
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
            break;
        }
    }
}
Example #15
0
static void
get_property (GObject *object,
              guint prop_id,
              GValue *value,
              GParamSpec *pspec)
{
	NMDeviceBond *device = NM_DEVICE_BOND (object);

	switch (prop_id) {
	case PROP_HW_ADDRESS:
		g_value_set_string (value, nm_device_bond_get_hw_address (device));
		break;
	case PROP_CARRIER:
		g_value_set_boolean (value, nm_device_bond_get_carrier (device));
		break;
	case PROP_SLAVES:
		g_value_take_boxed (value, _nm_utils_copy_object_array (nm_device_bond_get_slaves (device)));
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
		break;
	}
}
static void
gst_net_client_internal_clock_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec)
{
  GstNetClientInternalClock *self = GST_NET_CLIENT_INTERNAL_CLOCK (object);

  switch (prop_id) {
    case PROP_ADDRESS:
      GST_OBJECT_LOCK (self);
      g_value_set_string (value, self->address);
      GST_OBJECT_UNLOCK (self);
      break;
    case PROP_PORT:
      g_value_set_int (value, self->port);
      break;
    case PROP_IS_NTP:
      g_value_set_boolean (value, self->is_ntp);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}
Example #17
0
static void
st_scroll_bar_get_property (GObject    *gobject,
                            guint       prop_id,
                            GValue     *value,
                            GParamSpec *pspec)
{
    StScrollBarPrivate *priv = ST_SCROLL_BAR (gobject)->priv;

    switch (prop_id)
    {
    case PROP_ADJUSTMENT:
        g_value_set_object (value, priv->adjustment);
        break;

    case PROP_VERTICAL:
        g_value_set_boolean (value, priv->vertical);
        break;

    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
        break;
    }
}
Example #18
0
static void get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
  {
  QCADClockingLayer *layer = QCAD_CLOCKING_LAYER (object) ;

  switch (property_id)
    {
    case QCAD_CLOCKING_LAYER_PROPERTY_SHOW_POTENTIAL:
      g_value_set_boolean (value, layer->bDrawPotential) ;
      break ;

    case QCAD_CLOCKING_LAYER_PROPERTY_Z_SHOWING:
      g_value_set_double (value, layer->z_to_draw) ;
      break ;

    case QCAD_CLOCKING_LAYER_PROPERTY_TILE_SIZE:
       g_value_set_uint (value, layer->tile_size) ;
      break ;

    case QCAD_CLOCKING_LAYER_PROPERTY_TIME_COORD:
       g_value_set_double (value, layer->time_coord) ;
      break ;
    }
  }
static void
gimp_operation_tile_source_get_property (GObject    *object,
                                         guint       property_id,
                                         GValue     *value,
                                         GParamSpec *pspec)
{
  GimpOperationTileSource *self = GIMP_OPERATION_TILE_SOURCE (object);

  switch (property_id)
    {
    case PROP_TILE_MANAGER:
      g_value_set_boxed (value, self->tile_manager);
      break;

    case PROP_LINEAR:
      g_value_set_boolean (value, self->linear);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
      break;
    }
}
Example #20
0
static void
gtd_object_get_property (GObject    *object,
                         guint       prop_id,
                         GValue     *value,
                         GParamSpec *pspec)
{
  GtdObject *self = GTD_OBJECT (object);
  GtdObjectPrivate *priv = gtd_object_get_instance_private (self);

  switch (prop_id)
    {
    case PROP_LOADING:
      g_value_set_boolean (value, priv->loading > 0);
      break;

    case PROP_UID:
      g_value_set_string (value, GTD_OBJECT_GET_CLASS (self)->get_uid (self));
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}
static void
webrtc_transceiver_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec)
{
  WebRTCTransceiver *trans = WEBRTC_TRANSCEIVER (object);

  GST_OBJECT_LOCK (trans);
  switch (prop_id) {
    case PROP_FEC_TYPE:
      g_value_set_enum (value, trans->fec_type);
      break;
    case PROP_DO_NACK:
      g_value_set_boolean (value, trans->do_nack);
      break;
    case PROP_FEC_PERCENTAGE:
      g_value_set_uint (value, trans->fec_percentage);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
  GST_OBJECT_UNLOCK (trans);
}
static void
gimp_operation_point_layer_mode_get_property (GObject    *object,
                                              guint       property_id,
                                              GValue     *value,
                                              GParamSpec *pspec)
{
  GimpOperationPointLayerMode *self = GIMP_OPERATION_POINT_LAYER_MODE (object);

  switch (property_id)
    {
    case PROP_PREMULTIPLIED:
      g_value_set_boolean (value, self->premultiplied);
      break;

    case PROP_OPACITY:
      g_value_set_double (value, self->opacity);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
      break;
    }
}
Example #23
0
static void
gst_pngenc_get_property (GObject * object,
    guint prop_id, GValue * value, GParamSpec * pspec)
{
  GstPngEnc *pngenc;

  pngenc = GST_PNGENC (object);

  switch (prop_id) {
    case ARG_SNAPSHOT:
      g_value_set_boolean (value, pngenc->snapshot);
      break;
/*     case ARG_NEWMEDIA: */
/*       g_value_set_boolean (value, pngenc->newmedia); */
/*       break; */
    case ARG_COMPRESSION_LEVEL:
      g_value_set_uint (value, pngenc->compression_level);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}
Example #24
0
static void
get_property (GObject *object,
              guint prop_id,
              GValue *value,
              GParamSpec *pspec)
{
	NMDeviceVlan *device = NM_DEVICE_VLAN (object);

	switch (prop_id) {
	case PROP_HW_ADDRESS:
		g_value_set_string (value, nm_device_vlan_get_hw_address (device));
		break;
	case PROP_CARRIER:
		g_value_set_boolean (value, nm_device_vlan_get_carrier (device));
		break;
	case PROP_VLAN_ID:
		g_value_set_uint (value, nm_device_vlan_get_vlan_id (device));
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
		break;
	}
}
Example #25
0
/* BOOLEAN:POINTER (cong.marshal:3) */
void
cong_cclosure_marshal_BOOLEAN__POINTER (GClosure     *closure,
                                        GValue       *return_value,
                                        guint         n_param_values,
                                        const GValue *param_values,
                                        gpointer      invocation_hint,
                                        gpointer      marshal_data)
{
  typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer     data1,
                                                     gpointer     arg_1,
                                                     gpointer     data2);
  register GMarshalFunc_BOOLEAN__POINTER callback;
  register GCClosure *cc = (GCClosure*) closure;
  register gpointer data1, data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 2);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }
  callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);

  v_return = callback (data1,
                       g_marshal_value_peek_pointer (param_values + 1),
                       data2);

  g_value_set_boolean (return_value, v_return);
}
Example #26
0
static void client_get_property(GObject *object, guint property_id,GValue *value, GParamSpec *pspec)
{
	Client * obj = CLIENT(object);
	gchar * ip_str;
	switch (property_id)
	{
	case CLIENT_NAME:
		g_value_set_string(value,obj->name);
		break;
	case CLIENT_ID:
		g_value_set_string(value,obj->id);
		break;
	case CLIENT_ID_TYPE:
		g_value_set_string(value,obj->idtype);
		break;
	case CLIENT_IP_STR:
		ip_str = g_strdup_printf("%03d.%03d.%03d.%03d",
				((guchar*)&(obj->ip))[0],
				((guchar*)&(obj->ip))[1],
				((guchar*)&(obj->ip))[2],
				((guchar*)&(obj->ip))[3]);
		g_value_take_string(value,ip_str);
		break;
	case CLIENT_ROOM:
		g_value_set_string(value,obj->room);
		break;
	case CLIENT_IP:
		g_value_set_uint(value,obj->ip);
		break;
	case CLIENT_ENABLE:
		g_value_set_boolean(value,obj->enable);
		break;
	default:
		g_warn_if_reached();
		break;
	}
}
static void
replay_edge_create_event_get_property(GObject    *object,
                                   guint       property_id,
                                   GValue     *value,
                                   GParamSpec *pspec)
{
  ReplayEdgeCreateEvent *self;

  g_return_if_fail(REPLAY_IS_EDGE_CREATE_EVENT(object));

  self = REPLAY_EDGE_CREATE_EVENT(object);

  switch (property_id) {
    case PROP_ID:
      g_value_set_string(value, self->priv->id);
      break;

    case PROP_DIRECTED:
      g_value_set_boolean(value, self->priv->directed);
      break;

    case PROP_TAIL:
      g_value_set_string(value, self->priv->tail);
      break;

    case PROP_HEAD:
      g_value_set_string(value, self->priv->head);
      break;

    case PROP_PROPS:
      g_value_set_variant(value, self->priv->props);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
  }
}
Example #28
0
static void
vik_wmsc_map_source_get_property (GObject    *object,
                                    guint       property_id,
                                    GValue     *value,
                                    GParamSpec *pspec)
{
  VikWmscMapSource *self = VIK_WMSC_MAP_SOURCE (object);
  VikWmscMapSourcePrivate *priv = VIK_WMSC_MAP_SOURCE_PRIVATE (self);

  switch (property_id)
    {
    case PROP_HOSTNAME:
      g_value_set_string (value, priv->hostname);
      break;

    case PROP_URL:
      g_value_set_string (value, priv->url);
      break;

    case PROP_REFERER:
      g_value_set_string (value, priv->options.referer);
      break;

    case PROP_FOLLOW_LOCATION:
      g_value_set_long (value, priv->options.follow_location);
      break;

    case PROP_CHECK_FILE_SERVER_TIME:
      g_value_set_boolean (value, priv->options.check_file_server_time);
      break;
	  
    default:
      /* We don't have any other property... */
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
      break;
    }
}
Example #29
0
/**
 * pk_plugin_get_property:
 **/
static void
pk_plugin_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
	PkPlugin *plugin = PK_PLUGIN (object);
	switch (prop_id) {
	case PROP_X:
		g_value_set_uint (value, plugin->priv->x);
		break;
	case PROP_Y:
		g_value_set_uint (value, plugin->priv->y);
		break;
	case PROP_WIDTH:
		g_value_set_uint (value, plugin->priv->width);
		break;
	case PROP_HEIGHT:
		g_value_set_uint (value, plugin->priv->height);
		break;
	case PROP_DISPLAY:
		g_value_set_pointer (value, plugin->priv->display);
		break;
	case PROP_VISUAL:
		g_value_set_pointer (value, plugin->priv->visual);
		break;
	case PROP_STARTED:
		g_value_set_boolean (value, plugin->priv->started);
		break;
	case PROP_WINDOW:
		g_value_set_ulong (value, plugin->priv->window);
		break;
	case PROP_GDKWINDOW:
		g_value_set_pointer (value, plugin->priv->gdk_window);
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
		break;
	}
}
static void
gst_stream_info_get_property (GObject * object, guint prop_id, GValue * value,
    GParamSpec * pspec)
{
  GstStreamInfo *stream_info;

  g_return_if_fail (GST_IS_STREAM_INFO (object));

  stream_info = GST_STREAM_INFO (object);

  switch (prop_id) {
    case ARG_PAD:
      g_value_set_object (value, stream_info->object);
      break;
    case ARG_TYPE:
      g_value_set_enum (value, stream_info->type);
      break;
    case ARG_DECODER:
      g_value_set_string (value, stream_info->decoder);
      break;
    case ARG_MUTE:
      g_value_set_boolean (value, stream_info->mute);
      break;
    case ARG_CAPS:
      g_value_set_boxed (value, stream_info->caps);
      break;
    case ARG_LANG_CODE:
      g_value_set_string (value, stream_info->langcode);
      break;
    case ARG_CODEC:
      g_value_set_string (value, stream_info->codec);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}