USER_OBJECT_
toRPointer(void *val, const char *typeName)
{
USER_OBJECT_ ans, klass = NULL;
GType type = 0;
if(val == NULL)
return(NULL_USER_OBJECT);
PROTECT(ans = R_MakeExternalPtr(val, Rf_install(typeName), NULL_USER_OBJECT));
if (typeName)
type = g_type_from_name(typeName);
if(type) {
if (G_TYPE_IS_INSTANTIATABLE(type) || G_TYPE_IS_INTERFACE(type))
type = G_TYPE_FROM_INSTANCE(val);
if (G_TYPE_IS_DERIVED(type)) {
setAttrib(ans, install("interfaces"), R_internal_getInterfaces(type));
PROTECT(klass = R_internal_getGTypeHierarchy(type));
}
}
if (!klass && typeName) {
PROTECT(klass = asRString(typeName));
}
if(klass) {
SET_CLASS(ans, klass);
UNPROTECT(1);
}
UNPROTECT(1);
return(ans);
}
USER_OBJECT_
toRPointerWithFinalizer(gconstpointer val, const gchar *typeName, RPointerFinalizer finalizer)
{
USER_OBJECT_ ans;
USER_OBJECT_ r_finalizer = NULL_USER_OBJECT;
USER_OBJECT_ klass = NULL, rgtk_class;
int i = 0;
GType type = 0;
if(!val)
return(NULL_USER_OBJECT);
if (finalizer) {
PROTECT(r_finalizer = R_MakeExternalPtr(finalizer, NULL_USER_OBJECT, NULL_USER_OBJECT));
}
PROTECT(ans = R_MakeExternalPtr((gpointer)val, r_finalizer, NULL_USER_OBJECT));
if (finalizer) {
R_RegisterCFinalizer(ans, RGtk_finalizer);
}
if (typeName)
type = g_type_from_name(typeName);
if(type) {
if (G_TYPE_IS_INSTANTIATABLE(type) || G_TYPE_IS_INTERFACE(type))
type = G_TYPE_FROM_INSTANCE(val);
if (G_TYPE_IS_DERIVED(type)) {
setAttrib(ans, install("interfaces"), R_internal_getInterfaces(type));
PROTECT(klass = R_internal_getGTypeAncestors(type));
}
}
if (!klass && typeName) {
PROTECT(klass = asRString(typeName));
}
if (klass) { /* so much trouble just to add "RGtkObject" onto the end */
PROTECT(rgtk_class = NEW_CHARACTER(GET_LENGTH(klass)+1));
for (i = 0; i < GET_LENGTH(klass); i++)
SET_STRING_ELT(rgtk_class, i, STRING_ELT(klass, i));
} else {
PROTECT(rgtk_class = NEW_CHARACTER(1));
}
SET_STRING_ELT(rgtk_class, i, COPY_TO_USER_STRING("RGtkObject"));
SET_CLASS(ans, rgtk_class);
if (g_type_is_a(type, S_TYPE_G_OBJECT)) {
USER_OBJECT_ public_sym = install(".public");
setAttrib(ans, public_sym, findVar(public_sym, S_GOBJECT_GET_ENV(val)));
}
if (klass)
UNPROTECT(1);
if (finalizer)
UNPROTECT(1);
UNPROTECT(2);
return(ans);
}
/**
* gwy_coords_view_set_coords_type:
* @view: A coords view.
* @type: Type of coordinates this view will show.
*
* Sets the type of coordinates a coords view will show.
*
* It is not necessary to call this method before gwy_coords_view_set_coords()
* because setting the coordinates object sets the type automatically.
* However, you may want to use the setup function such as
* gwy_coords_view_set_dimension_format() or
* gwy_coords_view_create_column_coord() before setting any coordinate object
* to show and these functions need to know the type.
*
* Once set, the type should not change.
**/
void
gwy_coords_view_set_coords_type(GwyCoordsView *view,
GType type)
{
g_return_if_fail(GWY_IS_COORDS_VIEW(view));
g_return_if_fail(g_type_is_a(type, GWY_TYPE_COORDS));
g_return_if_fail(G_TYPE_IS_INSTANTIATABLE(type));
set_coords_type(view, type);
}
static GObject *
parse_object(Log4gConfigurator *base, xmlNodePtr node)
{
GObject *object = NULL;
xmlChar *name = xmlGetProp(node, (const xmlChar *)"name");
xmlChar *type = xmlGetProp(node, (const xmlChar *)"type");
if (!name) {
log4g_log_error(Q_("objects must have a `name'"));
goto exit;
}
if (!type) {
log4g_log_error(Q_("objects must have a `type'"));
goto exit;
}
GType gtype = g_type_from_name((const gchar *)type);
if (!gtype) {
log4g_log_error(Q_("%s: invalid `type'"), type);
goto exit;
}
if (!G_TYPE_IS_INSTANTIATABLE(gtype)) {
log4g_log_error(Q_("%s: is a non-instantiable type"), type);
goto exit;
}
object = g_object_new(gtype, NULL);
if (!object) {
log4g_log_error(Q_("%s: g_object_new() returned NULL"), type);
goto exit;
}
node = node->xmlChildrenNode;
while (node) {
if (!xmlStrcmp(node->name, (const xmlChar *)"property")) {
parse_property(base, node, object);
} else if (!xmlStrcmp(node->name, (const xmlChar *)"text")) {
log4g_log_warn(Q_("invalid text element"));
} else if (!xmlStrcmp(node->name, (const xmlChar *)"comment")) {
/* do nothing */
} else {
log4g_log_warn(Q_("%s: invalid element"), node->name);
}
node = node->next;
}
g_hash_table_insert(GET_PRIVATE(base)->objects, name, object);
exit:
if (name) {
xmlFree(name);
}
if (type) {
xmlFree(type);
}
return object;
}
static Log4gFilter *
parse_filter(Log4gConfigurator *base, xmlNodePtr node)
{
Log4gFilter *filter = NULL;
xmlChar *type = xmlGetProp(node, (const xmlChar *)"type");
if (!type) {
log4g_log_error(Q_("filters must have a `type'"));
goto exit;
}
GType gtype = g_type_from_name((const gchar *)type);
if (!gtype) {
log4g_log_error(Q_("%s: invalid `type'"), type);
goto exit;
}
if (!G_TYPE_IS_INSTANTIATABLE(gtype)) {
log4g_log_error(Q_("%s: is a non-instantiable type"), type);
goto exit;
}
filter = g_object_new(gtype, NULL);
if (!filter) {
log4g_log_error(Q_("%s: g_object_new() returned NULL"), type);
goto exit;
}
if (!LOG4G_IS_FILTER(filter)) {
log4g_log_error(Q_("%s: not an instance of Log4gFilter"), type);
g_object_unref(filter);
filter = NULL;
goto exit;
}
node = node->xmlChildrenNode;
while (node) {
if (!xmlStrcmp(node->name, (const xmlChar *)"property")) {
parse_property(base, node, filter);
} else if (!xmlStrcmp(node->name, (const xmlChar *)"text")) {
log4g_log_warn(Q_("invalid text element"));
} else if (!xmlStrcmp(node->name, (const xmlChar *)"comment")) {
/* do nothing */
} else {
log4g_log_warn(Q_("%s: invalid element"), node->name);
}
node = node->next;
}
log4g_filter_activate_options(filter);
exit:
if (type) {
xmlFree(type);
}
return filter;
}
/* Help function to dump a GType */
void my_dump_type(GType type_id) {
printf("Type id: %d\n", type_id);
printf("Type name: %s\n", g_type_name(type_id));
printf("Is fundamental? %s\n", G_TYPE_IS_FUNDAMENTAL(type_id) ? "yes" : "no");
printf("Is derived? %s\n", G_TYPE_IS_DERIVED(type_id) ? "yes" : "no");
printf("Is interface? %s\n", G_TYPE_IS_INTERFACE(type_id) ? "yes" : "no");
printf("Is classed? %s\n", G_TYPE_IS_CLASSED(type_id) ? "yes" : "no");
printf("Is instantiatable? %s\n", G_TYPE_IS_INSTANTIATABLE(type_id) ? "yes" : "no");
printf("Is derivable? %s\n", G_TYPE_IS_DERIVABLE(type_id) ? "yes" : "no");
printf("Is deep derivable? %s\n", G_TYPE_IS_DEEP_DERIVABLE(type_id) ? "yes" : "no");
printf("Is abstract? %s\n", G_TYPE_IS_ABSTRACT(type_id) ? "yes" : "no");
printf("Is value abstract? %s\n", G_TYPE_IS_VALUE_ABSTRACT(type_id) ? "yes" : "no");
printf("Is value type: %s\n", G_TYPE_IS_VALUE_TYPE(type_id) ? "yes" : "no");
printf("Has value table: %s\n", G_TYPE_HAS_VALUE_TABLE(type_id) ? "yes" : "no");
}
static GwyResource*
gwy_resource_parse_real(const gchar *text,
GType expected_type,
gboolean is_const)
{
GwyResourceClass *klass;
GwyResource *resource = NULL;
GType type;
gchar *name = NULL;
guint len;
if (!g_str_has_prefix(text, MAGIC_HEADER)) {
g_warning("Wrong resource magic header");
return NULL;
}
text += sizeof(MAGIC_HEADER) - 1;
len = strspn(text, G_CSET_a_2_z G_CSET_A_2_Z G_CSET_DIGITS);
name = g_strndup(text, len);
text = strchr(text + len, '\n');
if (!text) {
g_warning("Truncated resource header");
goto fail;
}
text++;
type = g_type_from_name(name);
if (!type
|| (expected_type && type != expected_type)
|| !g_type_is_a(type, GWY_TYPE_RESOURCE)
|| !G_TYPE_IS_INSTANTIATABLE(type)
|| G_TYPE_IS_ABSTRACT(type)) {
g_warning("Wrong resource type `%s'", name);
goto fail;
}
klass = GWY_RESOURCE_CLASS(g_type_class_peek_static(type));
g_return_val_if_fail(klass && klass->parse, NULL);
resource = klass->parse(text, is_const);
if (resource)
g_string_assign(resource->name, name);
fail:
g_free(name);
return resource;
}
int
main (int argc,
char *argv[])
{
GList *adaptors, *l;
gtk_test_init (&argc, &argv, NULL);
glade_init ();
glade_app_get ();
adaptors = g_list_sort (glade_widget_adaptor_list_adaptors (), adaptor_cmp);
for (l = adaptors; l; l = l->next)
{
GladeWidgetAdaptor *adaptor = l->data;
GType adaptor_type;
adaptor_type = glade_widget_adaptor_get_object_type (adaptor);
if (G_TYPE_IS_INSTANTIATABLE (adaptor_type) && !G_TYPE_IS_ABSTRACT (adaptor_type) &&
/* FIXME: FileChooserButton leaks a GTask which will crash in the following test */
adaptor_type != GTK_TYPE_FILE_CHOOSER_BUTTON &&
/* FIXME: GtkRecentChooser tries to remove an unknown source id */
!g_type_is_a (adaptor_type, GTK_TYPE_RECENT_CHOOSER))
{
gchar *test_path = g_strdup_printf ("/CreateWidget/%s", glade_widget_adaptor_get_name (adaptor));
g_test_add_data_func (test_path, adaptor, test_create_widget);
g_free (test_path);
}
}
g_list_free (adaptors);
return g_test_run ();
}
static PyObject*
_wrap_g_type_is_instantiatable(PyGTypeWrapper *self)
{
return PyBool_FromLong(G_TYPE_IS_INSTANTIATABLE(self->type));
}
static VALUE
rg_instantiatable_p(VALUE self)
{
return CBOOL2RVAL(G_TYPE_IS_INSTANTIATABLE(rbgobj_gtype_get(self)));
}
static const RGObjClassInfo *
rbgobj_lookup_class_by_gtype_without_lock(GType gtype, VALUE parent,
gboolean create_class)
{
GType fundamental_type;
RGObjClassInfo* cinfo;
RGObjClassInfoDynamic* cinfod;
void* gclass = NULL;
VALUE c;
if (gtype == G_TYPE_INVALID)
return NULL;
cinfo = g_hash_table_lookup(gtype_to_cinfo, GUINT_TO_POINTER(gtype));
if (cinfo)
return cinfo;
if (!create_class)
return NULL;
c = Data_Make_Struct(rb_cData, RGObjClassInfo, cinfo_mark, NULL, cinfo);
cinfo->gtype = gtype;
cinfo->mark = NULL;
cinfo->free = NULL;
cinfo->flags = 0;
fundamental_type = G_TYPE_FUNDAMENTAL(gtype);
switch (fundamental_type) {
case G_TYPE_POINTER:
case G_TYPE_BOXED:
case G_TYPE_PARAM:
case G_TYPE_OBJECT:
case G_TYPE_ENUM:
case G_TYPE_FLAGS:
if (NIL_P(parent)) parent = get_superclass(gtype);
cinfo->klass = rb_funcall(rb_cClass, id_new, 1, parent);
break;
case G_TYPE_INTERFACE:
cinfo->klass = rb_module_new();
break;
default:
if (NIL_P(parent)) parent = get_superclass(gtype);
if (NIL_P(parent)) {
fprintf(stderr,
"%s: %s's fundamental type %s isn't supported\n",
"rbgobj_lookup_class_by_gtype",
g_type_name(gtype),
g_type_name(fundamental_type));
return NULL;
}
cinfo->klass = rb_funcall(rb_cClass, id_new, 1, parent);
}
cinfod = (RGObjClassInfoDynamic *)g_hash_table_lookup(dynamic_gtype_list,
g_type_name(gtype));
if (cinfod) {
cinfo->mark = cinfod->mark;
cinfo->free = cinfod->free;
rb_define_const(cinfod->module, cinfod->name, cinfo->klass);
}
rb_hash_aset(klass_to_cinfo, cinfo->klass, c);
g_hash_table_insert(gtype_to_cinfo, GUINT_TO_POINTER(gtype), cinfo);
if (G_TYPE_IS_CLASSED(gtype))
gclass = g_type_class_ref(gtype);
if (G_TYPE_IS_INSTANTIATABLE(gtype) || G_TYPE_IS_INTERFACE(gtype))
rbgobj_define_action_methods(cinfo->klass);
if (G_TYPE_IS_INSTANTIATABLE(gtype)) {
GType* interfaces = NULL;
guint n_interfaces = 0;
guint i;
interfaces = g_type_interfaces(gtype, &n_interfaces);
for (i = 0; i < n_interfaces; i++) {
const RGObjClassInfo *iface_cinfo;
iface_cinfo =
rbgobj_lookup_class_by_gtype_without_lock(interfaces[i],
Qnil,
TRUE);
rb_include_module(cinfo->klass, iface_cinfo->klass);
}
g_free(interfaces);
}
if (!rbgobj_convert_type_init_hook(gtype, cinfo->klass)) {
switch (fundamental_type) {
case G_TYPE_OBJECT:
rbgobj_init_object_class(cinfo->klass);
break;
case G_TYPE_ENUM:
rbgobj_init_enum_class(cinfo->klass);
break;
case G_TYPE_FLAGS:
rbgobj_init_flags_class(cinfo->klass);
break;
case G_TYPE_INTERFACE:
rbgobj_init_interface(cinfo->klass);
break;
default:
rbgobj_convert_type_init_hook(fundamental_type, cinfo->klass);
break;
}
}
if (gclass)
g_type_class_unref(gclass);
return cinfo;
}
int
main (int argc, char **argv)
{
const GType *all_types;
guint n_types = 0, i;
gchar *schema_dir;
GTestDBus *bus;
gint result;
/* These must be set before before gtk_test_init */
g_setenv ("GIO_USE_VFS", "local", TRUE);
g_setenv ("GSETTINGS_BACKEND", "memory", TRUE);
/* initialize test program */
gtk_test_init (&argc, &argv);
gtk_test_register_all_types ();
/* g_test_build_filename must be called after gtk_test_init */
schema_dir = g_test_build_filename (G_TEST_BUILT, "", NULL);
g_setenv ("GSETTINGS_SCHEMA_DIR", schema_dir, TRUE);
/* Create one test bus for all tests, as we have a lot of very small
* and quick tests.
*/
bus = g_test_dbus_new (G_TEST_DBUS_NONE);
g_test_dbus_up (bus);
all_types = gtk_test_list_all_types (&n_types);
for (i = 0; i < n_types; i++)
{
if (g_type_is_a (all_types[i], G_TYPE_OBJECT) &&
G_TYPE_IS_INSTANTIATABLE (all_types[i]) &&
!G_TYPE_IS_ABSTRACT (all_types[i]) &&
#ifdef GDK_WINDOWING_X11
all_types[i] != GDK_TYPE_X11_WINDOW &&
all_types[i] != GDK_TYPE_X11_CURSOR &&
all_types[i] != GDK_TYPE_X11_SCREEN &&
all_types[i] != GDK_TYPE_X11_DISPLAY &&
all_types[i] != GDK_TYPE_X11_DEVICE_MANAGER_XI2 &&
all_types[i] != GDK_TYPE_X11_DISPLAY_MANAGER &&
all_types[i] != GDK_TYPE_X11_GL_CONTEXT &&
#endif
/* Not allowed to finalize a GdkPixbufLoader without calling gdk_pixbuf_loader_close() */
all_types[i] != GDK_TYPE_PIXBUF_LOADER &&
all_types[i] != gdk_pixbuf_simple_anim_iter_get_type())
{
gchar *test_path = g_strdup_printf ("/FinalizeObject/%s", g_type_name (all_types[i]));
g_test_add_data_func (test_path, GSIZE_TO_POINTER (all_types[i]), test_finalize_object);
g_free (test_path);
}
}
result = g_test_run();
g_test_dbus_down (bus);
g_object_unref (bus);
g_free (schema_dir);
return result;
}
static Log4gAppender *
parse_appender(Log4gConfigurator *base, xmlNodePtr node)
{
xmlChar *name = NULL;
Log4gAppender *appender = NULL;
struct Private *priv = GET_PRIVATE(base);
xmlChar *type = xmlGetProp(node, (const xmlChar *)"type");
if (type) {
GType gtype = g_type_from_name((const gchar *)type);
if (!gtype) {
log4g_log_error(Q_("%s: invalid `type'"), type);
goto exit;
}
if (!G_TYPE_IS_INSTANTIATABLE(gtype)) {
log4g_log_error(Q_("%s: is a non-instantiable type"),
type);
goto exit;
}
appender = g_object_new(gtype, NULL);
if (!appender) {
log4g_log_error(Q_("%s: g_object_new() returned NULL"),
type);
goto exit;
}
if (!LOG4G_IS_APPENDER(appender)) {
log4g_log_error(Q_("%s: not an instance of "
"Log4gAppender"), type);
g_object_unref(appender);
appender = NULL;
goto exit;
}
}
name = xmlGetProp(node, (const xmlChar *)"name");
if (appender) {
if (name) {
g_object_ref(appender);
g_hash_table_insert(priv->appenders, name, appender);
name = NULL;
}
} else {
if (name) {
appender = LOG4G_APPENDER(g_hash_table_lookup(
priv->appenders, name));
if (!appender) {
log4g_log_error(Q_("%s: no such appender"),
name);
goto exit;
}
g_object_ref(appender);
} else {
log4g_log_error(Q_("appenders without a `type' must "
"have a `name'"));
goto exit;
}
}
node = node->xmlChildrenNode;
while (node) {
if (!xmlStrcmp(node->name, (const xmlChar *)"property")) {
parse_property(base, node, appender);
} else if (!xmlStrcmp(node->name, (const xmlChar *)"layout")) {
Log4gLayout *layout = parse_layout(base, node);
if (layout) {
log4g_appender_set_layout(appender, layout);
g_object_unref(layout);
}
} else if (!xmlStrcmp(node->name, (const xmlChar *)"filter")) {
Log4gFilter *filter = parse_filter(base, node);
if (filter) {
log4g_appender_add_filter(appender, filter);
g_object_unref(filter);
}
} else if (!xmlStrcmp(node->name, (const xmlChar *)"appender")) {
if (LOG4G_IS_APPENDER_ATTACHABLE(appender)) {
Log4gAppender *child =
parse_appender(base, node);
if (child) {
log4g_appender_attachable_add_appender(
LOG4G_APPENDER_ATTACHABLE(appender),
child);
g_object_unref(child);
}
} else {
log4g_log_error(Q_("%s: does not implement "
"log4g_appender_attachable"),
type);
}
} else if (!xmlStrcmp(node->name, (const xmlChar *)"text")) {
log4g_log_warn(Q_("invalid text element"));
} else if (!xmlStrcmp(node->name, (const xmlChar *)"comment")) {
/* do nothing */
} else {
log4g_log_warn(Q_("%s: invalid element"), node->name);
}
node = node->next;
}
if (log4g_appender_requires_layout(appender)
&& !log4g_appender_get_layout(appender)) {
log4g_log_error(Q_("%s: appender requires a layout"), type);
g_hash_table_remove(priv->appenders,
log4g_appender_get_name(appender));
g_object_unref(appender);
appender = NULL;
goto exit;
}
log4g_appender_activate_options(appender);
exit:
if (type) {
xmlFree(type);
}
if (name) {
xmlFree(name);
}
return appender;
}
