sirens 0.0.1

data/lib/views/text_view.rb

@@ -0,0 +1,112 @@
+module Sirens
+    class TextView < View
+        # Class methods
+
+        class << self
+            ##
+            # Answer the styles accepted by this view.
+            #
+            def view_accepted_styles()
+                super() + [:wrap_mode].freeze
+            end
+        end
+
+        # Initializing
+
+        def initialize_handles()
+            @text_view = Gtk::TextView.new
+
+            @main_handle = Gtk::ScrolledWindow.new
+            @main_handle.set_policy(:automatic, :always)
+
+            @main_handle.add(@text_view)
+        end
+
+        # Hooking GUI signals
+
+        def subscribe_to_ui_events()
+            text_view.signal_connect('populate-popup') do |text_view, menu|
+                menu_view = MenuView.new(menu_handle: menu)
+
+                @populate_popup_menu_block.call(menu: menu_view)
+
+                menu.show_all
+            end
+        end
+
+        # Styles
+
+        def wrap_mode=(value)
+            text_view.wrap_mode = value
+        end
+
+        def wrap_mode()
+            text_view.wrap_mode
+        end
+
+        def background_color=(value)
+            state_colors_from(value).each_pair do |state, value|
+                next if value.nil?
+
+                text_view.override_background_color( state, Gdk::RGBA.parse(value) )
+            end
+        end
+
+        def foreground_color=(value, state: :normal)
+            state_colors_from(value).each_pair do |state, value|
+                next if value.nil?
+
+                text_view.override_color( state, Gdk::RGBA.parse(value) )
+            end
+        end
+
+        def state_colors_from(value)
+            colors = Hash[
+                normal: nil,
+                active: nil,
+                prelight: nil,
+                selected: nil,
+                insensitive: nil,
+            ]
+
+            if value.kind_of?(Hash)
+                value.each_pair do |state, value|
+                    colors[state] = value
+                end
+            else
+                colors[:normal] = value
+            end
+
+            colors
+        end
+
+        # Accessing
+
+        def text_view()
+            @text_view
+        end
+
+        def text()
+            text_view.buffer.text
+        end
+
+        def set_text(text)
+            text = '' if text.nil?
+
+            text_view.buffer.text = text
+        end
+
+        # Querying
+
+        ##
+        # Returns the selected text of nil if no text is selected.
+        #
+        def selected_text()
+            selection_bounds = text_view.buffer.selection_bounds
+
+            return if selection_bounds.nil?
+
+            text_view.buffer.get_text(selection_bounds[0], selection_bounds[1], false)
+        end
+    end
+end

data/lib/views/tree_view.rb

@@ -0,0 +1,314 @@
+module Sirens
+    class TreeView < View
+
+        # Class methods
+
+        class << self
+            ##
+            # Answer the laze children placeholder.
+            #
+            def placeholder()
+                @placeholder ||= '__placeholder__'
+            end
+
+            ##
+            # Answer the styles accepted by this view.
+            #
+            def view_accepted_styles()
+                super() + [:show_headers, :clickable_headers, :on_selection_action ].freeze
+            end
+        end
+
+        # Initializing
+
+        def initialize_handles()
+            @tree_view = Gtk::TreeView.new
+            @tree_view.set_model(Gtk::TreeStore.new(String))
+
+            @main_handle = Gtk::ScrolledWindow.new
+            @main_handle.add(tree_view)
+            @main_handle.set_policy(:automatic, :automatic)
+
+            @current_selection_indices = []
+
+            @columns_props = []
+
+            @on_selection_changed_block = nil
+            @get_item_block = nil
+            @get_children_block = nil
+        end
+
+        # Configuring callbacks
+
+        def on_selection_changed_block(&block)
+            @on_selection_changed_block = block
+
+            self
+        end
+
+        def get_item_block(&block)
+            @get_item_block = block
+
+            self
+        end
+
+        def get_children_block(&block)
+            @get_children_block = block
+
+            self
+        end
+
+        # Building columns
+
+        def define_columns(columns_props_array)
+            @columns_props = columns_props_array
+
+            tree_store_types = @columns_props
+                .collect { |each_column_props| each_column_props.fetch(:type, :text) }
+                .collect { |type| String }
+
+            tree_view.set_model(Gtk::TreeStore.new(*tree_store_types))
+
+            @columns_props.each do |each_column_props|
+                add_column_with_props(each_column_props)
+            end
+        end
+
+        def add_column_with_props(props)
+            column_type = props.fetch(:type, :text)
+            column_index = tree_view.columns.size
+
+            renderer = Gtk::CellRendererText.new
+
+            col = Gtk::TreeViewColumn.new(props[:label], renderer, column_type => column_index)
+
+            tree_view.append_column(col)
+        end
+
+        # Hooking GUI signals
+
+        def subscribe_to_ui_events()
+            tree_view.selection.signal_connect('changed') { |tree_selection|
+                on_selection_changed(tree_selection)
+            }
+
+            tree_view.signal_connect('row-activated') { |tree_view, tree_path, tree_column|
+                on_selection_action(tree_path: tree_path, tree_column: tree_column)
+            }
+
+            tree_view.signal_connect('row-expanded') { |tree_view, iter, tree_path|
+                on_row_expanded(iter: iter, tree_path: tree_path)
+            }
+
+            tree_view.signal_connect('button_press_event') do |tree_view, event|
+                show_popup_menu(button: event.button, time: event.time) if (event.button == 3)
+            end
+        end
+
+        # Accessing
+
+        def tree_store()
+            tree_view.model
+        end
+
+        def tree_view()
+            @tree_view
+        end
+
+        ##
+        # Returns the rows contents of the tree.
+        # For testing and debugging only.
+        #
+        def rows()
+            tree_store.collect { |store, path, iter|
+                iter[0]
+            }
+        end
+
+        def get_item_at(path:)
+            @get_item_block.call(path: path)
+        end
+
+        def get_children_at(path:)
+            @get_children_block.call(path: path)
+        end
+
+        # Styles
+
+        def show_headers=(boolean)
+            tree_view.headers_visible = boolean
+        end
+
+        def show_headers?()
+            tree_view.headers_visible?
+        end
+
+        def clickable_headers=(boolean)
+            tree_view.headers_clickable = boolean
+        end
+
+        def clickable_headers?()
+            tree_view.headers_clickable?
+        end
+
+        def on_selection_action=(block)
+            @on_selection_action_block = block
+        end
+
+        # Handlers
+
+        def on_selection_changed(tree_selection)
+            indices = []
+            items = []
+
+            tree_selection.each do |tree_store, tree_path, iter|
+                indices_path = tree_path.indices
+
+                indices << indices_path
+                items << get_item_at(path: indices_path)
+            end
+
+            @on_selection_changed_block.call(
+                selection_items: items,
+                selection_paths: indices
+            )
+        end
+
+        def on_selection_action(tree_path:, tree_column:)
+            return if @on_selection_action_block.nil?
+
+            index_path = tree_path.indices
+
+            item = get_item_at(path: index_path)
+
+            @on_selection_action_block.call(index_path: index_path, item: item)
+        end
+
+        ##
+        # To emulate a virtual tree elements are added with a child placeholder, the class placeholder constant.
+        # The first time a node is expanded if it has the child placeholder it is replaced by the actual node
+        # children.
+        # The actual children are get using the get_children_block.
+        #
+        def on_row_expanded(iter:, tree_path:)
+            child_iter = iter.first_child
+
+            return if tree_store.get_value(child_iter, 0) != self.class.placeholder
+
+            indices_path = tree_path.indices
+
+            children = get_children_at(path: indices_path)
+
+            tree_store.remove(child_iter)
+
+            add_items(items: children, parent_iter: iter, index: 0)
+
+            tree_view.expand_row(tree_path, false)
+        end
+
+        # Actions
+
+        def clear_items()
+            tree_store.clear
+        end
+
+        # Adding
+
+        def add_items(items:, parent_iter:, index:)
+            items.each_with_index do |each_item, i|
+                add_item(item: each_item, parent_iter: parent_iter, index: index + i)
+            end
+        end
+
+        def add_item(item:, parent_iter:, index:)
+            iter = tree_store.insert(parent_iter, index)
+
+            set_item_column_values(item: item, iter: iter)
+
+            if parent_iter.nil?
+                indices_path = [index]
+            else
+                indices_path = parent_iter.path.indices + [index]
+            end
+
+            children_count = get_children_at(path: indices_path).size
+
+            if children_count > 0
+                placeholder = tree_store.insert(iter, 0)
+
+                placeholder[0] = self.class.placeholder
+            end
+        end
+
+        # Updating
+
+        def update_items(items:, indices:)
+            items.each_with_index do |each_item, i|
+                update_item(item: each_item, index: indices[i])
+            end
+        end
+
+        def update_item(item:, index:)
+            iter = tree_store.get_iter(index.to_s)
+
+            set_item_column_values(item: item, iter: iter)
+        end
+
+        # Removing
+
+        def remove_items(items:, indices:)
+            items.each_with_index do |each_item, i|
+                remove_item(item: each_item, index: indices[i])
+            end
+        end
+
+        def remove_item(item:, index:)
+            iter = tree_store.get_iter(index.to_s)
+
+            tree_store.remove(iter)
+        end
+
+        def set_item_column_values(item:, iter:)
+            @columns_props.each_with_index { |column, column_index|
+                iter[column_index] = column.display_text_of(item)
+            }
+        end
+
+        # Querying
+
+        def selection_indices()
+            indices = []
+
+            tree_view.selection.each { |tree, path, iter|
+                indices << path.to_s.to_i
+            }
+
+            indices
+        end
+
+        def set_selection_indices(indices)
+            if indices.empty?
+                tree_view.unselect_all
+                return
+            end
+
+            tree_path = Gtk::TreePath.new(
+                    indices.join(':')
+                )
+
+            expand(path: indices[0..-2]) if indices.size > 1
+
+            tree_view.selection.select_path(tree_path)
+
+            tree_view.scroll_to_cell(tree_path, nil, false, 0.0, 0.0)
+        end
+
+        def expand(path:)
+            tree_path = Gtk::TreePath.new(
+                    path.join(':')
+                )
+
+            tree_view.expand_row(tree_path, false)
+        end
+    end
+end

data/lib/views/view.rb

@@ -0,0 +1,206 @@
+require 'set'
+
+module Sirens
+    ##
+    # A View is the library binding to a GUI interface handle.
+    # It is not a Component but is wrapped by a PrimitiveComponent.
+    # a View takes care of handling the internals of the GUI objects such as handles, events, default initialization,
+    # etc.
+    #
+    # By separating the View from the PrimitiveComponent that wraps it makes the PrimitiveComponents responsibilities
+    # more consistent with regular Components and it makes it easier to switch between GUI libraries
+    # (say, from Gtk to Qt).
+    #
+    class View
+
+        # Class methods
+
+        class << self
+            ##
+            # Answer the styles accepted by this view.
+            #
+            def accepted_styles()
+                @accepted_styles ||= Set.new(view_accepted_styles)
+            end
+
+            ##
+            # Answer the styles accepted by this view.
+            #
+            def view_accepted_styles()
+                [ :width, :height, :background_color, :foreground_color ].freeze
+            end
+        end
+
+        # Initializing
+
+        ##
+        # Initializes this View handles
+        #
+        def initialize()
+            @event_handles = Hash[]
+
+            @main_handle = nil
+
+            initialize_handles
+
+            subscribe_to_ui_events
+        end
+
+        ## Instantiates this view handles.
+        # A View usually has a single handle to the GUI library, but in same cases it may have more than one.
+        # For instance when adding a Scroll decorator to the actual widget.
+        #
+        def initialize_handles()
+            raise RuntimeError.new("Subclass #{self.class.name} must implement the method ::initialize_handles().")
+        end
+
+        ##
+        # Subscribes this View to the events/signals emitted by the GUI handle(s) of interest.
+        # When an event/signal is received calls the proper event_handler provided by the PrimitiveComponent,
+        # if one was given.
+        #
+        # This mechanism of event handler callbacks is more simple and lightweight than making this View to announce
+        # events using the Observer pattern, and since there is only one PrimitiveComponent wrapping each View
+        # using the Observer pattern would be unnecessary complex.
+        #
+        def subscribe_to_ui_events()
+            raise RuntimeError.new("Subclass #{self.class.name} must implement the method ::subscribe_to_ui_events().")
+        end
+
+        # Accessing
+
+        ##
+        # Returns the main handle of this View.
+        # The main handle is the one that this View parent add as its child.
+        # Also, it is the handle that receives the style props and events by default.
+        #
+        def main_handle()
+            @main_handle
+        end
+
+        # Styling
+
+        ##
+        # Answer the styles accepted by this view.
+        #
+        def accepted_styles()
+            self.class.accepted_styles
+        end
+
+        ##
+        # Applies each prop in props to the actual GUI object.
+        #
+        def apply_props(props)
+            accepted_styles = self.accepted_styles
+
+            props.each_pair { |prop, value|
+                apply_prop(prop, value) if accepted_styles.include?(prop)
+            }
+        end
+
+        ##
+        # Apply the prop to the actual GUI object.
+        #
+        def apply_prop(prop, value)
+            setter = prop.to_s + '='
+
+            send(setter, value)
+        end
+
+        # Styles
+
+        def width=(value)
+            main_handle.width_request = value
+        end
+
+        def width()
+            main_handle.width_request
+        end
+
+        def height=(value)
+            main_handle.height_request = value
+        end
+
+        def height()
+            main_handle.height_request
+        end
+
+        def background_color=(value)
+            state_colors_from(value).each_pair do |state, value|
+                next if value.nil?
+
+                main_handle.override_background_color( state, Gdk::RGBA.parse(value) )
+            end
+        end
+
+        def foreground_color=(value, state: :normal)
+            state_colors_from(value).each_pair do |state, value|
+                next if value.nil?
+
+                main_handle.override_color( state, Gdk::RGBA.parse(value) )
+            end
+        end
+
+        def state_colors_from(value)
+            colors = Hash[
+                normal: nil,
+                active: nil,
+                prelight: nil,
+                selected: nil,
+                insensitive: nil,
+            ]
+
+            if value.kind_of?(Hash)
+                value.each_pair do |state, value|
+                    colors[state] = value
+                end
+            else
+                colors[:normal] = value
+            end
+
+            colors
+        end
+
+        # Showing/hiding
+
+        ##
+        # Makes this component visible.
+        #
+        def show()
+            main_handle.show_all
+        end
+
+        # Child views
+
+        ##
+        # Adds a child_view.
+        #
+        def add_view(child_view)
+            main_handle.add(child_view.main_handle)
+        end
+
+        ##
+        # Removes a child view.
+        #
+        def remove_view(child_view)
+            main_handle.remove(child_view.main_handle)
+        end
+
+        # Popup menu
+
+        def populate_popup_menu_block=(populate_popup_menu_block)
+            @populate_popup_menu_block = populate_popup_menu_block
+        end
+
+        ##
+        # Create and show a popup menu
+        #
+        def show_popup_menu(props)
+            menu = MenuView.new
+
+            @populate_popup_menu_block.call(menu: menu)
+
+            menu.open(props) unless menu.empty?
+        end
+    end
+end

data/lib/views/window_view.rb

@@ -0,0 +1,51 @@
+module Sirens
+    class WindowView < View
+
+        # Class methods
+
+        class << self
+            ##
+            # Answer the styles accepted by this view.
+            #
+            def view_accepted_styles()
+                super() + [:title].freeze
+            end
+        end
+
+        # Initializing
+
+        def initialize_handles()
+            @main_handle = Gtk::Window.new()
+
+            Sirens.register_window
+        end
+
+        def subscribe_to_ui_events()
+            main_handle.signal_connect("delete_event") {
+                false
+            }
+
+            main_handle.signal_connect("destroy") {
+              Sirens.unregister_window
+            }
+        end
+
+        # Styles
+
+        def width=(value)
+            main_handle.default_width = value
+        end
+
+        def height=(value)
+            main_handle.default_height = value
+        end
+
+        def title=(value)
+            main_handle.title = value
+        end
+
+        def title()
+            main_handle.title
+        end
+    end
+end