qml 0.0.1

data/lib/qml/class_builder.rb

@@ -0,0 +1,126 @@
+require 'logger'
+require 'qml/qt_object_base'
+require 'qml/qml'
+require 'qml/name_helper'
+
+module QML
+
+  class QtProperty
+    prepend Reactive::Bindable
+
+    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 QtSignal < Reactive::Signal
+    def initialize(metaobj, objptr, name)
+      super(variadic: true)
+      @objptr = objptr
+      @metaobj = metaobj
+      @name = name
+    end
+
+    private
+
+    def connected(block)
+      return if @initialized
+      @metaobj.connect_signal(@objptr, @name, method(:emit))
+      @initialized = true
+    end
+  end
+
+  class ClassBuilder
+
+    attr_reader :metaobj, :klass
+
+    def initialize(metaobj, klass)
+      @metaobj = metaobj
+      @klass = klass
+    end
+
+    def build
+      create unless @klass
+      return if @klass.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
+      @klass.__send__ :meta_object=, @metaobj
+
+      self
+    end
+
+    private
+
+    def create
+      super_metaobj = @metaobj.super_class
+      @klass = Class.new(super_metaobj ? super_metaobj.build_class : QtObjectBase)
+    end
+
+    def define_method(name)
+      metaobj = @metaobj
+      return if metaobj.private?(name)
+      @klass.__send__ :define_method, name do |*args|
+        metaobj.invoke_method(@pointer, name, args)
+      end
+      @klass.__send__ :private, name if @metaobj.protected?(name)
+      underscore = NameHelper.to_underscore(name)
+      @klass.__send__ :alias_method, underscore, name if underscore != name
+    end
+
+    def define_signal(name)
+      @klass.__send__ :variadic_signal, name, factory: proc { |obj|
+        QtSignal.new(@metaobj, obj.pointer, name)
+      }
+      underscore = NameHelper.to_underscore(name)
+      @klass.__send__ :alias_signal, underscore, name if underscore != name
+    end
+
+    def define_property(name)
+      metaobj = @metaobj
+      @klass.__send__ :property, name, factory: proc { |obj|
+        QtProperty.new(@metaobj, obj.pointer, name)
+      }
+      underscore = NameHelper.to_underscore(name)
+      @klass.__send__ :alias_property, underscore, name if underscore != name
+    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
+      @klass.__send__ :const_set, name, value
+      underscore = NameHelper.to_upper_underscore(name)
+      @klass.__send__ :const_set, underscore, value if underscore != name
+    end
+  end
+end

data/lib/qml/component.rb

@@ -0,0 +1,53 @@
+require 'qml/engine'
+
+module QML
+  # @!parse class Component < QtObjectBase; end
+
+  # The Component class is used to instantiate objects like Window / ApplicationWindow objects from QML files.
+  #
+  # You usually do not need to use this class because Application#load, #load_path, #load_data do same
+  # for the application top-level objects such as main windows.
+  # @example
+  #   component = Component.new(path: path_to_qml_file)
+  #   root_object = component.create
+  # @see http://qt-project.org/doc/qt-5/qqmlcomponent.html QQmlComponent (C++)
+  class Component
+    attr_reader :data, :path, :context
+
+    # Creates an component. Either data or path must be specified.
+    # @param context [QML::Context|nil] The context that the created objects will depend on (default to the root context of the application engine)
+    # @param data [String] The QML file data
+    # @param path [#to_s] The QML file path
+    # @return QML::Component
+    def self.new(context: nil, data: nil, path: nil)
+      context ||= Engine.instance.context
+      Plugins.core.createComponent(Engine.instance).instance_eval do
+        @data = data
+        @path = path
+        @context = context
+
+        if data
+          @extension.loadString(data, (path && path.to_s) || '')
+        elsif path
+          @extension.loadFile(path.to_s)
+        else
+          fail QMLError, 'neither data nor path specified'
+        end
+
+        self
+      end
+    end
+
+    def initialize
+      super()
+      Access.register_classes
+      @extension = Plugins.core.createComponentExtension(self)
+    end
+
+    # Instantiates a object from the QML file.
+    # @return [QtObjectBase] The created Qt object
+    def create
+      @extension.create(@context)
+    end
+  end
+end

data/lib/qml/context.rb

@@ -0,0 +1,71 @@
+require 'qml/qt_classes'
+
+module QML
+  # @!parse class Context < QtObjectBase; end
+
+  # {Context} represents QML contexts and used to expose Ruby values to QML.
+  # Each context has values that is called "context properties" that can be accessed in QML by their names.
+  #
+  # This class is automatically created from QQmlContext (C++).
+  # @see http://qt-project.org/doc/qt-5/qqmlcontext.html QQmlContext(C++)
+  #
+  # @example
+  #   QML.application do |app|
+  #     app.context[:foo] = 'foo'
+  #     app.context[:bar] = 'bar'
+  #     ...
+  #   end
+  class Context
+
+    # Creates a new instance of {Context}.
+    def self.new
+      Plugins.core.createContext(Engine.instance)
+    end
+
+    def initialize
+      super()
+      @extension = Plugins.core.createContextExtension(self)
+      @context_properties = {}
+    end
+
+    # Evaluates an JavaScript expression on the object in this context.
+    # @param obj The object the expression is evaluated on
+    # @param str The JavaScript expression string
+    # @see QtObjectBase#qml_eval
+    def eval(obj, str)
+      @extension.evaluate(obj, str)
+    end
+
+    # Sets a context property.
+    # @param key [String|Symbol] The property key
+    # @param value The value
+    # @return The value
+    def []=(key, value)
+      # be sure that the value is managed when it is a QObject
+      value = value.create_wrapper if value.is_a? Wrappable
+      value.prefer_managed true if value.is_a? QtObjectBase
+
+      # hold referenece because QQmlContext::setContextProperty does not take ownership of objects
+      @context_properties[key] = value
+
+      @extension.setContextProperty(key, value)
+      value
+    end
+
+    # Gets a context property.
+    # @param key [String|Symbol] The property key
+    # @return The value
+    def [](key)
+      @extension.contextProperty(key)
+    end
+
+    # Gets a context that an object belongs to. If the object belongs to no context, returns nil.
+    # @param obj
+    # @return [Context|nil]
+    def self.for_object(obj)
+      Plugins.core.contextForObject(obj).tap do |context|
+        context.managed = false if context
+      end
+    end
+  end
+end

data/lib/qml/data.rb

@@ -0,0 +1,2 @@
+require 'qml/data/list_model'
+require 'qml/data/array_model'

data/lib/qml/data/array_model.rb

@@ -0,0 +1,103 @@
+module QML
+  module Data
+    # {ArrayModel} is one of ruby-qml's list models and it stores data in Array simply.
+    class ArrayModel < ListModel
+      def initialize
+        super()
+        @array = []
+      end
+
+      # Duplicates the internal array and returns it.
+      # @return [Array]
+      def to_a
+        @array.dup
+      end
+
+      # @return [Integer] the number of the items.
+      def count
+        @array.count
+      end
+
+      # Returns an item.
+      # @param [Integer] index the index of the item.
+      # @return the item.
+      def [](index)
+        @array[index]
+      end
+
+      # Updates an item.
+      # @param [Integer] index
+      # @param item
+      # @return the item.
+      def []=(index, item)
+        @array[index] = item
+        update(index .. index)
+        item
+      end
+
+      # Inserts items.
+      # @param [Integer] index
+      # @return [self]
+      def insert(index, *items)
+        inserting(index ... index + items.size) do
+          @array.insert(index, *items)
+        end
+        self
+      end
+
+      # @overload delete_at(index)
+      #   Deletes an item.
+      #   @param [Integer] index
+      #   @return the deleted item.
+      # @overload delete_at(index, count)
+      #   Deletes items.
+      #   @param [Integer] index
+      #   @return [Array] the deleted items.
+      def delete_at(index, count = nil)
+        if count
+          removing(index ... index + count) do
+            count.times.map { @array.delete_at(index) }
+          end
+        else
+          removing(index .. index) do
+            @array.delete_at(index)
+          end
+        end
+      end
+
+      # Prepend items.
+      # @return [self]
+      def unshift(*items)
+        insert(0, *items)
+      end
+
+      # @overload shift
+      #   Deletes the first item.
+      #   @return the deleted item.
+      # @overload shift(count)
+      #   Deletes the first items.
+      #   @return [Array] the deleted items.
+      def shift(count = nil)
+        delete_at(0, count)
+      end
+
+      # Append items.
+      # @return [self]
+      def push(*items)
+        insert(@array.size, *items)
+      end
+
+      alias_method :<<, :push
+
+      # @overload pop
+      #   Deletes the last item.
+      #   @return the deleted item.
+      # @overload pop(count)
+      #   Deletes the last items.
+      #   @return [Array] the deleted items.
+      def pop(count = nil)
+        delete_at(@array.size - count, count)
+      end
+    end
+  end
+end

data/lib/qml/data/error.rb

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

data/lib/qml/data/list_model.rb

@@ -0,0 +1,146 @@
+require 'qml/data/error'
+require 'qml/wrappable'
+require 'qml/dispatchable'
+
+module QML
+  module Data
+    # {ListModel} is the base class of list models which provides data to QML list views.
+    # @see http://qt-project.org/doc/qt-5/qabstractitemmodel.html QAbstractItemModel (C++)
+    # @see http://qt-project.org/doc/qt-5/qabstractlistmodel.html QAbstractListModel (C++)
+    class ListModel
+      include ::Enumerable
+      include Wrappable
+      include Dispatchable
+
+      class << self
+        # Declares the columns of the model.
+        # @param [Array<Symbol|String>] columns 
+        def column(*columns)
+          @columns ||= []
+          @columns |= columns
+        end
+
+        # The columns of the model.
+        attr_reader :columns
+      end
+
+      # @api private
+      # @return [Array<QtObjectBase>]
+      attr_reader :qt_models
+
+      def initialize
+        fail Error, 'columns not specified' unless self.class.columns
+        @qt_models = []
+      end
+
+      # Iterates each item.
+      # @overload each
+      #   @return [Enumerator]
+      # @overload each
+      #   @yield [item]
+      #   @return [self]
+      def each
+        return to_enum unless block_given?
+        count.times do |i|
+          yield self[i]
+        end
+        self
+      end
+
+      # @abstract
+      # @return [Integer] the number of the items.
+      def count
+        fail ::NotImplementedError
+      end
+
+      # Returns an item.
+      # @abstract
+      # @param [Integer] index the index of the item.
+      # @return the item.
+      def [](index)
+        fail ::NotImplementedError
+      end
+
+      protected
+
+      # Notifies the list views that the data of the items was changed.
+      # @param [Range<Integer>] range the index range of changed items.
+      def update(range)
+        @qt_models.each do |qt_model|
+          qt_model.update(range.min, range.max)
+        end
+      end
+
+      # Notifies the list views that items are about to be and were moved.
+      # @param [Range<Integer>] range the index range of the item being moved.
+      # @param [Integer] destination the first index of the items after moved.
+      # @yield the block that actually do moving operation of the items.
+      # @return the result of given block.
+      # @see http://qt-project.org/doc/qt-5/qabstractitemmodel.html#beginMoveRows QAbstractItemModel::beginMoveRows
+      # @see http://qt-project.org/doc/qt-5/qabstractitemmodel.html#endMoveRows QAbstractItemModel::endMoveRows
+      # @see #inserting
+      # @see #removing
+      def moving(range, destination, &block)
+        @qt_models.each do |qt_model|
+          qt_model.begin_move(range.min, range.max, destination)
+        end
+
+        ret = block.call
+
+        @qt_models.each do |qt_model|
+          qt_model.end_move
+        end
+
+        ret
+      end
+
+      # Notifies the list views that items are about to be and were inserted.
+      # @param [Range<Integer>] range the index range of the items after inserted.
+      # @yield the block that actually do insertion of the items.
+      # @return the result of give block.
+      # @example
+      #   inserting(index ... index + items.size) do
+      #     @array.insert(index, *items)
+      #   end
+      # @see http://qt-project.org/doc/qt-5/qabstractitemmodel.html#beginInsertRows QAbstractItemModel::beginInsertRows
+      # @see http://qt-project.org/doc/qt-5/qabstractitemmodel.html#endInsertRows QAbstractItemModel::endInsertRows
+      # @see #removing
+      # @see #moving
+      def inserting(range, &block)
+        @qt_models.each do |qt_model|
+          qt_model.begin_insert(range.min, range.max)
+        end
+
+        ret = block.call
+
+        @qt_models.each do |qt_model|
+          qt_model.end_insert
+        end
+
+        ret
+      end
+
+      # Notifies the list views that items are about to be and were removed.
+      # @param [Range<Integer>] range the index range of the items before removed.
+      # @yield the block that actually do removal of the items.
+      # @return the result of give block.
+      # @see http://qt-project.org/doc/qt-5/qabstractitemmodel.html#beginRemoveRows QAbstractItemModel::beginRemoveRows
+      # @see http://qt-project.org/doc/qt-5/qabstractitemmodel.html#endRemoveRows QAbstractItemModel::endRemoveRows
+      # @see #inserting
+      # @see #moving
+      def removing(range, &block)
+        @qt_models.each do |qt_model|
+          qt_model.begin_remove(range.min, range.max)
+        end
+
+        ret = block.call
+
+        @qt_models.each do |qt_model|
+          qt_model.end_remove
+        end
+
+        ret
+      end
+    end
+  end
+end