/* Builds a GList of the class structures of all subtypes of type. */ static GList * gimp_get_subtype_classes (GType type, GList *classes) { GeglOperationClass *klass; GType *ops; const gchar *categories; guint n_ops; gint i; if (! type) return classes; klass = GEGL_OPERATION_CLASS (g_type_class_ref (type)); ops = g_type_children (type, &n_ops); categories = gegl_operation_class_get_key (klass, "categories"); if (! gimp_gegl_tool_operation_blacklisted (klass->name, categories)) classes = g_list_prepend (classes, klass); for (i = 0; i < n_ops; i++) classes = gimp_get_subtype_classes (ops[i], classes); if (ops) g_free (ops); return classes; }
static void typesystem_recurse (GType type, GtkTreeIter *parent_iter, GtkTreeStore *store) { GType* children; guint n_children = 0; gint i; GtkTreeIter iter; gchar *str; gtk_tree_store_append (store, &iter, parent_iter); str = g_strdup_printf ("%ld", (glong)type); gtk_tree_store_set (store, &iter, 0, str, 1, g_type_name (type), 2, our_pixbuf, 3, 7.0, 4, (guint) 9000, 5, 'f', 6, 'g', 7, TRUE, 8, 23245454, -1); g_free (str); children = g_type_children (type, &n_children); i = 0; while (i < n_children) { typesystem_recurse (children[i], &iter, store); ++i; } g_free (children); }
static GList * gegl_operations_build (GList *list, GType type) { GeglOperationClass *klass; GType *ops; guint children; gint no; if (!type) return list; klass = g_type_class_ref (type); if (klass->name != NULL) list = g_list_prepend (list, klass); ops = g_type_children (type, &children); for (no=0; no<children; no++) { list = gegl_operations_build (list, ops[no]); } if (ops) g_free (ops); return list; }
static gboolean gtk_real_model_types_iter_next (GtkTreeModel *tree_model, GtkTreeIter *iter) { GType parent; GType type; type = GPOINTER_TO_INT (iter->user_data); parent = g_type_parent (type); if (parent == G_TYPE_INVALID) { /* find next _valid_ fundamental type */ do type++; while (!g_type_name (type) && type <= G_TYPE_FUNDAMENTAL_MAX); if (type <= G_TYPE_FUNDAMENTAL_MAX) { /* found one */ iter->user_data = GINT_TO_POINTER (type); return TRUE; } else return FALSE; } else { GType* children = g_type_children (parent, NULL); gint i = 0; g_assert (children != NULL); while (children[i] != type) ++i; ++i; if (children[i] != G_TYPE_INVALID) { g_free (children); iter->user_data = GINT_TO_POINTER (children[i]); return TRUE; } else { g_free (children); return FALSE; } } }
GObject * object_from_module (GType type, const gchar *module_dir, const gchar *module_name, const gchar *first_property_name, ...) { va_list ap; GType *filters = NULL; GType child_type = G_TYPE_INVALID; guint n_filters; const gchar *fmt; gchar *module_filename; gchar *module_path; GObject *fnval = NULL; DmapdModule *module; va_start (ap, first_property_name); if (! (fmt = find_plugin_template (type))) { g_error ("Could not find plugin template"); } /* dmapd-dmap-db-ghashtable is built in because it is used by DmapdDMAPContainerRecord: */ if (! strcmp (module_name, "ghashtable")) { g_debug ("Not loading built in %s.", g_type_name (TYPE_DMAPD_DMAP_DB_GHASHTABLE)); child_type = TYPE_DMAPD_DMAP_DB_GHASHTABLE; fnval = g_object_new_valist (child_type, first_property_name, ap); } else { module_filename = g_strdup_printf (fmt, module_name); module_path = g_module_build_path (module_dir, module_filename); module = dmapd_module_new (module_path); if (module == NULL || ! g_type_module_use (G_TYPE_MODULE (module))) { g_warning ("Error opening %s", module_path); } else { /* FIXME: free filters */ filters = g_type_children (type, &n_filters); g_assert (n_filters == 1); g_assert (g_type_is_a (filters[0], type)); child_type = filters[0]; fnval = g_object_new_valist (child_type, first_property_name, ap); } if (filters) g_free (filters); g_free (module_filename); g_free (module_path); } va_end (ap); return fnval; }
static void show_popup(cam* cam, GtkTreeView* treeview, GdkEventButton* ev) { GtkMenu* menu = GTK_MENU(gtk_menu_new()); GtkWidget* item; GtkWidget* add_filters = gtk_menu_new(); GType* filters; guint n_filters, i; GtkTreeModel* model = gtk_tree_view_get_model(treeview); GtkTreeSelection* sel = gtk_tree_view_get_selection(treeview); gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE); item = gtk_menu_item_new_with_mnemonic("_Delete"); g_signal_connect_swapped(item, "activate", G_CALLBACK(delete_filter_clicked), sel); gtk_container_add(GTK_CONTAINER(menu), item); gtk_container_add(GTK_CONTAINER(menu), gtk_separator_menu_item_new()); if(!gtk_tree_selection_count_selected_rows(sel)) { gtk_widget_set_sensitive(item, FALSE); } item = gtk_menu_item_new_with_mnemonic(_("_Add Filter")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), add_filters); gtk_container_add(GTK_CONTAINER(menu), item); filters = g_type_children(CAMORAMA_TYPE_FILTER, &n_filters); for(i = 0; i < n_filters; i++) { CamoramaFilterClass* filter_class = g_type_class_ref(filters[i]); gchar const* filter_name = filter_class->name; if(!filter_name) { filter_name = g_type_name(filters[i]); } item = gtk_menu_item_new_with_label(filter_name); g_object_set_qdata(G_OBJECT(item), menu_item_filter_type, GINT_TO_POINTER(filters[i])); g_signal_connect(item, "activate", G_CALLBACK(add_filter_clicked), model); gtk_container_add(GTK_CONTAINER(add_filters), item); g_type_class_unref(filter_class); } g_free(filters); gtk_widget_show_all(GTK_WIDGET(menu)); gtk_menu_popup(menu, NULL, NULL, menu_position_func, ev, ev ? ev->button : 0, ev ? ev->time : gtk_get_current_event_time()); }
static PyObject * _wrap_g_type_wrapper__get_children(PyGTypeWrapper *self, void *closure) { guint n_children, i; GType *children; PyObject *retval; children = g_type_children(self->type, &n_children); retval = PyList_New(n_children); for (i = 0; i < n_children; i++) PyList_SetItem(retval, i, pyg_type_wrapper_new(children[i])); g_free(children); return retval; }
static void _disable_gst_object_deep_notify_recurse (GType type) { gint i; GType *types; GObjectClass *klass = g_type_class_ref (type); klass->dispatch_properties_changed = pitivi_disable_gst_object_dispatch_properties_changed; g_type_class_unref (klass); types = g_type_children (type, NULL); for (i=0; types[i]; i++) _disable_gst_object_deep_notify_recurse (types[i]); }
static VALUE rg_children(VALUE self) { guint n_children; GType* types; VALUE result; guint i; types = g_type_children(rbgobj_gtype_get(self), &n_children); result = rb_ary_new2(n_children); for (i = 0; i < n_children; i++) rb_ary_store(result, i, rbgobj_gtype_new(types[i])); g_free(types); return result; }
static void * ruby_vips_type_map( GType base, VipsTypeMap2 fn, void *a, void *b ) { GType *child; guint n_children; unsigned int i; void *result; child = g_type_children( base, &n_children ); result = NULL; for( i = 0; i < n_children && !result; i++ ) result = fn( child[i], a, b ); g_free( child ); return( result ); }
static void show_nodes (GType type, GType sibling, const gchar *indent) { GType *children; guint i; if (!type) return; children = g_type_children (type, NULL); if (type != root) for (i = 0; i < spacing; i++) g_fprintf (f_out, "%s%s\n", indent, O_VLINE); g_fprintf (f_out, "%s%s%s%s", indent, sibling ? O_BRANCH : (type != root ? O_LLEAF : O_SPACE), O_ESPACE, g_type_name (type)); for (i = strlen (g_type_name (type)); i <= strlen (indent_inc); i++) fputs (O_KEY_FILL, f_out); fputc ('\n', f_out); if (children && recursion) { gchar *new_indent; GType *child; if (sibling) new_indent = g_strconcat (indent, O_VLINE, indent_inc, NULL); else new_indent = g_strconcat (indent, O_SPACE, indent_inc, NULL); for (child = children; *child; child++) show_nodes (child[0], child[1], new_indent); g_free (new_indent); } g_free (children); }
/** * g_socket_control_message_deserialize: * @level: a socket level * @type: a socket control message type for the given @level * @size: the size of the data in bytes * @data: pointer to the message data * * Tries to deserialize a socket control message of a given * @level and @type. This will ask all known (to GType) subclasses * of #GSocketControlMessage if they can understand this kind * of message and if so deserialize it into a #GSocketControlMessage. * * If there is no implementation for this kind of control message, %NULL * will be returned. * * Returns: the deserialized message or %NULL * * Since: 2.22 */ GSocketControlMessage * g_socket_control_message_deserialize (int level, int type, gsize size, gpointer data) { GSocketControlMessageClass *klass; GSocketControlMessage *message; GType *message_types; guint n_message_types; int i; #ifndef G_OS_WIN32 volatile GType a_type; #endif /* Ensure we know about the built in types */ #ifndef G_OS_WIN32 a_type = g_unix_fd_message_get_type (); #endif message_types = g_type_children (G_TYPE_SOCKET_CONTROL_MESSAGE, &n_message_types); message = NULL; for (i = 0; i < n_message_types; i++) { klass = (GSocketControlMessageClass *)g_type_class_ref (message_types[i]); if (klass && klass->deserialize) { message = klass->deserialize (level, type, size, data); g_type_class_unref ((GTypeClass *) klass); } if (message != NULL) break; } g_free (message_types); if (message == NULL) g_warning ("unknown control message type %d:%d", level, type); return message; }
static GtkTreePath * gtk_real_model_types_get_path (GtkTreeModel *tree_model, GtkTreeIter *iter) { GtkTreePath *retval; GType type; GType parent; g_return_val_if_fail (GTK_IS_TREE_MODEL_TYPES (tree_model), NULL); g_return_val_if_fail (iter != NULL, NULL); type = GPOINTER_TO_INT (iter->user_data); retval = gtk_tree_path_new (); parent = g_type_parent (type); while (parent != G_TYPE_INVALID) { GType* children = g_type_children (parent, NULL); gint i = 0; if (!children || children[0] == G_TYPE_INVALID) { g_warning ("bad iterator?"); return NULL; } while (children[i] != type) ++i; gtk_tree_path_prepend_index (retval, i); g_free (children); type = parent; parent = g_type_parent (parent); } /* The fundamental type itself is the index on the toplevel */ gtk_tree_path_prepend_index (retval, type); return retval; }
static gboolean gtk_real_model_types_iter_nth_child (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent, gint n) { if (parent == NULL) { /* fundamental type */ if (n < G_TYPE_FUNDAMENTAL_MAX) { iter->user_data = GINT_TO_POINTER (n); return TRUE; } else return FALSE; } else { GType type = GPOINTER_TO_INT (parent->user_data); guint n_children = 0; GType* children = g_type_children (type, &n_children); if (n_children == 0) { g_free (children); return FALSE; } else if (n >= n_children) { g_free (children); return FALSE; } else { iter->user_data = GINT_TO_POINTER (children[n]); g_free (children); return TRUE; } } }
static void gimp_color_notebook_init (GimpColorNotebook *notebook) { GType *selector_types; guint n_selector_types; guint i; notebook->notebook = gtk_notebook_new (); gtk_box_pack_start (GTK_BOX (notebook), notebook->notebook, TRUE, TRUE, 0); gtk_widget_show (notebook->notebook); gtk_notebook_popup_enable (GTK_NOTEBOOK (notebook->notebook)); g_signal_connect (notebook->notebook, "switch-page", G_CALLBACK (gimp_color_notebook_switch_page), notebook); selector_types = g_type_children (GIMP_TYPE_COLOR_SELECTOR, &n_selector_types); if (n_selector_types == 2) { gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook->notebook), FALSE); gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook->notebook), FALSE); } for (i = 0; i < n_selector_types; i++) { /* skip ourselves */ if (g_type_is_a (selector_types[i], GIMP_TYPE_COLOR_NOTEBOOK)) continue; /* skip the "Scales" color selector */ if (g_type_is_a (selector_types[i], GIMP_TYPE_COLOR_SCALES)) continue; gimp_color_notebook_add_page (notebook, selector_types[i]); } g_free (selector_types); }
static gboolean gtk_real_model_types_iter_has_child (GtkTreeModel *tree_model, GtkTreeIter *iter) { GType type; GType* children; type = GPOINTER_TO_INT (iter->user_data); children = g_type_children (type, NULL); if (!children || children[0] == G_TYPE_INVALID) { g_free (children); return FALSE; } else { g_free (children); return TRUE; } }
static void add_operations (GType parent) { GType *types; guint count; guint no; types = g_type_children (parent, &count); if (!types) return; for (no = 0; no < count; no++) { /* * Poke the operation so it registers its name with * gegl_operation_class_register_name */ g_type_class_unref (g_type_class_ref (types[no])); add_operations (types[no]); } g_free (types); }
static gint gtk_real_model_types_iter_n_children (GtkTreeModel *tree_model, GtkTreeIter *iter) { if (iter == NULL) { return G_TYPE_FUNDAMENTAL_MAX; } else { GType type; GType* children; guint n_children = 0; type = GPOINTER_TO_INT (iter->user_data); children = g_type_children (type, &n_children); g_free (children); return n_children; } }
static gboolean process_operations (GType type) { GType *operations; gboolean result = TRUE; guint count; gint i; operations = g_type_children (type, &count); if (!operations) { g_free (operations); return TRUE; } for (i = 0; i < count; i++) { GeglOperationClass *operation_class; const gchar *image, *xml, *name; gboolean matches; operation_class = g_type_class_ref (operations[i]); image = gegl_operation_class_get_key (operation_class, "reference-image"); xml = gegl_operation_class_get_key (operation_class, "reference-composition"); name = gegl_operation_class_get_key (operation_class, "name"); if (name == NULL) { result = result && process_operations (operations[i]); continue; } matches = g_regex_match (regex, name, 0, NULL) && !g_regex_match (exc_regex, name, 0, NULL); if (xml && matches) { GeglNode *composition; if (output_all) g_printf ("%s\n", name); else if (image) g_printf ("%s: ", name); /* more information will follow if we're testing */ composition = gegl_node_new_from_xml (xml, data_dir); if (!composition) { g_printf ("FAIL\n Composition graph is flawed\n"); result = FALSE; } else if (image || output_all) { gchar *output_path = operation_to_path (name, FALSE); GeglNode *output = gegl_node_new_child (composition, "operation", "gegl:png-save", "compression", 9, "path", output_path, NULL); gegl_node_link (composition, output); gegl_node_process (output); g_object_unref (composition); /* don't test if run with --all */ if (!output_all && image) result = test_operation (name, image, output_path) && result; g_free (output_path); } } /* if we are running with --all and the operation doesn't have a composition, use standard composition and images, don't test */ else if (output_all && matches && !(g_type_is_a (operations[i], GEGL_TYPE_OPERATION_SINK) || g_type_is_a (operations[i], GEGL_TYPE_OPERATION_TEMPORAL))) { g_printf ("%s\n", name); standard_output (name); } result = process_operations (operations[i]) && result; } g_free (operations); return result; }
static void gimp_controller_list_init (GimpControllerList *list) { GtkWidget *hbox; GtkWidget *sw; GtkWidget *tv; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkWidget *vbox; GtkWidget *image; GtkIconSize icon_size; gint icon_width; gint icon_height; GType *controller_types; guint n_controller_types; gint i; gtk_orientable_set_orientation (GTK_ORIENTABLE (list), GTK_ORIENTATION_VERTICAL); list->gimp = NULL; list->hbox = hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (list), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (hbox), sw, TRUE, TRUE, 0); gtk_widget_show (sw); list->src = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_GTYPE); tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list->src)); g_object_unref (list->src); gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (tv), FALSE); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Available Controllers")); gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "icon-name", COLUMN_ICON, NULL); g_object_get (cell, "stock-size", &icon_size, NULL); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", COLUMN_NAME, NULL); gtk_container_add (GTK_CONTAINER (sw), tv); gtk_widget_show (tv); g_signal_connect_object (tv, "row-activated", G_CALLBACK (gimp_controller_list_row_activated), G_OBJECT (list), 0); list->src_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tv)); gtk_tree_selection_set_mode (list->src_sel, GTK_SELECTION_BROWSE); g_signal_connect_object (list->src_sel, "changed", G_CALLBACK (gimp_controller_list_src_sel_changed), G_OBJECT (list), 0); controller_types = g_type_children (GIMP_TYPE_CONTROLLER, &n_controller_types); for (i = 0; i < n_controller_types; i++) { GimpControllerClass *controller_class; GtkTreeIter iter; controller_class = g_type_class_ref (controller_types[i]); gtk_list_store_append (list->src, &iter); gtk_list_store_set (list->src, &iter, COLUMN_ICON, controller_class->icon_name, COLUMN_NAME, controller_class->name, COLUMN_TYPE, controller_types[i], -1); g_type_class_unref (controller_class); } g_free (controller_types); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); list->add_button = gtk_button_new (); gtk_box_pack_start (GTK_BOX (vbox), list->add_button, TRUE, FALSE, 0); gtk_widget_set_sensitive (list->add_button, FALSE); gtk_widget_show (list->add_button); image = gtk_image_new_from_icon_name ("go-next", GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (list->add_button), image); gtk_widget_show (image); g_signal_connect (list->add_button, "clicked", G_CALLBACK (gimp_controller_list_add_clicked), list); g_object_add_weak_pointer (G_OBJECT (list->add_button), (gpointer) &list->add_button); list->remove_button = gtk_button_new (); gtk_box_pack_start (GTK_BOX (vbox), list->remove_button, TRUE, FALSE, 0); gtk_widget_set_sensitive (list->remove_button, FALSE); gtk_widget_show (list->remove_button); image = gtk_image_new_from_icon_name ("go-previous", GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (list->remove_button), image); gtk_widget_show (image); g_signal_connect (list->remove_button, "clicked", G_CALLBACK (gimp_controller_list_remove_clicked), list); g_object_add_weak_pointer (G_OBJECT (list->remove_button), (gpointer) &list->remove_button); gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (GTK_WIDGET (list)), icon_size, &icon_width, &icon_height); list->dest = gimp_container_tree_view_new (NULL, NULL, icon_height, 0); gimp_container_tree_view_set_main_column_title (GIMP_CONTAINER_TREE_VIEW (list->dest), _("Active Controllers")); gtk_tree_view_set_headers_visible (GIMP_CONTAINER_TREE_VIEW (list->dest)->view, TRUE); gtk_box_pack_start (GTK_BOX (list->hbox), list->dest, TRUE, TRUE, 0); gtk_widget_show (list->dest); g_signal_connect_object (list->dest, "select-item", G_CALLBACK (gimp_controller_list_select_item), G_OBJECT (list), 0); g_signal_connect_object (list->dest, "activate-item", G_CALLBACK (gimp_controller_list_activate_item), G_OBJECT (list), 0); list->edit_button = gimp_editor_add_button (GIMP_EDITOR (list->dest), "document-properties", _("Configure the selected controller"), NULL, G_CALLBACK (gimp_controller_list_edit_clicked), NULL, list); list->up_button = gimp_editor_add_button (GIMP_EDITOR (list->dest), "go-up", _("Move the selected controller up"), NULL, G_CALLBACK (gimp_controller_list_up_clicked), NULL, list); list->down_button = gimp_editor_add_button (GIMP_EDITOR (list->dest), "go-down", _("Move the selected controller down"), NULL, G_CALLBACK (gimp_controller_list_down_clicked), NULL, list); gtk_widget_set_sensitive (list->edit_button, FALSE); gtk_widget_set_sensitive (list->up_button, FALSE); gtk_widget_set_sensitive (list->down_button, FALSE); }