qml 0.0.1

data/lib/qml/dispatchable.rb

@@ -0,0 +1,34 @@
+module QML
+
+  # {Dispatchable} provides a handy way for asynchronous (queued) method calls
+  # which actually processed later in the event loop.
+  # @see QML.later
+  module Dispatchable
+
+    class Proxy < BasicObject
+      def initialize(obj)
+        @obj = obj
+      end
+
+      # Actually enqueues the method call using {QML.later}.
+      def method_missing(name, *args, &block)
+        ::QML.later do
+          @obj.__send__(name, *args, &block)
+        end
+      end
+    end
+
+    # Returns a proxy object for calling a method asynchronously within the event loop.
+    # @return [Proxy]
+    # @example
+    #   def on_button_clicked
+    #     Thread.new do
+    #       result = do_task
+    #       later.set_result_to_ui(result)
+    #     end
+    #   end
+    def later
+      Proxy.new(self)
+    end
+  end
+end

data/lib/qml/dispatcher.rb

@@ -0,0 +1,61 @@
+require 'singleton'
+require 'monitor'
+
+module QML
+
+  class Dispatcher
+    include Singleton
+    include MonitorMixin
+
+    MAX_DURATION = 1/10.to_r
+
+    def initialize
+      @tasks = []
+      super
+    end
+
+    def add_task(&task)
+      synchronize do
+        @tasks << task
+      end
+    end
+
+    def empty?
+      synchronize do
+        @tasks.empty?
+      end
+    end
+
+    def run_tasks
+      synchronize do
+        start_time = Time.now
+        loop do
+          break if @tasks.empty?
+          break if start_time.to_r - Time.now.to_r > MAX_DURATION
+          task = @tasks.shift
+          task.call
+        end
+      end
+    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.
+  # Use this method to set results of asynchronous tasks to UI.
+  # @example
+  #   def on_button_clicked
+  #     Thread.new do
+  #       result = do_task
+  #       QML.later do
+  #         set_result_to_ui(result)
+  #       end
+  #     end
+  #   end
+  # @see Dispatchable#later
+  # @see Dispatcher#add_task
+  def later(&block)
+    Dispatcher.instance.add_task(&block)
+  end
+  module_function :later
+end

data/lib/qml/engine.rb

@@ -0,0 +1,54 @@
+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
+    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
+  end
+
+  # @return [Engine] the instance of {Engine}.
+  # @see Engine.instance
+  def engine
+    Kernel.engine
+  end
+  module_function :engine
+end

data/lib/qml/error_converter.rb

@@ -0,0 +1,15 @@
+module QML
+  module ErrorConverter
+
+    class << self
+      attr_reader :patterns
+
+      def add_pattern(cpp_classname, ruby_class)
+        @patterns ||= {}
+        @patterns[cpp_classname] = ruby_class
+      end
+    end
+
+    add_pattern 'RubyQml::QmlException', QMLError
+  end
+end

data/lib/qml/errors.rb

@@ -0,0 +1,26 @@
+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/geometry.rb

@@ -0,0 +1,3 @@
+require 'qml/geometry/point'
+require 'qml/geometry/size'
+require 'qml/geometry/rectangle'

data/lib/qml/geometry/point.rb

@@ -0,0 +1,5 @@
+module QML
+  module Geometry
+    class Point < Struct.new(:x, :y); end
+  end
+end

data/lib/qml/geometry/rectangle.rb

@@ -0,0 +1,5 @@
+module QML
+  module Geometry
+    class Rectangle < Struct.new(:x, :y, :width, :height); end
+  end
+end

data/lib/qml/geometry/size.rb

@@ -0,0 +1,5 @@
+module QML
+  module Geometry
+    class Size < Struct.new(:width, :height); end
+  end
+end

data/lib/qml/image_provider.rb

@@ -0,0 +1,87 @@
+require 'qml/access'
+
+module QML
+
+  # {ImageProvider} is used to provide images manually to QML.
+  #
+  # QML requests images to ImageProviders when you use "image:" URL scheme
+  # (like "image://my_image_provider/foo.png") in source specification of Image elements.
+  #
+  # @example
+  #   class MyImageProvider < QML::ImageProvider
+  #     def request(req)
+  #       Thread.new do
+  #         image_data = load_image_data()
+  #         req.finish(image_data)
+  #       end
+  #     end
+  #   end
+  #   QML.engine.add_image_provider(MyImageProvider.new)
+  #
+  # @see Engine#add_image_provider
+  # @see http://qt-project.org/doc/qt-5/qquickimageprovider.html QQuickImageProvider (C++)
+  # @see http://qt-project.org/doc/qt-5/qml-qtquick-image.html Image (QML)
+
+  class ImageProvider
+
+    # {Request} represents a image request from QML.
+    # @see ImageProvider#request
+    class Request
+      # The image ID.
+      # If you requested "image://my_image_provider/foo/bar.png", the ID would be "foo/bar.png".
+      attr_reader :id
+
+      # Finishes the image request.
+      # @param data [String] The image file data
+      def finish(data)
+        fail ::TypeError, "data must be a String" unless data.is_a? ::String
+        QML.later do
+          @promise.set_data(data)
+        end
+      end
+
+      private
+
+      def initialize(id, promise)
+        @id = id;
+        @promise = promise
+      end
+    end
+
+    attr_reader :qt_image_provider
+
+    def initialize
+      @callback = Callback.new(self)
+      @qt_image_provider = Plugins.core.createImageProvider(@callback)
+      @qt_image_provider.prefer_managed false
+    end
+
+    # @abstract
+    # @param req [Request] 
+    #
+    # Implement this method to handle image requests from QML.
+    #
+    # Call {Request#finish} to finish image loading.
+    # Image loading should be done asynchnorously because this method is called within the event loop.
+
+    def request(req)
+      fail ::NotImplementedError
+    end
+
+    private
+
+    class Callback
+      include QML::Access
+
+      def initialize(provider)
+        super()
+        @provider = provider
+      end
+
+      def request(id, promise)
+        promise.prefer_managed true
+        @provider.request(Request.new(id, promise))
+      end
+    end
+  end
+end

data/lib/qml/meta_object.rb

@@ -0,0 +1,20 @@
+require 'qml/qml'
+require 'qml/class_builder'
+
+module QML
+  class MetaObject
+    alias_method :to_s, :name
+
+    def inspect
+      "<QML::MetaObject:#{self}>"
+    end
+
+    def build_class
+      @@classes ||= {}
+      klass = @@classes[name]
+      builder = ClassBuilder.new(self, klass)
+      builder.build
+      @@classes[name] = builder.klass
+    end
+  end
+end

data/lib/qml/models.rb

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

data/lib/qml/name_helper.rb

@@ -0,0 +1,12 @@
+module QML
+  module NameHelper
+    module_function
+
+    def to_underscore(sym)
+      sym.to_s.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase.to_sym
+    end
+    def to_upper_underscore(sym)
+      to_underscore(sym).upcase
+    end
+  end
+end

data/lib/qml/platform.rb

@@ -0,0 +1,15 @@
+module QML
+
+  module Platform
+    module_function
+
+    def windows?
+      !!(/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM)
+    end
+
+    def mac?
+      !!(/darwin/ =~ RUBY_PLATFORM)
+    end
+  end
+
+end

data/lib/qml/plugin_loader.rb

@@ -0,0 +1,46 @@
+require 'pathname'
+require 'qml/platform'
+
+module QML
+  # {PluginLoader} loads Qt C++ plugins and enables you to use your Qt C++ codes from Ruby easily.
+  # @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
+    #      loader = QML::PluginLoader.new('path/to/libhoge.dylib')
+    # @overload initialize(dir, libname)
+    #   @param [String|Pathname] dir the library directory.
+    #   @param [String] libname the platform-independent library name.
+    #   @example
+    #      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)
+    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?
+        "#{libname}.dll"
+      when Platform::mac?
+        "lib#{libname}.dylib"
+      else
+        "lib#{libname}.so"
+      end
+    end
+  end
+end

data/lib/qml/plugins.rb

@@ -0,0 +1,26 @@
+require 'qml/plugin_loader'
+require 'qml/root_path'
+require 'pathname'
+
+module QML
+  module Plugins
+
+    PATH = ROOT_PATH + 'ext/qml/plugins'
+
+    class << self
+      def core
+        @core ||= load('core')
+      end
+
+      def test_util
+        @test_util ||= load('testutil')
+      end
+
+      private
+
+      def load(name)
+        QML::PluginLoader.new(PATH + name, "rubyqml-#{name}").instance
+      end
+    end
+  end
+end

data/lib/qml/qml.rb

@@ -0,0 +1 @@
+require_relative '../../ext/qml/qml'

data/lib/qml/qt.rb

@@ -0,0 +1,6 @@
+require 'qml/qt_classes'
+
+module QML
+  # @!parse class Qt < QtObjectBase; end
+  class Qt; end
+end