static gboolean gst_object_set_name_default (GstObject * object) { const gchar *type_name; gint count; gchar *name; GQuark q; guint i, l; /* to ensure guaranteed uniqueness across threads, only one thread * may ever assign a name */ G_LOCK (object_name_mutex); if (!object_name_counts) { g_datalist_init (&object_name_counts); } q = g_type_qname (G_OBJECT_TYPE (object)); count = GPOINTER_TO_INT (g_datalist_id_get_data (&object_name_counts, q)); g_datalist_id_set_data (&object_name_counts, q, GINT_TO_POINTER (count + 1)); G_UNLOCK (object_name_mutex); /* GstFooSink -> foosink<N> */ type_name = g_quark_to_string (q); if (strncmp (type_name, "Gst", 3) == 0) type_name += 3; /* give the 20th "queue" element and the first "queue2" different names */ l = strlen (type_name); if (l > 0 && g_ascii_isdigit (type_name[l - 1])) { name = g_strdup_printf ("%s-%d", type_name, count); } else { name = g_strdup_printf ("%s%d", type_name, count); } l = strlen (name); for (i = 0; i < l; i++) name[i] = g_ascii_tolower (name[i]); GST_OBJECT_LOCK (object); if (G_UNLIKELY (object->parent != NULL)) goto had_parent; g_free (object->name); object->name = name; GST_OBJECT_UNLOCK (object); return TRUE; had_parent: { g_free (name); GST_WARNING ("parented objects can't be renamed"); GST_OBJECT_UNLOCK (object); return FALSE; } }
static void bt_song_io_native_xml_class_init (BtSongIONativeXMLClass * klass) { BtSongIOClass *const btsongio_class = BT_SONG_IO_CLASS (klass); error_domain = g_type_qname (BT_TYPE_SONG_IO_NATIVE_XML); //g_type_class_add_private(klass,sizeof(BtSongIONativeXMLPrivate)); btsongio_class->load = bt_song_io_native_xml_load; btsongio_class->save = bt_song_io_native_xml_save; }
/* * Returns a style property if it exists and if it is a long. If not, 0 is returned. * Its a dirty hack. The proper way would be using gtk_style_get() which is only * available with Gtk+ >= 2.16 */ static glong get_style_property_long (GtkStyle *style, GType widget_type, const gchar *property_name) { GtkRcProperty *rcprop = NULL; GtkWidgetClass *klass = g_type_class_ref (widget_type); GParamSpec *pspec = gtk_widget_class_find_style_property (klass, property_name); /* Style must be rc style */ g_return_val_if_fail(style->rc_style != NULL, 0); if (!pspec) { g_printerr("WARN: get_style_property_long: Property '%s' not found\n", property_name); return 0; } if (style->rc_style->rc_properties) { GtkRcProperty key; key.type_name = g_type_qname(widget_type); key.property_name = g_quark_from_string(pspec->name); /* Search all properties for given key */ rcprop = bsearch (&key, style->rc_style->rc_properties->data, style->rc_style->rc_properties->len, sizeof(GtkRcProperty), gtk_rc_properties_cmp); } if (rcprop == NULL) { g_printerr("WARN: get_style_property_long: RcProperty '%s' not found\n", property_name); return 0; } if (G_VALUE_HOLDS_LONG(&(rcprop->value))) { return g_value_get_long(&(rcprop->value)); } else { g_printerr("WARN: get_style_property_long: Property '%s' is not a long\n", property_name); return 0; } }
/** * gst_iterator_new: * @size: the size of the iterator structure * @type: #GType of children * @lock: pointer to a #GMutex. * @master_cookie: pointer to a guint32 that is changed when the items in the * iterator changed. * @next: function to get next item * @item: function to call on each item retrieved * @resync: function to resync the iterator * @free: function to free the iterator * * Create a new iterator. This function is mainly used for objects * implementing the next/resync/free function to iterate a data structure. * * For each item retrieved, the @item function is called with the lock * held. The @free function is called when the iterator is freed. * * Returns: the new #GstIterator. * * MT safe. */ GstIterator * gst_iterator_new (guint size, GType type, GMutex * lock, guint32 * master_cookie, GstIteratorNextFunction next, GstIteratorItemFunction item, GstIteratorResyncFunction resync, GstIteratorFreeFunction free) { GstIterator *result; g_return_val_if_fail (size >= sizeof (GstIterator), NULL); g_return_val_if_fail (g_type_qname (type) != 0, NULL); g_return_val_if_fail (master_cookie != NULL, NULL); g_return_val_if_fail (next != NULL, NULL); g_return_val_if_fail (resync != NULL, NULL); g_return_val_if_fail (free != NULL, NULL); result = g_malloc (size); gst_iterator_init (result, type, lock, master_cookie, next, item, resync, free); return result; }
static gboolean gst_object_set_name_default (GstObject * object) { const gchar *type_name; gint count; gchar *name, *tmp; gboolean result; GQuark q; /* to ensure guaranteed uniqueness across threads, only one thread * may ever assign a name */ G_LOCK (object_name_mutex); if (!object_name_counts) { g_datalist_init (&object_name_counts); } q = g_type_qname (G_OBJECT_TYPE (object)); count = GPOINTER_TO_INT (g_datalist_id_get_data (&object_name_counts, q)); g_datalist_id_set_data (&object_name_counts, q, GINT_TO_POINTER (count + 1)); G_UNLOCK (object_name_mutex); /* GstFooSink -> foosinkN */ type_name = g_quark_to_string (q); if (strncmp (type_name, "Gst", 3) == 0) type_name += 3; tmp = g_strdup_printf ("%s%d", type_name, count); name = g_ascii_strdown (tmp, -1); g_free (tmp); result = gst_object_set_name (object, name); g_free (name); return result; }
/** * gimp_config_deserialize_properties: * @config: a #GimpConfig. * @scanner: a #GScanner. * @nest_level: the nest level * * This function uses the @scanner to configure the properties of @config. * * Return value: %TRUE on success, %FALSE otherwise. * * Since: GIMP 2.4 **/ gboolean gimp_config_deserialize_properties (GimpConfig *config, GScanner *scanner, gint nest_level) { GObjectClass *klass; GParamSpec **property_specs; guint n_property_specs; guint i; guint scope_id; guint old_scope_id; GTokenType token; GTokenType next; g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE); klass = G_OBJECT_GET_CLASS (config); property_specs = g_object_class_list_properties (klass, &n_property_specs); if (! property_specs) return TRUE; scope_id = g_type_qname (G_TYPE_FROM_INSTANCE (config)); old_scope_id = g_scanner_set_scope (scanner, scope_id); for (i = 0; i < n_property_specs; i++) { GParamSpec *prop_spec = property_specs[i]; if (prop_spec->flags & GIMP_CONFIG_PARAM_SERIALIZE) { g_scanner_scope_add_symbol (scanner, scope_id, prop_spec->name, prop_spec); } } g_free (property_specs); g_object_freeze_notify (G_OBJECT (config)); token = G_TOKEN_LEFT_PAREN; while (TRUE) { next = g_scanner_peek_next_token (scanner); if (G_UNLIKELY (next != token && ! (token == G_TOKEN_SYMBOL && next == G_TOKEN_IDENTIFIER))) { break; } token = g_scanner_get_next_token (scanner); switch (token) { case G_TOKEN_LEFT_PAREN: token = G_TOKEN_SYMBOL; break; case G_TOKEN_IDENTIFIER: token = gimp_config_skip_unknown_property (scanner); break; case G_TOKEN_SYMBOL: token = gimp_config_deserialize_property (config, scanner, nest_level); break; case G_TOKEN_RIGHT_PAREN: token = G_TOKEN_LEFT_PAREN; break; default: /* do nothing */ break; } } g_scanner_set_scope (scanner, old_scope_id); g_object_thaw_notify (G_OBJECT (config)); if (token == G_TOKEN_NONE) return FALSE; return gimp_config_deserialize_return (scanner, token, nest_level); }
/** * pango_shape: * @text: the text to process * @length: the length (in bytes) of @text * @analysis: #PangoAnalysis structure from pango_itemize() * @glyphs: glyph string in which to store results * * Given a segment of text and the corresponding * #PangoAnalysis structure returned from pango_itemize(), * convert the characters into glyphs. You may also pass * in only a substring of the item from pango_itemize(). */ void pango_shape (const gchar *text, gint length, const PangoAnalysis *analysis, PangoGlyphString *glyphs) { int i; int last_cluster; glyphs->num_glyphs = 0; if (G_LIKELY (analysis->shape_engine && analysis->font)) { _pango_engine_shape_shape (analysis->shape_engine, analysis->font, text, length, analysis, glyphs); if (G_UNLIKELY (glyphs->num_glyphs == 0)) { /* If a font has been correctly chosen, but no glyphs are output, * there's probably something wrong with the shaper, or the font. * * Trying to be informative, we print out the font description, * shaper name, and the text, but to not flood the terminal with * zillions of the message, we set a flag to only err once per * font/engine pair. * * To do the flag fast, we use the engine qname to qflag the font, * but also the font description to flag the engine. This is * supposed to be fast to check, but also avoid writing out * duplicate warnings when a new PangoFont is created. */ GType engine_type = G_OBJECT_TYPE (analysis->shape_engine); GQuark warned_quark = g_type_qname (engine_type); if (!g_object_get_qdata (G_OBJECT (analysis->font), warned_quark)) { PangoFontDescription *desc; char *font_name; const char *engine_name; desc = pango_font_describe (analysis->font); font_name = pango_font_description_to_string (desc); pango_font_description_free (desc); if (!g_object_get_data (G_OBJECT (analysis->shape_engine), font_name)) { engine_name = g_type_name (engine_type); if (!engine_name) engine_name = "(unknown)"; g_warning ("shaping failure, expect ugly output. shape-engine='%s', font='%s', text='%.*s'", engine_name, font_name, length == -1 ? (gint) strlen (text) : length, text); g_object_set_data_full (G_OBJECT (analysis->shape_engine), font_name, GINT_TO_POINTER (1), NULL); } g_free (font_name); g_object_set_qdata_full (G_OBJECT (analysis->font), warned_quark, GINT_TO_POINTER (1), NULL); } } } else glyphs->num_glyphs = 0; if (!glyphs->num_glyphs) { PangoEngineShape *fallback_engine = _pango_get_fallback_shaper (); _pango_engine_shape_shape (fallback_engine, analysis->font, text, length, analysis, glyphs); } /* make sure last_cluster is invalid */ last_cluster = glyphs->log_clusters[0] - 1; for (i = 0; i < glyphs->num_glyphs; i++) { /* Set glyphs[i].attr.is_cluster_start based on log_clusters[] */ if (glyphs->log_clusters[i] != last_cluster) { glyphs->glyphs[i].attr.is_cluster_start = TRUE; last_cluster = glyphs->log_clusters[i]; } else glyphs->glyphs[i].attr.is_cluster_start = FALSE; /* Shift glyph if width is negative, and negate width. * This is useful for rotated font matrices and shouldn't * harm in normal cases. */ if (glyphs->glyphs[i].geometry.width < 0) { glyphs->glyphs[i].geometry.width = -glyphs->glyphs[i].geometry.width; glyphs->glyphs[i].geometry.x_offset += glyphs->glyphs[i].geometry.width; } } }
static void _set_name (GESTimelineElement * self, const gchar * wanted_name) { const gchar *type_name; gchar *lowcase_type; gint count; GQuark q; guint i, l; gchar *name = NULL; if (!object_name_counts) { g_datalist_init (&object_name_counts); } q = g_type_qname (G_OBJECT_TYPE (self)); count = GPOINTER_TO_INT (g_datalist_id_get_data (&object_name_counts, q)); /* GstFooSink -> foosink<N> */ type_name = g_quark_to_string (q); if (strncmp (type_name, "GES", 3) == 0) type_name += 3; lowcase_type = g_strdup (type_name); l = strlen (lowcase_type); for (i = 0; i < l; i++) lowcase_type[i] = g_ascii_tolower (lowcase_type[i]); if (wanted_name == NULL) { /* give the 20th "uriclip" element and the first "uriclip2" (if needed in the future) * different names */ l = strlen (type_name); if (l > 0 && g_ascii_isdigit (type_name[l - 1])) { name = g_strdup_printf ("%s-%d", lowcase_type, count++); } else { name = g_strdup_printf ("%s%d", lowcase_type, count++); } } else { /* If the wanted name uses the same 'namespace' as default, make * sure it does not badly interfere with our counting system */ if (g_str_has_prefix (wanted_name, lowcase_type)) { guint64 tmpcount = g_ascii_strtoull (&wanted_name[strlen (lowcase_type)], NULL, 10); if (tmpcount > count) { count = tmpcount + 1; GST_DEBUG_OBJECT (self, "Using same naming %s but updated count to %i", wanted_name, count); } else if (tmpcount < count) { name = g_strdup_printf ("%s%d", lowcase_type, count); count++; GST_DEBUG_OBJECT (self, "Name %s already allocated, giving: %s instead" " New count is %i", wanted_name, name, count); } else { count++; GST_DEBUG_OBJECT (self, "Perfect name, just bumping object count"); } } if (name == NULL) name = g_strdup (wanted_name); } g_free (lowcase_type); g_datalist_id_set_data (&object_name_counts, q, GINT_TO_POINTER (count)); g_free (self->name); self->name = name; }
static gboolean gimp_session_info_deserialize (GimpConfig *config, GScanner *scanner, gint nest_level, gpointer data) { GimpSessionInfo *info = GIMP_SESSION_INFO (config); GTokenType token; guint scope_id; guint old_scope_id; scope_id = g_type_qname (G_TYPE_FROM_INSTANCE (config)); old_scope_id = g_scanner_set_scope (scanner, scope_id); g_scanner_scope_add_symbol (scanner, scope_id, "factory-entry", GINT_TO_POINTER (SESSION_INFO_FACTORY_ENTRY)); g_scanner_scope_add_symbol (scanner, scope_id, "position", GINT_TO_POINTER (SESSION_INFO_POSITION)); g_scanner_scope_add_symbol (scanner, scope_id, "size", GINT_TO_POINTER (SESSION_INFO_SIZE)); g_scanner_scope_add_symbol (scanner, scope_id, "monitor", GINT_TO_POINTER (SESSION_INFO_MONITOR)); g_scanner_scope_add_symbol (scanner, scope_id, "open-on-exit", GINT_TO_POINTER (SESSION_INFO_OPEN)); g_scanner_scope_add_symbol (scanner, scope_id, "aux-info", GINT_TO_POINTER (SESSION_INFO_AUX)); g_scanner_scope_add_symbol (scanner, scope_id, "gimp-dock", GINT_TO_POINTER (SESSION_INFO_GIMP_DOCK)); g_scanner_scope_add_symbol (scanner, scope_id, "gimp-toolbox", GINT_TO_POINTER (SESSION_INFO_GIMP_TOOLBOX)); /* For sessionrc files from version <= GIMP 2.6 */ g_scanner_scope_add_symbol (scanner, scope_id, "dock", GINT_TO_POINTER (SESSION_INFO_DOCK)); token = G_TOKEN_LEFT_PAREN; while (g_scanner_peek_next_token (scanner) == token) { token = g_scanner_get_next_token (scanner); switch (token) { gint dummy; case G_TOKEN_LEFT_PAREN: token = G_TOKEN_SYMBOL; break; case G_TOKEN_SYMBOL: switch (GPOINTER_TO_INT (scanner->value.v_symbol)) { case SESSION_INFO_FACTORY_ENTRY: { gchar *identifier = NULL; GimpDialogFactoryEntry *entry = NULL; token = G_TOKEN_STRING; if (! gimp_scanner_parse_string (scanner, &identifier)) goto error; entry = gimp_dialog_factory_find_entry (gimp_dialog_factory_get_singleton (), identifier); if (! entry) goto error; gimp_session_info_set_factory_entry (info, entry); g_free (identifier); } break; case SESSION_INFO_POSITION: token = G_TOKEN_INT; if (! gimp_session_info_parse_offset (scanner, &info->p->x, &info->p->right_align)) goto error; if (! gimp_session_info_parse_offset (scanner, &info->p->y, &info->p->bottom_align)) goto error; break; case SESSION_INFO_SIZE: token = G_TOKEN_INT; if (! gimp_scanner_parse_int (scanner, &info->p->width)) goto error; if (! gimp_scanner_parse_int (scanner, &info->p->height)) goto error; break; case SESSION_INFO_MONITOR: token = G_TOKEN_INT; if (gimp_scanner_parse_int (scanner, &dummy)) { info->p->monitor = gdk_display_get_monitor (gdk_display_get_default (), dummy); } else goto error; break; case SESSION_INFO_OPEN: info->p->open = TRUE; /* the screen number is optional, and obsolete */ if (g_scanner_peek_next_token (scanner) == G_TOKEN_RIGHT_PAREN) break; token = G_TOKEN_INT; if (! gimp_scanner_parse_int (scanner, &dummy)) goto error; break; case SESSION_INFO_AUX: token = gimp_session_info_aux_deserialize (scanner, &info->p->aux_info); if (token != G_TOKEN_LEFT_PAREN) goto error; break; case SESSION_INFO_GIMP_TOOLBOX: case SESSION_INFO_GIMP_DOCK: case SESSION_INFO_DOCK: { GimpSessionInfoDock *dock_info = NULL; const gchar *dock_type = NULL; /* Handle old sessionrc:s from versions <= GIMP 2.6 */ if (GPOINTER_TO_INT (scanner->value.v_symbol) == SESSION_INFO_DOCK && info->p->factory_entry && info->p->factory_entry->identifier && strcmp ("gimp-toolbox-window", info->p->factory_entry->identifier) == 0) { dock_type = "gimp-toolbox"; } else { dock_type = ((GPOINTER_TO_INT (scanner->value.v_symbol) == SESSION_INFO_GIMP_TOOLBOX) ? "gimp-toolbox" : "gimp-dock"); } g_scanner_set_scope (scanner, scope_id + 1); token = gimp_session_info_dock_deserialize (scanner, scope_id + 1, &dock_info, dock_type); if (token == G_TOKEN_LEFT_PAREN) { g_scanner_set_scope (scanner, scope_id); info->p->docks = g_list_append (info->p->docks, dock_info); } else goto error; } break; default: break; } token = G_TOKEN_RIGHT_PAREN; break; case G_TOKEN_RIGHT_PAREN: token = G_TOKEN_LEFT_PAREN; break; default: break; } } error: /* If we don't have docks, assume it is a toolbox dock window from a * sessionrc file from GIMP <= 2.6 and add a toolbox dock manually */ if (! info->p->docks && info->p->factory_entry && strcmp ("gimp-toolbox-window", info->p->factory_entry->identifier) == 0) { info->p->docks = g_list_append (info->p->docks, gimp_session_info_dock_new ("gimp-toolbox")); } g_scanner_scope_remove_symbol (scanner, scope_id, "factory-entry"); g_scanner_scope_remove_symbol (scanner, scope_id, "position"); g_scanner_scope_remove_symbol (scanner, scope_id, "size"); g_scanner_scope_remove_symbol (scanner, scope_id, "open-on-exit"); g_scanner_scope_remove_symbol (scanner, scope_id, "aux-info"); g_scanner_scope_remove_symbol (scanner, scope_id, "gimp-dock"); g_scanner_scope_remove_symbol (scanner, scope_id, "gimp-toolbox"); g_scanner_scope_remove_symbol (scanner, scope_id, "dock"); g_scanner_set_scope (scanner, old_scope_id); return gimp_config_deserialize_return (scanner, token, nest_level); }