static VALUE
rbatk_document_get_locale(VALUE self)
{
    return CSTR2RVAL(atk_document_get_locale(_SELF(self)));
}
static VALUE
rg_accel_path(VALUE self)
{
    const gchar *quark_str = g_quark_to_string(_SELF(self)->accel_path_quark);
    return quark_str ? CSTR2RVAL(quark_str) : Qnil;
}
static gchar *
translate_func(const gchar *path, gpointer func)
{
    VALUE ret = rb_funcall((VALUE)func, id_call, 1, CSTR2RVAL(path));
    return (gchar *)RVAL2CSTR(ret);
}
Beispiel #4
0
/* Accessor */
static VALUE
device_name(VALUE self)
{
    return CSTR2RVAL(_SELF(self)->name);
}
Beispiel #5
0
static VALUE
ifact_s_path_from_widget(VALUE self, VALUE widget)
{
    return CSTR2RVAL(gtk_item_factory_path_from_widget(RVAL2WIDGET(widget)));
}
static VALUE
rg_output_bin(VALUE self)
{
    return CSTR2RVAL(gtk_print_settings_get_output_bin(_SELF(self)));
}
static VALUE
ps_get(VALUE self, VALUE key)
{
    return CSTR2RVAL(gtk_print_settings_get(_SELF(self), RVAL2CSTR(key)));
}
Beispiel #8
0
static VALUE
rg_description(VALUE self)
{
    return CSTR2RVAL(gtk_recent_info_get_description(_SELF(self)));
}
Beispiel #9
0
static VALUE
rg_mime_type(VALUE self)
{
    return CSTR2RVAL(gtk_recent_info_get_mime_type(_SELF(self)));
}
Beispiel #10
0
static VALUE
rg_short_name(VALUE self)
{
    return CSTR2RVAL(gtk_recent_info_get_short_name(_SELF(self)));
}
Beispiel #11
0
static VALUE
rg_uri(VALUE self)
{
    return CSTR2RVAL(gtk_recent_info_get_uri(_SELF(self)));
}
Beispiel #12
0
static VALUE
rg_last_application(VALUE self)
{
    return CSTR2RVAL(gtk_recent_info_last_application(_SELF(self)));
}
Beispiel #13
0
VALUE
rb_gi_argument_to_ruby(GIArgument *argument, GITypeInfo *type_info)
{
    VALUE rb_argument = Qnil;
    GITypeTag type_tag;

    type_tag = g_type_info_get_tag(type_info);
    switch (type_tag) {
      case GI_TYPE_TAG_VOID:
        rb_argument = Qnil;
        break;
      case GI_TYPE_TAG_BOOLEAN:
        rb_argument = CBOOL2RVAL(argument->v_boolean);
        break;
      case GI_TYPE_TAG_INT8:
        rb_argument = INT2NUM(argument->v_int8);
        break;
      case GI_TYPE_TAG_UINT8:
        rb_argument = UINT2NUM(argument->v_uint8);
        break;
      case GI_TYPE_TAG_INT16:
        rb_argument = INT2NUM(argument->v_int16);
        break;
      case GI_TYPE_TAG_UINT16:
        rb_argument = UINT2NUM(argument->v_uint16);
        break;
      case GI_TYPE_TAG_INT32:
        rb_argument = INT2NUM(argument->v_int32);
        break;
      case GI_TYPE_TAG_UINT32:
        rb_argument = UINT2NUM(argument->v_uint32);
        break;
      case GI_TYPE_TAG_INT64:
        rb_argument = LONG2NUM(argument->v_int64);
        break;
      case GI_TYPE_TAG_UINT64:
        rb_argument = ULONG2NUM(argument->v_uint64);
        break;
      case GI_TYPE_TAG_FLOAT:
        rb_argument = DBL2NUM(argument->v_float);
        break;
      case GI_TYPE_TAG_DOUBLE:
        rb_argument = DBL2NUM(argument->v_double);
        break;
      case GI_TYPE_TAG_GTYPE:
        rb_argument = rbgobj_gtype_new(argument->v_size);
        break;
      case GI_TYPE_TAG_UTF8:
        rb_argument = CSTR2RVAL(argument->v_string);
        break;
      case GI_TYPE_TAG_FILENAME:
        /* TODO: set encoding */
        rb_argument = CSTR2RVAL(argument->v_string);
        break;
      case GI_TYPE_TAG_ARRAY:
        rb_argument = array_to_ruby(argument->v_pointer, type_info);
        break;
      case GI_TYPE_TAG_INTERFACE:
        rb_argument = interface_to_ruby(argument, type_info);
        break;
      case GI_TYPE_TAG_GLIST:
      case GI_TYPE_TAG_GSLIST:
      case GI_TYPE_TAG_GHASH:
        rb_raise(rb_eNotImpError, "TODO: GIArgument(unichar) -> Ruby");
        break;
      case GI_TYPE_TAG_ERROR:
        rb_argument = GERROR2RVAL(argument->v_pointer);
        break;
      case GI_TYPE_TAG_UNICHAR:
        rb_raise(rb_eNotImpError,
                 "TODO: GIArgument(%s) -> Ruby",
                 g_type_tag_to_string(type_tag));
        break;
      default:
        g_assert_not_reached();
        break;
    }

    return rb_argument;
}
Beispiel #14
0
static VALUE
rg_composite_name(VALUE self)
{
    return CSTR2RVAL(gtk_widget_get_composite_name(_SELF(self)));
}
Beispiel #15
0
static VALUE
rg_dither(VALUE self)
{
    return CSTR2RVAL(gtk_print_settings_get_dither(_SELF(self)));
}
Beispiel #16
0
static VALUE
rg_filename(VALUE self)
{
    return CSTR2RVAL(gtk_icon_info_get_filename(_SELF(self)));
}
Beispiel #17
0
static VALUE
rg_finishings(VALUE self)
{
    return CSTR2RVAL(gtk_print_settings_get_finishings(_SELF(self)));
}
Beispiel #18
0
static VALUE
rg_display_name(VALUE self)
{
    return CSTR2RVAL(gtk_icon_info_get_display_name(_SELF(self)));
}
Beispiel #19
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
}
Beispiel #20
0
static VALUE
ps_s_get_default(VALUE self)
{
    return CSTR2RVAL(gtk_paper_size_get_default());
}
Beispiel #21
0
static void
ps_foreach_cb(const gchar *key, const gchar *value, gpointer data)
{
    rb_funcall((VALUE)data, id_call, 2, CSTR2RVAL(key), CSTR2RVAL(value));
}
Beispiel #22
0
static VALUE
ps_get_ppd_name(VALUE self)
{
    return CSTR2RVAL(gtk_paper_size_get_ppd_name(_SELF(self)));
}
Beispiel #23
0
void 
Init_gtk_itemfactory()
{
    VALUE gItemFactory = G_DEF_CLASS(GTK_TYPE_ITEM_FACTORY, "ItemFactory", mGtk);

    rb_define_singleton_method(gItemFactory, "from_widget", ifact_s_from_widget, 1);
    rb_define_singleton_method(gItemFactory, "path_from_widget", ifact_s_path_from_widget, 1);

    rb_define_method(gItemFactory, "initialize", ifact_initialize, 3);
    rb_define_method(gItemFactory, "construct", ifact_construct, -1);
    rb_define_method(gItemFactory, "get_item", ifact_get_item, 1);
    rb_define_method(gItemFactory, "get_widget", ifact_get_widget, 1);
    rb_define_method(gItemFactory, "create_item", ifact_create_item, -1);
    rb_define_method(gItemFactory, "create_items", ifact_create_items, 1);
    rb_define_method(gItemFactory, "delete_item", ifact_delete_item, 1);
    rb_define_method(gItemFactory, "popup", ifact_popup, 4);

    /* Ruby/GTK Original constants */
    rb_define_const(gItemFactory, "TYPE_MENU_BAR", INT2FIX(GTK_TYPE_MENU_BAR));
    rb_define_const(gItemFactory, "TYPE_MENU", INT2FIX(GTK_TYPE_MENU));
    rb_define_const(gItemFactory, "TYPE_OPTION_MENU", INT2FIX(GTK_TYPE_OPTION_MENU));

    rb_define_const(gItemFactory, "TITLE", CSTR2RVAL("<Title>"));
    rb_define_const(gItemFactory, "ITEM", CSTR2RVAL("<Item>"));
    rb_define_const(gItemFactory, "CHECK_ITEM", CSTR2RVAL("<CheckItem>"));
    rb_define_const(gItemFactory, "TOGGLE_ITEM", CSTR2RVAL("<ToggleItem>"));
    rb_define_const(gItemFactory, "RADIO_ITEM", CSTR2RVAL("<RadioItem>"));
    rb_define_const(gItemFactory, "IMAGE_ITEM", CSTR2RVAL("<ImageItem>"));
    rb_define_const(gItemFactory, "STOCK_ITEM", CSTR2RVAL("<StockItem>"));
    rb_define_const(gItemFactory, "SEPARATOR", CSTR2RVAL("<Separator>"));
    rb_define_const(gItemFactory, "BRANCH", CSTR2RVAL("<Branch>"));
    rb_define_const(gItemFactory, "LAST_BRANCH", CSTR2RVAL("<LastBranch>"));
    rb_define_const(gItemFactory, "TEAROFF", CSTR2RVAL("<Tearoff>"));

    action_table = rb_hash_new();
    rb_global_variable(&action_table);
}
Beispiel #24
0
static VALUE
rg_shape_engine_type(VALUE self)
{
    return CSTR2RVAL(pango_font_map_get_shape_engine_type(_SELF(self)));
}
Beispiel #25
0
static VALUE
label_get_text(VALUE self)
{
    return CSTR2RVAL(gtk_label_get_text(_SELF(self)));
}
Beispiel #26
0
static VALUE
rg_default_source(VALUE self)
{
    return CSTR2RVAL(gtk_print_settings_get_default_source(_SELF(self)));
}
Beispiel #27
0
static VALUE
rg_get_tab_label_text(VALUE self, VALUE child)
{
    return CSTR2RVAL(gtk_notebook_get_tab_label_text(_SELF(self), 
                                                     RVAL2WIDGET(child)));
}
Beispiel #28
0
static VALUE
rg_media_type(VALUE self)
{
    return CSTR2RVAL(gtk_print_settings_get_media_type(_SELF(self)));
}
static VALUE
actiongroup_translate_string(VALUE self, VALUE str)
{
    return CSTR2RVAL(gtk_action_group_translate_string(_SELF(self), RVAL2CSTR(str)));
}
Beispiel #30
0
static VALUE
rbatk_document_get_attribute_value(VALUE self, VALUE name)
{
    return CSTR2RVAL(atk_document_get_attribute_value(_SELF(self), 
                                                      RVAL2CSTR(name)));
}