gui 0.0.1.pre1

data/lib/gui/selector.rb

@@ -0,0 +1,66 @@
+#  Copyright 2014 Noel Cower
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+#  -----------------------------------------------------------------------------
+#
+#  selector.rb
+#    Selector chain class.
+
+
+module GUI
+
+class Selector
+
+  class << self
+    def view_matches_attr(view, name, value)
+      view.respond_to?(name) && view.__send__(name) == value
+    end
+
+    def build(selector_str)
+
+    end
+  end # singleton_class
+
+  # The next
+  attr_accessor :succ
+  # Array of proc/lambda objects that receive a view and return true if
+  # the view matches, otherwise nil/false
+  attr_accessor :attributes
+  attr_accessor :direct
+
+  def initialize
+    @succ = nil
+    @attributes = []
+    @direct = false
+  end
+
+  # Whether this selector matches a view.
+  def matches?(view)
+    attributes.empty? || attributes.all? { |sel_attr| sel_attr[view] }
+  end
+
+  def find_match(view)
+    # TODO: Grab leaves and test selectors in reverse order
+    further = direct ? nil : self
+    if matches?(view)
+      return view unless @succ
+      further = @succ
+    end
+
+    view.subviews.detect { |subview| further.find_match(subview) }
+  end
+
+end # Selector
+
+end # GUI

data/lib/gui/selector/checks.rb

@@ -0,0 +1,178 @@
+#  Copyright 2014 Noel Cower
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+#  -----------------------------------------------------------------------------
+#
+#  checks.rb
+#    Selector checks (class/tag/attribute)
+
+
+module GUI
+
+#
+# All selector checks (held by the attributes array of a selector) expect a
+# call(view) method to be implemented. This returns either true or false values,
+# though it's only necessary that they return things that evaluate to true or
+# false. It is possible, therefore, to hand-write all your selectors rather than
+# compiling them, which can be _much_ faster when performing lookups since
+# attribute checks don't have to depend on reducing something by sending
+# messages over and over.
+#
+# In practice, however, selectors are just slow in all my tests right now and I
+# need to rewrite them to test starting with leaf views anyway (this should
+# result in more specific matches and avoid recursive tests since it's then
+# possible to iterate down through parents and cut off if a minimum depth isn't
+# met [i.e., a selector with N views to match requires at least depth N, but
+# can match views across depths greater than N if it has indirect matches]).
+#
+
+
+class ViewTagCheck
+
+  def initialize(tagname)
+    @tagname = tagname
+  end
+
+  def call(view)
+    view.tag == tagname
+  end
+
+  alias_method :[], :call
+
+end # ViewTagCheck
+
+
+class ViewClassCheck
+
+  def initialize(classname)
+    @classnames =
+      case classname
+      when Array then classname.dup
+      when Symbol then [classname]
+      when String then [classname.to_sym]
+      else raise ArgumentError, "Invalid class name type: #{classname.class}"
+      end
+  end
+
+  def call(view)
+    klass = view.class
+    name = nil
+    while klass
+      name = ViewAttrCheck.extract_class_name(klass)
+      return true if @classnames.include?(name)
+      klass = klass.superclass
+    end
+    false
+  end
+
+  alias_method :[], :call
+
+end # ViewClassCheck
+
+
+class ViewAttrCheck
+
+  SCO_MARKER          = '::'
+  KEYPATH_SEPARATOR   = '.'
+
+  class << self
+    attr_accessor :__module_name_cache__
+
+    def extract_class_name(klass)
+      (__module_name_cache__ ||= {})[klass] ||= begin
+        # Cache classname symbols because string ops are slow
+        name = klass.name
+        sco_index = klass.rindex(SCO_MARKER)
+        if sco_index
+          klass.slice!(0 .. sco_index + 1)
+        end
+        name.to_sym
+      end
+    end
+  end # singleton_class
+
+  def initialize(key, operator, operand)
+    @key = key.split(KEYPATH_SEPARATOR).map!(&:to_sym)
+    @operator = operator
+    @operand = operand
+    @is_string = @operand.kind_of?(String)
+  end
+
+  # NOTE: Deprecate and remove class checks for ViewAttrCheck? Might be a good
+  # idea, but it sort of remains since it's occasionally handy to do something
+  # like [content_view.class = Something]. Probably just going to remove this,
+  # though.
+  def class_check(klass)
+    # Cache Symbol for operand so I'm not converting it every time.
+    name = (@operand_sym ||= @operand.to_sym)
+
+    while klass
+      case @operator
+      when :equal
+        return true if self.class.extract_class_name(klass) == name
+      when :not_equal
+        return true unless self.class.extract_class_name(klass) == name
+      when :trueish # Necessarily true for classes.
+        true
+      else # Otherwise no test passes.
+        false
+      end
+      klass = klass.superclass
+    end
+    false
+  end
+
+  def call(view)
+    view_value = @key.reduce(view) { |value, msg| value.__send__(msg) }
+
+    if @is_string && !view_value.kind_of?(String)
+      view_value =
+        case view_value
+        when Class then return class_check(view_value) # return early
+        when Module then extract_class_name(view_value)
+        when Enumerable then
+          # There is a case here where doing something like
+          # `included_modules <- X` will fail because the values contained by
+          # the Enumerable are modules but the check won't know, so it'll just
+          # always fail. Thought about working around this by mapping modules
+          # to their extracted names, but decided I'll only do that if it turns
+          # out to be a problem.
+          return false unless @operator == :contains
+          view_value
+        else view_value.to_s
+        end
+    end
+
+    case operator
+    when :trueish       then !!view_value
+    when :falseish      then !view_value
+    when :equal         then view_value == @operand
+    when :not_equal     then view_value != @operand
+    when :greater       then view_value >  @operand
+    when :greater_equal then view_value >= @operand
+    when :lesser        then view_value <  @operand
+    when :lesser_equal  then view_value <= @operand
+    when :contains
+      view_value.respond_to?(:include?) && view_value.include?(@operand)
+    else
+      raise SelectorError, "Invalid operator for ViewAttrCheck: #{operator}"
+    end
+  end
+
+  alias_method :[], :call
+
+end # ViewAttrCheck
+
+end # GUI
+

data/lib/gui/texture.rb

@@ -0,0 +1,103 @@
+#  Copyright 2014 Noel Cower
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+#  -----------------------------------------------------------------------------
+#
+#  texture.rb
+#    Wrapper around GL texture names.
+
+
+require 'stb-image'
+require 'snow-data'
+
+
+module GUI
+
+class Texture
+
+  TextureName = Snow::CStruct.new { uint32_t :name }
+
+  LOAD_TEXTURE_BLOCK = -> (data, x, y, components) do
+    internalFormat =
+      case components
+      when STBI::COMPONENTS_GREY        then Gl::GL_RED
+      when STBI::COMPONENTS_GREY_ALPHA  then Gl::GL_RG
+      when STBI::COMPONENTS_RGB         then Gl::GL_RGB
+      when STBI::COMPONENTS_RGB_ALPHA   then Gl::GL_RGBA
+      else raise ArgumentError, "Invalid number of texture components"
+      end
+
+    name = TextureName.new
+    raise "Unable to allocate texture name" unless name
+
+    Gl::glGetIntegerv(Gl::GL_TEXTURE_BINDING_2D, name.address)
+    prev_name = name.name
+
+    Gl::glGenTextures(1, name.address)
+    Gl::glBindTexture(Gl::GL_TEXTURE_2D, name.name)
+
+    Gl::glTexParameteri(Gl::GL_TEXTURE_2D, Gl::GL_TEXTURE_WRAP_S, Gl::GL_CLAMP_TO_EDGE)
+    Gl::glTexParameteri(Gl::GL_TEXTURE_2D, Gl::GL_TEXTURE_WRAP_T, Gl::GL_CLAMP_TO_EDGE)
+    Gl::glTexParameteri(Gl::GL_TEXTURE_2D, Gl::GL_TEXTURE_MIN_FILTER, Gl::GL_LINEAR)
+    Gl::glTexParameteri(Gl::GL_TEXTURE_2D, Gl::GL_TEXTURE_MAG_FILTER, Gl::GL_LINEAR)
+
+    Gl::glTexImage2D(
+      Gl::GL_TEXTURE_2D,      # target
+      0,                      # level
+      format,                 # internal format
+      x, y,                   # width, height
+      0,                      # border
+      format,                 # format
+      Gl::GL_UNSIGNED_BYTE,   # typep
+      data
+      )
+
+    glBindTexture(Gl::GL_TEXTURE_2D, prev_name)
+
+    name
+  end
+
+
+  # Allocates a new texture using the given IO object.
+  # If a block is given, the texture is only valid in the scope of the block
+  # unless retained elsewhere.
+  def initialize(io, &block)
+    @name = STBI.load_image(io, STBI::COMPONENTS_DEFAULT, &LOAD_TEXTURE_BLOCK)
+    @refs = 0
+    retain(&block)
+  end
+
+  def retain
+    @refs += 1
+
+    if block_given?
+      yield self
+      release
+    end
+  end
+
+  def release
+    @refs -= 1
+    if @refs == 0
+      # If it's necessary to do anything else to release the object, pass it
+      # to a block first.
+      yield self if block_given?
+
+      glDeleteTextures(1, @name.address)
+    end
+  end
+
+end # Texture
+
+end # GUI

data/lib/gui/version.rb

@@ -0,0 +1,36 @@
+#  Copyright 2014 Noel Cower
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+#  -----------------------------------------------------------------------------
+#
+#  version.rb
+#    Version information for the gui gem.
+
+
+module GUI
+
+  GUI_VERSION           = '0.0.1.pre1'.freeze
+  GUI_LICENSE_BRIEF     = 'Apache 2.0 License'.freeze
+  GUI_GEM_ROOT          = File.expand_path('../../../', __FILE__).freeze
+
+  # Don't load the license unless it's needed.
+  define_singleton_method(:GUI_LICENSE_FULL, &-> do
+    File.open("#{GUI_GEM_ROOT}/COPYING") do |io|
+      io.read
+    end.freeze.tap do |license_txt|
+      ::GUI::set_const(:GUI_LICENSE_FULL, license_txt)
+    end
+  end)
+
+end # GUI

data/lib/gui/view.rb

@@ -0,0 +1,134 @@
+#  Copyright 2014 Noel Cower
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+#  -----------------------------------------------------------------------------
+#
+#  widget.rb
+#    Base class for view types.
+
+
+require 'gui/geom'
+
+
+module GUI
+
+class View
+
+  # View tag (default: nil)
+  attr_accessor :tag
+
+  # Subviews held by the view. Should not be modified directly. Instead, to
+  # add a subview, use add_view.
+  attr_reader   :subviews
+
+  # Rectangular portion
+  attr_accessor :frame # Rect
+
+  def initialize(frame = nil)
+    @needs_layout   = false
+    @invalidated    = nil
+    @subviews       = []
+    @attributes     = []
+    @superview      = nil
+    @tag            = nil
+    @frame          = frame || Rect.new
+
+    invalidate
+    request_layout
+  end
+
+  # Returns the containing superview of the view.
+  def superview
+    @superview
+  end
+
+  # Sets the containing superview of the view. This invalidates and requests
+  # layout on the previous superview, if any.
+  def superview=(new_superview)
+    old_superview = @superview
+    if !old_superview.nil?
+      old_superview.delete(self)
+      old_superview.invalidate(@frame.dup)
+      old_superview.request_layout
+    end
+
+    @superview = new_superview
+    if !new_superview.nil?
+      new_superview.children << self
+    end
+  end
+
+  def add_view(view)
+    raise ArgumentError, "View already has a superview" if view.superview
+    view.superview = self
+  end
+
+  def bounds
+    @frame.with_origin(0, 0)
+  end
+
+  def remove_from_superview
+    self.superview = nil
+  end
+
+  def invalidated_region
+    @invalidated
+  end
+
+  def invalidate(region = nil)
+    if @invalidated
+      @invalidated.contains_both!(region || @frame)
+    else
+      @invalidated = (region || @frame.with_origin(0, 0)).dup
+    end.intersection!(bounds)
+
+    self
+  end
+
+  def request_layout
+    @needs_layout = true
+  end
+
+  def needs_layout?
+    @needs_layout
+  end
+
+  def perform_layout
+  end
+
+  def view_with_tag(tag)
+    if @tag == tag
+      self
+    else
+      @subviews.detect { |subview| subview.view_with_tag(tag) }
+    end
+  end
+
+  def view_with_selector(selector)
+    nil
+  end
+
+  def [](selector)
+    case selector
+    when Symbol   then view_with_tag(selector)
+    when Selector then view_with_selector(selector)
+    when String   then view_with_selector(Selector.build(selector))
+    when Numeric  then @subviews[selector]
+    else raise ArgumentError, "Invalid selector for View#[]"
+    end
+  end
+
+end # View
+
+end # GUI