qml 0.0.7 → 1.0.0

data/lib/qml/models.rb

@@ -1 +0,0 @@
-require 'qml/models/array_model'

data/lib/qml/qt_classes.rb

@@ -1,9 +0,0 @@
-require 'qml/plugins'
-
-module QML
-  Application = Kernel.application_meta_object.build_class
-  Engine = Kernel.engine_meta_object.build_class
-  Context = Plugins.core.metaObjects['QQmlContext'].build_class
-  Component = Plugins.core.metaObjects['QQmlComponent'].build_class
-  Qt = Plugins.core.metaObjects['Qt'].build_class
-end

data/lib/qml/qt_object_base.rb

@@ -1,233 +0,0 @@
-require 'qml/dispatchable'
-require 'qml/name_helper'
-
-module QML
-
-  class QtPropertyBase
-    attr_reader :changed
-
-    def initialize(metaobj, objptr, name)
-      super()
-      @metaobj = metaobj
-      @objptr = objptr
-      @name = name
-      @changed = QtSignal.new(metaobj, objptr, @metaobj.notify_signal(@name))
-    end
-
-    def value=(newval)
-      @metaobj.set_property(@objptr, @name, newval)
-    end
-
-    def value
-      @metaobj.get_property(@objptr, @name)
-    end
-  end
-
-  class QtProperty < QtPropertyBase
-    include Reactive::Bindable
-  end
-
-  class QtSignal < Reactive::Signal
-    def initialize(metaobj, objptr, name)
-      super(nil)
-      @objptr = objptr
-      @metaobj = metaobj
-      @name = name
-      @initialized = false
-    end
-
-    private
-
-    def connected(block)
-      return if @initialized
-      @metaobj.connect_signal(@objptr, @name, method(:emit))
-      @initialized = true
-    end
-  end
-
-  # {QtObjectBase} is the base class for Qt object wrappers.
-  #
-  # In ruby-qml you can access the followings of Qt objects in Ruby.
-  #
-  # * Properties as {Reactive::Property}
-  # * Signals as {Reactive::Signal}
-  # * Q_INVOKABLE methods, slots and QML methods as Ruby methods
-  #
-  # Properties and signals support is provided by {Reactive::Object}.
-  #
-  # While their names are camelCase in Qt, ruby-qml aliases them as underscore_case.
-  #
-  # @example
-  #   # QML::Application is actually a wrapper for QApplication
-  #   app = QML.application
-  #
-  #   # set property
-  #   app.applicationName = "Test"
-  #   app.application_name = "Test" # aliased version
-  #
-  #   # connect to signal
-  #   app.aboutToQuit.connect do # "about_to_quit" is also OK
-  #     puts "quitting..."
-  #   end
-  #
-  #   # call slot
-  #   app.quit
-  class QtObjectBase
-    include Dispatchable
-    include Reactive::Object
-
-    # @api private
-    class SubclassBuilder
-
-      attr_reader :subclass
-
-      def initialize(metaobj, klass)
-        @metaobj = metaobj
-        @subclass = klass
-      end
-
-      def build
-        create unless @subclass
-        return if @subclass.meta_object == @metaobj
-
-        @metaobj.method_names.reject { |name| @metaobj.signal?(name) }.each do |name|
-          define_method(name)
-        end
-        @metaobj.method_names.select { |name| @metaobj.signal?(name) }.each do |name|
-          define_signal(name)
-        end
-        @metaobj.property_names.each do |name|
-          define_property(name)
-        end
-        @metaobj.enumerators.each do |k, v|
-          define_enum(k, v)
-        end
-        @subclass.__send__ :meta_object=, @metaobj
-
-        self
-      end
-
-      private
-
-      def create
-        super_metaobj = @metaobj.super_class
-        @subclass = Class.new(super_metaobj ? super_metaobj.build_class : QtObjectBase)
-      end
-
-      def define_method(name)
-        metaobj = @metaobj
-        return if metaobj.private?(name)
-        underscore = NameHelper.to_underscore(name)
-
-        @subclass.class_eval do
-          define_method name do |*args|
-            metaobj.invoke_method(@pointer, name, args)
-          end
-          private name if metaobj.protected?(name)
-          alias_method underscore, name unless underscore == name
-        end
-      end
-
-      def define_signal(name)
-        metaobj = @metaobj
-        underscore = NameHelper.to_underscore(name)
-        @subclass.class_eval do
-          variadic_signal name, signal: -> { QtSignal.new(metaobj, @pointer, name) }
-          alias_signal underscore, name unless underscore == name
-        end
-      end
-
-      def define_property(name)
-        metaobj = @metaobj
-        underscore = NameHelper.to_underscore(name)
-        @subclass.class_eval do
-          property name, nil, property: -> { QtProperty.new(metaobj, @pointer, name) }
-          alias_property underscore, name unless underscore == name
-        end
-      end
-
-      def define_enum(name, hash)
-        define_const(name, hash.values.sort)
-        hash.each do |k, v|
-          define_const(k, v)
-        end
-      end
-
-      def define_const(name, value)
-        name = (name[0].capitalize + name[1..-1]).to_sym
-        underscore = NameHelper.to_upper_underscore(name)
-        @subclass.class_eval do
-          const_set name, value
-          const_set underscore, value unless underscore == name
-        end
-      end
-    end
-
-    class << self
-      attr_accessor :meta_object
-      private :meta_object=
-    end
-
-    attr_accessor :pointer
-    private :pointer=
-
-    # Evaluates a JavaScript expression on the QML context of the object.
-    # Fails with {QMLError} when the object is not created by QML and does not belong to any context.
-    # @param [String] str
-    # @return the result.
-    # @example
-    #   component = QML::Component.new data: <<-EOS
-    #     import QtQuick 2.0
-    #     QtObject {
-    #       property string foo: 'foo'
-    #       property string bar: 'bar'
-    #     }
-    #   EOS
-    #   obj = component.create
-    #   obj.qml_eval("foo + bar") #=> "foobar"
-    def qml_eval(str)
-      context = Context.for_object(self)
-      fail QMLError, 'belongs to no context' unless context
-      context.eval(self, str)
-    end
-
-    def inspect
-      klass = self.class
-      property_inspect = klass.instance_properties.sort
-        .reject { |name| klass.instance_property(name).alias? }
-        .map do |name|
-          "#{name}=" +
-            begin
-              property(name).value.inspect
-            rescue ConversionError
-              "<unsupported type>"
-            end
-        end
-        .join(' ')
-      classname = klass.name || "[class for #{klass.meta_object.name}]"
-      "#<#{classname}:#{__id__} #{property_inspect}>"
-    end
-
-    alias_method :to_s, :inspect
-
-    # @return whether the object is managed by Ruby and QML and garbage collected when no longer used.
-    def managed?
-      pointer.managed?
-    end
-
-    # Sets the management status of the object.
-    # @param [Boolean] managed
-    # @return [Boolean]
-    def managed=(managed)
-      pointer.managed = managed
-    end
-
-    # Sets the management status of the object in safer way.
-    # Objects that are created by QML will remain managed and objects that have parents will remain unmanaged.
-    # @param [Boolean] managed
-    # @return [Boolean]
-    def prefer_managed(managed)
-      pointer.prefer_managed managed
-    end
-  end
-end

data/lib/qml/reactive/bindable.rb

@@ -1,79 +0,0 @@
-module QML
-  module Reactive
-    module Bindable
-
-      def initialize(*args, &block)
-        super
-        @connections = []
-      end
-
-      # Sets a new value.
-      # The old property binding is discarded.
-      # @param new_value new value 
-      def value=(new_value, unbind = true)
-        self.unbind if unbind
-        unless value == new_value
-          super(new_value)
-          changed.emit(new_value)
-        end
-        new_value
-      end
-
-      alias_method :set_value, :value=
-
-      # @return The property value
-      def value
-        touch
-        super
-      end
-
-      # @api private
-      module Resolver
-        @sources_stack = []
-        class << self
-          def eval_and_resolve(&block)
-            @sources_stack.push([])
-            ret = block.call
-            [ret, @sources_stack.pop]
-          end
-
-          def add(property)
-            current = @sources_stack.last
-            current && current << property
-          end
-        end
-      end
-
-      # Sets a property binding.
-      # The block is re-evaluated when any of other properties used in it is updated
-      # and the result is used as the new property value.
-      # @yield
-      # @example
-      #    p1 = Property.new
-      #    p2 = Property.new
-      #    p1.bind { p2.value + 1 }
-      #    p2.value = 10
-      #    p1.value #=> 11
-      # @return The property value
-      def bind(&block)
-        unbind
-        value, sources = Resolver.eval_and_resolve(&block)
-        set_value(value, false)
-        @connections = sources.map do |source|
-          fail Error, 'Recursive binding' if source == self
-          source.changed.connect { set_value(block.call, false) }
-        end
-      end
-
-      def unbind
-        @connections.each(&:disconnect)
-      end
-
-      private
-
-      def touch
-        Resolver.add(self)
-      end
-    end
-  end
-end

data/lib/qml/reactive/chained_signal.rb

@@ -1,25 +0,0 @@
-require 'qml/reactive/signal'
-
-module QML
-  module Reactive
-    class ChainedSignal < Signal
-      private
-      def connected(listener)
-        if connection_count == 1
-          @connections = Array(connect_to_sources)
-        end
-      end
-
-      def disconnected(listener)
-        if connection_count == 0
-          @connections.each(&:disconnect)
-          @connections = nil
-        end
-      end
-
-      def connect_to_sources
-        fail NotImplementedError
-      end
-    end
-  end
-end

data/lib/qml/reactive/error.rb

@@ -1,5 +0,0 @@
-module QML
-  module Reactive
-    class Error < ::StandardError; end
-  end
-end

data/lib/qml/reactive/object.rb

@@ -1,293 +0,0 @@
-require 'qml/reactive/unbound_signal'
-require 'qml/reactive/unbound_property'
-
-module QML
-  module Reactive
-
-    # {Object} is used to define signals and properties within class definition.
-    # Signals and properties will be inherited by and can be overridden in subclasses.
-    # @note Currently {Object} can be included only by classes, not modules.
-    # @see Object::ClassMethods
-    module Object
-
-      # When {Object} is included by a class, the class extends {ClassMethods} to add the common class methods.
-      def self.included(derived)
-        fail Error, "#{Object} must be included in a class" unless derived.is_a? ::Class
-        derived.extend(ClassMethods)
-      end
-
-      def initialize(*args, &block)
-        # prepare properties
-        properties = self.class.instance_property_hash
-          .values
-          .map { |property| self.class.instance_property(property.original) }
-          .uniq
-        properties.each do |property|
-          instance_variable_set("@_property_#{property.name}", property.bind(self))
-        end
-
-        # prepare signals
-        signals = self.class.instance_signal_hash
-          .values
-          .map { |signal| self.class.instance_signal(signal.original) }
-          .uniq
-        signals.each do |signal|
-          instance_variable_set("@_signal_#{signal.name}", signal.bind(self))
-        end
-
-        # prepare signal connections
-        self.class.send(:initial_connections_hash).each do |name, blocks|
-          blocks.each do |block|
-            signal(name).connect do |*args|
-              instance_exec(*args, &block)
-            end
-          end
-        end
-
-        super
-      end
-
-      # @!method signal(name)
-      #   Returns a signal.
-      #   @param name [Symbol] The signal name
-      #   @return [QML::Reactive::Signal]
-
-      # @!method signals
-      #   Returns all signal names.
-      #   @return [Array<Symbol>]
-
-      # @!method property(name)
-      #   Returns a property.
-      #   @param name [Symbol] The property name
-      #   @return [QML::Reactive::Property]
-
-      # @!method properties
-      #   Returns all property names.
-      #   @return [Array<Symbol>]
-
-      [%w{signal signals}, %w{property properties}].each do |singular, plural|
-        class_eval <<-EOS, __FILE__, __LINE__ + 1
-          def #{singular}(name)
-            name = self.class.instance_#{singular}(name).original
-            instance_variable_get(:"@_#{singular}_\#{name}") or
-              fail ::NameError, "undefined #{singular} '\#{name}' for class '\#{self.class}'"
-          end
-
-          def #{plural}
-            self.class.instance_#{plural}
-          end
-        EOS
-      end
-
-      # @!parse extend ClassMethods
-
-      module ClassMethods
-
-        # @!method instance_signals(include_super = true)
-        #   Returns all signal names for the class.
-        #   @param include_super [true|false]
-        #   @return [Array<Symbol>]
-
-        # @!method instance_signal(name)
-        #   Returns an unbound signal.
-        #   @param name [Symbol] The signal name
-        #   @return [QML::Reactive::UnboundSignal]
-
-        # @!method instance_properties(include_super = true)
-        #   Returns all property names for the class.
-        #   @param include_super [true|false]
-        #   @return [Array<Symbol>]
-
-        # @!method instance_property(name)
-        #   Returns an unbound property.
-        #   @param name [Symbol] The property name
-        #   @return [QML::Reactive::UnboundProperty]
-        [%w{signal signals}, %w{property properties}].each do |singular, plural|
-          class_eval <<-EOS, __FILE__, __LINE__ + 1
-            def instance_#{singular}_hash(include_super = true)
-              if include_super && superclass.include?(Object)
-                superclass.instance_#{singular}_hash.merge instance_#{singular}_hash(false)
-              else
-                @instance_#{singular}_hash ||= {}
-              end
-            end
-
-            def instance_#{plural}(include_super = true)
-              instance_#{singular}_hash(include_super).keys
-            end
-
-            def instance_#{singular}(name)
-              instance_#{singular}_hash[name] or fail ::NameError, "undefined #{singular} '\#{name}' for class '\#{self}'"
-            end
-          EOS
-        end
-
-        # Defines a signal for the class.
-        # The signal will be variadic if args == nil.
-        # @param name [#to_sym] The signal name
-        # @param params [Array<#to_sym>, nil] The signal parameter names
-        # @param opts [Hash]
-        # @option opts [Proc] :signal (nil)
-        # @return [Symbol] The signal name
-        # @example
-        #   class Button
-        #     include QML::Reactive::Object
-        #     signal :pressed, [:pos]
-        #     def press(pos)
-        #       pressed.emit(pos)
-        #     end
-        #   end
-        #
-        #   button = Button.new
-        #   button.pressed.connect { |pos| puts "Pressed at #{pos}" }
-        #   button.press([10, 20])
-        #
-        #   class ColorButton < Button
-        #     signal :pressed, [:pos, :color]
-        #   end
-        #
-        #   color_button = ColorButton.new
-        #   color_button.pressed.connect { |pos, color| "#{color} button pressed at #{pos}" }
-        #   color_button.press([10, 20], 'red')
-        def signal(name, params, opts = {})
-          name.to_sym.tap do |name|
-            params = params.map(&:to_sym)
-            add_signal(UnboundSignal.new(name, params, false, self, opts[:signal]))
-          end
-        end
-
-        # Defines a variadic signal.
-        # Variadic signals do not restrict the number of arguments.
-        # @param opts [Hash]
-        # @option opts [Proc] :signal (nil)
-        # @see #signal
-        def variadic_signal(name, opts = {})
-          name.to_sym.tap do |name|
-            add_signal(UnboundSignal.new(name, nil, true, self, opts[:signal]))
-          end
-        end
-
-        # Aliases a signal.
-        # @param name [#to_sym]
-        # @param original_name [#to_sym]
-        # @return [Symbol] The new name
-        def alias_signal(name, original_name)
-          name.to_sym.tap do |name|
-            original_name = original_name.to_sym
-            add_signal(instance_signal(original_name).alias(name))
-          end
-        end
-
-        # Defines a property for the class.
-        # @param name [#to_sym] The name of the property
-        # @param init_value The initial value (optional)
-        # @param opts [Hash]
-        # @option opts [Proc] :property (nil)
-        # @yield The initial property binding (optional)
-        # @return [Symbol] The name
-        # @example
-        #   class Foo
-        #     include QML::Reactive::Object
-        #     property(:name) { 'hogehoge' }
-        #     ...
-        #   end
-        #   Foo.new.name #=> 'hogehoge'
-        #   Foo.new.name = 'foobar'
-        #   Foo.new.name #=> 'foobar'
-        #   Foo.new.name_changed.connect do |new_name|
-        #     ...
-        #
-        #   class Bar < Foo
-        #     property(:name) { 'piyopiyo' }
-        #   end
-        #   Bar.new.name #=> 'piyopiyo'
-        def property(name, init_value = nil, opts = {}, &init_binding)
-          name.to_sym.tap do |name|
-            add_property(UnboundProperty.new(name, init_value, init_binding, self, opts[:property]))
-            signal("#{name}_changed", [:new_value], signal: -> { property(name).changed })
-          end
-        end
-
-        # Aliases a property.
-        # @param name [#to_sym]
-        # @param original_name [#to_sym]
-        # @return [Symbol] The new name
-        def alias_property(name, original_name)
-          name.to_sym.tap do |name|
-            original_name = original_name.to_sym
-            add_property(instance_property(original_name).alias(name))
-            alias_signal("#{name}_changed", "#{original_name}_changed")
-          end
-        end
-
-        # Adds a signal handler.
-        # @param signal_name The name of the signal
-        # @yield The block that is connected to the signal during object initialization
-        def on(signal_name, &block)
-          # just for check
-          instance_signal(signal_name)
-          @initial_connections_hash ||= {}
-          @initial_connections_hash[signal_name] ||= []
-          @initial_connections_hash[signal_name] << block
-        end
-
-        # Adds a handler to a property change signal.
-        # @param property_name The name of the property
-        # @yield The block that is connected to the property change signal during object initialization
-        # @example
-        #   class Foo
-        #     property :bar, ''
-        #     on_changed :bar do
-        #       some_action
-        #     end
-        #     def some_action
-        #       ...
-        #     end
-        #   end
-        # @see #on
-        def on_changed(property_name, &block)
-          on(:"#{property_name}_changed", &block)
-        end
-
-        private
-
-        def add_signal(signal)
-          instance_signal_hash(false)[signal.name] = signal
-
-          class_eval <<-EOS, __FILE__, __LINE__ + 1
-            def #{signal.name}
-              @_signal_#{signal.original}
-            end
-          EOS
-        end
-
-        def add_property(property)
-          instance_property_hash(false)[property.name] = property
-
-          class_eval <<-EOS, __FILE__, __LINE__ + 1
-            def #{property.name}(&block)
-              @_property_#{property.original}.value(&block)
-            end
-            def #{property.name}=(new_value)
-              @_property_#{property.original}.value = new_value
-            end
-          EOS
-        end
-
-        def initial_connections_hash(include_super = true)
-          if include_super && superclass.include?(Object)
-            superclass.send(:initial_connections_hash).dup.tap do |hash|
-              initial_connections_hash(false).each do |key, blocks|
-                hash[key] ||= []
-                hash[key] += blocks
-              end
-            end
-          else
-            @initial_connections_hash ||= {}
-          end
-        end
-      end
-    end
-  end
-end
-