Revision: 158
Author: ktou
Date: 2006-04-28 18:26:02 -0700 (Fri, 28 Apr 2006)
ViewCVS: http://svn.sourceforge.net/openprinting/?rev=158&view=rev
Log Message:
-----------
Import Ruby bindings.
* configure.in, source/Makefile.am: added Ruby bindings
configuration.
* source/ruby: imported Ruby bindings.
Modified Paths:
--------------
trunk/papi/ChangeLog
trunk/papi/configure.in
trunk/papi/source/Makefile.am
Added Paths:
-----------
trunk/papi/source/ruby/
trunk/papi/source/ruby/Makefile.am
trunk/papi/source/ruby/papi.rb
trunk/papi/source/ruby/rb-papi-attribute-list.c
trunk/papi/source/ruby/rb-papi-attribute.c
trunk/papi/source/ruby/rb-papi-encrypt.c
trunk/papi/source/ruby/rb-papi-error.c
trunk/papi/source/ruby/rb-papi-filter.c
trunk/papi/source/ruby/rb-papi-job.c
trunk/papi/source/ruby/rb-papi-metadata.c
trunk/papi/source/ruby/rb-papi-printer.c
trunk/papi/source/ruby/rb-papi-resolution.c
trunk/papi/source/ruby/rb-papi-service.c
trunk/papi/source/ruby/rb-papi-status.c
trunk/papi/source/ruby/rb-papi.c
trunk/papi/source/ruby/rb-papi.h
trunk/papi/source/ruby/run-test.rb
trunk/papi/source/ruby/test-papi.rb
Modified: trunk/papi/ChangeLog
===================================================================
--- trunk/papi/ChangeLog 2006-04-26 15:07:55 UTC (rev 157)
+++ trunk/papi/ChangeLog 2006-04-29 01:26:02 UTC (rev 158)
@@ -1,3 +1,9 @@
+2006-04-29 Kouhei Sutou <kou@...>
+
+ * configure.in, source/Makefile.am: added Ruby bindings
+ configuration.
+ * source/ruby: imported Ruby bindings.
+
2006-04-27 Kouhei Sutou <kou@...>
* source/libpapi-common/attribute.c (papiAttributeListPrint):
Modified: trunk/papi/configure.in
===================================================================
--- trunk/papi/configure.in 2006-04-26 15:07:55 UTC (rev 157)
+++ trunk/papi/configure.in 2006-04-29 01:26:02 UTC (rev 158)
@@ -153,6 +153,95 @@
AC_SUBST(MAP_FILTER)
AC_SUBST(MAPFLAGS)
+dnl **************************************************************
+dnl Check for Ruby.
+dnl **************************************************************
+ruby_available="no"
+AC_ARG_WITH([ruby],
+ AS_HELP_STRING([--with-ruby=PATH],
+ [Ruby interpreter path (default: auto-detect)]),
+ [RUBY="$withval"])
+
+if test "$RUBY" = "no"; then
+ : # ignore
+elif test "$RUBY" = ""; then
+ AC_PATH_PROG(RUBY, ruby, none)
+ if test "$RUBY" != "none"; then
+ ruby_available="yes"
+ fi
+else
+ AC_CHECK_FILE([$RUBY],
+ [ruby_available="yes"],
+ [AC_MSG_WARN([$RUBY is not found. Disable Ruby bindings.])])
+fi
+
+if test "$ruby_available" = "yes"; then
+ AC_MSG_NOTICE([Configuring Ruby bindings])
+
+ rbconfig="$RUBY -rrbconfig -e "
+
+ changequote(<<, >>)
+ var_list="archdir sitearchdir libdir sitelibdir CFLAGS LIBRUBYARG DLEXT"
+ for var_name in $var_list ; do
+ rbconfig_tmp=`$rbconfig "print Config::CONFIG['$var_name']"`
+ eval "rbconfig_$var_name=\"$rbconfig_tmp\""
+ done
+ changequote([, ])
+
+ RUBY_CFLAGS="$RUBY_CFLAGS -I$rbconfig_archdir "
+ RUBY_CFLAGS="$RUBY_CFLAGS -I$rbconfig_sitearchdir "
+ RUBY_CFLAGS="$RUBY_CFLAGS $rbconfig_CFLAGS "
+ RUBY_LIBS="$rbconfig_LIBRUBYARG"
+ RUBY_LDFLAGS="-L$rbconfig_libdir"
+ RUBY_EXT_LDFLAGS="-shrext .$rbconfig_DLEXT"
+
+ AC_SUBST(RUBY_CFLAGS)
+ AC_SUBST(RUBY_LIBS)
+ AC_SUBST(RUBY_LDFLAGS)
+ AC_SUBST(RUBY_EXT_LDFLAGS)
+
+
+ AC_MSG_CHECKING([where to install Ruby bindings (scripts)])
+ AC_ARG_WITH([ruby-sitelibdir],
+ AC_HELP_STRING([--with-ruby-sitelibdir=SITELIBDIR],
+ [install Ruby bindings (scripts) in SITELIBDIR
+ (default is same as ruby's one)]),
+ [ruby_sitelibdir="$withval"],
+ [ruby_sitelibdir="$rbconfig_sitelibdir"])
+ AC_MSG_RESULT([$ruby_sitelibdir])
+
+ AC_MSG_CHECKING([where to install Ruby bindings (shared library)])
+ AC_ARG_WITH([ruby-sitearchdir],
+ AC_HELP_STRING([--with-ruby-sitearchdir=SITEARCDIR],
+ [install Ruby bindings (shared library) in SITEARCDIR
+ (default is same as ruby's one)]),
+ [ruby_sitearchdir="$withval"],
+ [ruby_sitearchdir="$rbconfig_sitearchdir"])
+ AC_MSG_RESULT([$ruby_sitearchdir])
+
+ AC_SUBST(ruby_sitelibdir)
+ AC_SUBST(ruby_sitearchdir)
+
+
+ _SAVE_CFLAGS=$CFLAGS
+ ruby_undef_package_macros="
+#undef PACKAGE_NAME
+#undef PACKAGE_TARNAME
+#undef PACKAGE_STRING
+#undef PACKAGE_VERSION
+"
+ ruby_disable_message="Disable Ruby bindings."
+ CFLAGS="$CFLAGS $RUBY_CFLAGS"
+ AC_CHECK_HEADERS(ruby.h, [],
+ [ruby_available="no"
+ AC_MSG_WARN([$ruby_disable_message])],
+ [$ruby_undef_package_macros])
+ CFLAGS=$_SAVE_CFLAGS
+fi
+
+AM_CONDITIONAL([WITH_RUBY], [test "$ruby_available" = "yes"])
+
+
AC_OUTPUT(
Makefile
docs/Makefile
@@ -178,6 +267,7 @@
source/libpapi-lpd/Makefile
source/libpapi-lpd/mapfile
source/mod_ipp/Makefile
+ source/ruby/Makefile
packaging/Solaris/pkginfo
packaging/RPM/FSGpapi.spec
packaging/DEB/control
Modified: trunk/papi/source/Makefile.am
===================================================================
--- trunk/papi/source/Makefile.am 2006-04-26 15:07:55 UTC (rev 157)
+++ trunk/papi/source/Makefile.am 2006-04-29 01:26:02 UTC (rev 158)
@@ -32,6 +32,10 @@
APACHE_MODULE= mod_ipp
endif
+if WITH_RUBY
+RUBY_BINDINGS = ruby
+endif
+
AUTOMAKE_OPTIONS=foreign
SUBDIRS= libpapi-common \
libpapi-dynamic \
@@ -42,6 +46,7 @@
libipp-listener \
bsd-sysv-commands \
$(APACHE_MODULE) \
+ $(RUBY_BINDINGS) \
examples
libpapi-dynamic: libpapi-common
@@ -51,4 +56,4 @@
mod_ipp: libipp-listener libpapi-dynamic
bsd-sysv-commands: libpapi-dynamic
examples: libpapi-dynamic
-
+ruby: libpapi-dynamic
Property changes on: trunk/papi/source/ruby
___________________________________________________________________
Name: svn:ignore
+ Makefile.in
Makefile
.libs
.deps
Added: trunk/papi/source/ruby/Makefile.am
===================================================================
--- trunk/papi/source/ruby/Makefile.am (rev 0)
+++ trunk/papi/source/ruby/Makefile.am 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,39 @@
+# -*- Mode: Makefile; tab-width: 8; indent-tabs-mode: t; -*-
+
+rubypapilibdir = $(ruby_sitelibdir)
+rubypapilib_DATA = papi.rb
+
+rubypapiarchdir = $(ruby_sitearchdir)
+rubypapiarch_LTLIBRARIES = papi.la
+
+INCLUDES = \
+ $(RUBY_CFLAGS) \
+ $(RUBY_EXT_CFLAGS) \
+ -I$(top_srcdir)/source/libpapi-common
+
+papi_la_SOURCES = \
+ rb-papi.c \
+ rb-papi.h \
+ rb-papi-attribute-list.c \
+ rb-papi-attribute.c \
+ rb-papi-encrypt.c \
+ rb-papi-error.c \
+ rb-papi-filter.c \
+ rb-papi-job.c \
+ rb-papi-metadata.c \
+ rb-papi-printer.c \
+ rb-papi-resolution.c \
+ rb-papi-service.c \
+ rb-papi-status.c
+
+papi_la_LDFLAGS = \
+ -module \
+ $(RUBY_LDFLAGS) \
+ $(RUBY_EXT_LDFLAGS)
+
+papi_la_LIBADD = \
+ $(RUBY_LIBS) \
+ $(top_builddir)/source/libpapi-dynamic/libpapi.la
+
+TESTS = run-test.rb
+TESTS_ENVIRONMENT = EXT_DIR=$(top_builddir)/source/ruby $(RUBY)
Added: trunk/papi/source/ruby/papi.rb
===================================================================
--- trunk/papi/source/ruby/papi.rb (rev 0)
+++ trunk/papi/source/ruby/papi.rb 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,89 @@
+require "papi.so"
+
+module PAPI
+ module Util
+ module_function
+ def to_ruby_class_name(name)
+ name.split("_").collect do |x|
+ "#{x[0,1].upcase}#{x[1..-1].downcase}"
+ end.join("")
+ end
+ end
+
+ class Error < StandardError
+ class << self
+ def corresponding_error(status)
+ constants.each do |name|
+ klass = const_get(name)
+ return klass if klass.status == status
+ end
+ raise "Unknown error status: #{status}"
+ end
+ end
+
+
+ Status.constants.each do |name|
+ status = Status.const_get(name)
+ module_eval(<<-EOS, __FILE__, __LINE__ + 1)
+ class #{Util.to_ruby_class_name(name)} < Error
+ class << self
+ def status
+ #{status}
+ end
+
+ def string
+ Status.string(status)
+ end
+ end
+
+ def status
+ self.class.status
+ end
+
+ def string
+ self.class.string
+ end
+ end
+EOS
+ end
+ end
+
+ class AttributeList
+ def [](name)
+ attr = find(name)
+ if attr
+ attr.values
+ else
+ nil
+ end
+ end
+ end
+
+ class Job
+ alias job_ticket ticket
+ end
+
+ class Metadata
+ constants.each do |name|
+ value = const_get(name)
+ module_eval(<<-EOS, __FILE__, __LINE__ + 1)
+ class #{Util.to_ruby_class_name(name)} < Metadata
+ class << self
+ def value
+ #{value}
+ end
+ end
+
+ attr_reader :value
+ def initialize
+ @value = value
+ end
+
+ def to_s
+ "#<#{self.class.name}:#{name}>"
+ end
+ end
+EOS
+ end
+ end
+end
Added: trunk/papi/source/ruby/rb-papi-attribute-list.c
===================================================================
--- trunk/papi/source/ruby/rb-papi-attribute-list.c (rev 0)
+++ trunk/papi/source/ruby/rb-papi-attribute-list.c 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,171 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+
+#include "rb-papi.h"
+
+static VALUE cAttributeList;
+
+static void
+no_free(void *ptr)
+{
+}
+
+VALUE
+rb_papi_c2r_attribute_list(papi_attribute_t **attrs)
+{
+ return Data_Wrap_Struct(cAttributeList, 0, papiAttributeListFree, attrs);
+}
+
+VALUE
+rb_papi_c2r_attribute_list_no_free(papi_attribute_t **attrs)
+{
+ return Data_Wrap_Struct(cAttributeList, 0, no_free, attrs);
+}
+
+static VALUE
+rb_papi_attribute_list_allocate(VALUE klass)
+{
+ return Data_Wrap_Struct(klass, NULL, papiAttributeListFree, NULL);
+}
+
+static VALUE
+rb_papi_attribute_list_initialize(int argc, VALUE *argv, VALUE self)
+{
+ VALUE buffer, rb_attrs, rb_add_flags;
+ papi_attribute_t **attrs = NULL;
+
+ rb_scan_args(argc, argv, "03", &buffer, &rb_attrs, &rb_add_flags);
+
+ if (!NIL_P(buffer)) {
+ papi_status_t status;
+ int add_flags = PAPI_ATTR_EXCL;
+
+ if (!NIL_P(rb_attrs)) {
+ attrs = RVAL2ATTRLST(rb_attrs);
+ if (!NIL_P(rb_add_flags))
+ add_flags = NUM2INT(rb_add_flags);
+ }
+
+ status = papiAttributeListFromString(&attrs, add_flags,
+ StringValueCStr(buffer));
+ rb_papi_status_check(status);
+ }
+
+ RDATA(self)->data = attrs;
+
+ return Qnil;
+}
+
+static VALUE
+rb_papi_attribute_list_add(int argc, VALUE *argv, VALUE self)
+{
+ VALUE name, value, flags;
+ papi_attribute_t *attr;
+ papi_attribute_t ***attrs;
+ papi_attribute_t **dummy_attrs;
+
+ rb_scan_args(argc, argv, "21", &name, &value, &flags);
+
+ attrs = (papi_attribute_t ***)&(RDATA(self)->data);
+ attr = rb_papi_r2c_attribute(name, value);
+ rb_papi_status_check(papiAttributeListAddValue(attrs,
+ NIL_P(flags) ?
+ PAPI_ATTR_APPEND :
+ NUM2INT(flags),
+ attr->name,
+ attr->type,
+ *(attr->values)));
+
+ dummy_attrs = ALLOC_N(papi_attribute_t *, 2);
+ dummy_attrs[0] = attr;
+ dummy_attrs[1] = NULL;
+ papiAttributeListFree(dummy_attrs);
+
+ return self;
+}
+
+static VALUE
+rb_papi_attribute_list_find(VALUE self, VALUE name)
+{
+ VALUE result = Qnil;
+ papi_attribute_t **attrs = RVAL2ATTRLST(self);
+ papi_attribute_t *attr;
+
+ if (attrs) {
+ attr = papiAttributeListFind(attrs, StringValueCStr(name));
+ if (attr) {
+ result = ATTR2RVAL_NO_FREE(attr);
+ }
+ }
+
+ return result;
+}
+
+static VALUE
+rb_papi_attribute_list_each(VALUE self)
+{
+ VALUE rb_attrs = rb_ary_new();
+ papi_attribute_t **attrs = RVAL2ATTRLST(self);
+ papi_attribute_t *attr;
+ void *iter = NULL;
+
+ if (attrs) {
+ while ((attr = papiAttributeListGetNext(attrs, &iter))) {
+ VALUE rb_attr = ATTR2RVAL_NO_FREE(attr);
+ rb_ary_push(rb_attrs, rb_attr);
+ rb_yield(rb_attr);
+ }
+ }
+
+ return rb_attrs;
+}
+
+static VALUE
+rb_papi_attribute_list_to_string(int argc, VALUE *argv, VALUE self)
+{
+ VALUE rb_delim, result;
+ char *delim, *buffer;
+ papi_attribute_t **attrs;
+ papi_status_t status = PAPI_NOT_POSSIBLE;
+ int i;
+
+ rb_scan_args(argc, argv, "01", &rb_delim);
+
+ attrs = RVAL2ATTRLST(self);
+ delim = NIL_P(rb_delim) ? NULL : StringValuePtr(rb_delim);
+
+ buffer = ALLOC_N(char, BUFFER_SIZE);
+ status = papiAttributeListToString(attrs, delim, buffer, BUFFER_SIZE);
+ for (i = 2; status != PAPI_OK; i++) {
+ if (i > 10) {
+ free(buffer);
+ rb_raise(rb_eNoMemError, "%s", papiStatusString(status));
+ }
+ REALLOC_N(buffer, char, BUFFER_SIZE * i);
+ status = papiAttributeListToString(attrs, delim,
+ buffer, BUFFER_SIZE * i);
+ }
+ result = rb_str_new2(buffer);
+ free(buffer);
+
+ return result;
+}
+
+
+void
+Init_rb_papi_attribute_list(VALUE mPAPI)
+{
+ cAttributeList = rb_define_class_under(mPAPI, "AttributeList", rb_cData);
+
+ rb_include_module(cAttributeList, rb_mEnumerable);
+ rb_define_alloc_func(cAttributeList, rb_papi_attribute_list_allocate);
+ rb_define_method(cAttributeList, "initialize",
+ rb_papi_attribute_list_initialize, -1);
+
+ rb_define_method(cAttributeList, "find", rb_papi_attribute_list_find, 1);
+ rb_define_method(cAttributeList, "each", rb_papi_attribute_list_each, 0);
+ rb_define_method(cAttributeList, "to_s",
+ rb_papi_attribute_list_to_string, -1);
+
+ rb_define_method(cAttributeList, "add",
+ rb_papi_attribute_list_add, -1);
+}
Added: trunk/papi/source/ruby/rb-papi-attribute.c
===================================================================
--- trunk/papi/source/ruby/rb-papi-attribute.c (rev 0)
+++ trunk/papi/source/ruby/rb-papi-attribute.c 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,225 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+
+#include "rb-papi.h"
+
+static ID id_new, id_begin, id_end, id_xres, id_yres;
+static ID id_units, id_tv_sec, id_value;
+static VALUE cAttribute, cResolution, cMetadata;
+
+static void
+no_free(void *ptr)
+{
+}
+
+VALUE
+rb_papi_c2r_attribute_no_free(papi_attribute_t *attr)
+{
+ return Data_Wrap_Struct(cAttribute, 0, no_free, attr);
+}
+
+static VALUE
+rb_papi_attribute_get_name(VALUE self)
+{
+ return rb_str_new2(RVAL2ATTR(self)->name);
+}
+
+static VALUE
+rb_papi_attribute_get_value_type(VALUE self)
+{
+ return INT2NUM(RVAL2ATTR(self)->type);
+}
+
+static VALUE
+c2r_attribute_value_string(papi_attribute_value_t *value)
+{
+ return rb_str_new2(value->string);
+}
+
+static VALUE
+c2r_attribute_value_integer(papi_attribute_value_t *value)
+{
+ return INT2NUM(value->integer);
+}
+
+static VALUE
+c2r_attribute_value_boolean(papi_attribute_value_t *value)
+{
+ return value->boolean ? Qtrue : Qfalse;
+}
+
+static VALUE
+c2r_attribute_value_range(papi_attribute_value_t *value)
+{
+ return rb_range_new(INT2NUM(value->range.lower),
+ INT2NUM(value->range.upper),
+ FALSE);
+}
+
+static VALUE
+c2r_attribute_value_resolution(papi_attribute_value_t *value)
+{
+ return rb_funcall(cResolution,
+ id_new,
+ 3,
+ INT2NUM(value->resolution.xres),
+ INT2NUM(value->resolution.yres),
+ INT2NUM(value->resolution.units));
+}
+
+static VALUE
+c2r_attribute_value_datetime(papi_attribute_value_t *value)
+{
+ return rb_time_new(value->datetime, 0);
+}
+
+static VALUE
+c2r_attribute_value_collection(papi_attribute_value_t *value)
+{
+ VALUE rb_value = rb_ary_new();
+ papi_attribute_t **attr;
+
+ for (attr = value->collection; *attr; attr++) {
+ rb_ary_push(rb_value, ATTR2RVAL_NO_FREE(*attr));
+ }
+
+ return rb_value;
+}
+
+static VALUE
+c2r_attribute_value_metadata(papi_attribute_value_t *value)
+{
+ return MD2RVAL(value->metadata);
+}
+
+static VALUE
+rb_papi_attribute_get_values(VALUE self)
+{
+ VALUE values = rb_ary_new();
+ c2r_attr_value_t c2r_converter = NULL;
+ papi_attribute_t *attr;
+ papi_attribute_value_t **value;
+
+ attr = RVAL2ATTR(self);
+ switch (attr->type) {
+ case PAPI_STRING:
+ c2r_converter = c2r_attribute_value_string;
+ break;
+ case PAPI_INTEGER:
+ c2r_converter = c2r_attribute_value_integer;
+ break;
+ case PAPI_BOOLEAN:
+ c2r_converter = c2r_attribute_value_boolean;
+ break;
+ case PAPI_RANGE:
+ c2r_converter = c2r_attribute_value_range;
+ break;
+ case PAPI_RESOLUTION:
+ c2r_converter = c2r_attribute_value_resolution;
+ break;
+ case PAPI_DATETIME:
+ c2r_converter = c2r_attribute_value_datetime;
+ break;
+ case PAPI_COLLECTION:
+ c2r_converter = c2r_attribute_value_collection;
+ break;
+ case PAPI_METADATA:
+ c2r_converter = c2r_attribute_value_metadata;
+ break;
+ default:
+ rb_raise(rb_eArgError, "invalid value type %d", attr->type);
+ break;
+ }
+
+ for (value = attr->values; *value; value++) {
+ rb_ary_push(values, c2r_converter(*value));
+ }
+
+ return values;
+}
+
+papi_attribute_t *
+rb_papi_r2c_attribute(VALUE name, VALUE rb_value)
+{
+ papi_attribute_t *attr;
+ papi_attribute_value_t **values;
+ papi_attribute_value_t *value;
+
+ attr = ALLOC(papi_attribute_t);
+ attr->name = strdup(StringValueCStr(name));
+
+ value = ALLOC(papi_attribute_value_t);
+
+ if (rb_obj_is_kind_of(rb_value, rb_cString)) {
+ attr->type = PAPI_STRING;
+ value->string = strdup(StringValueCStr(rb_value));
+ } else if (rb_obj_is_kind_of(rb_value, rb_cNumeric)) {
+ attr->type = PAPI_INTEGER;
+ value->integer = NUM2INT(rb_value);
+ } else if (rb_value == Qtrue || rb_value == Qfalse) {
+ attr->type = PAPI_BOOLEAN;
+ value->boolean = RTEST(rb_value);
+ } else if (rb_obj_is_kind_of(rb_value, rb_cRange)) {
+ attr->type = PAPI_RANGE;
+ value->range.lower = NUM2INT(rb_funcall(rb_value, id_begin, 0));
+ value->range.upper = NUM2INT(rb_funcall(rb_value, id_end, 0));
+ } else if (rb_obj_is_kind_of(rb_value, cResolution)) {
+ attr->type = PAPI_RESOLUTION;
+ value->resolution.xres = NUM2INT(rb_funcall(rb_value, id_xres, 0));
+ value->resolution.yres = NUM2INT(rb_funcall(rb_value, id_yres, 0));
+ value->resolution.units = NUM2INT(rb_funcall(rb_value, id_units, 0));
+ } else if (rb_obj_is_kind_of(rb_value, rb_cTime)) {
+ attr->type = PAPI_DATETIME;
+ value->datetime = NUM2LONG(rb_funcall(rb_value, id_tv_sec, 0));
+ } else if (rb_obj_is_kind_of(rb_value, rb_cArray)) {
+ papi_attribute_t **collection;
+ int i, len;
+
+ attr->type = PAPI_COLLECTION;
+ len = RARRAY(rb_value)->len;
+ collection = ALLOC_N(papi_attribute_t *, len);
+ for (i = 0; i < len; i++) {
+ VALUE sub_name, sub_value;
+ sub_name = rb_ary_entry(RARRAY(rb_value)->ptr[i], 0);
+ sub_value = rb_ary_entry(RARRAY(rb_value)->ptr[i], 1);
+ collection[i] = rb_papi_r2c_attribute(sub_name, sub_value);
+ }
+ collection[i] = NULL;
+ value->collection = collection;
+ } else if (rb_obj_is_kind_of(rb_value, cMetadata)) {
+ attr->type = PAPI_METADATA;
+ value->metadata = NUM2INT(rb_funcall(rb_value, id_value, 0));
+ }
+
+ values = ALLOC_N(papi_attribute_value_t *, 2);
+ values[0] = value;
+ values[1] = NULL;
+ attr->values = values;
+ return attr;
+}
+
+
+void
+Init_rb_papi_attribute(VALUE mPAPI)
+{
+ id_begin = rb_intern("begin");
+ id_end = rb_intern("end");
+ id_xres = rb_intern("xres");
+ id_yres = rb_intern("yres");
+ id_units = rb_intern("units");
+ id_tv_sec = rb_intern("tv_sec");
+ id_value = rb_intern("value");
+
+ cAttribute = rb_define_class_under(mPAPI, "Attribute", rb_cData);
+ cResolution = rb_const_get(mPAPI, rb_intern("Resolution"));
+ cMetadata = rb_const_get(mPAPI, rb_intern("Metadata"));
+
+ rb_define_method(cAttribute, "name", rb_papi_attribute_get_name, 0);
+ rb_define_method(cAttribute, "value_type",
+ rb_papi_attribute_get_value_type, 0);
+ rb_define_method(cAttribute, "values", rb_papi_attribute_get_values, 0);
+
+ /* PAPI_ATTR_* */
+ rb_define_const(cAttribute, "APPEND", INT2NUM(PAPI_ATTR_APPEND));
+ rb_define_const(cAttribute, "REPLACE", INT2NUM(PAPI_ATTR_REPLACE));
+ rb_define_const(cAttribute, "EXCL", INT2NUM(PAPI_ATTR_EXCL));
+}
Added: trunk/papi/source/ruby/rb-papi-encrypt.c
===================================================================
--- trunk/papi/source/ruby/rb-papi-encrypt.c (rev 0)
+++ trunk/papi/source/ruby/rb-papi-encrypt.c 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,16 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+
+#include "rb-papi.h"
+
+void
+Init_rb_papi_encrypt(VALUE mPAPI)
+{
+ VALUE mEncrypt;
+ mEncrypt = rb_define_module_under(mPAPI, "Encrypt");
+
+ rb_define_const(mEncrypt, "IF_REQUESTED",
+ INT2NUM(PAPI_ENCRYPT_IF_REQUESTED));
+ rb_define_const(mEncrypt, "NEVER", INT2NUM(PAPI_ENCRYPT_NEVER));
+ rb_define_const(mEncrypt, "REQUIRED", INT2NUM(PAPI_ENCRYPT_REQUIRED));
+ rb_define_const(mEncrypt, "ALWAYS", INT2NUM(PAPI_ENCRYPT_ALWAYS));
+}
Added: trunk/papi/source/ruby/rb-papi-error.c
===================================================================
--- trunk/papi/source/ruby/rb-papi-error.c (rev 0)
+++ trunk/papi/source/ruby/rb-papi-error.c 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,20 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+
+#include "rb-papi.h"
+
+static ID id_corresponding_error;
+static VALUE eError;
+
+VALUE
+rb_papi_corresponding_error(papi_status_t status)
+{
+ return rb_funcall(eError, id_corresponding_error,
+ 1, INT2NUM(status));
+}
+
+void
+Init_rb_papi_error(VALUE mPAPI)
+{
+ id_corresponding_error = rb_intern("corresponding_error");
+ eError = rb_define_class_under(mPAPI, "Error", rb_eStandardError);
+}
Added: trunk/papi/source/ruby/rb-papi-filter.c
===================================================================
--- trunk/papi/source/ruby/rb-papi-filter.c (rev 0)
+++ trunk/papi/source/ruby/rb-papi-filter.c 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,88 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+
+#include "rb-papi.h"
+
+static ID id_new;
+static VALUE cFilter, cFilterBitmask;
+
+
+VALUE
+rb_papi_c2r_filter(papi_filter_t *filter)
+{
+ papi_filter_t *ptr = ALLOC(papi_filter_t);
+ ptr = filter;
+ return Data_Wrap_Struct(cFilter, 0, 0, ptr);
+}
+
+static VALUE
+rb_papi_filter_get_type(VALUE self)
+{
+ return INT2NUM(RVAL2FILTER(self)->type);
+}
+
+static VALUE
+rb_papi_filter_get_filter(VALUE self)
+{
+ VALUE result = Qnil;
+ papi_filter_t *filter;
+
+ filter = RVAL2FILTER(self);
+
+ switch (filter->type) {
+ case PAPI_FILTER_BITMASK:
+ result = rb_funcall(cFilterBitmask,
+ id_new,
+ 2,
+ UINT2NUM(filter->filter.bitmask.mask),
+ UINT2NUM(filter->filter.bitmask.value));
+ break;
+ default:
+ rb_raise(rb_eArgError, "invalid filter type %d", filter->type);
+ break;
+ }
+
+ return result;
+}
+
+
+void
+Init_rb_papi_filter(VALUE mPAPI)
+{
+ VALUE mFilterType;
+
+ id_new = rb_intern("new");
+
+ mFilterType = rb_define_module_under(mPAPI, "FilterType");
+ cFilter = rb_define_class_under(mPAPI, "Filter", rb_cData);
+ cFilterBitmask = rb_struct_define("FilterBitmask", "mask", "value", NULL);
+ rb_define_const(mPAPI, "FilterBitmask", cFilterBitmask);
+
+ /* papi_filter_type_t */
+ rb_define_const(mFilterType, "BITMASK", INT2NUM(PAPI_FILTER_BITMASK));
+
+ /* papi_filter_t */
+ rb_define_method(cFilter, "type", rb_papi_filter_get_type, 0);
+ rb_define_method(cFilter, "filter", rb_papi_filter_get_filter, 0);
+
+ /* PAPI_PRINTER_* for bitmask filter */
+ rb_define_const(cFilterBitmask, "LOCAL", INT2NUM(PAPI_PRINTER_LOCAL));
+ rb_define_const(cFilterBitmask, "CLASS", INT2NUM(PAPI_PRINTER_CLASS));
+ rb_define_const(cFilterBitmask, "REMOTE", INT2NUM(PAPI_PRINTER_REMOTE));
+ rb_define_const(cFilterBitmask, "BW", INT2NUM(PAPI_PRINTER_BW));
+ rb_define_const(cFilterBitmask, "COLOR", INT2NUM(PAPI_PRINTER_COLOR));
+ rb_define_const(cFilterBitmask, "DUPLEX", INT2NUM(PAPI_PRINTER_DUPLEX));
+ rb_define_const(cFilterBitmask, "STAPLE", INT2NUM(PAPI_PRINTER_STAPLE));
+ rb_define_const(cFilterBitmask, "COPIES", INT2NUM(PAPI_PRINTER_COPIES));
+ rb_define_const(cFilterBitmask, "COLLATE", INT2NUM(PAPI_PRINTER_COLLATE));
+ rb_define_const(cFilterBitmask, "PUNCH", INT2NUM(PAPI_PRINTER_PUNCH));
+ rb_define_const(cFilterBitmask, "COVER", INT2NUM(PAPI_PRINTER_COVER));
+ rb_define_const(cFilterBitmask, "BIND", INT2NUM(PAPI_PRINTER_BIND));
+ rb_define_const(cFilterBitmask, "SORT", INT2NUM(PAPI_PRINTER_SORT));
+ rb_define_const(cFilterBitmask, "SMALL", INT2NUM(PAPI_PRINTER_SMALL));
+ rb_define_const(cFilterBitmask, "MEDIUM", INT2NUM(PAPI_PRINTER_MEDIUM));
+ rb_define_const(cFilterBitmask, "LARGE", INT2NUM(PAPI_PRINTER_LARGE));
+ rb_define_const(cFilterBitmask, "VARIABLE", INT2NUM(PAPI_PRINTER_VARIABLE));
+ rb_define_const(cFilterBitmask, "IMPLICIT", INT2NUM(PAPI_PRINTER_IMPLICIT));
+ rb_define_const(cFilterBitmask, "DEFAULT", INT2NUM(PAPI_PRINTER_DEFAULT));
+ rb_define_const(cFilterBitmask, "OPTIONS", INT2NUM(PAPI_PRINTER_OPTIONS));
+}
Added: trunk/papi/source/ruby/rb-papi-job.c
===================================================================
--- trunk/papi/source/ruby/rb-papi-job.c (rev 0)
+++ trunk/papi/source/ruby/rb-papi-job.c 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,468 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+
+#include "rb-papi.h"
+
+static ID id_service, id_call;
+static VALUE cJob, cJobTicket, cJobStream;
+
+static void
+no_free(void *ptr)
+{
+}
+
+VALUE
+rb_papi_c2r_job(papi_job_t job)
+{
+ return Data_Wrap_Struct(cJob, 0, papiJobFree, job);
+}
+
+VALUE
+rb_papi_c2r_job_no_free(papi_job_t job)
+{
+ return Data_Wrap_Struct(cJob, 0, no_free, job);
+}
+
+VALUE
+rb_papi_c2r_job_ticket(papi_job_ticket_t *job_ticket)
+{
+ return Data_Wrap_Struct(cJobTicket, 0, 0, job_ticket);
+}
+
+VALUE
+rb_papi_c2r_job_ticket_no_free(papi_job_ticket_t *job_ticket)
+{
+ return Data_Wrap_Struct(cJobTicket, 0, no_free, job_ticket);
+}
+
+VALUE
+rb_papi_c2r_job_stream_no_free(papi_stream_t stream)
+{
+ return Data_Wrap_Struct(cJobStream, 0, no_free, stream);
+}
+
+/* JobTicket related */
+static VALUE
+rb_papi_job_ticket_allocate(VALUE klass)
+{
+ return Data_Wrap_Struct(klass, NULL, NULL, NULL);
+}
+
+static VALUE
+rb_papi_job_ticket_initialize(VALUE self, VALUE format,
+ VALUE data, VALUE file_name)
+{
+ papi_job_ticket_t *ticket;
+
+ ticket = ALLOC(papi_job_ticket_t);
+
+ ticket->format = NUM2INT(format);
+ ticket->ticket_data = StringValueCStr(data);
+ ticket->file_name = StringValueCStr(file_name);
+
+ RDATA(self)->data = ticket;
+
+ return Qnil;
+}
+
+static VALUE
+rb_papi_job_ticket_get_format(VALUE self)
+{
+ return INT2NUM(RVAL2JT(self)->format);
+}
+
+static VALUE
+rb_papi_job_ticket_get_data(VALUE self)
+{
+ return rb_str_new2(RVAL2JT(self)->ticket_data);
+}
+
+static VALUE
+rb_papi_job_ticket_get_file_name(VALUE self)
+{
+ return rb_str_new2(RVAL2JT(self)->file_name);
+}
+
+static VALUE
+rb_papi_job_ticket_set_format(VALUE self, VALUE format)
+{
+ RVAL2JT(self)->format = NUM2INT(format);
+ return Qnil;
+}
+
+static VALUE
+rb_papi_job_ticket_set_data(VALUE self, VALUE data)
+{
+ RVAL2JT(self)->ticket_data = StringValueCStr(data);
+ return Qnil;
+}
+
+static VALUE
+rb_papi_job_ticket_set_file_name(VALUE self, VALUE file_name)
+{
+ RVAL2JT(self)->file_name = StringValueCStr(file_name);
+ return Qnil;
+}
+
+
+
+/* Job related */
+static VALUE
+rb_papi_job_submit(int argc, VALUE *argv, VALUE self)
+{
+ VALUE service, printer, job_attributes, job_ticket, rb_files;
+ VALUE rb_job;
+ papi_job_t job;
+ char **files;
+
+ rb_scan_args(argc, argv, "23", &service, &printer, &job_attributes,
+ &job_ticket, &rb_files);
+
+ ARY2STRARY(rb_files, files);
+ rb_papi_status_check(papiJobSubmit(RVAL2SERVICE(service),
+ StringValueCStr(printer),
+ RVAL2ATTRLST(job_attributes),
+ RVAL2JT(job_ticket),
+ files,
+ &job));
+ rb_job = JOB2RVAL(job);
+ rb_ivar_set(rb_job, id_service, service);
+ return rb_job;
+}
+
+static VALUE
+rb_papi_job_submit_by_reference(int argc, VALUE *argv, VALUE self)
+{
+ VALUE service, printer, job_attributes, job_ticket, rb_files;
+ VALUE rb_job;
+ papi_job_t job;
+ char **files;
+
+ rb_scan_args(argc, argv, "23", &service, &printer, &job_attributes,
+ &job_ticket, &rb_files);
+
+ ARY2STRARY(rb_files, files);
+ rb_papi_status_check(papiJobSubmitByReference(RVAL2SERVICE(service),
+ StringValueCStr(printer),
+ RVAL2ATTRLST(job_attributes),
+ RVAL2JT(job_ticket),
+ files,
+ &job));
+ rb_job = JOB2RVAL(job);
+ rb_ivar_set(rb_job, id_service, service);
+ return rb_job;
+}
+
+static VALUE
+rb_papi_job_validate(int argc, VALUE *argv, VALUE self)
+{
+ VALUE service, printer, job_attributes, job_ticket, rb_files;
+ VALUE rb_job;
+ papi_job_t job;
+ char **files;
+
+ rb_scan_args(argc, argv, "23", &service, &printer, &job_attributes,
+ &job_ticket, &rb_files);
+
+ ARY2STRARY(rb_files, files);
+ rb_papi_status_check(papiJobValidate(RVAL2SERVICE(service),
+ StringValueCStr(printer),
+ RVAL2ATTRLST(job_attributes),
+ RVAL2JT(job_ticket),
+ files,
+ &job));
+ rb_job = JOB2RVAL(job);
+ rb_ivar_set(rb_job, id_service, service);
+ return rb_job;
+}
+
+
+static VALUE
+rb_papi_job_query(int argc, VALUE *argv, VALUE self)
+{
+ VALUE service, printer, job_id, rb_requested_attrs;
+ VALUE rb_job;
+ char **requested_attrs;
+ papi_job_t job;
+
+ rb_scan_args(argc, argv, "31", &service, &printer, &job_id,
+ &rb_requested_attrs);
+
+ ARY2STRARY(rb_requested_attrs, requested_attrs);
+ rb_papi_status_check(papiJobQuery(RVAL2SERVICE(service),
+ StringValueCStr(printer),
+ NUM2INT(job_id),
+ requested_attrs,
+ &job));
+
+ rb_job = JOB2RVAL(job);
+ rb_ivar_set(rb_job, id_service, service);
+ return rb_job;
+}
+
+static VALUE
+rb_papi_job_modify(VALUE self, VALUE attributes)
+{
+ VALUE rb_job, service;
+ papi_job_t job, new_job;
+
+ job = RVAL2JOB(self);
+ service = rb_ivar_get(self, id_service);
+ rb_papi_status_check(papiJobModify(RVAL2SERVICE(service),
+ papiJobGetPrinterName(job),
+ papiJobGetId(job),
+ RVAL2ATTRLST(attributes),
+ &new_job));
+
+ rb_job = JOB2RVAL(job);
+ rb_ivar_set(rb_job, id_service, service);
+ return rb_job;
+}
+
+static VALUE
+rb_papi_job_move(VALUE self, VALUE destination)
+{
+ VALUE service;
+ papi_job_t job;
+
+ job = RVAL2JOB(self);
+ service = rb_ivar_get(self, id_service);
+ rb_papi_status_check(papiJobMove(RVAL2SERVICE(service),
+ papiJobGetPrinterName(job),
+ papiJobGetId(job),
+ StringValueCStr(destination)));
+ return Qnil;
+}
+
+static VALUE
+rb_papi_job_cancel(VALUE self)
+{
+ VALUE service;
+ papi_job_t job;
+
+ job = RVAL2JOB(self);
+ service = rb_ivar_get(self, id_service);
+ rb_papi_status_check(papiJobCancel(RVAL2SERVICE(service),
+ papiJobGetPrinterName(job),
+ papiJobGetId(job)));
+ return Qnil;
+}
+
+static VALUE
+rb_papi_job_hold(VALUE self)
+{
+ VALUE service;
+ papi_job_t job;
+
+ job = RVAL2JOB(self);
+ service = rb_ivar_get(self, id_service);
+ rb_papi_status_check(papiJobHold(RVAL2SERVICE(service),
+ papiJobGetPrinterName(job),
+ papiJobGetId(job)));
+ return Qnil;
+}
+
+static VALUE
+rb_papi_job_release(VALUE self)
+{
+ VALUE service;
+ papi_job_t job;
+
+ job = RVAL2JOB(self);
+ service = rb_ivar_get(self, id_service);
+ rb_papi_status_check(papiJobRelease(RVAL2SERVICE(service),
+ papiJobGetPrinterName(job),
+ papiJobGetId(job)));
+ return Qnil;
+}
+
+static VALUE
+rb_papi_job_restart(VALUE self)
+{
+ VALUE service;
+ papi_job_t job;
+
+ job = RVAL2JOB(self);
+ service = rb_ivar_get(self, id_service);
+ rb_papi_status_check(papiJobRestart(RVAL2SERVICE(service),
+ papiJobGetPrinterName(job),
+ papiJobGetId(job)));
+ return Qnil;
+}
+
+static VALUE
+rb_papi_job_promote(VALUE self)
+{
+ VALUE service;
+ papi_job_t job;
+
+ job = RVAL2JOB(self);
+ service = rb_ivar_get(self, id_service);
+ rb_papi_status_check(papiJobPromote(RVAL2SERVICE(service),
+ papiJobGetPrinterName(job),
+ papiJobGetId(job)));
+ return Qnil;
+}
+
+
+/* Job accessors */
+static VALUE
+rb_papi_job_get_attribute_list(VALUE self)
+{
+ return ATTRLST2RVAL_NO_FREE(papiJobGetAttributeList(RVAL2JOB(self)));
+}
+
+static VALUE
+rb_papi_job_get_printer_name(VALUE self)
+{
+ return rb_str_new2(papiJobGetPrinterName(RVAL2JOB(self)));
+}
+
+static VALUE
+rb_papi_job_get_id(VALUE self)
+{
+ return INT2NUM(papiJobGetId(RVAL2JOB(self)));
+}
+
+static VALUE
+rb_papi_job_get_job_ticket(VALUE self)
+{
+ return JT2RVAL_NO_FREE(papiJobGetJobTicket(RVAL2JOB(self)));
+}
+
+
+/* JobStream related */
+static VALUE
+rb_papi_job_stream_callback(VALUE info)
+{
+ VALUE callback;
+
+ callback = rb_ary_shift(info);
+ return rb_apply(callback, id_call, info);
+}
+
+static VALUE
+rb_papi_job_stream_close(VALUE self)
+{
+ VALUE service;
+ papi_job_t job;
+
+ service = rb_ivar_get(self, id_service);
+ rb_papi_status_check(papiJobStreamClose(RVAL2SERVICE(service),
+ RVAL2JS(self),
+ &job));
+
+ return JOB2RVAL(job);
+}
+
+static VALUE
+rb_papi_job_stream_open(int argc, VALUE *argv, VALUE self)
+{
+ VALUE service, printer, job_attributes, job_ticket;
+ VALUE rb_stream, result;
+ papi_stream_t stream;
+
+ rb_scan_args(argc, argv, "22", &service, &printer,
+ &job_attributes, &job_ticket);
+ rb_papi_status_check(papiJobStreamOpen(RVAL2SERVICE(service),
+ StringValueCStr(printer),
+ RVAL2ATTRLST(job_attributes),
+ RVAL2JT(job_ticket),
+ &stream));
+
+ rb_stream = JS2RVAL_NO_FREE(stream);
+ rb_ivar_set(rb_stream, id_service, service);
+
+ if (rb_block_given_p()) {
+ result = rb_ensure(rb_papi_job_stream_callback,
+ rb_ary_new3(2, rb_block_proc(), rb_stream),
+ rb_papi_job_stream_close, rb_stream);
+ } else {
+ result = rb_stream;
+ }
+
+ return result;
+}
+
+static VALUE
+rb_papi_job_stream_write(VALUE self, VALUE buffer)
+{
+ VALUE service;
+
+ service = rb_ivar_get(self, id_service);
+ rb_papi_status_check(papiJobStreamWrite(RVAL2SERVICE(service),
+ RVAL2JS(self),
+ StringValueCStr(buffer),
+ RSTRING(buffer)->len));
+ return Qnil;
+}
+
+
+
+void
+Init_rb_papi_job(VALUE mPAPI)
+{
+ VALUE mListJobs, mJobTicketFormat;
+
+ id_call = rb_intern("call");
+ id_service = rb_intern("service");
+
+ mListJobs = rb_define_module_under(mPAPI, "ListJobs");
+ mJobTicketFormat = rb_define_module_under(mPAPI, "JobTicketFormat");
+
+ cJob = rb_define_class_under(mPAPI, "Job", rb_cData);
+ cJobTicket = rb_define_class_under(mPAPI, "JobTicket", rb_cData);
+ cJobStream = rb_define_class_under(mPAPI, "JobStream", rb_cData);
+
+ /* PAPI_LIST_JOBS_* */
+ rb_define_const(mListJobs, "OTHERS", INT2NUM(PAPI_LIST_JOBS_OTHERS));
+ rb_define_const(mListJobs, "COMPLETED", INT2NUM(PAPI_LIST_JOBS_COMPLETED));
+ rb_define_const(mListJobs, "NOT_COMPLETED",
+ INT2NUM(PAPI_LIST_JOBS_NOT_COMPLETED));
+ rb_define_const(mListJobs, "ALL", INT2NUM(PAPI_LIST_JOBS_ALL));
+
+ /* PAPI_JT_FORMAT_* */
+ rb_define_const(mJobTicketFormat, "JDF", INT2NUM(PAPI_JT_FORMAT_JDF));
+ rb_define_const(mJobTicketFormat, "PWG", INT2NUM(PAPI_JT_FORMAT_PWG));
+
+ /* JobTicket related */
+ rb_define_alloc_func(cJobTicket, rb_papi_job_ticket_allocate);
+ rb_define_method(cJobTicket, "initialize",
+ rb_papi_job_ticket_initialize, 3);
+
+ rb_define_method(cJobTicket, "format", rb_papi_job_ticket_get_format, 0);
+ rb_define_method(cJobTicket, "data", rb_papi_job_ticket_get_data, 0);
+ rb_define_method(cJobTicket, "file_name",
+ rb_papi_job_ticket_get_file_name, 0);
+
+ rb_define_method(cJobTicket, "format=", rb_papi_job_ticket_set_format, 1);
+ rb_define_method(cJobTicket, "data=", rb_papi_job_ticket_set_data, 1);
+ rb_define_method(cJobTicket, "file_name=",
+ rb_papi_job_ticket_set_file_name, 1);
+
+ /* Job related */
+ rb_define_singleton_method(cJob, "submit", rb_papi_job_submit, -1);
+ rb_define_singleton_method(cJob, "submit_by_reference",
+ rb_papi_job_submit_by_reference, -1);
+ rb_define_singleton_method(cJob, "validate", rb_papi_job_validate, -1);
+
+ rb_define_method(cJob, "query", rb_papi_job_query, -1);
+ rb_define_method(cJob, "modify", rb_papi_job_modify, 1);
+ rb_define_method(cJob, "move", rb_papi_job_move, 1);
+ rb_define_method(cJob, "cancel", rb_papi_job_cancel, 0);
+ rb_define_method(cJob, "hold", rb_papi_job_hold, 0);
+ rb_define_method(cJob, "release", rb_papi_job_release, 0);
+ rb_define_method(cJob, "restart", rb_papi_job_restart, 0);
+ rb_define_method(cJob, "promote", rb_papi_job_promote, 0);
+
+ /* Job accessors */
+ rb_define_method(cJob, "attributes", rb_papi_job_get_attribute_list, 0);
+ rb_define_method(cJob, "printer_name", rb_papi_job_get_printer_name, 0);
+ rb_define_method(cJob, "id", rb_papi_job_get_id, 0);
+ rb_define_method(cJob, "ticket", rb_papi_job_get_job_ticket, 0);
+
+ /* JobStream related */
+ rb_define_singleton_method(cJobStream, "open",
+ rb_papi_job_stream_open, -1);
+ rb_define_method(cJobStream, "write", rb_papi_job_stream_write, 1);
+ rb_define_method(cJobStream, "close", rb_papi_job_stream_close, 0);
+}
Added: trunk/papi/source/ruby/rb-papi-metadata.c
===================================================================
--- trunk/papi/source/ruby/rb-papi-metadata.c (rev 0)
+++ trunk/papi/source/ruby/rb-papi-metadata.c 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,74 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+
+#include "rb-papi.h"
+
+static VALUE cMetadata;
+static ID id_new, id_to_s, id_name, id_value, id_metadata;
+
+papi_metadata_t
+rb_papi_r2c_metadata(VALUE data)
+{
+ return NUM2INT(rb_ivar_get(data, id_value));
+}
+
+VALUE
+rb_papi_c2r_metadata(papi_metadata_t data)
+{
+ return rb_hash_aref(rb_ivar_get(cMetadata, id_metadata), INT2NUM(data));
+}
+
+static VALUE
+rb_papi_metadata_initialize(VALUE self, VALUE name, VALUE value)
+{
+ rb_ivar_set(self, id_name, name);
+ rb_ivar_set(self, id_value, value);
+ return Qnil;
+}
+
+static VALUE
+rb_papi_metadata_to_s(VALUE self)
+{
+ VALUE result;
+
+ result = rb_str_new2("#<");
+ rb_str_concat(result, rb_funcall(rb_obj_class(self), id_name, 0));
+ rb_str_cat2(result, ":");
+ rb_str_concat(result, rb_ivar_get(self, id_name));
+ rb_str_cat2(result, ">");
+
+ return result;
+}
+
+#define DEF_METADATA(klass, name) \
+ do { \
+ VALUE metadata = rb_funcall(klass, id_new, 2, \
+ rb_str_new2(# name), \
+ INT2NUM(PAPI_ ## name)); \
+ rb_define_const(klass, # name, metadata); \
+ rb_hash_aset(rb_ivar_get(klass, id_metadata), \
+ INT2NUM(PAPI_ ## name), metadata); \
+ } while (0)
+
+void
+Init_rb_papi_metadata(VALUE mPAPI)
+{
+ id_new = rb_intern("new");
+ id_to_s = rb_intern("to_s");
+ id_name = rb_intern("name");
+ id_value = rb_intern("@value");
+ id_metadata = rb_intern("metadata");
+
+ cMetadata = rb_define_class_under(mPAPI, "Metadata", rb_cObject);
+ rb_ivar_set(cMetadata, id_metadata, rb_hash_new());
+
+ rb_attr(cMetadata, rb_intern("value"), TRUE, FALSE, FALSE);
+ rb_define_method(cMetadata, "initialize", rb_papi_metadata_initialize, 2);
+ rb_define_method(cMetadata, "to_s", rb_papi_metadata_to_s, 0);
+
+ DEF_METADATA(cMetadata, UNSUPPORTED);
+ DEF_METADATA(cMetadata, DEFAULT);
+ DEF_METADATA(cMetadata, UNKNOWN);
+ DEF_METADATA(cMetadata, NO_VALUE);
+ DEF_METADATA(cMetadata, NOT_SETTABLE);
+ DEF_METADATA(cMetadata, DELETE);
+}
Added: trunk/papi/source/ruby/rb-papi-printer.c
===================================================================
--- trunk/papi/source/ruby/rb-papi-printer.c (rev 0)
+++ trunk/papi/source/ruby/rb-papi-printer.c 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,233 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+
+#include "rb-papi.h"
+
+static VALUE cPrinter;
+
+static void
+no_free(void *ptr)
+{
+}
+
+VALUE
+rb_papi_c2r_printer(papi_printer_t printer)
+{
+ return Data_Wrap_Struct(cPrinter, 0, papiPrinterFree, printer);
+}
+
+VALUE
+rb_papi_c2r_printer_no_free(papi_printer_t printer)
+{
+ return Data_Wrap_Struct(cPrinter, 0, no_free, printer);
+}
+
+static VALUE
+rb_papi_printers_list(int argc, VALUE *argv, VALUE self)
+{
+ VALUE requested_attrs, filter;
+ VALUE rb_printers = rb_ary_new();
+ papi_printer_t *printers = NULL;
+ papi_printer_t *printer = NULL;
+ papi_status_t status;
+
+ rb_scan_args(argc, argv, "02", &requested_attrs, &filter);
+
+ status =
+ papiPrintersList(RVAL2SERVICE(self),
+ NIL_P(requested_attrs) ? NULL : NULL,
+ NIL_P(filter) ? NULL : NULL,
+ &printers);
+ rb_papi_status_check(status);
+
+ if (printers) {
+ for (printer = printers; *printer; printer++) {
+ rb_ary_push(rb_printers, PRINTER2RVAL_NO_FREE(*printer));
+ printer++;
+ }
+ }
+
+ return rb_printers;
+}
+
+static VALUE
+rb_papi_printer_query(int argc, VALUE *argv, VALUE self)
+{
+ VALUE name, rb_requested_attrs, job_attributes;
+ char **requested_attrs = NULL;
+ papi_printer_t printer;
+
+ rb_scan_args(argc, argv, "12", &name, &rb_requested_attrs, &job_attributes);
+
+ ARY2STRARY(rb_requested_attrs, requested_attrs);
+
+ rb_papi_status_check(papiPrinterQuery(RVAL2SERVICE(self),
+ StringValueCStr(name),
+ requested_attrs,
+ NIL_P(job_attributes) ?
+ NULL :
+ RVAL2ATTRLST(job_attributes),
+ &printer));
+
+ return PRINTER2RVAL(printer);
+}
+
+static VALUE
+rb_papi_printer_add(VALUE self, VALUE name, VALUE attrs)
+{
+ papi_printer_t printer;
+
+ rb_papi_status_check(papiPrinterAdd(RVAL2SERVICE(self),
+ StringValueCStr(name),
+ RVAL2ATTRLST(attrs),
+ &printer));
+
+ return PRINTER2RVAL(printer);
+}
+
+static VALUE
+rb_papi_printer_modify(VALUE self, VALUE name, VALUE attrs)
+{
+ papi_printer_t printer;
+
+ rb_papi_status_check(papiPrinterModify(RVAL2SERVICE(self),
+ StringValueCStr(name),
+ RVAL2ATTRLST(attrs),
+ &printer));
+
+ return PRINTER2RVAL(printer);
+}
+
+static VALUE
+rb_papi_printer_remove(VALUE self, VALUE name)
+{
+ rb_papi_status_check(papiPrinterRemove(RVAL2SERVICE(self),
+ StringValueCStr(name)));
+ return Qnil;
+}
+
+static VALUE
+rb_papi_printer_disable(int argc, VALUE *argv, VALUE self)
+{
+ VALUE name, message;
+ rb_scan_args(argc, argv, "11", &name, &message);
+
+ rb_papi_status_check(papiPrinterDisable(RVAL2SERVICE(self),
+ StringValueCStr(name),
+ NIL_P(message) ?
+ NULL :
+ StringValueCStr(message)));
+ return Qnil;
+}
+
+static VALUE
+rb_papi_printer_enable(VALUE self, VALUE name)
+{
+ rb_papi_status_check(papiPrinterEnable(RVAL2SERVICE(self),
+ StringValueCStr(name)));
+ return Qnil;
+}
+
+static VALUE
+rb_papi_printer_pause(int argc, VALUE *argv, VALUE self)
+{
+ VALUE name, message;
+ rb_scan_args(argc, argv, "11", &name, &message);
+
+ rb_papi_status_check(papiPrinterPause(RVAL2SERVICE(self),
+ StringValueCStr(name),
+ NIL_P(message) ?
+ NULL :
+ StringValueCStr(message)));
+ return Qnil;
+}
+
+static VALUE
+rb_papi_printer_resume(VALUE self, VALUE name)
+{
+ rb_papi_status_check(papiPrinterResume(RVAL2SERVICE(self),
+ StringValueCStr(name)));
+ return Qnil;
+}
+
+static VALUE
+rb_papi_printer_purge_jobs(VALUE self, VALUE name)
+{
+ VALUE rb_jobs = rb_ary_new();
+ papi_job_t **jobs;
+ papi_job_t *job = NULL;
+
+ jobs = &job;
+ rb_papi_status_check(papiPrinterPurgeJobs(RVAL2SERVICE(self),
+ StringValueCStr(name),
+ jobs));
+
+ for (; *jobs; jobs++) {
+ rb_ary_push(rb_jobs, JOB2RVAL(*jobs));
+ }
+
+ return rb_jobs;
+}
+
+static VALUE
+rb_papi_printer_list_jobs(int argc, VALUE *argv, VALUE self)
+{
+ VALUE rb_jobs = rb_ary_new();
+ VALUE name, rb_requested_attrs, type_mask, max_num_jobs;
+ char **requested_attrs;
+ papi_job_t **jobs;
+ papi_job_t *job = NULL;
+
+ rb_scan_args(argc, argv, "13",
+ &name, &rb_requested_attrs, &type_mask, &max_num_jobs);
+
+ ARY2STRARY(rb_requested_attrs, requested_attrs);
+ jobs = &job;
+ rb_papi_status_check(papiPrinterListJobs(RVAL2SERVICE(self),
+ StringValueCStr(name),
+ requested_attrs,
+ NIL_P(type_mask) ?
+ PAPI_LIST_JOBS_NOT_COMPLETED :
+ NUM2INT(type_mask),
+ NIL_P(max_num_jobs) ?
+ 0 :
+ NUM2INT(max_num_jobs),
+ jobs));
+
+ for (; *jobs; jobs++) {
+ rb_ary_push(rb_jobs, JOB2RVAL(*jobs));
+ }
+
+ return rb_jobs;
+}
+
+static VALUE
+rb_papi_printer_attribute_list(VALUE self)
+{
+ papi_attribute_t **attrs = papiPrinterGetAttributeList(RVAL2PRINTER(self));
+ return ATTRLST2RVAL_NO_FREE(attrs);
+}
+
+
+void
+Init_rb_papi_printer(VALUE mPAPI)
+{
+ VALUE cService;
+
+ cService = rb_const_get(mPAPI, rb_intern("Service"));
+ cPrinter = rb_define_class_under(mPAPI, "Printer", rb_cData);
+
+ rb_define_method(cService, "printers", rb_papi_printers_list, -1);
+ rb_define_method(cService, "printer_query", rb_papi_printer_query, -1);
+ rb_define_method(cService, "printer_add", rb_papi_printer_add, 2);
+ rb_define_method(cService, "printer_modify", rb_papi_printer_modify, 2);
+ rb_define_method(cService, "printer_remove", rb_papi_printer_remove, 1);
+ rb_define_method(cService, "printer_disable", rb_papi_printer_disable, -1);
+ rb_define_method(cService, "printer_enable", rb_papi_printer_enable, 1);
+ rb_define_method(cService, "printer_pause", rb_papi_printer_pause, -1);
+ rb_define_method(cService, "printer_resume", rb_papi_printer_resume, 1);
+ rb_define_method(cService, "printer_purge_jobs",
+ rb_papi_printer_purge_jobs, 1);
+ rb_define_method(cService, "printer_jobs", rb_papi_printer_list_jobs, -1);
+
+ rb_define_method(cPrinter, "attributes", rb_papi_printer_attribute_list, 0);
+}
Added: trunk/papi/source/ruby/rb-papi-resolution.c
===================================================================
--- trunk/papi/source/ruby/rb-papi-resolution.c (rev 0)
+++ trunk/papi/source/ruby/rb-papi-resolution.c 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,16 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+
+#include "rb-papi.h"
+
+void
+Init_rb_papi_resolution(VALUE mPAPI)
+{
+ VALUE mResolutionUnit, cResolution;
+
+ mResolutionUnit = rb_define_module_under(mPAPI, "ResolutionUnit");
+ cResolution = rb_struct_define("Resolution", "xres", "yres", "units", NULL);
+ rb_define_const(mPAPI, "Resolution", cResolution);
+
+ rb_define_const(mResolutionUnit, "PER_INCH", INT2NUM(PAPI_RES_PER_INCH));
+ rb_define_const(mResolutionUnit, "PER_CM", INT2NUM(PAPI_RES_PER_CM));
+}
Added: trunk/papi/source/ruby/rb-papi-service.c
===================================================================
--- trunk/papi/source/ruby/rb-papi-service.c (rev 0)
+++ trunk/papi/source/ruby/rb-papi-service.c 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,179 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+
+#include "rb-papi.h"
+
+static ID id_call, id_callback;
+static VALUE cService;
+
+static void
+no_free(void *ptr)
+{
+}
+
+VALUE
+rb_papi_c2r_service_no_free(papi_service_t service)
+{
+ return Data_Wrap_Struct(cService, NULL, no_free, service);
+}
+
+static VALUE
+rb_papi_service_allocate(VALUE klass)
+{
+ return Data_Wrap_Struct(klass, NULL, papiServiceDestroy, NULL);
+}
+
+static int
+rb_papi_service_auth_cb(papi_service_t service)
+{
+ VALUE callback = (VALUE)papiServiceGetAppData(service);
+ int result = PAPI_FALSE;
+
+ if (!NIL_P(callback)) {
+ result = RTEST(rb_funcall(callback, id_call, 1,
+ SERVICE2RVAL_NO_FREE(service)));
+ }
+
+ return result;
+}
+
+static VALUE
+rb_papi_service_initialize(int argc, VALUE *argv, VALUE self)
+{
+ VALUE name, user, password, encryption, callback;
+ papi_service_t handle;
+ papi_status_t status;
+
+ rb_scan_args(argc, argv, "04", &name, &user, &password, &encryption);
+
+ callback = rb_block_given_p() ? rb_block_proc() : Qnil;
+ status =
+ papiServiceCreate(&handle,
+ NIL_P(name) ? NULL : StringValuePtr(name),
+ NIL_P(user) ? NULL : StringValuePtr(user),
+ NIL_P(password) ? NULL : StringValuePtr(password),
+ rb_papi_service_auth_cb,
+ NIL_P(encryption) ?
+ PAPI_ENCRYPT_IF_REQUESTED :
+ NUM2INT(encryption),
+ (void *)callback);
+ rb_papi_status_check(status);
+
+ RDATA(self)->data = handle;
+ rb_ivar_set(self, id_callback, callback);
+
+ return Qnil;
+}
+
+static VALUE
+rb_papi_service_get_service_name(VALUE self)
+{
+ return rb_str_new2(papiServiceGetServiceName(RVAL2SERVICE(self)));
+}
+
+static VALUE
+rb_papi_service_get_status_message(VALUE self)
+{
+ return rb_str_new2(papiServiceGetStatusMessage(RVAL2SERVICE(self)));
+}
+
+static VALUE
+rb_papi_service_get_attribute_list(VALUE self)
+{
+ papi_attribute_t **attr;
+ attr = papiServiceGetAttributeList(RVAL2SERVICE(self));
+ return ATTRLST2RVAL_NO_FREE(attr);
+}
+
+
+static VALUE
+rb_papi_service_get_user_name(VALUE self)
+{
+ return rb_str_new2(papiServiceGetUserName(RVAL2SERVICE(self)));
+}
+
+static VALUE
+rb_papi_service_get_password(VALUE self)
+{
+ return rb_str_new2(papiServiceGetPassword(RVAL2SERVICE(self)));
+}
+
+static VALUE
+rb_papi_service_get_encription(VALUE self)
+{
+ return INT2NUM(papiServiceGetEncryption(RVAL2SERVICE(self)));
+}
+
+static VALUE
+rb_papi_service_get_auth_callback(VALUE self)
+{
+ return rb_ivar_get(self, id_callback);
+}
+
+
+static VALUE
+rb_papi_service_set_user_name(VALUE self, VALUE user_name)
+{
+ rb_papi_status_check(papiServiceSetUserName(RVAL2SERVICE(self),
+ StringValueCStr(user_name)));
+ return Qnil;
+}
+
+static VALUE
+rb_papi_service_set_password(VALUE self, VALUE password)
+{
+ rb_papi_status_check(papiServiceSetPassword(RVAL2SERVICE(self),
+ StringValueCStr(password)));
+ return Qnil;
+}
+
+static VALUE
+rb_papi_service_set_encription(VALUE self, VALUE encription)
+{
+ rb_papi_status_check(papiServiceSetEncryption(RVAL2SERVICE(self),
+ NUM2INT(encription)));
+ return Qnil;
+}
+
+static VALUE
+rb_papi_service_set_auth_callback(VALUE self)
+{
+ VALUE callback;
+
+ callback = rb_block_proc();
+ rb_ivar_set(self, id_callback, callback);
+ rb_papi_status_check(papiServiceSetAppData(RVAL2SERVICE(self),
+ (void *)callback));
+ return Qnil;
+}
+
+void
+Init_rb_papi_service(VALUE mPAPI)
+{
+ id_call = rb_intern("call");
+ id_callback = rb_intern("callback");
+
+ cService = rb_define_class_under(mPAPI, "Service", rb_cData);
+
+ rb_define_alloc_func(cService, rb_papi_service_allocate);
+ rb_define_method(cService, "initialize", rb_papi_service_initialize, -1);
+
+ rb_define_method(cService, "name", rb_papi_service_get_service_name, 0);
+ rb_define_method(cService, "status_message",
+ rb_papi_service_get_status_message, 0);
+ rb_define_method(cService, "attributes",
+ rb_papi_service_get_attribute_list, 0);
+
+ rb_define_method(cService, "user_name", rb_papi_service_get_user_name, 0);
+ rb_define_method(cService, "password", rb_papi_service_get_password, 0);
+ rb_define_method(cService, "encription",
+ rb_papi_service_get_encription, 0);
+ rb_define_method(cService, "auth_callback",
+ rb_papi_service_get_auth_callback, 0);
+
+ rb_define_method(cService, "user_name=", rb_papi_service_set_user_name, 1);
+ rb_define_method(cService, "password=", rb_papi_service_set_password, 1);
+ rb_define_method(cService, "encription=",
+ rb_papi_service_set_encription, 1);
+ rb_define_method(cService, "auth_callback=",
+ rb_papi_service_set_auth_callback, 1);
+}
Added: trunk/papi/source/ruby/rb-papi-status.c
===================================================================
--- trunk/papi/source/ruby/rb-papi-status.c (rev 0)
+++ trunk/papi/source/ruby/rb-papi-status.c 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,95 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+
+#include "rb-papi.h"
+
+void
+rb_papi_status_check(papi_status_t status)
+{
+ if (status != PAPI_OK) {
+ rb_raise(rb_papi_corresponding_error(status),
+ "%s", papiStatusString(status));
+ }
+}
+
+static VALUE
+rb_papi_status_string(VALUE self, VALUE status)
+{
+ return rb_str_new2(papiStatusString(NUM2INT(status)));
+}
+
+void
+Init_rb_papi_status(VALUE mPAPI)
+{
+ VALUE mStatus;
+ mStatus = rb_define_module_under(mPAPI, "Status");
+
+ rb_define_module_function(mStatus, "string", rb_papi_status_string, 1);
+
+ rb_define_const(mStatus, "OK", INT2NUM(PAPI_OK));
+ rb_define_const(mStatus, "OK_SUBST", INT2NUM(PAPI_OK_SUBST));
+ rb_define_const(mStatus, "OK_CONFLICT", INT2NUM(PAPI_OK_CONFLICT));
+ rb_define_const(mStatus, "OK_IGNORED_SUBSCRIPTIONS",
+ INT2NUM(PAPI_OK_IGNORED_SUBSCRIPTIONS));
+ rb_define_const(mStatus, "OK_IGNORED_NOTIFICATIONS",
+ INT2NUM(PAPI_OK_IGNORED_NOTIFICATIONS));
+ rb_define_const(mStatus, "OK_TOO_MANY_EVENTS",
+ INT2NUM(PAPI_OK_TOO_MANY_EVENTS));
+ rb_define_const(mStatus, "OK_BUT_CANCEL_SUBSCRIPTION",
+ INT2NUM(PAPI_OK_BUT_CANCEL_SUBSCRIPTION));
+ rb_define_const(mStatus, "REDIRECTION_OTHER_SITE",
+ INT2NUM(PAPI_REDIRECTION_OTHER_SITE));
+ rb_define_const(mStatus, "BAD_REQUEST", INT2NUM(PAPI_BAD_REQUEST));
+ rb_define_const(mStatus, "FORBIDDEN", INT2NUM(PAPI_FORBIDDEN));
+ rb_define_const(mStatus, "NOT_AUTHENTICATED",
+ INT2NUM(PAPI_NOT_AUTHENTICATED));
+ rb_define_const(mStatus, "NOT_AUTHORIZED", INT2NUM(PAPI_NOT_AUTHORIZED));
+ rb_define_const(mStatus, "NOT_POSSIBLE", INT2NUM(PAPI_NOT_POSSIBLE));
+ rb_define_const(mStatus, "TIMEOUT", INT2NUM(PAPI_TIMEOUT));
+ rb_define_const(mStatus, "NOT_FOUND", INT2NUM(PAPI_NOT_FOUND));
+ rb_define_const(mStatus, "GONE", INT2NUM(PAPI_GONE));
+ rb_define_const(mStatus, "REQUEST_ENTITY", INT2NUM(PAPI_REQUEST_ENTITY));
+ rb_define_const(mStatus, "REQUEST_VALUE", INT2NUM(PAPI_REQUEST_VALUE));
+ rb_define_const(mStatus, "DOCUMENT_FORMAT", INT2NUM(PAPI_DOCUMENT_FORMAT));
+ rb_define_const(mStatus, "ATTRIBUTES", INT2NUM(PAPI_ATTRIBUTES));
+ rb_define_const(mStatus, "URI_SCHEME", INT2NUM(PAPI_URI_SCHEME));
+ rb_define_const(mStatus, "CHARSET", INT2NUM(PAPI_CHARSET));
+ rb_define_const(mStatus, "CONFLICT", INT2NUM(PAPI_CONFLICT));
+ rb_define_const(mStatus, "COMPRESSION_NOT_SUPPORTED",
+ INT2NUM(PAPI_COMPRESSION_NOT_SUPPORTED));
+ rb_define_const(mStatus, "COMPRESSION_ERROR",
+ INT2NUM(PAPI_COMPRESSION_ERROR));
+ rb_define_const(mStatus, "DOCUMENT_FORMAT_ERROR",
+ INT2NUM(PAPI_DOCUMENT_FORMAT_ERROR));
+ rb_define_const(mStatus, "DOCUMENT_ACCESS_ERROR",
+ INT2NUM(PAPI_DOCUMENT_ACCESS_ERROR));
+ rb_define_const(mStatus, "ATTRIBUTES_NOT_SETTABLE",
+ INT2NUM(PAPI_ATTRIBUTES_NOT_SETTABLE));
+ rb_define_const(mStatus, "IGNORED_ALL_SUBSCRIPTIONS",
+ INT2NUM(PAPI_IGNORED_ALL_SUBSCRIPTIONS));
+ rb_define_const(mStatus, "TOO_MANY_SUBSCRIPTIONS",
+ INT2NUM(PAPI_TOO_MANY_SUBSCRIPTIONS));
+ rb_define_const(mStatus, "IGNORED_ALL_NOTIFICATIONS",
+ INT2NUM(PAPI_IGNORED_ALL_NOTIFICATIONS));
+ rb_define_const(mStatus, "PRINT_SUPPORT_FILE_NOT_FOUND",
+ INT2NUM(PAPI_PRINT_SUPPORT_FILE_NOT_FOUND));
+ rb_define_const(mStatus, "INTERNAL_ERROR", INT2NUM(PAPI_INTERNAL_ERROR));
+ rb_define_const(mStatus, "OPERATION_NOT_SUPPORTED",
+ INT2NUM(PAPI_OPERATION_NOT_SUPPORTED));
+ rb_define_const(mStatus, "SERVICE_UNAVAILABLE",
+ INT2NUM(PAPI_SERVICE_UNAVAILABLE));
+ rb_define_const(mStatus, "VERSION_NOT_SUPPORTED",
+ INT2NUM(PAPI_VERSION_NOT_SUPPORTED));
+ rb_define_const(mStatus, "DEVICE_ERROR", INT2NUM(PAPI_DEVICE_ERROR));
+ rb_define_const(mStatus, "TEMPORARY_ERROR", INT2NUM(PAPI_TEMPORARY_ERROR));
+ rb_define_const(mStatus, "NOT_ACCEPTING", INT2NUM(PAPI_NOT_ACCEPTING));
+ rb_define_const(mStatus, "PRINTER_BUSY", INT2NUM(PAPI_PRINTER_BUSY));
+ rb_define_const(mStatus, "ERROR_JOB_CANCELLED",
+ INT2NUM(PAPI_ERROR_JOB_CANCELLED));
+ rb_define_const(mStatus, "MULTIPLE_JOBS_NOT_SUPPORTED",
+ INT2NUM(PAPI_MULTIPLE_JOBS_NOT_SUPPORTED));
+ rb_define_const(mStatus, "PRINTER_IS_DEACTIVATED",
+ INT2NUM(PAPI_PRINTER_IS_DEACTIVATED));
+ rb_define_const(mStatus, "BAD_ARGUMENT", INT2NUM(PAPI_BAD_ARGUMENT));
+ rb_define_const(mStatus, "JOB_TICKET_NOT_SUPPORTED",
+ INT2NUM(PAPI_JOB_TICKET_NOT_SUPPORTED));
+}
Added: trunk/papi/source/ruby/rb-papi.c
===================================================================
--- trunk/papi/source/ruby/rb-papi.c (rev 0)
+++ trunk/papi/source/ruby/rb-papi.c 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,23 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+
+#include "rb-papi.h"
+
+void
+Init_papi(void)
+{
+ VALUE mPAPI;
+
+ mPAPI = rb_define_module("PAPI");
+
+ Init_rb_papi_error(mPAPI);
+ Init_rb_papi_encrypt(mPAPI);
+ Init_rb_papi_resolution(mPAPI);
+ Init_rb_papi_metadata(mPAPI);
+ Init_rb_papi_attribute(mPAPI);
+ Init_rb_papi_status(mPAPI);
+ Init_rb_papi_job(mPAPI);
+ Init_rb_papi_filter(mPAPI);
+ Init_rb_papi_service(mPAPI);
+ Init_rb_papi_printer(mPAPI);
+ Init_rb_papi_attribute_list(mPAPI);
+}
Added: trunk/papi/source/ruby/rb-papi.h
===================================================================
--- trunk/papi/source/ruby/rb-papi.h (rev 0)
+++ trunk/papi/source/ruby/rb-papi.h 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,88 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+
+#ifndef RB_PAPI_H
+#define RB_PAPI_H
+
+#include <ruby.h>
+
+#include "papi.h"
+
+#ifndef TRUE
+# define TRUE 1
+#endif
+#ifndef FALSE
+# define FALSE 0
+#endif
+
+#define BUFFER_SIZE 4096
+
+#define RVAL2MD(obj) (rb_papi_r2c_metadata(obj))
+#define MD2RVAL(obj) (rb_papi_c2r_metadata(obj))
+#define RVAL2ATTR(obj) ((papi_attribute_t *)(RDATA(obj)->data))
+#define ATTR2RVAL_NO_FREE(obj) (rb_papi_c2r_attribute_no_free(obj))
+#define RVAL2FILTER(obj) ((papi_filter_t *)(RDATA(obj)->data))
+#define FILTER2RVAL(obj) (rb_papi_c2r_filter(obj))
+#define RVAL2SERVICE(obj) ((papi_service_t)(RDATA(obj)->data))
+#define SERVICE2RVAL_NO_FREE(obj) (rb_papi_c2r_service_no_free(obj))
+#define RVAL2PRINTER(obj) ((papi_printer_t)(RDATA(obj)->data))
+#define PRINTER2RVAL(obj) (rb_papi_c2r_printer(obj))
+#define PRINTER2RVAL_NO_FREE(obj) (rb_papi_c2r_printer_no_free(obj))
+#define RVAL2ATTRLST(obj) ((papi_attribute_t **)(RDATA(obj)->data))
+#define ATTRLST2RVAL(obj) (rb_papi_c2r_attribute_list(obj))
+#define ATTRLST2RVAL_NO_FREE(obj) (rb_papi_c2r_attribute_list_no_free(obj))
+#define RVAL2JOB(obj) ((papi_job_t)(RDATA(obj)->data))
+#define JOB2RVAL(obj) (rb_papi_c2r_job(obj))
+#define JOB2RVAL_NO_FREE(obj) (rb_papi_c2r_job_no_free(obj))
+#define RVAL2JT(obj) ((papi_job_ticket_t *)(RDATA(obj)->data))
+#define JT2RVAL_NO_FREE(obj) (rb_papi_c2r_job_ticket_no_free(obj))
+#define RVAL2JS(obj) ((papi_job_ticket_t *)(RDATA(obj)->data))
+#define JS2RVAL_NO_FREE(obj) (rb_papi_c2r_job_stream_no_free(obj))
+
+typedef VALUE (*c2r_attr_value_t) (papi_attribute_value_t *value);
+
+extern void Init_rb_papi_error(VALUE mPAPI);
+extern void Init_rb_papi_encrypt(VALUE mPAPI);
+extern void Init_rb_papi_resolution(VALUE mPAPI);
+extern void Init_rb_papi_metadata(VALUE mPAPI);
+extern void Init_rb_papi_attribute(VALUE mPAPI);
+extern void Init_rb_papi_status(VALUE mPAPI);
+extern void Init_rb_papi_job(VALUE mPAPI);
+extern void Init_rb_papi_filter(VALUE mPAPI);
+extern void Init_rb_papi_service(VALUE mPAPI);
+extern void Init_rb_papi_printer(VALUE mPAPI);
+extern void Init_rb_papi_attribute_list(VALUE mPAPI);
+
+extern VALUE rb_papi_c2r_metadata(papi_metadata_t data);
+extern VALUE rb_papi_c2r_attribute_no_free(papi_attribute_t *attr);
+extern VALUE rb_papi_c2r_attribute_list(papi_attribute_t **attrs);
+extern VALUE rb_papi_c2r_attribute_list_no_free(papi_attribute_t **attrs);
+extern VALUE rb_papi_c2r_job(papi_job_t job);
+extern VALUE rb_papi_c2r_job_no_free(papi_job_t job);
+extern VALUE rb_papi_c2r_job_stream_no_free(papi_stream_t stream);
+
+extern papi_attribute_t *rb_papi_r2c_attribute(VALUE name, VALUE rb_value);
+extern papi_metadata_t rb_papi_r2c_metadata(VALUE data);
+
+extern void rb_papi_status_check(papi_status_t status);
+extern VALUE rb_papi_corresponding_error(papi_status_t status);
+
+#define ARY2STRARY(array, strary) do { \
+ if (NIL_P(array)) { \
+ strary = ALLOCA_N(char *, 1); \
+ *strary = NULL; \
+ } else { \
+ char **attr; \
+ int i, len; \
+ \
+ len = RARRAY(array)->len; \
+ strary = ALLOCA_N(char *, len + 1); \
+ for (i = 0; i < len; i++) { \
+ attr = strary + i; \
+ *attr = StringValueCStr(RARRAY(array)->ptr[i]); \
+ } \
+ attr = strary + i; \
+ *attr = NULL; \
+ } \
+} while (0)
+
+#endif
Added: trunk/papi/source/ruby/run-test.rb
===================================================================
--- trunk/papi/source/ruby/run-test.rb (rev 0)
+++ trunk/papi/source/ruby/run-test.rb 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require "test/unit"
+require "fileutils"
+
+ext_dir_key = "EXT_DIR"
+ext_dir = ENV["EXT_DIR"]
+ext_dir ||= Dir.pwd
+
+$LOAD_PATH.unshift(File.join(ext_dir, ".libs"))
+$LOAD_PATH.unshift(Dir.pwd)
+
+ARGV.unshift("--pattern=test-.*\\.rb")
+
+if Test::Unit::AutoRunner.respond_to?(:standalone?)
+ exit Test::Unit::AutoRunner.run($0, File.dirname($0))
+else
+ exit Test::Unit::AutoRunner.run(false, File.dirname($0))
+end
Property changes on: trunk/papi/source/ruby/run-test.rb
___________________________________________________________________
Name: svn:executable
+ *
Added: trunk/papi/source/ruby/test-papi.rb
===================================================================
--- trunk/papi/source/ruby/test-papi.rb (rev 0)
+++ trunk/papi/source/ruby/test-papi.rb 2006-04-29 01:26:02 UTC (rev 158)
@@ -0,0 +1,207 @@
+require "test/unit"
+
+require "papi"
+
+class PAPITest < Test::Unit::TestCase
+ def test_encrypt
+ assert_equal(0, PAPI::Encrypt::IF_REQUESTED)
+ assert_equal(1, PAPI::Encrypt::NEVER)
+ assert_equal(2, PAPI::Encrypt::REQUIRED)
+ assert_equal(3, PAPI::Encrypt::ALWAYS)
+ end
+
+ def test_resolution_unit
+ assert_equal(3, PAPI::ResolutionUnit::PER_INCH)
+ assert_equal(4, PAPI::ResolutionUnit::PER_CM)
+ end
+
+ def test_metadata
+ assert_equal(0x10, PAPI::Metadata::UNSUPPORTED.value)
+ assert_equal(0x11, PAPI::Metadata::DEFAULT.value)
+ assert_equal(0x12, PAPI::Metadata::UNKNOWN.value)
+ assert_equal(0x13, PAPI::Metadata::NO_VALUE.value)
+ assert_equal(0x15, PAPI::Metadata::NOT_SETTABLE.value)
+ assert_equal(0x16, PAPI::Metadata::DELETE.value)
+ end
+
+ def test_list_jobs
+ assert_equal(0x0001, PAPI::ListJobs::OTHERS)
+ assert_equal(0x0002, PAPI::ListJobs::COMPLETED)
+ assert_equal(0x0004, PAPI::ListJobs::NOT_COMPLETED)
+ assert_equal(0xffff, PAPI::ListJobs::ALL)
+ end
+
+ def test_attribute_add_flags
+ assert_equal(0x0001, PAPI::Attribute::APPEND)
+ assert_equal(0x0002, PAPI::Attribute::REPLACE)
+ assert_equal(0x0004, PAPI::Attribute::EXCL)
+ end
+
+ def test_job_ticket_format
+ assert_equal(0, PAPI::JobTicketFormat::JDF)
+ assert_equal(1, PAPI::JobTicketFormat::PWG)
+ end
+
+ def test_status
+ assert_equal(0x0000, PAPI::Status::OK)
+ assert_equal(0x0001, PAPI::Status::OK_SUBST)
+ assert_equal(0x0002, PAPI::Status::OK_CONFLICT)
+ assert_equal(0x0003, PAPI::Status::OK_IGNORED_SUBSCRIPTIONS)
+ assert_equal(0x0004, PAPI::Status::OK_IGNORED_NOTIFICATIONS)
+ assert_equal(0x0005, PAPI::Status::OK_TOO_MANY_EVENTS)
+ assert_equal(0x0006, PAPI::Status::OK_BUT_CANCEL_SUBSCRIPTION)
+ assert_equal(0x0300, PAPI::Status::REDIRECTION_OTHER_SITE)
+ assert_equal(0x0400, PAPI::Status::BAD_REQUEST)
+ assert_equal(0x0401, PAPI::Status::FORBIDDEN)
+ assert_equal(0x0402, PAPI::Status::NOT_AUTHENTICATED)
+ assert_equal(0x0403, PAPI::Status::NOT_AUTHORIZED)
+ assert_equal(0x0404, PAPI::Status::NOT_POSSIBLE)
+ assert_equal(0x0405, PAPI::Status::TIMEOUT)
+ assert_equal(0x0406, PAPI::Status::NOT_FOUND)
+ assert_equal(0x0407, PAPI::Status::GONE)
+ assert_equal(0x0408, PAPI::Status::REQUEST_ENTITY)
+ assert_equal(0x0409, PAPI::Status::REQUEST_VALUE)
+ assert_equal(0x040a, PAPI::Status::DOCUMENT_FORMAT)
+ assert_equal(0x040b, PAPI::Status::ATTRIBUTES)
+ assert_equal(0x040c, PAPI::Status::URI_SCHEME)
+ assert_equal(0x040d, PAPI::Status::CHARSET)
+ assert_equal(0x040e, PAPI::Status::CONFLICT)
+ assert_equal(0x040f, PAPI::Status::COMPRESSION_NOT_SUPPORTED)
+ assert_equal(0x0410, PAPI::Status::COMPRESSION_ERROR)
+ assert_equal(0x0411, PAPI::Status::DOCUMENT_FORMAT_ERROR)
+ assert_equal(0x0412, PAPI::Status::DOCUMENT_ACCESS_ERROR)
+ assert_equal(0x0413, PAPI::Status::ATTRIBUTES_NOT_SETTABLE)
+ assert_equal(0x0414, PAPI::Status::IGNORED_ALL_SUBSCRIPTIONS)
+ assert_equal(0x0415, PAPI::Status::TOO_MANY_SUBSCRIPTIONS)
+ assert_equal(0x0416, PAPI::Status::IGNORED_ALL_NOTIFICATIONS)
+ assert_equal(0x0417, PAPI::Status::PRINT_SUPPORT_FILE_NOT_FOUND)
+ assert_equal(0x0500, PAPI::Status::INTERNAL_ERROR)
+ assert_equal(0x0501, PAPI::Status::OPERATION_NOT_SUPPORTED)
+ assert_equal(0x0502, PAPI::Status::SERVICE_UNAVAILABLE)
+ assert_equal(0x0503, PAPI::Status::VERSION_NOT_SUPPORTED)
+ assert_equal(0x0504, PAPI::Status::DEVICE_ERROR)
+ assert_equal(0x0505, PAPI::Status::TEMPORARY_ERROR)
+ assert_equal(0x0506, PAPI::Status::NOT_ACCEPTING)
+ assert_equal(0x0507, PAPI::Status::PRINTER_BUSY)
+ assert_equal(0x0508, PAPI::Status::ERROR_JOB_CANCELLED)
+ assert_equal(0x0509, PAPI::Status::MULTIPLE_JOBS_NOT_SUPPORTED)
+ assert_equal(0x050a, PAPI::Status::PRINTER_IS_DEACTIVATED)
+ assert_equal(0x050b, PAPI::Status::BAD_ARGUMENT)
+ assert_equal(0x050c, PAPI::Status::JOB_TICKET_NOT_SUPPORTED)
+ end
+
+ def test_filter_type
+ assert_equal(0, PAPI::FilterType::BITMASK)
+ end
+
+ def test_filter_bitmask
+ assert_equal(0x0000, PAPI::FilterBitmask::LOCAL)
+ assert_equal(0x0001, PAPI::FilterBitmask::CLASS)
+ assert_equal(0x0002, PAPI::FilterBitmask::REMOTE)
+ assert_equal(0x0004, PAPI::FilterBitmask::BW)
+ assert_equal(0x0008, PAPI::FilterBitmask::COLOR)
+ assert_equal(0x0010, PAPI::FilterBitmask::DUPLEX)
+ assert_equal(0x0020, PAPI::FilterBitmask::STAPLE)
+ assert_equal(0x0040, PAPI::FilterBitmask::COPIES)
+ assert_equal(0x0080, PAPI::FilterBitmask::COLLATE)
+ assert_equal(0x0100, PAPI::FilterBitmask::PUNCH)
+ assert_equal(0x0200, PAPI::FilterBitmask::COVER)
+ assert_equal(0x0400, PAPI::FilterBitmask::BIND)
+ assert_equal(0x0800, PAPI::FilterBitmask::SORT)
+ assert_equal(0x1000, PAPI::FilterBitmask::SMALL)
+ assert_equal(0x2000, PAPI::FilterBitmask::MEDIUM)
+ assert_equal(0x4000, PAPI::FilterBitmask::LARGE)
+ assert_equal(0x8000, PAPI::FilterBitmask::VARIABLE)
+ assert_equal(0x10000, PAPI::FilterBitmask::IMPLICIT)
+ assert_equal(0x20000, PAPI::FilterBitmask::DEFAULT)
+ assert_equal(0xfffc, PAPI::FilterBitmask::OPTIONS)
+ end
+
+ def test_service
+ service = PAPI::Service.new("ipp://localhost/")
+ service.attributes.each do |attr|
+ p [attr.name, attr.values]
+ end
+ end
+
+ def test_printer
+ service = PAPI::Service.new
+ printers = service.printers
+
+ name_key = "printer-name"
+ name = nil
+ printers.each do |printer|
+ name, = printer.attributes[name_key]
+ end
+
+ attrs = [name_key]
+ uri = "ipp://localhost/printers/#{name}"
+ printer = service.printer_query(uri, attrs)
+ assert_equal([name], printer.attributes[name_key])
+ end
+
+ def test_printer_add_and_remove
+ return
+ service = PAPI::Service.new(nil, "user", "password")
+
+ name = "dummy"
+ name_key = "printer-name"
+ uri = "ipp://localhost/printers/#{name}"
+ device_uri = "ipp://localhost/printers/PostScript-Printer"
+ ppd = "Generic-PostScript_Printer-Postscript.ppd"
+
+ attrs = "printer-uri=#{uri} "
+ attrs << "#{name_key}=#{name} "
+ attrs << "ppd-name=#{ppd} "
+ attrs << "device-uri=#{device_uri} "
+ attrs << "printer-is-accepting-job=true "
+ attrs << "printer-state=3 "
+ attrs = PAPI::AttributeList.new(attrs)
+
+ printer = service.printer_add(uri, attrs)
+ assert_equal([name], printer.attributes[name_key])
+
+ service.printer_remove(uri)
+ assert_raises(PAPI::Error::NotFound) do
+ service.printer_query(uri)
+ end
+ end
+
+ def test_printer_resume_pause
+ return
+ service = PAPI::Service.new(nil, "user", "password")
+
+ name = "PostScript-Printer"
+ uri = "ipp://localhost/printers/#{name}"
+ state_key = "printer-state"
+ ipp_state_idle = 3
+ ipp_state_stopped = 5
+
+ printer = service.printer_query(uri)
+ assert_equal([ipp_state_idle], printer.attributes[state_key])
+
+ service.printer_pause(uri, "test")
+ printer = service.printer_query(uri)
+ assert_equal([ipp_state_stopped], printer.attributes[state_key])
+
+ service.printer_resume(uri)
+ printer = service.printer_query(uri)
+ assert_equal([ipp_state_idle], printer.attributes[state_key])
+ end
+
+ def test_jobs
+ return
+ service = PAPI::Service.new
+ printers = service.printers
+
+ name_key = "printer-name"
+ name = nil
+ printers.each do |printer|
+ name, = printer.attributes[name_key]
+ break if name
+ end
+
+ uri = "ipp://localhost/printers/#{name}"
+ assert_equal([], service.printer_jobs(uri))
+ end
+end
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|