rgw 0.5.0

data/README.md

@@ -0,0 +1,22 @@
+## RGW Ruby Gtk Widgets
+
+Rgw is a collection of [Gtk+](http://www.gtk.org/) widgets implemented in and for the
+[ruby](https://www.ruby-lang.org) programming language.
+
+**requirements**  
+ruby >= 2.0.0  
+ruby-gtk >= 2.2.0  
+gtk >= 3.10  
+
+**how to install**  
+ruby setup.rb config  
+ruby setup.rb setup  
+*get root / superuser*  
+ruby setup.rb install  
+
+At this point, the widgets are working, but special functionality may be missing. A TODO list is at
+the head of every library file. Feel free to implement :-)
+
+If you also have created gtk widgets in ruby and think, that they may be useful for others,
+fork this project, include them and send me a pull request. Please attend, that you also provide
+a small example of the widgets use under the *examples* directory.

data/lib/rgw/big-list.rb

@@ -0,0 +1,316 @@
+#encoding: UTF-8
+
+=begin
+BigList 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.1 of the License, or (at your option) any later version.
+
+BigList is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with BigList; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Copyright 2014 Detlef Reichl  detlef!reichl()gmx!org
+=end
+
+
+=begin
+TODO:
+get all colors from the system settings
+make the columns resizable
+use copy while scrolling
+add a data provider that calls a block. For very big data pools or as backend for a DB
+=end
+
+require 'rgw/types'
+
+# Rgw::BigList is a widget, that shows a data list from an array of arrays. It has no  bells and
+# whistles, but is _very_ fast.
+
+module Rgw
+    class BigList < Gtk::Table
+        
+        ROW_PADDING = 4 # @private
+        # Initializes a new Rgw::BigList object
+        #
+        # @param num_cols [Integer, nil] The number of columns the list sould have.
+        def initialize num_cols=1
+            super(2, 2, false)
+            raise ArgumentError, 'positive integer expected' unless (num_cols.is_a? Integer and num_cols > 0)
+            @numCols = num_cols
+            # the X poxitions of the column ends
+            @colsX = []
+            # current displayed top column
+            @col = 0
+            # current displayed left column
+            @row = 0
+
+            @data = nil
+            @heads = nil
+            @headHeight = 0.0
+            @separator = "\t"
+
+            @area = Gtk::DrawingArea.new
+            self.attach @area, 0, 1, 0, 2, Gtk::AttachOptions::EXPAND | Gtk::AttachOptions::FILL,
+                                           Gtk::AttachOptions::EXPAND | Gtk::AttachOptions::FILL
+
+            # I don't use the integrated double buffering, cause it flickers
+            # I can do it better myself
+            double_buffered = false
+            @backBuffer = nil
+
+            @area.add_events Gdk::Event::Mask::SCROLL_MASK
+
+            @area.signal_connect(:scroll_event) {|object, event| on_scroll event.direction; false}
+            @area.signal_connect(:draw)                   {|object, cc| redraw; false}
+            @area.signal_connect(:configure_event)        {|object, event| on_configure event; false}
+
+            @scroll = Gtk::Scrollbar.new :vertical
+            self.attach @scroll, 1, 2, 1, 2, 0, Gtk::AttachOptions::EXPAND | Gtk::AttachOptions::FILL
+
+            dummy = Gtk::Label.new ' '
+            self.attach dummy, 1, 2, 0, 1, 0, 0
+        end
+        
+        # @return [Array] The complete data of the list as set by {#data=} or
+        #         nil if not.
+        attr_reader :data
+        
+        # @return [Array<String>, nil] The heads of the list if set by {#heads=}
+        #         or nil if not.
+        attr_reader :heads
+
+        #   @return [String] The separator to split data strings as set by {#separator=}
+        attr_reader :separator
+        
+        # @return [Integer] The number of columns for the list as set by {#num_cols=}
+        attr_reader :numCols
+
+        
+        # Set the lists data
+        #
+        # @param data [Array] The data for the list. The array has to contain Strings, which will
+        #        be split with [separator], or arrays of strings, which will be used directly.
+        def data=(data)
+            @data = data
+            configure_scrollbar
+            queue_draw
+        end
+
+
+        # Set the heads of the the list
+        # @param heads [Array<String>] The texts which should be displayed as the columns heads.
+        def heads=(heads)
+            unless heads.nil?
+                raise ArgumentError, "invalid type %s for heads; expect Array of String" % heads.class.to_s unless heads.is_a? Array
+                raise ArgumentError, "invalid size of heads" unless @numCols == heads.length
+                heads.each {|head| raise ArgumentError, "invalid type %s for head; expect String" % head.class.to_s unless head.is_a? String}
+            end
+            @heads = heads
+            calculate_rows
+            configure_scrollbar
+        end
+
+
+        # Set the column separator
+        #
+        # @param sep [String] For lists, where the data is provided as an array of strings the
+        #        separator will be used to split the input to the text for each column.
+        def separator=(sep)
+            @separator = sep
+            queue_draw
+        end
+
+
+        # Sets the number of columns
+        #
+        # @param cols [Integer] The number of columns the list should display
+        # @raise [ArgumentError] if cols is not an Integer or less then 1
+        def num_cols=(cols)
+            
+            raise ArgumentError, 'invalid column number' unless cols.is_a? Integer and cols > 0
+            @numCols = cols
+            @colsX = []
+            width = @width.to_f / @numCols.to_f
+            0.upto(@numCols) {|col| @colsX << col.to_f * width}
+            queue_draw
+        end
+
+        
+        # Get the row data from a given position
+        #
+        # @param x [Integer] Ignored for now.
+        # @param y [Integer] The vertical position in pixels from the list top position from where
+        #        to get the data from
+        # @return [Array<String>] The rows data for the requested position. The data is owend
+        #         by the list and should not be modified, because it will change your original data!
+        def row_at_pos x, y
+            @data[@row + y.to_f / @rowHeight]
+        end
+
+private
+
+        def queue_draw
+            @area.queue_draw_area 0, 0, @area.allocation.width, @area.allocation.height
+        end
+
+
+        def on_scroll dir
+            return if @data.nil?
+            case dir
+                when Gdk::EventScroll::Direction::UP
+                    return if @row == 0
+                    @row -= 1
+                    @scroll.adjustment.value = @row
+                    queue_draw
+                when Gdk::EventScroll::Direction::DOWN
+                    return if @row + @numRows > @data.length
+                    @row += 1
+                    @scroll.adjustment.value = @row
+                    queue_draw
+            end
+        end
+
+
+        def configure_scrollbar
+            return if @data.nil? or @numRows.nil? or @height.nil?
+            if @numRows >= @data.length()
+                @scroll.hide
+            else
+                @scroll.show
+                @scroll.adjustment = Gtk::Adjustment.new 0, 0, @data.length(), 1, @numRows, @numRows
+                @scroll.adjustment.signal_connect(:value_changed) {on_scrollbar_change}
+            end
+        end
+
+
+        def on_scrollbar_change
+            @row = @scroll.value.to_i
+            queue_draw
+        end
+
+
+        def on_configure event
+            @width  = event.width
+            @height = event.height
+            ctx = self.toplevel.style_context
+            fnt = ctx.get_font :normal
+            @ccFontSize = Pango.pixels(fnt.size) / 72.0 * self.toplevel.screen.resolution
+            @ccFontFamily = fnt.family
+            calculate_rows
+            configure_scrollbar
+        end
+
+
+        def calculate_rows
+            return if self.window.nil?
+            @backBuffer = Cairo::ImageSurface.new Cairo::Format::RGB24, @width, @height
+            cc = Cairo::Context.new @backBuffer
+            cc.font_size = @ccFontSize
+            @rowHeight = cc.text_extents('XgqT)!_').height.to_f + ROW_PADDING.to_f * 2.0
+            @headHeight = @heads.nil? ? 0.0 : @rowHeight + 4.0
+            @numRows = ((@height.to_f - @headHeight) / @rowHeight).ceil
+
+            if @colsX.length() == 0
+                width = @width.to_f / @numCols.to_f
+                0.upto(@numCols) {|col| @colsX << col.to_f * width}
+            else
+                @colsX[-1] = @width.to_f
+            end
+        end
+
+
+        def redraw
+            return if self.window.nil?
+            cc = Cairo::Context.new @backBuffer
+            cc.antialias = :none
+            cc.set_source_rgb 1.0, 1.0, 1.0
+            cc.paint
+
+            # draw the head
+            unless @heads.nil?
+                cc.set_source_rgb 0.9, 0.9, 0.9
+                cc.rectangle 0, 0, @width, @headHeight
+                cc.fill.stroke
+                cc.antialias = :subpixel
+                cc.set_source_rgb 0.0, 0.0, 0.0
+                cc.font_size = @ccFontSize
+                cc.select_font_face @ccFontFamily, :normal, :bold
+
+                @heads.each_with_index do |head, col|
+                    cc.move_to @colsX[col] + 4, @rowHeight - 4
+                    cc.show_text head
+                    cc.stroke
+                end
+            end
+
+            # draw the data
+            unless @data.nil?
+                colClips = []
+                cellData = []
+                (@row).upto(@row + @numRows - 1) do |row|
+                    break if row >= @data.length()
+                    textRow = @data[row]
+                    if textRow.is_a? Array
+                        cellData << textRow
+                    else
+                        cellData << textRow.split(@separator)
+                    end
+                end
+
+                0.upto(@numCols - 1) do |col|
+                    cc = Cairo::Context.new @backBuffer
+                    cc.antialias = :subpixel
+                    cc.set_source_rgb 0.0, 0.0, 0.0
+                    cc.font_size = @ccFontSize
+                    cc.select_font_face @ccFontFamily, :normal, :normal
+
+                    cc.rectangle @colsX[col], @headHeight, @colsX[col + 1] - @colsX[col], @height - @headHeight
+                    cc.clip
+                    cc.new_path
+                    0.upto(cellData.length() - 1) do |row|
+                        tok = cellData[row][col]
+                        next if tok.nil?
+                        cc.move_to @colsX[col] + 4, (row + 1) * @rowHeight - 4 + @headHeight
+                        cc.show_text tok
+                        cc.stroke
+                        cc.new_path
+                    end
+                end
+            end
+            cc = Cairo::Context.new @backBuffer
+            cc.antialias = :none
+            cc.set_source_rgb 0.0, 0.0, 0.0
+            cc.line_width = 1.0
+            lg = @data.nil? ? 0 : @data.length()
+            lg += 1 unless @heads.nil?
+
+            # draw the vertical lines
+            0.upto(@numCols - 1) do |col|
+                x = @colsX[col]
+                cc.move_to x, 0
+                cc.line_to x, @height.min(lg * @rowHeight)
+            end
+            cc.stroke
+
+            # draw the horizontal lines
+            0.upto(@numRows.min(lg - 1)) do |row|
+                y = @rowHeight * row + @headHeight
+                cc.move_to 0, y
+                cc.line_to @width, y
+            end
+            cc.stroke
+
+            # copy backbuffer to the window
+            cb = @area.window.create_cairo_context
+            cb.set_source @backBuffer
+            cb.paint
+            false
+        end
+    end
+end

data/lib/rgw/property-editor.rb

@@ -0,0 +1,278 @@
+# encoding: UTF-8
+
+=begin
+PropertyEditor 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.1 of the License, or (at your option) any later version.
+
+PropertyEditor is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with PropertyEditor; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Copyright 2014 Detlef Reichl  detlef!reichl()gmx!org
+=end
+
+require 'rgw/synced-spin-button'
+require 'rgw/radio-revealer'
+
+module Rgw
+    class PropertyEditor < Gtk::Box
+
+        self.type_register
+        self.signal_new :property_changed, GLib::Signal::RUN_FIRST, nil, GLib::Type['void'], String, Object
+
+        def signal_do_property_changed foo, bla; end
+
+        def initialize props, type
+            super(:orientation => :vertical)
+            @widgetDefaults = []
+            @selectedElement = nil
+            table = create_prop_editor props, type
+            pack_start table, :expand => false, :fill => false, :padding => 4
+        end
+
+        attr_reader :selectedElement
+
+
+        def create_prop_editor props, type=nil
+            table = Gtk::Table.new props.length() + 1, 2
+            table.column_spacings = 8
+            table.row_spacings = 4
+
+            unless type.nil?
+                headline = Gtk::Label.new
+                headline.markup = '<b><big>' + type + '</big></b>'
+                headline.xalign = 0.1
+                table.attach headline, 0, 2, 0, 1, Gtk::AttachOptions::EXPAND | Gtk::AttachOptions::FILL,
+                                               Gtk::AttachOptions::EXPAND | Gtk::AttachOptions::FILL
+            end
+
+            0.upto(props.length()-1) { |a| create_prop_entry props[a], table, a + 1}
+            table.show_all
+            table
+        end
+
+
+        def create_prop_entry data, table, row
+            label = Gtk::Label.new
+            label.xalign = 1.0
+            widget = nil
+
+            case data[:type]
+            when :iRadio
+                label.text = data[:label]
+                hbox = Gtk::Box.new :horizontal
+
+                i = 0
+                while true do
+                    sym = ('img' + i.to_s).to_sym
+                    break if data[sym].nil?
+                    i += 1
+                end
+
+                group = nil
+                0.upto(i-1) do |n|
+                    if n == 0
+                        button = Gtk::RadioButton.new
+                        group = button
+                    else
+                        button = Gtk::RadioButton.new group
+                    end
+                    hbox.pack_start button, :expand => false, :fill => false, :padding => 2
+                    button.draw_indicator = false
+                    sym = ('img' + n.to_s).to_sym
+#                    img = Gtk::Image.new(:file => Rgw::PIXMAP_PATH + data[sym] + '.png')
+                    button.image = img
+                    button.signal_connect(:toggled) do |widget|
+                        0.upto(widget.group.length() - 1) do |m|
+                            if widget.group[m].active?
+                                signal_emit :property_changed, data[:id0], widget.group.length() - 1 - m
+                                break
+                            end
+                        end
+                    end
+                end
+                group.group[i - 1 - data[:default0]].active = true
+                @widgetDefaults << [group, data]
+                hbox.show_all
+                widget = hbox
+            when :sSpin
+                label.text = data[:label]
+                widget = Rgw::SyncedSpinButton.new data[:range].first, data[:range].last, data[:step], data[:synced]
+                @widgetDefaults << [widget, data]
+                widget.set_values data[:default0], data[:default1]
+                widget.signal_connect(:value1_changed) {|wid, val| signal_emit :property_changed, data[:id0], val}
+                widget.signal_connect(:value2_changed) {|wid, val| signal_emit :property_changed, data[:id1], val}
+            when :spin
+                label.text = data[:label]
+                widget = Gtk::SpinButton.new data[:range].first, data[:range].last, data[:step]
+                widget.value = data[:default0]
+                @widgetDefaults << [widget, data]
+                widget.signal_connect(:value_changed) do |wid|
+                    signal_emit :property_changed, data[:id0], wid.value
+                end
+            when :toggle
+                label.text = data[:label].split[0..-2].join(' ')
+                widget = Gtk::ToggleButton.new data[:label].split[-1]
+                widget.active = data[:default0]
+                @widgetDefaults << [widget, data]
+                widget.signal_connect(:toggled) do |wid|
+                    signal_emit :property_changed, data[:id0], wid.active?
+                end
+            when :entry
+                label.text = data[:label]
+                widget = Gtk::Entry.new
+                widget.text = data[:default0]
+                @widgetDefaults << [widget, data]
+                widget.signal_connect(:changed) do |wid|
+                    signal_emit :property_changed, data[:id0], wid.text
+                end
+            when :color
+                label.text = data[:label]
+                # fix for ruby gtk 2.2.0
+                col = data[:default0].map{|c| c * 0xffff}.take(3)
+                color = Gdk::Color.new *col
+                #color = Gdk::RGBA.new(*data[:default0]) 
+                widget = Gtk::ColorButton.new color
+                widget.use_alpha = true
+                @widgetDefaults << [widget, data]
+                widget.signal_connect(:color_set) do |wid|
+                    cl = wid.rgba
+                    signal_emit :property_changed, data[:id0], [cl.red, cl.green, cl.blue, cl.alpha]
+                end
+            when :combo
+                label.text = data[:label]
+                widget = Gtk::ComboBoxText.new
+                data[:entries].each {|entry| widget.append nil, entry}
+                @widgetDefaults << [widget, data]
+                widget.signal_connect(:changed) do |wid|
+                    signal_emit :property_changed, data[:id0], wid.active
+                end
+            when :radioRevealer
+                rbox = Gtk::Box.new :vertical
+                table.attach_defaults rbox, 0, 2, row, row+1
+                rbox.pack_start Gtk::Separator.new(:horizontal), :expand => :false, :fill => :false
+                label.set_xalign(0.5)
+                label.markup = '<span size="large" weight="bold">' + data[:label] + '</span>'
+                rbox.pack_start label, :expand => :false, :fill => :false
+                widget = Rgw::RadioRevealer.new
+                rbox.pack_start widget, :expand => :false, :fill => :false
+                @widgetDefaults << [widget, data]
+                data[:revealSections].each do |section|
+                    revealerChild = create_prop_editor section[:data]
+                    label = Gtk::Label.new
+                    label.markup = '<span size="medium" weight="bold">' + section[:section] + '</span>'
+                    widget.create_entry label, revealerChild
+                    widget.signal_connect(:revealed) do |wid, idx|
+                        signal_emit :property_changed, data[:id0], idx
+                    end
+                end
+                return
+            else
+                raise RuntimeError, 'invalid property type'
+            end
+            table.attach_defaults label, 0, 1, row, row+1
+            table.attach_defaults widget, 1, 2, row, row+1
+        end
+
+
+        def set_selected_element element
+            @selectedElement = element
+        end
+
+
+        def set_from_data
+            @widgetDefaults.each do |data|
+                val1 = @selectedElement.get_by_name data[1][:id0]
+                if data[1][:type] == :iRadio
+                    data[0].group[data[0].group.length() - 1 - val1].active = true
+                elsif data[1][:type] == :toggle
+                    data[0].active = val1
+                elsif data[1][:type] == :spin
+                    data[0].value = val1
+                elsif data[1][:type] == :sSpin
+                    val2 = @selectedElement.get_by_name data[1][:id1]
+                    data[0].set_values val1, val2
+                elsif data[1][:type] == :entry
+                    data[0].text = val1
+                elsif data[1][:type] == :color
+                    col = Gdk::RGBA.new *val1
+                    data[0].rgba = col
+                elsif data[1][:type] == :combo
+                    data[0].active = val1
+                elsif data[1][:type] == :radioRevealer
+                    data[0].active = val1
+                else
+                    raise RuntimeError, 'invalid type in set_from_data'
+               end
+            end
+        end
+
+
+        def set_defaults
+            @widgetDefaults.each do |data|
+                # set from defaults
+                if data[1][:useDefault]
+                    if data[1][:type] == :iRadio
+                        # the buttons in a radio button group are orderd reverse. strange...
+                        data[0].group[data[0].group.length() - 1 - data[1][:default0]].active = true
+                    elsif data[1][:type] == :toggle
+                        data[0].active = data[1][:default0]
+                    elsif data[1][:type] == :spin
+                        data[0].value = data[1][:default0]
+                    elsif data[1][:type] == :sSpin
+                        data[0].set_values data[1][:default0], data[1][:default1]
+                    elsif data[1][:type] == :entry
+                        data[0].text = data[1][:default0]
+                    elsif data[1][:type] == :color
+                        col = Gdk::RGBA.new(*data[1][:default0])
+                        data[0].rgba = col
+                    elsif data[1][:type] == :combo
+                        data[0].active = data[1][:default0]
+                    elsif data[1][:type] == :radioRevealer
+                        data[0].active = data[1][:default0]
+                    else
+                        raise RuntimeError, 'invalid type in set_defaults useDefault'
+                   end
+                # move from the widget into the data store
+                else
+                    if data[1][:type] == :iRadio
+                        nb = data[0].group.length
+                        0.upto(nb - 1) do |i|
+                            if data[0].group[i].active?
+                                signal_emit :property_changed, data[1][:id0], nb - 1 - i
+                                break
+                            end
+                        end
+                    elsif data[1][:type] == :toggle
+                        f = data[0].active? ? 1.0 : 0.0
+                        signal_emit :property_changed, data[1][:id0], f
+                    elsif data[1][:type] == :spin
+                        signal_emit :property_changed, data[1][:id0], data[0].value
+                    elsif data[1][:type] == :sSpin
+                        s1, s2 = *data[0].get_values
+                        signal_emit :property_changed, data[1][:id0], s1 if s1 >= 0.0
+                        signal_emit :property_changed, data[1][:id1], s2 if s2 >= 0.0
+                    elsif data[1][:type] == :entry
+                        signal_emit :property_changed, data[1][:id0], data[0].text
+                    elsif data[1][:type] == :color
+                        cl = data[0].rgba
+                        signal_emit :property_changed, data[1][:id0], [cl.red, cl.green, cl.blue, cl.alpha]
+                    elsif data[1][:type] == :combo
+                        signal_emit :property_changed, data[1][:id0], data[0].active
+                    elsif data[1][:type] == :radioRevealer
+                        signal_emit :property_changed, data[1][:id0], data[0].active
+                    else
+                        raise RuntimeError, 'invalid type in set_defaults !useDefault'
+                   end
+                end
+            end
+        end
+    end
+end