void
Init_gobject_gflags(void)
{
id_module_eval = rb_intern("module_eval");
id_new = rb_intern("new");
id_or = rb_intern("|");
id_to_i = rb_intern("to_i");
RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_FLAGS, "Flags", mGLib);
rbg_define_singleton_method(RG_TARGET_NAMESPACE, "gtype", generic_s_gtype, 0);
rbg_define_method(RG_TARGET_NAMESPACE, "gtype", generic_gtype, 0);
RG_DEF_SMETHOD(mask, 0);
RG_DEF_SMETHOD(values, 0);
rb_define_alloc_func(RG_TARGET_NAMESPACE, flags_s_allocate);
RG_DEF_METHOD(initialize, -1);
RG_DEF_METHOD(to_i, 0);
RG_DEF_ALIAS("to_int", "to_i");
RG_DEF_METHOD(name, 0);
RG_DEF_METHOD(nick, 0);
/*
rbg_define_method(RG_TARGET_NAMESPACE, "inspect", flags_inspect, 0);
*/
RG_DEF_METHOD_OPERATOR("<=>", flags_compare, 1);
RG_DEF_METHOD_OPERATOR("==", flags_eqv, 1);
RG_DEF_METHOD_OPERATOR(">=", flags_gt_eq, 1);
RG_DEF_METHOD_OPERATOR("<=", flags_lt_eq, 1);
RG_DEF_METHOD_OPERATOR(">", flags_gt, 1);
RG_DEF_METHOD_OPERATOR("<", flags_lt, 1);
RG_DEF_METHOD_OPERATOR("~", flags_not, 0);
rbg_define_method(RG_TARGET_NAMESPACE, "&", flags_and, 1);
rbg_define_method(RG_TARGET_NAMESPACE, "|", flags_or, 1);
rbg_define_method(RG_TARGET_NAMESPACE, "^", flags_xor, 1);
RG_DEF_METHOD_OPERATOR("-", flags_minus, 1);
RG_DEF_METHOD_P(empty, 0);
RG_DEF_METHOD(hash, 0);
RG_DEF_ALIAS("eql?", "==");
/* for compatibility */
RG_DEF_METHOD(coerce, 1);
RG_DEF_ALIAS("zero?", "empty?");
RG_DEF_METHOD_P(nonzero, 0);
}
void
Init_poppler_formfieldmapping(VALUE mPoppler)
{
VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(POPPLER_TYPE_FORM_FIELD_MAPPING,
"FormFieldMapping", mPoppler);
rbg_define_method(RG_TARGET_NAMESPACE, "area", form_field_mapping_get_area, 0);
rbg_define_method(RG_TARGET_NAMESPACE, "field", form_field_mapping_get_field,
0);
rbg_define_method(RG_TARGET_NAMESPACE, "set_area",
form_field_mapping_set_area, 1);
rbg_define_method(RG_TARGET_NAMESPACE, "set_field",
form_field_mapping_set_field, 1);
}
void
Init_poppler_image_mapping(VALUE mPoppler)
{
VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(POPPLER_TYPE_IMAGE_MAPPING,
"ImageMapping", mPoppler);
rbg_define_method(RG_TARGET_NAMESPACE, "area", image_mapping_get_area, 0);
rbg_define_method(RG_TARGET_NAMESPACE, "image_id", image_mapping_get_image_id, 0);
#ifdef RB_POPPLER_CAIRO_AVAILABLE
RG_DEF_METHOD(image, 0);
#endif
rbg_define_method(RG_TARGET_NAMESPACE, "set_area", image_mapping_set_area, 1);
rbg_define_method(RG_TARGET_NAMESPACE, "set_image_id",
image_mapping_set_image_id, 1);
}
void
rbgobj_init_object_class(VALUE klass)
{
rbgobj_define_property_accessors(klass);
if (G_TYPE_IS_ABSTRACT(CLASS2GTYPE(klass)))
rbg_define_method(klass, "initialize", dummy_init, -1);
}
void
Init_gobject_typeinterface(void)
{
RG_TARGET_NAMESPACE = rb_define_module_under(mGLib, "MetaInterface");
rbg_define_method(RG_TARGET_NAMESPACE, "gtype", generic_s_gtype, 0);
RG_DEF_METHOD(append_features, 1);
RG_DEF_METHOD(install_property, 1);
RG_DEF_METHOD(property, 1);
RG_DEF_METHOD(properties, -1);
rbgobj_mInterface = G_DEF_INTERFACE(G_TYPE_INTERFACE, "Interface", mGLib);
}
void
Init_gobject_gobject(void)
{
RG_TARGET_NAMESPACE = G_DEF_CLASS_WITH_GC_FUNC(G_TYPE_OBJECT, "Object", mGLib,
gobj_mark, NULL);
#ifdef G_TYPE_INITIALLY_UNOWNED
G_DEF_CLASS(G_TYPE_INITIALLY_UNOWNED, "InitiallyUnowned", mGLib);
#endif
RUBY_GOBJECT_OBJ_KEY = g_quark_from_static_string("__ruby_gobject_object__");
rb_define_alloc_func(RG_TARGET_NAMESPACE, (VALUE(*)_((VALUE)))gobj_s_allocate);
RG_DEF_SMETHOD_BANG(new, -1);
rbg_define_singleton_method(RG_TARGET_NAMESPACE, "property", &gobj_s_property, 1);
rbg_define_singleton_method(RG_TARGET_NAMESPACE, "properties", &gobj_s_properties, -1);
RG_DEF_SMETHOD(install_property, -1);
q_ruby_getter = g_quark_from_static_string("__ruby_getter");
q_ruby_setter = g_quark_from_static_string("__ruby_setter");
RG_DEF_METHOD(set_property, 2);
RG_DEF_METHOD(get_property, 1);
RG_DEF_METHOD(freeze_notify, 0);
rb_undef_method(RG_TARGET_NAMESPACE, "notify");
RG_DEF_METHOD(notify, 1);
RG_DEF_METHOD(thaw_notify, 0);
RG_DEF_METHOD_P(destroyed, 0);
RG_DEF_METHOD(initialize, -1);
rbg_define_method(RG_TARGET_NAMESPACE, "ref_count", gobj_ref_count, 0); /* for debugging */
RG_DEF_METHOD(unref, 0);
RG_DEF_METHOD(inspect, 0);
RG_DEF_METHOD(type_name, 0);
#if GLIB_CHECK_VERSION(2, 26, 0)
RG_DEF_METHOD(bind_property, 4);
G_DEF_CLASS(G_TYPE_BINDING_FLAGS, "BindingFlags", mGLib);
#endif
eNoPropertyError = rb_define_class_under(mGLib, "NoPropertyError",
rb_eNameError);
rb_global_variable(&type_to_prop_setter_table);
rb_global_variable(&type_to_prop_getter_table);
type_to_prop_setter_table = rb_hash_new();
type_to_prop_getter_table = rb_hash_new();
/* subclass */
RG_DEF_SMETHOD(type_register, -1);
}
void
Init_pango_logattr(VALUE mPango)
{
VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(PANGO_TYPE_LOG_ATTR, "LogAttr", mPango);
RG_DEF_METHOD(initialize, 0);
DEFINE_ACCESSOR(RG_TARGET_NAMESPACE, line_break);
DEFINE_ACCESSOR(RG_TARGET_NAMESPACE, mandatory_break);
DEFINE_ACCESSOR(RG_TARGET_NAMESPACE, char_break);
DEFINE_ACCESSOR(RG_TARGET_NAMESPACE, white);
DEFINE_ACCESSOR(RG_TARGET_NAMESPACE, cursor_position);
DEFINE_ACCESSOR(RG_TARGET_NAMESPACE, word_start);
DEFINE_ACCESSOR(RG_TARGET_NAMESPACE, word_end);
DEFINE_ACCESSOR(RG_TARGET_NAMESPACE, sentence_boundary);
DEFINE_ACCESSOR(RG_TARGET_NAMESPACE, sentence_start);
DEFINE_ACCESSOR(RG_TARGET_NAMESPACE, sentence_end);
#if PANGO_CHECK_VERSION(1,4,0)
rbg_define_method(RG_TARGET_NAMESPACE, "backspace_deletes_character?", log_get_backspace_deletes_character, 0);
rbg_define_method(RG_TARGET_NAMESPACE, "set_backspace_deletes_character", log_set_backspace_deletes_character, 1);
#endif
}
void
Init_gobject_gboxed(void)
{
RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_BOXED, "Boxed", mGLib);
rbgobj_register_g2r_func(G_TYPE_BOXED, boxed_to_ruby);
rbgobj_register_r2g_func(G_TYPE_BOXED, boxed_from_ruby);
rb_define_alloc_func(RG_TARGET_NAMESPACE, (VALUE(*)_((VALUE)))rbgobj_boxed_s_allocate);
rbg_define_singleton_method(RG_TARGET_NAMESPACE, "gtype", generic_s_gtype, 0);
rbg_define_method(RG_TARGET_NAMESPACE, "gtype", generic_gtype, 0);
RG_DEF_METHOD(initialize, 0);
RG_DEF_METHOD(inspect, 0);
RG_DEF_METHOD(initialize_copy, 1);
RG_DEF_ALIAS("copy", "dup");
}
void
Init_gst_event (VALUE mGst)
{
RGConvertTable table;
memset(&table, 0, sizeof(RGConvertTable));
table.type = GST_TYPE_EVENT;
table.get_superclass = get_superclass;
table.instance2robj = instance2robj;
RG_DEF_CONVERSION(&table);
rb_cGstEvent = G_DEF_CLASS(GST_TYPE_EVENT, "Event", mGst);
rbg_define_method(rb_cGstEvent, "get_type", rbgst_event_get_type, 0);
G_DEF_CLASS(GST_TYPE_EVENT_TYPE, "EventType", mGst);
G_DEF_CONSTANTS(rb_cGstEvent, GST_TYPE_EVENT_TYPE, "GST_EVENT_");
#define DEFINE_EVENT(type, lctype, arguments) \
rb_cGstEvent ## type = \
rb_define_class_under(mGst, "Event" #type, rb_cGstEvent); \
rbg_define_method(rb_cGstEvent ## type, "initialize", \
lctype ## _initialize, arguments)
#define DEFINE_EVENT_PARSE(type, lctype, arguments) \
DEFINE_EVENT(type, lctype, arguments); \
rbg_define_method(rb_cGstEvent ## type, "parse", \
lctype ## _parse, 0)
DEFINE_EVENT(FlushStart, flush_start, 0);
DEFINE_EVENT(FlushStop, flush_stop, 0);
DEFINE_EVENT(EOS, eos, 0);
DEFINE_EVENT_PARSE(NewSegment, newsegment, 7);
DEFINE_EVENT_PARSE(Tag, tag, 1);
DEFINE_EVENT_PARSE(BufferSize, buffersize, 4);
DEFINE_EVENT_PARSE(QOS, qos, 3);
DEFINE_EVENT_PARSE(Seek, seek, 7);
DEFINE_EVENT(Navigation, navigation, 1);
DEFINE_EVENT_PARSE(Latency, latency, 1);
#undef DEFINE_EVENT_PARSE
#undef DEFINE_EVENT
}
void
Init_gdk_event(VALUE mGdk)
{
/* GdkEvent */
rb_cGdkEvent = G_DEF_CLASS(GDK_TYPE_EVENT, "Event", mGdk);
rbg_define_method(rb_cGdkEvent, "initialize", gdkevent_initialize, 1);
rbg_define_method(rb_cGdkEvent, "event_type", gdkevent_type, 0);
rbg_define_singleton_method(rb_cGdkEvent, "events_pending?", gdkevent_s_events_pending, 0);
rbg_define_singleton_method(rb_cGdkEvent, "peek", gdkevent_s_peek, 0);
rbg_define_singleton_method(rb_cGdkEvent, "get", gdkevent_s_get, 0);
rbg_define_method(rb_cGdkEvent, "put", gdkevent_put, 0);
rbg_define_method(rb_cGdkEvent, "get_axis", gdkevent_get_axis, 1);
rbg_define_method(rb_cGdkEvent, "coords", gdkevent_get_coords, 0);
rbg_define_method(rb_cGdkEvent, "root_coords", gdkevent_get_root_coords, 0);
rbg_define_singleton_method(rb_cGdkEvent, "handler_set", gdkevent_s_handler_set, 0);
rbg_define_singleton_method(rb_cGdkEvent, "show_events?", gdkevent_s_get_show_events, 0);
rbg_define_singleton_method(rb_cGdkEvent, "set_show_events", gdkevent_s_set_show_events, 1);
rbg_define_singleton_method(rb_cGdkEvent, "setting_get", gdkevent_s_setting_get, -1);
rbg_define_method(rb_cGdkEvent, "screen", gdkevent_screen, 0);
rbg_define_method(rb_cGdkEvent, "set_screen", gdkevent_set_screen, 1);
/*
* GdkEvent's Constants
*/
rb_define_const(rb_cGdkEvent, "CURRENT_TIME", INT2FIX(GDK_CURRENT_TIME));
rb_define_const(rb_cGdkEvent, "PRIORITY_EVENTS", INT2FIX(GDK_PRIORITY_EVENTS));
rb_define_const(rb_cGdkEvent, "PRIORITY_REDRAW", INT2FIX(GDK_PRIORITY_REDRAW));
/* GdkEventType */
/* XXX */
G_RENAME_CONSTANT("2BUTTON_PRESS","BUTTON2_PRESS");
G_RENAME_CONSTANT("3BUTTON_PRESS","BUTTON3_PRESS");
G_DEF_CLASS(GDK_TYPE_EVENT_TYPE, "Type", rb_cGdkEvent);
G_RENAME_CONSTANT("2BUTTON_PRESS","BUTTON2_PRESS");
G_RENAME_CONSTANT("3BUTTON_PRESS","BUTTON3_PRESS");
G_DEF_CONSTANTS(rb_cGdkEvent, GDK_TYPE_EVENT_TYPE, "GDK_");
/* GdkEventMask */
G_DEF_CLASS(GDK_TYPE_EVENT_MASK, "Mask", rb_cGdkEvent);
G_DEF_CONSTANTS(rb_cGdkEvent, GDK_TYPE_EVENT_MASK, "GDK_");
/* GdkEventAny */
rb_cGdkEventAny =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_ANY, "EventAny",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventAny, any, window);
rbg_define_method(rb_cGdkEventAny, "send_event?", gdkeventany_send_event, 0);
rbg_define_method(rb_cGdkEventAny, "set_send_event", gdkeventany_set_send_event, 1);
/* GdkEventExpose */
rb_cGdkEventExpose =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_EXPOSE, "EventExpose",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventExpose, expose, area);
DEFINE_ACCESSOR(rb_cGdkEventExpose, expose, region);
DEFINE_ACCESSOR(rb_cGdkEventExpose, expose, count);
DEFINE_INIT(rb_cGdkEventExpose, expose);
/* GdkEventVisibility */
rb_cGdkEventVisibility =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_VISIBILITY, "EventVisibility",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventVisibility, visibility, state);
DEFINE_INIT(rb_cGdkEventVisibility, visibility);
/* GdkVisibilityState */
G_DEF_CLASS(GDK_TYPE_VISIBILITY_STATE, "State", rb_cGdkEventVisibility);
G_DEF_CONSTANTS(rb_cGdkEventVisibility,
GDK_TYPE_VISIBILITY_STATE, "GDK_VISIBILITY_");
/* GdkEventMotion */
rb_cGdkEventMotion =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_MOTION, "EventMotion",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventMotion, motion, time);
DEFINE_ACCESSOR(rb_cGdkEventMotion, motion, x);
DEFINE_ACCESSOR(rb_cGdkEventMotion, motion, y);
rbg_define_method(rb_cGdkEventMotion, "axes", gdkeventmotion_axes, 0);
rbg_define_method(rb_cGdkEventMotion, "set_axes", gdkeventmotion_set_axes, 1);
DEFINE_ACCESSOR(rb_cGdkEventMotion, motion, state);
rbg_define_method(rb_cGdkEventMotion, "hint?", gdkeventmotion_is_hint, 0);
rbg_define_method(rb_cGdkEventMotion, "set_hint", gdkeventmotion_set_is_hint, 1);
DEFINE_ACCESSOR(rb_cGdkEventMotion, motion, device);
DEFINE_ACCESSOR(rb_cGdkEventMotion, motion, x_root);
DEFINE_ACCESSOR(rb_cGdkEventMotion, motion, y_root);
DEFINE_INIT(rb_cGdkEventMotion, motion);
rbg_define_method(rb_cGdkEventMotion, "request", gdkeventmotion_request_motions, 0);
/* GdkEventButton */
rb_cGdkEventButton =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_BUTTON, "EventButton",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventButton, button, time);
DEFINE_ACCESSOR(rb_cGdkEventButton, button, x);
DEFINE_ACCESSOR(rb_cGdkEventButton, button, y);
rbg_define_method(rb_cGdkEventButton, "axes", gdkeventbutton_axes, 0);
rbg_define_method(rb_cGdkEventButton, "set_axes", gdkeventbutton_set_axes, 2);
DEFINE_ACCESSOR(rb_cGdkEventButton, button, state);
DEFINE_ACCESSOR(rb_cGdkEventButton, button, button);
DEFINE_ACCESSOR(rb_cGdkEventButton, button, device);
DEFINE_ACCESSOR(rb_cGdkEventButton, button, x_root);
DEFINE_ACCESSOR(rb_cGdkEventButton, button, y_root);
/* GdkEventTouch */
rb_cGdkEventTouch =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_TOUCH, "EventTouch",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventTouch, touch, window);
rbg_define_method(rb_cGdkEventTouch, "send_event?", gdkeventtouch_send_event, 0);
rbg_define_method(rb_cGdkEventTouch, "set_send_event", gdkeventtouch_set_send_event, 1);
DEFINE_ACCESSOR(rb_cGdkEventTouch, touch, time);
DEFINE_ACCESSOR(rb_cGdkEventTouch, touch, x);
DEFINE_ACCESSOR(rb_cGdkEventTouch, touch, y);
rbg_define_method(rb_cGdkEventTouch, "axes", gdkeventtouch_axes, 0);
rbg_define_method(rb_cGdkEventTouch, "set_axes", gdkeventtouch_set_axes, 2);
DEFINE_ACCESSOR(rb_cGdkEventTouch, touch, state);
DEFINE_ACCESSOR(rb_cGdkEventTouch, touch, emulating_pointer);
DEFINE_ACCESSOR(rb_cGdkEventTouch, touch, device);
DEFINE_ACCESSOR(rb_cGdkEventTouch, touch, x_root);
DEFINE_ACCESSOR(rb_cGdkEventTouch, touch, y_root);
/* GdkEventScroll */
rb_cGdkEventScroll =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_SCROLL, "EventScroll",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventScroll, scroll, time);
DEFINE_ACCESSOR(rb_cGdkEventScroll, scroll, x);
DEFINE_ACCESSOR(rb_cGdkEventScroll, scroll, y);
DEFINE_ACCESSOR(rb_cGdkEventScroll, scroll, state);
DEFINE_ACCESSOR(rb_cGdkEventScroll, scroll, direction);
DEFINE_ACCESSOR(rb_cGdkEventScroll, scroll, device);
DEFINE_ACCESSOR(rb_cGdkEventScroll, scroll, x_root);
DEFINE_ACCESSOR(rb_cGdkEventScroll, scroll, y_root);
DEFINE_INIT(rb_cGdkEventScroll, scroll);
/* GdkScrollDirection */
G_DEF_CLASS(GDK_TYPE_SCROLL_DIRECTION, "Direction", rb_cGdkEventScroll);
G_DEF_CONSTANTS(rb_cGdkEventScroll,
GDK_TYPE_SCROLL_DIRECTION, "GDK_SCROLL_");
/* GdkEventKey */
rb_cGdkEventKey =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_KEY, "EventKey",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventKey, key, time);
DEFINE_ACCESSOR(rb_cGdkEventKey, key, state);
DEFINE_ACCESSOR(rb_cGdkEventKey, key, keyval);
DEFINE_ACCESSOR(rb_cGdkEventKey, key, hardware_keycode);
DEFINE_ACCESSOR(rb_cGdkEventKey, key, group);
/* GdkEventCrossing */
rb_cGdkEventCrossing =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_CROSSING, "EventCrossing",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventCrossing, crossing, subwindow);
DEFINE_ACCESSOR(rb_cGdkEventCrossing, crossing, time);
DEFINE_ACCESSOR(rb_cGdkEventCrossing, crossing, x);
DEFINE_ACCESSOR(rb_cGdkEventCrossing, crossing, y);
DEFINE_ACCESSOR(rb_cGdkEventCrossing, crossing, x_root);
DEFINE_ACCESSOR(rb_cGdkEventCrossing, crossing, y_root);
DEFINE_ACCESSOR(rb_cGdkEventCrossing, crossing, mode);
DEFINE_ACCESSOR(rb_cGdkEventCrossing, crossing, detail);
rbg_define_method(rb_cGdkEventCrossing, "focus?", gdkeventcrossing_focus, 0);
rbg_define_method(rb_cGdkEventCrossing, "set_focus", gdkeventcrossing_set_focus, 1);
DEFINE_ACCESSOR(rb_cGdkEventCrossing, crossing, state);
/* GdkCrossingMode */
G_DEF_CLASS(GDK_TYPE_CROSSING_MODE, "Mode", rb_cGdkEventCrossing);
G_DEF_CONSTANTS(rb_cGdkEventCrossing,
GDK_TYPE_CROSSING_MODE, "GDK_CROSSING_");
/* GdkNotifyType */
G_DEF_CLASS(GDK_TYPE_NOTIFY_TYPE, "NotifyType", rb_cGdkEventScroll);
G_DEF_CONSTANTS(rb_cGdkEventScroll, GDK_TYPE_NOTIFY_TYPE, "GDK_");
/* GdkEventFocus */
rb_cGdkEventFocus =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_FOCUS, "EventFocus",
mGdk, rb_cGdkEvent);
rbg_define_method(rb_cGdkEventFocus, "in?", gdkeventfocus_change_in, 0);
rbg_define_method(rb_cGdkEventFocus, "set_in",
gdkeventfocus_change_set_in, 1);
DEFINE_INIT(rb_cGdkEventFocus, focus_change);
/* GdkEventConfigure */
rb_cGdkEventConfigure =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_CONFIGURE, "EventConfigure",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventConfigure, configure, x);
DEFINE_ACCESSOR(rb_cGdkEventConfigure, configure, y);
DEFINE_ACCESSOR(rb_cGdkEventConfigure, configure, width);
DEFINE_ACCESSOR(rb_cGdkEventConfigure, configure, height);
DEFINE_INIT(rb_cGdkEventConfigure, configure);
/* GdkEventProperty */
rb_cGdkEventProperty =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_PROPERTY, "EventProperty",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventProperty, property, atom);
DEFINE_ACCESSOR(rb_cGdkEventProperty, property, time);
DEFINE_ACCESSOR(rb_cGdkEventProperty, property, state);
DEFINE_INIT(rb_cGdkEventProperty, property);
/* GdkPropertyState */
G_DEF_CLASS(GDK_TYPE_PROPERTY_STATE, "State", rb_cGdkEventProperty);
G_DEF_CONSTANTS(rb_cGdkEventProperty, GDK_TYPE_PROPERTY_STATE, "GDK_");
/* GdkEventSelection */
rb_cGdkEventSelection =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_SELECTION, "EventSelection",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventSelection, selection, selection);
DEFINE_ACCESSOR(rb_cGdkEventSelection, selection, target);
DEFINE_ACCESSOR(rb_cGdkEventSelection, selection, property);
DEFINE_ACCESSOR(rb_cGdkEventSelection, selection, requestor);
DEFINE_ACCESSOR(rb_cGdkEventSelection, selection, time);
/* GdkEventOwnerChange */
rb_cGdkEventOwnerChange =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_OWNER_CHANGE, "EventOwnerChange",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventOwnerChange, owner_change, owner);
DEFINE_ACCESSOR(rb_cGdkEventOwnerChange, owner_change, reason);
DEFINE_ACCESSOR(rb_cGdkEventOwnerChange, owner_change, selection);
DEFINE_ACCESSOR(rb_cGdkEventOwnerChange, owner_change, time);
DEFINE_ACCESSOR(rb_cGdkEventOwnerChange, owner_change, selection_time);
DEFINE_INIT(rb_cGdkEventOwnerChange, owner_change);
/* GdkOwnerChange */
G_DEF_CLASS(GDK_TYPE_OWNER_CHANGE, "OwnerChange", rb_cGdkEventScroll);
G_DEF_CONSTANTS(rb_cGdkEventScroll,
GDK_TYPE_OWNER_CHANGE, "GDK_OWNER_CHANGE_");
/* GdkEventProximity */
rb_cGdkEventProximity =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_PROXIMITY, "EventProximity",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventProximity, proximity, time);
DEFINE_ACCESSOR(rb_cGdkEventProximity, proximity, device);
/* GdkEventDND */
rb_cGdkEventDND =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_DND, "EventDND",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventDND, dnd, context);
DEFINE_ACCESSOR(rb_cGdkEventDND, dnd, time);
DEFINE_ACCESSOR(rb_cGdkEventDND, dnd, x_root);
DEFINE_ACCESSOR(rb_cGdkEventDND, dnd, y_root);
/* GdkEventWindowState */
rb_cGdkEventWindowState =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_WINDOW_STATE, "EventWindowState",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventWindowState, window_state, changed_mask);
DEFINE_ACCESSOR(rb_cGdkEventWindowState, window_state, new_window_state);
DEFINE_INIT(rb_cGdkEventWindowState, window_state);
/* GdkWindowState */
G_DEF_CLASS(GDK_TYPE_WINDOW_STATE, "WindowState", rb_cGdkEventScroll);
G_DEF_CONSTANTS(rb_cGdkEventWindowState,
GDK_TYPE_WINDOW_STATE, "GDK_WINDOW_STATE_");
/* GdkEventSetting */
rb_cGdkEventSetting =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_SETTING, "EventSetting",
mGdk, rb_cGdkEvent);
DEFINE_ACCESSOR(rb_cGdkEventSetting, setting, action);
DEFINE_ACCESSOR(rb_cGdkEventSetting, setting, name);
DEFINE_INIT(rb_cGdkEventSetting, setting);
/* GdkSettingAction */
G_DEF_CLASS(GDK_TYPE_SETTING_ACTION, "Action", rb_cGdkEventScroll);
G_DEF_CONSTANTS(rb_cGdkEventSetting,
GDK_TYPE_SETTING_ACTION, "GDK_SETTING_");
/* GdkEventGrabBroken */
rb_cGdkEventGrabBroken =
G_DEF_CLASS_WITH_PARENT(GDK_TYPE_EVENT_GRAB_BROKEN, "EventGrabBroken",
mGdk, rb_cGdkEvent);
rbg_define_method(rb_cGdkEventGrabBroken,
"keyboard?", gdkeventgrab_broken_keyboard, 0);
rbg_define_method(rb_cGdkEventGrabBroken,
"set_keyboard", gdkeventgrab_broken_set_keyboard, 1);
rbg_define_method(rb_cGdkEventGrabBroken,
"implicit?", gdkeventgrab_broken_implicit, 0);
rbg_define_method(rb_cGdkEventGrabBroken,
"set_implicit", gdkeventgrab_broken_set_implicit, 1);
DEFINE_ACCESSOR(rb_cGdkEventGrabBroken, grab_broken, grab_window);
DEFINE_INIT(rb_cGdkEventGrabBroken, grab_broken);
rbgobj_register_g2r_func(GDK_TYPE_EVENT, &gdkevent_g2r);
}
void
Init_gdk_windowattr(VALUE mGdk)
{
VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_WINDOW_ATTR, "WindowAttr", mGdk);
RG_DEF_METHOD(initialize, 4);
rbg_define_method(RG_TARGET_NAMESPACE, "title", attr_get_title, 0);
rbg_define_method(RG_TARGET_NAMESPACE, "set_title", attr_set_title, 1);
rbg_define_method(RG_TARGET_NAMESPACE, "event_mask", attr_get_event_mask, 0);
rbg_define_method(RG_TARGET_NAMESPACE, "set_event_mask", attr_set_event_mask, 1);
rbg_define_method(RG_TARGET_NAMESPACE, "x", attr_get_x, 0);
rbg_define_method(RG_TARGET_NAMESPACE, "set_x", attr_set_x, 1);
rbg_define_method(RG_TARGET_NAMESPACE, "y", attr_get_y, 0);
rbg_define_method(RG_TARGET_NAMESPACE, "set_y", attr_set_y, 1);
rbg_define_method(RG_TARGET_NAMESPACE, "width", attr_get_width, 0);
rbg_define_method(RG_TARGET_NAMESPACE, "set_width", attr_set_width, 1);
rbg_define_method(RG_TARGET_NAMESPACE, "height", attr_get_height, 0);
rbg_define_method(RG_TARGET_NAMESPACE, "set_height", attr_set_height, 1);
RG_DEF_METHOD(wclass, 0);
RG_DEF_METHOD(set_wclass, 1);
RG_DEF_METHOD(visual, 0);
RG_DEF_METHOD(set_visual, 1);
RG_DEF_METHOD(window_type, 0);
RG_DEF_METHOD(set_window_type, 1);
RG_DEF_METHOD(cursor, 0);
RG_DEF_METHOD(set_cursor, 1);
rbg_define_method(RG_TARGET_NAMESPACE, "wmclass_name", attr_get_wmclass_name, 0);
rbg_define_method(RG_TARGET_NAMESPACE, "set_wmclass_name", attr_set_wmclass_name, 1);
rbg_define_method(RG_TARGET_NAMESPACE, "wmclass_class", attr_get_wmclass_class, 0);
rbg_define_method(RG_TARGET_NAMESPACE, "set_wmclass_class", attr_set_wmclass_class, 1);
RG_DEF_METHOD(override_redirect, 0);
RG_DEF_METHOD(set_override_redirect, 1);
}
void
Init_gst_value(VALUE mGst)
{
memset(&value_list_table, 0, sizeof(value_list_table));
value_list_table.type = GST_TYPE_LIST;
value_list_table.klass = Qnil;
value_list_table.rvalue2gvalue = value_list_rvalue2gvalue;
value_list_table.gvalue2rvalue = value_list_gvalue2rvalue;
RG_DEF_CONVERSION(&value_list_table);
memset(&value_array_table, 0, sizeof(value_array_table));
value_array_table.type = GST_TYPE_ARRAY;
value_array_table.klass = Qnil;
value_array_table.rvalue2gvalue = value_array_rvalue2gvalue;
value_array_table.gvalue2rvalue = value_array_gvalue2rvalue;
RG_DEF_CONVERSION(&value_array_table);
memset(&int_range_table, 0, sizeof(int_range_table));
int_range_table.type = GST_TYPE_INT_RANGE;
int_range_table.klass = Qnil;
int_range_table.get_superclass = int_range_get_superclass;
int_range_table.type_init_hook = NULL;
int_range_table.rvalue2gvalue = int_range_rvalue2gvalue;
int_range_table.gvalue2rvalue = g_value_to_ruby_value;
int_range_table.initialize = NULL;
int_range_table.robj2instance = int_range_robj2instance;
int_range_table.instance2robj = g_value_type_instance_to_ruby_object;
int_range_table.unref = g_value_type_unref;
RG_DEF_CONVERSION(&int_range_table);
cIntRange = G_DEF_CLASS(GST_TYPE_INT_RANGE, "IntRange", mGst);
rb_define_alloc_func(cIntRange, int_range_allocate);
rbg_define_method(cIntRange, "initialize", int_range_initialize, 2);
rbg_define_method(cIntRange, "min", int_range_get_min, 0);
rbg_define_method(cIntRange, "set_min", int_range_set_min, 1);
rbg_define_method(cIntRange, "max", int_range_get_max, 0);
rbg_define_method(cIntRange, "set_max", int_range_set_max, 1);
rbg_define_method(cIntRange, "set", int_range_set, 2);
rbg_define_method(cIntRange, "to_a", int_range_to_a, 0);
rbg_define_method(cIntRange, "to_s", g_value_to_s, 0);
memset(&fourcc_table, 0, sizeof(fourcc_table));
fourcc_table.type = GST_TYPE_FOURCC;
fourcc_table.klass = Qnil;
fourcc_table.get_superclass = fourcc_get_superclass;
fourcc_table.type_init_hook = NULL;
fourcc_table.rvalue2gvalue = fourcc_rvalue2gvalue;
fourcc_table.gvalue2rvalue = g_value_to_ruby_value;
fourcc_table.initialize = NULL;
fourcc_table.robj2instance = fourcc_robj2instance;
fourcc_table.instance2robj = g_value_type_instance_to_ruby_object;
fourcc_table.unref = g_value_type_unref;
RG_DEF_CONVERSION(&fourcc_table);
cFourcc = G_DEF_CLASS(GST_TYPE_FOURCC, "Fourcc", mGst);
rb_define_alloc_func(cFourcc, fourcc_allocate);
rbg_define_method(cFourcc, "initialize", fourcc_initialize, 1);
rbg_define_method(cFourcc, "replace!", fourcc_replace_bang, 1);
rbg_define_method(cFourcc, "to_i", fourcc_to_i, 0);
rbg_define_method(cFourcc, "to_s", g_value_to_s, 0);
memset(&fraction_table, 0, sizeof(fraction_table));
fraction_table.type = GST_TYPE_FRACTION;
fraction_table.klass = rb_const_get(rb_cObject, rb_intern("Rational"));
fraction_table.rvalue2gvalue = fraction_rvalue2gvalue;
fraction_table.gvalue2rvalue = fraction_gvalue2rvalue;
RG_DEF_CONVERSION(&fraction_table);
memset(&fraction_range_table, 0, sizeof(fraction_range_table));
fraction_range_table.type = GST_TYPE_FRACTION_RANGE;
fraction_range_table.klass = Qnil;
fraction_range_table.get_superclass = fraction_range_get_superclass;
fraction_range_table.type_init_hook = NULL;
fraction_range_table.rvalue2gvalue = fraction_range_rvalue2gvalue;
fraction_range_table.gvalue2rvalue = g_value_to_ruby_value;
fraction_range_table.initialize = NULL;
fraction_range_table.robj2instance = fraction_range_robj2instance;
fraction_range_table.instance2robj = g_value_type_instance_to_ruby_object;
fraction_range_table.unref = g_value_type_unref;
RG_DEF_CONVERSION(&fraction_range_table);
cFractionRange = G_DEF_CLASS(GST_TYPE_FRACTION_RANGE, "FractionRange", mGst);
rb_define_alloc_func(cFractionRange, fraction_range_allocate);
rbg_define_method(cFractionRange, "initialize", fraction_range_initialize, 2);
rbg_define_method(cFractionRange, "min", fraction_range_get_min, 0);
rbg_define_method(cFractionRange, "set_min", fraction_range_set_min, 1);
rbg_define_method(cFractionRange, "max", fraction_range_get_max, 0);
rbg_define_method(cFractionRange, "set_max", fraction_range_set_max, 1);
rbg_define_method(cFractionRange, "set", fraction_range_set, 2);
rbg_define_method(cFractionRange, "to_a", fraction_range_to_a, 0);
rbg_define_method(cFractionRange, "to_s", g_value_to_s, 0);
}
void
rbgobj_register_type(VALUE klass, VALUE type_name, GClassInitFunc class_init)
{
GType parent_type;
GTypeInfo *info;
{
const RGObjClassInfo *cinfo = rbgobj_lookup_class(klass);
if (cinfo->klass == klass)
rb_raise(rb_eTypeError,
"already registered class: <%s>",
RBG_INSPECT(klass));
}
{
VALUE superclass = rb_funcall(klass, rb_intern("superclass"), 0);
const RGObjClassInfo *cinfo = rbgobj_lookup_class(superclass);
if (cinfo->klass != superclass)
rb_raise(rb_eTypeError,
"super class must be registered to GLib: <%s>",
RBG_INSPECT(superclass));
parent_type = cinfo->gtype;
}
if (NIL_P(type_name)) {
VALUE klass_name = rb_funcall(klass, rb_intern("name"), 0);
if (strlen(StringValueCStr(klass_name)) == 0)
rb_raise(rb_eTypeError,
"can't determine type name: <%s>",
RBG_INSPECT(klass));
type_name = rb_funcall(klass_name, rb_intern("gsub"),
2,
rb_str_new_cstr("::"),
rb_str_new_cstr(""));
}
{
GTypeQuery query;
g_type_query(parent_type, &query);
/* TODO: Why new? g_type_register_static() doesn’t retain a copy, so
* this should be allocated on the stack. */
info = g_new0(GTypeInfo, 1);
info->class_size = query.class_size;
info->base_init = NULL;
info->base_finalize = NULL;
info->class_init = class_init;
info->class_finalize = NULL;
info->class_data = NULL;
info->instance_size = query.instance_size;
info->n_preallocs = 0;
info->instance_init = NULL;
info->value_table = NULL;
}
{
GType type = g_type_register_static(parent_type,
StringValueCStr(type_name),
info,
0);
rbgobj_register_class(klass, type, TRUE, TRUE);
{
RGObjClassInfo *cinfo = (RGObjClassInfo *)rbgobj_lookup_class(klass);
cinfo->flags |= RBGOBJ_DEFINED_BY_RUBY;
}
{
GType parent = g_type_parent(type);
const RGObjClassInfo *cinfo = GTYPE2CINFO(parent);
VALUE initialize_module;
initialize_module = rb_define_module_under(klass,
RubyGObjectHookModule);
if (!(cinfo->flags & RBGOBJ_DEFINED_BY_RUBY)) {
rbg_define_method(initialize_module,
"initialize", rg_initialize, -1);
}
rb_include_module(klass, initialize_module);
}
}
}
void
Init_gst_message(VALUE mGst)
{
VALUE rb_cGstMessageType;
RGConvertTable table;
memset(&table, 0, sizeof(RGConvertTable));
table.type = GST_TYPE_MESSAGE;
table.get_superclass = get_superclass;
table.instance2robj = instance2robj;
RG_DEF_CONVERSION(&table);
rb_cGstMessage = G_DEF_CLASS(GST_TYPE_MESSAGE, "Message", mGst);
#define DEFINE_MESSAGE(type) \
rb_cGstMessage ## type = \
rb_define_class_under(mGst, "Message" #type, rb_cGstMessage)
DEFINE_MESSAGE(Unknown);
DEFINE_MESSAGE(Eos);
DEFINE_MESSAGE(Error);
DEFINE_MESSAGE(Warning);
DEFINE_MESSAGE(Info);
DEFINE_MESSAGE(Tag);
DEFINE_MESSAGE(Buffering);
DEFINE_MESSAGE(StateChanged);
DEFINE_MESSAGE(StateDirty);
DEFINE_MESSAGE(StepDone);
DEFINE_MESSAGE(ClockProvide);
DEFINE_MESSAGE(ClockLost);
DEFINE_MESSAGE(NewClock);
DEFINE_MESSAGE(StructureChange);
DEFINE_MESSAGE(StreamStatus);
DEFINE_MESSAGE(Application);
DEFINE_MESSAGE(Element);
DEFINE_MESSAGE(SegmentStart);
DEFINE_MESSAGE(SegmentDone);
DEFINE_MESSAGE(Duration);
DEFINE_MESSAGE(Latency);
DEFINE_MESSAGE(AsyncStart);
DEFINE_MESSAGE(AsyncDone);
DEFINE_MESSAGE(Any);
#undef DEFINE_MESSAGE
rb_cGstMessageType = G_DEF_CLASS(GST_TYPE_MESSAGE_TYPE,
"Type", rb_cGstMessage);
G_DEF_CONSTANTS(rb_cGstMessage, GST_TYPE_MESSAGE_TYPE, "GST_MESSAGE_");
rbg_define_method(rb_cGstMessage, "initialize", initialize, 3);
rbg_define_method(rb_cGstMessage, "type", get_type, 0);
rbg_define_method(rb_cGstMessage, "set_type", set_type, 1);
rbg_define_method(rb_cGstMessage, "have_mutex?", have_mutex_p, 0);
rbg_define_method(rb_cGstMessage, "lock", lock, 0);
rbg_define_method(rb_cGstMessage, "unlock", unlock, 0);
rbg_define_method(rb_cGstMessage, "have_cond?", have_cond_p, 0);
rbg_define_method(rb_cGstMessage, "wait", cond_wait, 0);
rbg_define_method(rb_cGstMessage, "signal", cond_signal, 0);
rbg_define_method(rb_cGstMessage, "timestamp", get_timestamp, 0);
rbg_define_method(rb_cGstMessage, "set_timestamp", set_timestamp, 1);
rbg_define_method(rb_cGstMessage, "valid_timestamp?", valid_timestamp_p, 0);
rbg_define_method(rb_cGstMessage, "source", get_source, 0);
rbg_define_method(rb_cGstMessage, "set_source", set_source, 1);
rb_define_alias(rb_cGstMessage, "src", "source");
rb_define_alias(rb_cGstMessage, "set_src", "set_source");
rbg_define_method(rb_cGstMessage, "structure", get_structure, 0);
rbg_define_method(rb_cGstMessageEos, "initialize", eos_initialize, 1);
#if 0
rbg_define_method(rb_cGstMessageError, "initialize", error_initialize, 3);
#endif
rbg_define_method(rb_cGstMessageError, "parse", error_parse, 0);
#if 0
rbg_define_method(rb_cGstMessageWarning, "initialize", warning_initialize, 3);
#endif
rbg_define_method(rb_cGstMessageWarning, "parse", warning_parse, 0);
#if 0
rbg_define_method(rb_cGstMessageInfo, "initialize", info_initialize, 3);
#endif
rbg_define_method(rb_cGstMessageInfo, "parse", info_parse, 0);
#if 0
rbg_define_method(rb_cGstMessageTag, "initialize", tag_initialize, 2);
#endif
rbg_define_method(rb_cGstMessageTag, "parse", tag_parse, 0);
rbg_define_method(rb_cGstMessageBuffering, "initialize",
buffering_initialize, 2);
rbg_define_method(rb_cGstMessageBuffering, "parse", buffering_parse, 0);
rbg_define_method(rb_cGstMessageStateChanged, "initialize",
state_changed_initialize, 4);
rbg_define_method(rb_cGstMessageStateChanged, "parse",
state_changed_parse, 0);
rbg_define_method(rb_cGstMessageStateDirty, "initialize",
state_dirty_initialize, 1);
rbg_define_method(rb_cGstMessageClockProvide, "initialize",
clock_provide_initialize, 3);
rbg_define_method(rb_cGstMessageClockProvide, "parse",
clock_provide_parse, 0);
rbg_define_method(rb_cGstMessageClockLost, "initialize",
clock_lost_initialize, 2);
rbg_define_method(rb_cGstMessageClockLost, "parse", clock_lost_parse, 0);
rbg_define_method(rb_cGstMessageNewClock, "initialize",
new_clock_initialize, 2);
rbg_define_method(rb_cGstMessageNewClock, "parse", new_clock_parse, 0);
rbg_define_method(rb_cGstMessageApplication, "initialize",
application_initialize, 2);
rbg_define_method(rb_cGstMessageElement, "initialize",
element_initialize, 2);
#ifdef HAVE_GST_PBUTILS
rb_cGstMissingMessage =
rb_define_class_under(mGst, "MissingMessage", rb_cGstMessageElement);
rbg_define_method(rb_cGstMissingMessage, "installer_detail",
missing_message_get_installer_detail, 0);
rbg_define_method(rb_cGstMissingMessage, "description",
missing_message_get_description, 0);
rb_cGstMissingURISourceMessage =
rb_define_class_under(mGst, "MissingURISourceMessage",
rb_cGstMissingMessage);
rbg_define_method(rb_cGstMissingURISourceMessage, "initialize",
missing_uri_source_message_initialize, 2);
#endif
rbg_define_method(rb_cGstMessageSegmentStart, "initialize",
segment_start_initialize, 3);
rbg_define_method(rb_cGstMessageSegmentStart, "parse",
segment_start_parse, 0);
rbg_define_method(rb_cGstMessageSegmentDone, "initialize",
segment_done_initialize, 3);
rbg_define_method(rb_cGstMessageSegmentDone, "parse", segment_done_parse, 0);
rbg_define_method(rb_cGstMessageDuration, "initialize",
duration_initialize, 3);
rbg_define_method(rb_cGstMessageDuration, "parse", duration_parse, 0);
rbg_define_method(rb_cGstMessageAsyncStart, "initialize",
async_start_initialize, 2);
rbg_define_method(rb_cGstMessageAsyncStart, "parse", async_start_parse, 0);
rbg_define_method(rb_cGstMessageAsyncDone, "initialize",
async_done_initialize, 1);
rbg_define_method(rb_cGstMessageLatency, "initialize", latency_initialize, 1);
rbg_define_method(rb_cGstMessageType, "name", type_name, 0);
}
static VALUE
rg_s_type_register(int argc, VALUE* argv, VALUE self)
{
VALUE type_name, flags;
volatile VALUE class_init_proc = Qnil;
GType parent_type;
GTypeInfo* info;
rb_scan_args(argc, argv, "03", &type_name, &info, &flags);
{
const RGObjClassInfo* cinfo = rbgobj_lookup_class(self);
if (cinfo->klass == self)
rb_raise(rb_eTypeError, "already registered");
}
{
VALUE superclass = rb_funcall(self, rb_intern("superclass"), 0);
const RGObjClassInfo* cinfo = rbgobj_lookup_class(superclass);
if (cinfo->klass != superclass)
rb_raise(rb_eTypeError, "super class must be registered to GLib");
parent_type = cinfo->gtype;
}
if (NIL_P(type_name)) {
VALUE s = rb_funcall(self, rb_intern("name"), 0);
if (strlen(StringValuePtr(s)) == 0)
rb_raise(rb_eTypeError, "can't determine type name");
type_name = rb_funcall(
rb_eval_string("lambda{|x| x.gsub(/::/,'') }"),
rb_intern("call"), 1, s);
}
{
GTypeQuery query;
g_type_query(parent_type, &query);
/* TODO: Why new? g_type_register_static() doesn’t retain a copy, so
* this should be allocated on the stack. */
info = g_new0(GTypeInfo, 1);
info->class_size = query.class_size;
info->base_init = NULL;
info->base_finalize = NULL;
info->class_init = class_init_func;
info->class_finalize = NULL;
info->class_data = (gpointer)class_init_proc;
info->instance_size = query.instance_size;
info->n_preallocs = 0;
info->instance_init = NULL;
info->value_table = NULL;
}
{
GType type = g_type_register_static(parent_type,
StringValuePtr(type_name),
info,
NIL_P(flags) ? 0 : NUM2INT(flags));
G_RELATIVE(self, class_init_proc);
rbgobj_register_class(self, type, TRUE, TRUE);
{
RGObjClassInfo* cinfo = (RGObjClassInfo*)rbgobj_lookup_class(self);
cinfo->flags |= RBGOBJ_DEFINED_BY_RUBY;
}
{
GType parent = g_type_parent(type);
const RGObjClassInfo* cinfo = GTYPE2CINFO(parent);
VALUE m = rb_define_module_under(self, RubyGObjectHookModule);
if (! (cinfo->flags & RBGOBJ_DEFINED_BY_RUBY)) {
rbg_define_method(m, "initialize", rg_initialize, -1);
}
rb_include_module(self, m);
}
return Qnil;
}
}
