mittens_ui 0.0.7 → 0.0.11

data/lib/mittens_ui/hbox.rb

@@ -0,0 +1,56 @@
+require "mittens_ui/helpers"
+
+module MittensUi
+  class HBox      
+    include Helpers
+
+    def initialize(widgets, options={})
+      box_spacing = options[:spacing].nil? ? 6 : options[:spacing]
+      
+      @box = Gtk::Box.new(:horizontal, box_spacing)
+
+      set_margin_from_opts_for(@box, options)
+      
+      widgets.each do |w| 
+        # We need to remove the widget from the global $vertical_box before hand
+        # otherwise it won't render the widgets properly since they are already in another container.
+        w.remove
+        self.attach(w.core_widget, { position: :start }) 
+      end
+    end
+
+    def remove
+      return if @box.nil?
+      @box.destroy
+    end
+
+    def render
+      $vertical_box.pack_start(@box)
+      return self
+    end
+
+    private
+
+    def attach(widget, options={})
+      expand  = options[:expand].nil?   ? true : options[:expand]
+      fill    = options[:fill].nil?     ? true : options[:fill]
+      padding = options[:padding].nil?  ? 0    : options[:padding]
+
+      filterd_options = {
+        expaned: expand,
+        fill: fill,
+        padding: padding
+      }.freeze
+
+      case options.dig(:position)
+      when :start
+        @box.pack_start(widget, filterd_options)
+      when :end
+        @box.pack_end(widget, filterd_options)
+      when nil
+        @box.pack_start(widget, filterd_options)
+      end
+    end
+
+  end
+end

data/lib/mittens_ui/header_bar.rb

@@ -0,0 +1,46 @@
+require_relative "./core"
+
+module MittensUi
+  class HeaderBar < Core
+    def initialize(widgets, options = {})
+      title     = options[:title].nil? ? "" : options[:title]
+      position  = options[:position].nil? ? :left : options[:position]
+
+      box = Gtk::Box.new(:horizontal, 0)
+      box.style_context.add_class("linked")
+
+      @header = Gtk::HeaderBar.new
+      @header.show_close_button = true
+      @header.title = title
+      @header.has_subtitle = false
+
+      widgets.each do |w|
+        w.remove
+        case position
+        when :left
+          box.pack_start(w.core_widget)
+        when :right
+          box.pack_end(w.core_widget)
+        else
+          box.pack_start(w.core_widget)
+        end  
+      end
+
+      if position == :left 
+        @header.pack_start(box)
+      end
+
+      if position == :right
+        @header.pack_end(box)
+      end
+
+      super(@header, options)
+    end
+
+    def render
+      $app_window.titlebar = @header
+      return self
+    end
+
+  end
+end

data/lib/mittens_ui/helpers.rb

@@ -0,0 +1,41 @@
+module MittensUi
+  module Helpers
+    def icon_map
+      {
+        add:    "list-add-symbolic",
+        remove: "list-remove-symbolic",
+        add_green: 'add',
+        remove_red: 'remove'
+      }.freeze
+    end
+
+    def list_system_icons
+      @theme = Gtk::IconTheme.default
+      puts @theme.icons
+    end
+
+    def set_margin_from_opts_for(widget, options={})
+      margin_top    = options[:top].nil?    ? nil : options[:top]
+      margin_bottom = options[:bottom].nil? ? nil : options[:bottom]
+      margin_right  = options[:right].nil?  ? nil : options[:right]
+      margin_left   = options[:left].nil?   ? nil : options[:left]
+
+      unless margin_top.nil?
+        widget.set_margin_top(margin_top)
+      end
+
+      unless margin_bottom.nil?
+        widget.set_margin_bottom(margin_bottom)
+      end
+
+      unless margin_left.nil?
+        widget.set_margin_left(margin_left)
+      end
+
+      unless margin_right.nil?
+        widget.set_margin_right(margin_right)
+      end
+    end
+  end
+end
+

data/lib/mittens_ui/image.rb

@@ -0,0 +1,46 @@
+require_relative "./core"
+
+module MittensUi
+  class Image < Core
+    attr_reader :path
+
+    def initialize(path, options = {})
+      @path = File.join(path.strip)
+
+      tooltip_text = options[:tooltip_text].nil? ? "" : options[:tooltip_text]
+      width        = options[:width].nil?        ? 80 : options[:width]
+      height       = options[:height].nil?       ? 80 : options[:height]
+
+      pixbuf = nil
+
+      args_to_send = {}
+
+      if path.include?(".gif")
+        pixbuf = GdkPixbuf::PixbufAnimation.new(@path)
+        args_to_send[:animation] = pixbuf
+      else
+        pixbuf = GdkPixbuf::Pixbuf.new(file: @path, width: width, height: height)
+        args_to_send[:pixbuf] = pixbuf
+      end
+      
+      @image = Gtk::Image.new(args_to_send)
+      @image.tooltip_text = tooltip_text
+
+      @event_box = Gtk::EventBox.new.add_child(@image)
+
+      super(@image, options)
+    end
+
+    def click 
+      @event_box.signal_connect("button_press_event") do
+        yield
+      end    
+    end
+
+    def render
+      $vertical_box.pack_start(@event_box)
+      return self
+    end
+    
+  end
+end

data/lib/mittens_ui/label.rb

@@ -0,0 +1,19 @@
+require_relative "./core"
+
+module MittensUi
+  class Label < Core
+    def initialize(text, options)
+      if text.nil? || text == "" || text == " "
+        text = "Label"
+      end
+
+      @label = Gtk::Label.new(text)
+      super(@label, options)
+    end
+
+    def render
+      $vertical_box.pack_start(@label)
+      return self
+    end
+  end
+end

data/lib/mittens_ui/listbox.rb

@@ -0,0 +1,47 @@
+require_relative "./core"
+
+module MittensUi
+  class ListBox < Core   
+    attr_reader :items
+
+    def initialize(options={})
+      @items = options[:items]
+
+      list_store = Gtk::ListStore.new(String)
+
+      @items.each do |i|
+        iter = list_store.append
+        iter[0] = i
+      end
+
+      renderer = Gtk::CellRendererText.new
+
+      @gtk_combobox = Gtk::ComboBox.new(model: list_store)
+      @gtk_combobox.pack_start(renderer, true)
+      @gtk_combobox.set_attributes(renderer, "text" => 0)
+      @gtk_combobox.set_cell_data_func(renderer) do |_layout, _cell_renderer, _model, iter|
+        set_selected_value(iter[0])
+      end
+
+      @gtk_combobox.set_active(0)
+
+      super(@gtk_combobox)
+    end
+
+    def set_selected_value(value)
+      @selected_value = value
+    end
+    alias :set_value :set_selected_value
+
+    def get_selected_value
+      @selected_value
+    end
+    alias :selected_value :get_selected_value
+
+    def render
+      $vertical_box.pack_start(@gtk_combobox)
+      return self
+    end
+    
+  end
+end

data/lib/mittens_ui/loader.rb

@@ -0,0 +1,33 @@
+require_relative "./core"
+
+module MittensUi
+  class Loader < Core
+    def initialize(options={})
+      @spinner = Gtk::Spinner.new
+
+      @processing = false
+
+      super(@spinner, options)
+
+      self.hide
+    end
+
+    def start(&block)
+      return if @processing
+
+      return if @worker_thread && @worker_thread.alive?
+
+      self.show
+
+      @spinner.start
+
+      @worker_thread = Thread.new { yield; self.remove; @processing = true }
+    end
+
+    def render
+      $vertical_box.pack_end(@spinner)
+      return self
+    end
+
+  end
+end

data/lib/mittens_ui/notify.rb

@@ -0,0 +1,61 @@
+require_relative "./core"
+
+module MittensUi
+  class Notify < Core
+    def initialize(msg, options={})
+      @activate_timer = options[:timer] || true
+
+      @notify_bar = Gtk::InfoBar.new
+      
+      @notify_bar.set_show_close_button(true)
+
+      msg_label = Gtk::Label.new(msg)
+
+      @notify_bar.message_type = set_msg_type(options)
+      
+      @notify_bar.content_area.pack_start(msg_label)
+
+      setup_close_notification
+
+      super(@notify_bar, options)
+    end
+
+    def render
+      $vertical_box.pack_start(@notify_bar) unless $vertical_box.children.include?(@notify_bar)
+      $vertical_box.reorder_child(@notify_bar, 0)
+      
+      @notify_bar.show_all
+
+      trigger_notify_timer if @activate_timer
+     
+      return self
+    end
+
+    private
+    def set_msg_type(options={})
+      case options[:type]
+      when :question then Gtk::MessageType::QUESTION
+      when :error    then Gtk::MessageType::ERROR
+      when :info     then Gtk::MessageType::INFO
+      else                Gtk::MessageType::INFO
+      end
+    end
+
+    def trigger_notify_timer
+      Thread.new {
+        sleep 8
+
+        if @notify_bar.visible?
+          @notify_bar.hide
+        end
+      }
+    end
+
+    def setup_close_notification
+      @notify_bar.signal_connect("response") do |info_bar, response_id|
+        @notify_bar.hide if response_id == Gtk::ResponseType::CLOSE
+      end
+    end
+
+  end
+end

data/lib/mittens_ui/slider.rb

@@ -0,0 +1,32 @@
+require_relative "./core"
+
+module MittensUi
+  class Slider < Core
+    def initialize(options={})
+      start_value = options[:start_value].nil?    ? 1.0  : options[:start_value]
+      stop_value  = options[:stop_value].nil?     ? 10.0 : options[:stop_value]
+      step_value  = options[:step_value].nil?     ? 1.0  : options[:step_value]
+      init_value  = options[:initial_value].nil?  ? 1.0  : options[:initial_value]
+
+      @scale = Gtk::Scale.new(:horizontal, start_value, stop_value, step_value)
+      @scale.digits = 0
+      @scale.draw_value = true
+      @scale.value = init_value
+
+      super(@scale)
+    end
+
+    def move
+      @scale.signal_connect "value_changed" do |scale_widget|
+        yield(scale_widget)
+      end
+    end
+    alias :slide :move
+
+    def render
+      $vertical_box.pack_start(@scale)
+      return self
+    end
+    
+  end
+end

data/lib/mittens_ui/switch.rb

@@ -0,0 +1,36 @@
+require_relative "./core"
+
+module MittensUi
+  class Switch < Core
+    def initialize(options = {})
+      @switch = Gtk::Switch.new
+      @switch.set_active(false)
+
+      # We need a Grid within our global $vertical_box layout
+      # in order to make the Widget look good (meaning not overly streched).
+      @grid = Gtk::Grid.new
+      @grid.set_column_spacing(1)
+      @grid.set_row_spacing(1)
+      @grid.attach(@switch, 0, 0, 1, 1) 
+      
+      super(@switch, options)
+    end
+
+    def activate
+      @switch.signal_connect('notify::active') do |switch_widget|
+        switch_widget.active? ? switch_widget.set_active(true) : switch_widget.set_active(false)
+        yield
+      end
+    end
+    alias :on :activate
+
+    def render
+      $vertical_box.pack_start(@grid)
+      return self
+    end
+
+    def status
+      @switch.active? ? :on : :off
+    end
+  end
+end

data/lib/mittens_ui/table_view.rb

@@ -0,0 +1,179 @@
+require_relative "./core"
+
+module MittensUi
+  class TableView < Core
+
+    def initialize(options={})
+      headers = options[:headers] || []
+      data    = options[:data]    || []
+
+      unless is_data_valid?(headers, data)
+        exit 1
+      end
+
+      init_column_headers(headers)
+      
+      init_list_store
+ 
+      @scrolled_window = Gtk::ScrolledWindow.new
+      calc_min_height = (data.size ** 2 ) * 10
+      @scrolled_window.min_content_height = calc_min_height
+
+      @tree_view = Gtk::TreeView.new(@list_store)
+      @tree_view.selection.set_mode(:single)
+
+      @columns.each { |col| @tree_view.append_column(col) }
+      
+      init_sortable_columns
+      
+      init_data_rows(data)
+      
+      @scrolled_window.add(@tree_view)
+
+      super(@tree_view, options)
+    end
+    
+    def add(data, direction=:append)
+      return if data.size.zero?
+      
+      case direction
+      when :append
+        iter = @list_store.append
+      when :prepend
+        iter = @list_store.prepend
+      else
+        iter = @list_store.append
+      end
+        
+      data.each_with_index do |item, idx|
+        iter[idx] = item
+      end
+    end
+    
+    def clear
+      @list_store.clear
+    end
+
+    def render
+      $vertical_box.pack_start(@scrolled_window)
+      return self
+    end
+
+    def row_count
+      count = 0
+      @list_store.each { |item| count += 1 }
+
+      return count
+    end
+
+    def remove_selected
+      iter = @tree_view.selection.selected
+
+      values = []
+
+      if iter.nil?
+        return values
+      end
+      
+      @list_store.n_columns.times do |x| 
+        values << @list_store.get_value(iter, x)
+      end
+      
+      @list_store.remove(iter)
+      
+      return values
+    end
+    
+    def row_clicked
+      @tree_view.signal_connect("row-activated") do |tv, path, column|
+        row = tv.selection.selected
+
+        values = []
+
+        @list_store.n_columns.times { |x| values << row.get_value(x) if row }
+        
+        yield(values)
+      end
+    end
+
+    private
+
+    def is_data_valid?(headers, data)
+      column_size = headers.size
+
+      data_is_array    = data.class == Array
+      headers_is_array = headers.class == Array
+
+      valid = true
+
+      unless data_is_array
+        puts "=====[MittensUi: Critical Error]====="
+        puts "Incoming data must be an Array of Arrays: data = [ [el..], [el...] ]"
+        valid = false
+        return valid
+      end
+
+      unless headers_is_array
+        puts "=====[MittensUi: Critical Error]====="
+        puts "Incoming data must be an Array of Arrays: data = [ [el..], [el...] ]"
+        valid = false
+        return valid
+      end
+
+      data.each_with_index do |row, idx|
+        # Row data must be an Array.
+        # The size of the Row Array must match the size of the Header columns.
+        valid = (row.class == Array && column_size == row.size) ? true : false
+
+        unless valid
+          puts 
+          puts "=====[MittensUi: Critical Error]====="
+          puts "The length of your data(Row) must match the length of the headers."
+          puts "Failed at Row:  #{idx}"
+          puts "Row Length:     #{row.size} elements"
+          puts "Header Length   #{column_size} elements"
+          puts
+          return valid
+        end
+      end
+    end
+    
+    def init_sortable_columns
+      @columns.each_with_index do |col, idx|
+        col.sort_indicator = true
+        col.sort_column_id = idx
+        
+        col.signal_connect('clicked') do |w|
+          w.sort_order = w.sort_order == :ascending ? :descending : :ascending
+        end
+      end
+    end
+   
+    def init_list_store
+      types = []
+      @columns.size.times { types << String }
+      @list_store = Gtk::ListStore.new(*types)
+    end
+    
+    def init_data_rows(data)
+      data.each_with_index do |items_arr|
+        iter = @list_store.append
+        items_arr.each_with_index do |item, idx|
+          iter[idx] = item
+         end
+      end
+    end
+    
+    def init_column_headers(headers_list)
+      renderer = Gtk::CellRendererText.new
+      
+      @columns = []
+      
+      headers_list.each_with_index do |h, i|
+        next unless h.class == String
+        @columns << Gtk::TreeViewColumn.new(h, renderer, text: i)
+      end
+    end
+    
+  end
+end