qml 0.0.7 → 1.0.0

data/lib/qml/data/list_model_access.rb

@@ -0,0 +1,44 @@
+module QML
+  # @api private
+  class ListModelAccess
+    include Access
+
+    signal :begin_insert, [:first, :last]
+    signal :end_insert
+    signal :begin_move, [:first, :last, :dest]
+    signal :end_move
+    signal :begin_remove, [:first, :last]
+    signal :end_remove
+    signal :update, [:first, :last]
+    signal :begin_reset
+    signal :end_reset
+
+    attr_accessor :model
+
+    def columns
+      @model.columns.to_qml
+    end
+
+    def data(index, column)
+      @model[index.to_i][column.to_sym].to_qml
+    end
+
+    def count
+      @model.count
+    end
+
+    register_to_qml under: 'RubyQml', version: QML::VERSION
+
+    # @return [QML::JSWrapper]
+    def self.create(model)
+      @component ||= QML::Component.new(data: <<-QML)
+        import RubyQml 1.0
+        ListModelAccess {}
+      QML
+
+      @component.create.tap do |access|
+        access.unwrap.model = model
+      end
+    end
+  end
+end

data/lib/qml/data/query_model.rb

@@ -1,59 +1,57 @@
 module QML
-  module Data
-    # {QueryModel} provides a list model implementation with database backends like ActiveRecord.
-    class QueryModel < ListModel
-      attr_reader :count
-
-      # @param [Array<Symbol|String>] columns
-      def initialize(*columns)
-        super
-        @count = 0
-        @caches = []
-        update
-      end
+  # {QueryModel} provides a list model implementation with database backends like ActiveRecord.
+  class QueryModel < ListModel
+    attr_reader :count
+
+    # @param [Array<Symbol|String>] columns
+    def initialize(*columns)
+      super
+      @count = 0
+      @caches = []
+      update
+    end
 
-      def [](index)
-        block_index = index / CACHE_SIZE
-        cache = @caches.find { |c| c.block_index == block_index } || add_cache(block_index)
-        cache.items[index % CACHE_SIZE]
-      end
+    def [](index)
+      block_index = index / CACHE_SIZE
+      cache = @caches.find { |c| c.block_index == block_index } || add_cache(block_index)
+      cache.items[index % CACHE_SIZE]
+    end
 
-      # Updates the model.
-      def update
-        @caches = []
-        resetting do
-          @count = query_count
-        end
+    # Updates the model.
+    def update
+      @caches = []
+      resetting do
+        @count = query_count
       end
+    end
 
-      # @abstract
-      # Queries the count of the records.
-      # Called when {#update} is called and the result is set as the {#count} of the model.
-      # @return [Integer]
-      def query_count
-        fail ::NotImplementedError
-      end
+    # @abstract
+    # Queries the count of the records.
+    # Called when {#update} is called and the result is set as the {#count} of the model.
+    # @return [Integer]
+    def query_count
+      fail ::NotImplementedError
+    end
 
-      # @abstract
-      # Queries a block of records. The results are chached.
-      # @param [Integer] offset
-      # @param [Integer] count
-      # @return [Array]
-      def query(offset, count)
-        fail ::NotImplementedError
-      end
+    # @abstract
+    # Queries a block of records. The results are chached.
+    # @param [Integer] offset
+    # @param [Integer] count
+    # @return [Array]
+    def query(offset, count)
+      fail ::NotImplementedError
+    end
 
-      private
+    private
 
-      Cache = Struct.new(:block_index, :items)
-      CACHE_SIZE = 256
-      CACHE_COUNT = 4
+    Cache = Struct.new(:block_index, :items)
+    CACHE_SIZE = 256
+    CACHE_COUNT = 4
 
-      def add_cache(block_offset)
-        @caches.shift if @caches.size >= CACHE_COUNT
-        Cache.new(block_offset, query(block_offset * CACHE_SIZE, CACHE_SIZE)).tap do |cache|
-          @caches << cache
-        end
+    def add_cache(block_offset)
+      @caches.shift if @caches.size >= CACHE_COUNT
+      Cache.new(block_offset, query(block_offset * CACHE_SIZE, CACHE_SIZE)).tap do |cache|
+        @caches << cache
       end
     end
   end

data/lib/qml/dispatcher.rb

@@ -16,7 +16,7 @@ module QML
 
     def add_task(&task)
       synchronize do
-        Kernel.set_event_loop_hook_enabled_later true if @tasks.empty?
+        callback_enabled = true if @tasks.empty?
         @tasks << task
       end
     end
@@ -36,17 +36,11 @@ module QML
           task = @tasks.shift
           task.call
         end
-        Kernel.set_event_loop_hook_enabled_later false if @tasks.empty?
+        callback_enabled = false if @tasks.empty?
       end
     end
   end
 
-  on_init do
-    Kernel.event_loop_hook_timer.timeout.connect do
-      Dispatcher.instance.run_tasks
-    end
-  end
-
   # Runs a block asynchronously within the event loop.
   #
   # QML UI is not thread-safe and can only be accessed from the main thread.
@@ -55,15 +49,13 @@ module QML
   #   def on_button_clicked
   #     Thread.new do
   #       result = do_task
-  #       QML.later do
+  #       QML.next_tick do
   #         set_result_to_ui(result)
   #       end
   #     end
   #   end
-  # @see Dispatchable#later
-  # @see Dispatcher#add_task
-  def later(&block)
+  def next_tick(&block)
     Dispatcher.instance.add_task(&block)
   end
-  module_function :later
+  module_function :next_tick
 end

data/lib/qml/engine.rb

@@ -1,69 +1,20 @@
-require 'qml/qt_classes'
-
 module QML
   # @!parse class Engine < QtObjectBase; end
 
   # {Engine} provides a QML engine.
-  # 
+  #
   # @see http://qt-project.org/doc/qt-5/qqmlengine.html QQmlEngine (C++)
   class Engine
 
-    # @return [Engine] the instance of {Engine}.
-    # @see QML.engine
-    def self.instance
-      Kernel.engine
-    end
-
-    # @note This method cannot be called because {Engine} is singleton. 
-    def self.new
-      fail EngineError, "cannot create Engine instance manually"
-    end
-
-    def initialize
-      super()
-      @extension = Plugins.core.createEngineExtension(self)
-    end
-
-    # @return [Context] the root {Context} the {Engine}.
-    def context
-      @extension.rootContext
-    end
-
-    # Starts garbage collection on the {Engine}.
-    def collect_garbage
-      @extension.collect_garbage
+    # Evaluates an JavaScript expression
+    # @param [String] str The JavaScript string
+    # @param [String] file The file name
+    # @param [Integer] lineno The line number
+    def evaluate(str, file = '<in QML::Engine#evaluate>', lineno = 1)
+      evaluate_impl(str, file, lineno).tap do |result|
+        raise result.to_error if result.is_a?(JSObject) && result.error?
+      end
     end
 
-    # Adds an {ImageProvider} to the {Engine}.
-    # @param id [String]
-    # @param provider [ImageProvider]
-    # @return [ImageProvider]
-    # @see ImageProvider
-    def add_image_provider(id, provider)
-      @extension.add_image_provider(id, provider.qt_image_provider)
-      provider
-    end
-
-    # Adds a QML import path to the {Engine}.
-    # @param path [String]
-    # @see http://doc.qt.io/qt-5/qtqml-syntax-imports.html#qml-import-path
-    def add_import_path(path)
-      @extension.add_import_path(path)
-    end
-
-    # Gets an array of QML import paths.
-    # @see add_import_path
-    # @return [Array]
-    def import_paths()
-      @extension.import_paths()
-    end
-
-  end
-
-  # @return [Engine] the instance of {Engine}.
-  # @see Engine.instance
-  def engine
-    Kernel.engine
   end
-  module_function :engine
 end

data/lib/qml/errors.rb

@@ -1,26 +1,5 @@
 module QML
-
-  class MethodError < StandardError; end
-  class SignalError < StandardError; end
-  class PropertyError < StandardError; end
   class PluginError < StandardError; end
-  class QtObjectError < StandardError; end
-  class ConversionError < StandardError; end
   class QMLError < StandardError; end
   class AccessError < StandardError; end
-  class ApplicationError < StandardError; end
-  class EngineError < StandardError; end
-  class InvalidThreadError < StandardError; end
-  class UninitializedError < StandardError; end
-  class AlreadyInitializedError < StandardError; end
-
-  class CppError < StandardError
-    attr_reader :class_name, :raw_message
-
-    def initialize(classname, message)
-      super("<#{classname}> #{message}")
-      @class_name = classname
-      @raw_message = message
-    end
-  end
 end

data/lib/qml/interface.rb

@@ -0,0 +1,21 @@
+module QML
+  class Interface
+
+    def self.call_method(obj, name, args)
+      begin
+        obj.__send__ name, *args
+      rescue => error
+        notify_error(error)
+        nil
+      end
+    end
+
+    # Called when an Ruby error is occured in executing Qt code.
+    # @param error The error (or the exception)
+    def self.notify_error(error)
+      warn "-- An error occured when running Ruby code from Qt --"
+      warn "#{error.class.name}: #{error.message}"
+      warn "Backtrace: \n\t#{error.backtrace.join("\n\t")}"
+    end
+  end
+end

data/lib/qml/js_array.rb

@@ -0,0 +1,8 @@
+module QML
+  class JSArray < JSObject
+    # @return [Array]
+    def to_a
+      each.to_a
+    end
+  end
+end

data/lib/qml/js_object.rb

@@ -0,0 +1,69 @@
+module QML
+  # The JSObject represents JavaScript objects.
+  class JSObject
+
+    alias_method :each, :each_pair
+
+    # @return [Array<String>]
+    def keys
+      each.map { |k, v| k }
+    end
+
+    # @return [Array]
+    def values
+      each.map { |k, v| v }
+    end
+
+    # @return [Hash]
+    def to_hash
+      {}.tap do |hash|
+        each do |k, v|
+          hash[k] =v
+        end
+      end
+    end
+
+    # @return [Time]
+    def to_time
+      Time.at(getTime.to_i / 1000r).getlocal(-getTimezoneOffset * 60)
+    end
+
+    # @return [QML::QMLError]
+    def to_error
+      QMLError.new(self['message'])
+    end
+
+    def respond_to?(method)
+      has_key?(method) || super
+    end
+
+    # Gets or sets a JS property, or call it as a method if it is a function.
+    def method_missing(method, *args, &block)
+      if method[-1] == '='
+        # setter
+        key = method.slice(0...-1).to_sym
+
+        unless has_key?(key)
+          super
+        end
+        self[key] = args[0]
+      else
+        unless has_key?(method)
+          super
+        end
+
+        prop = self[method]
+        if prop.is_a? JSFunction
+          prop.call_with_instance(self, *args, &block)
+        else
+          prop
+        end
+      end
+    end
+
+    # @return [QML::JSObject] self
+    def to_qml
+      self
+    end
+  end
+end

data/lib/qml/js_util.rb

@@ -0,0 +1,18 @@
+module QML
+  module JSUtil
+
+    def self.data
+      @data ||= QML.engine.evaluate <<-JS
+        ({
+          classes: {
+            Date: Date
+          }
+        })
+      JS
+    end
+
+    def self.classes
+      data.classes
+    end
+  end
+end

data/lib/qml/plugin_loader.rb

@@ -6,9 +6,6 @@ module QML
   # @see http://qt-project.org/doc/qt-5/qpluginloader.html QPluginLoader (C++)
   class PluginLoader
 
-    alias_method :initialize_orig, :initialize
-    private :initialize_orig
-
     # @overload initialize(path)
     #   @param [String|Pathname] path the library path (may be platform-dependent).
     #   @example
@@ -20,18 +17,9 @@ module QML
     #      loader = QML::PluginLoader.new('path/to', 'hoge')
     def initialize(path, libname = nil)
       path = Pathname(path) + self.class.lib_filename(libname) if libname
-      initialize_orig(path.to_s)
+      initialize_impl(path.to_s)
     end
 
-    # @!method instance
-    #   Loads the plugin and returns the instance of the plugin.
-    #   @return [QtObjectBase]
-
-    # @param [String] libname
-    # @return [String] platform-dependent library file name.
-    # @example
-    #   # on Mac
-    #   QML::PluginLoader.lib_filename("hoge") #=> "libhoge.dylib"
     def self.lib_filename(libname)
       case
       when Platform::windows?