Пример #1
0
void
Init_gmount(VALUE mGio)
{
        VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(G_TYPE_MOUNT, "Mount", mGio);

        G_DEF_CLASS(G_TYPE_MOUNT_MOUNT_FLAGS, "MountFlags", RG_TARGET_NAMESPACE);
        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_MOUNT_MOUNT_FLAGS, "G_MOUNT_");

        G_DEF_CLASS(G_TYPE_MOUNT_UNMOUNT_FLAGS, "UnmountFlags", RG_TARGET_NAMESPACE);
        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_MOUNT_UNMOUNT_FLAGS, "G_MOUNT_");

        RG_DEF_METHOD(name, 0);
        RG_DEF_METHOD(uuid, 0);
        RG_DEF_METHOD(icon, 0);
        RG_DEF_METHOD(drive, 0);
        RG_DEF_METHOD(root, 0);
        RG_DEF_METHOD(volume, 0);
        RG_DEF_METHOD(default_location, 0);
        RG_DEF_METHOD_P(can_unmount, 0);
        RG_DEF_METHOD(unmount_with_operation, -1);
        RG_DEF_METHOD(unmount_with_operation_finish, 1);
        RG_DEF_METHOD(remount, -1);
        RG_DEF_METHOD(remount_finish, 1);
        RG_DEF_METHOD_P(can_eject, 0);
        RG_DEF_METHOD(eject_with_operation, -1);
        RG_DEF_METHOD(eject_with_operation_finish, 1);
        RG_DEF_METHOD(guess_content_type, -1);
        RG_DEF_METHOD(guess_content_type_finish, 1);
        RG_DEF_METHOD(guess_content_type_sync, -1);
        RG_DEF_METHOD_P(shadowed, 0);
        RG_DEF_METHOD(shadow, 0);
        RG_DEF_METHOD(unshadow, 0);
}
Пример #2
0
void
Init_atk_component(void)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(ATK_TYPE_COMPONENT, "Component", mAtk);
/*
    RG_DEF_METHOD(add_focus_handler, 0);
*/
    RG_DEF_METHOD_P(contains, 3);
    RG_DEF_METHOD(get_extents, 1);
#ifdef HAVE_ATK_COMPONENT_GET_LAYER
    RG_DEF_METHOD(layer, 0);
#endif
#ifdef HAVE_ATK_COMPONENT_GET_MDI_ZORDER
    RG_DEF_METHOD(mdi_zorder, 0);
#endif
    RG_DEF_METHOD(position, 1);
    RG_DEF_METHOD(size, 0);
    RG_DEF_METHOD(grab_focus, 0);
    RG_DEF_METHOD(ref_accessible_at_point, 3);
    RG_DEF_METHOD(remove_focus_handler, 1);
    RG_DEF_METHOD(set_extents, 5);
    RG_DEF_METHOD(set_position, 2);
    RG_DEF_METHOD(set_size, 2);
#if ATK_CHECK_VERSION(1,12,0)
    RG_DEF_METHOD(alpha, 0);
#endif
}
Пример #3
0
void
Init_gvolume(VALUE glib)
{
        VALUE volume = G_DEF_INTERFACE(G_TYPE_VOLUME, "Volume", glib);

        rb_define_const(volume, "IDENTIFIER_KIND_HAL_UDI", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_HAL_UDI));
        rb_define_const(volume, "IDENTIFIER_KIND_LABEL", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_LABEL));
        rb_define_const(volume, "IDENTIFIER_KIND_NFS_MOUNT", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_NFS_MOUNT));
        rb_define_const(volume, "IDENTIFIER_KIND_UNIX_DEVICE", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE));
        rb_define_const(volume, "IDENTIFIER_KIND_UUID", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_UUID));

        rb_define_method(volume, "name", volume_get_name, 0);
        rb_define_method(volume, "uuid", volume_get_uuid, 0);
        rb_define_method(volume, "icon", volume_get_icon, 0);
        rb_define_method(volume, "drive", volume_get_drive, 0);
        rb_define_method(volume, "mount", volume_get_mount, 0);
        rb_define_method(volume, "can_mount?", volume_can_mount, 0);
        rb_define_method(volume, "should_automount?", volume_should_automount, 0);
        rb_define_method(volume, "activation_root", volume_get_activation_root, 0);
        rb_define_method(volume, "mount", volume_mount, -1);
        rb_define_method(volume, "mount_finish", volume_mount_finish, 1);
        rb_define_method(volume, "can_eject?", volume_can_eject, 0);
        rb_define_method(volume, "eject_with_operation", volume_eject_with_operation, -1);
        rb_define_method(volume, "eject_with_operation_finish", volume_eject_with_operation_finish, 1);
        rb_define_method(volume, "enumerate_identifiers", volume_enumerate_identifiers, -1);
        rb_define_alias(volume, "identifiers", "enumerate_identifiers");
        rb_define_method(volume, "get_identifier", volume_get_identifier, 1);
}
Пример #4
0
void
Init_gasyncresult(VALUE glib)
{
        VALUE asyncresult = G_DEF_INTERFACE(G_TYPE_ASYNC_RESULT, "AsyncResult", glib);

        rb_define_method(asyncresult, "source_object", asyncresult_get_source_object, 0);
}
Пример #5
0
void 
Init_gtk_treemodel(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(GTK_TYPE_TREE_MODEL, "TreeModel", mGtk);

    RG_DEF_METHOD(flags, 0);
    RG_DEF_METHOD(n_columns, 0);
    RG_DEF_METHOD(get_column_type, 1);
    RG_DEF_METHOD(iter_first, 0);
    RG_DEF_METHOD(get_iter, 1);
    RG_DEF_METHOD(get_value, 2);
    RG_DEF_METHOD(each, 0);
    RG_DEF_METHOD(row_changed, 2);
    RG_DEF_METHOD(row_inserted, 2);
    RG_DEF_METHOD(row_has_child_toggled, 2);
    RG_DEF_METHOD(row_deleted, 1);
    RG_DEF_METHOD(rows_reordered, 3);
    RG_DEF_METHOD_P(iter_is_valid, 1);

    /* GtkTreeModelFlags */
    G_DEF_CLASS(GTK_TYPE_TREE_MODEL_FLAGS, "Flags", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_TREE_MODEL_FLAGS, "GTK_TREE_MODEL_");

    G_DEF_SIGNAL_FUNC(RG_TARGET_NAMESPACE, "row_changed", (GValToRValSignalFunc)signal_func);
    G_DEF_SIGNAL_FUNC(RG_TARGET_NAMESPACE, "row_inserted", (GValToRValSignalFunc)signal_func);
    G_DEF_SIGNAL_FUNC(RG_TARGET_NAMESPACE, "row_has_child_toggled", (GValToRValSignalFunc)signal_func);
    G_DEF_SIGNAL_FUNC(RG_TARGET_NAMESPACE, "rows_reordered", (GValToRValSignalFunc)signal_rows_reordered_func);

    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
}
Пример #6
0
void
Init_gvolume(VALUE mGio)
{
        VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(G_TYPE_VOLUME, "Volume", mGio);

        rb_define_const(RG_TARGET_NAMESPACE, "IDENTIFIER_KIND_HAL_UDI", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_HAL_UDI));
        rb_define_const(RG_TARGET_NAMESPACE, "IDENTIFIER_KIND_LABEL", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_LABEL));
        rb_define_const(RG_TARGET_NAMESPACE, "IDENTIFIER_KIND_NFS_MOUNT", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_NFS_MOUNT));
        rb_define_const(RG_TARGET_NAMESPACE, "IDENTIFIER_KIND_UNIX_DEVICE", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE));
        rb_define_const(RG_TARGET_NAMESPACE, "IDENTIFIER_KIND_UUID", CSTR2RVAL(G_VOLUME_IDENTIFIER_KIND_UUID));

        RG_DEF_METHOD(name, 0);
        RG_DEF_METHOD(uuid, 0);
        RG_DEF_METHOD(icon, 0);
        RG_DEF_METHOD(drive, 0);
        RG_DEF_METHOD(get_mount, 0);
        RG_DEF_METHOD_P(can_mount, 0);
        RG_DEF_METHOD_P(should_automount, 0);
        RG_DEF_METHOD(activation_root, 0);
        RG_DEF_METHOD(mount, -1);
        RG_DEF_METHOD(mount_finish, 1);
        RG_DEF_METHOD_P(can_eject, 0);
        RG_DEF_METHOD(eject_with_operation, -1);
        RG_DEF_METHOD(eject_with_operation_finish, 1);
        RG_DEF_METHOD(enumerate_identifiers, -1);
        RG_DEF_ALIAS("identifiers", "enumerate_identifiers");
        RG_DEF_METHOD(get_identifier, 1);
}
Пример #7
0
void
rbclt_model_init ()
{
    VALUE klass = G_DEF_INTERFACE (CLUTTER_TYPE_MODEL, "Model",
                                   rbclt_c_clutter);

    rb_define_method (klass, "set_types", rbclt_model_set_types, -1);
    rb_define_method (klass, "set_names", rbclt_model_set_names, -1);
    rb_define_method (klass, "append", rbclt_model_append, -1);
    rb_define_method (klass, "prepend", rbclt_model_prepend, -1);
    rb_define_method (klass, "insert", rbclt_model_insert, -1);
    rb_define_method (klass, "insert_value", rbclt_model_insert_value, -1);
    rb_define_method (klass, "remove", rbclt_model_remove, 1);
    rb_define_method (klass, "n_rows", rbclt_model_get_n_rows, 0);
    rb_define_method (klass, "n_columns", rbclt_model_get_n_columns, 0);
    rb_define_method (klass, "get_column_name", rbclt_model_get_column_name, 1);
    rb_define_method (klass, "get_column_type", rbclt_model_get_column_type, 1);
    rb_define_method (klass, "first_iter", rbclt_model_get_first_iter, 0);
    rb_define_method (klass, "last_iter", rbclt_model_get_last_iter, 0);
    rb_define_method (klass, "get_iter_at_row", rbclt_model_get_iter_at_row, 1);
    rb_define_method (klass, "each", rbclt_model_each, 0);
    rb_define_method (klass, "sorting_column",
                      rbclt_model_get_sorting_column, 0);
    rb_define_method (klass, "set_sorting_column",
                      rbclt_model_set_sorting_column, 1);
    rb_define_method (klass, "set_sort", rbclt_model_set_sort, 1);
    rb_define_method (klass, "set_filter", rbclt_model_set_filter, 0);
    rb_define_method (klass, "resort", rbclt_model_resort, 0);
    rb_define_method (klass, "filter_row?", rbclt_model_filter_row, 1);
    rb_define_method (klass, "filter_iter?", rbclt_model_filter_iter, 1);

    G_DEF_SETTERS (klass);

    klass = G_DEF_INTERFACE (CLUTTER_TYPE_MODEL_ITER, "ModelIter",
                             rbclt_c_clutter);
    rb_define_method (klass, "get", rbclt_model_iter_get, -1);
    rb_define_alias (klass, "[]", "get");
    rb_define_method (klass, "set", rbclt_model_iter_set, -1);
    rb_define_method (klass, "[]=", rbclt_model_iter_array_set, 2);
    rb_define_method (klass, "first?", rbclt_model_iter_is_first, 0);
    rb_define_method (klass, "last?", rbclt_model_iter_is_last, 0);
    rb_define_method (klass, "next!", rbclt_model_iter_next_bang, 0);
    rb_define_method (klass, "next", rbclt_model_iter_next, 0);
    rb_define_method (klass, "prev!", rbclt_model_iter_prev_bang, 0);
    rb_define_method (klass, "prev", rbclt_model_iter_prev, 0);
    rb_define_method (klass, "dup", rbclt_model_iter_dup, 0);
}
Пример #8
0
void
Init_ginitable(VALUE glib)
{
        VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(G_TYPE_INITABLE, "Initable", glib);

        RG_DEF_MODFUNC(new, -1);

        RG_DEF_METHOD(init, -1);
}
Пример #9
0
static VALUE
rg_s_define_interface(G_GNUC_UNUSED VALUE klass,
                      VALUE rb_gtype, VALUE rb_name, VALUE rb_module)
{
    GType gtype;

    gtype = NUM2ULONG(rb_to_int(rb_gtype));
    return G_DEF_INTERFACE(gtype, RVAL2CSTR(rb_name), rb_module);
}
Пример #10
0
void
Init_gtk_celleditable(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(GTK_TYPE_CELL_EDITABLE, "CellEditable", mGtk);

    RG_DEF_METHOD(start_editing, 1);
    RG_DEF_METHOD(editing_done, 0);
    RG_DEF_METHOD(remove_widget, 0);
}
Пример #11
0
void
Init_gthemedicon(VALUE glib)
{
        VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(G_TYPE_THEMED_ICON, "ThemedIcon", glib);

        RG_DEF_METHOD(initialize, -1);
        RG_DEF_METHOD(prepend_name, 1);
        RG_DEF_METHOD(append_name, 1);
}
Пример #12
0
void
Init_gfiledescriptorbased(G_GNUC_UNUSED VALUE mGio)
{
#ifdef HAVE_GIO_UNIX
        VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(G_TYPE_FILE_DESCRIPTOR_BASED, "FileDescriptorBased", mGio);

        RG_DEF_METHOD(fd, 0);
#endif
}
Пример #13
0
void
Init_atk_value(VALUE mAtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(ATK_TYPE_VALUE, "Value", mAtk);

    RG_DEF_METHOD(current, 0);
    RG_DEF_METHOD(max, 0);
    RG_DEF_METHOD(min, 0);
    RG_DEF_METHOD(set_current, 1);
}
Пример #14
0
void
Init_gasyncinitable(VALUE glib)
{
        VALUE asyncinitable = G_DEF_INTERFACE(G_TYPE_ASYNC_INITABLE, "AsyncInitable", glib);

        rb_define_method(asyncinitable, "init_async", asyncinitable_init_async, -1);
        rb_define_method(asyncinitable, "init_finish", asyncinitable_init_finish, 1);
        rb_define_method(asyncinitable, "initialize", asyncinitable_initialize, -1);
        rb_define_method(asyncinitable, "initialize_finish", asyncinitable_initialize_finish, 1);
}
void
Init_milter_error_emittable (void)
{
    VALUE rb_mMilterErrorEmittable;

    rb_mMilterErrorEmittable = G_DEF_INTERFACE(MILTER_TYPE_ERROR_EMITTABLE,
                                               "ErrorEmittable", rb_mMilter);

    G_DEF_SIGNAL_FUNC(rb_mMilterErrorEmittable, "error",
                      error_convert);
}
Пример #16
0
void
Init_gseekable(VALUE mGio)
{
        VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(G_TYPE_SEEKABLE, "Seekable", mGio);

        RG_DEF_METHOD(tell, 0);
        RG_DEF_METHOD_P(can_seek, 0);
        RG_DEF_METHOD(seek, -1);
        RG_DEF_METHOD_P(can_truncate, 0);
        RG_DEF_METHOD(truncate, -1);
}
Пример #17
0
void
rbclt_media_init ()
{
  VALUE klass = G_DEF_INTERFACE (CLUTTER_TYPE_MEDIA, "Media", rbclt_c_clutter);

  rb_define_method (klass, "set_filename", rbclt_media_set_filename, 1);
  rb_define_method (klass, "filename=", rbclt_media_filename_equals, 1);
  rb_define_method (klass, "set_position", rbclt_media_set_position, -1);

  /* All of the other methods are properties so they will get defined
     automatically */
}
Пример #18
0
void
Init_gtk_fontchooser(VALUE mGtk)
{
#if GTK_CHECK_VERSION(3, 2, 0)
    VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(GTK_TYPE_FONT_CHOOSER, "FontChooser", mGtk);

    RG_DEF_METHOD(font_face, 0);
    RG_DEF_METHOD(font_family, 0);
    RG_DEF_METHOD(font_size, 0);
    RG_DEF_METHOD(set_filter_func, 0);
#endif
}
Пример #19
0
void
Init_gemblem(VALUE glib)
{
        VALUE emblem = G_DEF_INTERFACE(G_TYPE_EMBLEM, "Emblem", glib);

        G_DEF_CLASS(G_TYPE_EMBLEM_ORIGIN, "Origin", emblem);
	G_DEF_CONSTANTS(emblem, G_TYPE_EMBLEM_ORIGIN, "G_EMBLEM_");

        rb_define_method(emblem, "initialize", emblem_initialize, -1);
        rb_define_method(emblem, "icon", emblem_icon, 0);
        rb_define_method(emblem, "origin", emblem_origin, 0);
}
Пример #20
0
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);
}
Пример #21
0
void
Init_gobject_typeinterface()
{
    mMetaInterface = rb_define_module_under(mGLib, "MetaInterface");
    rb_define_method(mMetaInterface, "gtype", generic_s_gtype, 0);
    rb_define_method(mMetaInterface, "append_features", interface_s_append_features, 1);
#if GLIB_CHECK_VERSION(2,4,0)
    rb_define_method(mMetaInterface, "install_property", interface_s_install_property, 1);
    rb_define_method(mMetaInterface, "property", interface_s_property, 1);
    rb_define_method(mMetaInterface, "properties", interface_s_properties, -1);
#endif

    rbgobj_mInterface = G_DEF_INTERFACE(G_TYPE_INTERFACE, "Interface", mGLib);
}
Пример #22
0
void
Init_gst_x_overlay(void)
{
    VALUE i = G_DEF_INTERFACE(GST_TYPE_X_OVERLAY, "XOverlay", mGst);
    
    xoverlay_xid_data_quark =
      g_quark_from_static_string("__rbgst_xoverlay_xid_data_quark__");

    rb_define_method(i, "set_xwindow_id", rb_gst_x_overlay_set_xwindow_id, 1);
    rb_define_method(i, "expose", rb_gst_x_overlay_expose, 0);
   
    rb_define_method(i, "got_xwindow_id", rb_gst_x_overlay_got_xwindow_id, 1);
    rb_define_method(i, "set_xwindow_id_with_buswatch", rb_gst_x_overlay_set_xwindow_id_with_buswatch, 2);
    
    G_DEF_SETTERS(i);
}
Пример #23
0
void
Init_gicon(VALUE glib)
{
        VALUE icon = G_DEF_INTERFACE(G_TYPE_ICON, "Icon", glib);

        rb_define_singleton_method(icon, "new_for_string", icon_new_for_string, 1);

        rb_define_method(icon, "hash", icon_hash, 0);
        /* TODO: Define initialize? */
        rb_define_method(icon, "==", icon_equal, 1);
        /* TODO: Implement eql? */
        /* TODO: Which of these three methods do we keep? */
        rb_define_method(icon, "to_string", icon_to_string, 0);
        rb_define_alias(icon, "to_str", "to_string");
        rb_define_alias(icon, "to_s", "to_string");
}
Пример #24
0
void
Init_gst_x_overlay(void)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(GST_TYPE_X_OVERLAY, "XOverlay", mGst);

    xoverlay_xid_data_quark =
      g_quark_from_static_string("__rbgst_xoverlay_xid_data_quark__");

    RG_DEF_METHOD(set_xwindow_id, 1);
    RG_DEF_METHOD(expose, 0);

    RG_DEF_METHOD(got_xwindow_id, 1);
    RG_DEF_METHOD(set_xwindow_id_with_buswatch, 2);

    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
}
Пример #25
0
void
Init_ginetaddress(VALUE glib)
{
        VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(G_TYPE_INET_ADDRESS, "InetAddress", glib);

        RG_DEF_SMETHOD(new_from_string, 1);
        RG_DEF_SMETHOD(new_from_bytes, -1);
        RG_DEF_SMETHOD(new_any, 1);
        RG_DEF_SMETHOD(new_loopback, 1);

        RG_DEF_METHOD(to_bytes, 0);
        RG_DEF_METHOD(get_native_size, 0);
        RG_DEF_METHOD(to_string, 0);
        RG_DEF_ALIAS("to_str", "to_string");
        RG_DEF_ALIAS("to_s", "to_string");
}
Пример #26
0
void
Init_gtk_celllayout()
{
#if GTK_CHECK_VERSION(2,4,0)
    VALUE layout = G_DEF_INTERFACE(GTK_TYPE_CELL_LAYOUT, "CellLayout", mGtk);

    rb_define_method(layout, "pack_start", layout_pack_start, 2);
    rb_define_method(layout, "pack_end", layout_pack_end, 2);
    rb_define_method(layout, "reorder", layout_reorder, 2);
    rb_define_method(layout, "clear", layout_clear, 0);
    rb_define_method(layout, "add_attribute", layout_add_attribute, 3);
    rb_define_method(layout, "set_cell_data_func", layout_set_cell_data_func, 1);
    rb_define_method(layout, "clear_attributes", layout_clear_attributes, 1);
    rb_define_method(layout, "set_attributes", layout_set_attributes, 2);
#endif
}
Пример #27
0
void
Init_gtk_celllayout(VALUE mGtk)
{
#if GTK_CHECK_VERSION(2,4,0)
    VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(GTK_TYPE_CELL_LAYOUT, "CellLayout", mGtk);

    RG_DEF_METHOD(pack_start, 2);
    RG_DEF_METHOD(pack_end, 2);
    RG_DEF_METHOD(reorder, 2);
    RG_DEF_METHOD(clear, 0);
    RG_DEF_METHOD(add_attribute, 3);
    RG_DEF_METHOD(set_cell_data_func, 1);
    RG_DEF_METHOD(clear_attributes, 1);
    RG_DEF_METHOD(set_attributes, 2);
#endif
}
Пример #28
0
void
Init_atk_document(VALUE mAtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(ATK_TYPE_DOCUMENT, "Document", mAtk);

    RG_DEF_METHOD(document_type, 0);
/*
    RG_DEF_METHOD(document, 0);
*/
#if ATK_CHECK_VERSION(1,12,0)
    RG_DEF_METHOD(get_attribute_value, 1);
    RG_DEF_ALIAS("[]", "get_attribute_value");
    RG_DEF_METHOD(set_attribute_value, 2);
    RG_DEF_ALIAS("[]=", "set_attribute_value");
    RG_DEF_METHOD(attributes, 0);
    RG_DEF_METHOD(locale, 0);
#endif
}
Пример #29
0
void
Init_atk_document()
{
    VALUE mDoc = G_DEF_INTERFACE(ATK_TYPE_DOCUMENT, "Document", mAtk);

    rb_define_method(mDoc, "document_type", rbatk_document_get_document_type, 0);
/*
    rb_define_method(mDoc, "document", rbatk_document_get_document, 0);
*/
#if ATK_CHECK_VERSION(1,12,0)
    rb_define_method(mDoc, "get_attribute_value", rbatk_document_get_attribute_value, 1);
    rb_define_alias(mDoc, "[]", "get_attribute_value");
    rb_define_method(mDoc, "set_attribute_value", rbatk_document_set_attribute_value, 2);
    rb_define_alias(mDoc, "[]=", "set_attribute_value");
    rb_define_method(mDoc, "attributes", rbatk_document_get_attributes, 0);
    rb_define_method(mDoc, "locale", rbatk_document_get_locale, 0);
#endif
}
Пример #30
0
void
Init_gappinfo(VALUE glib)
{
        VALUE appinfo = G_DEF_INTERFACE(G_TYPE_APP_INFO, "AppInfo", glib);

        G_DEF_CLASS(G_TYPE_APP_INFO_CREATE_FLAGS, "CreateFlags", appinfo);
        G_DEF_CONSTANTS(appinfo, G_TYPE_APP_INFO_CREATE_FLAGS, "G_APP_INFO_");

        rb_define_singleton_method(appinfo, "create_from_commandline", appinfo_create_from_commandline, -1);
        rb_define_singleton_method(appinfo, "reset_type_associations", appinfo_reset_type_associations, -1);
        rb_define_singleton_method(appinfo, "all", appinfo_get_all, 0);
        rb_define_singleton_method(appinfo, "get_all_for_type", appinfo_get_all_for_type, 1);
        rb_define_singleton_method(appinfo, "get_default_for_type", appinfo_get_default_for_type, -1);
        rb_define_singleton_method(appinfo, "get_default_for_uri_scheme", appinfo_get_default_for_uri_scheme, 1);
        rb_define_singleton_method(appinfo, "launch_default_for_uri", appinfo_launch_default_for_uri, 0);

        rb_define_method(appinfo, "dup", appinfo_dup, 0);
        rb_define_method(appinfo, "equal?", appinfo_equal, 1);
        rb_define_method(appinfo, "id", appinfo_get_id, 0);
        rb_define_method(appinfo, "name", appinfo_get_name, 0);
        rb_define_method(appinfo, "display_name", appinfo_get_display_name, 0);
        rb_define_method(appinfo, "description", appinfo_get_description, 0);
        rb_define_method(appinfo, "executable", appinfo_get_executable, 0);
        rb_define_method(appinfo, "commandline", appinfo_get_commandline, 0);
        rb_define_method(appinfo, "icon", appinfo_get_icon, 0);
        rb_define_method(appinfo, "launch", appinfo_launch, -1);
        rb_define_method(appinfo, "supports_files?", appinfo_supports_files, 0);
        rb_define_method(appinfo, "supports_uris?", appinfo_supports_uris, 0);
        rb_define_method(appinfo, "launch_uris", appinfo_launch_uris, -1);
        rb_define_method(appinfo, "should_show?", appinfo_should_show, 0);
        rb_define_method(appinfo, "can_delete?", appinfo_can_delete, 0);
        rb_define_method(appinfo, "delete", appinfo_delete, 0);
        rb_define_method(appinfo, "set_as_default_for_type", appinfo_set_as_default_for_type, 1);
        rb_define_method(appinfo, "set_as_default_for_extension", appinfo_set_as_default_for_extension, 1);
        rb_define_method(appinfo, "add_supports_type", appinfo_add_supports_type, 1);
        rb_define_method(appinfo, "can_remove_supports_type?", appinfo_can_remove_supports_type, 1);
        rb_define_method(appinfo, "remove_supports_type", appinfo_remove_supports_type, 1);
}