glimmer 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e54e98c5ffbe3d68414f3d50103d1d4871ba6a7d9a620b78c57850df8cd7247
-  data.tar.gz: 445cccf31afff2be026317731bd08d3cf51fe79fc3ae166ffd75ed7d93291f5e
+  metadata.gz: e13a3990377287df2bf023f72f4c6ab4b1cb8a58b4dad96321f4ac59e9efde11
+  data.tar.gz: 829597311c7719af97c326fd6f456038c1df94a76d8f140dd8acc430a8a951d4
 SHA512:
-  metadata.gz: 712e885e76e573b302a961e00a21b680d236aa4d63567e57c6d4dd014f3f57cddb82f72259769695bea4f4a7eb3da768153827f0554fe73002605944f6e60701
-  data.tar.gz: 93152749050dd124163b074260dc1c587fff26726d157808436922cb99aca5acd2156377b8e32344ee9a53cc686bac5ada5127ee96161e81622e159b2bd999cc
+  metadata.gz: 344b90942d68a6bd994b09eb0e0848f996d57da0526cf54a6fc11f9718aae850b3e53419ba8bb418470f303fda278283ae99420d6a04bbd2cbab5b22e9ad250e
+  data.tar.gz: 486bbbf6de699a7d3985eea76a5588a83fe32c8a1484648d68b026237390427c2e14b8083b59874f0e0a87454c8d0a05449ca12016ba950c2271d7ac0da7e960

data/README.markdown

@@ -1,4 +1,4 @@
-# Glimmer 0.5.3 Beta (JRuby Desktop UI DSL + Data-Binding)
+# Glimmer 0.5.4 Beta (JRuby Desktop UI DSL + Data-Binding)
 [![Coverage Status](https://coveralls.io/repos/github/AndyObtiva/glimmer/badge.svg?branch=master)](https://coveralls.io/github/AndyObtiva/glimmer?branch=master)
 
 Glimmer is a native-UI cross-platform desktop development library written in Ruby. Glimmer's main innovation is a JRuby DSL that enables productive and efficient authoring of desktop application user-interfaces while relying on the robust platform-native Eclipse SWT library. Glimmer additionally innovates by having built-in data-binding support to greatly facilitate synchronizing the UI with domain models. As a result, that achieves true decoupling of object oriented components, enabling developers to solve business problems without worrying about UI concerns, or alternatively drive development UI-first, and then write clean business components test-first afterwards.
@@ -111,19 +111,19 @@ Please follow these instructions to make the `glimmer` command available on your
 
 Run this command to install directly:
 ```
-jgem install glimmer -v 0.5.3
+jgem install glimmer -v 0.5.4
 ```
 
 ### Option 2: Bundler
 
 Add the following to `Gemfile`:
 ```
-gem 'glimmer', '~> 0.5.3'
+gem 'glimmer', '~> 0.5.4'
 ```
 
 And, then run:
 ```
-bundle install
+jruby -S bundle install
 ```
 
 ## Glimmer Command
@@ -153,7 +153,7 @@ bin/glimmer samples/hello_world.rb
 ### Advanced Usage
 
 ```
-glimmer [[-jruby-option]...] application.rb [[application2.rb]...]
+glimmer [--log-level=VALUE] [[ENV_VAR=VALUE]...] [[-jruby-option]...] application.rb [[application2.rb]...]
 ```
 
 Accepts JRuby options and multiple Glimmer applications to run simultaneously, each in a JRuby thread.
@@ -356,7 +356,7 @@ Example (you may copy/paste in [`girb`](#girb-glimmer-irb-command)):
   button {
     text "Press Me"
     on_widget_selected {
-      message_box = MessageBox.new(@shell.widget) # passing SWT Shell widget
+      message_box = MessageBox.new(@shell.swt_widget) # passing SWT Shell widget
       message_box.setText("Surprise")
       message_box.setMessage("You have won $1,000,000!")
       message_box.open      
@@ -481,7 +481,7 @@ In the above example, the `text` widget `enabled` property was data-bound to `#e
 
 #### Colors
 
-Colors make up a subset of widget properties. SWT accepts color objects created with RGB (Red Green Blue) or RGBA (Red Green Blue Alpha). Glimmer supports constructing color objects using the `rgb` and `rgba` DSL methods.
+Colors make up a subset of widget properties. SWT accepts color objects created with RGB (Red Green Blue) or RGBA (Red Green Blue Alpha). Glimmer supports constructing color objects using the `rgb` and `rgba` DSL keywords.
 
 Example:
 
@@ -494,21 +494,21 @@ label {
 # ...
 ```
 
-SWT also supports standard colors available as constants under the `SWT` namespace with the `COLOR_` prefix (e.g. `SWT::COLOR_BLUE`, `SWT::COLOR_WHITE`, `SWT::COLOR_RED`)
+SWT also supports standard colors available as constants under the `SWT` namespace with the `COLOR_` prefix (e.g. `SWT::COLOR_BLUE`)
 
-Glimmer accepts these constants as lowercase Ruby symbols with or without `color_` prefix.
+Glimmer supports constructing colors for these constants as lowercase Ruby symbols (with or without `color_` prefix) passed to `color` DSL keyword
 
 Example:
 
 ```ruby
 # ...
 label {
-  background :black
-  foreground :yellow
+  background color(:black)
+  foreground color(:yellow)
 }
 label {
-  background :color_white
-  foreground :color_red
+  background color(:color_white)
+  foreground color(:color_red)
 }
 # ...
 ```
@@ -522,9 +522,11 @@ https://help.eclipse.org/2019-12/nftopic/org.eclipse.platform.doc.isv/reference/
 
 Glimmer color objects come with an instance method `#swt_color` that returns the actual SWT `Color` object wrapped by the Glimmer color object. It is useful in cases you'd like to do some custom SWT programming outside of Glimmer.
 
-##### `Glimmer::SWT::ColorProxy.new(display = nil, standard_color).swt_color`
+Example:
 
-Glimmer `ColorProxy` class comes with `.color_for` method that builds an actual SWT `Color` object from a standard color string or symbol. Passing a `display` is optional. It is useful in cases you'd like to do some custom SWT programming outside of Glimmer.
+```ruby
+color(:black).swt_color # returns SWT Color object
+```
 
 #### Fonts
 
@@ -976,20 +978,20 @@ shell {
     text "Show 2nd Button"
     visible true
     on_event_show {
-      @button2.widget.setVisible(false)
+      @button2.swt_widget.setVisible(false)
     }
     on_widget_selected {
-      @button2.widget.setVisible(true)
+      @button2.swt_widget.setVisible(true)
     }
   }
   @button2 = button {
     text "Show 1st Button"
     visible false
     on_event_show {
-      @button1.widget.setVisible(false)
+      @button1.swt_widget.setVisible(false)
     }
     on_widget_selected {
-      @button1.widget.setVisible(true)        
+      @button1.swt_widget.setVisible(true)        
     }
   }
 }.open
@@ -1077,7 +1079,7 @@ class TicTacToe
   end
 
   def display_game_over_message(message)
-    message_box = MessageBox.new(@shell.widget)
+    message_box = MessageBox.new(@shell.swt_widget)
     message_box.setText("Game Over")
     message_box.setMessage(message)
     message_box.open
@@ -1313,7 +1315,7 @@ shell { |app_shell|
 
 Glimmer comes with a video widget not in SWT. It comes with very basic video functionality at the moment, such as autoplay by default, displaying controls, looping, and setting background.
 
-Attributes (passed in an options hash as arguments to video widget):
+Options (passed in an options hash as arguments to video widget):
 - `autoplay` (true [default] or false): plays video automatically as soon as loaded
 - `controls` (true [default] or false): displays controls
 - `looped` (true or false [default]): plays video in looped mode
@@ -1324,8 +1326,22 @@ Attributes (passed in an options hash as arguments to video widget):
 - `offset_y` (integer [default: 0]): offset from top border. Could be a negative number if you want to show only an area of the video. Useful when fit_to_height is false to pick an area of the video to display.
 
 Methods:
-- `play`: plays video
-- `pause`: pauses video
+- `#play`: plays video
+- `#pause`: pauses video
+- `#reload`: reloads video restarting from beginning
+- `#position`: position in seconds (and fractions)
+- `#position=`: seeks a new position in video
+- `#duration`: length of video, maximum video position possible
+- `#loaded?`: returns true when video has been initially loaded or reloaded
+- `#playing?`: returns true when video is actively playing
+- `#paused?`: returns true when video is not playing
+- `#ended?`: returns true when video has reached the end (position == duration)
+
+Events (to observe):
+- `on_loaded`: invoked when video `#loaded?` becomes true
+- `on_ended`: invoked when video `#ended?` becomes true
+- `on_playing`: invoked when video `#playing?` becomes true
+- `on_paused`: invoked when video `#paused?` becomes true
 
 Example ([samples/video/hello_video.rb](samples/video/hello_video.rb)):
 
@@ -1346,6 +1362,36 @@ shell {
 }.open
 ```
 
+Example ([samples/video/hello_video_observers.rb](samples/video/hello_video_observers.rb)):
+
+```ruby
+# ...
+def display_video_status(video, status)
+  message_box = MessageBox.new(video.swt_widget.getShell)
+  message_box.setText(status)
+  message = "Video Position: #{video.position} seconds\n"
+  message += "Video Duration: #{video.duration} seconds"
+  message_box.setMessage(message)
+  message_box.open
+end
+
+@shell = shell {
+  minimum_size 800, 500
+  @video = video(file: video_file, background: :black) {
+    on_playing {
+      display_video_status(@video, 'Playing')
+    }
+    on_paused {
+      display_video_status(@video, 'Paused')
+    }
+    on_ended {
+      display_video_status(@video, 'Ended')
+    }
+  }
+}
+@shell.open
+```
+
 #### Browser Widget
 
 Glimmer supports SWT Browser widget, which can load URLs or render HTML. It can even be instrumented with JavaScript when needed (though highly discouraged in Glimmer except for rare cases when leveraging a pre-existing web codebase in a desktop app).
@@ -1377,7 +1423,7 @@ shell {
       </html>
     HTML
     on_completed { # on load of the page execute this JavaScript
-      @browser.widget.execute("alert('Hello, World!');")
+      @browser.swt_widget.execute("alert('Hello, World!');")
     }
   }
 }.open
@@ -1539,10 +1585,8 @@ Glimmer simplifies the process for general packaging on the Mac by providing a r
 
 - Create `Rakefile` in your app root directory
 - Add the following line to it: `require 'glimmer/rake_task'`
-- Create a Ruby script under bin to launch your application (e.g. `bin/math_bowling`) with the following content (replacing `'../app/my_application.rb'` with your application path):
+- Create a Ruby script under bin (e.g. `bin/math_bowling`) to require the application file that uses Glimmer (e.g. `'../app/my_application.rb'`):
 ```ruby
-require 'glimmer/launcher'
-require Glimmer::Launcher.swt_jar_file
 require_relative '../app/my_application.rb'
 ```
 

data/lib/glimmer.rb

@@ -58,7 +58,7 @@ module Glimmer
     if method_symbol.to_s.match(REGEX_METHODS_EXCLUDED)
       raise InvalidKeywordError, "Glimmer excluded keyword: #{method_symbol}"
     end
-    Glimmer.logger&.debug "keyword: " + method_symbol.to_s + " and args: " + args.to_s
+    Glimmer.logger&.debug "Interpreting keyword: #{method_symbol}"
     Glimmer::DSL::Engine.interpret(method_symbol, *args, &block)
   rescue InvalidKeywordError => e
     if !method_symbol.to_s.match(REGEX_METHODS_EXCLUDED)
@@ -69,8 +69,15 @@ module Glimmer
   end
 end
 
+if ENV['GLIMMER_LOGGER_LEVEL']
+  Glimmer.enable_logging
+  Glimmer.logger.level = ENV['GLIMMER_LOGGER_LEVEL'].downcase
+end
+
 $LOAD_PATH.unshift(File.expand_path('..', __FILE__))
 
+require 'glimmer/launcher'
+require Glimmer::Launcher.swt_jar_file
 require 'glimmer/swt/packages'
 require 'glimmer/dsl'
 require 'glimmer/error'

data/lib/glimmer/data_binding/model_binding.rb

@@ -203,7 +203,10 @@ module Glimmer
       end
 
       def evaluate_property
-        invoke_property_reader(model, property_name) unless model.nil?
+        unless model.nil?
+          value = invoke_property_reader(model, property_name)
+          convert_on_read(value)        
+        end
       end
 
       def evaluate_options_property
@@ -219,16 +222,14 @@ module Glimmer
       end
 
       def invoke_property_reader(object, property_expression)
-        value = nil
         if property_indexed?(property_expression)
           property_method = '[]'
           property_argument = property_expression[1...-1]
           property_argument = property_argument.to_i if property_argument.match(/\d+/)
-          value = object.send(property_method, property_argument)
+          object.send(property_method, property_argument)
         else
-          value = object.send(property_expression)
+          object.send(property_expression)
         end
-        convert_on_read(value)
       end
 
       def invoke_property_writer(object, property_expression, value)

data/lib/glimmer/data_binding/widget_binding.rb

@@ -15,13 +15,10 @@ module Glimmer
         @property = property
         @translator = translator || proc {|value| value}
 
-        begin
+        if @widget.respond_to?(:dispose)
           @widget.on_widget_disposed do |dispose_event|
             unregister_all_observables
           end
-        rescue => e
-          # No Op
-          Glimmer.logger&.debug("#{e.message}\n#{e.backtrace.join("\n")}")
         end
       end
       def call(value)

data/lib/glimmer/dsl/custom_widget_expression.rb

@@ -18,7 +18,6 @@ module Glimmer
 
       def interpret(parent, keyword, *args, &block)
         options = args.last.is_a?(Hash) ? args.pop : {}
-        Glimmer.logger&.debug "Custom widget #{keyword} styles are: [" + args.inspect + "] and options are: #{options}"
         UI::CustomWidget.for(keyword).new(parent, *args, options, &block)
       end
 

data/lib/glimmer/dsl/engine.rb

@@ -58,9 +58,9 @@ module Glimmer
         #
         # For example, a shell widget would get properties set and children added
         def add_content(parent, expression, &block)
-          parent_stack.push(parent)
+          parent_stack.push(parent) if expression.is_a?(ParentExpression)
           expression.add_content(parent, &block) if block_given?
-          parent_stack.pop
+          parent_stack.pop if expression.is_a?(ParentExpression)
         end
 
         # Current parent while evaluating Glimmer DSL (nil if just started or done evaluatiing)

data/lib/glimmer/dsl/expression_handler.rb

@@ -23,16 +23,16 @@ module Glimmer
       # Otherwise, it forwards to the next handler configured via `#next=` method
       # If there is no handler next, then it raises an error
       def handle(parent, keyword, *args, &block)
-        Glimmer.logger&.debug "Attempting to handle #{keyword}(#{args}) with #{@expression.class.name.split(":").last}"
+        Glimmer.logger&.debug "Attempting to handle #{keyword} with #{@expression.class.name.split(":").last}"
         if @expression.can_interpret?(parent, keyword, *args, &block)
-          Glimmer.logger&.debug "#{@expression.class.name} will handle expression keyword #{keyword} with arguments #{args}"
+          Glimmer.logger&.debug "#{@expression.class.name} will handle expression keyword #{keyword}"
           return @expression
         elsif @next_expression_handler
           return @next_expression_handler.handle(parent, keyword, *args, &block)
         else
           # TODO see if we need a better response here (e.g. dev mode error raising vs production mode silent failure)
           message = "Glimmer keyword #{keyword} with args #{args} cannot be handled"
-          message += " inside parent #{parent.inspect}" if parent
+          message += " inside parent #{parent}" if parent
           message += "! Check the validity of the code."
           # Glimmer.logger&.error message
           raise InvalidKeywordError, message

data/lib/glimmer/dsl/layout_data_expression.rb

@@ -16,7 +16,6 @@ module Glimmer
       end
 
       def interpret(parent, keyword, *args, &block)
-        Glimmer.logger&.debug "Layout Data args are: #{args.inspect}"
         SWT::LayoutDataProxy.new(parent, args)
       end
     end

data/lib/glimmer/dsl/layout_expression.rb

@@ -18,7 +18,6 @@ module Glimmer
       end
 
       def interpret(parent, keyword, *args, &block)
-        Glimmer.logger&.debug "Layout #{keyword} args are: #{args.inspect}"
         SWT::LayoutProxy.new(keyword, parent, args)
       end
     end

data/lib/glimmer/dsl/static_expression.rb

@@ -19,9 +19,9 @@ module Glimmer
         Glimmer.define_method(keyword) do |*args, &block|
           parent = Glimmer::DSL::Engine.current_parent
           if !static_expression.can_interpret?(parent, keyword, *args, &block)
-            raise Error, "Invalid use of Glimmer keyword #{keyword} with args #{args.inspect} under parent #{parent.inspect}"
+            raise Error, "Invalid use of Glimmer keyword #{keyword} with args #{args} under parent #{parent}"
           else
-            Glimmer.logger&.debug "#{base.name} will handle expression keyword #{keyword} with arguments #{args}"
+            Glimmer.logger&.debug "#{base.name} will handle expression keyword #{keyword}"
             static_expression.interpret(parent, keyword, *args, &block).tap do |ui_object|
               Glimmer::DSL::Engine.add_content(ui_object, static_expression, &block) unless block.nil?
             end

data/lib/glimmer/dsl/widget_expression.rb

@@ -6,17 +6,16 @@ module Glimmer
   module DSL
     class WidgetExpression < Expression
       include ParentExpression
-      
+
       EXCLUDED_KEYWORDS = %w[shell display tab_item]
 
       def can_interpret?(parent, keyword, *args, &block)
         !EXCLUDED_KEYWORDS.include?(keyword) and
-          widget?(parent) and
+          widget?(parent) and #TODO change to composite?(parent)
           SWT::WidgetProxy.widget_exists?(keyword)
       end
 
       def interpret(parent, keyword, *args, &block)
-        Glimmer.logger&.debug "widget styles are: " + args.inspect
         SWT::WidgetProxy.new(keyword, parent, args)
       end
     end

data/lib/glimmer/dsl/widget_listener_expression.rb

@@ -14,7 +14,7 @@ module Glimmer
         Glimmer.logger&.debug "block exists?: #{!block.nil?}"
         raise Glimmer::Error, "Listener is missing block for keyword: #{keyword}" unless block_given?
         Glimmer.logger&.debug "args are empty?: #{args.empty?}"
-        raise Glimmer::Error, "Invalid listener arguments for keyword: #{keyword}(#{args.inspect})" unless args.empty?
+        raise Glimmer::Error, "Invalid listener arguments for keyword: #{keyword}(#{args})" unless args.empty?
         result = parent.can_handle_observation_request?(keyword)
         Glimmer.logger&.debug "can add listener? #{result}"
         raise Glimmer::Error, "Invalid listener keyword: #{keyword}" unless result

data/lib/glimmer/launcher.rb

@@ -4,7 +4,7 @@ module Glimmer
   class Launcher
     OPERATING_SYSTEMS_SUPPORTED = ["mac", "windows", "linux"]
     TEXT_USAGE = <<-MULTILINE
-  Usage: glimmer [[-jruby-option]...] application.rb [[application2.rb]...]
+  Usage: glimmer [--log-level=VALUE] [[ENV_VAR=VALUE]...] [[-jruby-option]...] application.rb [[application2.rb]...]
 
   Runs Glimmer applications using JRuby, automatically preloading
   the glimmer ruby gem and SWT jar dependency.
@@ -16,6 +16,10 @@ module Glimmer
     MULTILINE
     GLIMMER_LIB_LOCAL = File.expand_path(File.join(__FILE__, '..', '..', 'glimmer.rb'))
     GLIMMER_LIB_GEM = 'glimmer'
+    GLIMMER_OPTIONS = %w[--log-level]
+    GLIMMER_OPTION_ENV_VAR_MAPPING = {
+      '--log-level' => 'GLIMMER_LOGGER_LEVEL'
+    }
 
     @@mutex = Mutex.new
 
@@ -50,18 +54,25 @@ module Glimmer
         @glimmer_lib
       end
 
-      def launch(application, options = [])
-        options_string = options.join(' ') + ' ' if options.any?
-        system "jruby #{options_string}#{jruby_swt_options} -r #{glimmer_lib} -S #{application}"
+      def glimmer_option_env_vars(glimmer_options)
+        glimmer_options.map do |k, v|
+          "#{GLIMMER_OPTION_ENV_VAR_MAPPING[k]}=#{v}"
+        end.join(' ')
       end
-    end
 
-    def initialize(options)
-      @application_paths = options.select {|option| !option.start_with?('-')}
-      @application_paths.each do |application_path|
-        options.delete(application_path)
+      def launch(application, jruby_options: [], env_vars: {}, glimmer_options: {})
+        jruby_options_string = jruby_options.join(' ') + ' ' if jruby_options.any?
+        env_vars_string = env_vars.map {|k,v| "#{k}=#{v}"}.join(' ')
+        env_vars_string = [env_vars_string, glimmer_option_env_vars(glimmer_options)].join(' ')
+        system "#{env_vars_string} jruby #{jruby_options_string}#{jruby_os_specific_options} -r #{glimmer_lib} -S #{application}"
       end
-      @options = options
+    end
+
+    def initialize(raw_options)
+      @application_paths = extract_application_paths(raw_options)
+      @env_vars = extract_env_vars(raw_options)
+      @glimmer_options = extract_glimmer_options(raw_options)
+      @jruby_options = raw_options
     end
 
     def launch
@@ -78,7 +89,12 @@ module Glimmer
       threads = @application_paths.map do |application_path|
         puts "Launching Glimmer Application: #{application_path}" unless application_path.to_s.include?('irb')
         Thread.new do
-          self.class.launch(application_path, @options)
+          self.class.launch(
+            application_path,
+            jruby_options: @jruby_options,
+            env_vars: @env_vars,
+            glimmer_options: @glimmer_options
+          )
         end
       end
       threads.each(&:join)
@@ -87,5 +103,37 @@ module Glimmer
     def display_usage
       puts TEXT_USAGE
     end
+
+    def extract_application_paths(options)
+      options.select do |option|
+        !option.start_with?('-') && !option.include?('=')
+      end.each do |application_path|
+        options.delete(application_path)
+      end
+    end
+
+    def extract_env_vars(options)
+      options.select do |option|
+        !option.start_with?('-') && option.include?('=')
+      end.each do |env_var|
+        options.delete(env_var)
+      end.reduce({}) do |hash, env_var_string|
+        match = env_var_string.match(/^([^=]+)=(.+)$/)
+        hash.merge(match[1] => match[2])
+      end
+    end
+
+    def extract_glimmer_options(options)
+      options.select do |option|
+        GLIMMER_OPTIONS.reduce(false) do |result, glimmer_option|
+          result || option.include?(glimmer_option)
+        end
+      end.each do |glimmer_option|
+        options.delete(glimmer_option)
+      end.reduce({}) do |hash, glimmer_option_string|
+        match = glimmer_option_string.match(/^([^=]+)=?(.*)$/)
+        hash.merge(match[1] => match[2])
+      end
+    end
   end
 end

data/lib/glimmer/rake_task.rb

@@ -18,7 +18,6 @@ namespace :glimmer do
     end
     system('mkdir -p dist')
     system('warble')
-    puts("javapackager -deploy -native -outdir packages -outfile #{project_name} -srcdir dist -srcfiles #{project_name}.jar -appclass JarMain -name \"#{project_name}\" -title \"#{project_name}\" -BjvmOptions=-XstartOnFirstThread")
     system("javapackager -deploy -native -outdir packages -outfile #{project_name} -srcdir dist -srcfiles #{project_name}.jar -appclass JarMain -name \"#{project_name}\" -title \"#{project_name}\" -BjvmOptions=-XstartOnFirstThread")
   end
 end

data/lib/glimmer/ui/custom_widget.rb

@@ -25,6 +25,7 @@ module Glimmer
             split(/__/).map do |namespace|
               namespace.camelcase(:upper)
             end
+          #TODO update code to avoid using reduce and going through all of them, yet stop right when it finds something
           custom_widget_class = [Object, Glimmer::UI].reduce([]) do |found, base|
             if found.empty?
               found << namespaces.reduce(base) do |result, namespace|
@@ -135,7 +136,7 @@ module Glimmer
       end
 
       def can_add_observer?(attribute_name)
-        respond_to?(attribute_name) || @body_root.can_add_observer?(attribute_name)
+        respond_to?(attribute_name) || respond_to?("#{attribute_name}?") || @body_root.can_add_observer?(attribute_name)
       end
 
       def add_observer(observer, attribute_name)

data/lib/glimmer/ui/video.rb

@@ -10,15 +10,6 @@ module Glimmer
 
       include_package 'org.eclipse.swt.browser'
 
-      PROPERTIES_OBSERVED = [
-        'playing',
-        'paused',
-        'ended',
-        'started',
-        'remaining',
-        'current_time',
-      ]
-
       options :file, :url
       option :autoplay, true
       option :controls, true
@@ -70,6 +61,9 @@ module Glimmer
               </body>
             </html>
           HTML
+          on_completed {
+            @completed = true
+          }
         }
       }
 
@@ -103,10 +97,137 @@ module Glimmer
         video_action('pause')
       end
 
+      def reload
+        video_action('load')
+      end
+
+      def paused?
+        video_attribute('paused')
+      end
+
+      def playing?
+        !paused?
+      end
+
+      def ended?
+        video_attribute('ended')
+      end
+
+      # Video fully loaded and ready for playback
+      def loaded?
+        !!@completed
+      end
+
+      def position
+        video_attribute('currentTime')
+      end
+
+      def position=(new_position)
+        video_attribute_set('currentTime', new_position)
+      end
+
+      def duration
+        video_attribute('duration')
+      end
+
+      def can_handle_observation_request?(observation_request)
+        result = false
+        if observation_request.start_with?('on_')
+          attribute = observation_request.sub(/^on_/, '')
+          result = OBSERVED_ATTRIBUTE_TO_PROPERTY_MAPPING.keys.include?(attribute)
+        end
+        result || super
+      end
+
+      def handle_observation_request(observation_request, &block)
+        if observation_request.start_with?('on_')
+          attribute = observation_request.sub(/^on_/, '')
+          if attribute == 'loaded' && !@completed
+            super('on_completed', &block)
+          elsif OBSERVED_ATTRIBUTE_TO_PROPERTY_MAPPING.keys.include?(attribute)
+            add_video_observer(block, OBSERVED_ATTRIBUTE_TO_PROPERTY_MAPPING[attribute])
+          else
+            super
+          end
+        end
+      end
+
       private
 
+      class VideoObserverBrowserFunction < BrowserFunction
+        def initialize(video, observer_proc, attribute)
+          @observer_proc = observer_proc
+          @attribute = attribute
+          name = self.class.generate_name(@attribute)
+          super(video.swt_widget, name)
+        end
+
+        def function(arguments)
+          @observer_proc.call
+        rescue => e
+          Glimmer.logger&.error "#{e.message}\n#{e.backtrace.join("\n")}"
+        ensure
+          nil
+        end
+
+        private
+
+        class << self
+          def generate_name(attribute)
+            "video#{attribute}#{generate_attribute_id(attribute)}"
+          end
+
+          def generate_attribute_id(attribute)
+            attribute_max_ids[attribute] = attribute_max_id(attribute) + 1
+          end
+
+          def attribute_max_id(attribute)
+            attribute_max_ids[attribute] ||= 0
+          end
+
+          def attribute_max_ids
+            @attribute_max_ids ||= {}
+          end
+        end
+      end
+
+      OBSERVED_ATTRIBUTE_TO_PROPERTY_MAPPING = {
+        'playing' => 'play',
+        'paused' => 'pause',
+        'ended' => 'ended',
+        'loaded' => 'canplay',
+      }
+
       def video_action(action)
-        swt_widget.execute("document.getElementById('video').#{action}()")
+        run_on_completed do
+          swt_widget.execute("document.getElementById('video').#{action}()")
+        end
+      end
+
+      def video_attribute(attribute)
+        swt_widget.evaluate("return document.getElementById('video').#{attribute}") if @completed
+      end
+
+      def video_attribute_set(attribute, value)
+        value = "'#{value}'" if value.is_a?(String) || value.is_a?(Symbol)
+        run_on_completed do
+          swt_widget.execute("document.getElementById('video').#{attribute} = #{value}")
+        end
+      end
+
+      def add_video_observer(observer_proc, attribute)
+        run_on_completed do
+          video_observer_browser_function = VideoObserverBrowserFunction.new(self, observer_proc, attribute)
+          swt_widget.execute("document.getElementById('video').addEventListener('#{attribute}', function() {#{video_observer_browser_function.getName}()})")
+        end
+      end
+
+      def run_on_completed(&block)
+        if @completed
+          block.call
+        else
+          on_completed(&block)
+        end
       end
 
       def browser_video_autoplay

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glimmer
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - AndyMaleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-04-14 00:00:00.000000000 Z
+date: 2020-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement