qtbindings 4.6.3.0

data/ext/ruby/qtruby/src/lib/Qt3.rb

@@ -0,0 +1,6 @@
+begin
+  version = Qt::version
+  raise LoadError.new("Qt4 already loaded") unless version =~ /^3/
+rescue NameError
+  require 'qtruby'
+end

data/ext/ruby/qtruby/src/lib/Qt4.rb

@@ -0,0 +1,6 @@
+begin
+  version = Qt::version
+  raise LoadError.new("Qt3 already loaded") unless version =~ /^4/
+rescue NameError
+  require 'qtruby4'
+end

data/ext/ruby/qtruby/src/marshall.h

@@ -0,0 +1,66 @@
+/***************************************************************************
+ *                                                                         *
+ *   This program 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 of the    *
+ *   License, or (at your option) any later version.                       *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef MARSHALL_H
+#define MARSHALL_H
+
+#include <smoke/smoke.h>
+#include <ruby.h>
+
+class SmokeType;
+
+class Marshall {
+public:
+    /**
+     * FromVALUE is used for virtual function return values and regular
+     * method arguments.
+     *
+     * ToVALUE is used for method return-values and virtual function
+     * arguments.
+     */
+    typedef void (*HandlerFn)(Marshall *);
+    enum Action { FromVALUE, ToVALUE };
+    virtual SmokeType type() = 0;
+    virtual Action action() = 0;
+    virtual Smoke::StackItem &item() = 0;
+    virtual VALUE * var() = 0;
+    virtual void unsupported() = 0;
+    virtual Smoke *smoke() = 0;
+    /**
+     * For return-values, next() does nothing.
+     * For FromRV, next() calls the method and returns.
+     * For ToRV, next() calls the virtual function and returns.
+     *
+     * Required to reset Marshall object to the state it was
+     * before being called when it returns.
+     */
+    virtual void next() = 0;
+    /**
+     * For FromSV, cleanup() returns false when the handler should free
+     * any allocated memory after next().
+     *
+     * For ToSV, cleanup() returns true when the handler should delete
+     * the pointer passed to it.
+     */
+    virtual bool cleanup() = 0;
+
+    virtual ~Marshall() {}
+};    
+
+class SmokeEnumWrapper {
+public:
+	Marshall *m;
+};	
+
+class SmokeClassWrapper {
+public:
+  Marshall *m;
+};
+
+#endif

data/ext/ruby/qtruby/src/marshall_basetypes.h

@@ -0,0 +1,208 @@
+/***************************************************************************
+ *                                                                         *
+ *   This program 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 of the    *
+ *   License, or (at your option) any later version.                       *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef MARSHALL_BASETYPES_H
+#define MARSHALL_BASETYPES_H
+
+template <class T> T* smoke_ptr(Marshall *m) { return (T*) m->item().s_voidp; }
+
+template<> bool* smoke_ptr<bool>(Marshall *m) { return &m->item().s_bool; }
+template<> signed char* smoke_ptr<signed char>(Marshall *m) { return &m->item().s_char; }
+template<> unsigned char* smoke_ptr<unsigned char>(Marshall *m) { return &m->item().s_uchar; }
+template<> short* smoke_ptr<short>(Marshall *m) { return &m->item().s_short; }
+template<> unsigned short* smoke_ptr<unsigned short>(Marshall *m) { return &m->item().s_ushort; }
+template<> int* smoke_ptr<int>(Marshall *m) { return &m->item().s_int; }
+template<> unsigned int* smoke_ptr<unsigned int>(Marshall *m) { return &m->item().s_uint; }
+template<> long* smoke_ptr<long>(Marshall *m) { 	return &m->item().s_long; }
+template<> unsigned long* smoke_ptr<unsigned long>(Marshall *m) { return &m->item().s_ulong; }
+template<> float* smoke_ptr<float>(Marshall *m) { return &m->item().s_float; }
+template<> double* smoke_ptr<double>(Marshall *m) { return &m->item().s_double; }
+template<> void* smoke_ptr<void>(Marshall *m) { return m->item().s_voidp; }
+
+template <class T> T ruby_to_primitive(VALUE);
+template <class T> VALUE primitive_to_ruby(T);
+
+template <class T> 
+static void marshall_from_ruby(Marshall *m) 
+{
+	VALUE obj = *(m->var());
+	(*smoke_ptr<T>(m)) = ruby_to_primitive<T>(obj);
+}
+
+template <class T>
+static void marshall_to_ruby(Marshall *m)
+{
+	*(m->var()) = primitive_to_ruby<T>( *smoke_ptr<T>(m) ); 
+}
+
+#include "marshall_primitives.h"
+#include "marshall_complex.h"
+
+// Special case marshallers
+
+template <> 
+void marshall_from_ruby<char *>(Marshall *m) 
+{
+	m->item().s_voidp = ruby_to_primitive<char*>(*(m->var()));
+}
+
+template <>
+void marshall_from_ruby<unsigned char *>(Marshall *m)
+{
+	m->item().s_voidp = ruby_to_primitive<unsigned char*>(*(m->var()));
+}
+
+template <>
+void marshall_from_ruby<SmokeEnumWrapper>(Marshall *m)
+{
+	VALUE v = *(m->var());
+
+	if (v == Qnil) {
+		m->item().s_enum = 0;
+	} else if (TYPE(v) == T_OBJECT) {
+		// Both Qt::Enum and Qt::Integer have a value() method, so 'get_qinteger()' can be called ok
+		VALUE temp = rb_funcall(qt_internal_module, rb_intern("get_qinteger"), 1, v);
+		m->item().s_enum = (long) NUM2LONG(temp);
+	} else {
+		m->item().s_enum = (long) NUM2LONG(v);
+	}
+
+}
+
+template <>
+void marshall_to_ruby<SmokeEnumWrapper>(Marshall *m)
+{
+	long val = m->item().s_enum;
+    *(m->var()) = rb_funcall(qt_internal_module, rb_intern("create_qenum"),
+                             2, LONG2NUM(val), rb_str_new2( m->type().name()) );
+}
+
+extern QHash<QByteArray, TypeHandler*> type_handlers;
+
+template <>
+void marshall_from_ruby<SmokeClassWrapper>(Marshall *m)
+{
+	VALUE v = *(m->var());
+
+	if (v == Qnil) {
+		m->item().s_class = 0;
+		return;
+	}
+
+	smokeruby_object *o = value_obj_info(v);
+	if (o == 0 || o->ptr == 0) {
+		if(m->type().isRef()) {
+			rb_warning("References can't be nil\n");
+			m->unsupported();
+		}
+					
+		m->item().s_class = 0;
+		return;
+	}
+		
+	void *ptr = o->ptr;
+	if (!m->cleanup() && m->type().isStack()) {
+		ptr = construct_copy(o);
+		if (do_debug & qtdb_gc) {
+			qWarning("copying %s %p to %p\n", resolve_classname(o), o->ptr, ptr);
+		}
+	}
+
+
+	const Smoke::Class &cl = m->smoke()->classes[m->type().classId()];
+	
+	ptr = o->smoke->cast(
+		ptr,				// pointer
+		o->classId,				// from
+		o->smoke->idClass(cl.className, true).index	// to
+		);
+
+	m->item().s_class = ptr;
+	return;
+}
+
+template <>
+void marshall_to_ruby<SmokeClassWrapper>(Marshall *m)
+{
+	if (m->item().s_voidp == 0) {
+		*(m->var()) = Qnil;
+		return;
+	}
+	void *p = m->item().s_voidp;
+	VALUE obj = getPointerObject(p);
+	if (obj != Qnil) {
+    const char* ruby_class  = RSTRING_PTR(rb_funcall(rb_funcall(obj, rb_intern("class"), 0), rb_intern("to_s"), 0));
+    const char* smoke_class = m->type().name();
+    
+    if ((strcmp(ruby_class, "Qt::TextEdit::ExtraSelection") == 0) && (strcmp(smoke_class, "QTextCursor&") == 0))
+    {
+      /* Intentional Fall Through for ExtraSelection returning a cursor */
+    }
+    else
+    {
+		  *(m->var()) = obj;
+		  return ;
+    }
+	}
+
+	smokeruby_object  * o = alloc_smokeruby_object(false, m->smoke(), m->type().classId(), p);
+
+	const char * classname = resolve_classname(o);
+	if (m->type().isConst() && m->type().isRef()) {
+		p = construct_copy( o );
+		if (do_debug & qtdb_gc) {
+			qWarning("copying %s %p to %p\n", classname, o->ptr, p);
+		}
+
+		if (p) {
+			o->ptr = p;
+			o->allocated = true;
+		}
+	}
+		
+	obj = set_obj_info(classname, o);
+	if (do_debug & qtdb_gc) {
+		qWarning("allocating %s %p -> %p\n", classname, o->ptr, (void*)obj);
+	}
+
+/*
+	if(m->type().isStack()) {
+		o->allocated = true;
+		// Keep a mapping of the pointer so that it is only wrapped once as a ruby VALUE
+		mapPointer(obj, o, o->classId, 0);
+	}
+*/			
+
+	*(m->var()) = obj;
+}
+
+template <>
+void marshall_to_ruby<char *>(Marshall *m)
+{
+	char *sv = (char*)m->item().s_voidp;
+	VALUE obj;
+	if(sv)
+		obj = rb_str_new2(sv);
+	else
+		obj = Qnil;
+
+	if(m->cleanup())
+		delete[] sv;
+
+	*(m->var()) = obj;
+}
+
+template <>
+void marshall_to_ruby<unsigned char *>(Marshall *m)
+{
+	m->unsupported();
+}
+
+#endif
+// kate: space-indent false;

data/ext/ruby/qtruby/src/marshall_complex.h

@@ -0,0 +1,175 @@
+/***************************************************************************
+ *                                                                         *
+ *   This program 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 of the    *
+ *   License, or (at your option) any later version.                       *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef MARSHALL_COMPLEX_H
+#define MARSHALL_COMPLEX_H
+
+#include <QtCore/qlist.h>
+#include <QtCore/qlinkedlist.h>
+#include <QtCore/qvector.h>
+
+template <>
+void marshall_from_ruby<long long>(Marshall *m) 
+{
+	VALUE obj = *(m->var());
+	m->item().s_voidp = new long long;
+	*(long long *)m->item().s_voidp = ruby_to_primitive<long long>(obj);
+	
+	m->next();
+	
+	if(m->cleanup() && m->type().isConst()) {
+		delete (long long int *) m->item().s_voidp;
+	}	
+}
+
+template <>
+void marshall_from_ruby<unsigned long long>(Marshall *m) 
+{
+	VALUE obj = *(m->var());
+	m->item().s_voidp = new unsigned long long;
+	*(long long *)m->item().s_voidp = ruby_to_primitive<unsigned long long>(obj);
+
+	m->next();
+	
+	if(m->cleanup() && m->type().isConst()) {
+		delete (long long int *) m->item().s_voidp;
+	}	
+}
+
+template <>
+void marshall_from_ruby<int *>(Marshall *m) 
+{
+	VALUE rv = *(m->var());
+	int *i = new int;
+	
+	if (rv == Qnil) {
+		m->item().s_voidp = 0;
+		return;
+	} else if (TYPE(rv) == T_OBJECT) {
+		// A Qt::Integer has been passed as an integer value
+		VALUE temp = rb_funcall(qt_internal_module, rb_intern("get_qinteger"), 1, rv);
+		*i = NUM2INT(temp);
+		m->item().s_voidp = i;
+		m->next();
+		rb_funcall(qt_internal_module, rb_intern("set_qinteger"), 2, rv, INT2NUM(*i));
+		rv = temp;
+	} else {
+		*i = NUM2INT(rv);
+		m->item().s_voidp = i;
+		m->next();
+	}
+
+	if(m->cleanup() && m->type().isConst()) {
+		delete i;
+	} else {
+		m->item().s_voidp = new int((int)NUM2INT(rv));
+	}
+}
+
+template <>
+void marshall_to_ruby<int *>(Marshall *m)
+{
+	int *ip = (int*)m->item().s_voidp;
+	VALUE rv = *(m->var());
+	if(!ip) {
+		rv = Qnil;
+		return;
+	}
+	
+	*(m->var()) = INT2NUM(*ip);
+	m->next();
+	if(!m->type().isConst())
+		*ip = NUM2INT(*(m->var()));
+}
+
+template <>
+void marshall_from_ruby<unsigned int *>(Marshall *m) 
+{
+	VALUE rv = *(m->var());
+	unsigned int *i = new unsigned int;
+	
+	if (rv == Qnil) {
+		m->item().s_voidp = 0;
+		return;
+	} else if (TYPE(rv) == T_OBJECT) {
+		// A Qt::Integer has been passed as an integer value
+		VALUE temp = rb_funcall(qt_internal_module, rb_intern("get_qinteger"), 1, rv);
+		*i = NUM2INT(temp);
+		m->item().s_voidp = i;
+		m->next();
+		rb_funcall(qt_internal_module, rb_intern("set_qinteger"), 2, rv, INT2NUM(*i));
+		rv = temp;
+	} else {
+		*i = NUM2UINT(rv);
+		m->item().s_voidp = i;
+		m->next();
+	}
+
+	if(m->cleanup() && m->type().isConst()) {
+		delete i;
+	} else {
+		m->item().s_voidp = new int((int)NUM2UINT(rv));
+	}
+}
+
+template <>
+void marshall_to_ruby<unsigned int *>(Marshall *m)
+{
+	unsigned int *ip = (unsigned int*) m->item().s_voidp;
+	VALUE rv = *(m->var());
+	if (ip == 0) {
+		rv = Qnil;
+		return;
+	}
+	
+	*(m->var()) = UINT2NUM(*ip);
+	m->next();
+	if(!m->type().isConst())
+		*ip = NUM2UINT(*(m->var()));
+}
+
+template <>
+void marshall_from_ruby<bool *>(Marshall *m) 
+{
+   VALUE rv = *(m->var());
+	bool * b = new bool;
+
+	if (TYPE(rv) == T_OBJECT) {
+		// A Qt::Boolean has been passed as a value
+		VALUE temp = rb_funcall(qt_internal_module, rb_intern("get_qboolean"), 1, rv);
+		*b = (temp == Qtrue ? true : false);
+		m->item().s_voidp = b;
+		m->next();
+		rb_funcall(qt_internal_module, rb_intern("set_qboolean"), 2, rv, (*b ? Qtrue : Qfalse));
+	} else {
+		*b = (rv == Qtrue ? true : false);
+		m->item().s_voidp = b;
+		m->next();
+	}
+
+	if(m->cleanup() && m->type().isConst()) {
+		delete b;
+	}
+}
+
+template <>
+void marshall_to_ruby<bool *>(Marshall *m)
+{
+	bool *ip = (bool*)m->item().s_voidp;
+	if(!ip) {
+		*(m->var()) = Qnil;
+		return;
+	}
+	*(m->var()) = (*ip?Qtrue:Qfalse);
+	m->next();
+	if(!m->type().isConst())
+	*ip = *(m->var()) == Qtrue ? true : false;
+}
+
+#endif