Exemplo n.º 1
0
void
Init_goocanvaspoints(VALUE mGoo)
{
    VALUE RG_TARGET_NAMESPACE;

    RG_TARGET_NAMESPACE = G_DEF_CLASS(GOO_TYPE_CANVAS_POINTS, "CanvasPoints", mGoo);

    RG_DEF_METHOD(initialize, 1);
    RG_DEF_METHOD_OPERATOR("[]", get, 1);
    RG_DEF_METHOD_OPERATOR("[]=", set, 2);
    RG_DEF_METHOD(num_points, 0);
}
Exemplo n.º 2
0
void
Init_gtk_gdk_region(void)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_REGION, "Region", mGdk);

    RG_DEF_METHOD(initialize, -1);
    RG_DEF_METHOD(rectangles, 0);
    RG_DEF_METHOD(spans_intersect_each, 2);
    RG_DEF_METHOD(clipbox, 0);
    RG_DEF_METHOD_P(empty, 0);
    RG_DEF_METHOD_OPERATOR("==", equal, 1);
    RG_DEF_METHOD_P(point_in, 2);
    RG_DEF_METHOD(rect_in, 1);
    RG_DEF_METHOD(offset, 2);
    RG_DEF_METHOD(shrink, 2);
    RG_DEF_METHOD(intersect, 1);
    RG_DEF_METHOD(union, 1);
    RG_DEF_METHOD(subtract, 1);
    RG_DEF_METHOD(xor, 1);

    /* GdkOverlapType */
    G_DEF_CLASS(GDK_TYPE_OVERLAP_TYPE, "OverlapType", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_OVERLAP_TYPE, "GDK_");

    /* GdkFillRule */
    G_DEF_CLASS(GDK_TYPE_FILL_RULE, "FillRule", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_FILL_RULE, "GDK_");
}
Exemplo n.º 3
0
void 
Init_gtk_label(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_LABEL, "Label", mGtk);

    RG_DEF_METHOD(initialize, -1);
    RG_DEF_METHOD(text, 0);
    RG_DEF_METHOD(set_text, -1);
    RG_DEF_METHOD_OPERATOR("text=", label_set_text_only, 1);
    RG_DEF_METHOD(set_markup, -1);
    RG_DEF_METHOD_OPERATOR("markup=", label_set_markup_only, 1);
    RG_DEF_METHOD(layout_offsets, 0);
    RG_DEF_METHOD(select_region, 2);
    RG_DEF_METHOD(layout, 0);
    RG_DEF_METHOD(selection_bounds, 0);
}
Exemplo n.º 4
0
void
Init_gtk_recent_info(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_RECENT_INFO, "RecentInfo", mGtk);
    RG_DEF_METHOD(uri, 0);
    RG_DEF_METHOD(display_name, 0);
    RG_DEF_METHOD(description, 0);
    RG_DEF_METHOD(mime_type, 0);
    RG_DEF_METHOD(added, 0);
    RG_DEF_METHOD(modified, 0);
    RG_DEF_METHOD(visited, 0);
    RG_DEF_METHOD_P(private_hint, 0);
    RG_DEF_METHOD(application_info, 1);
    RG_DEF_METHOD(applications, 0);
    RG_DEF_METHOD(last_application, 0);
    RG_DEF_METHOD(groups, 0);
    RG_DEF_METHOD_P(has_group, 1);
    RG_DEF_METHOD_P(has_application, 1);
    RG_DEF_METHOD(get_icon, 1);
    RG_DEF_METHOD(short_name, 0);
    RG_DEF_METHOD(uri_display, 0);
    RG_DEF_METHOD(age, 0);
    RG_DEF_METHOD_P(local, 0);
    RG_DEF_METHOD_P(exist, 0);
    RG_DEF_METHOD_OPERATOR("==", ri_match, 1);
}
Exemplo n.º 5
0
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);
}
Exemplo n.º 6
0
void 
Init_gtk_treeiter(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_TREE_ITER, "TreeIter", mGtk);

    RG_DEF_METHOD_BANG(first, 0);
    RG_DEF_METHOD_BANG(next, 0);
    RG_DEF_METHOD(get_value, 1);
    RG_DEF_ALIAS("[]", "get_value");
    RG_DEF_METHOD(first_child, 0);
    RG_DEF_METHOD(path, 0);
    RG_DEF_METHOD_P(has_child, 0);
    RG_DEF_METHOD(n_children, 0);
    RG_DEF_METHOD(nth_child, 1);
    RG_DEF_METHOD(parent, 0);
    RG_DEF_METHOD(set_value, 2);
    RG_DEF_METHOD_OPERATOR("[]=", treeiter_set_value_eql, 2);
    RG_DEF_METHOD_OPERATOR("==", treeiter_eql, 1);
    RG_DEF_METHOD(to_str, 0);
    RG_DEF_ALIAS("to_s", "to_str");
}
Exemplo n.º 7
0
void 
Init_gtk_treepath(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_TREE_PATH, "TreePath", mGtk);

    id_equal = rb_intern("==");

    RG_DEF_METHOD(initialize, -1);
    RG_DEF_METHOD(to_str, 0);
    RG_DEF_ALIAS("to_s", "to_str");
    RG_DEF_METHOD(append_index, 1);
    RG_DEF_METHOD(prepend_index, 1);
    RG_DEF_METHOD(depth, 0);
    RG_DEF_METHOD(indices, 0);
    RG_DEF_METHOD_OPERATOR("<=>", treepath_compare, 1);
    RG_DEF_METHOD_OPERATOR("==", treepath_equal, 1);
    RG_DEF_METHOD_BANG(next, 0);
    RG_DEF_METHOD_BANG(prev, 0);
    RG_DEF_METHOD_BANG(up, 0);
    RG_DEF_METHOD_BANG(down, 0);
    RG_DEF_METHOD_P(ancestor, 1);
    RG_DEF_METHOD_P(descendant, 1);
}
Exemplo n.º 8
0
void
Init_gst_format (void)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS (GST_TYPE_FORMAT2, "Format", mGst);

    RG_DEF_SMETHOD(each, 0);
    RG_DEF_SMETHOD(find, 1);

    RG_DEF_METHOD(type_id, 0);
    RG_DEF_METHOD(nick, 0);
    RG_DEF_METHOD(description, 0);
    RG_DEF_METHOD_OPERATOR("==", is_equal, 1);

    G_DEF_CLASS (GST_TYPE_FORMAT, "Type", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS (RG_TARGET_NAMESPACE, GST_TYPE_FORMAT, "GST_FORMAT_");
}
Exemplo n.º 9
0
void
Init_pango_color(VALUE mPango)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(PANGO_TYPE_COLOR, "Color", mPango);

    RG_DEF_METHOD(initialize, 3);
    RG_DEF_METHOD(parse, 1);
    RG_DEF_METHOD(red, 0);
    RG_DEF_METHOD(set_red, 1);
    RG_DEF_METHOD(green, 0);
    RG_DEF_METHOD(set_green, 1);
    RG_DEF_METHOD(blue, 0);
    RG_DEF_METHOD(set_blue, 1);
    RG_DEF_METHOD(to_a, 0);
    RG_DEF_METHOD_OPERATOR("==", color_equal, 1);
}
Exemplo n.º 10
0
void
Init_gdk_atom(VALUE mGdk)
{
    VALUE none;
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_ATOM, "Atom", mGdk);

    RG_DEF_SMETHOD(intern, -1);

    RG_DEF_METHOD(initialize, 1);
    RG_DEF_METHOD(name, 0);
    RG_DEF_METHOD(to_i, 0);
    RG_DEF_METHOD_OPERATOR("==", equal, 1);

    /* This is a trick to define GDK_NONE as a BOXED object */
    none = GDKATOM2RVAL((gpointer)1);
    rb_define_const(RG_TARGET_NAMESPACE, "NONE", none);
    _SELF(none) = GDK_NONE;
}           
Exemplo n.º 11
0
void
Init_gtk_paper_size(VALUE mGtk)
{
#if GTK_CHECK_VERSION(2,10,0)
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_PAPER_SIZE, "PaperSize", mGtk);

    RG_DEF_SMETHOD(default, 0);

    rb_define_const(RG_TARGET_NAMESPACE, "A3", CSTR2RVAL(GTK_PAPER_NAME_A3));
    rb_define_const(RG_TARGET_NAMESPACE, "A4", CSTR2RVAL(GTK_PAPER_NAME_A4));
    rb_define_const(RG_TARGET_NAMESPACE, "A5", CSTR2RVAL(GTK_PAPER_NAME_A5));
    rb_define_const(RG_TARGET_NAMESPACE, "B5", CSTR2RVAL(GTK_PAPER_NAME_B5));
    rb_define_const(RG_TARGET_NAMESPACE, "LETTER", CSTR2RVAL(GTK_PAPER_NAME_LETTER));
    rb_define_const(RG_TARGET_NAMESPACE, "EXECUTIVE",
                    CSTR2RVAL(GTK_PAPER_NAME_EXECUTIVE));
    rb_define_const(RG_TARGET_NAMESPACE, "LEGAL", CSTR2RVAL(GTK_PAPER_NAME_LEGAL));

    RG_DEF_METHOD(initialize, -1);
    RG_DEF_METHOD_OPERATOR("==", equal, 1);

    RG_DEF_METHOD(name, 0);
    RG_DEF_METHOD(display_name, 0);
    RG_DEF_METHOD(ppd_name, 0);

    RG_DEF_METHOD(get_width, 1);
    RG_DEF_METHOD(get_height, 1);

    RG_DEF_METHOD_P(custom, 0);

    RG_DEF_METHOD(set_size, 3);

    RG_DEF_METHOD(get_default_top_margin, 1);
    RG_DEF_METHOD(get_default_bottom_margin, 1);
    RG_DEF_METHOD(get_default_left_margin, 1);
    RG_DEF_METHOD(get_default_right_margin, 1);

    G_DEF_SETTERS(RG_TARGET_NAMESPACE);

    /* GtkUnit */
    G_DEF_CLASS(GTK_TYPE_UNIT, "Unit", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_UNIT, "GTK_");

#endif
}
Exemplo n.º 12
0
void
Init_gst_plugin (VALUE mGst)
{
    VALUE RG_TARGET_NAMESPACE;

    RG_TARGET_NAMESPACE = G_DEF_CLASS(GST_TYPE_PLUGIN, "Plugin", mGst);

    RG_DEF_METHOD_P(loaded, 0);
    RG_DEF_METHOD_OPERATOR("==", is_equal, 1);

    RG_DEF_METHOD(filename, 0);
    RG_DEF_METHOD(major_version, 0);
    RG_DEF_METHOD(minor_version, 0);
    RG_DEF_METHOD(name, 0);
    RG_DEF_METHOD(description, 0);
    RG_DEF_METHOD(version, 0);
    RG_DEF_METHOD(license, 0);
    RG_DEF_METHOD(source, 0);
    RG_DEF_METHOD(package, 0);
    RG_DEF_METHOD(origin, 0);
}
Exemplo n.º 13
0
void
Init_gtk_printer(void)
{
#ifdef HAVE_GTK_UNIX_PRINT
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_PRINTER, "Printer", mGtk);
    rb_include_module(RG_TARGET_NAMESPACE, rb_mComparable);

    G_DEF_CLASS(GTK_TYPE_PRINT_BACKEND, "PrintBackend", mGtk);

    RG_DEF_SMETHOD(each, -1);

    RG_DEF_METHOD(initialize, 3);
    RG_DEF_METHOD(description, 0);
    RG_DEF_METHOD_P(active, 0);
    RG_DEF_METHOD_P(default, 0);
    RG_DEF_METHOD_OPERATOR("<=>", p_compare, 1);

    G_DEF_CLASS3("GtkPrintBackendCups", "PrintBackendCups", mGtk);
    G_DEF_CLASS3("GtkPrintBackendFile", "PrintBackendFile", mGtk);
    G_DEF_CLASS3("GtkPrintBackendLpr", "PrintBackendLpr", mGtk);

    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
#endif
}
Exemplo n.º 14
0
void
Init_pango_layout(VALUE mPango)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(PANGO_TYPE_LAYOUT, "Layout", mPango);

    RG_DEF_METHOD(initialize, 1);
    RG_DEF_METHOD(copy, 0);
    RG_DEF_METHOD(context, 0);
    RG_DEF_METHOD(context_changed, 0);
    RG_DEF_METHOD(set_text, 1);
    RG_DEF_METHOD(text, 0);
    RG_DEF_METHOD(set_markup, -1);
    RG_DEF_METHOD_OPERATOR("markup=", layout_set_markup_eq, 1);
    RG_DEF_METHOD(set_attributes, 1);
    RG_DEF_METHOD(attributes, 0);
    RG_DEF_METHOD(set_font_description, 1);
#ifdef HAVE_PANGO_LAYOUT_GET_FONT_DESCRIPTION
    RG_DEF_METHOD(font_description, 0);
#endif
    RG_DEF_METHOD(set_width, 1);
    RG_DEF_METHOD(width, 0);
    RG_DEF_METHOD(set_wrap, 1);
    RG_DEF_METHOD(wrap, 0);
#ifdef HAVE_PANGO_LAYOUT_SET_ELLIPSIZE
    RG_DEF_METHOD(set_ellipsize, 1);
    RG_DEF_METHOD(ellipsize, 0);
#endif
    RG_DEF_METHOD(set_indent, 1);
    RG_DEF_METHOD(indent, 0);
    RG_DEF_METHOD(spacing, 0);
    RG_DEF_METHOD(set_spacing, 1);
    RG_DEF_METHOD(set_justify, 1);
    RG_DEF_METHOD_P(justify, 0);
#if PANGO_CHECK_VERSION(1,4,0)
    RG_DEF_METHOD(set_auto_dir, 1);
    RG_DEF_METHOD_P(auto_dir, 0);
#endif
    RG_DEF_METHOD(set_alignment, 1);
    RG_DEF_METHOD(alignment, 0);
    RG_DEF_METHOD(set_tabs, 1);
    RG_DEF_METHOD(tabs, 0);
    RG_DEF_METHOD(set_single_paragraph_mode, 1);
    RG_DEF_METHOD_P(single_paragraph_mode, 0);
    RG_DEF_METHOD(log_attrs, 0);
    RG_DEF_METHOD(xy_to_index, 2);
    RG_DEF_METHOD(index_to_pos, 1);
    RG_DEF_METHOD(get_cursor_pos, 1);
    RG_DEF_METHOD(move_cursor_visually, 4);
    RG_DEF_METHOD(get_extents, -1);
    RG_DEF_METHOD(extents, 0);
    RG_DEF_METHOD(get_pixel_extents, -1);
    RG_DEF_METHOD(pixel_extents, 0);
    RG_DEF_METHOD(size, 0);
    RG_DEF_METHOD(pixel_size, 0);
    RG_DEF_METHOD(line_count, 0);
    RG_DEF_METHOD(get_line, 1);
    RG_DEF_METHOD(lines, 0);
    RG_DEF_METHOD(iter, 0);

    G_DEF_SETTERS(RG_TARGET_NAMESPACE);

    /* PangoWrapMode */
    G_DEF_CLASS(PANGO_TYPE_WRAP_MODE, "WrapMode", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, PANGO_TYPE_WRAP_MODE, "PANGO_");

    /* PangoAlignment */
    G_DEF_CLASS(PANGO_TYPE_ALIGNMENT, "Alignment", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, PANGO_TYPE_ALIGNMENT, "PANGO_");

#ifdef HAVE_PANGO_LAYOUT_SET_ELLIPSIZE
    /* PangoEllipsizeMode */
    G_DEF_CLASS(PANGO_TYPE_ELLIPSIZE_MODE, "EllipsizeMode", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, PANGO_TYPE_ELLIPSIZE_MODE, "PANGO_");
#endif
}
Exemplo n.º 15
0
void
Init_gtk_print_settings(void)
{
#if GTK_CHECK_VERSION(2,10,0)
    VALUE RG_TARGET_NAMESPACE;

    s_string = ID2SYM(rb_intern("string"));
    s_bool = ID2SYM(rb_intern("bool"));
    s_double = ID2SYM(rb_intern("double"));
    s_length = ID2SYM(rb_intern("length"));
    s_int = ID2SYM(rb_intern("int"));

    RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_PRINT_SETTINGS,
                                 "PrintSettings", mGtk);

    rb_include_module(RG_TARGET_NAMESPACE, rb_mEnumerable);

#if GTK_CHECK_VERSION(2,12,0)
    RG_DEF_METHOD(initialize, -1);
#else
    RG_DEF_METHOD(initialize, 0);
#endif
    RG_DEF_METHOD(dup, 0);
    RG_DEF_METHOD_P(has_key, 1);

    RG_DEF_METHOD(get, -1);
    RG_DEF_ALIAS("[]", "get");
    RG_DEF_METHOD(get_bool, 1);
    RG_DEF_METHOD(get_double, -1);
    RG_DEF_METHOD(get_length, 2);
    RG_DEF_METHOD(get_int, -1);

    RG_DEF_METHOD(set, -1);
    RG_DEF_METHOD_OPERATOR("[]=", ps_set_generic_indexer, -1);

    RG_DEF_METHOD(unset, -1);
    RG_DEF_ALIAS("delete", "unset");

    RG_DEF_METHOD(each, 0);

    rb_define_const(RG_TARGET_NAMESPACE, "PRINTER",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_PRINTER));
    rb_define_const(RG_TARGET_NAMESPACE, "ORIENTATION",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_ORIENTATION));
    rb_define_const(RG_TARGET_NAMESPACE, "PAPER_FORMAT",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_PAPER_FORMAT));
    rb_define_const(RG_TARGET_NAMESPACE, "PAPER_WIDTH",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_PAPER_WIDTH));
    rb_define_const(RG_TARGET_NAMESPACE, "PAPER_HEIGHT",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_PAPER_HEIGHT));
    rb_define_const(RG_TARGET_NAMESPACE, "N_COPIES",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_N_COPIES));
    rb_define_const(RG_TARGET_NAMESPACE, "DEFAULT_SOURCE",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_DEFAULT_SOURCE));
    rb_define_const(RG_TARGET_NAMESPACE, "QUALITY",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_QUALITY));
    rb_define_const(RG_TARGET_NAMESPACE, "RESOLUTION",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_RESOLUTION));
    rb_define_const(RG_TARGET_NAMESPACE, "USE_COLOR",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_USE_COLOR));
    rb_define_const(RG_TARGET_NAMESPACE, "DUPLEX",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_DUPLEX));
    rb_define_const(RG_TARGET_NAMESPACE, "COLLATE",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_COLLATE));
    rb_define_const(RG_TARGET_NAMESPACE, "REVERSE",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_REVERSE));
    rb_define_const(RG_TARGET_NAMESPACE, "MEDIA_TYPE",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_MEDIA_TYPE));
    rb_define_const(RG_TARGET_NAMESPACE, "DITHER",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_DITHER));
    rb_define_const(RG_TARGET_NAMESPACE, "SCALE",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_SCALE));
    rb_define_const(RG_TARGET_NAMESPACE, "PRINT_PAGES",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_PRINT_PAGES));
    rb_define_const(RG_TARGET_NAMESPACE, "PAGE_RANGES",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_PAGE_RANGES));
    rb_define_const(RG_TARGET_NAMESPACE, "PAGE_SET",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_PAGE_SET));
    rb_define_const(RG_TARGET_NAMESPACE, "FINISHINGS",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_FINISHINGS));
    rb_define_const(RG_TARGET_NAMESPACE, "NUMBER_UP",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_NUMBER_UP));
    rb_define_const(RG_TARGET_NAMESPACE, "OUTPUT_BIN",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_OUTPUT_BIN));

    rb_define_const(RG_TARGET_NAMESPACE, "OUTPUT_FILE_FORMAT",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT));
    rb_define_const(RG_TARGET_NAMESPACE, "OUTPUT_URI",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_OUTPUT_URI));

    rb_define_const(RG_TARGET_NAMESPACE, "WIN32_DRIVER_VERSION",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_WIN32_DRIVER_VERSION));
    rb_define_const(RG_TARGET_NAMESPACE, "WIN32_DRIVER_EXTRA",
                    CSTR2RVAL(GTK_PRINT_SETTINGS_WIN32_DRIVER_EXTRA));

    /* Helpers: */
    RG_DEF_METHOD(printer, 0);
    RG_DEF_METHOD(set_printer, 1);
    RG_DEF_METHOD(orientation, 0);
    RG_DEF_METHOD(set_orientation, 1);
    RG_DEF_METHOD(paper_size, 0);
    RG_DEF_METHOD(set_paper_size, 1);
    RG_DEF_METHOD(paper_width, 1);
    RG_DEF_METHOD(set_paper_width, 2);
    RG_DEF_METHOD(paper_height, 1);
    RG_DEF_METHOD(set_paper_height, 2);
    RG_DEF_METHOD_P(use_color, 0);
    RG_DEF_METHOD(set_use_color, 1);
    RG_DEF_METHOD_P(collate, 0);
    RG_DEF_METHOD(set_collate, 1);
    RG_DEF_METHOD_P(reverse, 0);
    RG_DEF_METHOD(set_reverse, 1);
    RG_DEF_METHOD(duplex, 0);
    RG_DEF_METHOD(set_duplex, 1);
    RG_DEF_METHOD(quality, 0);
    RG_DEF_METHOD(set_quality, 1);
    RG_DEF_METHOD(n_copies, 0);
    RG_DEF_METHOD(set_n_copies, 1);
    RG_DEF_METHOD(number_up, 0);
    RG_DEF_METHOD(set_number_up, 1);
    RG_DEF_METHOD(resolution, 0);
    RG_DEF_METHOD(set_resolution, 1);
    RG_DEF_METHOD(scale, 0);
    RG_DEF_METHOD(set_scale, 1);
    RG_DEF_METHOD(print_pages, 0);
    RG_DEF_METHOD(set_print_pages, 1);
    RG_DEF_METHOD(page_ranges, 0);
    RG_DEF_METHOD(set_page_ranges, 1);
    RG_DEF_METHOD(page_set, 0);
    RG_DEF_METHOD(set_page_set, 1);
    RG_DEF_METHOD(default_source, 0);
    RG_DEF_METHOD(set_default_source, 1);
    RG_DEF_METHOD(media_type, 0);
    RG_DEF_METHOD(set_media_type, 1);
    RG_DEF_METHOD(dither, 0);
    RG_DEF_METHOD(set_dither, 1);
    RG_DEF_METHOD(finishings, 0);
    RG_DEF_METHOD(set_finishings, 1);
    RG_DEF_METHOD(output_bin, 0);
    RG_DEF_METHOD(set_output_bin, 1);

    G_DEF_SETTERS(RG_TARGET_NAMESPACE);

    /* GtkPageOrientation */
    G_DEF_CLASS(GTK_TYPE_PAGE_ORIENTATION, "PageOrientation", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_PAGE_ORIENTATION, "GTK_PAGE_");
    /* GtkPrintDuplex */
    G_DEF_CLASS(GTK_TYPE_PRINT_DUPLEX, "PrintDuplex", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_PRINT_DUPLEX, "GTK_PRINT_");
    /* GtkPrintQuality */
    G_DEF_CLASS(GTK_TYPE_PRINT_QUALITY, "PrintQuality", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_PRINT_QUALITY, "GTK_PRINT_");
    /* GtkPrintPages */
    G_DEF_CLASS(GTK_TYPE_PRINT_PAGES, "PrintPages", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_PRINT_PAGES, "GTK_PRINT_");
    /* GtkPageSet */
    G_DEF_CLASS(GTK_TYPE_PAGE_SET, "PageSet", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_PAGE_SET, "GTK_");
#endif
#if GTK_CHECK_VERSION(2,12,0)
    RG_DEF_METHOD(to_file, 1);
    RG_DEF_METHOD(to_key_file, -1);
#endif
}
Exemplo n.º 16
0
void
Init_gobject_gtype(void)
{
#if !GLIB_CHECK_VERSION(2, 35, 1)
    g_type_init();
#endif

    init_typemap();

    /* type */
#ifndef rb_cMutex
    rb_cMutex = rb_const_get(rb_cObject, rb_intern("Mutex"));
#endif
    id_lock = rb_intern("lock");
    id_unlock = rb_intern("unlock");
    lookup_class_mutex = rb_funcall(rb_cMutex, id_new, 0);
    rb_iv_set(mGLib, "lookup_class_mutex", lookup_class_mutex);

    dynamic_gtype_list = g_hash_table_new(g_str_hash, g_str_equal);
    id_gtype = rb_intern("__gobject_gtype__");

    RG_TARGET_NAMESPACE = rb_define_class_under(mGLib, "Type", rb_cObject);

    rb_define_alias(CLASS_OF(RG_TARGET_NAMESPACE), "[]", "new");
    RG_DEF_METHOD(initialize, 1);
    RG_DEF_METHOD(inspect, 0);
    RG_DEF_METHOD_OPERATOR("<=>", type_compare, 1);
    RG_DEF_METHOD_OPERATOR("==", type_eq, 1);
    RG_DEF_METHOD_OPERATOR("<=", type_lt_eq, 1);
    RG_DEF_METHOD_OPERATOR(">=", type_gt_eq, 1);
    RG_DEF_METHOD_OPERATOR("<", type_lt, 1);
    RG_DEF_METHOD_OPERATOR(">", type_gt, 1);
    RG_DEF_ALIAS("eql?", "==");
    RG_DEF_METHOD(hash, 0);
    RG_DEF_ALIAS("to_i", "hash");
    RG_DEF_ALIAS("to_int", "hash");
    RG_DEF_METHOD(to_class, 0);

    RG_DEF_METHOD(fundamental, 0);
    RG_DEF_METHOD_P(fundamental, 0);
    RG_DEF_METHOD_P(derived, 0);
    RG_DEF_METHOD_P(interface, 0);
    RG_DEF_METHOD_P(classed, 0);
    RG_DEF_METHOD_P(instantiatable, 0);
    RG_DEF_METHOD_P(derivable, 0);
    RG_DEF_METHOD_P(deep_derivable, 0);
    RG_DEF_METHOD_P(abstract, 0);
    RG_DEF_METHOD_P(value_abstract, 0);
    RG_DEF_METHOD_P(value_type, 0);
    RG_DEF_METHOD(has_value_table, 0);

    RG_DEF_METHOD(name, 0);
    RG_DEF_ALIAS("to_s", "name");
    RG_DEF_METHOD(parent, 0);
    RG_DEF_METHOD(depth, 0);
    RG_DEF_METHOD(next_base, 1);
    RG_DEF_METHOD_P(type_is_a, 1);
    RG_DEF_METHOD(children, 0);
    RG_DEF_METHOD(interfaces, 0);
    RG_DEF_METHOD(class_size, 0);
    RG_DEF_METHOD(instance_size, 0);

    {
        VALUE ary = rb_ary_new();
        rb_define_const(RG_TARGET_NAMESPACE, "FUNDAMENTAL_MAX", INT2FIX(G_TYPE_FUNDAMENTAL_MAX));
        _def_fundamental_type(ary, G_TYPE_NONE,      "NONE");
        _def_fundamental_type(ary, G_TYPE_INTERFACE, "INTERFACE");
        _def_fundamental_type(ary, G_TYPE_CHAR,      "CHAR");
        _def_fundamental_type(ary, G_TYPE_UCHAR,     "UCHAR");
        _def_fundamental_type(ary, G_TYPE_BOOLEAN,   "BOOLEAN");
        _def_fundamental_type(ary, G_TYPE_INT,       "INT");
        _def_fundamental_type(ary, G_TYPE_UINT,      "UINT");
        _def_fundamental_type(ary, G_TYPE_LONG,      "LONG");
        _def_fundamental_type(ary, G_TYPE_ULONG,     "ULONG");
        _def_fundamental_type(ary, G_TYPE_INT64,     "INT64");
        _def_fundamental_type(ary, G_TYPE_UINT64,    "UINT64");
        _def_fundamental_type(ary, G_TYPE_ENUM,      "ENUM");
        _def_fundamental_type(ary, G_TYPE_FLAGS,     "FLAGS");
        _def_fundamental_type(ary, G_TYPE_FLOAT,     "FLOAT");
        _def_fundamental_type(ary, G_TYPE_DOUBLE,    "DOUBLE");
        _def_fundamental_type(ary, G_TYPE_STRING,    "STRING");
        _def_fundamental_type(ary, G_TYPE_POINTER,   "POINTER");
        _def_fundamental_type(ary, G_TYPE_BOXED,     "BOXED");
        _def_fundamental_type(ary, G_TYPE_PARAM,     "PARAM");
        _def_fundamental_type(ary, G_TYPE_OBJECT,    "OBJECT");
        rb_define_const(RG_TARGET_NAMESPACE, "FUNDAMENTAL_TYPES", ary); /* FIXME: better name */
    }
}
Exemplo n.º 17
0
void
Init_gtk_textiter(VALUE mGtk)
{
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_TEXT_ITER, "TextIter", mGtk);
    rb_include_module(RG_TARGET_NAMESPACE, rb_mComparable);

    is_compat_240 = gtk_check_version(2, 4, 0) ? FALSE : TRUE;

    id_pixbuf = rb_intern("pixbuf");

    RG_DEF_METHOD(buffer, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "offset", get_offset, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "line", get_line, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "line_offset", get_line_offset, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "line_index", get_line_index, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "visible_line_offset", get_visible_line_offset, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "visible_line_index", get_visible_line_index, 0);
    RG_DEF_METHOD(char, 0);

    RG_DEF_METHOD(get_slice, 1);
    RG_DEF_METHOD(get_text, 1);
    RG_DEF_METHOD(get_visible_slice, 1);
    RG_DEF_METHOD(get_visible_text, 1);

    RG_DEF_METHOD(pixbuf, 0);
    RG_DEF_METHOD(marks, 0);
    RG_DEF_METHOD(child_anchor, 0);

    RG_DEF_METHOD(toggled_tags, 1);
    RG_DEF_METHOD_P(begins_tag, 1);
    RG_DEF_METHOD_P(ends_tag, 1);
    RG_DEF_METHOD_P(toggles_tag, 1);
    RG_DEF_METHOD_P(has_tag, 1);
    RG_DEF_METHOD(tags, 0);

    RG_DEF_METHOD_P(editable, 1);
    RG_DEF_METHOD_P(can_insert, 1);

    rb_define_method(RG_TARGET_NAMESPACE, "starts_word?", starts_word, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "ends_word?", ends_word, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "inside_word?", inside_word, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "starts_sentence?", starts_sentence, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "ends_sentence?", ends_sentence, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "starts_line?", starts_line, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "ends_line?", ends_line, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "cursor_position?", is_cursor_position, 0);

    rb_define_method(RG_TARGET_NAMESPACE, "chars_in_line", get_chars_in_line, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "bytes_in_line", get_bytes_in_line, 0);

    RG_DEF_METHOD(attributes, 0);

    RG_DEF_METHOD(language, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "end?", is_end, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "start?", is_start, 0);

    rb_define_method(RG_TARGET_NAMESPACE, "forward_char", forward_char, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "backward_char", backward_char, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "forward_chars", forward_chars, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "backward_chars", backward_chars, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "forward_line", forward_line, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "backward_line", backward_line, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "forward_lines", forward_lines, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "backward_lines", backward_lines, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "forward_word_end", forward_word_end, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "backward_word_start", backward_word_start, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "forward_word_ends", forward_word_ends, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "backward_word_starts", backward_word_starts, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "forward_sentence_end", forward_sentence_end, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "backward_sentence_start", backward_sentence_start, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "forward_sentence_ends", forward_sentence_ends, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "backward_sentence_starts", backward_sentence_starts, 1);

    rb_define_method(RG_TARGET_NAMESPACE, "forward_visible_word_ends", forward_visible_word_ends, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "backward_visible_word_starts", backward_visible_word_starts, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "forward_visible_word_end", forward_visible_word_end, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "backword_visible_word_start", backward_visible_word_start, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "forward_visible_cursor_position", forward_visible_cursor_position, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "backward_visible_cursor_position", backward_visible_cursor_position, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "forward_visible_cursor_positions", forward_visible_cursor_positions, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "backward_visible_cursor_positions", backward_visible_cursor_positions, 1); 
    rb_define_method(RG_TARGET_NAMESPACE, "forward_visible_line", forward_visible_line, 0); 
    rb_define_method(RG_TARGET_NAMESPACE, "backward_visible_line", backward_visible_line, 0); 
    rb_define_method(RG_TARGET_NAMESPACE, "forward_visible_lines", forward_visible_lines, 1); 
    rb_define_method(RG_TARGET_NAMESPACE, "backward_visible_lines", backward_visible_lines, 1); 
    rb_define_method(RG_TARGET_NAMESPACE, "forward_cursor_position", forward_cursor_position, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "backward_cursor_position", backward_cursor_position, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "forward_cursor_positions", forward_cursor_positions, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "backward_cursor_positions", backward_cursor_positions, 1);
    RG_DEF_METHOD(forward_to_end, 0);
    rb_define_method(RG_TARGET_NAMESPACE, "forward_to_line_end", forward_to_line_end, 0);

    rb_define_method(RG_TARGET_NAMESPACE, "set_offset", set_offset, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "set_line", set_line, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "set_line_offset", set_line_offset, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "set_line_index", set_line_index, 1);

    rb_define_method(RG_TARGET_NAMESPACE, "set_visible_line_offset", set_visible_line_offset, 1);
    rb_define_method(RG_TARGET_NAMESPACE, "set_visible_line_index", set_visible_line_index, 1);

    RG_DEF_METHOD(forward_to_tag_toggle, -1);
    RG_DEF_METHOD(backward_to_tag_toggle, -1);
    RG_DEF_METHOD(forward_find_char, -1);
    RG_DEF_METHOD(backward_find_char, -1);
    RG_DEF_METHOD(forward_search, -1);
    RG_DEF_METHOD(backward_search, -1);

    RG_DEF_METHOD_OPERATOR("==", equal, 1);
    RG_DEF_METHOD_OPERATOR("<=>", compare, 1);

    G_DEF_SETTERS(RG_TARGET_NAMESPACE);

    /* GtkTextSearchFlags */
    G_DEF_CLASS(GTK_TYPE_TEXT_SEARCH_FLAGS, "SearchFlags", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_TEXT_SEARCH_FLAGS, "GTK_TEXT_");
}