Пример #1
0
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;
  }
}
Пример #4
0
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;
}
Пример #5
0
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;
  }
}
Пример #6
0
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);
}
Пример #7
0
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;
}
Пример #8
0
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;
    }
}
Пример #9
0
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;
    }
}
Пример #10
0
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;
    }
}
Пример #11
0
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);
}
Пример #13
0
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;
}
Пример #15
0
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;
	}
}
Пример #17
0
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);
    }
}
Пример #18
0
/**
 * 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 (&params, G_TYPE_STRING);
		g_value_set_string (&params, path);
		g_closure_invoke (list->data, &return_value, 1, &params, NULL);
		view = g_value_get_object (&return_value);
		g_value_unset (&return_value);
		g_value_unset (&params);
		if (view)
			break;
	}

	return view;
}
Пример #19
0
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;
  }
}
Пример #20
0
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;
    }
}
Пример #21
0
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);
    }
}
Пример #22
0
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;
	}
}
Пример #23
0
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));
}
Пример #24
0
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;
    }
}
Пример #25
0
/**
 * 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);
    }
}
Пример #27
0
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;
    }
}
Пример #28
0
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;
}
Пример #29
0
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;
}
Пример #30
0
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;
}