static void gimp_text_style_editor_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GimpTextStyleEditor *editor = GIMP_TEXT_STYLE_EDITOR (object); switch (property_id) { case PROP_GIMP: editor->gimp = g_value_get_object (value); /* don't ref */ break; case PROP_TEXT: editor->text = g_value_dup_object (value); break; case PROP_BUFFER: editor->buffer = g_value_dup_object (value); break; case PROP_FONTS: editor->fonts = g_value_dup_object (value); break; case PROP_RESOLUTION_X: editor->resolution_x = g_value_get_double (value); break; case PROP_RESOLUTION_Y: editor->resolution_y = g_value_get_double (value); if (editor->size_entry) gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (editor->size_entry), 0, editor->resolution_y, TRUE); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void gdl_dock_item_grip_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GdlDockItemGrip *grip; g_return_if_fail (GDL_IS_DOCK_ITEM_GRIP (object)); grip = GDL_DOCK_ITEM_GRIP (object); switch (prop_id) { case PROP_ITEM: grip->item = g_value_get_object (value); if (grip->item) { g_signal_connect (grip->item, "notify::long_name", G_CALLBACK (gdl_dock_item_grip_item_notify), grip); g_signal_connect (grip->item, "notify::stock_id", G_CALLBACK (gdl_dock_item_grip_item_notify), grip); g_signal_connect (grip->item, "notify::behavior", G_CALLBACK (gdl_dock_item_grip_item_notify), grip); if (!GDL_DOCK_ITEM_CANT_CLOSE (grip->item) && grip->_priv->close_button) gtk_widget_show (grip->_priv->close_button); if (!GDL_DOCK_ITEM_CANT_ICONIFY (grip->item) && grip->_priv->iconify_button) gtk_widget_show (grip->_priv->iconify_button); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
void ags_switch_buffer_flag_set_property(GObject *gobject, guint prop_id, const GValue *value, GParamSpec *param_spec) { AgsSwitchBufferFlag *switch_buffer_flag; switch_buffer_flag = AGS_SWITCH_BUFFER_FLAG(gobject); switch(prop_id){ case PROP_DEVICE: { GObject *device; device = (GObject *) g_value_get_object(value); if(switch_buffer_flag->device == (GObject *) device){ return; } if(switch_buffer_flag->device != NULL){ g_object_unref(switch_buffer_flag->device); } if(device != NULL){ g_object_ref(device); } switch_buffer_flag->device = (GObject *) device; } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec); break; } }
static HioRequestHttp* hwf_connection_container_create_request(HioConnectionHttp *http, const char *method, int major_version, int minor_version, const char *path, const char *query_string) { HioRequestHttp *request; GValue value = { 0, }; request = hio_request_http_new(HWF_TYPE_REQUEST_CONTAINER, method, major_version, minor_version, path, query_string); g_value_init(&value, HJS_TYPE_RUNTIME); if (!hrt_task_get_arg(HIO_CONNECTION(http)->task, "runtime", &value, NULL)) g_error("Task didn't have a runtime set on it"); hwf_request_container_set_runtime(HWF_REQUEST_CONTAINER(request), g_value_get_object(&value)); g_value_unset(&value); hrt_debug("Created request %s %d.%d '%s' query '%s'", hio_request_http_get_method(request), hio_request_http_get_major_version(request), hio_request_http_get_minor_version(request), hio_request_http_get_path(request), hio_request_http_get_query_string(request)); return request; }
static void coil_expandable_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { CoilExpandable *self = COIL_EXPANDABLE(object); switch (property_id) { case PROP_CONTAINER: { self->container = g_value_get_object(value); break; } /* TODO(jcon): refactor */ case PROP_LOCATION: { if (self->location.filepath) g_free(self->location.filepath); CoilLocation *loc_ptr; loc_ptr = (CoilLocation *)g_value_get_pointer(value); if (loc_ptr) { self->location = *((CoilLocation *)loc_ptr); self->location.filepath = g_strdup(loc_ptr->filepath); } break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); break; } }
void moto_variation_save_param(MotoVariation *self, MotoParam *p) { MotoVariationPriv *priv = MOTO_VARIATION_GET_PRIVATE(self); GValue none = {0,}; guint id = moto_param_get_id(p); GValue *pv = moto_param_get_value(p); GType pt = G_VALUE_TYPE(pv); GHashTable *params = priv->params; GValue *v = (GValue *)g_hash_table_lookup(params, &id); if( ! v) { v = g_slice_new(GValue); *v = none; g_value_init(v, pt); guint *key = g_slice_new(guint); *key = id; g_hash_table_insert(params, key, v); } else if(g_type_is_a(pt, G_TYPE_OBJECT)) { GObject *o = g_value_get_object(v); if(o) g_object_weak_unref(o, (GWeakNotify)null_value, v); } if(g_type_is_a(pt, G_TYPE_OBJECT)) { GObject *o = moto_param_get_object(p); if(o) g_object_weak_ref(o, (GWeakNotify)null_value, v); } g_value_copy(pv, v); }
static gboolean _button_press_event_watcher (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, gpointer data) { GObject *object; gchar * button_name = (gchar *) data; object = g_value_get_object (param_values + 0); if (ATK_IS_IMPLEMENTOR(object)) { AtkObject * atk_obj = atk_implementor_ref_accessible(ATK_IMPLEMENTOR(object)); g_print("Button <%s> pressed %d times!\n", button_name, (g_press_count + 1)); g_print("Displaying children of Button pressed!\n"); display_children(atk_obj, 0, 0); if (g_press_count >= 5) { g_print("Removing global event listener on buttons\n"); atk_remove_global_event_listener(g_signal_listener); g_signal_listener = 0; g_press_count = 0; g_register_listener = FALSE; } else { g_press_count++; } } return TRUE; }
static void hippo_canvas_widget_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { HippoCanvasWidget *widget; widget = HIPPO_CANVAS_WIDGET(object); switch (prop_id) { case PROP_WIDGET: { GtkWidget *w = (GtkWidget*) g_value_get_object(value); if (widget->widget != w) { if (w) { gtk_object_ref(GTK_OBJECT(w)); gtk_object_sink(GTK_OBJECT(w)); } if (widget->widget) g_object_unref(widget->widget); widget->widget = w; /* when/if canvas items have a visibility flag, * we'd force the widget to match it here */ if (widget->widget) gtk_widget_show(widget->widget); hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(widget)); } } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } }
static void set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { ExampleEchoChannel *self = EXAMPLE_ECHO_CHANNEL (object); switch (property_id) { case PROP_OBJECT_PATH: g_free (self->priv->object_path); self->priv->object_path = g_value_dup_string (value); break; case PROP_HANDLE: /* we don't ref it here because we don't necessarily have access to the * contact repo yet - instead we ref it in the constructor. */ self->priv->handle = g_value_get_uint (value); break; case PROP_INITIATOR_HANDLE: /* likewise */ self->priv->initiator = g_value_get_uint (value); break; case PROP_HANDLE_TYPE: case PROP_CHANNEL_TYPE: /* these properties are writable in the interface, but not actually * meaningfully changable on this channel, so we do nothing */ break; case PROP_CONNECTION: self->priv->conn = g_value_get_object (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void spectrum_profile_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { switch (prop_id) { case PROP_SPECTRUM: spectrum_profile_set_spectrum(HOS_SPECTRUM_PROFILE(object), HOS_SPECTRUM(g_value_get_object(value))); break; case PROP_ORIENTATION: spectrum_profile_set_orientation(HOS_SPECTRUM_PROFILE(object), g_value_get_enum(value)); break; case PROP_VPOLICY: spectrum_profile_set_vpolicy(HOS_SPECTRUM_PROFILE(object), g_value_get_enum(value)); break; case PROP_VOFFSET: spectrum_profile_set_voffset(HOS_SPECTRUM_PROFILE(object), g_value_get_double(value)); break; case PROP_VRANGE: spectrum_profile_set_vrange(HOS_SPECTRUM_PROFILE(object), g_value_get_double(value)); break; case PROP_VZOOM: spectrum_profile_set_vzoom(HOS_SPECTRUM_PROFILE(object), g_value_get_double(value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
void ags_indicator_set_property(GObject *gobject, guint prop_id, const GValue *value, GParamSpec *param_spec) { AgsIndicator *indicator; indicator = AGS_INDICATOR(gobject); switch(prop_id){ case PROP_ADJUSTMENT: { GtkAdjustment *adjustment; adjustment = (GtkAdjustment *) g_value_get_object(value); if(indicator->adjustment == adjustment) return; if(indicator->adjustment != NULL){ g_object_unref(G_OBJECT(indicator->adjustment)); } if(adjustment != NULL){ g_object_ref(G_OBJECT(adjustment)); } indicator->adjustment = (GObject *) adjustment; } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec); break; } }
static gboolean same_clock_rate_fold (const GValue * item, GValue * ret, gpointer user_data) { GstPad *mypad = user_data; GstPad *pad = g_value_get_object (item); GstCaps *peercaps; GstCaps *accumcaps; if (pad == mypad) return TRUE; accumcaps = g_value_get_boxed (ret); peercaps = gst_pad_peer_query_caps (pad, accumcaps); if (!peercaps) { g_warning ("no peercaps"); return TRUE; } peercaps = gst_caps_make_writable (peercaps); clear_caps (peercaps, TRUE); g_value_take_boxed (ret, peercaps); return !gst_caps_is_empty (peercaps); }
static void gkd_secret_objects_set_property (GObject *obj, guint prop_id, const GValue *value, GParamSpec *pspec) { GkdSecretObjects *self = GKD_SECRET_OBJECTS (obj); switch (prop_id) { case PROP_PKCS11_SLOT: g_return_if_fail (!self->pkcs11_slot); self->pkcs11_slot = g_value_dup_object (value); g_return_if_fail (self->pkcs11_slot); break; case PROP_SERVICE: g_return_if_fail (!self->service); self->service = g_value_get_object (value); g_return_if_fail (self->service); g_object_add_weak_pointer (G_OBJECT (self->service), (gpointer*)&(self->service)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec); break; } }
gboolean ephy_signal_accumulator_object (GSignalInvocationHint *ihint, GValue *return_accu, const GValue *handler_return, gpointer accu_data) { GObject *object; GetTypeFunc get_type = (GetTypeFunc) accu_data; object = g_value_get_object (handler_return); if (object != NULL && G_TYPE_CHECK_INSTANCE_TYPE (object, get_type ())) { g_value_set_object (return_accu, object); return FALSE; } else if (object != NULL) { g_return_val_if_reached (TRUE); } return TRUE; }
static void gdict_source_dialog_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GdictSourceDialog *dialog = GDICT_SOURCE_DIALOG (object); switch (prop_id) { case PROP_SOURCE_LOADER: set_source_loader (dialog, g_value_get_object (value)); break; case PROP_SOURCE_NAME: g_free (dialog->source_name); dialog->source_name = g_strdup (g_value_get_string (value)); break; case PROP_ACTION: dialog->action = (GdictSourceDialogAction) g_value_get_int (value); break; default: break; } }
static void rejilla_status_dialog_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { RejillaStatusDialogPrivate *priv; g_return_if_fail (REJILLA_IS_STATUS_DIALOG (object)); priv = REJILLA_STATUS_DIALOG_PRIVATE (object); switch (prop_id) { case PROP_SESSION: /* Readable and only writable at creation time */ priv->session = REJILLA_BURN_SESSION (g_value_get_object (value)); g_object_ref (priv->session); rejilla_status_dialog_wait_for_session (REJILLA_STATUS_DIALOG (object)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gtk_bubble_window_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { switch (prop_id) { case PROP_RELATIVE_TO: _gtk_bubble_window_set_relative_to (GTK_BUBBLE_WINDOW (object), g_value_get_object (value)); break; case PROP_POINTING_TO: _gtk_bubble_window_set_pointing_to (GTK_BUBBLE_WINDOW (object), g_value_get_boxed (value)); break; case PROP_POSITION: _gtk_bubble_window_set_position (GTK_BUBBLE_WINDOW (object), g_value_get_enum (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } }
/** * egg_view_resolve: * @path: a string containing the path * * Resolves an #EggView for a given path. * * Return value: an #EggView or %NULL. */ EggView* egg_view_resolve (const gchar *path) { EggView *view; GList *list; GValue return_value = {0,}, params = {0,}; g_return_val_if_fail (path != NULL, NULL); for (list = resolvers; list; list = list->next) { g_value_init (&return_value, EGG_TYPE_VIEW); g_value_init (¶ms, G_TYPE_STRING); g_value_set_string (¶ms, path); g_closure_invoke (list->data, &return_value, 1, ¶ms, NULL); view = g_value_get_object (&return_value); g_value_unset (&return_value); g_value_unset (¶ms); if (view) break; } return view; }
static void cheese_flash_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { CheeseFlashPrivate *priv = CHEESE_FLASH_GET_PRIVATE (object); switch (prop_id) { case PROP_PARENT: { GObject *object; object = g_value_get_object (value); if (object != NULL) priv->parent = g_object_ref (object); else priv->parent = NULL; } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void athena_navigation_state_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { AthenaNavigationState *self = ATHENA_NAVIGATION_STATE (object); switch (property_id) { case PROP_SLAVE: self->priv->slave = g_value_dup_object (value); athena_navigation_state_add_group (self, g_value_get_object (value)); break; case PROP_MASTER: self->priv->master = g_value_dup_object (value); break; case PROP_ACTION_NAMES: self->priv->action_names = g_value_dup_boxed (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void ide_file_settings_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { IdeFileSettings *self = IDE_FILE_SETTINGS (object); switch (prop_id) { case PROP_FILE: ide_file_settings_set_file (self, g_value_get_object (value)); break; case PROP_LANGUAGE: ide_file_settings_set_language (self, g_value_get_string (value)); break; #define IDE_FILE_SETTINGS_PROPERTY(NAME, name, _2, _3, _4, _5, _6, value_type) \ case PROP_##NAME: \ ide_file_settings_set_##name (self, g_value_get_##value_type (value)); \ break; # include "ide-file-settings.defs" #undef IDE_FILE_SETTINGS_PROPERTY #define IDE_FILE_SETTINGS_PROPERTY(NAME, name, _1, _2, _pname, _3, _4, _5) \ case PROP_##NAME##_SET: \ ide_file_settings_set_##name##_set (self, g_value_get_boolean (value)); \ break; # include "ide-file-settings.defs" #undef IDE_FILE_SETTINGS_PROPERTY default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } }
static void nemo_navigation_action_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { NemoNavigationAction *nav; nav = NEMO_NAVIGATION_ACTION (object); switch (prop_id) { case PROP_ARROW_TOOLTIP: g_free (nav->priv->arrow_tooltip); nav->priv->arrow_tooltip = g_value_dup_string (value); break; case PROP_DIRECTION: nav->priv->direction = g_value_get_int (value); break; case PROP_WINDOW: nav->priv->window = g_value_get_object (value); break; } }
static void add_channel_id(gpointer hkey, gpointer hvalue, gpointer user_data) { GValue *value = (GValue*)hvalue; GSList **list = (GSList**)user_data; const gchar *strkey; gchar *end; gint id; strkey = g_quark_to_string(GPOINTER_TO_UINT(hkey)); if (!strkey) return; if (strkey[0] != '/' || (id = strtol(strkey + 1, &end, 10)) < 0 || !gwy_strequal(end, "/data") || !G_VALUE_HOLDS_OBJECT(value) || !GWY_IS_DATA_FIELD(g_value_get_object(value))) return; *list = g_slist_prepend(*list, GINT_TO_POINTER(id)); }
static void owr_gst_audio_renderer_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { OwrGstAudioRendererPrivate *priv; GstElement *sink; g_return_if_fail(object); priv = OWR_GST_AUDIO_RENDERER_GET_PRIVATE(object); switch (property_id) { case PROP_SINK: sink = g_value_get_object(value); if (!GST_IS_ELEMENT(sink)) break; if (priv->sink) gst_object_unref(priv->sink); priv->sink = sink; gst_object_ref_sink(sink); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); break; } }
/** * This is called by uridecodebin (running inside playbin), after it has found * candidate factories to continue decoding the stream. We apply the whitelist * here, allowing only demuxers and decoders that output the formats we want to * support. */ GValueArray* GStreamerReader::AutoplugSortCb(GstElement* aElement, GstPad* aPad, GstCaps* aCaps, GValueArray* aFactories) { if (!aFactories->n_values) { return nullptr; } /* aFactories[0] is the element factory that is going to be used to * create the next element needed to demux or decode the stream. */ GstElementFactory *factory = (GstElementFactory*) g_value_get_object(g_value_array_get_nth(aFactories, 0)); if (!ShouldAutoplugFactory(factory, aCaps)) { /* We don't support this factory. Return an empty array to signal that we * don't want to continue decoding this (sub)stream. */ return g_value_array_new(0); } /* nullptr means that we're ok with the candidates and don't need to apply any * sorting/filtering. */ return nullptr; }
static void awn_throbber_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { AwnThrobberPrivate *priv; g_return_if_fail (AWN_IS_THROBBER (object)); priv = AWN_THROBBER (object)->priv; switch (prop_id) { case PROP_CLIENT: priv->client = g_value_get_object (value); break; case PROP_FILL_COLOR: if (priv->fill_color) { g_object_unref (priv->fill_color); } priv->fill_color = g_value_dup_object (value); gtk_widget_queue_draw (GTK_WIDGET (object)); break; case PROP_OUTLINE_COLOR: if (priv->outline_color) { g_object_unref (priv->outline_color); } priv->outline_color = g_value_dup_object (value); gtk_widget_queue_draw (GTK_WIDGET (object)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } }
static void gimp_ui_manager_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GimpUIManager *manager = GIMP_UI_MANAGER (object); switch (prop_id) { case PROP_NAME: g_free (manager->name); manager->name = g_value_dup_string (value); break; case PROP_GIMP: manager->gimp = g_value_get_object (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
JNIEXPORT jlong JNICALL Java_org_gnome_glib_GValue_g_1value_1get_1object ( JNIEnv* env, jclass cls, jlong _value ) { GValue* value; GObject* object; // translate value value = (GValue*) _value; if (!G_VALUE_HOLDS_OBJECT(value)) { bindings_java_throw(env, "You've asked for the GObject within a GValue, but it's not a G_TYPE_OBJECT!"); return 0L; } // call function object = g_value_get_object(value); // and return return (jlong) object; }
wxBitmap wxBitmapComboBox::GetItemBitmap(unsigned int n) const { wxBitmap bitmap; GtkComboBox* combobox = GTK_COMBO_BOX( m_widget ); GtkTreeModel *model = gtk_combo_box_get_model( combobox ); GtkTreeIter iter; if (gtk_tree_model_iter_nth_child (model, &iter, NULL, n)) { GValue value = { 0, }; gtk_tree_model_get_value( model, &iter, m_bitmapCellIndex, &value ); GdkPixbuf* pixbuf = (GdkPixbuf*) g_value_get_object( &value ); if ( pixbuf ) { g_object_ref( pixbuf ); bitmap = wxBitmap(pixbuf); } g_value_unset( &value ); } return bitmap; }
JNIEXPORT jlong JNICALL Java_org_gnome_glib_GValue_g_1value_1get_1pixbuf ( JNIEnv* env, jclass cls, jlong _value ) { GValue* value; GdkPixbuf* pixbuf; // translate value value = (GValue*) _value; if (G_VALUE_TYPE(value) != GDK_TYPE_PIXBUF) { bindings_java_throw(env, "You've asked for the GdkPixbuf within a GValue, but it's not a GDK_TYPE_PIXBUF!"); return 0L; } // call function pixbuf = g_value_get_object(value); // and return return (jlong) pixbuf; }