rui 0.1.0

data/.document

@@ -0,0 +1,4 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature

data/COPYING

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem "builder"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "yard", "~> 0.6.0"
+  gem "bluecloth"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.1"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,24 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    bluecloth (2.0.9)
+    builder (3.0.0)
+    git (1.2.5)
+    jeweler (1.5.1)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    yard (0.6.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bluecloth
+  builder
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.1)
+  rcov
+  yard (~> 0.6.0)

data/README.md

@@ -0,0 +1,8 @@
+# rui
+
+GUI abstraction library for ruby.
+
+## Supported backends
+
+* Qt
+* KDE

data/Rakefile

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "rui"
+  gem.homepage = "http://github.com/pcapriotti/rui"
+  gem.license = "LGPL"
+  gem.description = %q{GUI abstraction library supporting Qt and KDE backends}
+  gem.summary = %q{GUI abstraction library}
+  gem.email = "p.capriotti@gmail.com"
+  gem.authors = ["Paolo Capriotti"]
+  gem.rubyforge_project = "nowarning"
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/examples/autogui/main.rb

@@ -0,0 +1,12 @@
+require 'rui'
+
+RUI::Application.init('autogui') do |app|
+  widget = Qt::Widget.new
+  widget.gui = RUI::autogui do
+    layout(:type => :vertical) do
+      button(:name => :quit, :text => "Quit")
+    end
+  end
+  widget.quit.on(:clicked) { app.exit }
+  widget.show
+end

data/examples/hello/main.rb

@@ -0,0 +1,13 @@
+# Copyright (c) 2010 Paolo Capriotti <p.capriotti@gmail.com>
+# 
+# This library 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 3 of the
+# License, or (at your option) any later version.
+
+require 'rui'
+
+RUI::Application.init('hello') do
+  RUI::PushButton.new("Hello").show
+end
+

data/examples/kderun.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/ruby
+$:.unshift('lib')
+$toolkit = :kde
+load "examples/#{ARGV.shift}/main.rb"

data/examples/qtrun.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/ruby
+$:.unshift('lib')
+$toolkit = :qt
+load "examples/#{ARGV[0]}/main.rb"

data/examples/signals/main.rb

@@ -0,0 +1,15 @@
+# Copyright (c) 2010 Paolo Capriotti <p.capriotti@gmail.com>
+# 
+# This library 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 3 of the
+# License, or (at your option) any later version.
+
+require 'rui'
+
+RUI::Application.init('signals') do |app|
+  button = RUI::PushButton.new("Quit")
+  button.on(:clicked) { app.exit }
+  button.show
+end
+

data/lib/rui/descriptor.rb

@@ -0,0 +1,241 @@
+# Copyright (c) 2009 Paolo Capriotti <p.capriotti@gmail.com>
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+
+#
+# A <b>descriptor</b> is a rose tree with arbitrary properties at each node, used to
+# define GUIs declaratively.
+#
+# Descriptors can be created using a DSL. For example:
+#
+#   ex1 = Descriptor.build(:root, :name => 'parent') do
+#     child :name => 'foo'
+#     child :name => 'bar'
+#     merge_point
+#     child :name => 'hello' do
+#       grandchild :name => 'world'
+#     end
+#   end
+#
+# creates a tree which has a node with no name and three children with names
+# 'foo', 'bar', and 'hello', and hello having a child of its own, called
+# 'world'. Note that <b>descriptor tags</b> (<tt>:root</tt>, <tt>:child</tt> and
+# <tt>:grandchild</tt> in the example) are completely arbitrary, but they play
+# a special role when merging, together with the <tt>:name</tt> property.
+#
+# <b>Merging</b> consists of taking two descriptor trees, and matching their roots by
+# tag and name. If they match, their children are recursively matched and
+# merged, or simply concatenated when no match is found.
+#
+# For example, if <tt>ex1</tt> above is merged with the following descriptor:
+#
+#   ex2 = Descriptor.build(:root, :name => 'parent') do
+#     child :name => 'foo2'
+#     child :name => 'hello' do
+#       grandchild :name => 'world2'
+#     end
+#   end
+#
+# the resulting descriptor would be equivalent to the one created by:
+#
+#   ex1_merged_with_ex2 = Descriptor.build(:root, :name => 'parent') do
+#     child :name => 'foo'
+#     child :name => 'bar'
+#     child :name => 'foo2'
+#     child :name => 'hello' do
+#       grandchild :name => 'world'
+#       grandchild :name => 'world2'
+#     end
+#   end
+#
+# As can be seen in the example, <b>merge points</b> can be used to specify exactly
+# where children of merged descriptors should be inserted.
+#
+# Merge points can optionally have a <tt>count</tt>, which specifies the number
+# of children to be inserted on that particular point. When the count is
+# satisfied, additional children are added at the following merge point, or, if
+# no more merge points exist, at the bottom.
+#
+class Descriptor
+  attr_reader :tag # @return [Symbol] the descriptor tag
+  attr_reader :opts # @return [Hash] properties for this descriptor
+  attr_reader :children # @return [Array] children of this descriptor
+
+  #
+  # Create a descriptor using the DSL.
+  # @param tag [Symbol] descriptor tag
+  # @param opts [Hash] arbitrary hash of properties
+  # @return [Descriptor]
+  #
+  def self.build(tag, opts = { }, &blk)
+    root = new(tag, opts)
+    builder = Builder.new(root)
+    builder.instance_eval(&blk) if block_given?
+    root
+  end
+  
+  #
+  # Create a descriptor with no children.
+  # @param tag [Symbol] descriptor tag
+  # @param opts [Hash] arbitrary hash of properties
+  #
+  def initialize(tag, opts = { })
+    @tag = tag
+    @opts = opts
+    @children = []
+  end
+  
+  #
+  # Add a child to this descriptor.
+  #
+  def add_child(desc)
+    @children << desc
+  end
+  
+  #
+  # Add a child to this descriptor, taking merge points into account.
+  #
+  def merge_child(desc)
+    mp = @opts[:merge_points].first if @opts[:merge_points]
+    if mp
+      @children.insert(mp.position, desc)
+      @opts[:merge_points].step!
+    else
+      add_child(desc)
+    end
+  end
+
+  #
+  # Add a merge point to this descriptor. Newly added merge points will not
+  # affect existing children, even if they were added with <tt>merge_child</tt>
+  # @param position merge point position
+  # @param count maximum number of children that can be merged at this point.
+  #   If negative, no limit on the number of mergeable children is set.
+  #
+  def add_merge_point(position, count = -1)
+    mp = MergePoint.new(position, count)
+    @opts[:merge_points] ||= MergePoint::List.new
+    @opts[:merge_points].add(mp)
+    mp
+  end
+  
+  #
+  # Convert this descriptor to a human readable sexp representation. Descriptor
+  # properties are printed as ruby hashes.
+  #
+  def to_sexp
+    "(#{@tag} #{@opts.inspect}#{@children.map{|c| ' ' + c.to_sexp}.join})"
+  end
+  
+  #
+  # Destructively merge this descriptor with another.
+  #
+  # Descriptors are merged if they match by tag and name, or if this descriptor
+  # has tag <tt>:group</tt> and the other one has a property <tt>:group</tt>
+  # set to the name of this descriptor.
+  #
+  # @param other the descriptor to be merged
+  # @return [Boolean] whether the merge was successful
+  #
+  def merge!(other)
+    if tag == other.tag and
+        opts[:name] == other.opts[:name]
+      # if roots match
+      other.children.each do |child2|
+        # merge each of the children of the second descriptor
+        merged = false
+        children.each do |child|
+          # try to match with any of the children of the first descriptor
+          if child.merge!(child2)
+            merged = true
+            break
+          end
+        end
+        # if no match is found, just add it as a child of the root
+        merge_child(child2.dup) unless merged
+      end
+      true
+    elsif tag == :group and other.opts[:group] == opts[:name]
+      # if the root is the group of the second descriptor, add it as a child
+      merge_child(other)
+    else
+      false
+    end
+  end
+  
+  class MergePoint
+    attr_accessor :position, :count
+    
+    class List
+      def initialize
+        @mps = []
+      end
+      
+      def first
+        @mps.first
+      end
+      
+      def add(mp)
+        @mps << mp
+      end
+      
+      def step!
+        raise "Stepping invalid merge point list" if @mps.empty?
+        @mps.each do |mp|
+          mp.position += 1
+        end
+        @mps.first.count -= 1
+        clean!
+      end
+      
+      private
+      
+      def clean!
+        @mps.delete_if {|mp| not mp.valid? }
+      end
+    end
+    
+    def initialize(position, count = -1)
+      @position = position
+      @count = count
+      raise "Creating invalid merge point" if @count == 0
+    end
+    
+    def valid?
+      @count != 0
+    end
+  end
+  
+  class Builder
+    attr_reader :__desc__
+    private :__desc__
+    
+    def initialize(desc)
+      @__desc__ = desc
+    end
+    
+    def method_missing(name, *args, &blk)
+      opts = if args.empty?
+        { }
+      elsif args.size == 1
+        if args.first.is_a? Hash
+          args.first
+        else
+          { :name => args.first }
+        end
+      else
+        args[-1].merge(:name => args.first)
+      end
+      child = Descriptor.new(name, opts)
+      self.class.new(child).instance_eval(&blk) if block_given?
+      __desc__.add_child(child)
+    end
+    
+    def merge_point(count = -1)
+      @__desc__.add_merge_point(@__desc__.children.size, count)
+    end
+  end
+end

data/lib/rui/factory.rb

@@ -0,0 +1,84 @@
+# Copyright (c) 2009 Paolo Capriotti <p.capriotti@gmail.com>
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+
+class Proc
+  #
+  # Bind this Proc to an object.
+  #
+  def bind(object)
+    block, time = self, Time.now
+    (class << object; self end).class_eval do
+      method_name = "__bind_#{time.to_i}_#{time.usec}"
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
+      method
+    end.bind(object)
+  end
+end
+
+#
+# A Factory is a wrapper around a Proc that exposes it through its {Factory#new
+# new} method.
+#
+# Wrapping a Proc in a Factory is useful to have a uniform API across classes
+# and custom object-creating lambdas. For instance, if a method create_object
+# takes a class as argument, like:
+#
+#   def create_object(klass)
+#     obj = klass.new('foo')
+#     # do something with obj
+#     obj
+#   end
+#
+# you can pass modified class constructors:
+#
+#   create_object(Factory.new {|arg| Array.new(4) { arg } })
+#
+# and have the method behave as if the passed argument were a normal class.
+#
+class Factory
+  #
+  # A Factory can specify a <b>component</b>, which is the class used to
+  # instantiate the objects created by this Factory.
+  #
+  # When non-nil, it should satisfy <tt>component == new(*args).class</tt>.
+  #
+  # @return the component of this Factory
+  #
+  attr_reader :component
+
+  #
+  # Create a factory object.
+  #
+  # @param component[Class] the factory component
+  # @param &blk the wrapped Proc
+  #
+  def initialize(component = nil, &blk)
+    @blk = blk
+    @component = component
+  end
+  
+  #
+  # Call the wrapped Proc
+  #
+  def new(*args)
+    @blk[*args]
+  end
+  
+  #
+  # Rebind this Factory.
+  #
+  # Binding a Factory to an object causes the wrapped Proc to be executed in
+  # the given object's scope.
+  #
+  # @param object the object to bind this Factory to
+  #
+  def __bind__(object)
+    Factory.new(@component, &@blk.bind(object))
+  end
+end