qtbindings 4.6.3.0

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

@@ -0,0 +1,185 @@
+/***************************************************************************
+                          qtruby.h  -  description
+                             -------------------
+    begin                : Fri Jul 4 2003
+    copyright            : (C) 2003 by Richard Dale
+    email                : Richard_Dale@tipitina.demon.co.uk
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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 QTRUBY_H
+#define QTRUBY_H
+
+#include <QHash>
+#include <smoke/smoke.h>
+
+#include "marshall.h"
+
+#ifndef QT_VERSION_STR
+#define QT_VERSION_STR "Unknown"
+#endif
+#define QTRUBY_VERSION "2.0.5"
+
+#if !defined RSTRING_LEN
+#define RSTRING_LEN(a) RSTRING(a)->len
+#endif
+#if !defined RSTRING_PTR
+#define RSTRING_PTR(a) RSTRING(a)->ptr
+#endif
+#if !defined RARRAY_LEN
+#define RARRAY_LEN(a) RARRAY(a)->len
+#endif
+#if !defined RARRAY_PTR
+#define RARRAY_PTR(a) RARRAY(a)->ptr
+#endif
+#if !defined StringValueCStr
+#define StringValueCStr(s) STR2CSTR(s)
+#endif
+
+inline uint qHash(const Smoke::ModuleIndex& mi) {
+	return qHash(mi.index) ^ qHash(mi.smoke);
+}
+
+struct MocArgument;
+
+namespace QtRuby {
+
+class Q_DECL_EXPORT Binding : public SmokeBinding {
+public:
+	Binding();
+	Binding(Smoke *s);
+	void deleted(Smoke::Index classId, void *ptr);
+	bool callMethod(Smoke::Index method, void *ptr, Smoke::Stack args, bool /*isAbstract*/);
+	char *className(Smoke::Index classId);
+};
+
+}
+
+struct smokeruby_object {
+    void *ptr;
+    bool allocated;
+    Smoke *smoke;
+    int classId;
+};
+
+struct SmokeValue
+{
+  VALUE value;
+  smokeruby_object* o;
+  
+  SmokeValue()
+  : value(Qnil)
+  , o(0) { }
+  
+  SmokeValue(VALUE value, smokeruby_object* o)
+  : value(value)
+  , o(o) { }
+};
+
+struct TypeHandler {
+    const char *name;
+    Marshall::HandlerFn fn;
+};
+
+extern Q_DECL_EXPORT int do_debug;   // evil
+extern Q_DECL_EXPORT VALUE rv_qapp;
+extern Q_DECL_EXPORT int object_count;
+
+typedef const char* (*ResolveClassNameFn)(smokeruby_object * o);
+typedef void (*ClassCreatedFn)(const char* package, VALUE module, VALUE klass);
+
+struct QtRubyModule {
+    const char *name;
+    ResolveClassNameFn resolve_classname;
+    ClassCreatedFn class_created;
+    QtRuby::Binding *binding;
+};
+
+// keep this enum in sync with lib/Qt/qtruby4.rb
+
+enum QtDebugChannel {
+    qtdb_none = 0x00,
+    qtdb_ambiguous = 0x01,
+    qtdb_method_missing = 0x02,
+    qtdb_calls = 0x04,
+    qtdb_gc = 0x08,
+    qtdb_virtual = 0x10,
+    qtdb_verbose = 0x20
+};
+
+extern "C" {
+extern Q_DECL_EXPORT VALUE qt_internal_module;
+extern Q_DECL_EXPORT VALUE qt_module;
+
+extern Q_DECL_EXPORT VALUE qlistmodel_class;
+extern Q_DECL_EXPORT VALUE qmetaobject_class;
+extern Q_DECL_EXPORT VALUE qtablemodel_class;
+extern Q_DECL_EXPORT VALUE qt_base_class;
+extern Q_DECL_EXPORT VALUE qvariant_class;
+
+extern Q_DECL_EXPORT VALUE moduleindex_class;
+
+extern Q_DECL_EXPORT bool application_terminated;
+extern Q_DECL_EXPORT void set_qtruby_embedded(bool yn);
+}
+
+
+extern Q_DECL_EXPORT Smoke::ModuleIndex _current_method;
+
+extern Q_DECL_EXPORT QHash<Smoke*, QtRubyModule> qtruby_modules;
+extern Q_DECL_EXPORT QList<Smoke*> smokeList;
+
+extern Q_DECL_EXPORT QHash<QByteArray, Smoke::ModuleIndex *> methcache;
+extern Q_DECL_EXPORT QHash<QByteArray, Smoke::ModuleIndex *> classcache;
+// Maps from an int id to classname in the form Qt::Widget
+extern Q_DECL_EXPORT QHash<Smoke::ModuleIndex, QByteArray*> IdToClassNameMap;
+
+extern Q_DECL_EXPORT void install_handlers(TypeHandler *);
+
+extern Q_DECL_EXPORT void smokeruby_mark(void * ptr);
+extern Q_DECL_EXPORT void smokeruby_free(void * ptr);
+extern Q_DECL_EXPORT VALUE qchar_to_s(VALUE self);
+
+extern Q_DECL_EXPORT smokeruby_object * alloc_smokeruby_object(bool allocated, Smoke * smoke, int classId, void * ptr);
+extern Q_DECL_EXPORT void free_smokeruby_object(smokeruby_object * o);
+extern Q_DECL_EXPORT smokeruby_object *value_obj_info(VALUE value);
+extern Q_DECL_EXPORT void *value_to_ptr(VALUE ruby_value); // ptr on success, null on fail
+
+extern Q_DECL_EXPORT VALUE getPointerObject(void *ptr);
+extern Q_DECL_EXPORT SmokeValue getSmokeValue(void *ptr);
+extern Q_DECL_EXPORT void mapPointer(VALUE obj, smokeruby_object *o, Smoke::Index classId, void *lastptr);
+extern Q_DECL_EXPORT void unmapPointer(smokeruby_object *, Smoke::Index, void*);
+
+extern Q_DECL_EXPORT const char * resolve_classname(smokeruby_object * o);
+extern Q_DECL_EXPORT VALUE rb_str_catf(VALUE self, const char *format, ...) __attribute__ ((format (printf, 2, 3)));
+
+extern Q_DECL_EXPORT VALUE findMethod(VALUE self, VALUE c_value, VALUE name_value);
+extern Q_DECL_EXPORT VALUE findAllMethods(int argc, VALUE * argv, VALUE self);
+extern Q_DECL_EXPORT VALUE findAllMethodNames(VALUE self, VALUE result, VALUE classid, VALUE flags_value);
+
+extern Q_DECL_EXPORT QByteArray* find_cached_selector(int argc, VALUE * argv, VALUE klass, const char * methodName);
+extern Q_DECL_EXPORT VALUE method_missing(int argc, VALUE * argv, VALUE self);
+extern Q_DECL_EXPORT VALUE class_method_missing(int argc, VALUE * argv, VALUE klass);
+extern Q_DECL_EXPORT QList<MocArgument*> get_moc_arguments(Smoke* smoke, const char * typeName, QList<QByteArray> methodTypes);
+
+extern Q_DECL_EXPORT void * construct_copy(smokeruby_object *o);
+
+extern "C"
+{
+extern Q_DECL_EXPORT VALUE mapObject(VALUE self, VALUE obj);
+extern Q_DECL_EXPORT VALUE qobject_metaobject(VALUE self);
+extern Q_DECL_EXPORT VALUE set_obj_info(const char * className, smokeruby_object * o);
+extern Q_DECL_EXPORT VALUE kross2smoke(VALUE self, VALUE krobject, VALUE new_klass);
+extern Q_DECL_EXPORT const char* value_to_type_flag(VALUE ruby_value);
+extern Q_DECL_EXPORT VALUE prettyPrintMethod(Smoke::Index id);
+}
+
+#endif

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

@@ -0,0 +1,164 @@
+/***************************************************************************
+ *                                                                         *
+ *   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 SMOKERUBY_H
+#define SMOKERUBY_H
+
+#include <smoke/smoke.h>
+
+#undef DEBUG
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#ifndef __USE_POSIX
+#define __USE_POSIX
+#endif
+#ifndef __USE_XOPEN
+#define __USE_XOPEN
+#endif
+#include "ruby.h"
+
+#include <QtCore/qbytearray.h>
+
+#include "qtruby.h"
+#include "marshall.h"
+
+
+class SmokeRuby;
+
+class SmokeType {
+    Smoke::Type *_t;		// derived from _smoke and _id, but cached
+
+    Smoke *_smoke;
+    Smoke::Index _id;
+public:
+    SmokeType() : _t(0), _smoke(0), _id(0) {}
+    SmokeType(Smoke *s, Smoke::Index i) : _smoke(s), _id(i) {
+	if(_id < 0 || _id > _smoke->numTypes) _id = 0;
+	_t = _smoke->types + _id;
+    }
+    // default copy constructors are fine, this is a constant structure
+
+    // mutators
+    void set(Smoke *s, Smoke::Index i) {
+	_smoke = s;
+	_id = i;
+	_t = _smoke->types + _id;
+    }
+
+    // accessors
+    Smoke *smoke() const { return _smoke; }
+    Smoke::Index typeId() const { return _id; }
+    const Smoke::Type &type() const { return *_t; }
+    unsigned short flags() const { return _t->flags; }
+    unsigned short elem() const { return _t->flags & Smoke::tf_elem; }
+    const char *name() const { return _t->name; }
+    Smoke::Index classId() const { return _t->classId; }
+
+    // tests
+    bool isStack() const { return ((flags() & Smoke::tf_ref) == Smoke::tf_stack); }
+    bool isPtr() const { return ((flags() & Smoke::tf_ref) == Smoke::tf_ptr); }
+    bool isRef() const { return ((flags() & Smoke::tf_ref) == Smoke::tf_ref); }
+    bool isConst() const { return (flags() & Smoke::tf_const); }
+    bool isClass() const {
+	if(elem() == Smoke::t_class)
+	    return classId() ? true : false;
+	return false;
+    }
+
+    bool operator ==(const SmokeType &b) const {
+	const SmokeType &a = *this;
+	if(a.name() == b.name()) return true;
+	if(a.name() && b.name() && qstrcmp(a.name(), b.name()) == 0)
+	    return true;
+	return false;
+    }
+    bool operator !=(const SmokeType &b) const {
+	const SmokeType &a = *this;
+	return !(a == b);
+    }
+
+};
+
+class SmokeClass {
+    Smoke::Class *_c;
+    Smoke *_smoke;
+    Smoke::Index _id;
+public:
+    SmokeClass(const SmokeType &t) {
+	_smoke = t.smoke();
+	_id = t.classId();
+	_c = _smoke->classes + _id;
+    }
+    SmokeClass(Smoke *smoke, Smoke::Index id) : _smoke(smoke), _id(id) {
+	_c = _smoke->classes + _id;
+    }
+
+    Smoke *smoke() const { return _smoke; }
+    const Smoke::Class &c() const { return *_c; }
+    Smoke::Index classId() const { return _id; }
+    const char *className() const { return _c->className; }
+    Smoke::ClassFn classFn() const { return _c->classFn; }
+    Smoke::EnumFn enumFn() const { return _c->enumFn; }
+    bool operator ==(const SmokeClass &b) const {
+	const SmokeClass &a = *this;
+	if(a.className() == b.className()) return true;
+	if(a.className() && b.className() && qstrcmp(a.className(), b.className()) == 0)
+	    return true;
+	return false;
+    }
+    bool operator !=(const SmokeClass &b) const {
+	const SmokeClass &a = *this;
+	return !(a == b);
+    }
+    bool isa(const SmokeClass &sc) const {
+	// This is a sick function, if I do say so myself
+	if(*this == sc) return true;
+	Smoke::Index *parents = _smoke->inheritanceList + _c->parents;
+	for(int i = 0; parents[i]; i++) {
+	    if(SmokeClass(_smoke, parents[i]).isa(sc)) return true;
+	}
+	return false;
+    }
+
+    unsigned short flags() const { return _c->flags; }
+    bool hasConstructor() const { return flags() & Smoke::cf_constructor; }
+    bool hasCopy() const { return flags() & Smoke::cf_deepcopy; }
+    bool hasVirtual() const { return flags() & Smoke::cf_virtual; }
+    bool hasFire() const { return !(flags() & Smoke::cf_undefined); }
+};
+
+/*
+ * Simply using typeids isn't enough for signals/slots. It will be possible
+ * to declare signals and slots which use arguments which can't all be
+ * found in a single smoke object. Instead, we need to store smoke => typeid
+ * pairs. We also need additional informatation, such as whether we're passing
+ * a pointer to the union element.
+ */
+
+enum MocArgumentType {
+    xmoc_ptr,
+    xmoc_bool,
+    xmoc_int,
+    xmoc_uint,
+    xmoc_long,
+    xmoc_ulong,
+    xmoc_double,
+    xmoc_charstar,
+    xmoc_QString,
+    xmoc_void
+};
+
+struct MocArgument {
+    // smoke object and associated typeid
+    SmokeType st;
+    MocArgumentType argType;
+};
+
+#endif // SMOKERUBY_H

data/ext/ruby/qtruby/test/opoverloading.rb

@@ -0,0 +1,46 @@
+require 'Qt'
+
+class Qt::Point
+   def to_s
+      "(#{x}, #{y})"
+   end
+end
+
+$t = binding
+def test(str)
+   puts "#{str.ljust 25} => #{eval(str, $t)}"
+end
+
+test("p1 = Qt::Point.new(5,5)")
+test("p2 = Qt::Point.new(20,20)")
+test("p1 + p2")
+test("p1 - p2")
+test("-p1 + p2")
+test("p2 += p1")
+test("p2 -= p1")
+test("p2 * 3")
+
+class Qt::Region
+   def to_s
+      "(#{empty?})"
+   end
+end
+
+test("r1 = Qt::Region.new()")
+test("r2 = Qt::Region.new( 100,100,200,80, Qt::Region::Ellipse )")
+test("r1 + r2")
+
+class Qt::WMatrix
+   def to_s
+      "(#{m11}, #{m12}, #{m21}, #{m22}, #{dx}, #{dy})"
+   end
+end
+
+test("a    = Math::PI/180 * 25")         # convert 25 to radians
+test("sina = Math.sin(a)")
+test("cosa = Math.cos(a)")
+test("m1 = Qt::Matrix.new(1, 0, 0, 1, 10, -20)")  # translation matrix
+test("m2 = Qt::Matrix.new( cosa, sina, -sina, cosa, 0, 0 )")
+test("m3 = Qt::Matrix.new(1.2, 0, 0, 0.7, 0, 0)") # scaling matrix
+test("m = Qt::Matrix.new")
+test("m = m3 * m2 * m1")                  # combine all transformations

data/ext/ruby/qtruby/test/unittests.rb

@@ -0,0 +1,151 @@
+require 'Qt'
+require 'test/unit'
+
+class TestQtRuby < Test::Unit::TestCase
+
+  def setup
+    @app = Qt::Application.instance || Qt::Application.new(ARGV)
+    assert @app
+  end
+
+  def test_link_against_qt4
+    assert_raise(NoMethodError) { @app.setMainWidget(nil) }
+  end
+
+  def test_qapplication_methods
+   assert @app == Qt::Application::instance
+   assert @app == Qt::CoreApplication::instance
+   assert @app == Qt::Application.instance
+   assert @app == Qt::CoreApplication.instance
+   assert @app == $qApp
+  end
+
+  def test_qapplication_inheritance
+   assert @app.inherits("Qt::Application")
+   assert @app.inherits("Qt::CoreApplication")
+   assert @app.inherits("Qt::Object")
+  end
+
+  def test_widget_inheritance
+    widget = Qt::Widget.new(nil)
+    assert widget.inherits("Qt::Widget")
+    assert widget.inherits("Qt::Object")
+    assert widget.inherits("QObject")
+  end
+
+  def test_qstring_marshall
+    widget = Qt::Widget.new(nil)
+    assert widget.objectName.nil?
+    widget.objectName = "Barney"
+    assert widget.objectName == "Barney"
+  end
+
+  def test_widgetlist
+    w1 = Qt::Widget.new(nil)
+    w2 = Qt::Widget.new(w1)
+    w3 = Qt::Widget.new(w1)
+    w4 = Qt::Widget.new(w2)
+
+    assert w1.children == [ w2, w3 ]
+  end
+
+  def test_find_children
+    w = Qt::Widget.new(nil)
+    assert_raise(TypeError) { w.findChildren(nil) }
+
+    assert w.findChildren(Qt::Widget) == [ ]
+    w2 = Qt::Widget.new(w)
+
+    assert w.findChildren(Qt::Widget) == [ w2 ]
+    assert w.findChildren(Qt::Object) == [ w2 ]
+    assert w.findChildren(Qt::LineEdit) == [ ]
+    assert w.findChildren(Qt::Widget,"Bob") == [ ]
+    assert w.findChildren(Qt::Object,"Bob") == [ ]
+
+    w2.objectName = "Bob"
+
+    assert w.findChildren(Qt::Widget) == [ w2 ]
+    assert w.findChildren(Qt::Object) == [ w2 ]
+    assert w.findChildren(Qt::Widget,"Bob") == [ w2 ]
+    assert w.findChildren(Qt::Object,"Bob") == [ w2 ]
+    assert w.findChildren(Qt::LineEdit, "Bob") == [ ]
+
+    w3 = Qt::Widget.new(w)
+    w4 = Qt::LineEdit.new(w2)
+    w4.setObjectName("Bob")
+
+    assert w.findChildren(Qt::Widget) == [ w4, w2, w3 ]
+    assert w.findChildren(Qt::LineEdit) == [ w4 ]
+    assert w.findChildren(Qt::Widget,"Bob") == [ w4, w2 ]    
+    assert w.findChildren(Qt::LineEdit,"Bob") == [ w4 ]    
+  end
+
+  def test_find_child
+    w = Qt::Widget.new(nil)
+    assert_raise(TypeError) { w.findChild(nil) }
+
+    assert_nil w.findChild(Qt::Widget)
+    w2 = Qt::Widget.new(w)
+
+    w3 = Qt::Widget.new(w)
+    w3.objectName = "Bob"
+    w4 = Qt::LineEdit.new(w2)
+    w4.objectName = "Bob"
+
+    assert w.findChild(Qt::Widget,"Bob") == w3
+    assert w.findChild(Qt::LineEdit,"Bob") == w4
+  end
+
+  def test_boolean_marshalling
+    assert Qt::Variant.new(true).toBool
+    assert !Qt::Variant.new(false).toBool
+
+    assert !Qt::Boolean.new(true).nil?
+    assert Qt::Boolean.new(false).nil?
+
+    # Invalid variant conversion should change b to false
+    b = Qt::Boolean.new(true)
+    v = Qt::Variant.new("Blah")
+    v.toInt(b);
+
+    assert b.nil?
+  end
+
+  def test_intp_marshalling
+    assert Qt::Integer.new(100).value == 100
+  end
+
+  def test_variant_conversions
+    v = Qt::Variant.new(Qt::Variant::Invalid)
+
+    assert !v.isValid
+    assert v.isNull
+
+    v = Qt::Variant.new(55)
+    assert v.toInt == 55
+    assert v.toUInt == 55
+    assert v.toLongLong == 55
+    assert v.toULongLong == 55
+    assert Qt::Variant.new(-55).toLongLong == -55
+    assert Qt::Variant.new(-55).toULongLong == 18446744073709551561
+    assert v.toDouble == 55.0
+    assert v.toChar == Qt::Char.new(55)
+    assert v.toString == "55"
+    assert v.toStringList == [ ]
+
+
+    assert Qt::Variant.new("Blah").toStringList == [ "Blah" ]
+
+    assert Qt::Variant.new(Qt::Size.new(30,40)).toSize == Qt::Size.new(30,40)
+    assert Qt::Variant.new(Qt::SizeF.new(20,30)).toSizeF == Qt::SizeF.new(20,30)
+
+    assert Qt::Variant.new(Qt::Rect.new(30,40,10,10)).toRect == Qt::Rect.new(30,40,10,10)
+    assert Qt::Variant.new(Qt::RectF.new(20,30,10,10)).toRectF == Qt::RectF.new(20,30,10,10)
+
+    assert Qt::Variant.new(Qt::Point.new(30,40)).toPoint == Qt::Point.new(30,40)
+    assert Qt::Variant.new(Qt::PointF.new(20,30)).toPointF == Qt::PointF.new(20,30)
+
+
+  end
+
+end