xosd 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8f07a214334ffe8a9a960731a5c37bfb49079d5d
+  data.tar.gz: 642fba3637f1960b6e7a29f2840e49ec48686f15
+SHA512:
+  metadata.gz: 31603176ef270276dec710c1d770b45a9b8a9d4ed64233e0ef23f0849f97eea3c86cfabf7f029bc71983eeb2847e08ba38cf6e595fdfabf603aeb532900898dc
+  data.tar.gz: 1529f243ec028427cfdea09c3f53a4cfe23c3b6795988f9bbfbdebda25117b7c1e7abe946df03a7784649d03b081a54fcf2d12500f54b7059b9ee3b3af2a21b4

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    xosd (1.0.0)
+      ffi
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    ffi (1.9.23)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec
+  xosd!
+
+BUNDLED WITH
+   1.16.1

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Yurie Nagorny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,172 @@
+# xosd
+Ruby wrapper for xosd - X on screen display library
+
+## libxosd version
+The gem was designed for libxosd version 2.2.14 but likely to work with other versions too.
+
+## Usage
+
+### Constructor
+
+Instantiate an instance of XOSD:
+
+```
+require 'xosd'
+
+xosd = XOSD.new
+```
+
+You may pass zero or more of the options to the constructor:
+
+| Option | Description |
+| --- | --- |
+| lines | max number of lines in the on screen message |
+| :position | one of :top, :middle, :bottom |
+| :align | one of :left, :center, :right |
+| :colour | string with message color |
+| :font | string with font |
+| :horizontal_offset | horizontal message offset |
+| :vertical_offset | vertical message offset |
+| :outline_offset | message outline offset |
+| :outline_colour | message outline color |
+| :shadow_offset | message shadow offset |
+| :shadow_colour | message shadow color |
+| :bar_length | length of the percentage or slider bar |
+| :timeout | how long the message is displayed, seconds |
+
+All of the options have the corresponding setter, e.g. you can either:
+
+```
+xosd = XOSD.new(timeout: 5)
+``` 
+
+or
+
+```
+xosd = XOSD.new
+xosd.timeout = 5
+```
+
+Example:
+
+```
+xosd = XOSD.new(
+    position: :bottom,
+    align: :center,
+    vertical_offset: 100,
+    font: '-*-arial-*-*-*-*-*-320-*-*-*-*-*-*',
+    colour: 'black',
+    outline_colour: 'orange',
+    outline_offset: 1,
+    shadow_colour: 'white',
+    shadow_offset: 1,
+    timeout: 3
+)
+xosd.display_string 'A line to display on screen'
+xosd.teardown
+```
+
+### Teardown
+
+When done with displaying on screen messages, make sure to teardown the object by calling the teardown method:
+
+```
+xosd.teardown
+```
+
+If you don't do it, it will try to tear itself down during garbage collection, but you should not depend on it.
+
+### Displaying a string
+
+To display a string use display method:
+
+```
+xosd.display 'A message to display on screen'
+
+```
+
+You may use several lines:
+
+```
+xosd = XOSD.new(lines: 3)
+xosd.display 'First line to display', line: 0
+xosd.display 'Second line to display', line: 1
+xosd.display 'Third line to display', line: 2
+xosd.teardown
+```
+
+You may use #scroll_by to scroll the messages:
+
+```
+xosd.scroll_by 1
+```
+
+
+ 
+### Displaying a percentage bar
+
+To display a bar similar to TV volume bar:
+
+```
+xosd = XOSD.new(bar_length: 100)
+xosd.bar_length = 100 # same effect as above
+xosd.display_bar 50
+```
+
+Use :bar_length constructor option or set bar_length later to define how long the bar will be.
+
+### Displaying a slider
+
+To display a slider similar to TV brightness control:
+
+```
+xosd.display_slider 50
+```
+
+Adjust slider length similar to how it is done for the percentage bar.
+
+### On screen?
+
+Call on_screen? method to find out if anything is being displayed on screen.
+
+```
+xosd.on_screen?
+```
+
+### Wait until message is gone
+
+You may wait for the message to disappear using xosd_wait_until_no_display:
+
+```
+xosd.xosd_wait_until_no_display
+```
+
+### Hide and show
+
+You may hide and show the last displayed message
+
+```
+xosd.dispaly 'A message'
+xosd.hide
+xosd.show
+```
+
+## Virtual machine for gem development
+If you are interested in making changes to the gem, you may want to setup a virtual machine to assist with that.
+
+* Install Virtual Box from https://www.virtualbox.org/
+* Install Vagrant from https://www.vagrantup.com/
+* Provision the virtual machine (it will be named xosd):
+
+    $ vagrant up
+    
+* Add ssh info of the virtual machine to the ssh config:
+
+    $ vagrant ssh-config >> ~/.ssh/config
+    
+* To open an ssh session with the virtual machine (the gem folder will be mounted under /vagrant):
+
+    $ ssh -X xosd
+    
+
+   

data/lib/xosd/xosd.rb

@@ -0,0 +1,126 @@
+require_relative 'xosd_bindings'
+
+class XOSD
+
+  class XOSDError < StandardError; end
+
+  def initialize(opts={})
+    @osd = XOSD_Bindings.xosd_create opts[:lines]||1
+    handle(-1) if @osd.null?
+    ObjectSpace.define_finalizer(self, self.class.method(:finalize).to_proc)
+    self.bar_length = opts[:bar_length] if opts[:bar_length]
+    self.position = opts[:position] if opts[:position]
+    self.align = opts[:align] if opts[:align]
+    self.colour = opts[:colour] if opts[:colour]
+    self.font = opts[:font] if opts[:font]
+    self.horizontal_offset = opts[:horizontal_offset] if opts[:horizontal_offset]
+    self.vertical_offset = opts[:vertical_offset] if opts[:vertical_offset]
+    self.outline_offset = opts[:outline_offset] if opts[:outline_offset]
+    self.outline_colour = opts[:outline_colour] if opts[:outline_colour]
+    self.shadow_offset = opts[:shadow_offset] if opts[:shadow_offset]
+    self.shadow_colour = opts[:shadow_colour] if opts[:shadow_colour]
+    self.timeout = opts[:timeout] if opts[:timeout]
+  end
+
+  def teardown
+    handle(XOSD_Bindings.xosd_destroy(@osd)) if @osd && !@osd.null?
+    @osd = nil
+  end
+
+  def display(string, opts={line: 0})
+    handle(XOSD_Bindings.xosd_display(@osd, opts[:line], :xosd_command, :string, :string, string))
+  end
+
+  def display_bar(percentage, opts={line: 0})
+    handle(XOSD_Bindings.xosd_display(@osd, opts[:line], :xosd_command, :percentage, :int, percentage))
+  end
+
+  def display_slider(percentage, opts={line: 0})
+    handle(XOSD_Bindings.xosd_display(@osd, opts[:line], :xosd_command, :slider, :int, percentage))
+  end
+
+  def on_screen?
+    XOSD_Bindings.xosd_is_onscreen(@osd) != 0
+  end
+
+  def xosd_wait_until_no_display
+    handle(XOSD_Bindings.xosd_wait_until_no_display(@osd))
+  end
+
+  def hide
+    handle(XOSD_Bindings.xosd_hide(@osd))
+  end
+
+  def show
+    handle(XOSD_Bindings.xosd_show(@osd))
+  end
+
+  def colour=(colour)
+    handle(XOSD_Bindings.xosd_set_colour(@osd, colour))
+  end
+
+  def font=(font)
+    handle(XOSD_Bindings.xosd_set_font(@osd, font))
+  end
+
+  # :top, :middle, :bottom
+  def position=(position)
+    handle(XOSD_Bindings.xosd_set_pos(@osd, position))
+  end
+
+  # :left, :center, :right
+  def align=(align)
+    handle(XOSD_Bindings.xosd_set_align(@osd, align))
+  end
+
+  def horizontal_offset=(offset)
+    handle(XOSD_Bindings.xosd_set_horizontal_offset(@osd, offset))
+  end
+
+  def vertical_offset=(offset)
+    handle(XOSD_Bindings.xosd_set_vertical_offset(@osd, offset))
+  end
+
+  def outline_offset=(offset)
+    handle(XOSD_Bindings.xosd_set_outline_offset(@osd, offset))
+  end
+
+  def outline_colour=(colour)
+    handle(XOSD_Bindings.xosd_set_outline_colour(@osd, colour))
+  end
+
+  def shadow_offset=(offset)
+    handle(XOSD_Bindings.xosd_set_shadow_offset(@osd, offset))
+  end
+
+  def shadow_colour=(colour)
+    handle(XOSD_Bindings.xosd_set_shadow_colour(@osd, colour))
+  end
+
+  def bar_length=(length)
+    handle(XOSD_Bindings.xosd_set_bar_length(@osd, length))
+  end
+
+  def lines
+    XOSD_Bindings.xosd_get_number_lines(@osd)
+  end
+
+  def timeout=(period)
+    handle(XOSD_Bindings.xosd_set_timeout(@osd, period))
+  end
+
+  def scroll_by(lines)
+    handle(XOSD_Bindings.xosd_scroll(@osd, lines))
+  end
+
+  private
+
+  def self.finalize(id)
+    ObjectSpace._id2re(id).teardown
+  end
+
+  def handle(result)
+    raise XOSDError.new(XOSD_Bindings.xosd_error) if result == -1
+  end
+
+end

data/lib/xosd/xosd_bindings.rb

@@ -0,0 +1,84 @@
+require 'ffi'
+
+module XOSD_Bindings
+  extend FFI::Library
+  ffi_lib ['xosd', 'libxosd.so.2']
+
+  typedef :pointer, :osd
+
+  enum :xosd_command, [:percentage, :string, :printf, :slider]
+
+  enum :xosd_pos, [:top, :bottom, :middle]
+
+  enum :xosd_align, [:left, :center, :right]
+
+  attach_variable :xosd_error, :string
+  attach_variable :osd_default_font, :string
+  attach_variable :osd_default_colour, :string
+
+  # xosd* xosd_create(int number_lines);
+  attach_function :xosd_create, [:int], :osd
+
+  # int xosd_destroy(xosd* osd);
+  attach_function :xosd_destroy, [:osd], :int
+
+  # int xosd_set_bar_length(xosd * osd, int length);
+  attach_function :xosd_set_bar_length, [:osd, :int], :int
+
+  # int xosd_display (xosd* osd, int line, xosd_command command, ...);
+  attach_function :xosd_display, [:osd, :int, :varargs], :int
+
+  # int xosd_is_onscreen(xosd* osd);
+  attach_function :xosd_is_onscreen, [:osd], :int
+
+  # int xosd_wait_until_no_display(xosd* osd);
+  attach_function :xosd_wait_until_no_display, [:osd], :int
+
+  # int xosd_hide (xosd* osd);
+  attach_function :xosd_hide, [:osd], :int
+
+  # int xosd_show (xosd* osd);
+  attach_function :xosd_show, [:osd], :int
+
+  # int xosd_set_pos (xosd* osd, xosd_pos pos);
+  attach_function :xosd_set_pos, [:osd, :xosd_pos], :int
+
+  # int xosd_set_align (xosd* osd, xosd_align align);
+  attach_function :xosd_set_align, [:osd, :xosd_align], :int
+
+  # int xosd_set_shadow_offset (xosd* osd, int shadow_offset);
+  attach_function :xosd_set_shadow_offset, [:osd, :int], :int
+
+  # int xosd_set_outline_offset(xosd * osd, int outline_offset);
+  attach_function :xosd_set_outline_offset, [:osd, :int], :int
+
+  # int xosd_set_outline_colour(xosd * osd, const char *colour);
+  attach_function :xosd_set_outline_colour, [:osd, :string], :int
+
+  # int xosd_set_shadow_colour(xosd * osd, const char *colour);
+  attach_function :xosd_set_shadow_colour, [:osd, :string], :int
+
+  # int xosd_set_horizontal_offset (xosd* osd, int offset);
+  attach_function :xosd_set_horizontal_offset, [:osd, :int], :int
+
+  # int xosd_set_vertical_offset (xosd* osd, int offset);
+  attach_function :xosd_set_vertical_offset, [:osd, :int], :int
+
+  # int xosd_set_timeout (xosd* osd, int timeout);
+  attach_function :xosd_set_timeout, [:osd, :int], :int
+
+  # int xosd_set_colour (xosd* osd, char* colour);
+  attach_function :xosd_set_colour, [:osd, :string], :int
+
+  # int xosd_set_font (xosd* osd, char* font);
+  attach_function :xosd_set_font, [:osd, :string], :int
+
+  # int xosd_get_colour (xosd* osd, int* red, int* green, int* blue);
+  attach_function :xosd_get_colour, [:osd, :pointer, :pointer, :pointer], :int
+
+  # int xosd_scroll (xosd* osd, int lines);
+  attach_function :xosd_scroll, [:osd, :int], :int
+
+  # int xosd_get_number_lines ( xosd* osd);
+  attach_function :xosd_get_number_lines, [:osd], :int
+end

data/lib/xosd.rb

@@ -0,0 +1 @@
+require 'xosd/xosd'

data/spec/xosd_spec.rb

@@ -0,0 +1,83 @@
+require 'xosd'
+
+RSpec.describe XOSD do
+  describe 'display string' do
+    it 'displays string' do
+      xosd = XOSD.new
+      xosd.display 'A line to display'
+      xosd.teardown
+    end
+    it 'displays multiple string lines and can scroll them' do
+      xosd = XOSD.new(lines: 3)
+      expect(xosd.lines).to eq 3
+      xosd.display 'First line to display', line: 0
+      xosd.display 'Second line to display', line: 1
+      xosd.display 'Third line to display', line: 2
+      xosd.scroll_by 1
+      xosd.teardown
+    end
+    it 'displays string with options' do
+      xosd = XOSD.new(
+                     position: :bottom,
+                     align: :center,
+                     vertical_offset: 100,
+                     font: '-*-arial-*-*-*-*-*-320-*-*-*-*-*-*',
+                     colour: 'black',
+                     outline_colour: 'orange',
+                     outline_offset: 1,
+                     shadow_colour: 'white',
+                     shadow_offset: 1,
+                     timeout: 3
+      )
+      xosd.display 'A line to display on screen'
+      xosd.teardown
+    end
+  end
+  describe 'display percentage' do
+    it 'displays percentage bar' do
+      xosd = XOSD.new(bar_length: 100)
+      xosd.display_bar 50
+      xosd.teardown
+    end
+  end
+  describe 'display slider' do
+    it 'displays slider' do
+      xosd = XOSD.new
+      xosd.bar_length = 100
+      xosd.display_slider 50
+      xosd.teardown
+    end
+  end
+  describe 'on screen?' do
+    it 'is true if something is displayed' do
+      xosd = XOSD.new
+      expect(xosd.on_screen?).to be_falsey
+      xosd.display_slider 50
+      expect(xosd.on_screen?).to be_truthy
+      xosd.teardown
+    end
+  end
+  describe 'xosd_wait_until_no_display' do
+    it 'waits for the onscreen message to disappear' do
+      xosd = XOSD.new(timeout: 1)
+      xosd.display_slider 50
+      expect(xosd.on_screen?).to be_truthy
+      xosd.xosd_wait_until_no_display
+      expect(xosd.on_screen?).to be_falsey
+      xosd.teardown
+    end
+  end
+  describe 'hide and show' do
+    it 'hides and shows the message' do
+      xosd = XOSD.new
+      xosd.display_bar 25
+      expect(xosd.on_screen?).to be_truthy
+      xosd.hide
+      sleep 0.1
+      expect(xosd.on_screen?).to be_falsey
+      xosd.show
+      expect(xosd.on_screen?).to be_truthy
+      xosd.teardown
+    end
+  end
+end

data/xosd.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |spec|
+  spec.name        = 'xosd'
+  spec.version     = '1.0.0'
+  spec.date        = '2018-04-30'
+  spec.summary     = "Ruby wrapper for xosd"
+  spec.description = "Ruby wrapper for xosd - X on screen display library"
+  spec.authors     = ["Yurie Nagorny"]
+  spec.email       = 'ynagorny@bearincorp.com'
+  spec.homepage    = 'https://github.com/ynagorny/xosd'
+  spec.license     = 'MIT'
+
+  git_tracked_files = `git ls-files -z`.split("\x0")
+  gem_ignored_files = `git ls-files -i -X .gemignore -z`.split("\x0")
+  spec.files = git_tracked_files - gem_ignored_files
+
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'ffi'
+
+  spec.add_development_dependency 'rspec'
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: xosd
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yurie Nagorny
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby wrapper for xosd - X on screen display library
+email: ynagorny@bearincorp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- lib/xosd.rb
+- lib/xosd/xosd.rb
+- lib/xosd/xosd_bindings.rb
+- spec/xosd_spec.rb
+- xosd.gemspec
+homepage: https://github.com/ynagorny/xosd
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Ruby wrapper for xosd
+test_files:
+- spec/xosd_spec.rb