gtk3 0.0.1 → 1.2.0

data/ext/gtk3/rbgtkpapersize.c

@@ -0,0 +1,179 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2006  Ruby-GNOME2 Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cPaperSize
+#define _SELF(s) (RVAL2GTKPAPERSIZE(s))
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    GtkPaperSize *size;
+
+    if (argc <= 1) {
+        VALUE name;
+        rb_scan_args(argc, argv, "01", &name);
+        size = gtk_paper_size_new(RVAL2CSTR_ACCEPT_NIL(name));
+    } else if (argc == 4) {
+        size = gtk_paper_size_new_from_ppd(RVAL2CSTR(argv[0]),
+                                           RVAL2CSTR(argv[1]),
+                                           NUM2DBL(argv[2]),
+                                           NUM2DBL(argv[3]));
+    } else if (argc == 5) {
+        size = gtk_paper_size_new_custom(RVAL2CSTR(argv[0]),
+                                         RVAL2CSTR(argv[1]),
+                                         NUM2DBL(argv[2]),
+                                         NUM2DBL(argv[3]),
+                                         RVAL2GTKUNIT(argv[4]));
+    } else {
+        rb_raise(rb_eArgError,
+                 "wrong number of arguments (%d for 0, 1, 4 or 5)", argc);
+    }
+
+    G_INITIALIZE(self, size);
+    return Qnil;
+}
+
+static VALUE
+rg_operator_equal(VALUE self, VALUE other)
+{
+    return CBOOL2RVAL(RVAL2CBOOL(rb_equal(rb_obj_class(self), rb_obj_class(other))) &&
+                      gtk_paper_size_is_equal(_SELF(self), _SELF(other)));
+}
+
+/* The width is always the shortest side, measure in mm */
+static VALUE
+rg_name(VALUE self)
+{
+    return CSTR2RVAL(gtk_paper_size_get_name(_SELF(self)));
+}
+
+static VALUE
+rg_display_name(VALUE self)
+{
+    return CSTR2RVAL(gtk_paper_size_get_display_name(_SELF(self)));
+}
+
+static VALUE
+rg_ppd_name(VALUE self)
+{
+    return CSTR2RVAL(gtk_paper_size_get_ppd_name(_SELF(self)));
+}
+
+static VALUE
+rg_get_width(VALUE self, VALUE unit)
+{
+    return rb_float_new(gtk_paper_size_get_width(_SELF(self), RVAL2GTKUNIT(unit)));
+}
+
+static VALUE
+rg_get_height(VALUE self, VALUE unit)
+{
+    return rb_float_new(gtk_paper_size_get_height(_SELF(self), RVAL2GTKUNIT(unit)));
+}
+
+static VALUE
+rg_custom_p(VALUE self)
+{
+    return CBOOL2RVAL(gtk_paper_size_is_custom(_SELF(self)));
+}
+
+/* Only for custom sizes: */
+static VALUE
+rg_set_size(VALUE self, VALUE width, VALUE height, VALUE unit)
+{
+    gtk_paper_size_set_size(_SELF(self), NUM2DBL(width), NUM2DBL(height),
+                            RVAL2GTKUNIT(unit));
+    return self;
+}
+
+static VALUE
+rg_get_default_top_margin(VALUE self, VALUE unit)
+{
+    return rb_float_new(gtk_paper_size_get_default_top_margin(_SELF(self),
+                                                              RVAL2GTKUNIT(unit)));
+}
+
+static VALUE
+rg_get_default_bottom_margin(VALUE self, VALUE unit)
+{
+    return rb_float_new(gtk_paper_size_get_default_bottom_margin(_SELF(self),
+                                                                 RVAL2GTKUNIT(unit)));
+}
+
+static VALUE
+rg_get_default_left_margin(VALUE self, VALUE unit)
+{
+    return rb_float_new(gtk_paper_size_get_default_left_margin(_SELF(self),
+                                                               RVAL2GTKUNIT(unit)));
+}
+
+static VALUE
+rg_get_default_right_margin(VALUE self, VALUE unit)
+{
+    return rb_float_new(gtk_paper_size_get_default_right_margin(_SELF(self),
+                                                                RVAL2GTKUNIT(unit)));
+}
+
+static VALUE
+rg_s_default(G_GNUC_UNUSED VALUE self)
+{
+    return CSTR2RVAL(gtk_paper_size_get_default());
+}
+
+void
+Init_gtk_paper_size(VALUE mGtk)
+{
+    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_CLASS(GTK_TYPE_UNIT, "Unit", RG_TARGET_NAMESPACE);
+}

data/ext/gtk3/rbgtkplug.c

@@ -0,0 +1,85 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002  Neil Conway
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbgtk3private.h"
+
+#ifdef HAVE_GTK_PLUG_GET_TYPE
+
+#include <gtk/gtkx.h>
+
+#define RG_TARGET_NAMESPACE cPlug
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE socket_id;
+    Window id;
+
+    if (rb_scan_args(argc, argv, "01", &socket_id) == 0)
+        id = 0;
+    else {
+#ifdef GDK_NATIVE_WINDOW_POINTER
+        id = GUINT_TO_POINTER(NUM2ULONG(socket_id));
+#else
+        id = NUM2UINT(socket_id);
+#endif
+    }
+
+    RBGTK_INITIALIZE(self, gtk_plug_new(id));
+    return Qnil;
+}
+
+static VALUE
+rg_construct(VALUE self, VALUE socket_id)
+{
+#ifdef GDK_NATIVE_WINDOW_POINTER
+    gtk_plug_construct(RVAL2GTKPLUG(self), GUINT_TO_POINTER(NUM2ULONG(socket_id)));
+#else
+    gtk_plug_construct(RVAL2GTKPLUG(self), (guint32)NUM2UINT(socket_id));
+#endif
+    return self;
+}
+
+static VALUE
+rg_id(VALUE self)
+{
+    Window id = gtk_plug_get_id(RVAL2GTKPLUG(self));
+#ifdef GDK_NATIVE_WINDOW_POINTER
+    return UINT2NUM(GPOINTER_TO_UINT(id));
+#else
+    return UINT2NUM(id);
+#endif
+}
+
+#endif
+
+void 
+Init_gtk_plug(VALUE mGtk)
+{
+#ifdef HAVE_GTK_PLUG_GET_TYPE
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_PLUG, "Plug", mGtk);
+
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(construct, 1);
+    RG_DEF_METHOD(id, 0);
+#endif
+}

data/ext/gtk3/rbgtkprintcontext.c

@@ -0,0 +1,125 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2006  Ruby-GNOME2 Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cPrintContext
+#define _SELF(s) (RVAL2GTKPRINTCONTEXT(s))
+
+#ifdef HAVE_RB_CAIRO_H
+#include <rb_cairo.h>
+
+/* Rendering */
+static VALUE
+rg_cairo_context(VALUE self)
+{
+    return CRCONTEXT2RVAL(gtk_print_context_get_cairo_context(_SELF(self)));
+}
+#endif
+
+static VALUE
+rg_page_setup(VALUE self)
+{
+    return GOBJ2RVAL(gtk_print_context_get_page_setup(_SELF(self)));
+}
+
+static VALUE
+rg_width(VALUE self)
+{
+    return rb_float_new(gtk_print_context_get_width(_SELF(self)));
+}
+
+static VALUE
+rg_height(VALUE self)
+{
+    return rb_float_new(gtk_print_context_get_height(_SELF(self)));
+}
+
+static VALUE
+rg_dpi_x(VALUE self)
+{
+    return rb_float_new(gtk_print_context_get_dpi_x(_SELF(self)));
+}
+
+static VALUE
+rg_dpi_y(VALUE self)
+{
+    return rb_float_new(gtk_print_context_get_dpi_y(_SELF(self)));
+}
+
+/* Fonts */
+static VALUE
+rg_pango_fontmap(VALUE self)
+{
+    return GOBJ2RVAL(gtk_print_context_get_pango_fontmap(_SELF(self)));
+}
+
+static VALUE
+rg_create_pango_context(VALUE self)
+{
+    return GOBJ2RVALU(gtk_print_context_create_pango_context(_SELF(self)));
+}
+
+static VALUE
+rg_create_pango_layout(VALUE self)
+{
+    return GOBJ2RVALU(gtk_print_context_create_pango_layout(_SELF(self)));
+}
+
+/* Needed for preview implementations */
+#ifdef HAVE_RB_CAIRO_H
+static VALUE
+rg_set_cairo_context(VALUE self, VALUE cr, VALUE dpi_x, VALUE dpi_y)
+{
+    gtk_print_context_set_cairo_context(_SELF(self),
+                                        RVAL2CRCONTEXT(cr),
+                                        NUM2DBL(dpi_x),
+                                        NUM2DBL(dpi_y));
+    return self;
+}
+#endif
+
+void
+Init_gtk_print_context(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_PRINT_CONTEXT,
+                                      "PrintContext", mGtk);
+
+    /* Rendering */
+#ifdef HAVE_RB_CAIRO_H
+    RG_DEF_METHOD(cairo_context, 0);
+#endif
+    RG_DEF_METHOD(page_setup, 0);
+    RG_DEF_METHOD(width, 0);
+    RG_DEF_METHOD(height, 0);
+    RG_DEF_METHOD(dpi_x, 0);
+    RG_DEF_METHOD(dpi_y, 0);
+
+    /* Fonts */
+    RG_DEF_METHOD(pango_fontmap, 0);
+    RG_DEF_METHOD(create_pango_context, 0);
+    RG_DEF_METHOD(create_pango_layout, 0);
+
+    /* Needed for preview implementations */
+#ifdef HAVE_RB_CAIRO_H
+    RG_DEF_METHOD(set_cairo_context, 3);
+#endif
+}

data/ext/gtk3/rbgtkprinter.c

@@ -0,0 +1,155 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2006  Ruby-GNOME2 Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbgtk3private.h"
+
+#ifdef HAVE_GTK_UNIX_PRINT
+#include <gtk/gtkunixprint.h>
+
+#ifndef GTK_TYPE_PRINT_BACKEND
+#define GTK_TYPE_PRINT_BACKEND  (gtk_print_backend_get_type ())
+#define GTK_PRINT_BACKEND(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINT_BACKEND, GtkPrintBackend))
+GType gtk_print_backend_get_type (void) G_GNUC_CONST;
+#endif
+
+#define RG_TARGET_NAMESPACE cPrinter
+#define _SELF(s) (RVAL2GTKPRINTER(s))
+
+static VALUE rb_mGtk;
+
+static VALUE
+rg_initialize(VALUE self, VALUE name, VALUE backend, VALUE rb_virtual)
+{
+    GtkPrinter *printer;
+
+    printer = gtk_printer_new(RVAL2CSTR(name),
+                              RVAL2GTKPRINTBACKEND(backend),
+                              RVAL2CBOOL(rb_virtual));
+
+    G_INITIALIZE(self, printer);
+    return Qnil;
+}
+
+static VALUE
+rg_description(VALUE self)
+{
+    return CSTR2RVAL(gtk_printer_get_description(_SELF(self)));
+}
+
+static VALUE
+rg_active_p(VALUE self)
+{
+    return CBOOL2RVAL(gtk_printer_is_default(_SELF(self)));
+}
+
+static VALUE
+rg_default_p(VALUE self)
+{
+    return CBOOL2RVAL(gtk_printer_is_default(_SELF(self)));
+}
+
+static VALUE
+rg_operator_p_compare(VALUE self, VALUE other)
+{
+    if (rb_obj_is_kind_of(other, GTYPE2CLASS(GTK_TYPE_PRINTER))){
+        return INT2NUM(gtk_printer_compare(_SELF(self), _SELF(other)));
+    } else {
+        rb_raise(rb_eTypeError, "%s isn't a kind of Gtk::Printer", rb_class2name(other));
+    }
+}
+
+struct callback_arg
+{
+    VALUE callback;
+    int argc;
+    VALUE *argv;
+};
+
+static VALUE
+invoke_callback(VALUE data)
+{
+    struct callback_arg *arg = (struct callback_arg *)data;
+
+    return rb_funcall2(arg->callback, id_call, arg->argc, arg->argv);
+}
+
+static gboolean
+each_printer(GtkPrinter *printer, gpointer data)
+{
+    VALUE result;
+    VALUE argv[1];
+    struct callback_arg arg;
+
+    argv[0] = GOBJ2RVAL(printer);
+
+    arg.callback = (VALUE)data;
+    arg.argc = 1;
+    arg.argv = argv;
+
+    result = G_PROTECT_CALLBACK(invoke_callback, &arg);
+    return NIL_P(rb_errinfo()) ? TRUE : RVAL2CBOOL(result);
+}
+
+static void
+remove_callback_reference(gpointer data)
+{
+    VALUE callback = (VALUE)data;
+    G_CHILD_REMOVE(rb_mGtk, callback);
+}
+
+static VALUE
+rg_s_each(int argc, VALUE *argv, VALUE self)
+{
+    VALUE wait, block;
+    rb_scan_args(argc, argv, "01", &wait);
+
+    block = rb_block_proc();
+    G_CHILD_ADD(rb_mGtk, block);
+    gtk_enumerate_printers(each_printer, (gpointer)block,
+                           remove_callback_reference, RVAL2CBOOL(wait));
+
+    return self;
+}
+#endif
+
+void
+Init_gtk_printer(VALUE mGtk)
+{
+#ifdef HAVE_GTK_UNIX_PRINT
+    rb_mGtk = mGtk;
+    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);
+#endif
+}