interphase 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 601ea62e61b89deb55c6ff518e6d8340dc6c6c73
+  data.tar.gz: 2f3c770ff1b03e94ed2f54b9ccb2bf804d7215a4
+SHA512:
+  metadata.gz: 2feefd55a3a5186c6a091479faed94f32fc313480f47ed50ccfd1239e400a57e8ef78e750243bbf458ffe90e92b6d89b4330e854d9db951506652c1382e476f9
+  data.tar.gz: bb4b30b3de6fdf7d45b3e30a383ffad570f6862f0a66d1d0cf133e761ae6f380b6faf9fd47aed4bb1f467254d7b6dff8e5dbfab3ed6b1e09fcba63eb3b7d3e69

data/lib/interphase.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'interphase/helpers/observable'
+
+require 'interphase/widgets/basic_widgets'
+require 'interphase/widgets/window'
+require 'interphase/widgets/label'
+require 'interphase/widgets/box'
+require 'interphase/widgets/status_bar'
+require 'interphase/widgets/list_view'
+require 'interphase/widgets/simple_list_view'
+require 'interphase/widgets/fixed'
+require 'interphase/widgets/dialog'
+require 'interphase/widgets/button'

data/lib/interphase/helpers/observable.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Interphase
+  module Helpers
+    # An object wrapper which can invoke a method whenever the wrapped object
+    # changes.
+    # Unlike most classes, this class inherits from `BasicObject`, which has
+    # absolutely no methods whatsoever. This means that everything, even
+    # +inspect+ and +class+, fall into +Observable#method_missing+.
+    class Observable < BasicObject
+      # Wrap an object in a new instance of +Observable+.
+      # Takes a block which executes upon the object changing. This block is
+      # passed +object+ as a paremeter.
+      # +object+:: The object to wrap.
+      def initialize(object, &block)
+        # :: is required because we inherit BasicObject, not Object
+        ::Kernal.raise ::ArgumentError, 'Requires a block' if block.nil?
+
+        @object = object
+        @on_change = block
+      end
+
+      # TODO responds_to?
+      def method_missing(name, *args, &block)
+        if @object.respond_to?(name)
+          before_hash = @object.hash
+          ret_val = @object.send(name, *args, &block)
+          after_hash = @object.hash
+
+          @on_change.call(@object) if before_hash != after_hash
+
+          ret_val
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(*)
+        true
+      end
+    end
+  end
+end

data/lib/interphase/widgets/basic_widgets.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'gtk2'
+
+module Interphase
+  # A basic GTK widget wrapper.
+  class Widget
+    attr_accessor :gtk_instance, :parent, :name
+
+    # Creates a new widget.
+    # +gtk_instance+:: The GTK widget instance this is wrapping.
+    # +name:+:: This widgets name, allowing it to be referred to after being
+    #           created.
+    def initialize(gtk_instance, **options, &block)
+      @gtk_instance = gtk_instance
+      @parent = nil
+      @name = options[:name]
+
+      instance_eval(&block) if block_given?
+    end
+
+    # Requests that this widget is resized. Note that this is a method, rather
+    # than a 'size=' setter, because the request is not guaranteed, and indeed
+    # in many cases will not. Only some containers allow their child widgets
+    # to be resized.
+    def size(width, height)
+      gtk_instance.set_size_request(width, height)
+    end
+
+    # Shows this widget.
+    def show
+      gtk_instance.show
+    end
+
+    # Associates a block with a signal. The block is invoked whenever the
+    # signal occurs.
+    # +name+:: The name of the signal.
+    def on(name, &block)
+      gtk_instance.signal_connect(name, &block)
+    end
+
+    # Destroy this widget.
+    def destroy
+      gtk_instance.destroy
+    end
+
+    # Respond to lookups by name.
+    # TODO IMPLEMENT RESPONDS_TO
+    def method_missing(requested, *args, &block)
+      # If any arguments or a block have been given, then this isn't an attr
+      if !args.empty? || block_given?
+        super
+        return
+      end
+
+      return self if requested.to_s == name
+
+      super
+    end
+
+    def respond_to_missing?
+      true
+    end
+  end
+
+  # A widget which may contain other widgets.
+  class Container < Widget
+    attr_accessor :children
+
+    # Add a widget as a child of this one.
+    # Accepts a block which is executed on the child.
+    # +child+:: The new child widget.
+    # +should_add+:: (Optional) Whether to actually add the element, or just to 
+    #                register it as added by adding it to +children+. You
+    #                probably shouldn't change this.
+    def add(child, should_add = true, &block)
+      child.instance_eval(&block) if block_given?
+
+      raise 'Widget already has a parent' unless child.parent.nil?
+
+      gtk_instance.add(child.gtk_instance) if should_add
+      child.parent = self
+
+      # Ensure a children array exists, and add the new child to it
+      @children ||= []
+      children << child
+    end
+
+    # Show this widget and all of its children.
+    def show_all
+      gtk_instance.show_all
+    end
+
+    # Allows child named widgets to be looked up like an attribute.
+    # TODO IMPLEMENT RESPONDS_TO
+    def method_missing(requested, *args, &block)
+      (children || []).each do |child|
+        # An exception simply means that wasn't the child we were looking for
+        begin
+          return child.send(requested)
+        rescue StandardError
+          next
+        end
+      end
+
+      super
+    end
+
+    def respond_to_missing?(*)
+      true
+    end
+  end
+end

data/lib/interphase/widgets/box.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'gtk2'
+
+module Interphase
+  # A simple item container. You should use +VBox+ or +HBox+ rather than this.
+  class Box < Container
+    PACK_START = 0
+    PACK_END = 1
+
+    # Add a widget to the box, after all others added at the same reference.
+    # Accepts a block which is executed on the child.
+    # +child+:: The new child widget.
+    # +expand+:: (Optional) Allocate extra space to this widget, default +true+.
+    # +fill+:: (Optional) Allocate to the full width/height of the box, default
+    #          +true+.
+    # +padding+:: (Optional) Any padding to allocate to this widget, default 0.
+    # +ref+:: (Optional) The reference at which to add the widget. Either
+    #         +PACK_START+ (default) or +PACK_END+.
+    def add(child, expand = true, fill = true, padding = 0, ref = PACK_START, &block)
+      super(child, false, &block)
+
+      if ref == PACK_START
+        gtk_instance.pack_start(child.gtk_instance, expand, fill, padding)
+      elsif ref == PACK_END
+        gtk_instance.pack_end(child.gtk_instance, expand, fill, padding)
+      else
+        raise 'ref should be either PACK_START or PACK_END'
+      end
+    end
+  end
+
+  # A vertical item container.
+  class VBox < Box
+    # Creates a new vertical box.
+    def initialize(**options, &block)
+      super(Gtk::VBox.new, options, &block)
+    end
+  end
+
+  # A horizontal item container.
+  class HBox < Box
+    # Creates a new horizontal box.
+    def initialize(**options, &block)
+      super(Gtk::HBox.new, options, &block)
+    end
+  end
+end

data/lib/interphase/widgets/button.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'gtk2'
+
+module Interphase
+  # A button which can perform an action upon being clicked.
+  class Button < Widget
+    # Create a new button.
+    # +label+:: The text to display on the button.
+    def initialize(label = '', **options, &block)
+      super(Gtk::Button.new(label), **options, &block)
+    end
+
+    # Get the button's label text.
+    def label
+      gtk_instance.label
+    end
+
+    # Set the button's label text.
+    def label=(value)
+      gtk_instance.label = value
+    end
+
+    # Register a block to execute upon clicking the button.
+    def on_click(&block)
+      on('clicked', &block)
+    end
+
+    # Clicks the button, executing any blocks added using +#on_click+.
+    def click
+      gtk_instance.clicked
+    end
+  end
+end

data/lib/interphase/widgets/dialog.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'gtk2'
+
+module Interphase
+  # A base class representing a simple, blank dialog box.
+  class Dialog < Widget
+    # Construct a new blank dialog box.
+    def initialize(instance = nil, **options, &block)
+      super(instance || Gtk::Dialog.new, **options, &block)
+
+      options['buttons']&.map { |btn| add_button(*btn) }
+    end
+
+    # Converts an +#add_button+ +action+ symbol to the GTK RESPONSE integer
+    # which it represents.
+    # +action+:: The action symbol to convert. Should be one of the valid
+    #            values of +action+ to +#add_button+.
+    def action_to_integer(action)
+      valid_actions =
+        %i[none reject accept delete ok cancel close yes no apply help]
+
+      throw ArgumentError, 'Invalid button action' \
+        unless valid_actions.include? action
+
+      # Map :delete to its GTK equivalent
+      action = :delete_event if action == :delete
+
+      Gtk::Dialog.const_get("RESPONSE_#{action.to_s.upcase}")
+    end
+
+    # Adds a button to the dialog box.
+    # +text+:: The text to display on the button.
+    # +action+:: The action which occurs when this button is clicked. Must be
+    #            one of: +:none+, +:reject+, +:accept+, +:delete+, +:ok+,
+    #            +:cancel+, +:close+, +:yes+, +:no+, +:apply+, +:help+.
+    def add_button(text, action)
+      gtk_instance.add_button(text, action_to_integer(action))
+      nil
+    end
+
+    # Run this dialog box. This call will block execution until the dialog is
+    # closed. Consider using +Window#in_background+ if blocking is not desired.
+    # You should usually call +destroy+ after this method, otherwise the dialog
+    # will remain even after selecting an option.
+    def run
+      gtk_instance.run
+    end
+  end
+
+  # A message dialog which displays text and some buttons.
+  class MessageDialog < Dialog
+    # Create a new message dialog.
+    # +message+:: The message which the dialog displays.
+    def initialize(message, **options, &block)
+      super(
+        Gtk::MessageDialog.new(
+          nil,
+          0,
+          Gtk::MessageDialog::OTHER,
+          Gtk::MessageDialog::BUTTONS_NONE,
+          message
+        ),
+        options, &block
+      )
+    end
+
+    # A helper method which creates a new +MessageDialog+, adds an OK button, 
+    # displays it, blocks until 'OK' is clicked, then destroys it.
+    # +message+:: The message which the dialog displays.
+    def self.show(message)
+      dialog = MessageDialog.new(message)
+      dialog.add_button('OK', :ok)
+      dialog.run
+      dialog.destroy
+    end
+  end
+end

data/lib/interphase/widgets/fixed.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'gtk2'
+
+module Interphase
+  # A container in which items can be placed in a specific x/y location.
+  class Fixed < Container
+    # Construct a new fixed container.
+    def initialize(**options, &block)
+      super(Gtk::Fixed.new, **options, &block)
+    end
+
+    # Add a child widget to this +Fixed+ at a location.
+    # +child+:: The new child widget.
+    # +x_pos+:: The x position.
+    # +y_pos+:: The y position.
+    def add(child, x_pos, y_pos, &block)
+      gtk_instance.put(child.gtk_instance, x_pos, y_pos)
+
+      super(child, false, &block)
+    end
+  end
+end

data/lib/interphase/widgets/label.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'gtk2'
+
+module Interphase
+  # A text label.
+  class Label < Widget
+    # Creates a new label.
+    def initialize(text = '', **options, &block)
+      super(Gtk::Label.new(text), options, &block)
+    end
+
+    # Set the text in this label.
+    def text=(value)
+      gtk_instance.text = value
+    end
+
+    # Retrieve the label's text.
+    def text
+      gtk_instance.text
+    end
+  end
+end

data/lib/interphase/widgets/list_view.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'gtk2'
+require 'interphase/helpers/observable'
+
+module Interphase
+  # A list view which can be populated with objects.
+  class ListView < Widget
+    attr_reader :rows
+
+    # Create a new list view.
+    # +columns+:: The columns which this list view has, as an +Array+ of
+    #             +String+ objects.
+    def initialize(columns, **options, &block)
+      @store = Gtk::ListStore.new(*[String] * columns.length)
+
+      super(Gtk::TreeView.new(@store), options, &block)
+
+      # Init columns
+      columns.each_with_index do |col, index|
+        renderer = Gtk::CellRendererText.new
+        new_col = Gtk::TreeViewColumn.new(col[0], renderer, text: index)
+        gtk_instance.append_column(new_col)
+      end
+
+      @rows = Interphase::Helpers::Observable.new([]) { refresh_rows }
+
+      refresh_rows
+    end
+
+    # Refreshes the contents of the list view according to its rows. This is
+    # called automatically upon mutating #rows.
+    def refresh_rows
+      @store.clear
+
+      # Insert the rows
+      @rows.each do |data_row|
+        store_row = @store.append
+
+        # Basically a memcpy
+        data_row.each_with_index do |item, index|
+          store_row[index] = item
+        end
+      end
+    end
+  end
+end

data/lib/interphase/widgets/simple_list_view.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'gtk2'
+require 'interphase/helpers/observable'
+
+module Interphase
+  # A simple list view which displays an +Array+.
+  class SimpleListView < ListView
+    attr_reader :items
+
+    def initialize(items = [], **options, &block)
+      super(['Column'], options, &block)
+
+      gtk_instance.headers_visible = false
+
+      @items = Interphase::Helpers::Observable.new(items) do
+        refresh_items
+      end
+
+      refresh_items
+    end
+
+    # Copies #items into #rows, where each item is one row.
+    def refresh_items
+      items.each do |item|
+        rows << [item]
+      end
+    end
+  end
+end

data/lib/interphase/widgets/status_bar.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'gtk2'
+
+module Interphase
+  # Provides a simple status bar which can display a single message.
+  class SimpleStatusBar < Widget
+    attr_reader :text
+
+    # Create a new simple status bar.
+    def initialize(**options, &block)
+      super(Gtk::Statusbar.new, options, &block)
+    end
+
+    # Sets the text displayed in the status bar.
+    def text=(value)
+      # Value is frozen to prevent modification without updating the text on the
+      # widget (i.e. mutation must be through this method)
+      @text = value.clone.freeze
+
+      begin
+        gtk_instance.pop(1)
+      rescue StandardError # rubocop:disable Lint/HandleExceptions
+        # It doesn't matter; just means that there was no text previously
+      end
+
+      gtk_instance.push(1, text)
+    end
+  end
+end

data/lib/interphase/widgets/window.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'gtk2'
+
+module Interphase
+  # An application window.
+  class Window < Container
+    # Creates a new window.
+    def initialize(title, **options, &block)
+      super(Gtk::Window.new(title), options, &block)
+    end
+
+    # The given block will trigger when this window is closed.
+    def on_delete(&block)
+      on('delete-event', &block)
+    end
+
+    # Registers an #on_delete block which calls #quit.
+    def quit_on_delete!
+      on_delete do
+        quit
+      end
+    end
+
+    # Runs the entire Interphase application.
+    def run
+      Gtk.main
+    end
+
+    # Quits the entire Interphase application, killing all its threads.
+    def quit
+      @threads&.each(&:kill)
+      Gtk.main_quit
+    end
+
+    # Force-quits the entire Interphase application, including the Ruby Kernel.
+    # If your GUI quits but your terminal stays occupied after #quit, this will
+    # probably solve that issue.
+    # Having to use this is usually the sign of a badly-written program!
+    def quit!
+      @threads&.each(&:kill)
+      Gtk.main_quit
+      exit!
+    end
+
+    # Binds a block to run as a +Thread+; it begins executing immediately.
+    # Destroying the window kills all threads.
+    # TOOD DOES IT?
+    def in_background(&block)
+      @threads ||= []
+      thread = Thread.new(&block)
+      thread.abort_on_exception = true
+      @threads << thread
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: interphase
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Aaron Christiansen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gtk2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: 
+email: aaronc20000@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/interphase.rb
+- lib/interphase/helpers/observable.rb
+- lib/interphase/widgets/basic_widgets.rb
+- lib/interphase/widgets/box.rb
+- lib/interphase/widgets/button.rb
+- lib/interphase/widgets/dialog.rb
+- lib/interphase/widgets/fixed.rb
+- lib/interphase/widgets/label.rb
+- lib/interphase/widgets/list_view.rb
+- lib/interphase/widgets/simple_list_view.rb
+- lib/interphase/widgets/status_bar.rb
+- lib/interphase/widgets/window.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: A powerful, easy-to-use, native-looking GUI library
+test_files: []