gtk2 0.20.0

data/src/rbgdkpixmap.c

@@ -0,0 +1,255 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkpixmap.c -
+
+  $Author: mutoh $
+  $Date: 2006/11/25 17:50:41 $
+
+  Copyright (C) 2002-2004 Ruby-GNOME2 Project Team
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+#ifdef HAVE_XREADBITMAPFILEDATA
+#include <X11/Xlib.h>
+#endif /* HAVE_XREADBITMAPFILEDATA */
+
+static VALUE
+gdkpmap_initialize(self, win, w, h, depth)
+    VALUE self, win, w, h, depth;
+{
+	G_INITIALIZE(self, gdk_pixmap_new(GDK_WINDOW(RVAL2GOBJ(win)), 
+                                          NUM2INT(w), NUM2INT(h), 
+                                          NUM2INT(depth)));
+	return Qnil;
+}
+
+static VALUE
+gdkpmap_create_from_data(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE win, data, w, h, depth, fg, bg, ret;
+
+    rb_scan_args(argc, argv, "43", &win, &data, &w, &h, &depth, &fg, &bg);
+
+    Check_Type(data, T_STRING);
+    if (NIL_P(depth)){
+        ret = GOBJ2RVAL(gdk_bitmap_create_from_data(NIL_P(win) ? NULL : GDK_WINDOW(RVAL2GOBJ(win)),
+                                                    RVAL2CSTR(data), NUM2INT(w), NUM2INT(h)));
+    } else {
+        ret = GOBJ2RVAL(gdk_pixmap_create_from_data(NIL_P(win) ? NULL : GDK_WINDOW(RVAL2GOBJ(win)),
+                                                    RVAL2CSTR(data), NUM2INT(w), NUM2INT(h), 
+                                                    NUM2INT(depth),
+						    RVAL2GDKCOLOR(fg),
+						    RVAL2GDKCOLOR(bg)));
+    }
+    return ret;
+}
+
+static VALUE
+gdkpmap_create_from_xpm(self, win, color, fname)
+    VALUE self, win, color, fname;
+{
+    GdkPixmap *new;
+    GdkBitmap *mask;
+
+    new = gdk_pixmap_create_from_xpm(GDK_WINDOW(RVAL2GOBJ(win)), &mask,
+				     RVAL2GDKCOLOR(color), RVAL2CSTR(fname));
+    if (!new) {
+		rb_raise(rb_eArgError, "Pixmap not created from %s", RVAL2CSTR(fname));
+    }
+    return rb_assoc_new(GOBJ2RVAL(new),GOBJ2RVAL(mask));
+}
+
+static VALUE
+gdkpmap_create_from_xpm_d(self, win, tcolor, data)
+    VALUE self, win, tcolor, data;
+{
+    GdkPixmap *new;
+    GdkBitmap *mask;
+    int i;
+    gchar **buf;
+
+    Check_Type(data, T_ARRAY);
+    buf = ALLOCA_N(char*, RARRAY_LEN(data));
+    for (i=0; i < RARRAY_LEN(data); i++) {
+        buf[i] = RVAL2CSTR(RARRAY_PTR(data)[i]);
+    }
+    new = gdk_pixmap_create_from_xpm_d(GDK_WINDOW(RVAL2GOBJ(win)),
+				       &mask, RVAL2GDKCOLOR(tcolor), buf);
+
+    return rb_assoc_new(GOBJ2RVAL(new),GOBJ2RVAL(mask));
+}
+
+static VALUE
+gdkpmap_colormap_create_from_xpm(self, win, colormap, tcolor, fname)
+    VALUE self, win, colormap, tcolor, fname;
+{
+    GdkPixmap *new;
+    GdkBitmap *mask;
+
+    new = gdk_pixmap_colormap_create_from_xpm(NIL_P(win) ? NULL : GDK_WINDOW(RVAL2GOBJ(win)), 
+                                              GDK_COLORMAP(RVAL2GOBJ(colormap)),
+                                              &mask, RVAL2GDKCOLOR(tcolor),
+                                              RVAL2CSTR(fname));
+    if (!new) {
+		rb_raise(rb_eArgError, "Pixmap not created from %s", RVAL2CSTR(fname));
+    }
+    return rb_assoc_new(GOBJ2RVAL(new),GOBJ2RVAL(mask));
+}
+
+static VALUE
+gdkpmap_colormap_create_from_xpm_d(self, win, colormap, tcolor, data)
+    VALUE self, win, colormap, tcolor, data;
+{
+    GdkPixmap *new;
+    GdkBitmap *mask;
+    int i;
+    gchar **buf;
+
+    Check_Type(data, T_ARRAY);
+    buf = ALLOCA_N(char*, RARRAY_LEN(data));
+    for (i=0; i<RARRAY_LEN(data); i++) {
+	buf[i] = RVAL2CSTR(RARRAY_PTR(data)[i]);
+    }
+
+    new = gdk_pixmap_colormap_create_from_xpm_d(NIL_P(win) ? NULL : GDK_WINDOW(RVAL2GOBJ(win)),
+                                                GDK_COLORMAP(RVAL2GOBJ(colormap)),
+                                                &mask, RVAL2GDKCOLOR(tcolor),
+						buf);
+
+    return rb_assoc_new(GOBJ2RVAL(new),GOBJ2RVAL(mask));
+}
+
+#ifdef HAVE_XREADBITMAPFILEDATA
+static VALUE
+gdkpmap_create_from_xbm(self, win, fname)
+    VALUE self, win, fname;
+{
+    GdkBitmap *new;
+    unsigned char *data;
+    unsigned int width, height;
+    int x, y;
+
+    Check_Type(fname, T_STRING);
+    if (XReadBitmapFileData(RVAL2CSTR(fname), &width, &height, &data, &x, &y))
+        rb_raise(rb_eArgError, "Bitmap not created from %s", RVAL2CSTR(fname));
+
+    new = gdk_bitmap_create_from_data(GDK_WINDOW(RVAL2GOBJ(win)), 
+                                      (const gchar*)data, width, height);
+    XFree(data);
+    return GOBJ2RVAL(new);
+}
+#endif /* HAVE_XREADBITMAPFILEDATA */
+
+/* From X Window System Interaction */
+/*
+  Gdk::Window.foreign_new(anid)
+  Gdk::Window.foreign_new(display, anid)                       # Since GTK+-2.2
+  Gdk::Window.foreign_new(screen, anid, width, height, depth)  # Since GTK+-2.10
+ */
+
+static VALUE
+gdkpmap_foreign_new(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE arg[5];
+    GdkPixmap* win = NULL;
+    
+    rb_scan_args(argc, argv, "14", &arg[0], &arg[1], &arg[2], &arg[3], &arg[4]);
+    
+    switch(argc)
+        {
+        case 1:
+            win = gdk_pixmap_foreign_new(NUM2UINT(arg[0]));
+            break;
+        case 2:
+#if GTK_CHECK_VERSION(2,2,0)
+            win = gdk_pixmap_foreign_new_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(arg[0])), 
+                                                     NUM2UINT(arg[1])); 
+#else
+            win = gdk_pixmap_foreign_new(NUM2UINT(arg[1])); 
+            rb_warn("Not supported. Use GTK+-2.2.0 or later.");
+#endif
+            break;
+        case 5:
+#if GTK_CHECK_VERSION(2,10,0)
+            win = gdk_pixmap_foreign_new_for_screen(GDK_SCREEN(RVAL2GOBJ(arg[0])), 
+                                                    NUM2UINT(arg[1]), /* anid */
+                                                    NUM2INT(arg[2]),  /* width */
+                                                    NUM2INT(arg[3]),  /* height */
+                                                    NUM2INT(arg[4])); /* depth */
+#else
+            win = gdk_pixmap_foreign_new(NUM2UINT(arg[1])); 
+            rb_warn("Not supported. GTK+-2.10.0 or later.");
+#endif
+            break;
+        }
+    return win ? GOBJ2RVAL(win) : Qnil;
+}
+
+static VALUE
+gdkpmap_lookup(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE arg[2];
+    GdkPixmap* win = NULL;
+    
+    rb_scan_args(argc, argv, "11", &arg[0], &arg[1]);
+
+    switch(argc)
+    {
+      case 1:
+    	win = gdk_pixmap_lookup(NUM2UINT(arg[0]));
+	break;
+      case 2:
+#if GTK_CHECK_VERSION(2,2,0)
+    	win = gdk_pixmap_lookup_for_display(RVAL2GOBJ(arg[0]), NUM2UINT(arg[1])); 
+#else
+    	win = gdk_pixmap_lookup(NUM2UINT(arg[1])); 
+        rb_warn("Not supported in GTK+-2.0.x.");
+#endif
+    	break;
+    }
+    if (win == NULL)
+        return Qnil;
+    else {
+        return GOBJ2RVAL(win);
+    }
+}
+
+void
+Init_gtk_gdk_pixmap()
+{
+    VALUE gdkPixmap = G_DEF_CLASS(GDK_TYPE_PIXMAP, "Pixmap", mGdk);
+
+    rb_define_method(gdkPixmap, "initialize", gdkpmap_initialize, 4);
+    rb_define_singleton_method(gdkPixmap, "create_from_data", gdkpmap_create_from_data, -1);
+    rb_define_singleton_method(gdkPixmap, "create_from_xpm", gdkpmap_create_from_xpm, 3);
+    rb_define_singleton_method(gdkPixmap, "create_from_xpm_d", gdkpmap_create_from_xpm_d, 3);
+    rb_define_singleton_method(gdkPixmap, "colormap_create_from_xpm", gdkpmap_colormap_create_from_xpm, 4);
+    rb_define_singleton_method(gdkPixmap, "colormap_create_from_xpm_d", gdkpmap_colormap_create_from_xpm_d, 4);
+#ifdef HAVE_XREADBITMAPFILEDATA
+    rb_define_singleton_method(gdkPixmap, "create_from_xbm", gdkpmap_create_from_xbm, 2);
+#endif /* HAVE_XREADBITMAPFILEDATA */
+#ifdef GDK_WINDOWING_X11
+    G_DEF_CLASS3("GdkPixmapImplX11", "PixmapImplX11", mGdk);
+#elif defined(GDK_WINDOWING_WIN32)
+    G_DEF_CLASS3("GdkPixmapImplWin32", "PixmapImplWin32", mGdk);
+#elif defined(GDK_WINDOWING_FB)
+    G_DEF_CLASS3("GdkPixmapFB", "PixmapFB", mGdk);
+#endif
+
+    rb_define_singleton_method(gdkPixmap, "foreign_new", gdkpmap_foreign_new, -1);
+    rb_define_singleton_method(gdkPixmap, "lookup", gdkpmap_lookup, -1);
+
+}

data/src/rbgdkproperty.c

@@ -0,0 +1,342 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkproperty.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:31 $
+
+
+  Copyright (C) 2003,2004 Ruby-GNOME2 Project Team
+
+  Devided from rbgdkwindow.c
+  rbgdkwindow.c - 
+  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+#include "global.h"
+
+static VALUE
+gdkprop_text_property_to_text_list(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    gint num, i;
+    gchar** list;
+    VALUE ret = Qnil;
+    
+    if (argc == 3) {
+        VALUE encoding, format, text;
+        rb_scan_args(argc, argv, "30", &encoding, &format, &text);
+        StringValue(text);
+        
+        num = gdk_text_property_to_text_list(RVAL2ATOM(encoding),
+                                             NUM2INT(format),
+                                             (const guchar*)RVAL2CSTR(text), 
+                                             RSTRING_LEN(text), &list);
+    } else {
+#if GTK_CHECK_VERSION(2,2,0)
+        VALUE display, encoding, format, text;
+        rb_scan_args(argc, argv, "40", &display, &encoding, &format, &text);
+        StringValue(text);
+        
+        num = gdk_text_property_to_text_list_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
+                                                         RVAL2ATOM(encoding),
+                                                         NUM2INT(format),
+                                                         (const guchar*)RVAL2CSTR(text),
+                                                         RSTRING_LEN(text),
+                                                         &list);
+#else
+        VALUE encoding, format, text;
+        rb_scan_args(argc, argv, "30", &encoding, &format, &text);
+        rb_warn("Gdk::Property.text_property_to_text_list: Not supported arguments in GTK+-2.0.x.");
+        num = gdk_text_property_to_text_list(RVAL2ATOM(encoding),
+                                             NUM2INT(format),
+                                             (const guchar*)RVAL2CSTR(text),
+                                             RSTRING_LEN(text), &list);
+#endif
+    }
+
+    ret = rb_ary_new2(num);
+    for (i =0; i < num; i++){
+        rb_ary_push(ret, CSTR2RVAL(list[i]));
+    }
+    gdk_free_text_list(list);
+    return ret;
+}
+
+static VALUE
+gdkprop_text_property_to_utf8_list(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    gint num, i;
+    gchar** list;
+    VALUE ret = Qnil;
+    
+    if (argc == 3) {
+        VALUE encoding, format, text;
+        rb_scan_args(argc, argv, "30", &encoding, &format, &text);
+        StringValue(text);
+        
+        num = gdk_text_property_to_utf8_list(RVAL2ATOM(encoding),
+                                             NUM2INT(format),
+                                             (const guchar*)RVAL2CSTR(text),
+                                             RSTRING_LEN(text), &list);
+    } else {
+#if GTK_CHECK_VERSION(2,2,0)
+        VALUE display, encoding, format, text;
+        rb_scan_args(argc, argv, "40", &display, &encoding, &format, &text);
+        StringValue(text);
+        
+        num = gdk_text_property_to_utf8_list_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
+                                                         RVAL2ATOM(encoding),
+                                                         NUM2INT(format),
+                                                         (const guchar*)RVAL2CSTR(text),
+                                                         RSTRING_LEN(text),
+                                                         &list);
+#else
+        VALUE encoding, format, text;
+        rb_scan_args(argc, argv, "30", &encoding, &format, &text);
+        StringValue(text);
+
+        rb_warn("Gdk::Property.text_property_to_utf8_list: Not supported arguments in GTK+-2.0.x.");
+        num = gdk_text_property_to_utf8_list(RVAL2ATOM(encoding),
+                                             NUM2INT(format),
+                                             (const guchar*)RVAL2CSTR(text),
+                                             RSTRING_LEN(text), &list);
+#endif
+    }
+
+    ret = rb_ary_new2(num);
+    for (i =0; i < num; i++){
+        rb_ary_push(ret, CSTR2RVAL(list[i]));
+    }
+    g_strfreev(list);
+    return ret;
+}
+
+static VALUE
+gdkprop_string_to_compound_text(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    gint num;
+    GdkAtom encoding;
+    gint format;
+    guchar *ctext;
+    gint length;
+
+    if (argc == 1) {
+        VALUE str;
+        rb_scan_args(argc, argv, "10", &str);
+        num = gdk_string_to_compound_text(RVAL2CSTR(str),
+                                          &encoding, &format,
+                                          &ctext, &length);
+    } else {
+#if GTK_CHECK_VERSION(2,2,0)
+        VALUE display, str;
+
+        rb_scan_args(argc, argv, "20", &display, &str);
+        num = gdk_string_to_compound_text_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
+                                                      RVAL2CSTR(str),
+                                                      &encoding, &format,
+                                                      &ctext, &length);
+#else
+        VALUE str;
+        rb_scan_args(argc, argv, "10", &str);
+        rb_warn("Gdk::Property.string_to_compound_text: Not supported arguments in GTK+-2.0.x.");
+        num = gdk_string_to_compound_text(RVAL2CSTR(str),
+                                          &encoding, &format,
+                                          &ctext, &length);
+#endif
+    }
+
+    if (num == 0){
+        VALUE ret = CSTR2RVAL((const char*)ctext);
+        gdk_free_compound_text(ctext);
+        return rb_ary_new3(3, BOXED2RVAL(encoding, GDK_TYPE_ATOM),
+                           INT2NUM(format), ret);
+    } else {
+        rb_raise(rb_eRuntimeError, "failed to converts a string %d\n", num);
+    }
+    return Qnil;
+}
+
+static VALUE
+gdkprop_utf8_to_string_target(self, str)
+    VALUE self, str;
+{
+    return CSTR2RVAL((const char*)gdk_utf8_to_string_target(RVAL2CSTR(str)));
+}
+
+static VALUE
+gdkprop_utf8_to_compound_text(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    GdkAtom encoding;
+    gint format;
+    guchar *ctext;
+    gint length;
+    gint ret;
+
+    if (argc == 1) {
+        VALUE str;
+        rb_scan_args(argc, argv, "10", &str);
+    
+        ret = gdk_utf8_to_compound_text(RVAL2CSTR(str),
+                                        &encoding, &format,
+                                        &ctext, &length);
+    } else {
+#if GTK_CHECK_VERSION(2,2,0)
+        VALUE display, str;
+
+        rb_scan_args(argc, argv, "20", &display, &str);
+        ret = gdk_utf8_to_compound_text_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
+                                                    RVAL2CSTR(str),
+                                                    &encoding, &format,
+                                                    &ctext, &length);
+#else
+        VALUE str;
+        rb_scan_args(argc, argv, "10", &str);
+    
+        rb_warn("Gdk::Property.utf8_to_compound_text: Not supported arguments in GTK+-2.0.x.");
+        ret = gdk_utf8_to_compound_text(RVAL2CSTR(str),
+                                        &encoding, &format,
+                                        &ctext, &length);
+#endif
+    }
+
+    if (ret){
+        VALUE val = CSTR2RVAL((const char*)ctext);
+        gdk_free_compound_text(ctext);
+        return rb_ary_new3(3, BOXED2RVAL(encoding, GDK_TYPE_ATOM),
+                           INT2NUM(format), val);
+    } else {
+        rb_raise(rb_eRuntimeError, "failed to converts a string %d\n", ret);
+    }
+    return Qnil;
+}
+
+
+static VALUE
+gdkprop_change(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    int        fmt, len;
+    void*      dat;
+    GdkAtom    ntype;
+    VALUE win, property, type, size= Qnil, mode, src;
+    
+    if(6 == argc)
+        rb_scan_args(argc, argv, "60", &win, &property, &type, &size, &mode, &src);
+    else
+        rb_scan_args(argc, argv, "50", &win, &property, &type, &mode, &src);
+    
+    rbgtk_atom2selectiondata(type, size, src, &ntype, &dat, &fmt, &len);
+    
+    gdk_property_change(GDK_WINDOW(RVAL2GOBJ(win)), RVAL2ATOM(property), 
+                        ntype, fmt, RVAL2GENUM(mode, GDK_TYPE_PROP_MODE), dat, len);
+
+    rbgtk_atom2selectiondata_free(ntype, dat);
+
+    return self;
+}
+
+static VALUE
+gdkprop_get(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    /* for argument processing */
+    GdkAtom     rtype;
+    gint        rfmt, rlen;
+    guchar*	rdat;
+    VALUE win, property, type, offset=INT2FIX(0), length=INT2FIX(9999), delete;
+    
+    /* for inner processing */
+    int		i;
+    VALUE	ret = 0;
+    
+    if(6 == argc)
+        rb_scan_args(argc, argv, "60", &win, &property, &type, &offset, &length, &delete);
+    else
+        rb_scan_args(argc, argv, "40", &win, &property, &type, &delete);
+    
+    
+    if(gdk_property_get(GDK_WINDOW(RVAL2GOBJ(win)), RVAL2ATOM(property), RVAL2ATOM(type),
+                        NUM2INT(offset), NUM2INT(length),
+                        RVAL2CBOOL(delete), &rtype, &rfmt, &rlen, &rdat) == FALSE){
+        return Qnil;
+    }
+ 
+    switch(rfmt){
+      case 8:
+      default:
+        ret = rb_str_new((const char*)rdat, rlen);
+        break;
+        
+      case 16:
+        ret = rb_ary_new();
+        
+        for( i = 0; i < rlen; i++){
+            rb_ary_push(ret, rb_Integer(((unsigned short*)rdat)[i]));
+        }
+        break;
+        
+      case 32:
+         ret = rb_ary_new();
+
+         if(rtype != GDK_SELECTION_TYPE_ATOM){
+           for(i = 0; i < (rlen/sizeof(unsigned long)); i++){
+             rb_ary_push(ret, INT2FIX(((unsigned long*)rdat)[i]));
+           }
+         } else {
+           for(i = 0; i < (rlen/sizeof(unsigned long)); i++){
+             rb_ary_push(ret, BOXED2RVAL((GdkAtom)((unsigned long*)rdat)[i], GDK_TYPE_ATOM));
+           }
+         }
+        break;
+    }
+    
+    return rb_ary_new3(3, BOXED2RVAL(rtype, GDK_TYPE_ATOM), 
+                       ret, INT2NUM(rlen));
+}
+
+static VALUE
+gdkprop_delete(self, win, property)
+    VALUE self, win, property;
+{
+    gdk_property_delete(GDK_WINDOW(RVAL2GOBJ(win)), RVAL2ATOM(property));
+    return self;
+}
+
+void
+Init_gtk_gdk_property()
+{
+    VALUE gdkProperty = rb_define_module_under(mGdk, "Property");
+
+    rb_define_module_function(gdkProperty, "text_property_to_text_list", gdkprop_text_property_to_text_list, -1);
+    rb_define_module_function(gdkProperty, "text_property_to_utf8_list", gdkprop_text_property_to_utf8_list, -1);
+    rb_define_module_function(gdkProperty, "string_to_compound_text", gdkprop_string_to_compound_text, -1);
+    rb_define_module_function(gdkProperty, "utf8_to_string_target", gdkprop_utf8_to_string_target, 1);
+    rb_define_module_function(gdkProperty, "utf8_to_compound_text", gdkprop_utf8_to_compound_text, -1);
+    rb_define_module_function(gdkProperty, "change", gdkprop_change, -1);
+    rb_define_module_function(gdkProperty, "get", gdkprop_get, -1);
+    rb_define_module_function(gdkProperty, "delete", gdkprop_delete, 2);
+
+    /* GdkPropMode from GdkProperties */
+    G_DEF_CLASS(GDK_TYPE_PROP_MODE, "PropMode", gdkProperty);
+    G_DEF_CONSTANTS(gdkProperty, GDK_TYPE_PROP_MODE, "GDK_PROP_");
+
+}