RubyGems - qt_connect - Versions diffs - 1.5.1 - Mend

qt_connect 1.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

data/COPYING.LIB.txt +510 -0
data/README.md +257 -0
data/Rakefile +72 -0
data/examples/classexplorer/classexplorer.rb +828 -0
data/examples/classexplorer/menus.rb +1 -0
data/examples/classexplorer/menus/helpmenu.rb +73 -0
data/examples/classexplorer/packagetree.rb +91 -0
data/examples/classexplorer/qt_extensions.rb +2 -0
data/examples/classexplorer/qt_extensions/htmldelegate.rb +40 -0
data/examples/classexplorer/qt_extensions/line_edit.rb +65 -0
data/examples/deform/Deform.html +23 -0
data/examples/deform/Thumbs.db +0 -0
data/examples/deform/arthurframe.rb +273 -0
data/examples/deform/deform-demo.png +0 -0
data/examples/deform/deform.rb +502 -0
data/examples/deform/qt-logo.png +0 -0
data/examples/qtmapzoom/qtmapzoom.rb +340 -0
data/java/SignalActions.java +13 -0
data/lib/Qt.rb +10 -0
data/lib/qt_connect.rb +12 -0
data/lib/qt_connect/qt_compat.rb +700 -0
data/lib/qt_connect/qt_jbindings.rb +657 -0
data/lib/qt_connect/qt_sugar.rb +277 -0
data/lib/qt_connect/version.rb +3 -0
data/lib/qt_jambi.rb +8 -0
data/lib/signalactions.jar +0 -0
metadata +92 -0

data/examples/deform/qt-logo.png ADDED

Binary file

data/examples/qtmapzoom/qtmapzoom.rb ADDED

@@ -0,0 +1,340 @@
+=begin
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the Graphics Dojo project on Qt Labs.
+**
+** This file may be used under the terms of the GNU General Public
+** License version 2.0 or 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of
+** this file.  Please review the following information to ensure GNU
+** General Public Licensing requirements will be met:
+** http://www.fsf.org/licensing/licenses/info/GPLv2.html and
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** see original article 'Maps with a Magnifying Glass' by Ariya Hidayat
+** (http://labs.trolltech.com/blogs/2009/07/29/maps-with-a-magnifying-glass/)
+**
+** Ruby implementation and minor modifications by Cees Zeelenberg
+** (c.zeelenberg@computer.org)
+=end
+require 'qt_connect'
+MAP_HTML=%Q[
+<html>
+<head>
+<script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=false"></script>
+<script type="text/javascript">
+  var map;
+  function initialize() {
+    var myOptions = {
+      zoom: 15,
+      center: new google.maps.LatLng(51.4772,0.0),
+      disableDefaultUI: true,
+      mapTypeId: google.maps.MapTypeId.ROADMAP
+    }
+    map = new google.maps.Map(document.getElementById("map_canvas"),
+                                  myOptions);
+    var marker = new google.maps.Marker({map: map, position:
+        map.getCenter()});
+    return true;
+  }
+</script>
+</head>
+<body style="margin:0px; padding:0px;">
+    <div id="map_canvas" style="width:100%; height:100%"></div>
+    </body></html>
+</html>
+  ]
+  HOLD_TIME=701
+  MAX_MAGNIFIER=229
+ #
+# the GMaps class should really inherit from Qt:WebView
+# but at the time of writing this caused a problem with 'paintEvent', which could not
+# provide access to the paint device.
+# the disadvantage of this workaround is that keyboard and mouse-events are not passed on
+# to the Google application
+class GMaps < Qt::Widget
+  def initialize(parent)
+    @parent=parent
+    super(parent)
+    @timer=Qt::Timer.new
+    @timer.singleShot=true
+    @timer.timeout.connect{triggerLoading}
+    @pressed=false
+    @snapped=false
+    @zoomed=false
+    @zoomPage=Qt::WebPage.new(self)
+    @zoomPage.repaintRequested.connect{update()}
+    @mainPage=Qt::WebPage.new(self)
+    @mainFrame=@mainPage.mainFrame
+    @mainFrame.setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff)
+    @mainFrame.setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff)
+    content=MAP_HTML
+    @mainFrame.setHtml(content)
+    @zoomFrame=@zoomPage.mainFrame
+    @zoomFrame.setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff)
+    @zoomFrame.setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff)
+    @zoomFrame.loadFinished.connect{ |tf| triggerLoading}
+    content=MAP_HTML.gsub("zoom: 15", "zoom: 16")
+    @zoomFrame.setHtml(content)
+    @pressPos=Qt::Point.new
+    @dragPos=Qt::Point.new
+    @tapTimer=Qt::BasicTimer.new
+    @zoomPixmap=Qt::Pixmap.new
+    @maskPixmap=Qt::Pixmap.new
+    @normalPixmapSize=Qt::Size.new
+  end
+  def setCenter(latitude,longitude)
+    @lat=latitude
+    @lng=longitude
+    @dlat=0.0
+    @dlng=0.0
+    @mousePos=@lastPos
+    @code = "map.setCenter(new google.maps.LatLng(#{latitude}, #{longitude}));"
+    @mainFrame.evaluateJavaScript(@code)
+    @zoomFrame.evaluateJavaScript(@code)
+    code = "map.getBounds().toUrlValue(5)"
+    return unless coors=(@mainFrame.evaluateJavaScript(code)).toString
+    fx1,fy1,fx2,fy2=coors.split(',').map{ |f| f.to_f}
+    @dlat=(fx2-fx1)/size.width
+    @dlng=(fy2-fy1)/size.height
+  end
+  def setMagnifierMode(mode)
+    code=%Q[map.setMapTypeId(google.maps.MapTypeId.#{mode.to_s.upcase});]
+    @zoomFrame.evaluateJavaScript(code)
+  end
+  def setPanelMode(mode)
+    code=%Q[map.setMapTypeId(google.maps.MapTypeId.#{mode.to_s.upcase});]
+    @mainFrame.evaluateJavaScript(code)
+  end
+  def setZoom(zoomfactor)
+    code=%Q[map.setZoom(#{zoomfactor});]
+    @mainFrame.evaluateJavaScript(code)
+    code=%Q[map.setZoom(#{zoomfactor+1});]
+    @zoomFrame.evaluateJavaScript(code)
+  end
+  def triggerLoading()
+    code = "initialize();"
+    xm=@mainFrame.evaluateJavaScript(code).toBool
+    xz=@zoomFrame.evaluateJavaScript(code).toBool
+    Qt::Timer.singleShot(1000,self,:triggerLoading) unless xm && xz
+  end
+  def timerEvent(event)
+    super(event)
+    if (!@zoomed)
+        @zoomed = true
+        @tapTimer.stop()
+        @mainPage.viewportSize=size
+        @zoomPage.viewportSize=self.size*2
+        lat = @mainFrame.evaluateJavaScript("map.getCenter().lat()").toDouble
+        lng = @mainFrame.evaluateJavaScript("map.getCenter().lng()").toDouble
+        setCenter(lat, lng);
+    end
+    update();
+  end
+  def mousePressEvent(event)
+    @pressed = @snapped = true
+    @pressPos = @dragPos = event.pos()
+    @tapTimer.stop()
+    @tapTimer.start(HOLD_TIME, self)
+    super(event)
+  end
+  def mouseReleaseEvent(event)
+    @pressed = @snapped = false
+    @tapTimer.stop()
+    if (!@zoomed)
+      super(event)
+    else
+      @zoomed = false
+      event.accept()
+      update();
+    end
+end
+  def mouseMoveEvent(event)
+    @mousePos ||= event.pos
+    @lastPos=event.pos()
+    if (!@zoomed)
+      if (!@pressed || !@snapped)
+        begin
+        deltamouse=@lastPos-@mousePos
+        newlat=@lat+@dlat*deltamouse.y
+        newlng=@lng-@dlng*deltamouse.x
+        setCenter(newlat,newlng)
+        rescue
+        end
+        return
+      else
+        threshold=40
+        delta = event.pos() - @pressPos
+        if (@snapped)
+          @snapped &= (delta.x() < threshold)
+          @snapped &= (delta.y() < threshold)
+          @snapped &= (delta.x() > -threshold)
+          @snapped &= (delta.y() > -threshold)
+        end
+        (@tapTimer.stop() ; super(event)) if (!@snapped)
+      end
+    else
+      @dragPos = event.pos();
+      update();
+    end
+  end
+    def paintEvent(event)
+      if @normalPixmapSize !=self.size
+        @normalPixmapSize=size
+        @mainPage.viewportSize=size
+        @zoomPage.viewportSize=size * 2
+      end
+      @painter=Qt::Painter.new(self)
+      @painter.renderHint=Qt::Painter::Antialiasing
+      @painter.save
+      @mainFrame.render(@painter,event.region)
+      @painter.restore
+      if @zoomed
+        dim = [width(), height()].min
+        magnifierSize = [MAX_MAGNIFIER, dim * 2 / 3].min
+        radius = magnifierSize / 2
+        ring = radius - 15
+        box = Qt::Size.new(magnifierSize, magnifierSize)
+        if (@maskPixmap.size() != box)
+          @maskPixmap = Qt::Pixmap.new(box) {fill(Qt::Color.new(Qt::transparent))}
+          g=Qt::RadialGradient.new {
+            setCenter(radius, radius)
+            setFocalPoint(radius, radius)
+            setRadius(radius)
+            setColorAt(1.0, Qt::Color.new(255, 255, 255, 0))
+            setColorAt(0.5, Qt::Color.new(128, 128, 128, 255))
+          }
+          Qt::Painter.new(@maskPixmap) { |p|
+            p.setRenderHint(Qt::Painter::Antialiasing)
+            p.setCompositionMode(Qt::Painter::CompositionMode_Source)
+            p.setBrush(Qt::Brush.new(g))
+            p.setPen(Qt::NoPen)
+            p.drawRect(@maskPixmap.rect())
+            p.setBrush(Qt::Brush.new(Qt::Color.new(Qt::transparent)))
+            p.drawEllipse(g.center(), ring, ring)
+            p.end
+          }
+        end
+        center_xy=@dragPos - Qt::Point.new(0,radius/2)
+        ulhc_xy = center_xy - Qt::Point.new(radius, radius)
+        zoom_ulhc_xy = center_xy * 2 - Qt::Point.new(radius, radius)
+        center_xy_f=Qt::PointF.new(center_xy.x.to_f,center_xy.y.to_f)
+        if (@zoomPixmap.size() != box)
+            @zoomPixmap = Qt::Pixmap.new(box) { fill(Qt::Color.new(Qt::lightGray))}
+        end
+        Qt::Painter.new(@zoomPixmap) { |zp|
+          zp.translate(-zoom_ulhc_xy)
+          region=Qt::Region.new(Qt::Rect.new(zoom_ulhc_xy, box))
+          @zoomFrame.render(zp,region)
+          zp.end
+        }
+        @clippath=Qt::PainterPath.new{addEllipse(center_xy_f, ring.to_f, ring.to_f)}
+        @painter.clipPath=@clippath
+        @painter.drawPixmap(ulhc_xy, @zoomPixmap)
+        @painter.clipping=false
+        @painter.drawPixmap(ulhc_xy, @maskPixmap)
+        @painter.pen=Qt::gray
+        @painter.drawPath(@clippath)
+      end
+      @painter.end
+    end
+end
+if $0==__FILE__
+PLACES={ "&Oslo"=>[59.9138204, 10.7387413],
+         "&Berlin"=>[52.5056819, 13.3232027],
+         "&Jakarta"=>[-6.211544, 106.845172],
+         "The &Hague"=>[52.075489,4.309369],
+         "&Geelong"=>[-38.1445,144.3710]
+    }
+MODES=[:hybrid,:roadmap,:satellite,:terrain]
+ZOOMRANGE=(14..17)
+class MapZoom  < Qt::MainWindow
+  def initialize
+    super
+    @map = GMaps.new(self)
+    setCentralWidget(@map)
+    placeMenu = menuBar().addMenu("&Place")
+    placeGroup=Qt::ActionGroup.new(self)
+    PLACES.each{ |city,coordinates|
+      Qt::Action.new(city, self){ |action|
+        action.triggered.connect{@map.setCenter(*coordinates)}
+        action.checkable=true
+        placeMenu.addAction(action)
+      }
+    }
+    settingsMenu = menuBar().addMenu("&Settings")
+    magnifierSubMenu=settingsMenu.addMenu("Magnifier")
+    panelSubMenu=settingsMenu.addMenu("Panel")
+    zoomSubMenu=settingsMenu.addMenu("Zoomfactor")
+    magnifierGroup=Qt::ActionGroup.new(self)
+    MODES.each{ |mode|
+      Qt::Action.new(mode.to_s.capitalize,self){ |action|
+        action.triggered.connect{@map.setMagnifierMode(mode)}
+        action.checkable=true
+        action.checked=true if mode==:roadmap
+        magnifierSubMenu.addAction(action)
+        magnifierGroup.addAction(action)
+      }
+    }
+    panelGroup=Qt::ActionGroup.new(self)
+    MODES.each{ |mode|
+      Qt::Action.new(mode.to_s.capitalize,self){ |action|
+        action.triggered.connect{@map.setPanelMode(mode)}
+        action.checkable=true
+        action.checked=true if mode==:roadmap
+        panelSubMenu.addAction(action)
+        panelGroup.addAction(action)
+      }
+    }
+    zoomGroup=Qt::ActionGroup.new(self)
+    ZOOMRANGE.each{ |zoomfactor|
+      Qt::Action.new(zoomfactor.to_s,self){ |action|
+        action.triggered.connect{@map.setZoom(zoomfactor)}
+        action.checkable=true
+        action.checked=true if zoomfactor==15
+        zoomSubMenu.addAction(action)
+        zoomGroup.addAction(action)
+      }
+    }
+  end
+end
+    a = Qt::Application.new(ARGV)
+    w = MapZoom.new
+    w.setWindowTitle("Maps (powered by Google)")
+    w.resize(600,450)
+    w.show()
+    a.exec
+end

data/java/SignalActions.java ADDED

@@ -0,0 +1,13 @@
+public interface SignalActions {
+  void signal0();
+  void signal1(Object a1);
+  void signal2(Object a1,Object a2);
+  void signal3(Object a1,Object a2,Object a3);
+  void signal4(Object a1,Object a2,Object a3,Object a4);
+  void signal5(Object a1,Object a2,Object a3,Object a4,Object a5);
+  void signal6(Object a1,Object a2,Object a3,Object a4,Object a5,Object a6);
+  void signal7(Object a1,Object a2,Object a3,Object a4,Object a5,Object a6,Object a7);
+  void signal8(Object a1,Object a2,Object a3,Object a4,Object a5,Object a6,Object a7,Object a8);
+  void signal9(Object a1,Object a2,Object a3,Object a4,Object a5,Object a6,Object a7,Object a8,Object a9);
+}

data/lib/Qt.rb ADDED

@@ -0,0 +1,10 @@
+if RUBY_PLATFORM =~ /java/
+  require 'qt_connect'
+else
+  begin
+    require 'Qt4'
+  rescue LoadError
+    raise "qt_connect for Ruby requires the qtbindings gem installed "
+  end
+  require 'qt_connect'
+end

data/lib/qt_connect.rb ADDED

@@ -0,0 +1,12 @@
+if RUBY_PLATFORM =~ /java/
+  require 'java'
+  require 'signalactions.jar'
+  require 'qt_connect/qt_jbindings'
+  require 'qt_connect/qt_compat'
+else
+  require 'Qt'
+  require 'qtwebkit'
+  require 'qt_connect/qt_sugar'
+end

data/lib/qt_connect/qt_compat.rb ADDED

@@ -0,0 +1,700 @@
+=begin
+    Author:     Cees Zeelenberg (c.zeelenberg@computer.org)
+    Copyright:  (c) 2010-2012 by Cees Zeelenberg
+    License:    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.                       *
+    This software extends the basic qt_jbindings API with functionality to
+    improve compatibility with the existing QtRuby API:
+    - same shorthand notations for Enums
+    - patches to classes where the API is slightly different to support
+      both interfaces (ongoing work)
+    - support for the QtRuby signals/slot interface in addition
+      to the QtJambi signals interface
+    - implementations of Qt::Variant and Qt::ModelIndex to allow single source
+      maintenance for QtRuby and QtJRuby
+=end
+module Qt
+module Internal
+  # for all constants which inherit from the Enum class or are  "public static final int" fields
+  # define a shorthand notation to be compatible with the Ruby version of qtbindings
+  # e.g. Qt::PenStyle::SolidLine can be abbreviated to Qt::SolidLine
+  #suppress clashing or otherwise undesirable shorthands with an entry in the DONT_ABBREVIATE hash.
+    DONT_ABBREVIATE= {
+        'Qt::WindowType::Widget' => true,
+        'Qt::WindowType::Dialog' => true,
+        'Qt::WindowType::ToolTip' => true,
+        'Qt::WindowType::SplashScreen' => true,
+        'Qt::Style::PixelMetric::CustomEnum' => true,
+        'Qt::Style::PrimitiveElement::CustomEnum' => true,
+        'Qt::Style::ContentsType::CustomEnum' => true,
+        'Qt::Style::ComplexControl::CustomEnum' => true,
+        'Qt::Style::SubElement::CustomEnum' => true,
+        'Qt::Style::ControlElement::CustomEnum' => true,
+        'Qt::Style::StandardPixmap::CustomEnum' => true,
+      }
+  end
+  # 'create_constants' is called whenever new Module or Class is activated
+  #qtclass    Java::ComTrollTechQtGui::QDockWidget (Class)
+  #qtname     Qt::Dockwidget (String)
+  def self.create_constants(qtclass,qtname)
+    qtclass.class_eval{
+      constants.dup.each{ |c|
+        embedded_class=eval("#{qtclass.name}::#{c}")
+        next unless embedded_class.respond_to?(:java_class)
+        ancestors=(embedded_class.respond_to?(:ancestors)) ? embedded_class.ancestors : []
+        if ancestors.include? java.lang.Enum
+          embedded_class.values.to_ary.each{ |s|
+            symbol=s.toString
+            next if Qt::Internal::DONT_ABBREVIATE["#{qtname}::#{c}::#{symbol}"]
+            next if symbol=~/\A[^A-Z].*\Z/
+            next if const_defined?(symbol)
+            qtclass.class_eval("#{symbol}=#{qtclass.name}::#{c}::#{symbol}") rescue next
+          }
+        else
+          #could be class with public static final int field(s)
+          fields=embedded_class.java_class.fields rescue next
+          fields.each{ |field|
+            next unless field.static? && field.final? && field.public? && (field.value_type=="int")
+            symbol=field.name
+            value=Java.java_to_ruby(field.static_value)
+            qtclass.class_eval("#{symbol}=#{value}") rescue next
+          }
+        end
+      }
+    }
+  end
+  create_constants(self,'Qt')
+  #compat QtRuby4 (fails for WindowType)
+  WidgetType=WindowType::Widget
+  #WindowType=WindowType::Window
+  DialogType=WindowType::Dialog
+  SheetType=WindowType::Sheet
+  DrawerType=WindowType::Drawer
+  PopupType=WindowType::Popup
+  ToolType=WindowType::Tool
+  ToolTipType=WindowType::ToolTip
+  SplashScreenType=WindowType::SplashScreen
+  DesktopType=WindowType::Desktop
+ SubWindowType=WindowType::SubWindow
+  #deal with Qt::blue etc.
+  def Qt.method_missing(method,*args)
+    return Color.send(method) if Color.respond_to?(method)
+    return Color.new(*args).rgba if method==:qRgba
+    super(*args)
+  end
+  class MetaObject < QtJambi::QObject
+    def self.connectSlotsByName(arg)
+      arg.connectSlotsByName()
+    end
+  end
+  #mutable boolean for compatibility compatibility with qtruby
+  #
+  class Boolean
+    attr_accessor :value
+    def initialize(b=false) @value = b end
+    def nil?
+      return !@value
+    end
+  end
+  class ModelIndex
+    class <<self
+      def new
+        return nil
+      end
+    end
+  end
+  #
+  #following are patches to QtJambi classes, mostly for compatibility with qtruby
+  #Corresponding Procs are 'class_eval-ed' when a Qt class is activated
+  #see companion code: qt_jbindings  Qt#const_missing
+  # 'signature' calls are for documentation only (e.g. classexplorer.rb) and have
+  # no effect on the functionality
+  module Internal
+    signature "void Qt::AbstractSlider.range=(Range)"
+    AbstractSlider=Proc.new do
+          def range=(arg)
+            if arg.kind_of? Range
+              return setRange(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+            else
+              return setRange(arg)
+            end
+          end
+    end
+    #QtRuby uses: Qt::AbstractTextDocumentLayout::PaintContext.new
+    #QtJambi : Qt::AbstractTextDocumentLayout_PaintContext
+    AbstractTextDocumentLayout=Proc.new do
+          self.const_set('PaintContext',Qt::AbstractTextDocumentLayout_PaintContext)
+    end
+    #example\dialogs\simplewizard
+    signature "Qt::ByteArray Qt::ByteArray.+(Object)"
+    ByteArray=Proc.new do
+      def +(o)
+        self.clone.append(o)
+      end
+    end
+    signature "static Qt::DataStream Qt::DataStream.new"
+    signature "static Qt::DataStream Qt::DataStream.new(Qt::IODevice)"
+    signature "static Qt::DataStream Qt::DataStream.new(Qt::ByteArray)"
+    signature "static Qt::DataStream Qt::DataStream.new(Qt::ByteArray, Qt::IODevice::OpenMode)"
+    signature "static Qt::DataStream Qt::DataStream.new(Qt::ByteArray, int openmode)"
+    signature "static Qt::DataStream Qt::DataStream.new(Qt::ByteArray, Qt::IODevice::OpenModeFlag[])"
+    signature "void Qt::DataStream.setVersion(Enum)"
+    signature "Qt::DataStream Qt::DataStream.<<(Object)"
+    signature "Qt::DataStream Qt::DataStream.>>(Object)"
+        DataStream=Proc.new do
+          class << self
+            alias :orig_new :new
+            def new(*a,&block)
+              args=a.dup
+              args[1]=Qt::IODevice::OpenMode.new(args[1]) if (args.size>1) && args[1].kind_of?(Fixnum)
+              return orig_new(*args,&block)
+            end
+          end
+          alias orig_setVersion setVersion
+          def setVersion(a)
+            orig_setVersion(a.respond_to?(:value) ? a.value : a)
+          end
+          alias set_version setVersion
+          alias version= setVersion
+          def <<(arg)
+            case arg
+              when String ; writeString(arg)
+              when Float,Java::Float ; writeFloat(arg)
+              when Fixnum,Java::Int ; writeInt(arg)
+              when Java::Double ; writeDouble(arg)
+              when Java::ComTrolltechQtGui::QPixmap,
+                    Java::ComTrolltechQtGui::QImage,
+                    Java::ComTrolltechQtCore::QPointF,
+                    Java::ComTrolltechQtCore::QPoint,
+                    Java::ComTrolltechQtCore::QRect,
+                    Java::ComTrolltechQtCore::QRectF,
+                    Java::ComTrolltechQtGui::QRegion,
+                    Java::ComTrolltechQtCore::QSize,
+                    Java::ComTrolltechQtCore::QSizeF
+                  arg.writeTo(self)
+              else
+                raise "Qt::Datastream: no '<<' for #{arg.class}"
+            end
+            self # allows concatenation
+          end
+          def >>(arg)
+            case arg
+              when String ; arg=readString
+              when Float ; arg=readFloat
+              when Fixnum ; arg=readInt
+              when Java::ComTrolltechQtGui::QPixmap,
+                    Java::ComTrolltechQtGui::QImage,
+                    Java::ComTrolltechQtCore::QPointF,
+                    Java::ComTrolltechQtCore::QPoint,
+                    Java::ComTrolltechQtCore::QRect,
+                    Java::ComTrolltechQtCore::QRectF,
+                    Java::ComTrolltechQtGui::QRegion,
+                    Java::ComTrolltechQtCore::QSize,
+                    Java::ComTrolltechQtCore::QSizeF
+              arg.readFrom(self)
+            else
+              raise "Qt::Datastream: no '>>' for #{arg.class}"
+            end
+            self
+          end
+        end
+    signature "void Qt::DoubleSpinBox.range=(Range)"
+        DoubleSpinBox=Proc.new do
+          def range=(arg)
+            if arg.kind_of? Range
+              return setRange(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+            else
+              return setRange(arg)
+            end
+          end
+        end
+    #examples\draganddrop\draggabletext
+    signature "Qt::DropAction Qt::Drag.start"
+    signature "Qt::DropAction Qt::Drag.start(Fixnum dropactions)"
+    signature "Qt::DropAction Qt::Drag.start(Qt::DropAction[])"
+    signature "Qt::DropAction Qt::Drag.start(Qt::DropActions)"
+    signature "Qt::DropAction Qt::Drag.start(Qt::DropActions,Qt::DropAction)"
+        Drag=Proc.new do
+          alias orig_exec exec
+            def exec(*a)
+              args=a.dup
+              args[0]=Qt::DropActions.new(args[0]) if args[0].kind_of? Fixnum
+              orig_exec(*args)
+            end
+            alias :start :exec
+        end
+    #example\dialogs\findfile
+    signature "boolean Qt::File.open(Fixnum openmode)"
+    File=Proc.new do
+      alias orig_open open
+      def open(a)
+        arg=(a.kind_of?(Fixnum)) ? Qt::IODevice::OpenMode.new(a) : a
+        orig_open(arg)
+      end
+    end
+    signature "static java.lang.String Qt::FileDialog.getSaveFileName(Qt::Widget,String,String,String filter)"
+    signature "static java.lang.String Qt::FileDialog.getOpenFileName(Qt::Widget,String,String,String filter)"
+    signature "static java.util.List Qt::FileDialog.getOpenFileNames(Qt::Widget,String,String,String filter)"
+        FileDialog=Proc.new do
+          class << self
+          #getSaveFileName
+            alias orig_getSaveFileName getSaveFileName
+            def getSaveFileName(*a)
+              args=a.dup
+              args[3]=self::Filter.new(args[3]) if args.size==4 && (args[3].kind_of?(String))
+              orig_getSaveFileName(*args)
+            end
+            alias get_save_file_name getSaveFileName
+          #getOpenFilename
+            alias orig_getOpenFileName getOpenFileName
+            def getOpenFileName(*a)
+              args=a.dup
+              args[3]=self::Filter.new(args[3]) if args.size==4 && (args[3].kind_of?(String))
+              orig_getOpenFileName(*args)
+            end
+            alias get_open_file_name getOpenFileName
+          #getOpenFilenames
+            alias orig_getOpenFileNames getOpenFileNames
+            def getOpenFileNames(*a)
+              args=a.dup
+              args[3]=self::Filter.new(args[3]) if args.size==4 && (args[3].kind_of?(String))
+              orig_getOpenFileNames(*args)
+            end
+            alias get_open_file_names getOpenFileNames
+          end
+        end
+    #examples\dialogs\standarddialogs
+    signature "static Qt::Font Qt:FontDialog.getFont(Qt::Boolean ok)"
+    signature "static Qt::Font Qt:FontDialog.getFont(Qt::Boolean ok,Qt::Font)"
+    signature "static Qt::Font Qt:FontDialog.getFont(Qt::Boolean ok,Qt::Font,Qt::Widget,String)"
+    signature "static Qt::Font Qt:FontDialog.getFont(Qt::Boolean ok,Qt::Widget)"
+    signature "static Qt::Font Qt:FontDialog.getFont(Qt::Boolean ok,Qt::Font,Qt::Widget)"
+    signature "static Qt::Font Qt:FontDialog.getFont(Qt::Boolean ok,Qt::Font,Qt::Widget,String,Qt::FontDialog::FontDialogOptions)"
+        FontDialog=Proc.new do
+          class << self
+            alias orig_getFont getFont
+            def getFont(*a)
+              args=a.dup
+              if args[0].kind_of? Qt::Boolean
+                ok=args.shift
+                result=orig_getFont(*args)
+                ok.value=result.ok
+                result.font
+              else
+                orig_getFont(*args)
+              end
+            end
+            alias get_font getFont
+          end
+        end
+#examples\draganddrop\fridgemagnets
+    signature "Qt::Size Qt::FontMetrics.size(Enum,String)"
+    FontMetrics=Proc.new do
+      alias :orig_size :size
+          def size(*a)
+            args=a.dup
+            args[0]=args[0].value if args[0].respond_to?(:value)
+            orig_size(*args)
+          end
+      end
+    signature "static java.lang.String Qt::InputDialog.getItem(Qt::Widget parent,String title,String label,java.util.List,int current,bool editable,Qt::Boolean ok)"
+    signature "static java.lang.String Qt::InputDialog.getText(Qt::Widget parent,String title,String label,Qt::LineEdit::EchoMode mode,String text,Qt::Boolean ok)"
+    signature "static java.lang.String Qt::InputDialog.getInteger(Qt::Widget parent,String title,String label,int value,int minvalue,int maxvalue,int decimals,Qt::Boolean ok)"
+    signature "static java.lang.String Qt::InputDialog.getInt(Qt::Widget parent,String title,String label,int value,int minvalue,int maxvalue,int decimals,Qt::Boolean ok)"
+    signature "static java.lang.String Qt::InputDialog.getDouble(Qt::Widget parent,String title,String label,Float value,Float minvalue,Float maxvalue,int decimals,Qt::Boolean ok)"
+    InputDialog=Proc.new do
+      class << self
+    #getInt
+    #getInteger
+        alias orig_getInt getInt
+        def getInt(*a)
+          args=a.dup
+          if args[-1].kind_of? Qt::Boolean
+            ok=args.pop
+            result=orig_getInt(*args)
+            ok.value=(result.nil?) ? false : true
+            result
+          else
+            orig_getInt(*args)
+          end
+        end
+        alias get_int getInt
+        alias getInteger getInt
+        alias get_integer getInt
+    #getDouble
+        alias orig_getDouble getDouble
+        def getDouble(*a)
+          args=a.dup
+          if args[-1].kind_of? Qt::Boolean
+            ok=args.pop
+            result=orig_getDouble(*args)
+            ok.value=(result.nil?) ? false : true
+            result
+          else
+            orig_getDouble(*args)
+          end
+        end
+        alias get_double getDouble
+    #getItem
+        alias :orig_getItem :getItem
+        def getItem(*a)
+          args=a.dup
+          if args[-1].kind_of? Qt::Boolean
+            ok=args.pop
+            result=orig_getItem(*args)
+            ok.value=(result.nil?) ? false : true
+            result
+          else
+            orig_getItem(*args)
+          end
+        end
+        alias get_item getItem
+    #getText
+        alias :orig_getText :getText
+        def getText(*a)
+          args=a.dup
+          if args[-1].kind_of? Qt::Boolean
+            ok=args.pop
+            result=orig_getText(*args)
+            ok.value=(result.nil?) ? false : true
+            result
+          else
+            orig_getText(*args)
+          end
+        end
+        alias :get_text :getText
+      end
+    end
+    signature "void Qt::Label.setAlignment(Fixnum)"
+    Label=Proc.new do
+            alias :orig_setAlignment :setAlignment
+            def setAlignment(a)
+              a=Qt::Alignment.new(a) if a.kind_of?(Fixnum)
+              orig_setAlignment(a)
+            end
+            alias :'alignment=' :setAlignment
+    end
+    #examples\layout\borderlayout
+    signature "int Qt::Layout.spacing"
+    signature "void Qt::Layout.setSpacing(int)"
+        Layout=Proc.new do
+          alias :spacing :widgetSpacing
+          alias :setSpacing :setWidgetSpacing
+          alias :set_spacing :setWidgetSpacing
+        end
+    signature "void Qt::ListWidgetItem.setTextAlignment(Qt::AlignmentFlag)"
+    signature "void Qt::ListWidgetItem.setFlags(int)"
+    ListWidgetItem=Proc.new do
+            alias :orig_setTextAlignment :setTextAlignment
+            def setTextAlignment(a)
+              arg=(a.respond_to?(:value)) ? a.value : a
+              orig_setTextAlignment(arg)
+            end
+            alias textAlignment= setTextAlignment
+            #examples\draganddrop\puzzle
+            alias :orig_setFlags :setFlags
+            def setFlags(a)
+              arg=(a.kind_of? Fixnum) ? Qt::ItemFlags.new(a) : a
+              orig_setFlags(arg)
+            end
+            alias :set_flags :setFlags
+    end
+    #examples\dialogs\standarddialogs
+    signature "static Qt::MessageBox::StandardButton Qt::MessageBox.critical(Qt::Widget,String,String"+
+                ",Qt::MessageBox::StandardButton,Qt::MessageBox::StandardButton,Qt::MessageBox::StandardButton)"
+    signature "static Qt::MessageBox::StandardButton Qt::MessageBox.question(Qt::Widget,String,String"+
+                ",Qt::MessageBox::StandardButton,Qt::MessageBox::StandardButton,Qt::MessageBox::StandardButton)"
+        MessageBox=Proc.new do
+          class<<self
+            alias orig_critical critical
+            def critical(*a)
+              args=a.dup
+              (a.size-4).times{ x=args.pop ; args[-1] |= x}
+              orig_critical(*args)
+            end
+            alias orig_question question
+            def question(*a)
+              args=a.dup
+              (a.size-4).times{ x=args.pop ; args[-1] |= x}
+              orig_question(*args)
+            end
+          end
+        end
+    signature "void Qt::Painter.drawText(Qt::Rect,Qt::Alignment,String)"
+        Painter=Proc.new do
+          alias orig_drawText drawText
+          def drawText(*a)
+            args=a.dup
+            args[1]=args[1].value if (args[1].respond_to?(:value))
+            orig_drawText(*args)
+          end
+          alias draw_text drawText
+        end
+    #examples\draganddrop\dragabletext
+        Palette=Proc.new do
+          #Background=ColorRole::Window (Background is Obsolete)
+          const_set('Background',const_get(:ColorRole).const_get(:Window))
+        end
+    signature "void Qt::ProgressDialog.range=(Range)"
+        ProgressDialog=Proc.new do
+              def range=(arg)
+                if arg.kind_of? Range
+                  return setRange(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+                else
+                  return setRange(arg)
+                end
+              end
+        end
+    SignalMapper=Proc.new do
+      def mapped
+        return mappedQObject
+      end
+    end
+    signature "static Qt::SizePolicy Qt::SizePolicy.new"
+    signature "static Qt::SizePolicy Qt::SizePolicy.new(Qt::SizePolicy::Policy,Qt::SizePolicy::Policy,Qt::SizePolicy::ControlType)"
+    signature "static Qt::SizePolicy Qt::SizePolicy.new(Qt::SizePolicy::Policy,Qt::SizePolicy::Policy)"
+    signature "static Qt::SizePolicy Qt::SizePolicy.new(int,int,int)"
+    signature "static Qt::SizePolicy Qt::SizePolicy.new(int,int)"
+        SizePolicy=Proc.new do
+          class << self
+            alias :orig_new :new
+            def new(*args,&block)
+              args=args.map{ |arg| arg.kind_of?(Fixnum) ? Qt::SizePolicy::Policy.resolve(arg) : arg}
+              return orig_new(*args,&block)
+            end
+          end
+        end
+    signature "void Qt::SpinBox.range=(Range)"
+        SpinBox=Proc.new do
+          def range=(arg)
+            if arg.kind_of? Range
+              return setRange(arg.begin, arg.exclude_end?  ? arg.end - 1 : arg.end)
+            else
+              return setRange(arg)
+            end
+          end
+        end
+    #examples\dialogs\findfiles
+    signature "void Qt::TableWidgetItem.setFlags(Fixnum flags)"
+    signature "void Qt::TableWidgetItem.setTextAlignment(Qt::AlignmentFlag)"
+        TableWidgetItem=Proc.new do
+          alias orig_setTextAlignment setTextAlignment
+          def setTextAlignment(a)
+            arg=(a.respond_to?(:value)) ? a.value : a
+            orig_setTextAlignment(arg)
+          end
+          alias textAlignment= setTextAlignment
+          alias set_text_alignment setTextAlignment
+          alias orig_setFlags setFlags
+          def setFlags(*a)
+            args=a.dup
+            args[0]=Qt::ItemFlags.new(args[0]) if args[0].kind_of? Fixnum
+            orig_setFlags(*args)
+          end
+          alias set_flags setFlags
+          alias flags= setFlags
+        end
+    signature "void Qt::TextCharFormat.setFontWeight(Qt::Enumerator)"
+        TextCharFormat=Proc.new do
+          alias :orig_fw :setFontWeight
+          def setFontWeight(val)
+            orig_fw( (val.respond_to? :value) ? val.value : val)
+          end
+          alias :set_font_weight :setFontWeight
+          alias :'fontWeight=' :setFontWeight
+        end
+    #require 'jruby/core_ext'
+    signature "void Qt::TextStream.<<(String)"
+    signature "void Qt::TextStream.>>(String)"
+        TextStream=Proc.new do
+              def <<(a)
+                self.writeString(a)
+              end
+              def >>(a)
+                a.replace(readString)
+              end
+        end
+    signature "static Object Qt::Variant.new(Object)"
+    signature "static Object Qt::Variant.fromValue(Object)"
+      Variant=Proc.new do
+          class << self
+            def new(obj=nil)
+              return obj
+            end
+            alias fromValue new
+            alias from_value new
+          end
+      end
+  end #Internal
+AlignTrailing=AlignRight
+AlignLeading=AlignLeft
+end #QT
+Qt::Internal::signature "void Qt::Object.connect(Qt::Object,Symbol,Qt::Object,Symbol)"
+Qt::Internal::signature "void Qt::Object.connect(Qt::Object,Symbol,Qt::Object,String)"
+Qt::Internal::signature "void Qt::Object.disconnect(Qt::Object,Symbol,Qt::Object,Symbol)"
+Qt::Internal::signature "void Qt::Object.disconnect(Qt::Object,Symbol,Qt::Object,String)"
+Qt::Internal::signature "int Qt::Object.qRgba(int,int,int,int)"
+Qt::Internal::signature "static java.lang.String Qt::Object.tr(String)"
+Qt::Internal::signature "Qt::SignalEmitter Qt::Object.sender"
+Java::ComTrolltechQtCore::QObject.class_eval{
+#connect(producer,SIGNAL('sig1'),consumer,SLOT('sig2'))
+#connect(producer,SIGNAL('sig1'),consumer,SIGNAL('sig2')
+#SIGNAL generates :sig1 (Symbol, only name of signal)
+#SLOT generates 'sig1(a,b)' (String, full signature)
+  def connect(producer,sig1,consumer,sig2,type=0)
+    #see if Signal is of type QSignalEmitter  or of type Qt::Signal
+    signal1=producer.java_class.field(sig1).value(producer) rescue signal1=producer.send(sig1)
+    #puts "connect #{signal1}(#{signal1.class}) => #{sig2}(#{sig2.class}) #{caller[0]}"
+    if sig2.kind_of?(String)
+      if md=sig2.match(/([^(]+)\([.]*/)
+        n=0 ; sig2.gsub(/ (\([^,)]+)|(,[^,)]+) | (,[^,)]+)  /x){n+=1}
+        sig2=(n.to_s+md[1].strip)
+      end
+      #puts "signal->slot #{signal1}.connect(#{consumer},#{sig2.to_sym} #{caller[0]})"
+      return signal1.connect(consumer,sig2.to_sym)
+    end
+    signal2=consumer.java_class.field(sig2).value(consumer) rescue signal2=consumer.send(sig2)
+    #puts "signal->signal #{signal1}.connect(#{signal2}) #{caller[0]}"
+    return signal1.connect(signal2)
+  end
+  def disconnect(producer,sig1,consumer,sig2)
+    if sig2.kind_of?(String) && (md=sig2.match(/([^(]+)\([.]*/))
+        n=0 ; sig2.gsub(/ (\([^,)]+)|(,[^,)]+) | (,[^,)]+)  /x){n+=1}
+        sig2=(n.to_s+md[1].strip).to_sym
+    end
+    sig2=sig2.to_sym
+    producer.java_class.field(sig1).value(producer).disconnect(consumer,sig2) rescue producer.send(sig1).disconnect(consumer,sig2)
+  end
+  def sender
+    #signalSender ia a static method of QSignalEmitter => Ruby Class Method
+    return QtJambi::QSignalEmitter.signalSender()
+  end
+  #'doc_was_epibrated(a1,a2)' => :'2doc_was_epibrated'
+  #'doc_was_cooked()' => :'0doc_was_cooked'
+  def SLOT(signature)
+    return signature if signature.kind_of? String
+    s=signature.to_s
+    return s if s.match(/([^(]+)\([.]*/)
+    return s+'()'
+  end
+  def SIGNAL(signature)
+    if signature.kind_of? Symbol
+      return signature
+    else
+      if md=signature.match(/([^(]+)\([.]*/)
+        return md[1].strip.to_sym
+      end
+      return signature.to_sym
+    end
+  end
+  def self.slots(*signallist) ; end
+  #emit signal(a1,a2..)
+  def emit(signal)
+    signal.emit
+  end
+  def qRgba(*args)
+    return Color.new(*args).rgba
+  end
+  def self.tr(s)
+    return self.new.tr(s)
+  end
+}
+#try using Qt.Variant type conversions if all else fails
+class Object
+  def method_missing(m,*args,&block)
+    #puts "missing #{m} for #{self.class}  #{caller[0].split('/')[-1]}"
+    method=((m==:toBool) || (m==:to_bool)) ? :toBoolean : m
+    return Qt::Variant.send(method,self) if com.trolltech.qt.QVariant.respond_to? method
+    return super
+  end
+end
+class Class
+  RX0=/([^(]+)\([.]*/                      #name(.....
+  RX1=/\A[A-Z]+\z/                         #1+ alpha => alt_m==m
+  RX2=/([A-Z]+)([A-Z][a-z])/
+  RX3=/([a-z\d])([A-Z])/
+  def signals(*signallist)
+      signallist.each{ |signature|
+        if signature.kind_of? String
+          if md=signature.match(RX0)
+            m=md[1].strip
+          else
+            m=signature.strip
+          end
+        else
+          m=signature.to_s
+        end
+        alt_m =(m=~RX1) ? m.downcase : m.gsub(RX2, '\1_\2').gsub(RX3, '\1_\2').tr("-","_").downcase
+        self.class_eval(%Q[
+          def #{m}(*args)
+            if @_#{m}
+              @_#{m}.setargs(*args)
+              return @_#{m}
+            else
+              return @_#{m}=Qt::Signal.new(self)
+            end
+          end
+          #{(alt_m==m) ? '' : "alias :#{alt_m} :#{m}"}
+        ])
+      }
+  end
+end
+class NilClass
+  def valid?
+    return false
+  end
+end