qtbindings 4.6.3.0-x86-mingw32

data/ext/ruby/qtruby/examples/graphicsview/collidingmice/makefile

@@ -0,0 +1,2 @@
+qrc_mice.rb: mice.qrc
+	rbrcc -name mice mice.qrc -o qrc_mice.rb

data/ext/ruby/qtruby/examples/graphicsview/collidingmice/mice.qrc

@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/" >
+        <file>images/cheese.jpg</file>
+    </qresource>
+</RCC>

data/ext/ruby/qtruby/examples/graphicsview/collidingmice/mouse.rb

@@ -0,0 +1,176 @@
+=begin
+**
+** Copyright (C) 2004-2005 Trolltech AS. All rights reserved.
+**
+** This file is part of the example classes of the Qt Toolkit.
+**
+** This file may be used under the terms of the GNU General Public
+** License version 2.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.trolltech.com/products/qt/opensource.html
+**
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://www.trolltech.com/products/qt/licensing.html or contact the
+** sales department at sales@trolltech.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.
+**
+
+** Translated to QtRuby by Richard Dale
+=end
+
+
+# In the original C++ example the Mouse class inherited from both
+# QObject and QGraphicsItem. As that isn't possible in Ruby, use
+# a helper class 'MouseTimer' to periodically invoke the 
+# Mouse.timerEvent() method.
+class MouseTimer < Qt::Object
+    def initialize(mouse)
+        super(nil)
+        @mouse = mouse
+    end
+
+    def timerEvent(event)
+        @mouse.timerEvent(event)
+    end
+end
+
+class Mouse < Qt::GraphicsItem
+    TwoPi = 2.0 * Math::PI
+    
+    def self.normalizeAngle(angle)
+        while angle < 0 do
+            angle += TwoPi
+        end
+        while angle > TwoPi do
+            angle -= TwoPi
+        end
+        return angle
+    end
+    
+    def initialize()
+        super(nil)
+        @angle = 0.0
+        @speed = 0.0
+        @mouseEyeDirection = 0.0
+        @color = Qt::Color.new(rand(256), rand(256), rand(256))
+        rotate(rand(360 * 16))
+        adjust = 0.5
+        @boundingRect = Qt::RectF.new(-20 - adjust, -22 - adjust,
+                      40 + adjust, 83 + adjust)
+        @timer = MouseTimer.new(self)
+        @timer.startTimer(1000 / 33)
+    end
+    
+    def boundingRect
+        return @boundingRect
+    end
+    
+    def shape
+        path = Qt::PainterPath.new
+        path.addRect(-10, -20, 20, 40)
+        return path
+    end
+    
+    def paint(painter, arg, widget)
+        # Body
+        painter.brush = Qt::Brush.new(@color)
+        painter.drawEllipse(-10, -20, 20, 40)
+    
+        # Eyes
+        painter.brush = Qt::Brush.new(Qt::white)
+        painter.drawEllipse(-10, -17, 8, 8)
+        painter.drawEllipse(2, -17, 8, 8)
+    
+        # Nose
+        painter.brush = Qt::Brush.new(Qt::black)
+        painter.drawEllipse(Qt::RectF.new(-2, -22, 4, 4))
+    
+        # Pupils
+        painter.drawEllipse(Qt::RectF.new(-8.0 + @mouseEyeDirection, -17, 4, 4))
+        painter.drawEllipse(Qt::RectF.new(4.0 + @mouseEyeDirection, -17, 4, 4))
+    
+        # Ears
+        painter.brush = Qt::Brush.new(scene.collidingItems(self).empty? ? Qt::darkYellow : Qt::red)
+        painter.drawEllipse(-17, -12, 16, 16)
+        painter.drawEllipse(1, -12, 16, 16)
+    
+        # Tail
+        path = Qt::PainterPath.new(Qt::PointF.new(0, 20))
+        path.cubicTo(-5, 22, -5, 22, 0, 25)
+        path.cubicTo(5, 27, 5, 32, 0, 30)
+        path.cubicTo(-5, 32, -5, 42, 0, 35)
+        painter.brush = Qt::NoBrush
+        painter.drawPath(path)
+    end
+    
+    def timerEvent(event)
+        # Don't move too far away
+        lineToCenter = Qt::LineF.new(Qt::PointF.new(0, 0), mapFromScene(0, 0))
+        if lineToCenter.length() > 150
+            angleToCenter = Math.acos(lineToCenter.dx / lineToCenter.length)
+            if lineToCenter.dy < 0
+                angleToCenter = TwoPi - angleToCenter
+            end
+            angleToCenter = Mouse.normalizeAngle((Math::PI - angleToCenter) + Math::PI / 2)
+    
+            if angleToCenter < Math::PI && angleToCenter > Math::PI / 4
+                # Rotate left
+                @angle += (@angle < -Math::PI / 2) ? 0.25 : -0.25
+            elsif angleToCenter >= Math::PI && angleToCenter < (Math::PI + Math::PI / 2 + Math::PI / 4)
+                # Rotate right
+                @angle += (@angle < Math::PI / 2) ? 0.25 : -0.25
+            end
+        elsif Math.sin(@angle) < 0
+            @angle += 0.25
+        elsif Math.sin(@angle) > 0
+            @angle -= 0.25
+        end
+    
+        # Try not to crash with any other mice
+        dangerMice = scene.items(Qt::PolygonF.new([mapToScene(0, 0),
+                                   mapToScene(-30, -50),
+                                   mapToScene(30, -50)]))
+        dangerMice.each do |item|
+            if item == self
+                next
+            end
+            
+            lineToMouse = Qt::LineF.new(Qt::PointF.new(0, 0), mapFromItem(item, 0, 0))
+            angleToMouse = Math.acos(lineToMouse.dx / lineToMouse.length)
+            if lineToMouse.dy < 0
+                angleToMouse = TwoPi - angleToMouse
+            end
+            angleToMouse = Mouse.normalizeAngle((Math::PI - angleToMouse) + Math::PI / 2)
+    
+            if angleToMouse >= 0 && angleToMouse < Math::PI / 2
+                # Rotate right
+                @angle += 0.5
+            elsif angleToMouse <= TwoPi && angleToMouse > (TwoPi - Math::PI / 2)
+                # Rotate left
+                @angle -= 0.5
+            end
+        end
+    
+        # Add some random movement
+        if dangerMice.size > 1 && rand(10) == 0
+            if rand(1) == 1
+                @angle += rand(100) / 500.0
+            else
+                @angle -= rand(100) / 500.0
+            end
+        end
+    
+        @speed += (-50 + rand(100)) / 100.0
+    
+        dx = Math.sin(@angle) * 10
+        @mouseEyeDirection = ((dx / 5).abs < 1) ? 0 : dx / 5
+    
+        rotate(dx)
+        setPos(mapToParent(0, -(3 + Math.sin(@speed) * 3)))
+    end
+end

data/ext/ruby/qtruby/examples/graphicsview/dragdroprobot/coloritem.rb

@@ -0,0 +1,86 @@
+=begin
+**
+** Copyright (C) 2004-2005 Trolltech AS. All rights reserved.
+**
+** This file is part of the example classes of the Qt Toolkit.
+**
+** This file may be used under the terms of the GNU General Public
+** License version 2.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.trolltech.com/products/qt/opensource.html
+**
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://www.trolltech.com/products/qt/licensing.html or contact the
+** sales department at sales@trolltech.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.
+**
+
+** Translated to QtRuby by Richard Dale
+=end
+    
+class ColorItem < Qt::GraphicsItem
+    @@n = 0
+
+    def initialize
+        super
+        @color = Qt::Color.new(rand(256), rand(256), rand(256))
+        setToolTip("Qt::Color(%d, %d, %d)\n%s" %
+               [@color.red, @color.green, @color.blue,
+               "Click and drag this color onto the robot!"])
+        setCursor(Qt::Cursor.new(Qt::OpenHandCursor))
+    end
+    
+    def boundingRect
+        return Qt::RectF.new(-15.5, -15.5, 34, 34)
+    end
+    
+    def paint(painter, option, widget)
+        painter.pen = Qt::NoPen
+        painter.brush = Qt::Brush.new(Qt::darkGray)
+        painter.drawEllipse(-12, -12, 30, 30)
+        painter.pen = Qt::Pen.new(Qt::Brush.new(Qt::black), 1)
+        painter.brush = Qt::Brush.new(@color)
+        painter.drawEllipse(-15, -15, 30, 30)
+    end
+    
+    def mousePressEvent(event)
+        if event.button != Qt::LeftButton
+            event.ignore
+            return
+        end
+    
+        drag = Qt::Drag.new(event.widget)
+        mime = Qt::MimeData.new
+        drag.mimeData = mime
+    
+        @@n += 1
+        if @@n > 2 && rand(3) == 0
+            image = Qt::Image.new(":/images/head.png")
+            mime.imageData = qVariantFromValue(image)
+    
+            drag.pixmap = Qt::Pixmap.fromImage(image.scaled(30, 40))
+            drag.setHotSpot(Qt::Point.new(30, 40))
+        else
+            mime.colorData = qVariantFromValue(@color)
+            mime.text = "#%2.2x%2.2x%2.2x" % [@color.red, @color.green, @color.blue]
+
+            pixmap = Qt::Pixmap.new(34, 34)
+            pixmap.fill(Qt::Color.new(Qt::transparent))
+            painter = Qt::Painter.new(pixmap)
+            painter.translate(15, 15)
+            painter.renderHint = Qt::Painter::Antialiasing
+            paint(painter, 0, 0)
+            painter.end
+        
+            drag.pixmap = pixmap
+            drag.hotSpot = Qt::Point.new(15, 20)
+        end
+        drag.start
+    end
+    
+end

data/ext/ruby/qtruby/examples/graphicsview/dragdroprobot/main.rb

@@ -0,0 +1,57 @@
+=begin
+**
+** Copyright (C) 2004-2005 Trolltech AS. All rights reserved.
+**
+** This file is part of the example classes of the Qt Toolkit.
+**
+** This file may be used under the terms of the GNU General Public
+** License version 2.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.trolltech.com/products/qt/opensource.html
+**
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://www.trolltech.com/products/qt/licensing.html or contact the
+** sales department at sales@trolltech.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.
+**
+
+** Translated to QtRuby by Richard Dale
+=end
+    
+require 'Qt'
+require 'qrc_robot.rb'
+require 'coloritem.rb'
+require 'robot.rb'
+
+app = Qt::Application.new(ARGV)
+
+scene = Qt::GraphicsScene.new(-200, -200, 400, 400)
+
+for i in 0...10 do
+    item = ColorItem.new
+    item.setPos(Math.sin((i * 6.28) / 10.0) * 150,
+                    Math.cos((i * 6.28) / 10.0) * 150)
+
+    scene.addItem(item)
+end
+
+view = Qt::GraphicsView.new(scene)
+
+# Pass the view to the Robot and make it the parent of the
+# Qt::GraphicsItemAnimations, to prevent them being GC'd
+robot = Robot.new(view)
+robot.scale(1.2, 1.2)
+robot.setPos(0, -20)
+scene.addItem(robot)
+
+view.renderHint = Qt::Painter::Antialiasing
+view.backgroundBrush = Qt::Brush.new(Qt::Color.new(230, 200, 167))
+view.windowTitle = "Drag and Drop Robot"
+view.show
+
+app.exec

data/ext/ruby/qtruby/examples/graphicsview/dragdroprobot/makefile

@@ -0,0 +1,2 @@
+qrc_robot.rb: robot.qrc
+	rbrcc -name robot robot.qrc -o qrc_robot.rb

data/ext/ruby/qtruby/examples/graphicsview/dragdroprobot/robot.qrc

@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/" >
+        <file>images/head.png</file>
+    </qresource>
+</RCC>

data/ext/ruby/qtruby/examples/graphicsview/dragdroprobot/robot.rb

@@ -0,0 +1,246 @@
+=begin
+**
+** Copyright (C) 2004-2005 Trolltech AS. All rights reserved.
+**
+** This file is part of the example classes of the Qt Toolkit.
+**
+** This file may be used under the terms of the GNU General Public
+** License version 2.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.trolltech.com/products/qt/opensource.html
+**
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://www.trolltech.com/products/qt/licensing.html or contact the
+** sales department at sales@trolltech.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.
+**
+
+** Translated to QtRuby by Richard Dale
+=end
+    
+class RobotPart < Qt::GraphicsItem
+    
+    def initialize(parent)
+        super(parent)
+        @color = Qt::Color.new(Qt::lightGray)
+        @pixmap = Qt::Pixmap.new
+        @dragOver = false
+        setAcceptDrops(true)
+    end
+    
+    def dragEnterEvent(event)
+        if event.mimeData.hasColor ||
+            self.kind_of?(RobotHead) && event.mimeData.hasImage
+            event.accepted = true
+            @dragOver = true
+            update()
+        else
+            event.accepted = false
+        end
+    end
+    
+    def dragLeaveEvent(event)
+        @dragOver = false
+        update()
+    end
+    
+    def dropEvent(event)
+        @dragOver = false
+        if event.mimeData.hasColor
+            @color = qVariantValue(Qt::Color, event.mimeData.colorData)
+        elsif event.mimeData.hasImage
+            @pixmap = qVariantValue(Qt::Pixmap, event.mimeData.imageData)
+        end
+        update()
+    end
+end
+
+class RobotHead < RobotPart
+    Type = Qt::GraphicsItem::UserType + 1
+    
+    def initialize(parent)
+        super(parent)
+    end
+    
+    def boundingRect
+        return Qt::RectF.new(-15, -50, 30, 50)
+    end
+    
+    def paint(painter, option, widget)
+        if @pixmap.null?
+            painter.brush = Qt::Brush.new(@dragOver ? @color.light(130) : @color)
+            painter.drawRoundRect(-10, -30, 20, 30)
+            painter.brush = Qt::Brush.new(Qt::white)
+            painter.drawEllipse(-7, -3 - 20, 7, 7)
+            painter.drawEllipse(0, -3 - 20, 7, 7)
+            painter.brush = Qt::Brush.new(Qt::black)
+            painter.drawEllipse(-5, -1 - 20, 2, 2)
+            painter.drawEllipse(2, -1 - 20, 2, 2)
+            painter.pen = Qt::Pen.new(Qt::Brush.new(Qt::black), 2)
+            painter.brush = Qt::NoBrush
+            painter.drawArc(-6, -2 - 20, 12, 15, 190 * 16, 160 * 16)
+        else
+            painter.scale(0.2272, 0.2824)
+            painter.drawPixmap(Qt::PointF.new(-15 * 4.4, -50 * 3.54), @pixmap)
+        end
+    end
+    
+    def type()
+        return Type
+    end
+end
+
+class RobotTorso < RobotPart
+
+    def initialize(parent)
+        super(parent)
+    end
+    
+    def boundingRect
+        return Qt::RectF.new(-30, -20, 60, 60)
+    end
+    
+    def paint(painter, option, widget)
+        painter.brush = Qt::Brush.new(@dragOver ? @color.light(130) : @color)
+        painter.drawRoundRect(-20, -20, 40, 60)
+        painter.drawEllipse(-25, -20, 20, 20)
+        painter.drawEllipse(5, -20, 20, 20)
+        painter.drawEllipse(-20, 22, 20, 20)
+        painter.drawEllipse(0, 22, 20, 20)
+    end
+end
+
+class RobotLimb < RobotPart
+
+    def initialize(parent)
+        super(parent)
+    end
+    
+    def boundingRect
+        return Qt::RectF.new(-5, -5, 40, 10)
+    end
+    
+    def paint(painter, option, widget)
+        painter.brush = Qt::Brush.new(@dragOver ? @color.light(130) : @color)
+        painter.drawRoundRect(boundingRect(), 50, 50)
+        painter.drawEllipse(-5, -5, 10, 10)
+    end
+end
+
+class Robot < RobotPart
+    
+    def initialize(view)
+        super(nil)
+        torsoItem = RobotTorso.new(self)
+        headItem = RobotHead.new(torsoItem)
+        upperLeftArmItem = RobotLimb.new(torsoItem)
+        lowerLeftArmItem = RobotLimb.new(upperLeftArmItem)
+        upperRightArmItem = RobotLimb.new(torsoItem)
+        lowerRightArmItem = RobotLimb.new(upperRightArmItem)
+        upperRightLegItem = RobotLimb.new(torsoItem)
+        lowerRightLegItem = RobotLimb.new(upperRightLegItem)
+        upperLeftLegItem = RobotLimb.new(torsoItem)
+        lowerLeftLegItem = RobotLimb.new(upperLeftLegItem)
+        
+        headItem.setPos(0, -18)
+        upperLeftArmItem.setPos(-15, -10)
+        lowerLeftArmItem.setPos(30, 0)
+        upperRightArmItem.setPos(15, -10)
+        lowerRightArmItem.setPos(30, 0)
+        upperRightLegItem.setPos(10, 32)
+        lowerRightLegItem.setPos(30, 0)
+        upperLeftLegItem.setPos(-10, 32)
+        lowerLeftLegItem.setPos(30, 0)
+    
+        @timeLine = Qt::TimeLine.new
+    
+        headAnimation = Qt::GraphicsItemAnimation.new(view) do |a|
+            a.item = headItem
+            a.timeLine = @timeLine
+            a.setRotationAt(0, 20)
+            a.setRotationAt(1, -20)
+            a.setScaleAt(1, 1.1, 1.1)
+        end
+    
+        upperLeftArmAnimation = Qt::GraphicsItemAnimation.new(view) do |a|
+            a.item = upperLeftArmItem
+            a.timeLine = @timeLine
+            a.setRotationAt(0, 190)
+            a.setRotationAt(1, 180)
+        end
+    
+        lowerLeftArmAnimation = Qt::GraphicsItemAnimation.new(view) do |a|
+            a.item = lowerLeftArmItem
+            a.timeLine = @timeLine
+            a.setRotationAt(0, 50)
+            a.setRotationAt(1, 10)
+        end
+        
+        upperRightArmAnimation = Qt::GraphicsItemAnimation.new(view) do |a|
+            a.item = upperRightArmItem
+            a.timeLine = @timeLine
+            a.setRotationAt(0, 300)
+            a.setRotationAt(1, 310)
+        end
+    
+        lowerRightArmAnimation = Qt::GraphicsItemAnimation.new(view) do |a|
+            a.item = lowerRightArmItem
+            a.timeLine = @timeLine
+            a.setRotationAt(0, 0)
+            a.setRotationAt(1, -70)
+        end
+    
+        upperLeftLegAnimation = Qt::GraphicsItemAnimation.new(view) do |a|
+            a.item = upperLeftLegItem
+            a.timeLine = @timeLine
+            a.setRotationAt(0, 150)
+            a.setRotationAt(1, 80)
+        end
+    
+        lowerLeftLegAnimation = Qt::GraphicsItemAnimation.new(view) do |a|
+            a.item = lowerLeftLegItem
+            a.timeLine = @timeLine
+            a.setRotationAt(0, 70)
+            a.setRotationAt(1, 10)
+        end
+    
+        upperRightLegAnimation = Qt::GraphicsItemAnimation.new(view) do |a|
+            a.item = upperRightLegItem
+            a.timeLine = @timeLine
+            a.setRotationAt(0, 40)
+            a.setRotationAt(1, 120)
+        end
+        
+        lowerRightLegAnimation = Qt::GraphicsItemAnimation.new(view) do |a|
+            a.item = lowerRightLegItem
+            a.timeLine = @timeLine
+            a.setRotationAt(0, 10)
+            a.setRotationAt(1, 50)
+        end
+        
+        torsoAnimation = Qt::GraphicsItemAnimation.new(view) do |a|
+            a.item = torsoItem
+            a.timeLine = @timeLine
+            a.setRotationAt(0, 5)
+            a.setRotationAt(1, -20)
+        end
+    
+        @timeLine.updateInterval = 1000 / 25
+        @timeLine.curveShape = Qt::TimeLine::SineCurve
+        @timeLine.loopCount = 0
+        @timeLine.duration = 2000
+        @timeLine.start
+    end
+    
+    def boundingRect
+        return Qt::RectF.new()
+    end
+    
+    def paint(painter, option, widget)
+    end
+end