gtk2 0.20.0

data/src/rbgtkprinter.c

@@ -0,0 +1,155 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkprinter.c -
+
+  $Author: sakai $
+  $Date: 2007/07/08 03:00:49 $
+
+  Copyright (C) 2006 Ruby-GNOME2 Project Team
+************************************************/
+
+#include "global.h"
+
+#ifdef HAVE_GTK_UNIX_PRINT
+#include <gtk/gtkprinter.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 _SELF(s) (GTK_PRINTER(RVAL2GOBJ(s)))
+
+static VALUE
+p_initialize(VALUE self, VALUE name, VALUE backend, VALUE rb_virtual)
+{
+    GtkPrinter *printer;
+
+    printer = gtk_printer_new(RVAL2CSTR(name),
+                              GTK_PRINT_BACKEND(RVAL2GOBJ(backend)),
+                              RVAL2CBOOL(rb_virtual));
+
+    G_INITIALIZE(self, printer);
+    return Qnil;
+}
+
+/* Defined as properties
+gboolean    gtk_printer_accepts_ps          (GtkPrinter *printer);
+gboolean    gtk_printer_accepts_pdf         (GtkPrinter *printer);
+GtkPrintBackend* gtk_printer_get_backend    (GtkPrinter *printer);
+const gchar* gtk_printer_get_icon_name      (GtkPrinter *printer);
+gboolean    gtk_printer_is_virtual          (GtkPrinter *printer);
+const gchar* gtk_printer_get_name           (GtkPrinter *printer);
+const gchar* gtk_printer_get_state_message  (GtkPrinter *printer);
+const gchar* gtk_printer_get_location       (GtkPrinter *printer);
+gint        gtk_printer_get_job_count       (GtkPrinter *printer);
+*/
+
+static VALUE
+p_get_description(VALUE self)
+{
+    return CSTR2RVAL(gtk_printer_get_description(_SELF(self)));
+}
+
+static VALUE
+p_is_active(VALUE self)
+{
+    return CBOOL2RVAL(gtk_printer_is_default(_SELF(self)));
+}
+
+static VALUE
+p_is_default(VALUE self)
+{
+    return CBOOL2RVAL(gtk_printer_is_default(_SELF(self)));
+}
+
+static VALUE
+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(mGtk, callback);
+}
+
+static VALUE
+p_s_enumerate_printers(int argc, VALUE *argv, VALUE self)
+{
+    VALUE wait, block;
+    rb_scan_args(argc, argv, "01", &wait);
+
+    block = rb_block_proc();
+    G_CHILD_ADD(mGtk, block);
+    gtk_enumerate_printers(each_printer, (gpointer)block,
+                           remove_callback_reference, RVAL2CBOOL(wait));
+
+    return self;
+}
+#endif
+
+void
+Init_gtk_printer()
+{
+#ifdef HAVE_GTK_UNIX_PRINT
+    VALUE gPrinter = G_DEF_CLASS(GTK_TYPE_PRINTER, "Printer", mGtk);
+    rb_include_module(gPrinter, rb_mComparable);
+
+    G_DEF_CLASS(GTK_TYPE_PRINT_BACKEND, "PrintBackend", mGtk);
+
+    rb_define_singleton_method(gPrinter, "each", p_s_enumerate_printers, -1);
+
+    rb_define_method(gPrinter, "initialize", p_initialize, 3);
+    rb_define_method(gPrinter, "description", p_get_description, 0);
+    rb_define_method(gPrinter, "active?", p_is_active, 0);
+    rb_define_method(gPrinter, "default?", p_is_default, 0);
+    rb_define_method(gPrinter, "<=>", p_compare, 1);
+
+    G_DEF_CLASS3("GtkPrintBackendCups", "PrintBackendCups", mGtk);
+    G_DEF_CLASS3("GtkPrintBackendFile", "PrintBackendFile", mGtk);
+    G_DEF_CLASS3("GtkPrintBackendLpr", "PrintBackendLpr", mGtk);
+
+    G_DEF_SETTERS(gPrinter);
+#endif
+}

data/src/rbgtkprintjob.c

@@ -0,0 +1,151 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkprintjob.c -
+
+  $Author: sakai $
+  $Date: 2007/07/08 03:00:49 $
+
+  Copyright (C) 2006 Ruby-GNOME2 Project Team
+************************************************/
+
+#include "global.h"
+
+#ifdef HAVE_GTK_UNIX_PRINT
+#include <gtk/gtkprintjob.h>
+#ifndef GTK_TYPE_PRINT_CAPABILITIES
+#  define GTK_TYPE_PRINT_CAPABILITIES (gtk_print_capabilities_get_type())
+#endif
+
+#ifdef HAVE_RB_CAIRO_H
+#  include <rb_cairo.h>
+#endif
+
+#define _SELF(s) (GTK_PRINT_JOB(RVAL2GOBJ(s)))
+
+static VALUE gPrintJob;
+
+static VALUE
+pj_initialize(VALUE self, VALUE title, VALUE printer,
+              VALUE settings, VALUE page_setup)
+{
+    GtkPrintJob *job;
+
+    job = gtk_print_job_new(RVAL2CSTR(title), 
+                            GTK_PRINTER(RVAL2GOBJ(printer)),
+                            GTK_PRINT_SETTINGS(RVAL2GOBJ(settings)),
+                            GTK_PAGE_SETUP(RVAL2GOBJ(page_setup)));
+
+    G_INITIALIZE(self, job);
+    return Qnil;
+}
+
+/* Defined as properties.
+GtkPrintSettings* gtk_print_job_get_settings
+                                            (GtkPrintJob *job);
+GtkPrinter* gtk_print_job_get_printer       (GtkPrintJob *job);
+const gchar* gtk_print_job_get_title        (GtkPrintJob *job);
+void        gtk_print_job_set_track_print_status
+                                            (GtkPrintJob *job,
+                                             gboolean track_status);
+gboolean    gtk_print_job_get_track_print_status
+                                            (GtkPrintJob *job);
+*/
+
+static VALUE
+pj_get_status(VALUE self)
+{
+    return GENUM2RVAL(gtk_print_job_get_status(_SELF(self)), GTK_TYPE_PRINT_STATUS);
+}
+
+static VALUE
+pj_set_source_file(VALUE self, VALUE filename)
+{
+    GError *error = NULL;
+    gboolean result;
+
+    result = gtk_print_job_set_source_file(_SELF(self), RVAL2CSTR(filename),
+                                           &error);
+
+    if (!result)
+        RAISE_GERROR(error);
+
+    return Qnil;
+}
+
+#ifdef HAVE_RB_CAIRO_H
+static VALUE
+pj_get_surface(VALUE self)
+{
+    cairo_surface_t *surface;
+    GError *error = NULL;
+
+    surface = gtk_print_job_get_surface(_SELF(self), &error);
+    if (error)
+        RAISE_GERROR(error);
+    return CRSURFACE2RVAL(surface);
+}
+#endif
+
+struct callback_arg
+{
+    VALUE callback;
+    VALUE job;
+    GError* error;
+};
+
+static VALUE
+invoke_callback(VALUE data)
+{
+    struct callback_arg *arg = (struct callback_arg *)data;
+
+    if (arg->error) RAISE_GERROR(arg->error);
+    rb_funcall(arg->callback, id_call, 1, arg->job);
+    return Qnil;
+}
+static void
+complete_func(GtkPrintJob *job, gpointer data, GError *error)
+{
+    struct callback_arg arg;
+
+    arg.callback = (VALUE)data;
+    arg.job = GOBJ2RVAL(job);
+    arg.error = error;
+    G_PROTECT_CALLBACK(invoke_callback, &arg);
+}
+
+static void
+remove_callback_reference(gpointer data)
+{
+    G_CHILD_REMOVE(gPrintJob, (VALUE)data);
+}
+
+static VALUE
+pj_send(VALUE self)
+{
+    VALUE block = rb_block_proc();
+    G_CHILD_ADD(gPrintJob, block);
+    gtk_print_job_send(_SELF(self), complete_func, (gpointer)block,
+                       remove_callback_reference);
+    return self;
+}
+#endif
+
+void
+Init_gtk_print_job()
+{
+#ifdef HAVE_GTK_UNIX_PRINT
+    gPrintJob = G_DEF_CLASS(GTK_TYPE_PRINT_JOB, "PrintJob", mGtk);
+    G_DEF_CLASS(GTK_TYPE_PRINT_CAPABILITIES, "PrintCapabilities", mGtk);
+
+    rb_define_method(gPrintJob, "initialize", pj_initialize, 4);
+    rb_define_method(gPrintJob, "status", pj_get_status, 0);
+    rb_define_method(gPrintJob, "set_source_file", pj_set_source_file, 1);
+#ifdef HAVE_RB_CAIRO_H
+    rb_define_method(gPrintJob, "surface", pj_get_surface, 0);
+#endif
+    rb_define_method(gPrintJob, "send", pj_send, 0);
+
+    G_DEF_SETTERS(gPrintJob);
+#endif
+}

data/src/rbgtkprintoperation.c

@@ -0,0 +1,152 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkprintoperation.c -
+
+  $Author: sakai $
+  $Date: 2007/07/08 03:00:49 $
+
+  Copyright (C) 2006 Ruby-GNOME2 Project Team
+************************************************/
+
+#include "global.h"
+
+#if GTK_CHECK_VERSION(2,10,0)
+#define _SELF(s) (GTK_PRINT_OPERATION(RVAL2GOBJ(s)))
+
+static VALUE gPrintOperation;
+
+static VALUE
+po_initialize(VALUE self)
+{
+    G_INITIALIZE(self, gtk_print_operation_new());
+    return Qnil;
+}
+
+static VALUE
+po_run(int argc, VALUE *argv, VALUE self)
+{
+    VALUE action, parent, rb_result;
+    GtkPrintOperationResult result;
+    GError *error = NULL;
+
+    rb_scan_args(argc, argv, "11", &action, &parent);
+
+    result = gtk_print_operation_run(_SELF(self), 
+                                     RVAL2GENUM(action, GTK_TYPE_PRINT_OPERATION_ACTION),
+                                     RVAL2GOBJ(parent), &error);
+
+    rb_result = GENUM2RVAL(result, GTK_TYPE_PRINT_OPERATION_RESULT);
+    if (rb_block_given_p()) {
+        return rb_yield(rb_result);
+    } else {
+        if (result == GTK_PRINT_OPERATION_RESULT_ERROR)
+            RAISE_GERROR(error);
+        return rb_result;
+    }
+}
+
+static VALUE
+po_get_error(VALUE self)
+{
+    GError *error = NULL;
+    gtk_print_operation_get_error(_SELF(self), &error);
+    return error ? rbgerr_gerror2exception(error) : Qnil;
+}
+
+static VALUE
+po_is_finished(VALUE self)
+{
+    return CBOOL2RVAL(gtk_print_operation_is_finished(_SELF(self)));
+}
+
+static VALUE
+po_cancel(VALUE self)
+{
+    gtk_print_operation_cancel(_SELF(self));
+    return self;
+}
+
+struct callback_arg
+{
+    VALUE callback;
+    VALUE page_setup;
+};
+
+static VALUE
+invoke_callback(VALUE arg_)
+{
+    struct callback_arg *arg = (struct callback_arg *)arg_;
+    return rb_funcall(arg->callback, id_call, 1, arg->page_setup);
+}
+
+static void
+page_setup_done_cb(GtkPageSetup *page_setup, gpointer data)
+{
+    VALUE callback = (VALUE)data;
+    struct callback_arg arg;
+
+    G_CHILD_UNSET(gPrintOperation, rb_intern("setup_done_cb"));
+
+    arg.callback = callback;
+    arg.page_setup = GOBJ2RVAL(page_setup);
+
+    G_PROTECT_CALLBACK(invoke_callback, &arg);
+}
+
+static VALUE
+po_run_page_setup_dialog(int argc, VALUE *argv, VALUE self)
+{
+    VALUE parent, page_setup, settings;
+    rb_scan_args(argc, argv, "03", &parent, &page_setup, &settings);
+
+    if (rb_block_given_p()) {
+        volatile VALUE func = rb_block_proc();
+        G_CHILD_SET(gPrintOperation, rb_intern("setup_done_cb"), func);
+        gtk_print_run_page_setup_dialog_async(RVAL2GOBJ(parent),
+                                              RVAL2GOBJ(page_setup),
+                                              RVAL2GOBJ(settings),
+                                              page_setup_done_cb,
+                                              (gpointer)func);
+        return Qnil;
+    } else {
+        return GOBJ2RVALU(gtk_print_run_page_setup_dialog(RVAL2GOBJ(parent),
+                                                          RVAL2GOBJ(page_setup),
+                                                          RVAL2GOBJ(settings)));
+    }
+}
+#endif
+
+void
+Init_gtk_print_operation()
+{
+#if GTK_CHECK_VERSION(2,10,0)
+    gPrintOperation = G_DEF_CLASS(GTK_TYPE_PRINT_OPERATION, "PrintOperation", mGtk);
+
+    G_DEF_ERROR(GTK_PRINT_ERROR, "PrintError", mGtk, rb_eRuntimeError,
+                GTK_TYPE_PRINT_ERROR);
+
+    rb_define_method(gPrintOperation, "initialize", po_initialize, 0);
+    rb_define_method(gPrintOperation, "run", po_run, -1);
+    rb_define_method(gPrintOperation, "error", po_get_error, 0);
+    rb_define_method(gPrintOperation, "finished?", po_is_finished, 0);
+    rb_define_method(gPrintOperation, "cancel", po_cancel, 0);
+
+    rb_define_singleton_method(gPrintOperation, "run_page_setup_dialog",
+                               po_run_page_setup_dialog, -1);
+
+    /* GtkPrintStatus */
+    G_DEF_CLASS(GTK_TYPE_PRINT_STATUS, "Status", gPrintOperation);
+    G_DEF_CONSTANTS(gPrintOperation, GTK_TYPE_PRINT_STATUS, "GTK_PRINT_");
+
+    /* GtkPrintOperationAction */
+    G_DEF_CLASS(GTK_TYPE_PRINT_OPERATION_ACTION,"Action", gPrintOperation);
+    G_DEF_CONSTANTS(gPrintOperation, GTK_TYPE_PRINT_OPERATION_ACTION, "GTK_PRINT_OPERATION_");
+
+    /* GtkPrintOperationResult */
+    G_DEF_CLASS(GTK_TYPE_PRINT_OPERATION_RESULT, "Result", gPrintOperation);
+    G_DEF_CONSTANTS(gPrintOperation, GTK_TYPE_PRINT_OPERATION_RESULT, "GTK_PRINT_OPERATION_");
+
+    G_DEF_SETTERS(gPrintOperation);
+#endif
+}