gboolean ibus_message_iter_get (IBusMessageIter *iter, GType type, gpointer value) { g_assert (iter != NULL); g_assert (type != G_TYPE_INVALID); g_assert (value != NULL); switch (type) { case G_TYPE_CHAR: { char v; if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_BYTE) return FALSE; dbus_message_iter_get_basic (iter, &v); *(gchar *) value = (gchar) v; return TRUE; } case G_TYPE_INT: { dbus_int32_t v; if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_INT32) return FALSE; dbus_message_iter_get_basic (iter, &v); *(gint *) value = (gint) v; return TRUE; } case G_TYPE_UINT: { dbus_uint32_t v; if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_UINT32) return FALSE; dbus_message_iter_get_basic (iter, &v); *(guint *) value = (guint) v; return TRUE; } case G_TYPE_LONG: { dbus_int64_t v; if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_INT32) return FALSE; dbus_message_iter_get_basic (iter, &v); *(glong *) value = (glong) v; return TRUE; } case G_TYPE_ULONG: { dbus_uint64_t v; if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_UINT32) return FALSE; dbus_message_iter_get_basic (iter, &v); *(gulong *) value = (gulong) v; return TRUE; } case G_TYPE_BOOLEAN: { dbus_bool_t v; if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_BOOLEAN) return FALSE; dbus_message_iter_get_basic (iter, &v); *(gboolean *) value = (gboolean) v; return TRUE; } case G_TYPE_STRING: { gchar *v; if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_STRING) return FALSE; dbus_message_iter_get_basic (iter, &v); *(gchar **) value = (gchar *) v; return TRUE; } case G_TYPE_INT64: { dbus_int64_t v; if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_INT64) return FALSE; dbus_message_iter_get_basic (iter, &v); *(gint64 *) value = (gint64) v; return TRUE; } case G_TYPE_UINT64: { dbus_uint64_t v; if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_UINT64) return FALSE; dbus_message_iter_get_basic (iter, &v); *(guint64 *) value = (guint64) v; return TRUE; } case G_TYPE_FLOAT: { double v; if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_DOUBLE) return FALSE; dbus_message_iter_get_basic (iter, &v); *(gfloat *) value = (gfloat) v; return TRUE; } case G_TYPE_DOUBLE: { double v; if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_DOUBLE) return FALSE; dbus_message_iter_get_basic (iter, &v); *(gdouble *) value = (gdouble) v; return TRUE; } default: if (type == G_TYPE_VALUE) { _from_dbus_value (iter, (GValue *) value); return TRUE; } if (type == IBUS_TYPE_OBJECT_PATH) { gchar *v; if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_OBJECT_PATH) return FALSE; dbus_message_iter_get_basic (iter, &v); *(gchar **) value = (gchar *) v; return TRUE; } if (g_type_is_a (type, IBUS_TYPE_SERIALIZABLE)) { IBusSerializable *v; v = ibus_serializable_deserialize (iter); if (v == NULL) return FALSE; if (!g_type_is_a (G_OBJECT_TYPE (v), type)) { g_object_unref (v); return FALSE; } *(gpointer *) value = v; return TRUE; } } return FALSE; }
static gboolean test_type_is_a (GType type, gpointer is_a_type) { return g_type_is_a (type, (GType) GPOINTER_TO_UINT (is_a_type)); }
static ClutterActor * create_property_editor (GObject *object, GParamSpec *pspec) { ClutterActor *box, *label, *value; gint i; /* skip properties that are not writable */ if (!(pspec->flags & G_PARAM_WRITABLE)) return NULL; /* skip other properties */ for (i = 0; i < G_N_ELEMENTS (skip_properties); i++) { if (g_str_equal (pspec->name, skip_properties[i])) return NULL; } box = mx_box_layout_new (); label = mx_label_new_with_text (pspec->name); clutter_actor_set_width (label, 150); clutter_actor_add_child (box, label); if (pspec->value_type == G_TYPE_BOOLEAN) { value = mx_toggle_new (); g_object_bind_property (object, pspec->name, value, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); } else if (pspec->value_type == G_TYPE_STRING) { value = mx_entry_new (); g_object_bind_property (object, pspec->name, value, "text", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); } else if (pspec->value_type == G_TYPE_INT || pspec->value_type == G_TYPE_UINT || pspec->value_type == G_TYPE_FLOAT || pspec->value_type == G_TYPE_DOUBLE) { value = mx_entry_new (); g_object_bind_property_full (object, pspec->name, value, "text", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE, num_to_string, string_to_num, NULL, NULL); } else if (g_type_is_a (pspec->value_type, G_TYPE_ENUM)) { GEnumValue *evalue; GEnumClass *eclass; gint init = 0; value = mx_combo_box_new (); clutter_actor_set_width (value, 100); eclass = g_type_class_ref (pspec->value_type); while ((evalue = g_enum_get_value (eclass, init))) { mx_combo_box_append_text (MX_COMBO_BOX (value), evalue->value_nick); init++; } g_type_class_unref (eclass); g_object_bind_property (object, pspec->name, value, "index", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); } else value = NULL; if (value) { clutter_actor_add_child (box, value); return box; } else return NULL; }
/* * gda_ldap_attr_value_to_g_value: * Converts a #BerValue to a new #GValue * * Returns: a new #GValue, or %NULL on error */ GValue * gda_ldap_attr_value_to_g_value (LdapConnectionData *cdata, GType type, BerValue *bv) { GValue *value = NULL; if ((type == G_TYPE_DATE_TIME) || (type == G_TYPE_DATE)) { /* see ftp://ftp.rfc-editor.org/in-notes/rfc4517.txt, * section 3.3.13: Generalized Time */ GTimeVal tv; gboolean conv; if (! (conv = g_time_val_from_iso8601 (bv->bv_val, &tv))) { /* Add the 'T' char */ gchar *tmp, *str; gint i, len; str = bv->bv_val; len = strlen (str); if (len > 8) { tmp = g_new (gchar, len + 2); for (i = 0; i < 8; i++) tmp[i] = str[i]; tmp [8] = 'T'; for (i = 9; str[i]; i++) tmp[i] = str[i-1]; tmp[i] = 0; conv = g_time_val_from_iso8601 (tmp, &tv); g_free (tmp); } } if (conv) { struct tm *ptm; #ifdef HAVE_LOCALTIME_R struct tm tmpstm; ptm = localtime_r (&(tv.tv_sec), &tmpstm); #elif HAVE_LOCALTIME_S struct tm tmpstm; if (localtime_s (&tmpstm, &(tv.tv_sec)) == 0) ptm = &tmpstm; else ptm = NULL; #else ptm = localtime (&(tv.tv_sec)); #endif if (!ptm) return NULL; if (g_type_is_a (type, G_TYPE_DATE_TIME)) { GTimeZone *tz = g_time_zone_new ("Z"); // UTC GDateTime *ts = g_date_time_new (tz, ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec); value = gda_value_new (G_TYPE_DATE_TIME); g_value_set_boxed (value, ts); g_date_time_unref (ts); } else { GDate *date; date = g_date_new (); g_date_set_time_val (date, &tv); value = gda_value_new (type); g_value_take_boxed (value, date); } } } else if (type == GDA_TYPE_BINARY) { guchar *data; data = g_new (guchar, bv->bv_len); memcpy (data, bv->bv_val, sizeof (guchar) * bv->bv_len); value = gda_value_new_binary (data, bv->bv_len); } else value = gda_value_new_from_string (bv->bv_val, type); return value; }
static void tool_manager_tool_changed (GimpContext *user_context, GimpToolInfo *tool_info, GimpToolManager *tool_manager) { GimpTool *new_tool = NULL; if (! tool_info) return; /* FIXME: gimp_busy HACK */ if (user_context->gimp->busy) { /* there may be contexts waiting for the user_context's "tool-changed" * signal, so stop emitting it. */ g_signal_stop_emission_by_name (user_context, "tool-changed"); if (G_TYPE_FROM_INSTANCE (tool_manager->active_tool) != tool_info->tool_type) { g_signal_handlers_block_by_func (user_context, tool_manager_tool_changed, tool_manager); /* explicitly set the current tool */ gimp_context_set_tool (user_context, tool_manager->active_tool->tool_info); g_signal_handlers_unblock_by_func (user_context, tool_manager_tool_changed, tool_manager); } return; } if (g_type_is_a (tool_info->tool_type, GIMP_TYPE_TOOL)) { new_tool = g_object_new (tool_info->tool_type, "tool-info", tool_info, NULL); } else { g_warning ("%s: tool_info->tool_type is no GimpTool subclass", G_STRFUNC); return; } /* disconnect the old tool's context */ if (tool_manager->active_tool && tool_manager->active_tool->tool_info) { tool_manager_disconnect_options (user_context, tool_manager->active_tool->tool_info); } /* connect the new tool's context */ tool_manager_connect_options (user_context, tool_info); tool_manager_select_tool (user_context->gimp, new_tool); g_object_unref (new_tool); }
/** * ags_recall_container_find: * @recall_container: the #AgsRecallContainer * @type: recall type * @find_flags: search mask * @recall_id: an #AgsRecallID * * Finds #AgsRecall for appropriate search criteria. * * Returns: the matching recalls * * Since: 0.4 */ GList* ags_recall_container_find(GList *recall_container, GType type, guint find_flags, AgsRecallID *recall_id) { AgsRecallContainer *current; AgsRecall *recall; guint mode; if(g_type_is_a(type, AGS_TYPE_RECALL_AUDIO)){ mode = 0; }else if(g_type_is_a(type, AGS_TYPE_RECALL_AUDIO_RUN)){ mode = 1; }else if(g_type_is_a(type, AGS_TYPE_RECALL_CHANNEL)){ mode = 2; }else if(g_type_is_a(type, AGS_TYPE_RECALL_CHANNEL_RUN)){ mode = 3; }else{ g_message("ags_recall_container_find: invalid type\n\0"); return(NULL); } while(recall_container != NULL){ current = AGS_RECALL_CONTAINER(recall_container->data); if(mode == 0){ recall = ags_recall_container_get_recall_audio(current); }else if(mode == 1){ GList *list; list = ags_recall_container_get_recall_audio_run(current); if(list == NULL) recall = NULL; else recall = AGS_RECALL(list->data); }else if(mode == 2){ GList *list; list = ags_recall_container_get_recall_channel(current); if(list == NULL) recall = NULL; else recall = AGS_RECALL(list->data); }else if(mode == 3){ GList *list; list = ags_recall_container_get_recall_channel_run(current); if(list == NULL) recall = NULL; else recall = AGS_RECALL(list->data); } if(recall != NULL){ if(((AGS_RECALL_CONTAINER_FIND_TYPE & find_flags) == 0 || G_OBJECT_TYPE(recall) == type) && ((AGS_RECALL_CONTAINER_FIND_TEMPLATE & find_flags) == 0 || (AGS_RECALL_TEMPLATE & (recall->flags)) != 0) && ((AGS_RECALL_CONTAINER_FIND_RECALL_ID & find_flags) == 0 || (recall->recall_id != NULL && recall->recall_id == recall_id))){ break; } } recall_container = recall_container->next; } return(recall_container); }
GtkWidget * gimp_prop_gui_new (GObject *config, GType owner_type, GimpContext *context, GimpCreatePickerFunc create_picker_func, gpointer picker_creator) { GtkWidget *gui = NULL; GParamSpec **param_specs; guint n_param_specs; gint i, j; g_return_val_if_fail (G_IS_OBJECT (config), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); param_specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (config), &n_param_specs); for (i = 0, j = 0; i < n_param_specs; i++) { GParamSpec *pspec = param_specs[i]; /* ignore properties of parent classes of owner_type */ if (! g_type_is_a (pspec->owner_type, owner_type)) continue; if (HAS_KEY (pspec, "role", "output-extent")) continue; param_specs[j] = param_specs[i]; j++; } n_param_specs = j; if (n_param_specs > 0) { const gchar *config_type_name = G_OBJECT_TYPE_NAME (config); for (i = 0; i < G_N_ELEMENTS (gui_new_funcs); i++) { if (! gui_new_funcs[i].config_type || ! strcmp (gui_new_funcs[i].config_type, config_type_name)) { g_printerr ("GUI new func match: %s\n", gui_new_funcs[i].config_type ? gui_new_funcs[i].config_type : "generic fallback"); gui = gui_new_funcs[i].gui_new_func (config, param_specs, n_param_specs, context, create_picker_func, picker_creator); break; } } } else { gui = gtk_label_new (_("This operation has no editable properties")); gimp_label_set_attributes (GTK_LABEL (gui), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_misc_set_padding (GTK_MISC (gui), 0, 4); } g_free (param_specs); return gui; }
PpgAnimation* g_object_animatev (gpointer object, PpgAnimationMode mode, guint duration_msec, guint frame_rate, const gchar *first_property, va_list args) { PpgAnimation *animation; GObjectClass *klass; GObjectClass *pklass; const gchar *name; GParamSpec *pspec; GtkWidget *parent; GValue value = { 0 }; gchar *error = NULL; GType type; GType ptype; g_return_val_if_fail(first_property != NULL, NULL); g_return_val_if_fail(mode < PPG_ANIMATION_LAST, NULL); name = first_property; type = G_TYPE_FROM_INSTANCE(object); klass = G_OBJECT_GET_CLASS(object); animation = g_object_new(PPG_TYPE_ANIMATION, "duration", duration_msec, "frame-rate", frame_rate ? frame_rate : 60, "mode", mode, "target", object, NULL); do { /* * First check for the property on the object. If that does not exist * then check if the object has a parent and look at its child * properties (if its a GtkWidget). */ if (!(pspec = g_object_class_find_property(klass, name))) { if (!g_type_is_a(type, GTK_TYPE_WIDGET)) { g_critical("Failed to find property %s in %s", name, g_type_name(type)); goto failure; } if (!(parent = gtk_widget_get_parent(object))) { g_critical("Failed to find property %s in %s", name, g_type_name(type)); goto failure; } pklass = G_OBJECT_GET_CLASS(parent); ptype = G_TYPE_FROM_INSTANCE(parent); if (!(pspec = gtk_container_class_find_child_property(pklass, name))) { g_critical("Failed to find property %s in %s or parent %s", name, g_type_name(type), g_type_name(ptype)); goto failure; } } g_value_init(&value, pspec->value_type); G_VALUE_COLLECT(&value, args, 0, &error); if (error != NULL) { g_critical("Failed to retrieve va_list value: %s", error); g_free(error); goto failure; } ppg_animation_add_property(animation, pspec, &value); g_value_unset(&value); } while ((name = va_arg(args, const gchar *))); ppg_animation_start(animation); return animation; failure: g_object_ref_sink(animation); g_object_unref(animation); return NULL; }
/** * ges_project_save: * @project: A #GESProject to save * @timeline: The #GESTimeline to save, it must have been extracted from @project * @uri: The uri where to save @project and @timeline * @formatter_asset: (allow-none): The formatter asset to use or %NULL. If %NULL, * will try to save in the same format as the one from which the timeline as been loaded * or default to the formatter with highest rank * @overwrite: %TRUE to overwrite file if it exists * @error: (out) (allow-none): An error to be set in case something wrong happens or %NULL * * Save the timeline of @project to @uri. You should make sure that @timeline * is one of the timelines that have been extracted from @project * (using ges_asset_extract (@project);) * * Returns: %TRUE if the project could be save, %FALSE otherwize */ gboolean ges_project_save (GESProject * project, GESTimeline * timeline, const gchar * uri, GESAsset * formatter_asset, gboolean overwrite, GError ** error) { GESAsset *tl_asset; gboolean ret = TRUE; GESFormatter *formatter = NULL; g_return_val_if_fail (GES_IS_PROJECT (project), FALSE); g_return_val_if_fail (formatter_asset == NULL || g_type_is_a (ges_asset_get_extractable_type (formatter_asset), GES_TYPE_FORMATTER), FALSE); g_return_val_if_fail ((error == NULL || *error == NULL), FALSE); tl_asset = ges_extractable_get_asset (GES_EXTRACTABLE (timeline)); if (tl_asset == NULL && project->priv->uri == NULL) { GESAsset *asset = ges_asset_cache_lookup (GES_TYPE_PROJECT, uri); if (asset) { GST_WARNING_OBJECT (project, "Trying to save project to %s but we already" "have %" GST_PTR_FORMAT " for that uri, can not save", uri, asset); goto out; } GST_DEBUG_OBJECT (project, "Timeline %" GST_PTR_FORMAT " has no asset" " we have no uri set, so setting ourself as asset", timeline); ges_extractable_set_asset (GES_EXTRACTABLE (timeline), GES_ASSET (project)); } else if (tl_asset != GES_ASSET (project)) { GST_WARNING_OBJECT (project, "Timeline %" GST_PTR_FORMAT " not created by this project can not save", timeline); ret = FALSE; goto out; } if (formatter_asset == NULL) formatter_asset = gst_object_ref (ges_formatter_get_default ()); formatter = GES_FORMATTER (ges_asset_extract (formatter_asset, error)); if (formatter == NULL) { GST_WARNING_OBJECT (project, "Could not create the formatter %p %s: %s", formatter_asset, ges_asset_get_id (formatter_asset), (error && *error) ? (*error)->message : "Unknown Error"); ret = FALSE; goto out; } ges_project_add_formatter (project, formatter); ret = ges_formatter_save_to_uri (formatter, timeline, uri, overwrite, error); if (ret && project->priv->uri == NULL) ges_project_set_uri (project, uri); out: if (formatter_asset) gst_object_unref (formatter_asset); ges_project_remove_formatter (project, formatter); return ret; }
/* Check and score this selector against stylable node. * A score below 0 means that they did not match. */ static gint _xfdashboard_css_selector_score_matching_node(XfdashboardCssSelectorRule *inRule, XfdashboardStylable *inStylable) { gint score; gint a, b, c; const gchar *classes; const gchar *pseudoClasses; const gchar *id; g_return_val_if_fail(inRule, -1); g_return_val_if_fail(XFDASHBOARD_IS_STYLABLE(inStylable), -1); /* For information about how the scoring is done, see documentation * "Cascading Style Sheets, level 1" of W3C, section "3.2 Cascading order" * URL: http://www.w3.org/TR/2008/REC-CSS1-20080411/#cascading-order * * 1. Find all declarations that apply to the element/property in question. * Declarations apply if the selector matches the element in question. * If no declarations apply, the inherited value is used. If there is * no inherited value (this is the case for the 'HTML' element and * for properties that do not inherit), the initial value is used. * 2. Sort the declarations by explicit weight: declarations marked * '!important' carry more weight than unmarked (normal) declarations. * 3. Sort by origin: the author's style sheets override the reader's * style sheet which override the UA's default values. An imported * style sheet has the same origin as the style sheet from which it * is imported. * 4. Sort by specificity of selector: more specific selectors will * override more general ones. To find the specificity, count the * number of ID attributes in the selector (a), the number of CLASS * attributes in the selector (b), and the number of tag names in * the selector (c). Concatenating the three numbers (in a number * system with a large base) gives the specificity. * Pseudo-elements and pseudo-classes are counted as normal elements * and classes, respectively. * 5. Sort by order specified: if two rules have the same weight, the * latter specified wins. Rules in imported style sheets are considered * to be before any rules in the style sheet itself. * * NOTE: Keyword '!important' is not supported. */ a=b=c=0; /* Get properties for given stylable */ id=xfdashboard_stylable_get_name(XFDASHBOARD_STYLABLE(inStylable)); classes=xfdashboard_stylable_get_classes(XFDASHBOARD_STYLABLE(inStylable)); pseudoClasses=xfdashboard_stylable_get_pseudo_classes(XFDASHBOARD_STYLABLE(inStylable)); /* Check and score type of selectors but ignore NULL or universal selectors */ if(inRule->type && inRule->type[0]!='*') { GType ruleTypeID; GType nodeTypeID; /* Get type of this rule */ ruleTypeID=g_type_from_name(inRule->type); if(!ruleTypeID) return(-1); /* Get type of other rule to check against and score it */ nodeTypeID=G_OBJECT_TYPE(inStylable); if(!nodeTypeID) return(-1); /* Check if type of this rule matches type of other rule */ if(!g_type_is_a(nodeTypeID, ruleTypeID)) return(-1); /* Determine depth difference between both types * which is the score of this test with a maximum of 99 */ c=g_type_depth(ruleTypeID)-g_type_depth(nodeTypeID); c=MAX(ABS(c), 99); } /* Check and score ID */ if(inRule->id) { /* If node has no ID return immediately */ if(!id || strcmp(inRule->id, id)) return(-1); /* Score ID */ a+=10; } /* Check and score classes */ if(inRule->classes) { gchar *needle; gint numberMatches; /* If node has no pseudo class return immediately */ if(!classes) return(-1); /* Check that each class from the selector's rule appears in the * list of classes from the node, i.e. the selector's rule class list * is a subset of the node's class list */ numberMatches=0; for(needle=inRule->classes; needle; needle=strchr(needle, '.')) { gint needleLength; gchar *nextNeedle; /* Move pointer of needle beyond class seperator '.' */ if(needle[0]=='.') needle++; /* Get length of needle */ nextNeedle=strchr(needle, '.'); if(nextNeedle) needleLength=nextNeedle-needle; else needleLength=strlen(needle); /* If pseudo-class from the selector does not appear in the * list of pseudo-classes from the node, then this is not a * match */ if(!_xfdashboard_css_selector_list_contains(needle, needleLength, classes, '.')) return(-1); numberMatches++; } /* Score matching class */ b=b+(10*numberMatches); } /* Check and score pseudo classes */ if(inRule->pseudoClasses) { gchar *needle; gint numberMatches; /* If node has no pseudo class return immediately */ if(!pseudoClasses) return(-1); /* Check that each pseudo-class from the selector appears in the * pseudo-classes from the node, i.e. the selector pseudo-class list * is a subset of the node's pseudo-class list */ numberMatches=0; for(needle=inRule->pseudoClasses; needle; needle=strchr(needle, ':')) { gint needleLength; gchar *nextNeedle; /* Move pointer of needle beyond pseudo-class seperator ':' */ if(needle[0]==':') needle++; /* Get length of needle */ nextNeedle=strchr(needle, ':'); if(nextNeedle) needleLength=nextNeedle-needle; else needleLength=strlen(needle); /* If pseudo-class from the selector does not appear in the * list of pseudo-classes from the node, then this is not a * match */ if(!_xfdashboard_css_selector_list_contains(needle, needleLength, pseudoClasses, ':')) return(-1); numberMatches++; } /* Score matching pseudo-class */ b=b+(10*numberMatches); } /* Check and score parent */ if(inRule->parentRule && inRule->parentRuleMode==XFDASHBOARD_CSS_SELECTOR_RULE_MODE_PARENT) { gint parentScore; XfdashboardStylable *parent; /* If node has no parent, no parent can match ;) so return immediately */ parent=xfdashboard_stylable_get_parent(inStylable); if(!parent || !XFDASHBOARD_IS_STYLABLE(parent)) return(-1); /* Check if there are matching parents. If not return immediately. */ parentScore=_xfdashboard_css_selector_score_matching_node(inRule->parentRule, parent); if(parentScore<0) return(-1); /* Score matching parents */ c+=parentScore; } /* Check and score ancestor */ if(inRule->parentRule && inRule->parentRuleMode==XFDASHBOARD_CSS_SELECTOR_RULE_MODE_ANCESTOR) { gint ancestorScore; XfdashboardStylable *ancestor; ancestor=inStylable; /* If node has no parents, no ancestor can match so return immediately */ do { ancestor=xfdashboard_stylable_get_parent(ancestor); } while(ancestor && !XFDASHBOARD_IS_STYLABLE(ancestor)); if(!ancestor || !XFDASHBOARD_IS_STYLABLE(ancestor)) return(-1); /* Iterate through ancestors and check and score them */ while(ancestor) { /* Get number of matches for ancestor and if at least one matches, * stop search and score */ ancestorScore=_xfdashboard_css_selector_score_matching_node(inRule->parentRule, ancestor); if(ancestorScore>=0) { c+=ancestorScore; break; } /* Get next ancestor to check but skip actors not implementing * the XfdashboardStylable interface */ do { ancestor=xfdashboard_stylable_get_parent(ancestor); } while(ancestor && !XFDASHBOARD_IS_STYLABLE(ancestor)); if(!ancestor || !XFDASHBOARD_IS_STYLABLE(ancestor)) return(-1); } } /* Calculate final score */ score=(a*10000)+(b*100)+c; return(score); }
gboolean gimp_container_tree_view_real_drop_possible (GimpContainerTreeView *tree_view, GimpDndType src_type, GimpViewable *src_viewable, GimpViewable *dest_viewable, GtkTreePath *drop_path, GtkTreeViewDropPosition drop_pos, GtkTreeViewDropPosition *return_drop_pos, GdkDragAction *return_drag_action) { GimpContainerView *view = GIMP_CONTAINER_VIEW (tree_view); GimpContainer *container = gimp_container_view_get_container (view); GimpContainer *src_container = NULL; GimpContainer *dest_container = NULL; gint src_index = -1; gint dest_index = -1; if (src_viewable) { GimpViewable *parent = gimp_viewable_get_parent (src_viewable); if (parent) src_container = gimp_viewable_get_children (parent); else if (gimp_container_have (container, GIMP_OBJECT (src_viewable))) src_container = container; if (src_container) src_index = gimp_container_get_child_index (src_container, GIMP_OBJECT (src_viewable)); } if (dest_viewable) { GimpViewable *parent; /* dropping on the lower third of a group item drops into that group */ if (drop_pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER && gimp_viewable_get_children (dest_viewable)) { parent = dest_viewable; } else { parent = gimp_viewable_get_parent (dest_viewable); } if (parent) dest_container = gimp_viewable_get_children (parent); else if (gimp_container_have (container, GIMP_OBJECT (dest_viewable))) dest_container = container; if (parent == dest_viewable) dest_index = 0; else dest_index = gimp_container_get_child_index (dest_container, GIMP_OBJECT (dest_viewable)); } if (src_viewable && g_type_is_a (G_TYPE_FROM_INSTANCE (src_viewable), gimp_container_get_children_type (container))) { if (src_viewable == dest_viewable) return FALSE; if (src_index == -1 || dest_index == -1) return FALSE; /* don't allow dropping a parent node onto one of its descendants */ if (gimp_viewable_is_ancestor (src_viewable, dest_viewable)) return FALSE; } if (src_container == dest_container) { if (drop_pos == GTK_TREE_VIEW_DROP_BEFORE) { if (dest_index == (src_index + 1)) return FALSE; } else if (drop_pos == GTK_TREE_VIEW_DROP_AFTER) { if (dest_index == (src_index - 1)) return FALSE; } } if (return_drop_pos) *return_drop_pos = drop_pos; if (return_drag_action) { if (src_viewable && g_type_is_a (G_TYPE_FROM_INSTANCE (src_viewable), gimp_container_get_children_type (container))) *return_drag_action = GDK_ACTION_MOVE; else *return_drag_action = GDK_ACTION_COPY; } return TRUE; }
/** * gst_element_register: * @plugin: (allow-none): #GstPlugin to register the element with, or NULL for * a static element (note that passing NULL only works in GStreamer 0.10.13 * and later) * @name: name of elements of this type * @rank: rank of element (higher rank means more importance when autoplugging) * @type: GType of element to register * * Create a new elementfactory capable of instantiating objects of the * @type and add the factory to @plugin. * * Returns: TRUE, if the registering succeeded, FALSE on error */ gboolean gst_element_register (GstPlugin * plugin, const gchar * name, guint rank, GType type) { GstPluginFeature *existing_feature; GstRegistry *registry; GstElementFactory *factory; GType *interfaces; guint n_interfaces, i; GstElementClass *klass; GList *item; g_return_val_if_fail (name != NULL, FALSE); g_return_val_if_fail (g_type_is_a (type, GST_TYPE_ELEMENT), FALSE); registry = gst_registry_get_default (); /* check if feature already exists, if it exists there is no need to update it * when the registry is getting updated, outdated plugins and all their * features are removed and readded. */ existing_feature = gst_registry_lookup_feature (registry, name); if (existing_feature) { GST_DEBUG_OBJECT (registry, "update existing feature %p (%s)", existing_feature, name); factory = GST_ELEMENT_FACTORY_CAST (existing_feature); factory->type = type; existing_feature->loaded = TRUE; g_type_set_qdata (type, _gst_elementclass_factory, factory); gst_object_unref (existing_feature); return TRUE; } factory = GST_ELEMENT_FACTORY_CAST (g_object_newv (GST_TYPE_ELEMENT_FACTORY, 0, NULL)); gst_plugin_feature_set_name (GST_PLUGIN_FEATURE_CAST (factory), name); GST_LOG_OBJECT (factory, "Created new elementfactory for type %s", g_type_name (type)); /* provide info needed during class structure setup */ g_type_set_qdata (type, _gst_elementclass_factory, factory); klass = GST_ELEMENT_CLASS (g_type_class_ref (type)); if ((klass->details.longname == NULL) || (klass->details.klass == NULL) || (klass->details.author == NULL)) goto detailserror; factory->type = type; __gst_element_details_copy (&factory->details, &klass->details); if (klass->meta_data) { factory->meta_data = gst_structure_copy ((GstStructure *) klass->meta_data); } else { factory->meta_data = NULL; } for (item = klass->padtemplates; item; item = item->next) { GstPadTemplate *templ = item->data; GstStaticPadTemplate *newt; gchar *caps_string = gst_caps_to_string (templ->caps); newt = g_slice_new (GstStaticPadTemplate); newt->name_template = g_intern_string (templ->name_template); newt->direction = templ->direction; newt->presence = templ->presence; newt->static_caps.caps.refcount = 0; newt->static_caps.string = g_intern_string (caps_string); factory->staticpadtemplates = g_list_append (factory->staticpadtemplates, newt); g_free (caps_string); } factory->numpadtemplates = klass->numpadtemplates; /* special stuff for URI handling */ if (g_type_is_a (type, GST_TYPE_URI_HANDLER)) { GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_type_interface_peek (klass, GST_TYPE_URI_HANDLER); if (!iface || (!iface->get_type && !iface->get_type_full) || (!iface->get_protocols && !iface->get_protocols_full)) goto urierror; if (iface->get_type) factory->uri_type = iface->get_type (); else if (iface->get_type_full) factory->uri_type = iface->get_type_full (factory->type); if (!GST_URI_TYPE_IS_VALID (factory->uri_type)) goto urierror; if (iface->get_protocols) factory->uri_protocols = g_strdupv (iface->get_protocols ()); else if (iface->get_protocols_full) factory->uri_protocols = iface->get_protocols_full (factory->type); if (!factory->uri_protocols) goto urierror; } interfaces = g_type_interfaces (type, &n_interfaces); for (i = 0; i < n_interfaces; i++) { __gst_element_factory_add_interface (factory, g_type_name (interfaces[i])); } g_free (interfaces); if (plugin && plugin->desc.name) { GST_PLUGIN_FEATURE_CAST (factory)->plugin_name = plugin->desc.name; GST_PLUGIN_FEATURE_CAST (factory)->plugin = plugin; g_object_add_weak_pointer ((GObject *) plugin, (gpointer *) & GST_PLUGIN_FEATURE_CAST (factory)->plugin); } else { GST_PLUGIN_FEATURE_CAST (factory)->plugin_name = "NULL"; GST_PLUGIN_FEATURE_CAST (factory)->plugin = NULL; } gst_plugin_feature_set_rank (GST_PLUGIN_FEATURE_CAST (factory), rank); GST_PLUGIN_FEATURE_CAST (factory)->loaded = TRUE; gst_registry_add_feature (registry, GST_PLUGIN_FEATURE_CAST (factory)); return TRUE; /* ERRORS */ urierror: { GST_WARNING_OBJECT (factory, "error with uri handler!"); gst_element_factory_cleanup (factory); return FALSE; } detailserror: { GST_WARNING_OBJECT (factory, "The GstElementDetails don't seem to have been set properly"); gst_element_factory_cleanup (factory); return FALSE; } }
/* Build target list of registered focusable actors for requested binding but also check * if this focus manager is a target. */ static GSList* _xfdashboard_focus_manager_get_targets_for_binding(XfdashboardFocusManager *self, const XfdashboardBinding *inBinding) { XfdashboardFocusManagerPrivate *priv; GList *focusablesIter; GList *focusablesStartPoint; XfdashboardFocusable *focusable; GType targetType; GSList *targets; gboolean mustBeFocusable; g_return_val_if_fail(XFDASHBOARD_IS_FOCUS_MANAGER(self), NULL); g_return_val_if_fail(XFDASHBOARD_IS_BINDING(inBinding), NULL); priv=self->priv; targets=NULL; mustBeFocusable=TRUE; /* Get type of target */ targetType=g_type_from_name(xfdashboard_binding_get_target(inBinding)); if(!targetType) { g_warning(_("Cannot build target list for unknown type %s"), xfdashboard_binding_get_target(inBinding)); return(NULL); } /* Determine if unfocusable targets should be included */ if(xfdashboard_binding_get_flags(inBinding) & XFDASHBOARD_BINDING_FLAGS_ALLOW_UNFOCUSABLE_TARGET) { mustBeFocusable=FALSE; } /* Check if class name of target at binding points to ourselve */ if(g_type_is_a(G_OBJECT_TYPE(self), targetType)) { targets=g_slist_append(targets, g_object_ref(self)); } /* Iterate through list of focusable actors to add each one * matching the target class name to the list of targets. * Begin with finding starting point of iteration. */ focusablesStartPoint=g_list_find(priv->registeredFocusables, priv->currentFocus); if(!focusablesStartPoint) focusablesStartPoint=priv->registeredFocusables; /* Iterate through list of registered focusable actors beginning at * found starting point of iteration (might be begin of list of registered actors) * and add each focusable actor matching target class name to target list. */ for(focusablesIter=focusablesStartPoint; focusablesIter; focusablesIter=g_list_next(focusablesIter)) { focusable=(XfdashboardFocusable*)focusablesIter->data; /* If focusable can be focused and matches target class name * then add it to target list. */ if((!mustBeFocusable || xfdashboard_focusable_can_focus(focusable)) && g_type_is_a(G_OBJECT_TYPE(focusable), targetType)) { targets=g_slist_append(targets, g_object_ref(focusable)); } } /* We have to continue search at the beginning of list of registered actors * up to the found starting point of iteration. Add each focusable actor matching * target class name to target list. */ for(focusablesIter=priv->registeredFocusables; focusablesIter!=focusablesStartPoint; focusablesIter=g_list_next(focusablesIter)) { focusable=(XfdashboardFocusable*)focusablesIter->data; /* If focusable can be focused and matches target class name * then add it to target list. */ if((!mustBeFocusable || xfdashboard_focusable_can_focus(focusable)) && g_type_is_a(G_OBJECT_TYPE(focusable), targetType)) { targets=g_slist_append(targets, g_object_ref(focusable)); } } /* Return list of targets found */ g_debug("Target list for action '%s' and target class '%s' has %d entries", xfdashboard_binding_get_action(inBinding), xfdashboard_binding_get_target(inBinding), g_slist_length(targets)); return(targets); }
static void __add_implicit_workspace_join (MidgardQuerySelect *self, GdaSqlOperation *operation) { g_return_if_fail (self != NULL); MidgardDBObjectClass *klass = MIDGARD_QUERY_EXECUTOR (self)->priv->storage->priv->klass; if (!g_type_is_a (G_OBJECT_CLASS_TYPE (klass), MIDGARD_TYPE_OBJECT)) return; MidgardConnection *mgd = MIDGARD_QUERY_EXECUTOR (self)->priv->mgd; /* Do not take worskpace into account if if it's disabled * or enabled and none set */ if (!MGD_CNC_USES_WORKSPACE (mgd)) return; if (!MGD_CNC_HAS_WORKSPACE (mgd)) return; gboolean bool_is_int = MIDGARD_QUERY_EXECUTOR (self)->priv->bool_is_int; guint ws_id = MGD_CNC_WORKSPACE_ID (mgd); MidgardQueryExecutor *executor = MIDGARD_QUERY_EXECUTOR (self); GdaSqlStatement *sql_stm = executor->priv->stmt; GdaSqlStatementSelect *select = (GdaSqlStatementSelect *) sql_stm->contents; GdaSqlSelectFrom *from = select->from; GdaSqlSelectJoin *join; const gchar *klass_table = MGD_DBCLASS_TABLENAME (klass); gchar *left_table = executor->priv->table_alias; //gchar *right_table = g_strdup_printf ("t%d", ++executor->priv->tableid); gchar *right_table = g_strdup ("midgard_ws_tmp_table"); join = gda_sql_select_join_new (GDA_SQL_ANY_PART (from)); join->type = GDA_SQL_SELECT_JOIN_INNER; GdaSqlExpr *expr = gda_sql_expr_new (GDA_SQL_ANY_PART (join)); expr->value = gda_value_new (G_TYPE_STRING); g_value_take_string (expr->value, g_strdup_printf ("%s.%s = %s.%s", left_table, MGD_WORKSPACE_ID_FIELD, right_table, MGD_WORKSPACE_ID_FIELD)); join->expr = expr; join->position = ++executor->priv->joinid; MidgardConfig *config = mgd->priv->config; const gchar *sql_part_bool_func_start = ""; const gchar *sql_part_bool_func_end = ""; const gchar *deleted_field = midgard_core_object_get_deleted_field (klass); GString *table = g_string_new ("(SELECT DISTINCT MAX"); if (config->priv->dbtype == MIDGARD_DB_TYPE_POSTGRES && deleted_field) { sql_part_bool_func_start = " bool_or("; sql_part_bool_func_end = ") AS metadata_deleted"; } g_string_append_printf (table, "(%s) AS %s, %s %s%s%s%s FROM %s WHERE %s IN (0,", MGD_WORKSPACE_ID_FIELD, MGD_WORKSPACE_ID_FIELD, MGD_WORKSPACE_OID_FIELD, deleted_field ? "," : "", sql_part_bool_func_start, deleted_field ? deleted_field : "", sql_part_bool_func_end, klass_table, MGD_WORKSPACE_ID_FIELD); const MidgardWorkspaceStorage *ws = midgard_connection_get_workspace (mgd); GSList *list = MIDGARD_WORKSPACE_STORAGE_GET_INTERFACE (ws)->priv->list_ids (mgd, MIDGARD_WORKSPACE_STORAGE (ws)); GSList *l = NULL; guint i = 0; guint id; for (l = list; l != NULL; l = l->next, i++) { GValue *id_val = (GValue *) l->data; if (G_VALUE_HOLDS_UINT (id_val)) id = g_value_get_uint (id_val); else id = (guint) g_value_get_int (id_val); g_string_append_printf (table, "%s%d", i > 0 ? "," : "", id); } if (!list) g_string_append (table, "0"); g_string_append (table, ") "); if (deleted_field) g_string_append_printf (table, "AND %s = %s ", deleted_field, __BOOL_VALUE (bool_is_int)); g_string_append_printf (table, "GROUP BY %s)", MGD_WORKSPACE_OID_FIELD); g_slist_free (list); gda_sql_select_from_take_new_join (from , join); GdaSqlSelectTarget *s_target = gda_sql_select_target_new (GDA_SQL_ANY_PART (from)); s_target->table_name = g_string_free (table, FALSE); s_target->as = right_table; gda_sql_select_from_take_new_target (from, s_target); /* MIDGARD_QUERY_EXECUTOR (self)->priv->include_deleted_targets = g_slist_append (MIDGARD_QUERY_EXECUTOR (self)->priv->include_deleted_targets, s_target); */ GdaSqlExpr *texpr = gda_sql_expr_new (GDA_SQL_ANY_PART (s_target)); GValue *tval = g_new0 (GValue, 1); g_value_init (tval, G_TYPE_STRING); g_value_set_string (tval, g_strdup (s_target->table_name)); texpr->value = tval; s_target->expr = texpr; /* Add workspace object id constraint */ GdaSqlExpr *ws_expr = gda_sql_expr_new (GDA_SQL_ANY_PART (operation)); ws_expr->value = gda_value_new (G_TYPE_STRING); g_value_take_string (ws_expr->value, g_strdup_printf ("%s.%s = %s.%s", left_table, MGD_WORKSPACE_OID_FIELD, right_table, MGD_WORKSPACE_OID_FIELD)); operation->operands = g_slist_append (operation->operands, ws_expr); }
IdeFileSettings * ide_file_settings_new (IdeObject *parent, GFile *file, const gchar *language) { IdeFileSettingsPrivate *priv; GIOExtensionPoint *extension_point; IdeFileSettings *ret; GList *list; g_return_val_if_fail (G_IS_FILE (file), NULL); g_return_val_if_fail (IDE_IS_OBJECT (parent), NULL); ret = g_object_new (IDE_TYPE_FILE_SETTINGS, "file", file, "language", language, NULL); priv = ide_file_settings_get_instance_private (ret); ide_object_append (parent, IDE_OBJECT (ret)); extension_point = g_io_extension_point_lookup (IDE_FILE_SETTINGS_EXTENSION_POINT); list = g_io_extension_point_get_extensions (extension_point); /* * Don't allow our unsettled count to hit zero until we are finished. */ priv->unsettled_count++; for (; list; list = list->next) { GIOExtension *extension = list->data; g_autoptr(IdeFileSettings) child = NULL; GType gtype; gtype = g_io_extension_get_type (extension); if (!g_type_is_a (gtype, IDE_TYPE_FILE_SETTINGS)) { g_warning ("%s is not an IdeFileSettings", g_type_name (gtype)); continue; } child = g_object_new (gtype, "file", file, "language", language, NULL); ide_object_append (IDE_OBJECT (ret), IDE_OBJECT (child)); if (G_IS_INITABLE (child)) { g_autoptr(GError) error = NULL; if (!g_initable_init (G_INITABLE (child), NULL, &error)) { if (!ide_error_ignore (error)) g_warning ("%s", error->message); } } else if (G_IS_ASYNC_INITABLE (child)) { priv->unsettled_count++; g_async_initable_init_async (G_ASYNC_INITABLE (child), G_PRIORITY_DEFAULT, NULL, ide_file_settings__init_cb, g_object_ref (ret)); } _ide_file_settings_append (ret, child); } priv->unsettled_count--; return ret; }
gint rc_extract_packages_from_aptrpm_buffer (const guint8 *data, int len, RCPackman *packman, RCChannel *channel, RCPackageFn callback, gpointer user_data) { #ifndef ENABLE_RPM /* We can't support apt-rpm without rpm support */ rc_debug (RC_DEBUG_LEVEL_ERROR, "RPM support is not enabled"); return -1; #else RCRpmman *rpmman; int count = 0; const int hdrmagic_len = 8; const char *hdrmagic; const guint8 *cur_ptr; g_return_val_if_fail (packman != NULL, -1); if (!g_type_is_a (G_TYPE_FROM_INSTANCE (packman), RC_TYPE_RPMMAN)) { rc_debug (RC_DEBUG_LEVEL_ERROR, "apt-rpm support is not available on non-RPM systems"); return -1; } rpmman = RC_RPMMAN (packman); if (len < hdrmagic_len) { rc_debug (RC_DEBUG_LEVEL_ERROR, "Data is too small to possibly be correct"); return 0; } /* * The apt-rpm pkglist files are a set of rpm headers, each prefixed * with the header magic, one right after the other. If opened on disk, * they can be iterated using headerRead(). Since we have an in-memory * buffer, we use headerCopyLoad to read them. We could, potentially, * use headerLoad(); but I'm unsure as to what happens when headerFree * is called on a Header returned from headerLoad. It may be a small * memory savings to do so. */ /* Skip the inital RPM header magic */ hdrmagic = data; cur_ptr = data + hdrmagic_len; while (cur_ptr != NULL) { Header h; RCPackage *p; RCPackageUpdate *pu; int bytesleft, i; char *tmpc; int typ, n; char *filename = NULL; h = rpmman->headerLoad (cur_ptr); if (h == NULL) { rc_debug (RC_DEBUG_LEVEL_ERROR, "Unable to get header from headerCopyLoad!"); return 0; } p = rc_package_new (); rc_rpmman_read_header (rpmman, h, p); rc_rpmman_depends_fill (rpmman, h, p, TRUE); p->channel = rc_channel_ref (channel); rpmman->headerGetEntry (h, CRPMTAG_FILENAME, &typ, (void **)&tmpc, &n); if (n && (typ == RPM_STRING_TYPE) && tmpc && tmpc[0]) { if (g_utf8_validate (tmpc, -1, NULL)) { filename = g_strdup (tmpc); } else { filename = g_convert_with_fallback (tmpc, -1, "UTF-8", "ISO-8859-1", "?", NULL, NULL, NULL); } } else { filename = g_strdup_printf ("%s.rpm", rc_package_spec_to_str (RC_PACKAGE_SPEC (p))); } pu = rc_package_update_new (); rc_package_spec_copy (RC_PACKAGE_SPEC (pu), RC_PACKAGE_SPEC (p)); pu->importance = RC_IMPORTANCE_SUGGESTED; pu->description = g_strdup ("No information available."); pu->package_url = g_strdup_printf ("%s/%s", rc_channel_get_file_path (channel), filename); p->history = g_slist_append (p->history, pu); if (callback) callback (p, user_data); rc_package_unref (p); ++count; rpmman->headerFree (h); g_free (filename); /* This chunk of ugly could be removed if a) memmem() was portable; * or b) if rpmlib didn't suck, and I could figure out how much * data it read from the buffer. */ bytesleft = len - (cur_ptr - data); for (i = 0; i < bytesleft - hdrmagic_len; i++) { if (memcmp (cur_ptr + i, hdrmagic, hdrmagic_len) == 0) { /* We found a match */ cur_ptr = cur_ptr + i + hdrmagic_len; break; } } if (i >= bytesleft - hdrmagic_len) { /* No match was found */ cur_ptr = NULL; } } return count; #endif }
gboolean _gdart_marshaller_check_argument_object( GdartBridgeContext *self, Dart_Handle element, gpointer type, const ObjectInfoKlass *type_klass, Dart_Handle *dart_error_out, GError **error) { Dart_Handle base_object_class, temp_result, inner_container, name_handle; bool is_proper_type; RawPointerContainer* raw_pointer; GdartBridgeContextWrappedObject* object_info; GObject* object; GType gtype; GIInfoType object_info_type; base_object_class = gdart_bridge_context_get_base_object_class(self, dart_error_out, error); if (base_object_class == NULL) { return false; } if (Dart_IsNull(element)) { return TRUE; } temp_result = Dart_ObjectIsType(element, base_object_class, &is_proper_type); if (Dart_IsError(temp_result)) { *dart_error_out = temp_result; g_set_error(error, GDART_ERROR, 1, "Error from Dart operation."); goto error; } if (!is_proper_type) { *dart_error_out = gdart_bridge_context_create_error_handle(self, "%s: received an unexpected base info type", G_STRFUNC); g_set_error(error, GDART_ERROR, 1, "%s: received an unexpected base info type", G_STRFUNC); goto error; } name_handle = Dart_NewStringFromCString("_internal"); if (Dart_IsError(name_handle)) { *dart_error_out = name_handle; g_set_error(error, GDART_ERROR, 1, "Error from Dart operation."); return FALSE; } inner_container = Dart_GetField(element, name_handle); if (Dart_IsError(inner_container)) { *dart_error_out = inner_container; g_set_error(error, GDART_ERROR, 1, "Error from Dart operation."); return FALSE; } temp_result = Dart_GetNativeInstanceField(inner_container, 0, (intptr_t*) &raw_pointer); if (Dart_IsError(temp_result)) { *dart_error_out = temp_result; g_set_error(error, GDART_ERROR, 1, "Error from Dart operation."); return FALSE; } object_info = (GdartBridgeContextWrappedObject*) raw_pointer->raw_pointer; if (!object_info->object_info_klass.get_type(object_info->object_info, self, &object_info_type, dart_error_out, error)) return FALSE; if (object_info_type != GI_INFO_TYPE_OBJECT) { *dart_error_out = gdart_bridge_context_create_error_handle(self, "%s: expected an object but got a struct", G_STRFUNC); g_set_error(error, GDART_ERROR, 1, "%s: expected an object but got a struct", G_STRFUNC); goto error; } object = (GObject*) object_info->object; if (!type_klass->get_gtype(type, self, >ype, dart_error_out, error)) return FALSE; if (!g_type_is_a(G_OBJECT_TYPE(object), gtype)) { *dart_error_out = gdart_bridge_context_create_error_handle(self, "%s: expected an object of one type but got another", G_STRFUNC); g_set_error(error, GDART_ERROR, 1, "%s: expected an object of one type but got another", G_STRFUNC); goto error; } return TRUE; error: return FALSE; }
static VALUE rg_type_is_a_p(VALUE self, VALUE is_a_type) { return CBOOL2RVAL(g_type_is_a(rbgobj_gtype_get(self), rbgobj_gtype_get(is_a_type))); }
static gboolean gtk_css_matcher_node_has_type (const GtkCssMatcher *matcher, GType type) { return g_type_is_a (gtk_css_node_get_widget_type (matcher->node.node), type); }
static void pygi_signal_closure_marshal(GClosure *closure, GValue *return_value, guint n_param_values, const GValue *param_values, gpointer invocation_hint, gpointer marshal_data) { PyGILState_STATE state; PyGClosure *pc = (PyGClosure *)closure; PyObject *params, *ret = NULL; guint i; GISignalInfo *signal_info; gint n_sig_info_args; gint sig_info_highest_arg; GSList *list_item = NULL; GSList *pass_by_ref_structs = NULL; state = PyGILState_Ensure(); signal_info = ((PyGISignalClosure *)closure)->signal_info; n_sig_info_args = g_callable_info_get_n_args(signal_info); /* the first argument to a signal callback is instance, but instance is not counted in the introspection data */ sig_info_highest_arg = n_sig_info_args + 1; g_assert_cmpint(sig_info_highest_arg, ==, n_param_values); /* construct Python tuple for the parameter values */ params = PyTuple_New(n_param_values); for (i = 0; i < n_param_values; i++) { /* swap in a different initial data for connect_object() */ if (i == 0 && G_CCLOSURE_SWAP_DATA(closure)) { g_return_if_fail(pc->swap_data != NULL); Py_INCREF(pc->swap_data); PyTuple_SetItem(params, 0, pc->swap_data); } else if (i == 0) { PyObject *item = pyg_value_as_pyobject(¶m_values[i], FALSE); if (!item) { goto out; } PyTuple_SetItem(params, i, item); } else if (i < sig_info_highest_arg) { GIArgInfo arg_info; GITypeInfo type_info; GITypeTag type_tag; GIArgument arg = { 0, }; PyObject *item = NULL; gboolean free_array = FALSE; gboolean pass_struct_by_ref = FALSE; g_callable_info_load_arg(signal_info, i - 1, &arg_info); g_arg_info_load_type(&arg_info, &type_info); arg = _pygi_argument_from_g_value(¶m_values[i], &type_info); type_tag = g_type_info_get_tag (&type_info); if (type_tag == GI_TYPE_TAG_ARRAY) { /* Skip the self argument of param_values */ arg.v_pointer = _pygi_argument_to_array (&arg, _pygi_argument_array_length_marshal, (void *)(param_values + 1), signal_info, &type_info, &free_array); } /* Hack to ensure struct arguments are passed-by-reference allowing * callback implementors to modify the struct values. This is needed * for keeping backwards compatibility and should be removed in future * versions which support signal output arguments as return values. * See: https://bugzilla.gnome.org/show_bug.cgi?id=735486 * * Note the logic here must match the logic path taken in _pygi_argument_to_object. */ if (type_tag == GI_TYPE_TAG_INTERFACE) { GIBaseInfo *info = g_type_info_get_interface (&type_info); GIInfoType info_type = g_base_info_get_type (info); if (info_type == GI_INFO_TYPE_STRUCT || info_type == GI_INFO_TYPE_BOXED || info_type == GI_INFO_TYPE_UNION) { GType gtype = g_registered_type_info_get_g_type ((GIRegisteredTypeInfo *) info); gboolean is_foreign = (info_type == GI_INFO_TYPE_STRUCT) && (g_struct_info_is_foreign ((GIStructInfo *) info)); if (!is_foreign && !g_type_is_a (gtype, G_TYPE_VALUE) && g_type_is_a (gtype, G_TYPE_BOXED)) { pass_struct_by_ref = TRUE; } } g_base_info_unref (info); } if (pass_struct_by_ref) { /* transfer everything will ensure the struct is not copied when wrapped. */ item = _pygi_argument_to_object (&arg, &type_info, GI_TRANSFER_EVERYTHING); if (item && PyObject_IsInstance (item, (PyObject *) &PyGIBoxed_Type)) { ((PyGBoxed *)item)->free_on_dealloc = FALSE; pass_by_ref_structs = g_slist_prepend (pass_by_ref_structs, item); } } else { item = _pygi_argument_to_object (&arg, &type_info, GI_TRANSFER_NOTHING); } if (free_array) { g_array_free (arg.v_pointer, FALSE); } if (item == NULL) { PyErr_Print (); goto out; } PyTuple_SetItem(params, i, item); } } /* params passed to function may have extra arguments */ if (pc->extra_args) { PyObject *tuple = params; params = PySequence_Concat(tuple, pc->extra_args); Py_DECREF(tuple); } ret = PyObject_CallObject(pc->callback, params); if (ret == NULL) { if (pc->exception_handler) pc->exception_handler(return_value, n_param_values, param_values); else PyErr_Print(); goto out; } if (G_IS_VALUE(return_value) && pyg_value_from_pyobject(return_value, ret) != 0) { PyErr_SetString(PyExc_TypeError, "can't convert return value to desired type"); if (pc->exception_handler) pc->exception_handler(return_value, n_param_values, param_values); else PyErr_Print(); } Py_DECREF(ret); /* Run through the list of structs which have been passed by reference and * check if they are being held longer than the duration of the callback * execution. This is determined if the ref count is greater than 1. * A single ref is held by the argument list and any more would mean the callback * stored a ref somewhere else. In this case we make an internal copy of * the boxed struct so Python can own the memory to it. */ list_item = pass_by_ref_structs; while (list_item) { PyObject *item = list_item->data; if (item->ob_refcnt > 1) { _pygi_boxed_copy_in_place ((PyGIBoxed *)item); } list_item = g_slist_next (list_item); } out: g_slist_free (pass_by_ref_structs); Py_DECREF(params); PyGILState_Release(state); }
void ges_base_xml_formatter_add_track_element (GESBaseXmlFormatter * self, GType track_element_type, const gchar * asset_id, const gchar * track_id, const gchar * timeline_obj_id, GstStructure * children_properties, GstStructure * properties, const gchar * metadatas, GError ** error) { GESTrackElement *trackelement; GError *err = NULL; GESAsset *asset = NULL; GESBaseXmlFormatterPrivate *priv = _GET_PRIV (self); if (priv->check_only) return; if (g_type_is_a (track_element_type, GES_TYPE_TRACK_ELEMENT) == FALSE) { GST_DEBUG_OBJECT (self, "%s is not a TrackElement, can not create it", g_type_name (track_element_type)); goto out; } if (g_type_is_a (track_element_type, GES_TYPE_BASE_EFFECT) == FALSE) { GST_FIXME_OBJECT (self, "%s currently not supported", g_type_name (track_element_type)); goto out; } asset = ges_asset_request (track_element_type, asset_id, &err); if (asset == NULL) { GST_DEBUG_OBJECT (self, "Can not create trackelement %s", asset_id); GST_FIXME_OBJECT (self, "Check if missing plugins etc %s", err ? err->message : ""); goto out; } trackelement = GES_TRACK_ELEMENT (ges_asset_extract (asset, NULL)); if (trackelement) { GESClip *clip; if (metadatas) ges_meta_container_add_metas_from_string (GES_META_CONTAINER (trackelement), metadatas); clip = g_hash_table_lookup (priv->containers, timeline_obj_id); if (clip) { _add_track_element (GES_FORMATTER (self), clip, trackelement, track_id, children_properties, properties); } else { PendingEffects *peffect; PendingClip *pend = g_hash_table_lookup (priv->clipid_pendings, timeline_obj_id); if (pend == NULL) { GST_WARNING_OBJECT (self, "No Clip with id: %s can not " "add TrackElement", timeline_obj_id); goto out; } peffect = g_slice_new0 (PendingEffects); peffect->trackelement = trackelement; peffect->track_id = g_strdup (track_id); peffect->properties = properties ? gst_structure_copy (properties) : NULL; peffect->children_properties = children_properties ? gst_structure_copy (children_properties) : NULL; pend->effects = g_list_append (pend->effects, peffect); } priv->current_track_element = trackelement; } ges_project_add_asset (GES_FORMATTER (self)->project, asset); out: if (asset) gst_object_unref (asset); if (err) g_error_free (err); return; }
static void gom_repository_find_cb (GomAdapter *adapter, gpointer user_data) { GSimpleAsyncResult *simple = user_data; GomCommandBuilder *builder = NULL; GomResourceGroup *ret; GomRepository *repository = NULL; GomCommand *command; GomCursor *cursor; GomFilter *filter; GError *error = NULL; GType resource_type; GAsyncQueue *queue; guint count; g_return_if_fail(GOM_IS_ADAPTER(adapter)); g_return_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple)); repository = GOM_REPOSITORY(g_async_result_get_source_object(G_ASYNC_RESULT(simple))); g_assert(GOM_IS_REPOSITORY(repository)); resource_type = GPOINTER_TO_SIZE(g_object_get_data(G_OBJECT(simple), "resource-type")); g_assert(g_type_is_a(resource_type, GOM_TYPE_RESOURCE)); filter = g_object_get_data(G_OBJECT(simple), "filter"); g_assert(!filter || GOM_IS_FILTER(filter)); queue = g_object_get_data(G_OBJECT(simple), "queue"); builder = g_object_new(GOM_TYPE_COMMAND_BUILDER, "adapter", adapter, "resource-type", resource_type, "filter", filter, NULL); command = gom_command_builder_build_count(builder); g_assert(GOM_IS_COMMAND(command)); if (!gom_command_execute(command, &cursor, &error)) { g_simple_async_result_take_error(simple, error); goto out; } g_assert(GOM_IS_CURSOR(cursor)); if (!gom_cursor_next(cursor)) { g_assert_not_reached(); goto out; } count = gom_cursor_get_column_uint(cursor, 0); ret = g_object_new(GOM_TYPE_RESOURCE_GROUP, "adapter", adapter, "count", count, "filter", filter, "repository", repository, "resource-type", resource_type, NULL); g_simple_async_result_set_op_res_gpointer(simple, ret, g_object_unref); out: if (!queue) g_simple_async_result_complete_in_idle(simple); else g_async_queue_push(queue, GINT_TO_POINTER(TRUE)); g_object_unref(repository); g_clear_object(&cursor); g_clear_object(&command); g_clear_object(&builder); }
GtkWidget * gimp_prop_table_new (GObject *config, GType owner_type, GimpContext *context, GimpCreatePickerFunc create_picker_func, gpointer picker_creator) { GtkWidget *table; GtkSizeGroup *size_group; GParamSpec **param_specs; guint n_param_specs; gint i; gint row = 0; GParamSpec *last_pspec = NULL; GtkAdjustment *last_x_adj = NULL; gint last_x_row = 0; g_return_val_if_fail (G_IS_OBJECT (config), NULL); g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL); param_specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (config), &n_param_specs); size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); table = gtk_table_new (3, 1, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 4); gtk_table_set_row_spacings (GTK_TABLE (table), 2); for (i = 0; i < n_param_specs; i++) { GParamSpec *pspec = param_specs[i]; GtkWidget *widget = NULL; const gchar *label = NULL; /* ignore properties of parent classes of owner_type */ if (! g_type_is_a (pspec->owner_type, owner_type)) continue; if (G_IS_PARAM_SPEC_STRING (pspec)) { static GQuark multiline_quark = 0; if (! multiline_quark) multiline_quark = g_quark_from_static_string ("multiline"); if (GIMP_IS_PARAM_SPEC_CONFIG_PATH (pspec)) { widget = gimp_prop_file_chooser_button_new (config, pspec->name, g_param_spec_get_nick (pspec), GTK_FILE_CHOOSER_ACTION_OPEN); } else if (g_param_spec_get_qdata (pspec, multiline_quark)) { GtkTextBuffer *buffer; GtkWidget *view; buffer = gimp_prop_text_buffer_new (config, pspec->name, -1); view = gtk_text_view_new_with_buffer (buffer); widget = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (widget), view); gtk_widget_show (view); } else { widget = gimp_prop_entry_new (config, pspec->name, -1); } label = g_param_spec_get_nick (pspec); } else if (G_IS_PARAM_SPEC_BOOLEAN (pspec)) { widget = gimp_prop_check_button_new (config, pspec->name, g_param_spec_get_nick (pspec)); } else if (G_IS_PARAM_SPEC_ENUM (pspec)) { widget = gimp_prop_enum_combo_box_new (config, pspec->name, 0, 0); gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (widget), g_param_spec_get_nick (pspec)); } else if (GEGL_IS_PARAM_SPEC_SEED (pspec)) { GtkAdjustment *adj; GtkWidget *scale; GtkWidget *button; widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); scale = gimp_prop_spin_scale_new (config, pspec->name, g_param_spec_get_nick (pspec), 1.0, 10.0, 0); gtk_box_pack_start (GTK_BOX (widget), scale, TRUE, TRUE, 0); gtk_widget_show (scale); button = gtk_button_new_with_label (_("New Seed")); gtk_box_pack_start (GTK_BOX (widget), button, FALSE, FALSE, 0); gtk_widget_show (button); adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (scale)); g_signal_connect (button, "clicked", G_CALLBACK (gimp_prop_table_new_seed_clicked), adj); } else if (G_IS_PARAM_SPEC_INT (pspec) || G_IS_PARAM_SPEC_UINT (pspec) || G_IS_PARAM_SPEC_FLOAT (pspec) || G_IS_PARAM_SPEC_DOUBLE (pspec)) { GtkAdjustment *adj; gdouble value; gdouble lower; gdouble upper; gdouble step = 1.0; gdouble page = 10.0; gint digits = (G_IS_PARAM_SPEC_FLOAT (pspec) || G_IS_PARAM_SPEC_DOUBLE (pspec)) ? 2 : 0; if (GEGL_IS_PARAM_SPEC_DOUBLE (pspec)) { GeglParamSpecDouble *gspec = GEGL_PARAM_SPEC_DOUBLE (pspec); lower = gspec->ui_minimum; upper = gspec->ui_maximum; } else if (GEGL_IS_PARAM_SPEC_INT (pspec)) { GeglParamSpecInt *gspec = GEGL_PARAM_SPEC_INT (pspec); lower = gspec->ui_minimum; upper = gspec->ui_maximum; } else { _gimp_prop_widgets_get_numeric_values (config, pspec, &value, &lower, &upper, G_STRFUNC); } if ((upper - lower < 10.0) && (G_IS_PARAM_SPEC_FLOAT (pspec) || G_IS_PARAM_SPEC_DOUBLE (pspec))) { step = 0.1; page = 1.0; digits = 3; } widget = gimp_prop_spin_scale_new (config, pspec->name, g_param_spec_get_nick (pspec), step, page, digits); adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)); if (g_str_has_suffix (pspec->name, "x") || g_str_has_suffix (pspec->name, "width")) { last_pspec = pspec; last_x_adj = adj; last_x_row = row; } else if ((g_str_has_suffix (pspec->name, "y") || g_str_has_suffix (pspec->name, "height")) && last_pspec != NULL && last_x_adj != NULL && last_x_row == row - 1) { GtkWidget *chain = gimp_chain_button_new (GIMP_CHAIN_RIGHT); gtk_table_attach (GTK_TABLE (table), chain, 3, 4, last_x_row, row + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (chain); if (gtk_adjustment_get_value (last_x_adj) == gtk_adjustment_get_value (adj)) { GBinding *binding; gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain), TRUE); binding = g_object_bind_property (last_x_adj, "value", adj, "value", G_BINDING_BIDIRECTIONAL); g_object_set_data (G_OBJECT (chain), "binding", binding); } g_signal_connect (chain, "toggled", G_CALLBACK (gimp_prop_table_chain_toggled), last_x_adj); g_object_set_data (G_OBJECT (last_x_adj), "y-adjustment", adj); if (create_picker_func) { GtkWidget *button; gchar *pspec_name; pspec_name = g_strconcat (last_pspec->name, ":", pspec->name, NULL); button = create_picker_func (picker_creator, pspec_name, GIMP_STOCK_CURSOR, _("Pick coordinates from the image")); gtk_table_attach (GTK_TABLE (table), button, 4, 5, last_x_row, row + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (button); g_object_weak_ref (G_OBJECT (button), (GWeakNotify) g_free, pspec_name); } } } else if (GIMP_IS_PARAM_SPEC_RGB (pspec)) { GtkWidget *button; widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); button = gimp_prop_color_button_new (config, pspec->name, g_param_spec_get_nick (pspec), 128, 24, GIMP_COLOR_AREA_SMALL_CHECKS); gimp_color_button_set_update (GIMP_COLOR_BUTTON (button), TRUE); gimp_color_panel_set_context (GIMP_COLOR_PANEL (button), context); gtk_box_pack_start (GTK_BOX (widget), button, TRUE, TRUE, 0); gtk_widget_show (button); if (create_picker_func) { button = create_picker_func (picker_creator, pspec->name, GIMP_STOCK_COLOR_PICKER_GRAY, _("Pick color from the image")); gtk_box_pack_start (GTK_BOX (widget), button, FALSE, FALSE, 0); gtk_widget_show (button); } label = g_param_spec_get_nick (pspec); } else { g_warning ("%s: not supported: %s (%s)\n", G_STRFUNC, g_type_name (G_TYPE_FROM_INSTANCE (pspec)), pspec->name); } if (widget) { if (label) { gimp_table_attach_aligned (GTK_TABLE (table), 0, row, label, 0.0, 0.5, widget, 2, FALSE); } else { gtk_table_attach_defaults (GTK_TABLE (table), widget, 0, 3, row, row + 1); gtk_widget_show (widget); } row++; } } g_object_unref (size_group); g_free (param_specs); return table; }
void gtk2hs_value_from_haskellobj(GValue *value, HaskellObj obj) { switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) { case G_TYPE_INVALID: case G_TYPE_NONE: return; case G_TYPE_INTERFACE: /* we only handle interface types that have a GObject prereq */ if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT)) { g_value_set_object(value, rts_getPtr(obj)); } else { break; } return; case G_TYPE_CHAR: g_value_set_char(value, rts_getChar(obj)); return; case G_TYPE_UCHAR: g_value_set_char(value, rts_getChar(obj)); return; case G_TYPE_BOOLEAN: g_value_set_boolean(value, rts_getBool(obj)); return; case G_TYPE_INT: g_value_set_int(value, rts_getInt(obj)); return; case G_TYPE_UINT: g_value_set_uint(value, rts_getWord(obj)); return; case G_TYPE_LONG: g_value_set_long(value, rts_getInt(obj)); return; case G_TYPE_ULONG: g_value_set_ulong(value, rts_getWord(obj)); return; /* case G_TYPE_INT64: g_value_set_int64(value, rts_getInt64(obj)); return; case G_TYPE_UINT64: g_value_set_uint64(value, rts_getWord64(obj)); return; */ case G_TYPE_ENUM: g_value_set_enum(value, rts_getInt(obj)); return; case G_TYPE_FLAGS: g_value_set_flags(value, rts_getInt(obj)); return; case G_TYPE_FLOAT: g_value_set_float(value, rts_getFloat(obj)); return; case G_TYPE_DOUBLE: g_value_set_double(value, rts_getDouble(obj)); return; case G_TYPE_STRING: g_value_set_string(value, rts_getPtr(obj)); return; case G_TYPE_POINTER: g_value_set_pointer(value, rts_getPtr(obj)); return; /* case G_TYPE_BOXED: { g_value_set_boxed(value, obj); break; } case G_TYPE_PARAM: g_value_set_param(value, (obj)); break; */ case G_TYPE_OBJECT: g_value_set_object(value, rts_getPtr(obj)); return; } g_error("gtk2hs_value_from_haskellobj: unable to handle GValue with type %s\n" "please report this as a bug to [email protected]", g_type_name(G_VALUE_TYPE(value))); }
static gchar * dump_describe_param (GParamSpec *param_spec) { const gchar *blurb = g_param_spec_get_blurb (param_spec); const gchar *values = NULL; if (!blurb) { g_warning ("FIXME: Property '%s' has no blurb.", param_spec->name); blurb = g_strdup_printf ("The %s property has no description.", param_spec->name); } if (GIMP_IS_PARAM_SPEC_RGB (param_spec)) { if (gimp_param_spec_rgb_has_alpha (param_spec)) values = "The color is specified in the form (color-rgba red green blue " "alpha) with channel values as floats in the range of 0.0 to 1.0."; else values = "The color is specified in the form (color-rgb red green blue) " "with channel values as floats in the range of 0.0 to 1.0."; } else if (GIMP_IS_PARAM_SPEC_MEMSIZE (param_spec)) { values = "The integer size can contain a suffix of 'B', 'K', 'M' or 'G' which " "makes GIMP interpret the size as being specified in bytes, kilobytes, " "megabytes or gigabytes. If no suffix is specified the size defaults " "to being specified in kilobytes."; } else if (GIMP_IS_PARAM_SPEC_CONFIG_PATH (param_spec)) { switch (gimp_param_spec_config_path_type (param_spec)) { case GIMP_CONFIG_PATH_FILE: values = "This is a single filename."; break; case GIMP_CONFIG_PATH_FILE_LIST: switch (G_SEARCHPATH_SEPARATOR) { case ':': values = "This is a colon-separated list of files."; break; case ';': values = "This is a semicolon-separated list of files."; break; default: g_warning ("unhandled G_SEARCHPATH_SEPARATOR value"); break; } break; case GIMP_CONFIG_PATH_DIR: values = "This is a single folder."; break; case GIMP_CONFIG_PATH_DIR_LIST: switch (G_SEARCHPATH_SEPARATOR) { case ':': values = "This is a colon-separated list of folders to search."; break; case ';': values = "This is a semicolon-separated list of folders to search."; break; default: g_warning ("unhandled G_SEARCHPATH_SEPARATOR value"); break; } break; } } else if (GIMP_IS_PARAM_SPEC_UNIT (param_spec)) { values = "The unit can be one inches, millimeters, points or picas plus " "those in your user units database."; } else if (g_type_is_a (param_spec->value_type, GIMP_TYPE_CONFIG)) { values = "This is a parameter list."; } else { switch (G_TYPE_FUNDAMENTAL (param_spec->value_type)) { case G_TYPE_BOOLEAN: values = "Possible values are yes and no."; break; case G_TYPE_INT: case G_TYPE_UINT: case G_TYPE_LONG: case G_TYPE_ULONG: values = "This is an integer value."; break; case G_TYPE_FLOAT: case G_TYPE_DOUBLE: values = "This is a float value."; break; case G_TYPE_STRING: /* eek */ if (strcmp (g_param_spec_get_name (param_spec), "image-title-format") && strcmp (g_param_spec_get_name (param_spec), "image-status-format")) { values = "This is a string value."; } else { values = display_format_description; } break; case G_TYPE_ENUM: { GEnumClass *enum_class; GEnumValue *enum_value; GString *str; gint i; enum_class = g_type_class_peek (param_spec->value_type); str = g_string_new (blurb); g_string_append (str, " Possible values are "); for (i = 0, enum_value = enum_class->values; i < enum_class->n_values; i++, enum_value++) { g_string_append (str, enum_value->value_nick); switch (enum_class->n_values - i) { case 1: g_string_append_c (str, '.'); break; case 2: g_string_append (str, " and "); break; default: g_string_append (str, ", "); break; } } return g_string_free (str, FALSE); } break; default: break; } } if (!values) g_warning ("FIXME: Can't tell anything about a %s.", g_type_name (param_spec->value_type)); if (strcmp (blurb, "") == 0) return g_strdup_printf ("%s", values); else return g_strdup_printf ("%s %s", blurb, values); }
static void test_type (gconstpointer data) { GObjectClass *klass; GObject *instance; GParamSpec **pspecs; guint n_pspecs, i; GType type; GdkDisplay *display; type = * (GType *) data; display = gdk_display_get_default (); if (!G_TYPE_IS_CLASSED (type)) return; if (G_TYPE_IS_ABSTRACT (type)) return; if (!g_type_is_a (type, G_TYPE_OBJECT)) return; /* These can't be freely constructed/destroyed */ if (g_type_is_a (type, GTK_TYPE_APPLICATION) || g_type_is_a (type, GDK_TYPE_PIXBUF_LOADER) || g_type_is_a (type, GDK_TYPE_DRAWING_CONTEXT) || #ifdef G_OS_UNIX g_type_is_a (type, GTK_TYPE_PRINT_JOB) || #endif g_type_is_a (type, gdk_pixbuf_simple_anim_iter_get_type ()) || g_str_equal (g_type_name (type), "GdkX11DeviceManagerXI2") || g_str_equal (g_type_name (type), "GdkX11DeviceManagerCore") || g_str_equal (g_type_name (type), "GdkX11Display") || g_str_equal (g_type_name (type), "GdkX11DisplayManager") || g_str_equal (g_type_name (type), "GdkX11Screen") || g_str_equal (g_type_name (type), "GdkX11GLContext")) return; /* This throws a critical when the connection is dropped */ if (g_type_is_a (type, GTK_TYPE_APP_CHOOSER_DIALOG)) return; /* These leak their GDBusConnections */ if (g_type_is_a (type, GTK_TYPE_FILE_CHOOSER_BUTTON) || g_type_is_a (type, GTK_TYPE_FILE_CHOOSER_DIALOG) || g_type_is_a (type, GTK_TYPE_FILE_CHOOSER_WIDGET) || g_type_is_a (type, GTK_TYPE_PLACES_SIDEBAR)) return; klass = g_type_class_ref (type); if (g_type_is_a (type, GTK_TYPE_SETTINGS)) instance = g_object_ref (gtk_settings_get_default ()); else if (g_type_is_a (type, GDK_TYPE_WINDOW)) { GdkWindowAttr attributes; attributes.wclass = GDK_INPUT_OUTPUT; attributes.window_type = GDK_WINDOW_TEMP; attributes.event_mask = 0; attributes.width = 100; attributes.height = 100; instance = g_object_ref (gdk_window_new (NULL, &attributes, 0)); } else if (g_str_equal (g_type_name (type), "GdkX11Cursor")) instance = g_object_new (type, "display", display, NULL); else instance = g_object_new (type, NULL); if (g_type_is_a (type, G_TYPE_INITIALLY_UNOWNED)) g_object_ref_sink (instance); pspecs = g_object_class_list_properties (klass, &n_pspecs); for (i = 0; i < n_pspecs; ++i) { GParamSpec *pspec = pspecs[i]; GValue value = G_VALUE_INIT; if (pspec->owner_type != type) continue; if ((pspec->flags & G_PARAM_READABLE) == 0) continue; /* This one has a special-purpose default value */ if (g_type_is_a (type, GTK_TYPE_DIALOG) && (strcmp (pspec->name, "use-header-bar") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_ASSISTANT) && (strcmp (pspec->name, "use-header-bar") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_POPOVER) && (strcmp (pspec->name, "pointing-to") == 0)) continue; if (g_type_is_a (type, GDK_TYPE_DISPLAY_MANAGER) && (strcmp (pspec->name, "default-display") == 0)) continue; if (g_type_is_a (type, GDK_TYPE_MONITOR) && (strcmp (pspec->name, "geometry") == 0 || strcmp (pspec->name, "workarea") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_ABOUT_DIALOG) && (strcmp (pspec->name, "program-name") == 0)) continue; /* These are set to the current date */ if (g_type_is_a (type, GTK_TYPE_CALENDAR) && (strcmp (pspec->name, "year") == 0 || strcmp (pspec->name, "month") == 0 || strcmp (pspec->name, "day") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_CELL_AREA_CONTEXT) && (strcmp (pspec->name, "minimum-width") == 0 || strcmp (pspec->name, "minimum-height") == 0 || strcmp (pspec->name, "natural-width") == 0 || strcmp (pspec->name, "natural-height") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_CELL_RENDERER_TEXT) && (strcmp (pspec->name, "background-gdk") == 0 || strcmp (pspec->name, "foreground-gdk") == 0 || strcmp (pspec->name, "background-rgba") == 0 || strcmp (pspec->name, "foreground-rgba") == 0 || strcmp (pspec->name, "font") == 0 || strcmp (pspec->name, "font-desc") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_CELL_VIEW) && (strcmp (pspec->name, "background-gdk") == 0 || strcmp (pspec->name, "foreground-gdk") == 0 || strcmp (pspec->name, "foreground-rgba") == 0 || strcmp (pspec->name, "background-rgba") == 0 || strcmp (pspec->name, "cell-area") == 0 || strcmp (pspec->name, "cell-area-context") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_COLOR_BUTTON) && (strcmp (pspec->name, "color") == 0 || strcmp (pspec->name, "rgba") == 0)) continue; G_GNUC_BEGIN_IGNORE_DEPRECATIONS if (g_type_is_a (type, GTK_TYPE_COLOR_SELECTION) && (strcmp (pspec->name, "current-color") == 0 || strcmp (pspec->name, "current-rgba") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_COLOR_SELECTION_DIALOG) && (strcmp (pspec->name, "color-selection") == 0 || strcmp (pspec->name, "ok-button") == 0 || strcmp (pspec->name, "help-button") == 0 || strcmp (pspec->name, "cancel-button") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_COMBO_BOX) && (strcmp (pspec->name, "cell-area") == 0 || strcmp (pspec->name, "cell-area-context") == 0)) continue; G_GNUC_END_IGNORE_DEPRECATIONS /* Default invisible char is determined at runtime */ if (g_type_is_a (type, GTK_TYPE_ENTRY) && (strcmp (pspec->name, "invisible-char") == 0 || strcmp (pspec->name, "buffer") == 0)) continue; G_GNUC_BEGIN_IGNORE_DEPRECATIONS if (g_type_is_a (type, GTK_TYPE_ENTRY_COMPLETION) && (strcmp (pspec->name, "cell-area") == 0 || strcmp (pspec->name, "cell-area-context") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_FONT_SELECTION) && strcmp (pspec->name, "font") == 0) continue; if (g_type_is_a (type, GTK_TYPE_ICON_VIEW) && (strcmp (pspec->name, "cell-area") == 0 || strcmp (pspec->name, "cell-area-context") == 0)) continue; G_GNUC_END_IGNORE_DEPRECATIONS if (g_type_is_a (type, GTK_TYPE_LAYOUT) && (strcmp (pspec->name, "hadjustment") == 0 || strcmp (pspec->name, "vadjustment") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_MESSAGE_DIALOG) && (strcmp (pspec->name, "image") == 0 || strcmp (pspec->name, "message-area") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_PANED) && strcmp (pspec->name, "max-position") == 0) continue; if (g_type_is_a (type, GTK_TYPE_PRINT_OPERATION) && strcmp (pspec->name, "job-name") == 0) continue; #ifdef G_OS_UNIX if (g_type_is_a (type, GTK_TYPE_PRINT_UNIX_DIALOG) && (strcmp (pspec->name, "page-setup") == 0 || strcmp (pspec->name, "print-settings") == 0)) continue; #endif if (g_type_is_a (type, GTK_TYPE_PROGRESS_BAR) && strcmp (pspec->name, "adjustment") == 0) continue; /* filename value depends on $HOME */ if (g_type_is_a (type, GTK_TYPE_RECENT_MANAGER) && (strcmp (pspec->name, "filename") == 0 || strcmp (pspec->name, "size") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_SCALE_BUTTON) && strcmp (pspec->name, "adjustment") == 0) continue; if (g_type_is_a (type, GTK_TYPE_SCROLLED_WINDOW) && (strcmp (pspec->name, "hadjustment") == 0 || strcmp (pspec->name, "vadjustment") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_SETTINGS)) continue; if (g_type_is_a (type, GTK_TYPE_SPIN_BUTTON) && (strcmp (pspec->name, "adjustment") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_STATUS_ICON) && (strcmp (pspec->name, "size") == 0 || strcmp (pspec->name, "screen") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_STYLE_CONTEXT) && strcmp (pspec->name, "screen") == 0) continue; if (g_type_is_a (type, GTK_TYPE_TEXT_BUFFER) && (strcmp (pspec->name, "tag-table") == 0 || strcmp (pspec->name, "copy-target-list") == 0 || strcmp (pspec->name, "paste-target-list") == 0)) continue; /* language depends on the current locale */ if (g_type_is_a (type, GTK_TYPE_TEXT_TAG) && (strcmp (pspec->name, "background-gdk") == 0 || strcmp (pspec->name, "foreground-gdk") == 0 || strcmp (pspec->name, "language") == 0 || strcmp (pspec->name, "font") == 0 || strcmp (pspec->name, "font-desc") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_TEXT_VIEW) && strcmp (pspec->name, "buffer") == 0) continue; if (g_type_is_a (type, GTK_TYPE_TOOL_ITEM_GROUP) && strcmp (pspec->name, "label-widget") == 0) continue; if (g_type_is_a (type, GTK_TYPE_TREE_VIEW) && (strcmp (pspec->name, "hadjustment") == 0 || strcmp (pspec->name, "vadjustment") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_TREE_VIEW_COLUMN) && (strcmp (pspec->name, "cell-area") == 0 || strcmp (pspec->name, "cell-area-context") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_VIEWPORT) && (strcmp (pspec->name, "hadjustment") == 0 || strcmp (pspec->name, "vadjustment") == 0)) continue; if (g_type_is_a (type, GTK_TYPE_WIDGET) && (strcmp (pspec->name, "name") == 0 || strcmp (pspec->name, "screen") == 0 || strcmp (pspec->name, "style") == 0)) continue; /* resize-grip-visible is determined at runtime */ if (g_type_is_a (type, GTK_TYPE_WINDOW) && strcmp (pspec->name, "resize-grip-visible") == 0) continue; /* show-desktop depends on desktop environment */ if (g_type_is_a (type, GTK_TYPE_PLACES_SIDEBAR) && strcmp (pspec->name, "show-desktop") == 0) continue; if (g_test_verbose ()) g_print ("Property %s.%s\n", g_type_name (pspec->owner_type), pspec->name); g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec)); g_object_get_property (instance, pspec->name, &value); check_property ("Property", pspec, &value); g_value_unset (&value); } g_free (pspecs); if (g_type_is_a (type, GTK_TYPE_WIDGET)) { g_object_set (gtk_settings_get_default (), "gtk-theme-name", "Raleigh", NULL); pspecs = gtk_widget_class_list_style_properties (GTK_WIDGET_CLASS (klass), &n_pspecs); for (i = 0; i < n_pspecs; ++i) { GParamSpec *pspec = pspecs[i]; GValue value = G_VALUE_INIT; if (pspec->owner_type != type) continue; if ((pspec->flags & G_PARAM_READABLE) == 0) continue; if (g_type_is_a (type, GTK_TYPE_BUTTON) && strcmp (pspec->name, "default-border") == 0) continue; if (g_type_is_a (type, GTK_TYPE_WINDOW) && (strcmp (pspec->name, "resize-grip-width") == 0 || strcmp (pspec->name, "resize-grip-height") == 0 || strcmp (pspec->name, "decoration-button-layout") == 0)) continue; g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec)); gtk_widget_style_get_property (GTK_WIDGET (instance), pspec->name, &value); check_property ("Style property", pspec, &value); g_value_unset (&value); } g_free (pspecs); } if (g_type_is_a (type, GDK_TYPE_WINDOW)) gdk_window_destroy (GDK_WINDOW (instance)); else g_object_unref (instance); g_type_class_unref (klass); }
static void gimp_tools_register (GType tool_type, GType tool_options_type, GimpToolOptionsGUIFunc options_gui_func, GimpContextPropMask context_props, const gchar *identifier, const gchar *blurb, const gchar *help, const gchar *menu_label, const gchar *menu_accel, const gchar *help_domain, const gchar *help_data, const gchar *icon_name, gpointer data) { Gimp *gimp = (Gimp *) data; GimpToolInfo *tool_info; const gchar *paint_core_name; gboolean visible; g_return_if_fail (GIMP_IS_GIMP (gimp)); g_return_if_fail (g_type_is_a (tool_type, GIMP_TYPE_TOOL)); g_return_if_fail (tool_options_type == G_TYPE_NONE || g_type_is_a (tool_options_type, GIMP_TYPE_TOOL_OPTIONS)); if (tool_options_type == G_TYPE_NONE) tool_options_type = GIMP_TYPE_TOOL_OPTIONS; if (tool_type == GIMP_TYPE_PENCIL_TOOL) { paint_core_name = "gimp-pencil"; } else if (tool_type == GIMP_TYPE_PAINTBRUSH_TOOL) { paint_core_name = "gimp-paintbrush"; } else if (tool_type == GIMP_TYPE_ERASER_TOOL) { paint_core_name = "gimp-eraser"; } else if (tool_type == GIMP_TYPE_AIRBRUSH_TOOL) { paint_core_name = "gimp-airbrush"; } else if (tool_type == GIMP_TYPE_CLONE_TOOL) { paint_core_name = "gimp-clone"; } else if (tool_type == GIMP_TYPE_HEAL_TOOL) { paint_core_name = "gimp-heal"; } else if (tool_type == GIMP_TYPE_PERSPECTIVE_CLONE_TOOL) { paint_core_name = "gimp-perspective-clone"; } else if (tool_type == GIMP_TYPE_CONVOLVE_TOOL) { paint_core_name = "gimp-convolve"; } else if (tool_type == GIMP_TYPE_SMUDGE_TOOL) { paint_core_name = "gimp-smudge"; } else if (tool_type == GIMP_TYPE_DODGE_BURN_TOOL) { paint_core_name = "gimp-dodge-burn"; } else if (tool_type == GIMP_TYPE_INK_TOOL) { paint_core_name = "gimp-ink"; } else if (tool_type == GIMP_TYPE_MYBRUSH_TOOL) { paint_core_name = "gimp-mybrush"; } else { paint_core_name = "gimp-paintbrush"; } tool_info = gimp_tool_info_new (gimp, tool_type, tool_options_type, context_props, identifier, blurb, help, menu_label, menu_accel, help_domain, help_data, paint_core_name, icon_name); visible = (! g_type_is_a (tool_type, GIMP_TYPE_IMAGE_MAP_TOOL)); g_object_set (tool_info, "visible", visible, NULL); g_object_set_data (G_OBJECT (tool_info), "gimp-tool-default-visible", GINT_TO_POINTER (visible)); g_object_set_data (G_OBJECT (tool_info), "gimp-tool-options-gui-func", options_gui_func); gimp_container_add (gimp->tool_info_list, GIMP_OBJECT (tool_info)); g_object_unref (tool_info); if (tool_type == GIMP_TYPE_PAINTBRUSH_TOOL) gimp_tool_info_set_standard (gimp, tool_info); }
static gboolean update_iface (StoragedObject *object, const gchar *uevent_action, StoragedObjectHasInterfaceFunc has_func, StoragedObjectConnectInterfaceFunc connect_func, StoragedObjectUpdateInterfaceFunc update_func, GType skeleton_type, gpointer _interface_pointer) { gboolean ret = FALSE; gboolean has; gboolean add; GDBusInterface **interface_pointer = _interface_pointer; GDBusInterfaceInfo *interface_info = NULL; g_return_val_if_fail (object != NULL, FALSE); g_return_val_if_fail (has_func != NULL, FALSE); g_return_val_if_fail (update_func != NULL, FALSE); g_return_val_if_fail (g_type_is_a (skeleton_type, G_TYPE_OBJECT), FALSE); g_return_val_if_fail (g_type_is_a (skeleton_type, G_TYPE_DBUS_INTERFACE), FALSE); g_return_val_if_fail (interface_pointer != NULL, FALSE); g_return_val_if_fail (*interface_pointer == NULL || G_IS_DBUS_INTERFACE (*interface_pointer), FALSE); add = FALSE; has = has_func (object); if (*interface_pointer == NULL) { if (has) { *interface_pointer = g_object_new (skeleton_type, NULL); if (connect_func != NULL) connect_func (object); add = TRUE; } } else { if (!has) { /* Check before we remove interface from object */ interface_info = g_dbus_interface_get_info (*interface_pointer); if (g_dbus_object_get_interface ((GDBusObject *) object, interface_info->name)) g_dbus_object_skeleton_remove_interface (G_DBUS_OBJECT_SKELETON (object), G_DBUS_INTERFACE_SKELETON (*interface_pointer)); g_object_unref (*interface_pointer); *interface_pointer = NULL; } } if (*interface_pointer != NULL) { if (update_func (object, uevent_action, G_DBUS_INTERFACE (*interface_pointer))) ret = TRUE; if (add) g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), G_DBUS_INTERFACE_SKELETON (*interface_pointer)); } return ret; }
static GtkWidget * dynamics_options_gui (GimpPaintOptions *paint_options, GType tool_type) { GObject *config = G_OBJECT (paint_options); GtkWidget *frame; GtkWidget *inner_frame; GtkWidget *label; GtkWidget *scale; GtkWidget *menu; GtkWidget *combo; GtkWidget *checkbox; GtkWidget *vbox; GtkWidget *inner_vbox; GtkWidget *hbox; GtkWidget *box; frame = gimp_prop_expander_new (config, "dynamics-expanded", _("Dynamics Options")); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); inner_frame = gimp_frame_new (_("Fade Options")); gtk_box_pack_start (GTK_BOX (vbox), inner_frame, FALSE, FALSE, 0); gtk_widget_show (inner_frame); inner_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_container_add (GTK_CONTAINER (inner_frame), inner_vbox); gtk_widget_show (inner_vbox); /* the fade-out scale & unitmenu */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (inner_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); scale = gimp_prop_spin_scale_new (config, "fade-length", _("Fade length"), 1.0, 50.0, 0); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_widget_show (scale); menu = gimp_prop_unit_combo_box_new (config, "fade-unit"); gtk_box_pack_start (GTK_BOX (hbox), menu, FALSE, FALSE, 0); gtk_widget_show (menu); #if 0 /* FIXME pixel digits */ g_object_set_data (G_OBJECT (menu), "set_digits", spinbutton); gimp_unit_menu_set_pixel_digits (GIMP_UNIT_MENU (menu), 0); #endif /* the repeat type */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (inner_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new (_("Repeat:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); combo = gimp_prop_enum_combo_box_new (config, "fade-repeat", 0, 0); gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); checkbox = gimp_prop_check_button_new (config, "fade-reverse", _("Reverse")); gtk_box_pack_start (GTK_BOX (inner_vbox), checkbox, FALSE, FALSE, 0); gtk_widget_show (checkbox); /* Color UI */ if (g_type_is_a (tool_type, GIMP_TYPE_PAINTBRUSH_TOOL)) { inner_frame = gimp_frame_new (_("Color Options")); gtk_box_pack_start (GTK_BOX (vbox), inner_frame, FALSE, FALSE, 0); gtk_widget_show (inner_frame); box = gimp_prop_gradient_box_new (NULL, GIMP_CONTEXT (config), _("Gradient"), 2, "gradient-view-type", "gradient-view-size", "gradient-reverse", "gimp-gradient-editor"); gtk_container_add (GTK_CONTAINER (inner_frame), box); gtk_widget_show (box); } return frame; }
gboolean ibus_message_iter_append (IBusMessageIter *iter, GType type, gconstpointer value) { g_assert (iter != NULL); g_assert (type != G_TYPE_INVALID); g_assert (value != NULL); switch (type) { case G_TYPE_CHAR: { char v; v = * (gchar *)value; return dbus_message_iter_append_basic (iter, DBUS_TYPE_BYTE, &v); } case G_TYPE_INT: { dbus_int32_t v; v = * (gint *)value; return dbus_message_iter_append_basic (iter, DBUS_TYPE_INT32, &v); } case G_TYPE_UINT: { dbus_uint32_t v; v = * (guint *)value; return dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT32, &v); } case G_TYPE_LONG: { dbus_int64_t v; v = * (glong *)value; return dbus_message_iter_append_basic (iter, DBUS_TYPE_INT64, &v); } case G_TYPE_ULONG: { dbus_uint64_t v; v = * (gulong *)value; return dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT64, &v); } case G_TYPE_BOOLEAN: { dbus_bool_t v; v = * (gboolean *)value; return dbus_message_iter_append_basic (iter, DBUS_TYPE_BOOLEAN, &v); } case G_TYPE_STRING: { const gchar *v; v = *(gchar **)value != NULL ? * (gchar **)value : ""; return dbus_message_iter_append_basic (iter, DBUS_TYPE_STRING, &v); } case G_TYPE_INT64: { dbus_int64_t v; v = * (gint64 *)value; return dbus_message_iter_append_basic (iter, DBUS_TYPE_INT64, &v); } case G_TYPE_UINT64: { dbus_uint64_t v; v = * (guint64 *)value; return dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT64, &v); } case G_TYPE_FLOAT: { double v; v = * (gfloat *)value; return dbus_message_iter_append_basic (iter, DBUS_TYPE_DOUBLE, &v); } case G_TYPE_DOUBLE: { double v; v = * (gdouble *)value; return dbus_message_iter_append_basic (iter, DBUS_TYPE_DOUBLE, &v); } default: if (type == G_TYPE_VALUE) { _to_dbus_value (iter, (GValue *)value); return TRUE; } if (type == IBUS_TYPE_OBJECT_PATH) { const gchar *v; v = * (gchar **)value; return dbus_message_iter_append_basic (iter, DBUS_TYPE_OBJECT_PATH, &v); } if (g_type_is_a (type, IBUS_TYPE_SERIALIZABLE)) { return ibus_serializable_serialize (*(IBusSerializable **)value, iter); } } return FALSE; }