コード例 #1
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);
}
コード例 #2
0
ファイル: rbgtkuimanager.c プロジェクト: Mazwak/ruby-gnome2
void
Init_gtk_uimanager(VALUE mGtk)
{
#if GTK_CHECK_VERSION(2,4,0)
    VALUE RG_TARGET_NAMESPACE;

    RG_TARGET_NAMESPACE = G_DEF_CLASS_WITH_GC_FUNC(GTK_TYPE_UI_MANAGER, "UIManager", mGtk,
                                                   rbuimanager_mark, NULL);

    RG_DEF_METHOD(initialize, 0);
    RG_DEF_METHOD(insert_action_group, 2);
    RG_DEF_METHOD(remove_action_group, 1);
    RG_DEF_METHOD(action_groups, 0);
    RG_DEF_METHOD(accel_group, 0);
    RG_DEF_METHOD(get_widget, 1);
    RG_DEF_ALIAS("[]", "get_widget");
    RG_DEF_METHOD(get_toplevels, 1);
    RG_DEF_METHOD(get_action, 1);
    RG_DEF_METHOD(add_ui, -1);
    RG_DEF_METHOD(new_merge_id, 0);
    RG_DEF_METHOD(remove_ui, 1);
    RG_DEF_METHOD(ensure_update, 0);

    /* GtkUIManagerItemType */
    G_DEF_CLASS(GTK_TYPE_UI_MANAGER_ITEM_TYPE, "ItemType", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_UI_MANAGER_ITEM_TYPE, "GTK_UI_MANAGER_");

#endif
}
コード例 #3
0
void
Init_gtk_treeviewcolumn(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_TREE_VIEW_COLUMN, "TreeViewColumn", mGtk);

    RG_DEF_METHOD(initialize, -1);
    RG_DEF_METHOD(pack_start, 2);
    RG_DEF_METHOD(pack_end, 2);
    RG_DEF_METHOD(clear, 0);
    RG_DEF_METHOD(cell_renderers, 0);
    RG_DEF_METHOD(add_attribute, 3);
    RG_DEF_METHOD(set_attributes, 2);
    RG_DEF_METHOD(set_cell_data_func, 1);
    RG_DEF_METHOD(clear_attributes, 1);
    RG_DEF_METHOD(clicked, 0);
    RG_DEF_METHOD(cell_set_cell_data, 4);
    RG_DEF_METHOD(cell_size, 0);
    RG_DEF_METHOD_P(cell_is_visible, 0);
    RG_DEF_METHOD(focus_cell, 1);
    RG_DEF_METHOD(queue_resize, 0);
#if GTK_CHECK_VERSION(2,12,0)
    RG_DEF_METHOD(tree_view, 0);
#endif
#if !GTK_CHECK_VERSION(2,18,0)
    RG_DEF_METHOD(sort_column_id, 0);
    RG_DEF_METHOD(set_sort_column_id, 1);
    RG_DEF_ALIAS("sort_column_id=", "set_sort_column_id");
#endif
    /* GtkTreeViewColumnSizing */
    G_DEF_CLASS(GTK_TYPE_TREE_VIEW_COLUMN_SIZING, "Sizing", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_TREE_VIEW_COLUMN_SIZING, "GTK_TREE_VIEW_COLUMN_");
}
コード例 #4
0
void 
Init_gtk_recent_filter()
{
#if GTK_CHECK_VERSION(2,10,0)
    VALUE rf = G_DEF_CLASS(GTK_TYPE_RECENT_FILTER, "RecentFilter", mGtk);
    rb_define_method(rf, "initialize", rf_initialize, 0);
    rb_define_method(rf, "name", rf_get_name, 0);
    rb_define_method(rf, "set_name", rf_set_name, 1);
    rb_define_method(rf, "add_mime_type", rf_add_mime_type, 1);
    rb_define_method(rf, "add_pattern", rf_add_pattern, 1);
    rb_define_method(rf, "add_pixbuf_formats", rf_add_pixbuf_formats, 0);
    rb_define_method(rf, "add_application", rf_add_application, 1);
    rb_define_method(rf, "add_group", rf_add_group, 1);
    rb_define_method(rf, "add_age", rf_add_age, 1);
    rb_define_method(rf, "add_custom", rf_add_custom, 1);
    rb_define_method(rf, "needed", rf_get_needed, 0);
    rb_define_method(rf, "filter", rf_filter_filter, 1);

    G_DEF_SETTERS(rf);   

    /* GtkRecentFilterFlags */
    G_DEF_CLASS(GTK_TYPE_RECENT_FILTER_FLAGS, "Flags", rf);
    G_DEF_CONSTANTS(rf, GTK_TYPE_RECENT_FILTER_FLAGS, "GTK_RECENT_FILTER_");
#endif
}
コード例 #5
0
ファイル: rbpangorenderer.c プロジェクト: Vasfed/pango
void
Init_pangorenderer(VALUE mPango)
{
#if PANGO_CHECK_VERSION(1,8,0)
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(PANGO_TYPE_RENDERER, "Renderer", mPango);

    RG_DEF_METHOD(draw_layout, 3);
    RG_DEF_METHOD(draw_layout_line, 3);
    RG_DEF_METHOD(draw_glyphs, 4);
    RG_DEF_METHOD(draw_rectangle, 5);
    RG_DEF_METHOD(draw_error_underline, 4);
    RG_DEF_METHOD(draw_trapezoid, 7);
    RG_DEF_METHOD(draw_glyph, 4);
    RG_DEF_METHOD(activate, 0);
    RG_DEF_METHOD(deactivate, 0); 
    RG_DEF_METHOD(part_changed, 1);
    RG_DEF_METHOD(set_color, 2);
    RG_DEF_METHOD(get_color, 1);
    RG_DEF_METHOD(set_matrix, 1);
    RG_DEF_METHOD(matrix, 0);

    /* PangoRenderPart */
#ifdef HAVE_PANGO_RENDER_PART_GET_TYPE
    G_DEF_CLASS(PANGO_TYPE_RENDER_PART, "Part", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, PANGO_TYPE_RENDER_PART, "PANGO_RENDER_");
#endif

#endif
}
コード例 #6
0
ファイル: rbgtkfilefilter.c プロジェクト: benolee/ruby-gnome2
void 
Init_gtk_file_filter()
{
#if GTK_CHECK_VERSION(2,4,0)

    VALUE gFileFilter = G_DEF_CLASS(GTK_TYPE_FILE_FILTER, "FileFilter", mGtk);

    rb_define_method(gFileFilter, "initialize", ffil_initialize, 0);
    rb_define_method(gFileFilter, "set_name", ffil_set_name, 1);
    rb_define_method(gFileFilter, "name", ffil_get_name, 0);
    rb_define_method(gFileFilter, "add_mime_type", ffil_add_mime_type, 1);
    rb_define_method(gFileFilter, "add_pattern", ffil_add_pattern, 1);
#if GTK_CHECK_VERSION(2,6,0)
    rb_define_method(gFileFilter, "add_pixbuf_formats", ffil_add_pixbuf_formats, 0);
#endif
    rb_define_method(gFileFilter, "add_custom", ffil_add_custom, 1);
    rb_define_method(gFileFilter, "needed", ffil_get_needed, 0);
    rb_define_method(gFileFilter, "filter?", ffil_filter, 5);

    G_DEF_SETTERS(gFileFilter);

    G_DEF_CLASS(GTK_TYPE_FILE_FILTER_FLAGS, "Flags", gFileFilter);
    G_DEF_CONSTANTS(gFileFilter, GTK_TYPE_FILE_FILTER_FLAGS, "GTK_FILE_FILTER_");


#endif
}
コード例 #7
0
void
Init_gtk_treeviewcolumn()
{
    VALUE tvc = G_DEF_CLASS(GTK_TYPE_TREE_VIEW_COLUMN, "TreeViewColumn", mGtk);

    rb_define_method(tvc, "initialize", tvc_initialize, -1);
    rb_define_method(tvc, "pack_start", tvc_pack_start, 2);
    rb_define_method(tvc, "pack_end", tvc_pack_end, 2);
    rb_define_method(tvc, "clear", tvc_clear, 0);
    rb_define_method(tvc, "cell_renderers", tvc_get_cell_renderers, 0);
    rb_define_method(tvc, "add_attribute", tvc_add_attribute, 3);
    rb_define_method(tvc, "set_attributes", tvc_set_attributes, 2);
    rb_define_method(tvc, "set_cell_data_func", tvc_set_cell_data_func, 1);
    rb_define_method(tvc, "clear_attributes", tvc_clear_attributes, 1);
    rb_define_method(tvc, "clicked", tvc_clicked, 0);
    rb_define_method(tvc, "cell_set_cell_data", tvc_cell_set_cell_data, 4);
    rb_define_method(tvc, "cell_size", tvc_cell_get_size, 0);
    rb_define_method(tvc, "cell_is_visible?", tvc_cell_is_visible, 0);
#if GTK_CHECK_VERSION(2,2,0)
    rb_define_method(tvc, "focus_cell", tvc_focus_cell, 1);
#endif
#if GTK_CHECK_VERSION(2,8,0)
    rb_define_method(tvc, "queue_resize", tvc_queue_resize, 0);
#endif
#if GTK_CHECK_VERSION(2,12,0)
    rb_define_method(tvc, "tree_view", tvc_get_tree_view, 0);
#endif
    /* GtkTreeViewColumnSizing */
    G_DEF_CLASS(GTK_TYPE_TREE_VIEW_COLUMN_SIZING, "Sizing", tvc);
    G_DEF_CONSTANTS(tvc, GTK_TYPE_TREE_VIEW_COLUMN_SIZING, "GTK_TREE_VIEW_COLUMN_");
}
コード例 #8
0
ファイル: rbgdkimage.c プロジェクト: msakai/ruby-gnome2
void 
Init_gtk_gdk_image(void)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_IMAGE, "Image", mGdk);

    RG_DEF_METHOD(initialize, 4);
    RG_DEF_METHOD(colormap, 0);
    RG_DEF_METHOD(set_colormap, 1);
    RG_DEF_METHOD(put_pixel, 3);
    RG_DEF_METHOD(get_pixel, 2);
    RG_DEF_METHOD(image_type, 0);
    RG_DEF_METHOD(visual, 0);
    RG_DEF_METHOD(byte_order, 0);
    RG_DEF_METHOD(bits_per_pixel, 0);
    RG_DEF_METHOD(width, 0);
    RG_DEF_METHOD(height, 0);
    RG_DEF_METHOD(depth, 0);
    RG_DEF_METHOD(bpp, 0);
    RG_DEF_METHOD(bpl, 0);

    G_DEF_SETTERS(RG_TARGET_NAMESPACE);

    /* GdkImageType */
    G_DEF_CLASS(GDK_TYPE_IMAGE_TYPE, "Type", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_IMAGE_TYPE, "GDK_IMAGE_");
}
コード例 #9
0
ファイル: rbgsttag.c プロジェクト: benolee/ruby-gnome2
void
Init_gst_tag (void)
{
    VALUE m = rb_define_module_under (mGst, "Tag");

    rb_define_module_function (m, "exists?", rb_gst_tag_exists, 1);
    rb_define_module_function (m, "get_nick", rb_gst_tag_get_nick, 1);
    rb_define_module_function (m, "get_description", 
                                rb_gst_tag_get_description, 1);
    rb_define_module_function (m, "get_flag", rb_gst_tag_get_flag, 1);
    rb_define_module_function (m, "fixed?", rb_gst_tag_fixed, 1);

    G_DEF_CLASS (GST_TYPE_TAG_FLAG, "Flag", m);
    G_DEF_CONSTANTS (m, GST_TYPE_TAG_FLAG, "GST_TAG_");
    G_DEF_CLASS (GST_TYPE_TAG_MERGE_MODE, "MergeMode", m);
    G_DEF_CONSTANTS (m, GST_TYPE_TAG_MERGE_MODE, "GST_TAG_");
}
コード例 #10
0
ファイル: gmountoperation.c プロジェクト: msakai/ruby-gnome2
void
Init_gmountoperation(VALUE glib)
{
        VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_MOUNT_OPERATION, "MountOperation", glib);

        G_DEF_CLASS(G_TYPE_MOUNT_OPERATION_RESULT, "Result", RG_TARGET_NAMESPACE);
        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_MOUNT_OPERATION_RESULT, "G_MOUNT_OPERATION_");

        G_DEF_CLASS(G_TYPE_ASK_PASSWORD_FLAGS, "AskPasswordFlags", glib);
        G_DEF_CONSTANTS(glib, G_TYPE_ASK_PASSWORD_FLAGS, "G_");

        G_DEF_CLASS(G_TYPE_PASSWORD_SAVE, "PasswordSave", glib);
        G_DEF_CONSTANTS(glib, G_TYPE_PASSWORD_SAVE, "G_");

        RG_DEF_METHOD(initialize, 0);
        RG_DEF_METHOD(reply, 1);
}
コード例 #11
0
ファイル: rbgdkconst.c プロジェクト: benolee/ruby-gnome2
/*
 * Gdk module constants
 */
void
Init_gtk_gdk_const()
{
    /* GdkStatus */
    G_DEF_CLASS(GDK_TYPE_STATUS, "Status", mGdk);
    G_DEF_CONSTANTS(mGdk, GDK_TYPE_STATUS, "GDK_");

}
コード例 #12
0
ファイル: rbgtkdrag.c プロジェクト: Vasfed/ruby-gnome2
void
Init_gtk_drag(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGtk, "Drag");

    RG_DEF_MODFUNC(dest_set, 4);
    RG_DEF_MODFUNC(dest_set_proxy, 4);
    RG_DEF_MODFUNC(dest_unset, 1);
    RG_DEF_MODFUNC(dest_find_target, -1);
    RG_DEF_MODFUNC(dest_get_target_list, 1);
    RG_DEF_MODFUNC(dest_set_target_list, 2);
    RG_DEF_MODFUNC(dest_add_text_targets, 1);
    RG_DEF_MODFUNC(dest_add_image_targets, 1);
    RG_DEF_MODFUNC(dest_add_uri_targets, 1);
    RG_DEF_MODFUNC(dest_set_track_motion, 2);
    RG_DEF_MODFUNC(dest_get_track_motion, 1);
    RG_DEF_MODFUNC(finish, 4);
    RG_DEF_MODFUNC(get_data, 4);
    RG_DEF_MODFUNC(get_source_widget, 1);
    RG_DEF_MODFUNC(highlight, 1);
    RG_DEF_MODFUNC(unhighlight, 1);
    RG_DEF_MODFUNC(begin, 5);
    RG_DEF_MODFUNC_P(threshold, 5);
    RG_DEF_MODFUNC(set_icon, -1);
    RG_DEF_MODFUNC(set_icon_name, 4);
    RG_DEF_MODFUNC(set_icon_default, 1);
    RG_DEF_MODFUNC(source_set, 4);
    RG_DEF_MODFUNC(source_set_icon, -1);
    RG_DEF_MODFUNC(source_set_icon_name, 2);
    RG_DEF_MODFUNC(source_unset, 1);
    RG_DEF_MODFUNC(source_set_target_list, 2);
    RG_DEF_MODFUNC(source_get_target_list, 1);
    RG_DEF_MODFUNC(source_add_text_targets, 1);
    RG_DEF_MODFUNC(source_add_image_targets, 1);
    RG_DEF_MODFUNC(source_add_uri_targets, 1);
    G_DEF_SETTERS(RG_TARGET_NAMESPACE);

    /* GtkDestDefaults */
    G_DEF_CLASS(GTK_TYPE_DEST_DEFAULTS, "DestDefaults", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_DEST_DEFAULTS, "GTK_");

    /* GtkTargetFlags */
    G_DEF_CLASS(GTK_TYPE_TARGET_FLAGS, "TargetFlags", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_TARGET_FLAGS, "GTK_");
}
コード例 #13
0
ファイル: rbgdkvisual.c プロジェクト: tec/ruby-gnome2
void
Init_gtk_gdk_visual(VALUE mGdk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_VISUAL, "Visual", mGdk);

    /* class methods */
    RG_DEF_SMETHOD(query_depths, 0);
    RG_DEF_SMETHOD(query_visual_types, 0);
    RG_DEF_SMETHOD(visuals, 0);
    RG_DEF_SMETHOD(best_depth, 0);
    RG_DEF_SMETHOD(best_type, 0);
    RG_DEF_SMETHOD(system, 0);
    RG_DEF_SMETHOD(best, 0);
    RG_DEF_SMETHOD(best_with_depth, 1);
    RG_DEF_SMETHOD(best_with_type, 1);
    RG_DEF_SMETHOD(best_with_both, 2);

    /* instance methods */
#if GTK_CHECK_VERSION(2,2,0)
    RG_DEF_METHOD(screen, 0);
#endif
    RG_DEF_METHOD(visual_type, 0);
    RG_DEF_METHOD(depth, 0);
    RG_DEF_METHOD(byte_order, 0);
    RG_DEF_METHOD(colormap_size, 0);
    RG_DEF_METHOD(bits_per_rgb, 0);
    RG_DEF_METHOD(red_mask, 0);
    RG_DEF_METHOD(red_shift, 0);
    RG_DEF_METHOD(red_prec, 0);
    RG_DEF_METHOD(green_mask, 0);
    RG_DEF_METHOD(green_shift, 0);
    RG_DEF_METHOD(green_prec, 0);
    RG_DEF_METHOD(blue_mask, 0);
    RG_DEF_METHOD(blue_shift, 0);
    RG_DEF_METHOD(blue_prec, 0);

    /* GdkVisualType */
    G_DEF_CLASS(GDK_TYPE_VISUAL_TYPE, "Type", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_VISUAL_TYPE, "GDK_VISUAL_");

    /* GdkByteOrder */
    G_DEF_CLASS(GDK_TYPE_BYTE_ORDER, "ByteOrder", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_BYTE_ORDER, "GDK_");
}
コード例 #14
0
void
Init_glib_utils(void)
{
    /* glib/gutils.h */
#if GLIB_CHECK_VERSION(2, 14, 0)
    G_DEF_CLASS(G_TYPE_USER_DIRECTORY, "UserDirectory", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_USER_DIRECTORY, "G_");
#endif

#if GLIB_CHECK_VERSION(2,2,0)
    RG_DEF_SMETHOD(application_name, 0);
    RG_DEF_SMETHOD(set_application_name, 1);
#endif
    RG_DEF_SMETHOD(prgname, 0);
    RG_DEF_SMETHOD(set_prgname, 1);
    RG_DEF_SMETHOD(getenv, 1);
#if GLIB_CHECK_VERSION(2,4,0)
    RG_DEF_SMETHOD(setenv, 2);
    RG_DEF_SMETHOD(unsetenv, 1);
#endif
#if GLIB_CHECK_VERSION(2,8,0)
#ifdef HAVE_G_LISTENV
    RG_DEF_SMETHOD(listenv, 0);
#endif
    RG_DEF_SMETHOD(host_name, 0);
#endif
    RG_DEF_SMETHOD(user_name, 0);
    RG_DEF_SMETHOD(real_name, 0);

#if GLIB_CHECK_VERSION(2, 6, 0)
    RG_DEF_SMETHOD(user_cache_dir, 0);
    RG_DEF_SMETHOD(user_data_dir, 0);
    RG_DEF_SMETHOD(user_config_dir, 0);
    RG_DEF_SMETHOD(system_data_dirs, 0);
    RG_DEF_SMETHOD(system_config_dirs, 0);
#endif
#if GLIB_CHECK_VERSION(2, 14, 0)
    RG_DEF_SMETHOD(get_user_special_dir, 1);
#endif
    RG_DEF_SMETHOD(home_dir, 0);
    RG_DEF_SMETHOD(tmp_dir, 0);
    RG_DEF_SMETHOD(current_dir, 0);

    RG_DEF_SMETHOD_P(path_is_absolute, 1);
    RG_DEF_SMETHOD(path_skip_root, 1);
    RG_DEF_SMETHOD(path_get_basename, 1);
    RG_DEF_SMETHOD(path_get_dirname, 1);
    RG_DEF_SMETHOD(find_program_in_path, 1);
    RG_DEF_SMETHOD(bit_nth_lsf, 2);
    RG_DEF_SMETHOD(bit_nth_msf, 2);
    RG_DEF_SMETHOD(bit_storage, 1);
    RG_DEF_SMETHOD(spaced_primes_closest, 1);
    RG_DEF_SMETHOD(parse_debug_string, 2);
    RG_DEF_SMETHOD_P(check_version, 3);

}
コード例 #15
0
ファイル: rbgdkdevice.c プロジェクト: geoffyoungs/ruby-gnome2
void 
Init_gtk_gdk_device()
{
    VALUE dev = G_DEF_CLASS(GDK_TYPE_DEVICE, "Device", mGdk);

    rb_define_singleton_method(dev, "list", device_s_list, 0);
    rb_define_singleton_method(dev, "core_pointer", device_s_get_core_pointer, 0);
    rb_define_singleton_method(dev, "set_extension_events", device_s_set_extension_events, 3);

    rb_define_method(dev, "set_source", device_set_source, 1);
    rb_define_method(dev, "set_mode", device_set_mode, 1);
    rb_define_method(dev, "set_key", device_set_key, 3);
    rb_define_method(dev, "set_axis_use", device_set_axis_use, 2);
    rb_define_method(dev, "get_state", device_get_state, 1);
    rb_define_method(dev, "get_history", device_get_history, 3);
    rb_define_method(dev, "get_axis", device_get_axis, 2);

    rb_define_method(dev, "name", device_name, 0);
    rb_define_method(dev, "source", device_source, 0);
    rb_define_method(dev, "mode", device_mode, 0);
    rb_define_method(dev, "has_cursor?", device_has_cursor, 0);
    rb_define_method(dev, "axes", device_axes, 0);
    rb_define_method(dev, "keys", device_keys, 0);

    G_DEF_SETTERS(dev);

    /* GdkInputSource */
    G_DEF_CLASS(GDK_TYPE_INPUT_SOURCE, "InputSource", dev);
    G_DEF_CONSTANTS(dev, GDK_TYPE_INPUT_SOURCE, "GDK_");

    /* GdkInputMode */
    G_DEF_CLASS(GDK_TYPE_INPUT_MODE, "InputMode", dev);
    G_DEF_CONSTANTS(dev, GDK_TYPE_INPUT_MODE, "GDK_");
    
    /* GdkAxisUse */
    G_DEF_CLASS(GDK_TYPE_AXIS_USE, "AxisUse", dev);
    G_DEF_CONSTANTS(dev, GDK_TYPE_AXIS_USE, "GDK_");

    /* GdkExtensionMode */
    G_DEF_CLASS(GDK_TYPE_EXTENSION_MODE, "ExtensionMode", dev);
    G_DEF_CONSTANTS(dev, GDK_TYPE_EXTENSION_MODE, "GDK_");

}
コード例 #16
0
void
Init_atk_text_attribute(VALUE mText)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(ATK_TYPE_TEXT_ATTRIBUTE, "Attribute", mText);
    G_DEF_CONSTANTS(mText, ATK_TYPE_TEXT_ATTRIBUTE, "ATK_TEXT_");

    RG_DEF_SMETHOD(type_register, 1);
    RG_DEF_SMETHOD(for_name, 1);
    RG_DEF_METHOD(get_value, 1);   
}
コード例 #17
0
void 
Init_gtk_message_dialog(void)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_MESSAGE_DIALOG, "MessageDialog", mGtk);

    RG_DEF_METHOD(initialize, -1);
#if GTK_CHECK_VERSION(2,4,0)
    RG_DEF_METHOD(set_markup, 1);
    G_DEF_SETTER(RG_TARGET_NAMESPACE, "markup");
#endif

    /* GtkMessageType */
    G_DEF_CLASS(GTK_TYPE_MESSAGE_TYPE, "Type", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_MESSAGE_TYPE, "GTK_MESSAGE_");

    /* GtkButtonsType */
    G_DEF_CLASS(GTK_TYPE_BUTTONS_TYPE, "ButtonsType", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_BUTTONS_TYPE, "GTK_");
}
コード例 #18
0
ファイル: rbgoocanvasitem.c プロジェクト: msakai/ruby-gnome2
void
Init_goocanvasitem(void)
{
    VALUE RG_TARGET_NAMESPACE;

    RG_TARGET_NAMESPACE = G_DEF_CLASS(GOO_TYPE_CANVAS_ITEM, "CanvasItem", mGoo);

    RG_DEF_METHOD(rotate, 3);
    RG_DEF_METHOD(translate, 2);
    RG_DEF_METHOD(lower, 1);
    RG_DEF_METHOD(raise, 1);
    RG_DEF_METHOD(scale, 2);
    RG_DEF_METHOD(skew_x, 3);
    RG_DEF_METHOD(skew_y, 3);
    RG_DEF_METHOD(set_simple_transform, 4);
    RG_DEF_METHOD(animate, 8);
    RG_DEF_METHOD(stop_animation, 0);

    RG_DEF_METHOD(set_style, 1);

    RG_DEF_METHOD(set_child_property, 3);

    RG_DEF_METHOD(canvas, 0);

    RG_DEF_METHOD(remove_child, 1);

    RG_DEF_METHOD(x1, 0);
    RG_DEF_METHOD(x2, 0);
    RG_DEF_METHOD(y1, 0);
    RG_DEF_METHOD(y2, 0);

    /* Enums */
    G_DEF_CLASS(GOO_TYPE_CANVAS_ITEM_VISIBILITY, "Visibility", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GOO_TYPE_CANVAS_ITEM_VISIBILITY, "GOO_CANVAS_ITEM_");
    G_DEF_CLASS(GOO_TYPE_CANVAS_ANIMATE_TYPE, "AnimateType", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GOO_TYPE_CANVAS_ANIMATE_TYPE, "GOO_CANVAS_");

    G_DEF_CLASS(GOO_TYPE_CANVAS_POINTER_EVENTS, "PointerEvents",RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GOO_TYPE_CANVAS_POINTER_EVENTS,"GOO_CANVAS_");

    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
}
コード例 #19
0
ファイル: rbgtkmenubar.c プロジェクト: Mazwak/ruby-gnome2
void 
Init_gtk_menu_bar(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_MENU_BAR, "MenuBar", mGtk);
    RG_DEF_METHOD(initialize, 0);

#if GTK_CHECK_VERSION(2,8,0)
    /* GtkPackDirection */
    G_DEF_CLASS(GTK_TYPE_PACK_DIRECTION, "PackDirection", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_PACK_DIRECTION, "GTK_");
#endif
}
コード例 #20
0
ファイル: gemblem.c プロジェクト: taf2/ruby-gnome2
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);
}
コード例 #21
0
ファイル: rbgstindexentry.c プロジェクト: Mazwak/ruby-gnome2
void
Init_gst_indexentry (VALUE mGst)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS (GST_TYPE_INDEX_ENTRY, "IndexEntry", mGst);

    rb_undef_method (RG_TARGET_NAMESPACE, "initialize");
    RG_DEF_METHOD(data, 0);
    RG_DEF_METHOD(entry_type, 0);

    G_DEF_CLASS (GST_TYPE_INDEX_ENTRY_TYPE, "Types", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS (RG_TARGET_NAMESPACE, GST_TYPE_INDEX_ENTRY_TYPE, "GST_INDEX_ENTRY_");
}
コード例 #22
0
ファイル: rbgstclockentry.c プロジェクト: Mazwak/ruby-gnome2
void
Init_gst_clock_entry (VALUE mGst)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS (GST_TYPE_CLOCK_ENTRY, "ClockEntry", mGst);

    RG_DEF_METHOD(initialize, -1);
    RG_DEF_METHOD_P(single_shot, 0);
    RG_DEF_METHOD_P(periodic, 0);
    RG_DEF_METHOD(wait, 0);
    RG_DEF_METHOD(wait_async, 0);
    RG_DEF_METHOD(unschedule, 0);
    RG_DEF_METHOD(clock, 0);
    RG_DEF_METHOD(time, 0);
    RG_DEF_METHOD(interval, 0);
    RG_DEF_METHOD(status, 0);

    G_DEF_CLASS (GST_TYPE_CLOCK_ENTRY_TYPE, "Type", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS (RG_TARGET_NAMESPACE, GST_TYPE_CLOCK_ENTRY_TYPE, "GST_CLOCK_ENTRY_");
    G_DEF_CLASS (GST_TYPE_CLOCK_RETURN, "Return", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS (RG_TARGET_NAMESPACE, GST_TYPE_CLOCK_RETURN, "GST_CLOCK_");
}
コード例 #23
0
ファイル: rbgtkarrow.c プロジェクト: Mazwak/ruby-gnome2
void 
Init_gtk_arrow(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_ARROW, "Arrow", mGtk);

    RG_DEF_METHOD(initialize, 2);
    RG_DEF_METHOD(set, 2);

    /* GtkArrowType (from General constants) */
    G_DEF_CLASS(GTK_TYPE_ARROW_TYPE, "Type", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_ARROW_TYPE, "GTK_ARROW_");
}
コード例 #24
0
ファイル: goutputstream.c プロジェクト: taf2/ruby-gnome2
void
Init_goutputstream(VALUE glib)
{
        VALUE outputstream = G_DEF_CLASS(G_TYPE_OUTPUT_STREAM, "OutputStream", glib);

        G_DEF_CLASS(G_TYPE_OUTPUT_STREAM_SPLICE_FLAGS, "SpliceFlags", outputstream);
	G_DEF_CONSTANTS(outputstream, G_TYPE_OUTPUT_STREAM_SPLICE_FLAGS, "G_OUTPUT_STREAM_");

        rb_define_method(outputstream, "write", stream_write, -1);
        rb_define_method(outputstream, "write_all", stream_write_all, -1);
        rb_define_method(outputstream, "splice", stream_splice, -1);
}
コード例 #25
0
ファイル: rbgdkinput.c プロジェクト: Mazwak/ruby-gnome2
void
Init_gtk_gdk_input(VALUE mGdk)
{
    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGdk, "Input");

    RG_DEF_MODFUNC(add, 2);
    RG_DEF_MODFUNC(remove, 1);

    /* GdkInputCondition */
    G_DEF_CLASS(GDK_TYPE_INPUT_CONDITION, "Condition", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_INPUT_CONDITION, "GDK_INPUT_");

}
コード例 #26
0
ファイル: rbgtkspinbutton.c プロジェクト: msakai/ruby-gnome2
void 
Init_gtk_spin_button(void)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_SPIN_BUTTON, "SpinButton", mGtk);

    RG_DEF_METHOD(initialize, -1);
    RG_DEF_METHOD(configure, 3);
    RG_DEF_METHOD(set_increments, 2);
    RG_DEF_METHOD(set_range, 2);
    RG_DEF_METHOD(value_as_int, 0);
    RG_DEF_METHOD(spin, 2);
    RG_DEF_METHOD(update, 0);
    RG_DEF_METHOD(increments, 0);
    RG_DEF_METHOD(range, 0);

    /* GtkSpinType */
    G_DEF_CLASS(GTK_TYPE_SPIN_TYPE, "Type", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_SPIN_TYPE, "GTK_SPIN_");

    /* GtkSpinButtonUpdatePolicy */
    G_DEF_CLASS(GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY, "UpdatePolicy", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY, "GTK_");
}
コード例 #27
0
void
Init_gtk_texttag()
{
    VALUE gTextTag = G_DEF_CLASS(GTK_TYPE_TEXT_TAG, "TextTag", mGtk);
    rb_define_method(gTextTag, "initialize", initialize, -1);
    rb_define_method(gTextTag, "priority", get_priority, 0);
    rb_define_method(gTextTag, "set_priority", set_priority, 1);
    G_DEF_SETTER(gTextTag, "priority");
    rb_define_method(gTextTag, "event", event, 3);

    /* GtkWrapMode */
    G_DEF_CLASS(GTK_TYPE_WRAP_MODE, "WrapMode", gTextTag);
    G_DEF_CONSTANTS(gTextTag, GTK_TYPE_WRAP_MODE, "GTK_");
}
コード例 #28
0
void
Init_gtk_message_dialog()
{
    VALUE gMessageDialog = G_DEF_CLASS(GTK_TYPE_MESSAGE_DIALOG, "MessageDialog", mGtk);

    rb_define_method(gMessageDialog, "initialize", mdiag_initialize, -1);
#if GTK_CHECK_VERSION(2,4,0)
    rb_define_method(gMessageDialog, "set_markup", mdiag_set_markup, 1);
#endif
#if GTK_CHECK_VERSION(2,6,0)
    rb_define_method(gMessageDialog, "set_secondary_text", mdiag_format_secondary_text, 1);
    rb_define_method(gMessageDialog, "set_secondary_markup", mdiag_format_secondary_markup, 1);
#endif
    G_DEF_SETTERS(gMessageDialog);

    /* GtkMessageType */
    G_DEF_CLASS(GTK_TYPE_MESSAGE_TYPE, "Type", gMessageDialog);
    G_DEF_CONSTANTS(gMessageDialog, GTK_TYPE_MESSAGE_TYPE, "GTK_MESSAGE_");

    /* GtkButtonsType */
    G_DEF_CLASS(GTK_TYPE_BUTTONS_TYPE, "ButtonsType", gMessageDialog);
    G_DEF_CONSTANTS(gMessageDialog, GTK_TYPE_BUTTONS_TYPE, "GTK_");
}
コード例 #29
0
ファイル: rbgstindex.c プロジェクト: benolee/ruby-gnome2
void
Init_gst_index (void)
{
    VALUE c = G_DEF_CLASS (GST_TYPE_INDEX, "Index", mGst);

    rb_define_method (c, "initialize", rb_gst_index_new, 0);
    rb_define_method (c, "readable?", rb_gst_index_is_readable, 0);
    rb_define_method (c, "writable?", rb_gst_index_is_writable, 0);
    rb_define_method (c, "commit", rb_gst_index_commit, 1);
    rb_define_method (c, "group", rb_gst_index_get_group, 0);
    rb_define_method (c, "new_group", rb_gst_index_new_group, 0);
    rb_define_method (c, "set_group", rb_gst_index_set_group, 1);
    rb_define_method (c, "certainty", rb_gst_index_get_certainty, 0);
    rb_define_method (c, "set_certainty", rb_gst_index_set_certainty, 1);
#if 0
    rb_define_method (c, "set_filter", rb_gst_index_set_filter, 0);
    rb_define_method (c, "set_resolver", rb_gst_index_set_resolver, 0);
#endif
    rb_define_method (c, "add", rb_gst_index_add, -1);
    rb_define_method (c, "get_assoc_entry", rb_gst_index_get_assoc_entry, 5);

    G_DEF_CLASS (GST_TYPE_INDEX_CERTAINTY, "Certainty", c);
    G_DEF_CONSTANTS (c, GST_TYPE_INDEX_CERTAINTY, "GST_INDEX_");
    G_DEF_CLASS (GST_TYPE_INDEX_LOOKUP_METHOD, "LookupMethod", c);
    G_DEF_CONSTANTS (c, GST_TYPE_INDEX_LOOKUP_METHOD, "GST_INDEX_");
    G_DEF_CLASS (GST_TYPE_ASSOC_FLAGS, "AssocFlags", c);
    G_DEF_CONSTANTS (c, GST_TYPE_ASSOC_FLAGS, "GST_");
    G_DEF_CLASS (GST_TYPE_INDEX_RESOLVER_METHOD, "ResolverMethod", c);
    G_DEF_CONSTANTS (c, GST_TYPE_INDEX_RESOLVER_METHOD, "GST_INDEX_");
    G_DEF_CLASS (GST_TYPE_INDEX_FLAGS, "Flags", c);
    G_DEF_CONSTANTS (c, GST_TYPE_INDEX_FLAGS, "GST_INDEX_");

    G_DEF_SETTERS (c);

    rb_undef_method (c, "resolver");
    rb_undef_method (c, "resolver=");
}
コード例 #30
0
void
Init_gtk_cellrenderer(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_CELL_RENDERER, "CellRenderer", mGtk);

    RG_DEF_METHOD(get_size, 2);
    RG_DEF_METHOD(render, 6);
    RG_DEF_METHOD(activate, 6);
    RG_DEF_METHOD(start_editing, 6);
#ifndef GTK_DISABLE_DEPRECATED
    RG_DEF_METHOD(editing_canceled, 0);
#endif
    RG_DEF_METHOD(stop_editing, 1);
    RG_DEF_METHOD(fixed_size, 0);
    RG_DEF_METHOD(set_fixed_size, 2);

    /* GtkCellRendererState */
    G_DEF_CLASS(GTK_TYPE_CELL_RENDERER_STATE, "State", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_CELL_RENDERER_STATE, "GTK_CELL_RENDERER_");

    /* GtkCellRendererMode */
    G_DEF_CLASS(GTK_TYPE_CELL_RENDERER_MODE, "Mode", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_CELL_RENDERER_MODE, "GTK_CELL_RENDERER_");
}