From 90825e2392b2d70e43c7a25b8a3752299a933894 Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdebindings@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- qtruby/rubylib/qtruby/lib/Makefile.am | 4 + qtruby/rubylib/qtruby/lib/Qt.rb | 1 + qtruby/rubylib/qtruby/lib/Qt/Makefile.am | 2 + qtruby/rubylib/qtruby/lib/Qt/qtruby.rb | 1978 ++++++++++++++++++++++++++++++ 4 files changed, 1985 insertions(+) create mode 100644 qtruby/rubylib/qtruby/lib/Makefile.am create mode 100644 qtruby/rubylib/qtruby/lib/Qt.rb create mode 100644 qtruby/rubylib/qtruby/lib/Qt/Makefile.am create mode 100644 qtruby/rubylib/qtruby/lib/Qt/qtruby.rb (limited to 'qtruby/rubylib/qtruby/lib') diff --git a/qtruby/rubylib/qtruby/lib/Makefile.am b/qtruby/rubylib/qtruby/lib/Makefile.am new file mode 100644 index 00000000..e8f6457a --- /dev/null +++ b/qtruby/rubylib/qtruby/lib/Makefile.am @@ -0,0 +1,4 @@ +SUBDIRS = Qt + +rubylibdir = $(RUBY_SITEDIR) +rubylib_DATA = Qt.rb diff --git a/qtruby/rubylib/qtruby/lib/Qt.rb b/qtruby/rubylib/qtruby/lib/Qt.rb new file mode 100644 index 00000000..70e9c776 --- /dev/null +++ b/qtruby/rubylib/qtruby/lib/Qt.rb @@ -0,0 +1 @@ +require 'qtruby' diff --git a/qtruby/rubylib/qtruby/lib/Qt/Makefile.am b/qtruby/rubylib/qtruby/lib/Qt/Makefile.am new file mode 100644 index 00000000..267582ef --- /dev/null +++ b/qtruby/rubylib/qtruby/lib/Qt/Makefile.am @@ -0,0 +1,2 @@ +qtrubylibdir = $(RUBY_SITEDIR)/Qt +qtrubylib_DATA = qtruby.rb diff --git a/qtruby/rubylib/qtruby/lib/Qt/qtruby.rb b/qtruby/rubylib/qtruby/lib/Qt/qtruby.rb new file mode 100644 index 00000000..50f2eaef --- /dev/null +++ b/qtruby/rubylib/qtruby/lib/Qt/qtruby.rb @@ -0,0 +1,1978 @@ +=begin +/*************************************************************************** + qtruby.rb - 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 General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ +=end + +module Qt + module DebugLevel + Off, Minimal, High, Extensive = 0, 1, 2, 3 + end + + module QtDebugChannel + QTDB_NONE = 0x00 + QTDB_AMBIGUOUS = 0x01 + QTDB_METHOD_MISSING = 0x02 + QTDB_CALLS = 0x04 + QTDB_GC = 0x08 + QTDB_VIRTUAL = 0x10 + QTDB_VERBOSE = 0x20 + QTDB_ALL = QTDB_VERBOSE | QTDB_VIRTUAL | QTDB_GC | QTDB_CALLS | QTDB_METHOD_MISSING | QTDB_AMBIGUOUS + end + + @@debug_level = DebugLevel::Off + def Qt.debug_level=(level) + @@debug_level = level + Internal::setDebug Qt::QtDebugChannel::QTDB_ALL if level >= DebugLevel::Extensive + end + + def Qt.debug_level + @@debug_level + end + + class Base + def self.signals(*signal_list) + meta = Qt::Meta[self.name] || Qt::MetaInfo.new(self) + meta.add_signals(signal_list) + meta.changed = true + end + + def self.slots(*slot_list) + meta = Qt::Meta[self.name] || Qt::MetaInfo.new(self) + meta.add_slots(slot_list) + meta.changed = true + end + + def **(a) + return Qt::**(self, a) + end + def +(a) + return Qt::+(self, a) + end + def ~(a) + return Qt::~(self, a) + end + def -@() + return Qt::-(self) + end + def -(a) + return Qt::-(self, a) + end + def *(a) + return Qt::*(self, a) + end + def /(a) + return Qt::/(self, a) + end + def %(a) + return Qt::%(self, a) + end + def >>(a) + return Qt::>>(self, a) + end + def <<(a) + return Qt::<<(self, a) + end + def &(a) + return Qt::&(self, a) + end + def ^(a) + return Qt::^(self, a) + end + def |(a) + return Qt::|(self, a) + end + +# Module has '<', '<=', '>' and '>=' operator instance methods, so pretend they +# don't exist by calling method_missing() explicitely + def <(a) + begin + Qt::method_missing(:<, self, a) + rescue + super(a) + end + end + + def <=(a) + begin + Qt::method_missing(:<=, self, a) + rescue + super(a) + end + end + + def >(a) + begin + Qt::method_missing(:>, self, a) + rescue + super(a) + end + end + + def >=(a) + begin + Qt::method_missing(:>=, self, a) + rescue + super(a) + end + end + +# Object has a '==' operator instance method, so pretend it +# don't exist by calling method_missing() explicitely + def ==(a) + begin + Qt::method_missing(:==, self, a) + rescue + super(a) + end + end + + def methods(regular=true) + if !regular + return singleton_methods + end + + qt_methods(super, 0x0) + end + + def protected_methods + # From smoke.h, Smoke::mf_protected 0x80 + qt_methods(super, 0x80) + end + + def public_methods + methods + end + + def singleton_methods + # From smoke.h, Smoke::mf_static 0x01 + qt_methods(super, 0x01) + end + + private + def qt_methods(meths, flags) + ids = [] + # These methods are all defined in Qt::Base, even if they aren't supported by a particular + # subclass, so remove them to avoid confusion + meths -= ["%", "&", "*", "**", "+", "-", "-@", "/", "<", "<<", "<=", ">", ">=", ">>", "|", "~", "^"] + classid = Qt::Internal::idInstance(self) + Qt::Internal::getAllParents(classid, ids) + ids << classid + ids.each { |c| Qt::Internal::findAllMethodNames(meths, c, flags) } + return meths.uniq + end + end # Qt::Base + + # Delete the underlying C++ instance after exec returns + # Otherwise, rb_gc_call_finalizer_at_exit() can delete + # stuff that Qt::Application still needs for its cleanup. + class Application < Qt::Base + def exec + method_missing(:exec) + self.dispose + Qt::Internal.application_terminated = true + end + + def exit(*args) + method_missing(:exit, *args) + end + + def type(*args) + method_missing(:type, *args) + end + end + + class BoxLayout < Qt::Base + include Enumerable + + def each + it = iterator() + while it.current + yield it.current + it += 1 + end + end + end + + class Buffer < Qt::Base + def open(*args) + method_missing(:open, *args) + end + end + + class ButtonGroup < Qt::Base + def id(*args) + method_missing(:id, *args) + end + end + + class ByteArray < Qt::Base + def to_s + return data() + end + + def length + return size() + end + + def data=(data) + setRawData(data) + end + end + + class CheckListItem < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class ChildEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class ClassInfo < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class CloseEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class Color < Qt::Base + def inspect + str = super + str.sub(/>$/, " %s>" % name) + end + + def pretty_print(pp) + str = to_s + pp.text str.sub(/>$/, " %s>" % name) + end + + def name(*args) + method_missing(:name, *args) + end + end + + class Connection < Qt::Base + def inspect + str = super + str.sub(/>$/, " memberName=%s, memberType=%s, object=%s>" % + [memberName.inspect, memberType == 1 ? "SLOT" : "SIGNAL", object.inspect] ) + end + + def pretty_print(pp) + str = to_s + pp.text str.sub(/>$/, "\n memberName=%s,\n memberType=%s,\n object=%s>" % + [memberName.inspect, memberType == 1 ? "SLOT" : "SIGNAL", object.inspect] ) + end + end + + class ContextMenuEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class Cursor < Qt::Base + def inspect + str = super + str.sub(/>$/, " shape=%d>" % shape) + end + + def pretty_print(pp) + str = to_s + pp.text str.sub(/>$/, " shape=%d>" % shape) + end + end + + class CustomEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class Date < Qt::Base + def inspect + str = super + str.sub(/>$/, " %s>" % toString) + end + + def pretty_print(pp) + str = to_s + pp.text str.sub(/>$/, " %s>" % toString) + end + end + + class DateTime < Qt::Base + def inspect + str = super + str.sub(/>$/, " %s>" % toString) + end + + def pretty_print(pp) + str = to_s + pp.text str.sub(/>$/, " %s>" % toString) + end + end + + class Dialog < Qt::Base + def exec(*args) + method_missing(:exec, *args) + end + end + + class DomAttr < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class DomDocumentType < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class DragLeaveEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class DropEvent < Qt::Base + def format(*args) + method_missing(:format, *args) + end + + def type(*args) + method_missing(:type, *args) + end + end + + class EucJpCodec < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class EucKrCodec < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class Event < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class EventLoop < Qt::Base + def exec(*args) + method_missing(:exec, *args) + end + + def exit(*args) + method_missing(:exit, *args) + end + end + + class File < Qt::Base + def name(*args) + method_missing(:name, *args) + end + + def open(*args) + method_missing(:open, *args) + end + end + + class FocusEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class Font < Qt::Base + def inspect + str = super + str.sub(/>$/, " family=%s, pointSize=%d, weight=%d, italic=%s, bold=%s, underline=%s, strikeOut=%s>" % + [family.inspect, pointSize, weight, italic, bold, underline, strikeOut]) + end + + def pretty_print(pp) + str = to_s + pp.text str.sub(/>$/, "\n family=%s,\n pointSize=%d,\n weight=%d,\n italic=%s,\n bold=%s,\n underline=%s,\n strikeOut=%s>" % + [family.inspect, pointSize, weight, italic, bold, underline, strikeOut]) + end + end + + class Ftp < Qt::Base + def abort(*args) + method_missing(:abort, *args) + end + end + + class GLContext < Qt::Base + def format(*args) + method_missing(:format, *args) + end + end + + class GLWidget < Qt::Base + def format(*args) + method_missing(:format, *args) + end + end + + class Gb18030Codec < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class Gb2312Codec < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class GbkCodec < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class GridLayout < Qt::Base + include Enumerable + + def each + it = iterator() + while it.current + yield it.current + it += 1 + end + end + end + + class HBoxLayout < Qt::Base + include Enumerable + + def each + it = iterator() + while it.current + yield it.current + it += 1 + end + end + end + + class HebrewCodec < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class HideEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class Http < Qt::Base + def abort(*args) + method_missing(:abort, *args) + end + end + + class HttpRequestHeader < Qt::Base + def method(*args) + method_missing(:method, *args) + end + end + + class IconDrag < Qt::Base + def format(*args) + method_missing(:format, *args) + end + + def type(*args) + method_missing(:type, *args) + end + end + + class Image < Qt::Base + def load(*args) + method_missing(:load, *args) + end + end + + class ImageDecoder < Qt::Base + def format(*args) + method_missing(:format, *args) + end + end + + class ImageDrag < Qt::Base + def format(*args) + method_missing(:format, *args) + end + end + + class ImageIO < Qt::Base + def format(*args) + method_missing(:format, *args) + end + end + + class IMEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class JisCodec < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class KeyEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class LCDNumber < Qt::Base + def display(item) + method_missing(:display, item) + end + end + + class Layout < Qt::Base + def freeze(*args) + method_missing(:freeze, *args) + end + end + + class LayoutIterator < Qt::Base + def +(a) + for i in 1..a + send("operator++".to_sym) + end + return self + end + end + + class Library < Qt::Base + def load(*args) + method_missing(:load, *args) + end + end + + class ListView < Qt::Base + include Enumerable + + def each + it = Qt::ListViewItemIterator.new(self) + while it.current + yield it.current + it += 1 + end + end + + def sort(*args) + method_missing(:sort, *args) + end + end + + class ListViewItem < Qt::Base + include Enumerable + + def each + it = Qt::ListViewItemIterator.new(self) + while it.current + yield it.current + it += 1 + end + end + + def sort(*args) + method_missing(:sort, *args) + end + + def inspect + str = super + str.sub!(/>$/, "") + for i in 0..(listView.columns - 1) + str << " text%d=%s," % [i, self.text(i)] + end + str.sub!(/,?$/, ">") + end + + def pretty_print(pp) + str = to_s + str.sub!(/>$/, "") + for i in 0..(listView.columns - 1) + str << " text%d=%s," % [i, self.text(i)] + end + str.sub!(/,?$/, ">") + pp.text str + end + end + + class Locale < Qt::Base + def name(*args) + method_missing(:name, *args) + end + def system(*args) + method_missing(:system, *args) + end + end + + class MenuItem < Qt::Base + def id(*args) + method_missing(:id, *args) + end + end + + class MetaData < Qt::Base + def method(*args) + method_missing(:method, *args) + end + + def name(*args) + method_missing(:name, *args) + end + end + + class MetaEnum < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class MetaProperty < Qt::Base + def id(*args) + method_missing(:id, *args) + end + + def name(*args) + method_missing(:name, *args) + end + + def type(*args) + method_missing(:type, *args) + end + end + + class MouseEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class MoveEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class Object < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class PaintEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class Picture < Qt::Base + def load(*args) + method_missing(:load, *args) + end + end + + class Pixmap < Qt::Base + def load(*args) + method_missing(:load, *args) + end + end + + class Point < Qt::Base + def inspect + str = super + str.sub(/>$/, " x=%d, y=%d>" % [x, y]) + end + + def pretty_print(pp) + str = to_s + pp.text str.sub(/>$/, "\n x=%d,\n y=%d>" % [x, y]) + end + end + + class PolygonScanner < Qt::Base + def scan(*args) + method_missing(:scan, *args) + end + end + + class PopupMenu < Qt::Base + def exec(*args) + method_missing(:exec, *args) + end + end + + class Printer < Qt::Base + def abort(*args) + method_missing(:abort, *args) + end + end + + class MetaObject < Qt::Base + def inspect + str = super + str.sub!(/>$/, "") + str << " className=%s," % className + str << " propertyNames=Array (%d element(s))," % numProperties unless numProperties == 0 + str << " signalNames=Array (%d element(s))," % numSignals unless numSignals == 0 + str << " slotNames=Array (%d element(s))," % numSlots unless numSlots == 0 + str << " superClass=%s," % superClass.inspect unless superClass == nil + str.chop! + str << ">" + end + + def pretty_print(pp) + str = to_s + str.sub!(/>$/, "") + str << "\n className=%s," % className + str << "\n propertyNames=Array (%d element(s))," % numProperties unless numProperties == 0 + str << "\n signalNames=Array (%d element(s))," % numSignals unless numSignals == 0 + str << "\n slotNames=Array (%d element(s))," % numSlots unless numSlots == 0 + str << "\n superClass=%s," % superClass.inspect unless superClass == nil + str.chop! + str << ">" + pp.text str + end + end + + class Rect < Qt::Base + def inspect + str = super + str.sub(/>$/, " left=%d, right=%d, top=%d, bottom=%d>" % [left, right, top, bottom]) + end + + def pretty_print(pp) + str = to_s + pp.text str.sub(/>$/, "\n left=%d,\n right=%d,\n top=%d,\n bottom=%d>" % [left, right, top, bottom]) + end + end + + class ResizeEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class ShowEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class Size < Qt::Base + def inspect + str = super + str.sub(/>$/, " width=%d, height=%d>" % [width, height]) + end + + def pretty_print(pp) + str = to_s + pp.text str.sub(/>$/, "\n width=%d,\n height=%d>" % [width, height]) + end + end + + class SizePolicy < Qt::Base + def inspect + str = super + str.sub(/>$/, " horData=%d, verData=%d>" % [horData, verData]) + end + + def pretty_print(pp) + str = to_s + pp.text str.sub(/>$/, "\n horData=%d,\n verData=%d>" % [horData, verData]) + end + end + + class SjisCodec < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class Socket < Qt::Base + def open(*args) + method_missing(:open, *args) + end + end + + class SocketDevice < Qt::Base + def open(*args) + method_missing(:open, *args) + end + + def type(*args) + method_missing(:type, *args) + end + end + + class SocketNotifier < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class SqlCursor < Qt::Base + def exec(*args) + method_missing(:exec, *args) + end + + def name(*args) + method_missing(:name, *args) + end + + def select(*args) + method_missing(:select, *args) + end + end + + class SqlDatabase < Qt::Base + def exec(*args) + method_missing(:exec, *args) + end + def open(*args) + method_missing(:open, *args) + end + end + + class SqlDriver < Qt::Base + def open(*args) + method_missing(:open, *args) + end + end + + class SqlError < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class SqlField < Qt::Base + def name(*args) + method_missing(:name, *args) + end + + def type(*args) + method_missing(:type, *args) + end + end + + class SqlFieldInfo < Qt::Base + def name(*args) + method_missing(:name, *args) + end + + def type(*args) + method_missing(:type, *args) + end + end + + class SqlIndex < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class SqlQuery < Qt::Base + def exec(*args) + method_missing(:exec, *args) + end + end + + class SqlSelectCursor < Qt::Base + def exec(*args) + method_missing(:exec, *args) + end + + def name(*args) + method_missing(:name, *args) + end + + def select(*args) + method_missing(:select, *args) + end + end + + class StoredDrag < Qt::Base + def format(*args) + method_missing(:format, *args) + end + end + + class StyleSheetItem < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class TextDrag < Qt::Base + def format(*args) + method_missing(:format, *args) + end + end + + class TabletEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class Time < Qt::Base + def inspect + str = super + str.sub(/>$/, " %s>" % toString) + end + + def pretty_print(pp) + str = to_s + pp.text str.sub(/>$/, " %s>" % toString) + end + end + + class TimeEdit < Qt::Base + def display + method_missing(:display) + end + end + + class TimerEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class Translator < Qt::Base + def load(*args) + method_missing(:load, *args) + end + end + + class TranslatorMessage < Qt::Base + def hash(*args) + method_missing(:hash, *args) + end + end + + class TsciiCodec < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class UrlInfo < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class Utf16Codec < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class Utf8Codec < Qt::Base + def name(*args) + method_missing(:name, *args) + end + end + + class Variant < Qt::Base + String = 3 + Date = 26 + Time = 27 + DateTime = 28 + + def initialize(*args) + # In C++, the boolean constructor needs an ugly dummy int argument, + # so special case that here to avoid needing it in Ruby + if args[0] == true || args[0] == false + super(args[0], 0) + else + super + end + end + + def to_a + return toStringList() + end + + def to_f + return toDouble() + end + + def to_i + return toInt() + end + + def to_int + return toInt() + end + + def to_ruby + case type() + when Qt::Variant::Bitmap + return toBitmap + when Qt::Variant::Bool + return toBool + when Qt::Variant::Brush + return toBrush + when Qt::Variant::ByteArray + return toByteArray + when Qt::Variant::Color + return toColor + when Qt::Variant::ColorGroup + return toColorGroup + when Qt::Variant::CString + return toCString + when Qt::Variant::Cursor + return toCursor + when Qt::Variant::Date + return toDate + when Qt::Variant::DateTime + return toDateTime + when Qt::Variant::Double + return toDouble + when Qt::Variant::Font + return toFont + when Qt::Variant::IconSet + return toIconSet + when Qt::Variant::Image + return toImage + when Qt::Variant::Int + return toInt + when Qt::Variant::KeySequence + return toKeySequence + when Qt::Variant::List + return toList + when Qt::Variant::LongLong + return toLongLong + when Qt::Variant::Map + return toMap + when Qt::Variant::Palette + return toPalette + when Qt::Variant::Pen + return toPen + when Qt::Variant::Pixmap + return toPixmap + when Qt::Variant::Point + return toPoint + when Qt::Variant::PointArray + return toPointArray + when Qt::Variant::Rect + return toRect + when Qt::Variant::Region + return toRegion + when Qt::Variant::Size + return toSize + when Qt::Variant::SizePolicy + return toSizePolicy + when Qt::Variant::String + return toString + when Qt::Variant::StringList + return toStringList + when Qt::Variant::Time + return toTime + when Qt::Variant::UInt + return toUint + when Qt::Variant::ULongLong + return toULongLong + end + end + + def inspect + str = super + str.sub(/>$/, " typeName=%s>" % typeName) + end + + def pretty_print(pp) + str = to_s + pp.text str.sub(/>$/, " typeName=%s>" % typeName) + end + + def load(*args) + method_missing(:load, *args) + end + + def type(*args) + method_missing(:type, *args) + end + end + + class VBoxLayout < Qt::Base + include Enumerable + + def each + it = iterator() + while it.current + yield it.current + it += 1 + end + end + end + + class WhatsThis < Qt::Base + def WhatsThis.display(*k) + method_missing(:display, *k) + end + end + + class WheelEvent < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + class Widget < Qt::Base + def raise(*args) + method_missing(:raise, *args) + end + end + + class WidgetStack < Qt::Base + def id(*args) + method_missing(:id, *args) + end + end + + class XmlAttributes < Qt::Base + def type(*args) + method_missing(:type, *args) + end + end + + # Provides a mutable numeric class for passing to methods with + # C++ 'int*' or 'int&' arg types + class Integer + attr_accessor :value + def initialize(n=0) @value = n end + + def +(n) + return Integer.new(@value + n.to_i) + end + def -(n) + return Integer.new(@value - n.to_i) + end + def *(n) + return Integer.new(@value * n.to_i) + end + def /(n) + return Integer.new(@value / n.to_i) + end + def %(n) + return Integer.new(@value % n.to_i) + end + def **(n) + return Integer.new(@value ** n.to_i) + end + + def |(n) + return Integer.new(@value | n.to_i) + end + def &(n) + return Integer.new(@value & n.to_i) + end + def ^(n) + return Integer.new(@value ^ n.to_i) + end + def <<(n) + return Integer.new(@value << n.to_i) + end + def >>(n) + return Integer.new(@value >> n.to_i) + end + + def >(n) + return @value > n.to_i + end + def >=(n) + return @value >= n.to_i + end + def <(n) + return @value < n.to_i + end + def <=(n) + return @value <= n.to_i + end + + def <=>(n) + if @value < n + return -1 + elsif @value > n + return 1 + else + return 0 + end + end + + def to_f() return @value.to_f end + def to_i() return @value.to_i end + def to_s() return @value.to_s end + + def coerce(n) + [n, @value] + end + end + + # If a C++ enum was converted to an ordinary ruby Integer, the + # name of the type is lost. The enum type name is needed for overloaded + # method resolution when two methods differ only by an enum type. + class Enum < Qt::Integer + attr_accessor :type + def initialize(n, type) + super(n) + @value = n + @type = type + end + + def |(n) + return Enum.new(@value | n.to_i, @type) + end + def &(n) + return Enum.new(@value & n.to_i, @type) + end + def ^(n) + return Enum.new(@value ^ n.to_i, @type) + end + def <(n) + return @value < n.to_i + end + def <=(n) + return @value <= n.to_i + end + def >(n) + return @value > n.to_i + end + def >=(n) + return @value >= n.to_i + end + def <<(n) + return Enum.new(@value << n.to_i, @type) + end + def >>(n) + return Enum.new(@value >> n.to_i, @type) + end + + def ==(n) return @value == n.to_i end + def to_i() return @value end + + def inspect + to_s + end + + def pretty_print(pp) + pp.text "#<%s:0x%8.8x @type=%s, @value=%d>" % [self.class.name, object_id, type, value] + end + end + + # Provides a mutable boolean class for passing to methods with + # C++ 'bool*' or 'bool&' arg types + class Boolean + attr_accessor :value + def initialize(b=false) @value = b end + def nil? + return !@value + end + end + + class SignalBlockInvocation < Qt::Object + def initialize(parent, block, args) + super(parent) + self.class.slots "invoke(#{args})" + @block = block + end + + def invoke(*args) + @block.call(*args) + end + end + + class BlockInvocation < Qt::Object + def initialize(target, block, args) + super(target) + self.class.slots "invoke(#{args})" + @target = target + @block = block + end + + def invoke(*args) + @target.instance_exec(*args, &@block) + end + end + + module Internal + @@classes = {} + @@cpp_names = {} + @@idclass = [] + + def Internal.normalize_classname(classname) + if classname =~ /^Qext/ + now = classname.sub(/^Qext(?=[A-Z])/,'Qext::') + elsif classname =~ /^Q/ + now = classname.sub(/^Q(?=[A-Z])/,'Qt::') + elsif classname =~ /^(KConfigSkeleton|KWin)::/ + now = classname.sub(/^K?(?=[A-Z])/,'KDE::') + elsif classname !~ /::/ + now = classname.sub(/^K?(?=[A-Z])/,'KDE::') + else + now = classname + end + # puts "normalize_classname = was::#{classname}, now::#{now}" + now + end + + def Internal.init_class(c) + classname = Qt::Internal::normalize_classname(c) + classId = Qt::Internal.idClass(c) + insert_pclassid(classname, classId) + @@idclass[classId] = classname + @@cpp_names[classname] = c + klass = isQObject(classId) ? create_qobject_class(classname) \ + : create_qt_class(classname) + @@classes[classname] = klass unless klass.nil? + end + + def Internal.debug_level + Qt.debug_level + end + + def Internal.checkarg(argtype, typename) + puts " #{typename} (#{argtype})" if debug_level >= DebugLevel::High + if argtype == 'i' + if typename =~ /^int&?$|^signed int&?$|^signed$|^Q_INT32&?$/ + return 1 + elsif typename =~ /^(?:short|ushort|unsigned short int|uchar|uint|long|ulong|unsigned long int|unsigned|float|double|Q_UINT32|Q_UINT16|Q_INT16)$/ + return 0 + else + t = typename.sub(/^const\s+/, '') + t.sub!(/[&*]$/, '') + if isEnum(t) + return 0 + end + end + elsif argtype == 'n' + if typename =~ /^double$/ + return 2 + elsif typename =~ /^float$/ + return 1 + elsif typename =~ /^int&?$/ + return 0 + elsif typename =~ /^(?:short|ushort|uint|long|ulong|signed|unsigned|float|double)$/ + return 0 + else + t = typename.sub(/^const\s+/, '') + t.sub!(/[&*]$/, '') + if isEnum(t) + return 0 + end + end + elsif argtype == 'B' + if typename =~ /^(?:bool)[*&]?$/ + return 0 + end + elsif argtype == 's' + if typename =~ /^(const )?((QChar)[*&]?)$/ + return 1 + elsif typename =~ /^(?:u?char\*|const u?char\*|(?:const )?(Q(C?)String)[*&]?)$/ + qstring = !$1.nil? + c = ("C" == $2) + return c ? 2 : (qstring ? 3 : 0) + end + elsif argtype == 'a' + # FIXME: shouldn't be hardcoded. Installed handlers should tell what ruby type they expect. + if typename =~ /^(?: + const\ QCOORD\*| + (?:const\ )? + (?: + QStringList[\*&]?| + QValueList[\*&]?| + QRgb\*| + char\*\* + ) + )$/x + return 0 + end + elsif argtype == 'u' + # Give nil matched against string types a higher score than anything else + if typename =~ /^(?:u?char\*|const u?char\*|(?:const )?((Q(C?)String))[*&]?)$/ + return 1 + # Numerics will give a runtime conversion error, so they fail the match + elsif typename =~ /^(?:short|ushort|uint|long|ulong|signed|unsigned|int)$/ + return -99 + else + return 0 + end + elsif argtype == 'U' + if typename =~ /QStringList/ + return 1 + else + return 0 + end + else + t = typename.sub(/^const\s+/, '') + t.sub!(/[&*]$/, '') + if argtype == t + return 1 + elsif classIsa(argtype, t) + return 0 + elsif isEnum(argtype) and + (t =~ /int|Q_INT32|uint|Q_UINT32|long|ulong/ or isEnum(t)) + return 0 + end + end + return -99 + end + + def Internal.find_class(classname) + # puts @@classes.keys.sort.join "\n" + @@classes[classname] + end + + # Runs the initializer as far as allocating the Qt C++ instance. + # Then use a throw to jump back to here with the C++ instance + # wrapped in a new ruby variable of type T_DATA + def Internal.try_initialize(instance, *args) + initializer = instance.method(:initialize) + catch "newqt" do + initializer.call(*args) + end + end + + # If a block was passed to the constructor, then + # run that now. Either run the context of the new instance + # if no args were passed to the block. Or otherwise, + # run the block in the context of the arg. + def Internal.run_initializer_block(instance, block) + if block.arity == -1 + instance.instance_eval(&block) + elsif block.arity == 1 + block.call(instance) + else + raise ArgumentError, "Wrong number of arguments to block(#{block.arity} for 1)" + end + end + + def Internal.do_method_missing(package, method, klass, this, *args) + if klass.class == Module + classname = klass.name + else + classname = @@cpp_names[klass.name] + if classname.nil? + if klass != Object and klass != Qt + return do_method_missing(package, method, klass.superclass, this, *args) + else + return nil + end + end + end + + if method == "new" + method = classname.dup + method.gsub!(/^(KParts|KIO|KNS|DOM|Kontact|Kate|KTextEditor|KConfigSkeleton::ItemEnum|KConfigSkeleton|KWin)::/,"") + end + method = "operator" + method.sub("@","") if method !~ /[a-zA-Z]+/ + # Change foobar= to setFoobar() + method = 'set' + method[0,1].upcase + method[1,method.length].sub("=", "") if method =~ /.*[^-+%\/|=]=$/ + + methods = [] + methods << method.dup + args.each do |arg| + if arg.nil? + # For each nil arg encountered, triple the number of munged method + # templates, in order to cover all possible types that can match nil + temp = [] + methods.collect! do |meth| + temp << meth + '?' + temp << meth + '#' + meth << '$' + end + methods.concat(temp) + elsif isObject(arg) + methods.collect! { |meth| meth << '#' } + elsif arg.kind_of? Array or arg.kind_of? Hash + methods.collect! { |meth| meth << '?' } + else + methods.collect! { |meth| meth << '$' } + end + end + + methodIds = [] + methods.collect { |meth| methodIds.concat( findMethod(classname, meth) ) } + + if method =~ /_/ && methodIds.length == 0 + # If the method name contains underscores, convert to camel case + # form and try again + method.gsub!(/(.)_(.)/) {$1 + $2.upcase} + return do_method_missing(package, method, klass, this, *args) + end + + if debug_level >= DebugLevel::High + puts "classname == #{classname}" + puts ":: method == #{method}" + puts "-> methodIds == #{methodIds.inspect}" + puts "candidate list:" + prototypes = dumpCandidates(methodIds).split("\n") + line_len = (prototypes.collect { |p| p.length }).max + prototypes.zip(methodIds) { + |prototype,id| puts "#{prototype.ljust line_len} (#{id})" + } + end + + chosen = nil + if methodIds.length > 0 + best_match = -1 + methodIds.each do + |id| + puts "matching => #{id}" if debug_level >= DebugLevel::High + current_match = 0 + (0...args.length).each do + |i| + current_match += checkarg( getVALUEtype(args[i]), getTypeNameOfArg(id, i) ) + end + + # Note that if current_match > best_match, then chosen must be nil + if current_match > best_match + best_match = current_match + chosen = id + # Multiple matches are an error; the equality test below _cannot_ be commented out. + # If ambiguous matches occur the problem must be fixed be adjusting the relative + # ranking of the arg types involved in checkarg(). + elsif current_match == best_match + chosen = nil + end + puts "match => #{id} score: #{current_match}" if debug_level >= DebugLevel::High + end + + puts "Resolved to id: #{chosen}" if !chosen.nil? && debug_level >= DebugLevel::High + end + + if debug_level >= DebugLevel::Minimal && chosen.nil? && method !~ /^operator/ + id = find_pclassid(normalize_classname(klass.name)) + hash = findAllMethods(id) + constructor_names = nil + if method == classname + puts "No matching constructor found, possibles:\n" + constructor_names = hash.keys.grep(/^#{classname}/) + else + puts "Possible prototypes:" + constructor_names = hash.keys + end + method_ids = hash.values_at(*constructor_names).flatten + puts dumpCandidates(method_ids) + end + + puts "setCurrentMethod(#{chosen})" if debug_level >= DebugLevel::High + setCurrentMethod(chosen) if chosen + return nil + end + + def Internal.init_all_classes() + Qt::Internal::getClassList().each do |c| + if c == "Qt" + # Don't change Qt to Qt::t, just leave as is + @@cpp_names["Qt"] = c + elsif c != "QInternal" + Qt::Internal::init_class(c) + end + end + + @@classes['Qt::Integer'] = Qt::Integer + @@classes['Qt::Boolean'] = Qt::Boolean + @@classes['Qt::Enum'] = Qt::Enum + end + + def Internal.get_qinteger(num) + return num.value + end + + def Internal.set_qinteger(num, val) + return num.value = val + end + + def Internal.create_qenum(num, type) + return Qt::Enum.new(num, type) + end + + def Internal.get_qenum_type(e) + return e.type + end + + def Internal.get_qboolean(b) + return b.value + end + + def Internal.set_qboolean(b, val) + return b.value = val + end + + def Internal.getAllParents(class_id, res) + getIsa(class_id).each do |s| + c = idClass(s) + res << c + getAllParents(c, res) + end + end + + def Internal.getSignalNames(klass) + meta = Meta[klass.name] || MetaInfo.new(klass) + signal_names = [] + meta.get_signals.each do |signal| + signal_names.push signal.name + end + return signal_names + end + + def Internal.signalInfo(qobject, signal_name) + signals = Meta[qobject.class.name].get_signals + signals.each_with_index do |signal, i| + if signal.name == signal_name + return [signal.full_name, i] + end + end + end + + def Internal.signalAt(qobject, index) + klass = qobject.class + begin + meta = Meta[klass.name] + klass = klass.superclass + end while meta.nil? and klass != Object + meta.get_signals[index].full_name + end + + def Internal.slotAt(qobject, index) + klass = qobject.class + begin + meta = Meta[klass.name] + klass = klass.superclass + end while meta.nil? and klass != Object + meta.get_slots[index].full_name + end + + def Internal.getMocArguments(member) + argStr = member.sub(/.*\(/, '').sub(/\)$/, '') + args = argStr.scan(/([^,]*<[^>]+>)|([^,]+)/) + mocargs = allocateMocArguments(args.length) + args.each_with_index do |arg, i| + arg = arg.to_s + a = arg.sub(/^const\s+/, '') + a = (a =~ /^(bool|int|double|char\*|QString)&?$/) ? $1 : 'ptr' + valid = setMocType(mocargs, i, arg, a) + end + result = [] + result << args.length << mocargs + result + end + + def Internal.makeMetaData(data) + return nil if data.nil? + tbl = [] + data.each do |entry| + name = entry.name + argStr = entry.arg_types + params = [] + args = argStr.scan(/[^,]+/) + args.each do |arg| + name = '' # umm.. is this the aim?, well. it works. soo... ;-) + param = make_QUParameter(name, arg, 0, 1) + params << param + end + method = make_QUMethod(name, params) + tbl << make_QMetaData(entry.full_name, method) + end + make_QMetaData_tbl(tbl) + end + + def Internal.getMetaObject(qobject) + klass = qobject.class + begin + meta = Meta[klass.name] + klass = klass.superclass + end while meta.nil? and klass != Object + + return nil if meta.nil? + + if meta.metaobject.nil? or meta.changed + slots = meta.get_slots + slotTable = makeMetaData(slots) + signals = meta.get_signals + signalTable = makeMetaData(signals) + meta.metaobject = make_metaObject(qobject.class.name, + qobject.staticMetaObject(), + slotTable, + slots.length, + signalTable, + signals.length) + addSignalMethods(qobject.class, getSignalNames(qobject.class)) + meta.changed = false + end + + meta.metaobject + end + + def Internal.connect(src, signal, target, block) + signature = (signal =~ /\((.*)\)/) ? $1 : "" + return Qt::Object.connect( src, + signal, + Qt::BlockInvocation.new(target, block, signature), + SLOT("invoke(#{signature})") ) + end + + def Internal.signal_connect(src, signal, block) + signature = (signal =~ /\((.*)\)/) ? $1 : "" + return Qt::Object.connect( src, + signal, + Qt::SignalBlockInvocation.new(src, block, signature), + SLOT("invoke(#{signature})") ) + end + end # Qt::Internal + + Meta = {} + + # An entry for each signal or slot + # Example + # foobar(QString,bool) + # :name is 'foobar' + # :full_name is 'foobar(QString,bool)' + # :arg_types is 'QString,bool' + QObjectMember = Struct.new :name, :full_name, :arg_types + + class MetaInfo + attr_accessor :signals, :slots, :metaobject, :mocargs, :changed + def initialize(klass) + Meta[klass.name] = self + @klass = klass + @metaobject = nil + @signals = [] + @slots = [] + @changed = false + Internal.addMetaObjectMethods(klass) + end + + def add_signals(signal_list) + signal_list.each do |signal| + if signal.kind_of? Symbol + signal = signal.to_s + "()" + end + signal = Qt::Object.normalizeSignalSlot(signal) + if signal =~ /([^\s]*)\((.*)\)/ + @signals.push QObjectMember.new($1, signal, $2) + else + qWarning( "#{@klass.name}: Invalid signal format: '#{signal}'" ) + end + end + end + + # Return a list of signals, including inherited ones + def get_signals + all_signals = [] + current = @klass + while current != Qt::Base + meta = Meta[current.name] + if !meta.nil? + all_signals.concat meta.signals + end + current = current.superclass + end + return all_signals + end + + def add_slots(slot_list) + slot_list.each do |slot| + if slot.kind_of? Symbol + slot = slot.to_s + "()" + end + slot = Qt::Object.normalizeSignalSlot(slot) + if slot =~ /([^\s]*)\((.*)\)/ + @slots.push QObjectMember.new($1, slot, $2) + else + qWarning( "#{@klass.name}: Invalid slot format: '#{slot}'" ) + end + end + end + + # Return a list of slots, including inherited ones + def get_slots + all_slots = [] + current = @klass + while current != Qt::Base + meta = Meta[current.name] + if !meta.nil? + all_slots.concat meta.slots + end + current = current.superclass + end + return all_slots + end + end # Qt::MetaInfo + + IO_Direct = 0x0100 + IO_Sequential = 0x0200 + IO_Combined = 0x0300 + IO_TypeMask = 0x0f00 + IO_Raw = 0x0040 + IO_Async = 0x0080 + IO_ReadOnly = 0x0001 + IO_WriteOnly = 0x0002 + IO_ReadWrite = 0x0003 + IO_Append = 0x0004 + IO_Truncate = 0x0008 + IO_Translate = 0x0010 + IO_ModeMask = 0x00ff + IO_Open = 0x1000 + IO_StateMask = 0xf000 + IO_Ok = 0 + IO_ReadError = 1 + IO_WriteError = 2 + IO_FatalError = 3 + IO_ResourceError = 4 + IO_OpenError = 5 + IO_ConnectError = 5 + IO_AbortError = 6 + IO_TimeOutError = 7 + IO_UnspecifiedError= 8 + +end # Qt + +class Object + def SIGNAL(signal) + if signal.kind_of? Symbol + return "2" + signal.to_s + "()" + else + return "2" + signal + end + end + + def SLOT(slot) + if slot.kind_of? Symbol + return "1" + slot.to_s + "()" + else + return "1" + slot + end + end + + def emit(signal) + return signal + end + + # See the discussion here: http://eigenclass.org/hiki.rb?instance_exec + # about implementations of the ruby 1.9 method instance_exec(). This + # version is the one from Rails. It isn't thread safe, but that doesn't + # matter for the intended use in invoking blocks as Qt slots. + def instance_exec(*arguments, &block) + block.bind(self)[*arguments] + end +end + +class Proc + # Part of the Rails Object#instance_exec implementation + def bind(object) + block, time = self, Time.now + (class << object; self end).class_eval do + method_name = "__bind_#{time.to_i}_#{time.usec}" + define_method(method_name, &block) + method = instance_method(method_name) + remove_method(method_name) + method + end.bind(object) + end +end + +class Module + alias_method :_constants, :constants + alias_method :_instance_methods, :instance_methods + alias_method :_protected_instance_methods, :protected_instance_methods + alias_method :_public_instance_methods, :public_instance_methods + + private :_constants, :_instance_methods + private :_protected_instance_methods, :_public_instance_methods + + def constants + qt_methods(_constants, 0x10, true) + end + + def instance_methods(inc_super=true) + qt_methods(_instance_methods(inc_super), 0x0, inc_super) + end + + def protected_instance_methods(inc_super=true) + qt_methods(_protected_instance_methods(inc_super), 0x80, inc_super) + end + + def public_instance_methods(inc_super=true) + qt_methods(_public_instance_methods(inc_super), 0x0, inc_super) + end + + private + def qt_methods(meths, flags, inc_super=true) + if !self.kind_of? Class + return meths + end + + klass = self + classid = 0 + loop do + classid = Qt::Internal::find_pclassid(klass.name) + break if classid > 0 + + klass = klass.superclass + if klass.nil? + return meths + end + end + + # These methods are all defined in Qt::Base, even if they aren't supported by a particular + # subclass, so remove them to avoid confusion + meths -= ["%", "&", "*", "**", "+", "-", "-@", "/", "<", "<<", "<=", ">", ">=", ">>", "|", "~", "^"] + ids = [] + if inc_super + Qt::Internal::getAllParents(classid, ids) + end + ids << classid + ids.each { |c| Qt::Internal::findAllMethodNames(meths, c, flags) } + return meths.uniq + end +end -- cgit v1.2.3