static GtkCssValue * gtk_css_custom_property_create_initial_value (GParamSpec *pspec) { GValue value = G_VALUE_INIT; GtkCssValue *result; g_value_init (&value, pspec->value_type); G_GNUC_BEGIN_IGNORE_DEPRECATIONS if (pspec->value_type == GTK_TYPE_THEMING_ENGINE) g_value_set_object (&value, gtk_theming_engine_load (NULL)); else if (pspec->value_type == PANGO_TYPE_FONT_DESCRIPTION) g_value_take_boxed (&value, pango_font_description_from_string ("Sans 10")); else if (pspec->value_type == GDK_TYPE_RGBA) { GdkRGBA color; gdk_rgba_parse (&color, "pink"); g_value_set_boxed (&value, &color); } else if (pspec->value_type == g_type_from_name ("GdkColor")) { GdkColor color; gdk_color_parse ("pink", &color); g_value_set_boxed (&value, &color); } else if (pspec->value_type == GTK_TYPE_BORDER) { g_value_take_boxed (&value, gtk_border_new ()); } else g_param_value_set_default (pspec, &value); G_GNUC_END_IGNORE_DEPRECATIONS result = _gtk_css_typed_value_new (&value); g_value_unset (&value); return result; }
static void load_panel_plugins (CinnamonControlCenter *shell) { GList *modules; /* only allow this function to be run once to prevent modules being loaded * twice */ if (shell->priv->extension_point) return; /* make sure the base type is registered */ g_type_from_name ("CcPanel"); shell->priv->extension_point = g_io_extension_point_register (CC_SHELL_PANEL_EXTENSION_POINT); /* load all the plugins in the panels directory */ modules = g_io_modules_load_all_in_directory (PANELS_DIR); g_list_free (modules); }
static PHP_METHOD(php_midgard_reflection_class, listSignals) { if (zend_parse_parameters_none() == FAILURE) { return; } _GET_RC_CE; if (ce == NULL) return; array_init(return_value); GType classtype = g_type_from_name(php_class_name_to_g_class_name(ce->name)); if (!classtype) { return; } guint n_ids = 0; guint *ids = g_signal_list_ids(classtype, &n_ids); if (ids == NULL) { return; } size_t i; for (i = 0; i < n_ids; i++) { zval *signalname; MAKE_STD_ZVAL(signalname); ZVAL_STRING(signalname, (char *) g_signal_name(ids[i]), 1); zend_hash_next_index_insert(HASH_OF(return_value), &signalname, sizeof(zval *), NULL); } g_free(ids); }
static void tray_widget_init_type(void) { if (widget_type != 0) return; widget_type = g_type_from_name(type_name); if (widget_type == 0) { GTypeInfo type_info; bzero(&type_info, sizeof(GTypeInfo)); type_info.class_size = sizeof(struct _tray_widget); type_info.class_init = (GClassInitFunc) tray_widget_class_init; type_info.instance_size = sizeof(struct _tray_widget_icon); type_info.instance_init = (GInstanceInitFunc) tray_widget_instance_init; widget_type = g_type_register_static(GTK_TYPE_PLUG, type_name, &type_info, 0); } else if (parent_class == NULL) tray_widget_class_init((struct _tray_widget *) g_type_class_peek(widget_type)); }
static gboolean infinoted_plugin_manager_check_session_type(InfinotedPluginInstance* instance, InfSessionProxy* proxy) { GType session_type; InfSession* session; gboolean result; if(instance->plugin->session_type == NULL) return TRUE; /* If the type was not registered yet the passed session cannot have the * correct type. */ session_type = g_type_from_name(instance->plugin->session_type); if(session_type == 0) return FALSE; g_object_get(G_OBJECT(proxy), "session", &session, NULL); result = g_type_is_a(G_TYPE_FROM_INSTANCE(session), session_type); g_object_unref(session); return result; }
GType menu_start_get_type () { static GType type = 0; type = g_type_from_name ("MenuStart"); if (!type) { static const GTypeInfo info = { sizeof (MenuStartClass), NULL, NULL, (GClassInitFunc) menu_start_class_init, NULL, NULL, sizeof (MenuStart), 0, (GInstanceInitFunc) menu_start_init, }; type = g_type_register_static (GTK_TYPE_WINDOW, "MenuStart", &info, 0); } return type; }
static void __midgard_query_storage_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { MidgardQueryStorage *self = (MidgardQueryStorage *) (object); MidgardDBObjectClass *dbklass = NULL; switch (property_id) { case MIDGARD_QUERY_STORAGE_DBCLASS: dbklass = g_type_class_peek (g_type_from_name (g_value_get_string (value))); if (dbklass) { self->priv->klass = dbklass; self->priv->classname = G_OBJECT_CLASS_NAME (G_OBJECT_CLASS (dbklass)); self->priv->table = midgard_core_class_get_table (dbklass); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (self, property_id, pspec); break; } }
/* Validable iface */ static void _midgard_query_storage_validable_iface_validate (MidgardValidable *iface, GError **error) { g_return_if_fail (iface != NULL); MidgardQueryStorage *self = MIDGARD_QUERY_STORAGE (iface); self->priv->is_valid = FALSE; if (!self->priv->classname) { g_set_error (error, MIDGARD_VALIDATION_ERROR, MIDGARD_VALIDATION_ERROR_VALUE_INVALID, "No class associated with storage"); return; } MidgardDBObjectClass *dbklass = g_type_class_peek (g_type_from_name (self->priv->classname)); if (!dbklass || (dbklass && !MIDGARD_IS_DBOBJECT_CLASS (dbklass))) { g_set_error (error, MIDGARD_VALIDATION_ERROR, MIDGARD_VALIDATION_ERROR_TYPE_INVALID, "Storage associated with class which is not DBObject derived."); return; } MIDGARD_QUERY_STORAGE (self)->priv->is_valid = TRUE; return; }
static gboolean _remove_asset (GstValidateScenario *scenario, GstValidateAction *action) { const gchar *id = NULL; const gchar *type_string = NULL; GType type; GESTimeline *timeline = get_timeline(scenario); GESProject *project = ges_timeline_get_project(timeline); GESAsset *asset; gboolean res = FALSE; id = gst_structure_get_string (action->structure, "id"); type_string = gst_structure_get_string (action->structure, "type"); if (!type_string || !id) { GST_ERROR("Missing parameters, we got type %s and id %s", type_string, id); goto beach; } if (!(type = g_type_from_name(type_string))) { GST_ERROR("This type doesn't exist : %s", type_string); goto beach; } asset = ges_project_get_asset(project, id, type); if (!asset) { GST_ERROR("No asset with id %s and type %s", id, type_string); goto beach; } res = ges_project_remove_asset(project, asset); beach: g_object_unref(timeline); return res; }
static GwySelection* gwyfile_gather_old_point_selection(GwyContainer *data) { GwySelection *sel; GType type; gint i, nselected; gdouble xy[2]; gchar key[40]; type = g_type_from_name("GwySelectionPoint"); if (!type || !gwy_container_gis_int32_by_name(data, "/0/select/points/nselected", &nselected)) return NULL; nselected = CLAMP(nselected, 0, 16); if (!nselected) return NULL; sel = GWY_SELECTION(g_object_new(type, "max-objects", nselected, NULL)); for (i = 0; i < nselected; i++) { g_snprintf(key, sizeof(key), "/0/select/points/%d/x", i); if (!gwy_container_gis_double_by_name(data, key, &xy[0])) break; g_snprintf(key, sizeof(key), "/0/select/points/%d/y", i); if (!gwy_container_gis_double_by_name(data, key, &xy[1])) break; gwy_selection_set_object(sel, i, xy); } if (!i) gwy_object_unref(sel); return sel; }
/** * g_pointer_type_register_static: * @name: the name of the new pointer type. * * Creates a new %G_TYPE_POINTER derived type id for a new * pointer type with name @name. * * Returns: a new %G_TYPE_POINTER derived type id for @name. */ GType g_pointer_type_register_static (const gchar *name) { static const GTypeInfo type_info = { 0, /* class_size */ NULL, /* base_init */ NULL, /* base_finalize */ NULL, /* class_init */ NULL, /* class_finalize */ NULL, /* class_data */ 0, /* instance_size */ 0, /* n_preallocs */ NULL, /* instance_init */ NULL /* value_table */ }; GType type; g_return_val_if_fail (name != NULL, 0); g_return_val_if_fail (g_type_from_name (name) == 0, 0); type = g_type_register_static (G_TYPE_POINTER, name, &type_info, 0); return type; }
GType egg_tray_icon_get_type (void) { static GType our_type = 0; if (our_type == 0) { our_type = g_type_from_name("EggTrayIcon"); if (our_type == 0) { static const GTypeInfo our_info = { sizeof (EggTrayIconClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) egg_tray_icon_class_init, NULL, /* class_finalize */ NULL, /* class_data */ sizeof (EggTrayIcon), 0, /* n_preallocs */ (GInstanceInitFunc) egg_tray_icon_init, NULL /* value_table */ }; our_type = g_type_register_static (GTK_TYPE_PLUG, "EggTrayIcon", &our_info, 0); } else if (parent_class == NULL) { /* we're reheating the old class from a previous instance - engage ugly hack =( */ egg_tray_icon_class_init((EggTrayIconClass *)g_type_class_peek(our_type)); } } return our_type; }
GType lgi_type_get_gtype (lua_State *L, int narg) { /* Handle simple cases natively, forward to Lua implementation for the rest. */ switch (lua_type (L, narg)) { case LUA_TNIL: case LUA_TNONE: return G_TYPE_INVALID; case LUA_TNUMBER: return lua_tonumber (L, narg); case LUA_TLIGHTUSERDATA: return (GType) lua_touserdata (L, narg); case LUA_TSTRING: return g_type_from_name (lua_tostring (L, narg)); case LUA_TTABLE: { GType gtype; lgi_makeabs (L, narg); lua_pushstring (L, "_gtype"); lua_rawget (L, narg); gtype = lgi_type_get_gtype (L, -1); lua_pop (L, 1); return gtype; } default: return luaL_error (L, "GType expected, got %s", lua_typename (L, lua_type (L, narg))); } }
GType calf_keyboard_get_type (void) { static GType type = 0; if (!type) { static const GTypeInfo type_info = { sizeof(CalfKeyboardClass), NULL, /* base_init */ NULL, /* base_finalize */ (GClassInitFunc)calf_keyboard_class_init, NULL, /* class_finalize */ NULL, /* class_data */ sizeof(CalfKeyboard), 0, /* n_preallocs */ (GInstanceInitFunc)calf_keyboard_init }; for (int i = 0; ; i++) { const char *name = "CalfKeyboard"; //char *name = g_strdup_printf("CalfKeyboard%u%d", //((unsigned int)(intptr_t)calf_keyboard_class_init) >> 16, i); if (g_type_from_name(name)) { //free(name); continue; } type = g_type_register_static(GTK_TYPE_WIDGET, name, &type_info, (GTypeFlags)0); //free(name); break; } } return type; }
GType calf_vumeter_get_type (void) { static GType type = 0; if (!type) { static const GTypeInfo type_info = { sizeof(CalfVUMeterClass), NULL, /* base_init */ NULL, /* base_finalize */ (GClassInitFunc)calf_vumeter_class_init, NULL, /* class_finalize */ NULL, /* class_data */ sizeof(CalfVUMeter), 0, /* n_preallocs */ (GInstanceInitFunc)calf_vumeter_init }; GTypeInfo *type_info_copy = new GTypeInfo(type_info); for (int i = 0; ; i++) { const char *name = "CalfVUMeter"; //char *name = g_strdup_printf("CalfVUMeter%u%d", ((unsigned int)(intptr_t)calf_vumeter_class_init) >> 16, i); if (g_type_from_name(name)) { //free(name); continue; } type = g_type_register_static( GTK_TYPE_DRAWING_AREA, name, type_info_copy, (GTypeFlags)0); //free(name); break; } } return type; }
static void facets_dialog(FacetsArgs *args, GwyContainer *data, GwyContainer *fdata, GwyDataField *dfield, GwyDataField *mfield, gint id, GQuark mquark) { GtkWidget *dialog, *table, *hbox, *hbox2, *vbox, *label, *scale, *button; GtkWidget *spin; FacetsControls controls; enum { RESPONSE_RESET = 1, RESPONSE_PREVIEW = 2 }; gint response; GwyPixmapLayer *layer; GwyVectorLayer *vlayer; GwySelection *selection; gint row; memset(&controls, 0, sizeof(FacetsControls)); controls.args = args; dialog = gtk_dialog_new_with_buttons(_("Mark Facets"), NULL, GTK_DIALOG_DESTROY_WITH_PARENT, _("_Mark"), RESPONSE_PREVIEW, _("_Reset"), RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); controls.dialog = dialog; /* Shallow-copy stuff to temporary container */ controls.fdata = fdata; controls.mydata = gwy_container_new(); gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield); gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE, GWY_DATA_ITEM_PALETTE, GWY_DATA_ITEM_RANGE, GWY_DATA_ITEM_MASK_COLOR, GWY_DATA_ITEM_REAL_SQUARE, 0); hbox = gtk_hbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 4); controls.view = gwy_data_view_new(controls.mydata); layer = gwy_layer_basic_new(); g_object_set(layer, "data-key", "/0/data", "gradient-key", "/0/base/palette", "range-type-key", "/0/base/range-type", "min-max-key", "/0/base", NULL); gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.view), "/0/data"); gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer); gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE); vlayer = g_object_new(g_type_from_name("GwyLayerPoint"), NULL); gwy_vector_layer_set_selection_key(vlayer, "/0/select/pointer"); gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.view), vlayer); selection = gwy_vector_layer_ensure_selection(vlayer); g_signal_connect(selection, "changed", G_CALLBACK(preview_selection_updated), &controls); gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4); vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0); hbox2 = gtk_hbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0); /* Slope view */ controls.fview = gwy_data_view_new(controls.fdata); gtk_box_pack_start(GTK_BOX(hbox2), controls.fview, FALSE, FALSE, 0); layer = gwy_layer_basic_new(); gwy_pixmap_layer_set_data_key(layer, "/0/data"); gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/0/base/palette"); gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.fview), layer); vlayer = g_object_new(g_type_from_name("GwyLayerPoint"), NULL); gwy_vector_layer_set_selection_key(vlayer, "/0/select/pointer"); gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.fview), GWY_VECTOR_LAYER(vlayer)); selection = gwy_vector_layer_ensure_selection(vlayer); g_signal_connect(selection, "changed", G_CALLBACK(facet_view_selection_updated), &controls); /* Info table */ table = gtk_table_new(7, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(hbox2), table, TRUE, TRUE, 4); row = 0; label = gwy_label_new_header(gwy_sgettext("noun|Normal")); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row+1, GTK_FILL, 0, 0, 0); row++; controls.theta_label = add_angle_label(table, _("θ:"), &row); controls.phi_label = add_angle_label(table, _("φ:"), &row); button = gtk_button_new_with_mnemonic(_("_Find Maximum")); gtk_table_attach(GTK_TABLE(table), button, 0, 2, row, row+1, GTK_FILL, 0, 0, 0); g_signal_connect_swapped(button, "clicked", G_CALLBACK(facet_view_reset_maximum), &controls); gtk_table_set_row_spacing(GTK_TABLE(table), row, 8); row++; label = gwy_label_new_header(_("Mean Normal")); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row+1, GTK_FILL, 0, 0, 0); row++; controls.mtheta_label = add_angle_label(table, _("θ:"), &row); controls.mphi_label = add_angle_label(table, _("φ:"), &row); gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8); label = gtk_label_new_with_mnemonic(_("Facet plane size:")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row+1, GTK_FILL, 0, 0, 0); row++; controls.kernel_size = gtk_adjustment_new(args->kernel_size, 0.0, MAX_PLANE_SIZE, 1.0, 1.0, 0); spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.kernel_size), 0.0, 0); gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin); gtk_table_attach(GTK_TABLE(table), spin, 0, 1, row, row+1, 0, 0, 0, 0); g_signal_connect(controls.kernel_size, "value-changed", G_CALLBACK(facet_view_recompute), &controls); row++; table = gtk_table_new(9, 4, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 4); row = 0; controls.tolerance = gtk_adjustment_new(args->tolerance*180.0/G_PI, 0.0, 15.0, 0.01, 0.1, 0); scale = gwy_table_attach_hscale(table, row++, _("_Tolerance:"), _("deg"), controls.tolerance, 0); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(scale), 3); g_signal_connect(controls.tolerance, "value-changed", G_CALLBACK(facets_tolerance_changed), &controls); controls.color_button = gwy_color_button_new(); gwy_color_button_set_use_alpha(GWY_COLOR_BUTTON(controls.color_button), TRUE); load_mask_color(controls.color_button, gwy_data_view_get_data(GWY_DATA_VIEW(controls.view))); gwy_table_attach_hscale(table, row++, _("_Mask color:"), NULL, GTK_OBJECT(controls.color_button), GWY_HSCALE_WIDGET_NO_EXPAND); g_signal_connect(controls.color_button, "clicked", G_CALLBACK(mask_color_change_cb), &controls); if (!gwy_si_unit_equal(gwy_data_field_get_si_unit_xy(dfield), gwy_data_field_get_si_unit_z(dfield))) { gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8); label = gtk_label_new(_("Warning: Lateral and value units differ. " "Angles are not physically meaningful.")); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; } facets_invalidate(&controls); gtk_widget_show_all(dialog); facet_view_select_angle(&controls, args->theta0, args->phi0); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: g_object_unref(controls.mydata); return; break; case GTK_RESPONSE_OK: break; case RESPONSE_RESET: args->tolerance = facets_defaults.tolerance; args->kernel_size = facets_defaults.kernel_size; facets_dialog_update_controls(&controls, args); break; case RESPONSE_PREVIEW: preview(&controls, args); update_average_angle(&controls, args); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE, GWY_DATA_ITEM_MASK_COLOR, 0); gtk_widget_destroy(dialog); if (controls.computed) { mfield = gwy_container_get_object_by_name(controls.mydata, "/0/mask"); gwy_app_undo_qcheckpointv(data, 1, &mquark); gwy_container_set_object(data, mquark, mfield); g_object_unref(controls.mydata); } else { g_object_unref(controls.mydata); run_noninteractive(args, data, fdata, dfield, mfield, mquark); } }
/* 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 __midgard_connection_open( MidgardConnection *mgd, GHashTable **hashtable, gboolean init_schema) { g_return_val_if_fail(mgd != NULL, FALSE); MIDGARD_ERRNO_SET (mgd, MGD_ERR_OK); gchar *host, *dbname, *dbuser, *dbpass, *loglevel, *tmpstr; guint port = 0; gchar *auth = NULL; MidgardConfig *config = mgd->priv->config; host = config->host; dbname = config->database; dbuser = config->dbuser; dbpass = config->dbpass; loglevel = config->loglevel; port = config->dbport; gboolean enable_threads = config->gdathreads; /* Get 30% performance boost for non threaded applications */ if(!enable_threads) g_setenv("LIBGDA_NO_THREADS", "yes", TRUE); /* Initialize libgda */ gda_init (); midgard_connection_set_loglevel(mgd, loglevel, NULL); if(config->priv->dbtype == MIDGARD_DB_TYPE_SQLITE) { gchar *path = NULL; gchar *dbdir = config->dbdir; if (!dbdir || *dbdir == '\0') { const gchar *sqlite_dir[] = {"data", NULL}; path = midgard_core_config_build_path(sqlite_dir, NULL, TRUE); } else { path = g_strdup(dbdir); } tmpstr = g_strconcat("DB_DIR=", path, ";", "DB_NAME=", dbname, NULL); g_free(path); } else if (config->priv->dbtype == MIDGARD_DB_TYPE_ORACLE) { GString *cnc = g_string_sized_new(100); cnc_add_part(cnc, "TNSNAME", dbname, MGD_MYSQL_HOST); cnc_add_part(cnc, "HOST", host, MGD_MYSQL_HOST); cnc_add_part(cnc, "DB_NAME", dbname, MGD_MYSQL_DATABASE); tmpstr = g_string_free(cnc, FALSE); cnc = g_string_sized_new(100); cnc_add_part(cnc, "USERNAME", dbuser, MGD_MYSQL_USERNAME); cnc_add_part(cnc, "PASSWORD", dbpass, MGD_MYSQL_PASSWORD); auth = g_string_free(cnc, FALSE); } else { GString *cnc = g_string_sized_new(100); cnc_add_part(cnc, "HOST", host, MGD_MYSQL_HOST); if (port > 0) { GString *_strp = g_string_new(""); g_string_append_printf (_strp, "%d", port); cnc_add_part (cnc, "PORT", _strp->str, ""); g_string_free (_strp, TRUE); } cnc_add_part(cnc, "DB_NAME", dbname, MGD_MYSQL_DATABASE); tmpstr = g_string_free(cnc, FALSE); GString *auth_str = g_string_sized_new(100); cnc_add_part(auth_str, "USERNAME", dbuser, MGD_MYSQL_USERNAME); cnc_add_part(auth_str, "PASSWORD", dbpass, MGD_MYSQL_PASSWORD); auth = g_string_free(auth_str, FALSE); } GError *error = NULL; GdaConnection *connection = gda_connection_open_from_string( config->dbtype, tmpstr, auth, GDA_CONNECTION_OPTIONS_NONE, &error); g_free(auth); if(connection == NULL) { MIDGARD_ERRNO_SET_STRING (mgd, MGD_ERR_NOT_CONNECTED, " Database [%s]. %s", tmpstr, error->message); g_free(tmpstr); return FALSE; } g_free(tmpstr); mgd->priv->parser = gda_connection_create_parser (connection); if (!mgd->priv->parser) mgd->priv->parser = gda_sql_parser_new(); g_assert (mgd->priv->parser != NULL); mgd->priv->connection = connection; midgard_core_connection_connect_error_callback (mgd); if(init_schema) { if(!g_type_from_name("midgard_quota")) { MidgardSchema *schema = g_object_new(MIDGARD_TYPE_SCHEMA, NULL); gchar *path = g_build_path(G_DIR_SEPARATOR_S, config->sharedir, "MidgardObjects.xml", NULL); midgard_schema_init(schema, (const gchar *)path); g_free(path); midgard_schema_read_dir(schema, config->sharedir); mgd->priv->schema = schema; } } //midgard_connection_set_loglevel(mgd, loglevel, NULL); /* Loads available authentication types */ midgard_core_connection_initialize_auth_types(mgd); g_signal_emit (mgd, MIDGARD_CONNECTION_GET_CLASS (mgd)->signal_id_connected, 0); return TRUE; }
static void gupnp_dlna_discoverer_class_init (GUPnPDLNADiscovererClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GParamSpec *pspec; g_type_class_add_private (klass, sizeof (GUPnPDLNADiscovererPrivate)); object_class->get_property = gupnp_dlna_discoverer_get_property; object_class->set_property = gupnp_dlna_discoverer_set_property; object_class->dispose = gupnp_dlna_discoverer_dispose; object_class->finalize = gupnp_dlna_discoverer_finalize; /** * GUPnPDLNADiscoverer::relaxed-mode: * @relaxed_mode: setting to true will enable relaxed mode * * The current release does not support relaxed mode yet */ pspec = g_param_spec_boolean ("relaxed-mode", "Relaxed mode property", "Indicates that profile matching should" "be strictly compliant with the DLNA " "specification", FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY); g_object_class_install_property (object_class, PROP_DLNA_RELAXED_MODE, pspec); /** * GUPnPDLNADiscoverer::extended-mode: * @extended: setting true will enable extended profile support * * The current release does not support extended mode yet */ pspec = g_param_spec_boolean ("extended-mode", "Extended mode property", "Indicates support for profiles that are " "not part of the DLNA specification", FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY); g_object_class_install_property (object_class, PROP_DLNA_EXTENDED_MODE, pspec); /** * GUPnPDLNADiscoverer::done: * @discoverer: the #GUPnPDLNADiscoverer * @dlna: the results as #GUPnPDLNAInformation * @err: contains details of the error if discovery fails, else is NULL * * Will be emitted when all information on a URI could be discovered. * * The reciever must unref @dlna with when done using it. */ signals[DONE] = g_signal_new ("done", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GUPnPDLNADiscovererClass, done), NULL, NULL, gupnp_dlna_marshal_VOID__OBJECT_BOXED, G_TYPE_NONE, 2, GUPNP_TYPE_DLNA_INFORMATION, GST_TYPE_G_ERROR); /* Load DLNA profiles from disk */ if (g_type_from_name ("GstElement")) { klass->profiles_list [0][0] = gupnp_dlna_load_profiles_from_disk (FALSE, FALSE); klass->profiles_list [0][1] = gupnp_dlna_load_profiles_from_disk (FALSE, TRUE); klass->profiles_list [1][0] = gupnp_dlna_load_profiles_from_disk (TRUE, FALSE); klass->profiles_list [1][1] = gupnp_dlna_load_profiles_from_disk (TRUE, TRUE); } else { klass->profiles_list [0][0] = NULL; klass->profiles_list [0][1] = NULL; klass->profiles_list [1][0] = NULL; klass->profiles_list [1][1] = NULL; g_warning ("GStreamer has not yet been initialised. You need " "to call gst_init()/gst_init_check() for discovery " "to work."); } }
/* transfer and may_be_null can be gotten from arg_info, but sv_to_arg is also * called from places which don't have access to a GIArgInfo. */ static void sv_to_arg (SV * sv, GIArgument * arg, GIArgInfo * arg_info, GITypeInfo * type_info, GITransfer transfer, gboolean may_be_null, GPerlI11nInvocationInfo * invocation_info) { GITypeTag tag = g_type_info_get_tag (type_info); if (!gperl_sv_is_defined (sv)) /* Interfaces and void types need to be able to handle undef * separately. */ if (!may_be_null && tag != GI_TYPE_TAG_INTERFACE && tag != GI_TYPE_TAG_VOID) { if (arg_info) { ccroak ("undefined value for mandatory argument '%s' encountered", g_base_info_get_name ((GIBaseInfo *) arg_info)); } else { ccroak ("undefined value encountered"); } } switch (tag) { case GI_TYPE_TAG_VOID: /* returns NULL if no match is found */ arg->v_pointer = sv_to_callback_data (sv, invocation_info); break; case GI_TYPE_TAG_BOOLEAN: arg->v_boolean = SvTRUE (sv); break; case GI_TYPE_TAG_INT8: arg->v_int8 = (gint8) SvIV (sv); break; case GI_TYPE_TAG_UINT8: arg->v_uint8 = (guint8) SvUV (sv); break; case GI_TYPE_TAG_INT16: arg->v_int16 = (gint16) SvIV (sv); break; case GI_TYPE_TAG_UINT16: arg->v_uint16 = (guint16) SvUV (sv); break; case GI_TYPE_TAG_INT32: arg->v_int32 = (gint32) SvIV (sv); break; case GI_TYPE_TAG_UINT32: arg->v_uint32 = (guint32) SvUV (sv); break; case GI_TYPE_TAG_INT64: arg->v_int64 = SvGInt64 (sv); break; case GI_TYPE_TAG_UINT64: arg->v_uint64 = SvGUInt64 (sv); break; case GI_TYPE_TAG_FLOAT: arg->v_float = (gfloat) SvNV (sv); break; case GI_TYPE_TAG_DOUBLE: arg->v_double = SvNV (sv); break; case GI_TYPE_TAG_UNICHAR: arg->v_uint32 = g_utf8_get_char (SvGChar (sv)); break; case GI_TYPE_TAG_GTYPE: /* GType == gsize */ arg->v_size = gperl_type_from_package (SvPV_nolen (sv)); if (!arg->v_size) arg->v_size = g_type_from_name (SvPV_nolen (sv)); break; case GI_TYPE_TAG_ARRAY: arg->v_pointer = sv_to_array (transfer, type_info, sv, invocation_info); break; case GI_TYPE_TAG_INTERFACE: dwarn (" type %p -> interface\n", type_info); sv_to_interface (arg_info, type_info, transfer, may_be_null, sv, arg, invocation_info); break; case GI_TYPE_TAG_GLIST: case GI_TYPE_TAG_GSLIST: arg->v_pointer = sv_to_glist (transfer, type_info, sv); break; case GI_TYPE_TAG_GHASH: arg->v_pointer = sv_to_ghash (transfer, type_info, sv); break; case GI_TYPE_TAG_ERROR: ccroak ("FIXME - A GError as an in/inout arg? Should never happen!"); break; case GI_TYPE_TAG_UTF8: arg->v_string = gperl_sv_is_defined (sv) ? SvGChar (sv) : NULL; if (transfer >= GI_TRANSFER_CONTAINER) arg->v_string = g_strdup (arg->v_string); break; case GI_TYPE_TAG_FILENAME: /* FIXME: Should we use SvPVbyte_nolen here? */ arg->v_string = gperl_sv_is_defined (sv) ? SvPV_nolen (sv) : NULL; if (transfer >= GI_TRANSFER_CONTAINER) arg->v_string = g_strdup (arg->v_string); break; default: ccroak ("Unhandled info tag %d in sv_to_arg", tag); } }
GType peas_extension_register_subclass (GType parent_type, GType *extension_types) { guint i; GString *type_name; GType the_type; type_name = g_string_new (g_type_name (parent_type)); for (i = 0; extension_types[i] != 0; ++i) { /* Use something that is not allowed in symbol names */ g_string_append_c (type_name, '+'); g_string_append (type_name, g_type_name (extension_types[i])); } the_type = g_type_from_name (type_name->str); if (the_type == G_TYPE_INVALID) { GTypeQuery query; GTypeInfo type_info = { 0, (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) extension_subclass_init, (GClassFinalizeFunc) NULL, g_memdup (extension_types, sizeof (GType) * (i + 1)), 0, 0, (GInstanceInitFunc) extension_subclass_instance_init, NULL }; GInterfaceInfo iface_info = { (GInterfaceInitFunc) implement_interface_methods, (GInterfaceFinalizeFunc) NULL, NULL }; g_debug ("Registering new type '%s'", type_name->str); g_type_query (parent_type, &query); type_info.class_size = query.class_size; type_info.instance_size = query.instance_size; the_type = g_type_register_static (parent_type, type_name->str, &type_info, 0); iface_info.interface_data = GSIZE_TO_POINTER (the_type); for (i = 0; extension_types[i] != 0; ++i) g_type_add_interface_static (the_type, extension_types[i], &iface_info); } /* Must be done outside of type registration * in the event that the same type is requested again. */ for (i = 0; extension_types[i] != 0; ++i) { if (!g_type_is_a (the_type, extension_types[i])) { g_warning ("Type '%s' is invalid", type_name->str); the_type = G_TYPE_INVALID; break; } } g_string_free (type_name, TRUE); return the_type; }
static void populate_colors (GtkWidget *widget) { struct { const gchar *name; const gchar *color; const gchar *title; } colors[] = { { "2.5", "#C8828C", "Red" }, { "5", "#C98286", NULL }, { "7.5", "#C9827F", NULL }, { "10", "#C98376", NULL }, { "2.5", "#C8856D", "Red/Yellow" }, { "5", "#C58764", NULL }, { "7.5", "#C1895E", NULL }, { "10", "#BB8C56", NULL }, { "2.5", "#B58F4F", "Yellow" }, { "5", "#AD924B", NULL }, { "7.5", "#A79548", NULL }, { "10", "#A09749", NULL }, { "2.5", "#979A4E", "Yellow/Green" }, { "5", "#8D9C55", NULL }, { "7.5", "#7F9F62", NULL }, { "10", "#73A06E", NULL }, { "2.5", "#65A27C", "Green" }, { "5", "#5CA386", NULL }, { "7.5", "#57A38D", NULL }, { "10", "#52A394", NULL }, { "2.5", "#4EA39A", "Green/Blue" }, { "5", "#49A3A2", NULL }, { "7.5", "#46A2AA", NULL }, { "10", "#46A1B1", NULL }, { "2.5", "#49A0B8", "Blue" }, { "5", "#529EBD", NULL }, { "7.5", "#5D9CC1", NULL }, { "10", "#689AC3", NULL }, { "2.5", "#7597C5", "Blue/Purple" }, { "5", "#8095C6", NULL }, { "7.5", "#8D91C6", NULL }, { "10", "#988EC4", NULL }, { "2.5", "#A08CC1", "Purple" }, { "5", "#A88ABD", NULL }, { "7.5", "#B187B6", NULL }, { "10", "#B786B0", NULL }, { "2.5", "#BC84A9", "Purple/Red" }, { "5", "#C183A0", NULL }, { "7.5", "#C48299", NULL }, { "10", "#C68292", NULL } }; gint i; GtkWidget *row, *box, *label, *swatch; GtkWidget *sw; GdkRGBA rgba; gtk_list_box_set_header_func (GTK_LIST_BOX (widget), update_title_header, NULL, NULL); for (i = 0; i < G_N_ELEMENTS (colors); i++) { row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 20); label = gtk_label_new (colors[i].name); g_object_set (label, "halign", GTK_ALIGN_START, "valign", GTK_ALIGN_CENTER, "margin", 6, "xalign", 0.0, NULL); gtk_box_pack_start (GTK_BOX (row), label, TRUE, TRUE, 0); gdk_rgba_parse (&rgba, colors[i].color); swatch = g_object_new (g_type_from_name ("GtkColorSwatch"), "rgba", &rgba, "selectable", FALSE, "halign", GTK_ALIGN_END, "valign", GTK_ALIGN_CENTER, "margin", 6, "height-request", 24, NULL); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_add (GTK_CONTAINER (box), swatch); gtk_box_pack_start (GTK_BOX (row), box, FALSE, FALSE, 0); gtk_widget_show_all (row); gtk_list_box_insert (GTK_LIST_BOX (widget), row, -1); row = gtk_widget_get_parent (row); gtk_list_box_row_set_activatable (GTK_LIST_BOX_ROW (row), FALSE); if (colors[i].title) g_object_set_data (G_OBJECT (row), "title", (gpointer)colors[i].title); } gtk_list_box_invalidate_headers (GTK_LIST_BOX (widget)); sw = gtk_widget_get_ancestor (widget, GTK_TYPE_SCROLLED_WINDOW); g_signal_connect (sw, "edge-overshot", G_CALLBACK (overshot), widget); }
GType pyg_type_from_object_strict(PyObject *obj, gboolean strict) { PyObject *gtype; GType type; /* NULL check */ if (!obj) { PyErr_SetString(PyExc_TypeError, "can't get type from NULL object"); return 0; } /* map some standard types to primitive GTypes ... */ if (obj == Py_None) return G_TYPE_NONE; if (PyType_Check(obj)) { PyTypeObject *tp = (PyTypeObject *)obj; if (tp == &PYGLIB_PyLong_Type) return G_TYPE_INT; else if (tp == &PyBool_Type) return G_TYPE_BOOLEAN; else if (tp == &PyLong_Type) return G_TYPE_LONG; else if (tp == &PyFloat_Type) return G_TYPE_DOUBLE; else if (tp == &PYGLIB_PyUnicode_Type) return G_TYPE_STRING; else if (tp == &PyBaseObject_Type) return PY_TYPE_OBJECT; } if (Py_TYPE(obj) == &PyGTypeWrapper_Type) { return ((PyGTypeWrapper *)obj)->type; } /* handle strings */ if (PYGLIB_PyUnicode_Check(obj)) { gchar *name = PYGLIB_PyUnicode_AsString(obj); type = g_type_from_name(name); if (type != 0) { return type; } } /* finally, look for a __gtype__ attribute on the object */ gtype = PyObject_GetAttrString(obj, "__gtype__"); if (gtype) { if (Py_TYPE(gtype) == &PyGTypeWrapper_Type) { type = ((PyGTypeWrapper *)gtype)->type; Py_DECREF(gtype); return type; } Py_DECREF(gtype); } PyErr_Clear(); /* Some API like those that take GValues can hold a python object as * a pointer. This is potentially dangerous becuase everything is * passed in as a PyObject so we can't actually type check it. Only * fallback to PY_TYPE_OBJECT if strict checking is disabled */ if (!strict) return PY_TYPE_OBJECT; PyErr_SetString(PyExc_TypeError, "could not get typecode from object"); return 0; }
static void overshot (GtkScrolledWindow *sw, GtkPositionType pos, GtkWidget *widget) { GtkWidget *box, *row, *label, *swatch; GdkRGBA rgba; const gchar *color; gchar *text; GtkWidget *silver; GtkWidget *gold; silver = GTK_WIDGET (g_object_get_data (G_OBJECT (widget), "Silver")); gold = GTK_WIDGET (g_object_get_data (G_OBJECT (widget), "Gold")); if (pos == GTK_POS_TOP) { if (silver) { gtk_container_remove (GTK_CONTAINER (widget), silver); g_object_set_data (G_OBJECT (widget), "Silver", NULL); } if (gold) { gtk_container_remove (GTK_CONTAINER (widget), gold); g_object_set_data (G_OBJECT (widget), "Gold", NULL); } #ifdef HAVE_LIBCANBERRA if (silver || gold) ca_gtk_play_for_widget (widget, 0, "event.id", "message", NULL); #endif return; } if (gold) return; else if (silver) color = "Gold"; else color = "Silver"; row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 20); text = g_strconcat ("<b>", color, "</b>", NULL); label = gtk_label_new (text); g_free (text); g_object_set (label, "use-markup", TRUE, "halign", GTK_ALIGN_START, "valign", GTK_ALIGN_CENTER, "margin", 6, "xalign", 0.0, NULL); gtk_box_pack_start (GTK_BOX (row), label, TRUE, TRUE, 0); gdk_rgba_parse (&rgba, color); swatch = g_object_new (g_type_from_name ("GtkColorSwatch"), "rgba", &rgba, "selectable", FALSE, "halign", GTK_ALIGN_END, "valign", GTK_ALIGN_CENTER, "margin", 6, "height-request", 24, NULL); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_add (GTK_CONTAINER (box), swatch); gtk_box_pack_start (GTK_BOX (row), box, FALSE, FALSE, 0); gtk_widget_show_all (row); gtk_list_box_insert (GTK_LIST_BOX (widget), row, -1); row = gtk_widget_get_parent (row); gtk_list_box_row_set_activatable (GTK_LIST_BOX_ROW (row), FALSE); g_object_set_data (G_OBJECT (widget), color, row); #ifdef HAVE_LIBCANBERRA ca_gtk_play_for_widget (widget, 0, "event.id", "complete", NULL); #endif }
GType gsk_load_type_introspective (const char *type_name, gpointer unused, GError **error) { static gboolean self_inited = FALSE; static GModule *self_module = NULL; guint index = 0; GType type; GString *func_name; gpointer symbol; (void) unused; type = g_type_from_name (type_name); if (type != G_TYPE_INVALID) return type; /* Transform `GObject' into `g_object_get_type', * which should be a function that returns a GType, * if we're lucky... */ func_name = g_string_new (""); while (type_name[index] != '\0') { if ('A' <= type_name[index] && type_name[index] <= 'Z') { if (index > 0) g_string_append_c (func_name, '_'); g_string_append_c (func_name, g_ascii_tolower (type_name[index])); } else g_string_append_c (func_name, type_name[index]); ++index; } g_string_append (func_name, "_get_type"); if (!self_inited) { self_inited = TRUE; self_module = g_module_open (NULL, G_MODULE_BIND_LAZY); if (self_module == NULL) { g_set_error (error, GSK_G_ERROR_DOMAIN, GSK_ERROR_UNKNOWN, "g_module_open: %s", g_module_error ()); goto DONE; } } if (g_module_symbol (self_module, func_name->str, &symbol)) { GType (*func) () = (GType (*)()) symbol; const char *name; GTypeClass *klass; type = (*func) (); name = g_type_name (type); if (name == NULL) { g_set_error (error, GSK_G_ERROR_DOMAIN, GSK_ERROR_UNKNOWN, "called %s, didn't get a valid GType", func_name->str); type = G_TYPE_INVALID; goto DONE; } if (strcmp (name, type_name) != 0) { g_set_error (error, GSK_G_ERROR_DOMAIN, GSK_ERROR_UNKNOWN, "called %s: got %s instead of %s", func_name->str, name, type_name); type = G_TYPE_INVALID; goto DONE; } /* Sometimes the registrations in the class_init are vital. */ klass = g_type_class_ref (type); g_type_class_unref (klass); } else { g_set_error (error, GSK_G_ERROR_DOMAIN, GSK_ERROR_UNKNOWN, "couldn't find symbol %s: %s", func_name->str, g_module_error ()); } DONE: g_string_free (func_name, TRUE); return type; }
/** * gutachter_lookup_child: * @widget: the parent #GtkWidget or %NULL * @path: the path to the desired widget * * Lookup a child of @widget (or from the toplevel if @widget is %NULL). * * Returns: the child specified by @widget and @path or %NULL if not found. */ GtkWidget* gutachter_lookup_child (GtkWidget * widget, gchar const* path) { GtkWidget * result = NULL; GList * list; GList * iterator; gchar const* lookup; gchar const* end; g_return_val_if_fail (path, NULL); if (!*path) { path = "urn:gtk:"; } lookup = path; if (!g_str_has_prefix (lookup, "urn:")) { g_warning ("%s(%s): path is no URN: \"%s\" should start with \"urn:\"", G_STRFUNC, G_STRLOC, path); return NULL; } lookup += 4; /* path points to 32bit word boundary */ if (!g_str_has_prefix (lookup, "gtk:")) { g_warning ("%s(%s): the URN's namespace doesn't match ours (\"gtk\"): %s", G_STRFUNC, G_STRLOC, path); return NULL; } lookup += 4; /* path points to 32bit and 64bit word boundary */ if (widget) { result = widget; } else { if (!*lookup) { return NULL; } if (!g_str_has_prefix (lookup, "GtkWindow")) { g_warning ("the gtk namespace can only be used with GtkWindow functions"); return NULL; } lookup += strlen ("GtkWindow"); if (!g_str_has_prefix (lookup, "(\"")) { g_warning ("GtkWindows can only be looked up by title right now (e.g. 'GtkWindow(\"window title\")'): %s", path); return NULL; } lookup += 2; end = strstr (lookup, "\")"); if (!end) { g_warning ("window title doesn't seem to be closed: %s", path); return NULL; } for (iterator = list = gtk_window_list_toplevels (); iterator; iterator = iterator->next) { gchar const* title = gtk_window_get_title (iterator->data); if (g_str_has_prefix (lookup, title) && *(title + (end - lookup)) == '\0') { result = iterator->data; break; } } g_list_free (list); if (!result) { /* no window found */ return NULL; } lookup = end + 2; /* result holds the window now */ if (*lookup == ':') { lookup++; } } while (*lookup != '\0') { gchar* type_name; GType type; int index; end = strstr (lookup, "["); if (!end) { g_warning ("the type starting at column %" G_GUINTPTR_FORMAT " doesn't have a lookup operator (\"[]\")", lookup - path); return NULL; } type_name = g_strndup (lookup, end - lookup); type = g_type_from_name (type_name); if (!type) { g_warning ("couldn't lookup the type \"%s\". it is not registered. this " "usually means that you have a typo in your string as the " "creation of a widget would automatically register its type " "(and its parent types)", type_name); g_free (type_name); return NULL; } g_free (type_name); lookup = end + 1; index = strtol (lookup, &type_name, 10); /* FIXME: watch for ERANGE in errno */ end = type_name; /* use type_name because it is non-const */ if (!end || *end != ']') { g_warning ("the index starting at column %" G_GUINTPTR_FORMAT " doesn't seem to be properly terminated: expected ']', got '%c': %s", lookup - path, *end, path); return NULL; } if (!GTK_IS_CONTAINER (result)) { gchar* result_end = g_strrstr_len (path, lookup - path, ":"); gchar* result_path = g_strndup (path, result_end - path); g_warning ("the widget specified by \"%s\" is a %s (which is not a GtkContainer)", result_path, G_OBJECT_TYPE_NAME (result)); g_free (result_path); return NULL; } list = gtk_container_get_children (GTK_CONTAINER (result)); iterator = g_list_nth (list, index); if (!iterator) { g_warning ("%s doesn't have a child with the index %d", G_OBJECT_TYPE_NAME (result), index); g_list_free (list); return NULL; } result = iterator->data; g_list_free (list); lookup = end + 1; if (*lookup == '\0') { break; } else if (*lookup == ':') { lookup++; continue; } else { g_warning ("unexpected character after widget lookup (column %" G_GUINTPTR_FORMAT "): expected dereferencing (\":\") or end: '%c'", lookup - path, *lookup); return NULL; } } return result; }
int main (gint argc, gchar *argv[]) { GLogLevelFlags fatal_mask; gboolean gen_froots = 0; gboolean gen_tree = 0; gint i; gchar *iindent = ""; f_out = stdout; fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK); fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL; g_log_set_always_fatal (fatal_mask); root = G_TYPE_OBJECT; for (i = 1; i < argc; i++) { if (strcmp ("-s", argv[i]) == 0) { i++; if (i < argc) spacing = atoi (argv[i]); } else if (strcmp ("-i", argv[i]) == 0) { i++; if (i < argc) { char *p; guint n; p = argv[i]; while (*p) p++; n = p - argv[i]; indent_inc = g_new (gchar, n * strlen (O_SPACE) + 1); *indent_inc = 0; while (n) { n--; strcpy (indent_inc, O_SPACE); } } } else if (strcmp ("-b", argv[i]) == 0) { i++; if (i < argc) iindent = argv[i]; } else if (strcmp ("-r", argv[i]) == 0) { i++; if (i < argc) root = g_type_from_name (argv[i]); } else if (strcmp ("-n", argv[i]) == 0) { recursion = FALSE; } else if (strcmp ("froots", argv[i]) == 0) { gen_froots = 1; } else if (strcmp ("tree", argv[i]) == 0) { gen_tree = 1; } else if (strcmp ("-h", argv[i]) == 0) { return help (NULL); } else if (strcmp ("--help", argv[i]) == 0) { return help (NULL); } else return help (argv[i]); } if (!gen_froots && !gen_tree) return help (argv[i-1]); if (!indent_inc) { indent_inc = g_new (gchar, strlen (O_SPACE) + 1); *indent_inc = 0; strcpy (indent_inc, O_SPACE); } if (gen_tree) show_nodes (root, 0, iindent); if (gen_froots) { root = ~0; for (i = 0; i <= G_TYPE_FUNDAMENTAL_MAX; i += G_TYPE_MAKE_FUNDAMENTAL (1)) { const gchar *name = g_type_name (i); if (name) show_nodes (i, 0, iindent); } } return 0; }
gchar * midgard_cr_core_query_compute_constraint_property (MidgardCRCoreQueryExecutor *executor, MidgardCRCoreQueryStorage *storage, const gchar *name) { g_return_val_if_fail (executor != NULL, FALSE); g_return_val_if_fail (name != NULL, FALSE); /* Set table alias if it's not set */ if (storage) MQE_SET_TABLE_ALIAS (executor, storage); MidgardCRSQLStorageManager *manager = (MidgardCRSQLStorageManager*) executor->priv->storage_manager; GObjectClass *klass = g_type_class_peek (g_type_from_name (executor->priv->storage->priv->classname)); MidgardCRSQLTableModel *table_model = midgard_cr_core_query_find_table_model_by_name (manager, executor->priv->storage->priv->classname); gchar *table_field = NULL; gchar *table_alias = executor->priv->table_alias; const gchar *table = midgard_cr_storage_model_get_location (MIDGARD_CR_STORAGE_MODEL (table_model)); if (storage) { //table = executor->priv->storage->priv->table; table_alias = storage->priv->table_alias; klass = g_type_class_peek (g_type_from_name (storage->priv->classname)); } gchar **spltd = g_strsplit(name, ".", 0); guint i = 0; guint j = 0; /* We can support max 3 tokens */ while(spltd[i] != NULL) i++; gchar *q_table = NULL; gchar *q_field = NULL; /* case: property */ if (i == 1) { const gchar *property_field = __get_property_colname (MIDGARD_CR_SQL_STORAGE_MANAGER (executor->priv->storage_manager), G_OBJECT_CLASS_NAME (klass), name); if (!property_field) { g_warning ("%s doesn't seem to be registered for %s", name, G_OBJECT_CLASS_NAME (klass)); g_strfreev (spltd); return NULL; } q_table = gda_connection_quote_sql_identifier (MCQE_CNC (executor), table_alias); q_field = gda_connection_quote_sql_identifier (MCQE_CNC (executor), property_field); table_field = g_strdup_printf ("%s.%s", q_table, q_field); } else if (i < 4) { /* Set all pointers we need to generate valid tables' names, aliases or joins */ Psh holder = {NULL, }; holder.table = table; holder.table_alias = table_alias; holder.klass = klass; holder.executor = MIDGARD_CR_CORE_QUERY_EXECUTOR (executor); holder.colname = NULL; while (spltd[j] != NULL) { if (spltd[j+1] == NULL) break; /* Set all pointers we need to generate valid tables' names, aliases or joins */ /* case: metadata.property, attachment.property, property.link, etc */ if (!__compute_reserved_property_constraint (&holder, spltd[j], spltd[j+1])) break; j++; } if (holder.table_alias && holder.colname) { q_table = gda_connection_quote_sql_identifier (MCQE_CNC (executor), holder.table_alias); q_field = gda_connection_quote_sql_identifier (MCQE_CNC (executor), holder.colname); table_field = g_strdup_printf ("%s.%s", q_table, q_field); } } else { g_warning("Failed to parse '%s'. At most 3 tokens allowed", name); } g_strfreev (spltd); g_free (q_table); g_free (q_field); return table_field; }
static void parse_template (GMarkupParseContext *context, ParserData *data, const gchar *element_name, const gchar **names, const gchar **values, GError **error) { ObjectInfo *object_info; const gchar *object_class = NULL; const gchar *parent_class = NULL; gint line; GType template_type; GType parsed_type; template_type = _gtk_builder_get_template_type (data->builder); if (!g_markup_collect_attributes (element_name, names, values, error, G_MARKUP_COLLECT_STRING, "class", &object_class, G_MARKUP_COLLECT_STRING|G_MARKUP_COLLECT_OPTIONAL, "parent", &parent_class, G_MARKUP_COLLECT_INVALID)) { _gtk_builder_prefix_error (data->builder, data->ctx, error); return; } if (template_type == 0) { g_set_error (error, GTK_BUILDER_ERROR, GTK_BUILDER_ERROR_UNHANDLED_TAG, "Not expecting to handle a template (class '%s', parent '%s')", object_class, parent_class ? parent_class : "GtkWidget"); _gtk_builder_prefix_error (data->builder, context, error); return; } else if (state_peek (data) != NULL) { error_invalid_tag (data, "template", NULL, error); return; } parsed_type = g_type_from_name (object_class); if (template_type != parsed_type) { g_set_error (error, GTK_BUILDER_ERROR, GTK_BUILDER_ERROR_TEMPLATE_MISMATCH, "Parsed template definition for type '%s', expected type '%s'", object_class, g_type_name (template_type)); _gtk_builder_prefix_error (data->builder, context, error); return; } if (parent_class) { GType parent_type = g_type_from_name (parent_class); GType expected_type = g_type_parent (parsed_type); if (parent_type == G_TYPE_INVALID) { g_set_error (error, GTK_BUILDER_ERROR, GTK_BUILDER_ERROR_INVALID_VALUE, "Invalid template parent type '%s'", parent_class); _gtk_builder_prefix_error (data->builder, context, error); return; } if (parent_type != expected_type) { g_set_error (error, GTK_BUILDER_ERROR, GTK_BUILDER_ERROR_TEMPLATE_MISMATCH, "Template parent type '%s' does not match instance parent type '%s'.", parent_class, g_type_name (expected_type)); _gtk_builder_prefix_error (data->builder, context, error); return; } } ++data->cur_object_level; object_info = g_slice_new0 (ObjectInfo); object_info->tag.name = element_name; object_info->type = parsed_type; object_info->oclass = g_type_class_ref (parsed_type); object_info->id = g_strdup (object_class); object_info->object = gtk_builder_get_object (data->builder, object_class); state_push (data, object_info); line = GPOINTER_TO_INT (g_hash_table_lookup (data->object_ids, object_class)); if (line != 0) { g_set_error (error, GTK_BUILDER_ERROR, GTK_BUILDER_ERROR_DUPLICATE_ID, "Duplicate object ID '%s' (previously on line %d)", object_class, line); _gtk_builder_prefix_error (data->builder, context, error); return; } g_markup_parse_context_get_position (context, &line, NULL); g_hash_table_insert (data->object_ids, g_strdup (object_class), GINT_TO_POINTER (line)); }
static void append_element (GtkWidgetPath *path, const char *selector) { static const struct { const char *name; GtkStateFlags state_flag; } pseudo_classes[] = { { "active", GTK_STATE_FLAG_ACTIVE }, { "hover", GTK_STATE_FLAG_PRELIGHT }, { "selected", GTK_STATE_FLAG_SELECTED }, { "disabled", GTK_STATE_FLAG_INSENSITIVE }, { "indeterminate", GTK_STATE_FLAG_INCONSISTENT }, { "focus", GTK_STATE_FLAG_FOCUSED }, { "backdrop", GTK_STATE_FLAG_BACKDROP }, { "dir(ltr)", GTK_STATE_FLAG_DIR_LTR }, { "dir(rtl)", GTK_STATE_FLAG_DIR_RTL }, { "link", GTK_STATE_FLAG_LINK }, { "visited", GTK_STATE_FLAG_VISITED }, { "checked", GTK_STATE_FLAG_CHECKED }, { "drop(active)", GTK_STATE_FLAG_DROP_ACTIVE } }; const char *next; char *name; char type; guint i; next = strpbrk (selector, "#.:"); if (next == NULL) next = selector + strlen (selector); name = g_strndup (selector, next - selector); if (g_ascii_isupper (selector[0])) { GType gtype; gtype = g_type_from_name (name); if (gtype == G_TYPE_INVALID) { g_critical ("Unknown type name `%s'", name); g_free (name); return; } gtk_widget_path_append_type (path, gtype); } else { /* Omit type, we're using name */ gtk_widget_path_append_type (path, G_TYPE_NONE); gtk_widget_path_iter_set_object_name (path, -1, name); } g_free (name); while (*next != '\0') { type = *next; selector = next + 1; next = strpbrk (selector, "#.:"); if (next == NULL) next = selector + strlen (selector); name = g_strndup (selector, next - selector); switch (type) { case '#': gtk_widget_path_iter_set_name (path, -1, name); break; case '.': gtk_widget_path_iter_add_class (path, -1, name); break; case ':': for (i = 0; i < G_N_ELEMENTS (pseudo_classes); i++) { if (g_str_equal (pseudo_classes[i].name, name)) { gtk_widget_path_iter_set_state (path, -1, gtk_widget_path_iter_get_state (path, -1) | pseudo_classes[i].state_flag); break; } } if (i == G_N_ELEMENTS (pseudo_classes)) g_critical ("Unknown pseudo-class :%s", name); break; default: g_assert_not_reached (); break; } g_free (name); } }