qtbindings 4.6.3.0-x86-mingw32

data/examples/itemviews/chart/chart.qrc

@@ -0,0 +1,5 @@
+<!DOCTYPE RCC><RCC version="1.0">
+<qresource prefix="/Charts" >
+   <file>qtdata.cht</file>
+</qresource>
+</RCC>

data/examples/itemviews/chart/main.rb

@@ -0,0 +1,33 @@
+=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_chart.rb'
+require 'mainwindow.rb'
+
+app = Qt::Application.new(ARGV)
+window = MainWindow.new
+window.show
+app.exec

data/examples/itemviews/chart/mainwindow.rb

@@ -0,0 +1,151 @@
+=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 'pieview.rb'
+
+class MainWindow < Qt::MainWindow
+	
+	slots 'openFile(const QString)', 'openFile()',
+    		'saveFile()'
+	
+	def initialize()
+		super
+	    fileMenu = Qt::Menu.new(tr("&File"), self)
+	    openAction = fileMenu.addAction(tr("&Open"))
+	    openAction.shortcut = Qt::KeySequence.new(tr("Ctrl+O"))
+	    saveAction = fileMenu.addAction(tr("&Save"))
+	    saveAction.shortcut = Qt::KeySequence.new(tr("Ctrl+S"))
+	    quitAction = fileMenu.addAction(tr("E&xit"))
+	    quitAction.shortcut = Qt::KeySequence.new(tr("Ctrl+Q"))
+	
+	    setupModel()
+	    setupViews()
+	
+	    connect(openAction, SIGNAL('triggered()'), self, SLOT('openFile()'))
+	    connect(saveAction, SIGNAL('triggered()'), self, SLOT('saveFile()'))
+	    connect(quitAction, SIGNAL('triggered()'), $qApp, SLOT('quit()'))
+	
+	    menuBar().addMenu(fileMenu)
+	    statusBar()
+	
+	    openFile(":/Charts/qtdata.cht")
+	
+	    setWindowTitle(tr("Chart"))
+	    resize(640, 480)
+	end
+	
+	def setupModel()
+	    @model = Qt::StandardItemModel.new(8, 2, self)
+	    @model.setHeaderData(0, Qt::Horizontal, Qt::Variant.new(tr("Label")))
+	    @model.setHeaderData(1, Qt::Horizontal, Qt::Variant.new(tr("Quantity")))
+	end
+	
+	def setupViews()
+	    splitter = Qt::Splitter.new
+	    table = Qt::TableView.new
+	    @pieChart = PieView.new
+	    splitter.addWidget(table)
+	    splitter.addWidget(@pieChart)
+	    splitter.setStretchFactor(0, 0)
+	    splitter.setStretchFactor(1, 1)
+	
+	    table.model = @model
+	    @pieChart.model = @model
+	
+	    @selectionModel = Qt::ItemSelectionModel.new(@model)
+	    table.selectionModel = @selectionModel
+	    @pieChart.selectionModel = @selectionModel
+	
+	    setCentralWidget(splitter)
+	end
+	
+	def openFile(path = nil)
+	    if path.nil?
+	        fileName = Qt::FileDialog.getOpenFileName(self, tr("Choose a data file"),
+	                                                "", "*.cht")
+	    else
+	        fileName = path
+		end
+	
+	    if !fileName.nil?
+	        file = Qt::File.new(fileName)
+	
+	        if file.open(Qt::File::ReadOnly | Qt::File::Text)
+	            stream = Qt::TextStream.new(file)
+	
+	            @model.removeRows(0, @model.rowCount(Qt::ModelIndex.new), Qt::ModelIndex.new)
+	
+	            row = 0
+	            line = stream.readLine()
+				while !line.nil?
+					@model.insertRows(row, 1, Qt::ModelIndex.new())
+
+					pieces = line.split(",")
+
+					@model.setData(@model.index(row, 0, Qt::ModelIndex.new),
+									Qt::Variant.new(pieces[0]))
+					@model.setData(@model.index(row, 1, Qt::ModelIndex.new),
+									Qt::Variant.new(pieces[1]))
+					@model.setData(@model.index(row, 0, Qt::ModelIndex.new),
+									qVariantFromValue(Qt::Color.new(pieces[2])), Qt::DecorationRole)
+	                row += 1
+
+	                line = stream.readLine()
+	            end
+	
+	            file.close()
+	            statusBar().showMessage(tr("Loaded %s" % fileName), 2000)
+	        end
+	    end
+	end
+	
+	def saveFile()
+	    fileName = Qt::FileDialog.getSaveFileName(self,
+	        tr("Save file as"), "", "*.cht")
+	
+	    if !fileName.nil?
+	        file = Qt::File.new(fileName)
+	        stream = Qt::TextStream.new(file)
+	
+	        if file.open(Qt::File::WriteOnly | Qt::File::Text)
+				(0...@model.rowCount(Qt::ModelIndex.new)).each do |row|
+	                pieces = []
+	
+	                pieces.push(@model.data(@model.index(row, 0, Qt::ModelIndex.new),
+	                                          Qt::DisplayRole).toString)
+	                pieces.push(@model.data(@model.index(row, 1, Qt::ModelIndex.new),
+	                                          Qt::DisplayRole).toString)
+	                pieces.push(@model.data(@model.index(row, 0, Qt::ModelIndex.new),
+	                                          Qt::DecorationRole).toString)
+	
+	                stream << pieces.join(",") << "\n"
+	            end
+	        end
+	
+	        file.close()
+	        statusBar().showMessage(tr("Saved %s" % fileName), 2000)
+	    end
+	end
+end

data/examples/itemviews/chart/makefile

@@ -0,0 +1,2 @@
+all:
+	rbrcc -name chart chart.qrc -o qrc_chart.rb

data/examples/itemviews/chart/mydata.cht

@@ -0,0 +1,8 @@
+London,4,red
+Stockholm,5,pink
+Paris,2,lightgreen
+Rome,11,green
+Lisbon,9,blue
+Madrid,8,lightblue
+Berlin,6,magenta
+Vienna,7,purple

data/examples/itemviews/chart/pieview.rb

@@ -0,0 +1,516 @@
+=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 PieView < Qt::AbstractItemView
+    
+    slots 'dataChanged(const QModelIndex &, const QModelIndex &)',
+            'rowsInserted(const QModelIndex &, int, int)',
+            'rowsAboutToBeRemoved(const QModelIndex &, int, int)'
+    
+    def initialize(parent = nil)
+        super(parent)
+        horizontalScrollBar.range = 0..0
+        verticalScrollBar.range = 0..0
+    
+        @margin = 8
+        @totalSize = 300
+        @pieSize = @totalSize - 2*@margin
+        @validItems = 0
+        @totalValue = 0.0
+    end
+    
+    def dataChanged(topLeft, bottomRight)
+        super(topLeft, bottomRight)
+    
+        @validItems = 0
+        @totalValue = 0.0
+    
+        (0...model().rowCount(rootIndex())).each do |row|
+    
+            index = model().index(row, 1, rootIndex())
+            value = model().data(index).toDouble
+    
+            if value > 0.0
+                @totalValue += value
+                @validItems += 1
+            end
+        end
+        viewport().update()
+    end
+    
+    def edit(index, trigger, event)
+        if index.column() == 0
+            return super(index, trigger, event)
+        else
+            return false
+        end
+    end
+    
+    # Returns the item that covers the coordinate given in the view.
+    
+    def indexAt(point)
+        if @validItems == 0
+            return Qt::ModelIndex.new
+        end
+    
+        # Transform the view coordinates into contents widget coordinates.
+        wx = point.x() + horizontalScrollBar().value()
+        wy = point.y() + verticalScrollBar().value()
+    
+        if wx < @totalSize
+            cx = wx - @totalSize/2
+            cy = @totalSize/2 - wy # positive cy for items above the center
+    
+            # Determine the distance from the center point of the pie chart.
+            d = ((cx ** 2) + (cy ** 2)) ** 0.5
+    
+            if d == 0 || d > @pieSize/2
+                return Qt::ModelIndex.new
+            end
+    
+            # Determine the angle of the point.
+            angle = (180 / Math::PI) * Math.acos(cx/d)
+            if cy < 0
+                angle = 360 - angle
+            end
+    
+            # Find the relevant slice of the pie.
+            startAngle = 0.0
+    
+            for row in 0...model.rowCount(rootIndex)
+    
+                index = model.index(row, 1, rootIndex())
+                value = model.data(index).to_f
+    
+                if value > 0.0
+                    sliceAngle = 360*value/@totalValue
+    
+                    if angle >= startAngle && angle < (startAngle + sliceAngle)
+                        return model().index(row, 1, rootIndex())
+                    end
+    
+                    startAngle += sliceAngle
+                end
+            end
+        else
+            itemHeight = Qt::FontMetrics.new(viewOptions().font).height()
+            listItem = ((wy - @margin) / itemHeight).to_i
+            validRow = 0
+    
+            for row in 0...model.rowCount(rootIndex) do
+    
+                index = model().index(row, 1, rootIndex())
+                if model().data(index).to_f > 0.0
+    
+                    if listItem == validRow
+                        return model().index(row, 0, rootIndex())
+                    end
+    
+                    # Update the list index that corresponds to the next valid row.
+                    validRow += 1
+                end
+            end
+        end
+    
+        return Qt::ModelIndex.new
+    end
+    
+    def isIndexHidden(index)
+        return false
+    end
+    
+    # Returns the rectangle of the item at position \a index in the
+    # model. The rectangle is in contents coordinates.
+    
+    def itemRect(index)
+        if !index.isValid()
+            return Qt::Rect.new
+        end
+    
+        # Check whether the index's row is in the list of rows represented
+        # by slices.
+        valueIndex = Qt::ModelIndex.new
+    
+        if index.column() != 1
+            valueIndex = model().index(index.row(), 1, rootIndex())
+        else
+            valueIndex = index
+        end
+    
+        if model().data(valueIndex).toDouble > 0.0
+    
+            listItem = 0
+            (index.row()-1).downto(0) do |row|
+                if model().data(model().index(row, 1, rootIndex())).toDouble > 0.0
+                    listItem += 1
+                end
+            end
+    
+            case index.column
+            when 0:
+                itemHeight = Qt::FontMetrics.new(viewOptions().font).height()
+    
+                return Qt::Rect.new(@totalSize,
+                             (@margin + listItem*itemHeight).to_i,
+                             @totalSize - @margin, itemHeight.to_i)
+            when 1:
+                return viewport().rect()
+            end
+    
+        end
+        return Qt::Rect.new
+    end
+    
+    def itemRegion(index)
+        if !index.isValid()
+            return Qt::Region.new
+        end
+    
+        if index.column() != 1
+            return Qt::Region.new(itemRect(index))
+        end
+    
+        if model().data(index).to_f <= 0.0
+            return Qt::Region.new
+        end
+    
+        startAngle = 0.0
+        (0...model.rowCount(rootIndex())).each do |row|
+    
+            sliceIndex = model.index(row, 1, rootIndex)
+            value = model.data(sliceIndex).to_f
+    
+            if value > 0.0
+                angle = 360*value/@totalValue
+    
+                if sliceIndex == index
+                    slicePath = Qt::PainterPath.new
+                    slicePath.moveTo(@totalSize/2, @totalSize/2)
+                    slicePath.arcTo(@margin, @margin, @margin+@pieSize, @margin+@pieSize,
+                                    startAngle, angle)
+                    slicePath.closeSubpath()
+    
+                    return Qt::Region.new(slicePath.toFillPolygon().toPolygon())
+                end
+    
+                startAngle += angle
+            end
+        end
+    
+        return Qt::Region.new
+    end
+    
+    def horizontalOffset()
+        return horizontalScrollBar().value()
+    end
+    
+    def mouseReleaseEvent(event)
+        super(event)
+        @selectionRect = Qt::Rect.new
+        viewport().update()
+    end
+    
+    def moveCursor(cursorAction, modifiers)
+        current = currentIndex()
+    
+        case cursorAction
+        when MoveLeft, MoveUp
+            if current.row > 0
+                current = model().index(current.row() - 1, current.column,
+                                            rootIndex())
+            else
+                current = model().index(0, current.column, rootIndex())
+            end
+        when MoveRight, MoveDown
+            if current.row < rows(current) - 1
+                current = model().index(current.row + 1, current.column,
+                                            rootIndex())
+            else
+                current = model().index(rows(current) - 1, current.column,
+                                            rootIndex())
+            end
+        end
+    
+        viewport().update()
+        return current
+    end
+    
+    def paintEvent(event)
+        selections = selectionModel()
+        option = viewOptions()
+        state = option.state
+    
+        background = option.palette.base()
+        foreground = Qt::Pen.new(option.palette.color(Qt::Palette::Foreground))
+        textPen = Qt::Pen.new(option.palette.color(Qt::Palette::Text))
+        highlightedPen = Qt::Pen.new(option.palette.color(Qt::Palette::HighlightedText))
+    
+        painter = Qt::Painter.new(viewport())
+        painter.renderHint = Qt::Painter::Antialiasing
+    
+        painter.fillRect(event.rect(), background)
+        painter.pen = foreground
+    
+        # Viewport rectangles
+        pieRect = Qt::Rect.new(@margin, @margin, @pieSize, @pieSize)
+        keyPoint = Qt::Point.new(@totalSize - horizontalScrollBar().value(),
+                                 @margin - verticalScrollBar().value())
+    
+        if @validItems > 0
+            painter.save()
+            painter.translate(pieRect.x() - horizontalScrollBar().value(),
+                              pieRect.y() - verticalScrollBar().value())
+            painter.drawEllipse(0, 0, @pieSize, @pieSize)
+            startAngle = 0.0
+    
+            for row in 0...model.rowCount(rootIndex) do
+                index = model.index(row, 1, rootIndex())
+                value = model.data(index).toDouble
+    
+                if value > 0.0
+                    angle = 360*value/@totalValue
+    
+                    colorIndex = model().index(row, 0, rootIndex())
+                    color = Qt::Color.new(model().data(colorIndex,
+                                    Qt::DecorationRole).toString)
+    
+                    if currentIndex() == index
+                        painter.brush = Qt::Brush.new(color, Qt::Dense4Pattern)
+                    elsif selections.isSelected(index)
+                        painter.brush = Qt::Brush.new(color, Qt::Dense3Pattern)
+                    else
+                        painter.brush = Qt::Brush.new(color)
+                    end
+    
+                    painter.drawPie(0, 0, @pieSize, @pieSize, (startAngle*16).to_i,
+                                    (angle*16).to_i)
+    
+                    startAngle += angle
+                end
+            end
+            painter.restore()
+    
+            keyNumber = 0
+    
+            for row in 0...model.rowCount(rootIndex()) do
+    
+                index = model.index(row, 1, rootIndex())
+                value = model.data(index).toDouble
+    
+                if value > 0.0
+                    labelIndex = model.index(row, 0, rootIndex())
+    
+                    option = viewOptions()
+                    option.rect = visualRect(labelIndex)
+                    if selections.isSelected(labelIndex)
+                        option.state |= Qt::Style::State_Selected.to_i
+                    end
+                    if currentIndex() == labelIndex
+                        option.state |= Qt::Style::State_HasFocus.to_i
+                    end
+                    itemDelegate().paint(painter, option, labelIndex)
+    
+                    keyNumber += 1
+                end
+            end
+        end
+    
+        if !@selectionRect.nil?
+            band = Qt::StyleOptionRubberBand.new
+            band.shape = Qt::RubberBand::Rectangle
+            band.rect = @selectionRect
+            painter.save()
+            style().drawControl(Qt::Style::CE_RubberBand, band, painter)
+            painter.restore()
+        end
+
+        painter.end
+    end
+    
+    def resizeEvent(event)
+        updateGeometries()
+    end
+    
+    def rows(index)
+        return model().rowCount(model().parent(index))
+    end
+    
+    def rowsInserted(parent, start_row, end_row)
+        for row in start_row..end_row do
+    
+            index = model.index(row, 1, rootIndex)
+            value = model.data(index).toDouble
+    
+            if value > 0.0
+                @totalValue += value
+                @validItems += 1
+            end
+        end
+    
+        super(parent, start_row, end_row)
+    end
+    
+    def rowsAboutToBeRemoved(parent, start_row, end_row)
+        for row in start_row..end_row do
+    
+            index = model.index(row, 1, rootIndex())
+            value = model.data(index).toDouble
+            if value > 0.0
+                @totalValue -= value
+                @validItems -= 1
+            end
+        end
+    
+        super(parent, start_row, end_row)
+    end
+    
+    def scrollContentsBy(dx, dy)
+        viewport().scroll(dx, dy)
+    end
+    
+    def scrollTo(index, hint)
+        area = viewport.rect
+        rect = visualRect(index)
+    
+        if rect.left < area.left
+            horizontalScrollBar.setValue(
+                horizontalScrollBar.value + rect.left - area.left)
+        elsif rect.right > area.right
+            horizontalScrollBar.setValue(
+                horizontalScrollBar.value +
+                    [rect.right - area.right, rect.left - area.left].min)
+        end
+    
+        if rect.top < area.top()
+            verticalScrollBar.setValue(
+                verticalScrollBar.value + rect.top - area.top)
+        elsif rect.bottom > area.bottom()
+            verticalScrollBar.setValue(
+                verticalScrollBar.value +
+                    [rect.bottom - area.bottom, rect.top - area.top].min)
+        end
+    end
+    
+    # Find the indices corresponding to the extent of the selection.
+    def setSelection(rect, command)
+        # Use content widget coordinates because we will use the itemRegion()
+        # function to check for intersections.
+    
+        contentsRect = rect.translated(horizontalScrollBar.value,
+                                             verticalScrollBar.value)
+    
+        rows = model.rowCount(rootIndex)
+        columns = model.columnCount(rootIndex)
+        indexes = []
+    
+        for row in 0...rows do
+            for column in 0...columns do
+                index = model.index(row, column, rootIndex)
+                region = itemRegion(index)
+                if !region.intersect(Qt::Region.new(contentsRect)).empty?
+                    indexes.push(index)
+                end
+            end
+        end
+    
+        if indexes.size > 0
+            firstRow = indexes[0].row
+            lastRow = indexes[0].row
+            firstColumn = indexes[0].column
+            lastColumn = indexes[0].column
+    
+            for i in 1...indexes.size do
+                firstRow = [firstRow, indexes[i].row].min
+                lastRow = [lastRow, indexes[i].row].max
+                firstColumn = [firstColumn, indexes[i].column].min
+                lastColumn = [lastColumn, indexes[i].column].max
+            end
+    
+             selection = Qt::ItemSelection.new(
+                model.index(firstRow, firstColumn, rootIndex()),
+                model.index(lastRow, lastColumn, rootIndex()))
+            selectionModel.select(selection, command)
+        else
+            noIndex = Qt::ModelIndex.new
+            selection = Qt::ItemSelection.new(noIndex, noIndex)
+            selectionModel.select(selection, command)
+        end
+    
+        @selectionRect = rect
+    end
+    
+    def updateGeometries
+        horizontalScrollBar.pageStep = viewport.width
+        horizontalScrollBar.range = 0..[0, 2*@totalSize - viewport.width].max
+        verticalScrollBar.pageStep = viewport.height
+        verticalScrollBar.range = 0..[0, @totalSize - viewport.height].max
+    end
+    
+    def verticalOffset
+        return verticalScrollBar.value
+    end
+    
+    # Returns the position of the item in viewport coordinates.
+    
+    def visualRect(index)
+        rect = itemRect(index)
+        if rect.valid?
+            return Qt::Rect.new(rect.left - horizontalScrollBar.value,
+                         rect.top - verticalScrollBar.value,
+                         rect.width, rect.height)
+        else
+            return rect
+        end
+    end
+    
+    # Returns a region corresponding to the selection in viewport coordinates.
+    
+    def visualRegionForSelection(selection)
+        ranges = selection.length
+
+        if ranges == 0
+            return Qt::Region.new(Qt::Rect.new)
+        end
+    
+        # Note that we use the top and bottom functions of the selection range
+        # since the data is stored in rows.
+    
+        firstRow = selection.at(0).top
+        lastRow = selection.at(0).top
+    
+        for i in 0...ranges do
+            firstRow = [firstRow, selection.at(i).top].min
+            lastRow = [lastRow, selection.at(i).bottom].max
+        end
+    
+        firstItem = model().index([firstRow, lastRow].min, 0, rootIndex())
+        lastItem = model().index([firstRow, lastRow].max, 0, rootIndex())
+    
+        firstRect = visualRect(firstItem)
+        lastRect = visualRect(lastItem)
+    
+        return Qt::Region.new(firstRect.unite(lastRect))
+    end
+end