nyle 0.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 42ab8fbeb3f524b4e03c3007e5021196296a4492e62ba78ae2b5a596dcb02a46
+  data.tar.gz: 365227d4c2aaf246b5ed0f17cc928b179c533cf90f258fd4533106e91701bd66
+SHA512:
+  metadata.gz: 330e8bac463e481d5066c9313ca6ea94cde526727ec88b9e21f1e9bf27259dab1862dfc60bfd32714591e2ac0c2c3887a46c16262e3c6279bcc46bbd6cc5775a
+  data.tar.gz: 1b98f3ef0709b13780a335109c5e880a1c371c3993598585ff82845f8e66b966a4365809fd0427cb1cc647db7e444d3d8d7bbe44f1d42452b880a0e38f8d8d60

data/.gitignore

@@ -0,0 +1,8 @@
+desktop.ini
+*.gem
+bin/
+doc/*.docx
+samples/.bundle/
+samples/Gemfile
+samples/Gemfile.lock
+samples/readme_torun.txt

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in nyle.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 TODO: Write your name
+
+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,37 @@
+# Nyle
+
+'Nyle' is a minimal graphics framework using Ruby/GTK3 and Cairo.
+
+## Requirements
+
+* Ruby/GTK3
+* rsvg2 (for Windows only)
+
+## Installation
+
+Install it yourself as:
+
+    $ gem install nyle
+
+Or for Windows
+
+    $ gem install nyle
+    $ gem rsvg2
+
+## Usage
+
+```ruby
+require 'nyle'
+```
+
+## Documents
+
+Reference manual: https://github.com/spoolkitamura/nyle/tree/master/doc/Nyle_reference.pdf
+
+## Samples
+
+Reference manual: https://github.com/spoolkitamura/nyle/tree/master/samples
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/lib/nyle/frame.rb

@@ -0,0 +1,107 @@
+
+=begin
+    'Nyle'
+      minimal graphics framework using Ruby/GTK3 and Cairo
+
+      Copyright (c) 2018 Koki Kitamura
+      Released under the MIT license
+      https://opensource.org/licenses/mit-license.php
+=end
+
+module Nyle
+  class Error < StandardError; end
+
+  # Frame
+  class Frame < Gtk::Window
+    include Gdk::Keyval                            # Include key definication to omit 'Gdk::Keyval::' for subclass
+    def initialize(width = DEFAULT_WIDTH, height = DEFAULT_HEIGHT, title: DEFAULT_TITLE)
+      super()
+      self.set_size_request(width, height)
+      self.resizable = false
+      self.title     = title
+      @transition    = []                          # Screen transition table
+      @interval_time = ENV['NYLE_INTERVAL'].to_i   # milli seconds
+      @interval_time = 15 if @interval_time < 5 or @interval_time > 60
+      GLib::Timeout.add(@interval_time) do
+        if @current_screen
+          Nyle.module_eval {
+            _update_mouse_state
+            _update_key_state
+          }
+          update
+          @current_screen.queue_draw unless @current_screen.destroyed?
+        end
+      end
+
+      # Mouse events
+      self.add_events([:button_press_mask,
+                       :button_release_mask])
+
+      # Signal handler for mouse pressed
+      self.signal_connect(:button_press_event) do |widget, event|
+        Nyle.module_eval {
+          _set_mouse_down(event.button, true)
+        }
+        false
+      end
+
+      # Signal handler for mouse released
+      self.signal_connect(:button_release_event) do |widget, event|
+        Nyle.module_eval {
+          _set_mouse_down(event.button, false)
+        }
+        false
+      end
+
+      # Signal handler for key pressed
+      self.signal_connect(:key_press_event) do |widget, event|
+        Nyle.module_eval {
+          _set_key_down(event.keyval, true)
+        }
+        # [debug]
+        # puts "keyname: [#{Gdk::Keyval.to_name(event.keyval)}]"
+        false
+      end
+
+      # Signal handler for key released
+      self.signal_connect(:key_release_event) do |widget, event|
+        Nyle.module_eval {
+          _set_key_down(event.keyval, false)
+        }
+        false
+      end
+
+      self.signal_connect(:destroy) do
+        Gtk.main_quit
+      end
+    end
+
+    def set_current(screen)
+      _set_current(screen)
+    end
+
+    private def _set_current(screen)
+      self.remove(@current_screen) if @current_screen
+      @current_screen = screen
+      self.add(@current_screen)
+      w = @current_screen.width
+      h = @current_screen.height
+      Nyle.module_eval {
+        _set_screen_size(w, h)
+      }
+    end
+
+    private def update
+      @transition.each do |tr|
+        if tr[:current] == @current_screen and tr[:status] == @current_screen.status
+          tr[:current].instance_eval { suspend }                  # Suspend for current screen
+          tr[:next].instance_eval    { resume  }                  # Resume for next screen
+          _set_current(tr[:next])                                 # Change screen
+          self.show_all
+        end
+      end
+    end
+  end
+
+end
+

data/lib/nyle/screen.rb

@@ -0,0 +1,106 @@
+
+=begin
+    'Nyle'
+      minimal graphics framework using Ruby/GTK3 and Cairo
+
+      Copyright (c) 2018 Koki Kitamura
+      Released under the MIT license
+      https://opensource.org/licenses/mit-license.php
+=end
+
+module Nyle
+  class Error < StandardError; end
+
+  # Screen
+  class Screen < Gtk::DrawingArea
+    include Gdk::Keyval                       # Include key definication to omit 'Gdk::Keyval::' for subclass
+    attr_reader :width, :height, :status
+    def initialize(width = DEFAULT_WIDTH, height = DEFAULT_HEIGHT, bgcolor: :WHITE, trace: false)
+      super()
+      @width         = width
+      @height        = height
+      @trace         = trace
+      @bgcolor       = bgcolor
+      @running_count = 0
+      @status        = nil
+
+      # Draw to 'CairoContext' of ImageSurface once, and copy to 'CairoContext' of DrawingArea
+      if @trace
+        # specified color background
+        # [WARN] Segmentation Fault happen after a while
+        #data = sprintf("%02X%02X%02X%02X", Cairo::Color.parse(@bgcolor).b * 255,
+        #                                   Cairo::Color.parse(@bgcolor).g * 255,
+        #                                   Cairo::Color.parse(@bgcolor).r * 255, 255)   # Hex            (e.g. CC7700FF; b=CC, g=77, r=00, a=FF)
+        #data = [data].pack("H*")                                                        # Pack as binary (e.g. \xCC\x77\x00\xFF)
+        #@canvas = Cairo::ImageSurface.new(data * @width * @height, :ARGB32, @width, @height, @width * 4)
+        @canvas = Cairo::ImageSurface.new(@width, @height)
+      else
+        # transparent background
+        @canvas = Cairo::ImageSurface.new(@width, @height)
+      end
+      self.signal_connect(:configure_event) do |widget, event|
+        ;   # For resizing and so on
+      end
+
+      self.signal_connect(:draw) do |widget, cairo_context|
+        # Draw to 'CairoContext' of ImageSurface
+        Cairo::Context.new(@canvas) do |cr|
+          Nyle.module_eval {
+            _set_cr(cr)
+          }
+          unless @trace                       # If not trace, fill screen each time
+            Nyle.cr.set_source_color(@bgcolor)
+            Nyle.cr.paint
+          end
+          update
+          draw
+        end
+        # Copy to 'CairoContext' of DrawingArea
+        Nyle.module_eval {
+          _set_cr(cairo_context)
+        }
+        pattern = Cairo::SurfacePattern.new(@canvas)
+        Nyle.cr.set_source(pattern)
+        Nyle.cr.paint
+        @running_count += 1
+      end
+
+      # Need not only :pointer_motion but also :button_press and :button_release
+      self.add_events([:button_press_mask,
+                       :button_release_mask,
+                       :pointer_motion_mask])
+
+      # Signal handler for mouse position
+      self.signal_connect(:motion_notify_event) do |widget, event|
+        Nyle.module_eval {
+          _set_mouse_pos(event.x, event.y)
+        }
+        false
+      end
+    end
+
+    # When single screen, create frame to show self
+    def show_all(title = DEFAULT_TITLE)
+      f = Nyle::Frame.new(@width, @height, {title: title})
+      f.set_current(self)
+
+      # Workaround for Segmentation Fault when ImageSureface instance create by using RGBA32 data at Screen.initialize
+      f.override_background_color(:normal, Gdk::RGBA::new(Cairo::Color.parse(@bgcolor).r,
+                                                          Cairo::Color.parse(@bgcolor).g,
+                                                          Cairo::Color.parse(@bgcolor).b, 1.0))
+      f.show_all
+      f
+    end
+
+    # Abstract methods to be overriden
+    private def update  ; end
+    private def draw    ; end
+    private def suspend ; end
+    private def resume  ; end
+  end
+
+end
+
+
+# [TODO] :draw counter (for waiting, sleeping, idling)
+

data/lib/nyle/version.rb

@@ -0,0 +1,3 @@
+module Nyle
+  VERSION = "0.5.2"
+end

data/lib/nyle.rb

@@ -0,0 +1,345 @@
+
+=begin
+    'Nyle'
+      minimal graphics framework using Ruby/GTK3 and Cairo
+
+      Copyright (c) 2018 Koki Kitamura
+      Released under the MIT license
+      https://opensource.org/licenses/mit-license.php
+=end
+
+require 'gtk3'
+require 'rbconfig'
+
+require 'nyle/version'
+require 'nyle/frame'
+require 'nyle/screen'
+
+module Nyle
+  class Error < StandardError; end
+
+  DEFAULT_WIDTH  = 640
+  DEFAULT_HEIGHT = 480
+  DEFAULT_TITLE  = 'Nyle'
+
+  @__cr              = nil
+  @__screen_width    = DEFAULT_WIDTH
+  @__screen_height   = DEFAULT_HEIGHT
+  @__mouse_x         = 0
+  @__mouse_y         = 0
+  @__mouse_down      = {}
+  @__mouse_down_last = {}
+  @__mouse_press     = {}
+  @__mouse_release   = {}
+  @__key_down        = {}
+  @__key_down_last   = {}
+  @__key_press       = {}
+  @__key_release     = {}
+  @__mask_control    = false
+  @__mask_shift      = false
+
+  @__os = (
+    host_os = RbConfig::CONFIG['host_os']
+    case host_os
+    when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+      :windows
+    when /darwin|mac os/
+      :mac
+    when /linux/
+      :linux
+    else
+      :unknown
+    end
+  )
+
+
+  # Singleton class
+  class << self
+    # private methods for classes in module 'Nyle'
+    private def _set_cr(cr)
+      @__cr = cr
+    end
+
+    private def _set_screen_size(w, h)
+      @__screen_width  = w
+      @__screen_height = h
+    end
+
+    private def _set_mouse_pos(x, y)
+      @__mouse_x = x
+      @__mouse_y = y
+    end
+
+    private def _set_mouse_down(button, status)
+      @__mouse_down[button] = status
+    end
+
+    private def _set_key_down(keyval, status)
+      @__key_down[keyval] = status
+    end
+
+    private def _update_mouse_state
+      @__mouse_down.each_key do |k|
+        change  = @__mouse_down[k] ^ @__mouse_down_last[k]       # Get change of mouse press status (XOR)
+        press   = change &  @__mouse_down[k]                     # Detect change to press from release
+        release = change & !@__mouse_down[k]                     # Detect change to release from press
+        @__mouse_press[k] = press                                # Set mouse_press status
+        @__mouse_release[k] = release                            # Set mouse_release status
+        @__mouse_down_last[k] = @__mouse_down[k]
+      end
+    end
+
+    private def _update_key_state
+      @__key_down.each_key do |k|
+        change  = @__key_down[k] ^ @__key_down_last[k]           # Get change of key press status (XOR)
+        press   = change &  @__key_down[k]                       # Detect change to press from release
+        release = change & !@__key_down[k]                       # Detect change to release from press
+        @__key_press[k] = press                                  # Set key_press status
+        @__key_release[k] = release                              # Set key_release status
+        @__key_down_last[k] = @__key_down[k]
+
+        if @__key_down[Gdk::Keyval::KEY_Control_L] or
+          @__key_down[Gdk::Keyval::KEY_Control_R]
+          @__mask_control = true                                 # Set true to mask_control status
+        else
+          @__mask_control = false                                # Set false to mask_control status
+        end
+
+        if @__key_down[Gdk::Keyval::KEY_Shift_L] or
+          @__key_down[Gdk::Keyval::KEY_Shift_R]
+          @__mask_shift = true                                   # Set true to mask_shift status
+        else
+          @__mask_shift = false                                  # Set false to mask_shift status
+        end
+      end
+    end
+  end
+
+
+  # module functions for user
+  # (need module_eval{} statement to use including Nyle)
+  module_function def cr                      ;  Nyle.module_eval{ @__cr                            } ; end
+  module_function def screen_width            ;  Nyle.module_eval{ @__screen_width                  } ; end
+  module_function def screen_height           ;  Nyle.module_eval{ @__screen_height                 } ; end
+  module_function def mouse_x                 ;  Nyle.module_eval{ @__mouse_x                       } ; end
+  module_function def mouse_y                 ;  Nyle.module_eval{ @__mouse_y                       } ; end
+  module_function def mouse_down?(button)     ;  Nyle.module_eval{ @__mouse_down   [button] == true } ; end
+  module_function def mouse_press?(button)    ;  Nyle.module_eval{ @__mouse_press  [button] == true } ; end
+  module_function def mouse_release?(button)  ;  Nyle.module_eval{ @__mouse_release[button] == true } ; end
+  module_function def key_down?(keyval)       ;  Nyle.module_eval{ @__key_down     [keyval] == true } ; end
+  module_function def key_press?(keyval)      ;  Nyle.module_eval{ @__key_press    [keyval] == true } ; end
+  module_function def key_release?(keyval)    ;  Nyle.module_eval{ @__key_release  [keyval] == true } ; end
+  module_function def mask_control?           ;  Nyle.module_eval{ @__mask_control                  } ; end
+  module_function def mask_shift?             ;  Nyle.module_eval{ @__mask_shift                    } ; end
+  module_function def os                      ;  Nyle.module_eval{ @__os                            } ; end
+
+  module_function def draw_line(x1, y1, x2, y2, weight: 2, cap: :BUTT, color: :BLACK, a: 1.0)
+    cr = Nyle.module_eval{ @__cr }
+    cr.save do
+      cr.line_width = weight
+      cr.line_cap   = cap
+      if a == 1.0
+        cr.set_source_color(color)
+      else
+        cr.set_source_rgba(Cairo::Color.parse(color).r, 
+                           Cairo::Color.parse(color).g, 
+                           Cairo::Color.parse(color).b, a)
+      end
+      cr.move_to(x1, y1)
+      cr.line_to(x2, y2)
+      cr.stroke
+    end
+  end
+
+  module_function def draw_rect(x, y, w, h, weight: 2, cap: :BUTT, color: :BLACK, round: 0, fill: false, a: 1.0)
+    cr = Nyle.module_eval{ @__cr }
+    cr.save do
+      cr.line_width = weight
+      cr.line_cap   = cap
+      if a == 1.0
+        cr.set_source_color(color)
+      else
+        cr.set_source_rgba(Cairo::Color.parse(color).r, 
+                           Cairo::Color.parse(color).g, 
+                           Cairo::Color.parse(color).b, a)
+      end
+      if round
+        cr.rounded_rectangle(x, y, w, h, round, round)
+      else
+        cr.rectangle(x, y, w, h)
+      end
+      if fill
+        cr.fill
+      else
+        cr.stroke
+      end
+    end
+  end
+
+  module_function def draw_circle(x, y, r, weight: 2, color: :BLACK, fill: false, a: 1.0)
+    cr = Nyle.module_eval{ @__cr }
+    cr.save do
+      cr.line_width = weight
+      if a == 1.0
+        cr.set_source_color(color)
+      else
+        cr.set_source_rgba(Cairo::Color.parse(color).r, 
+                           Cairo::Color.parse(color).g, 
+                           Cairo::Color.parse(color).b, a)
+      end
+      cr.circle(x, y, r)
+      if fill
+        cr.fill
+      else
+        cr.stroke
+      end
+    end
+  end
+
+  module_function def draw_shape(points, weight: 2, cap: :BUTT, color: :BLACK, a: 1.0, close: false, fill: false)
+    cr = Nyle.module_eval{ @__cr }
+    cr.save do
+      cr.line_width = weight
+      cr.line_cap   = cap
+      if a == 1.0
+        cr.set_source_color(color)
+      else
+        cr.set_source_rgba(Cairo::Color.parse(color).r, 
+                           Cairo::Color.parse(color).g, 
+                           Cairo::Color.parse(color).b, a)
+      end
+      vertex = points.dup
+      vertex << vertex.first if close   # closed shape
+      vertex.each do |v|
+        cr.line_to(v[0], v[1])
+      end
+      if fill
+        cr.fill
+      else
+        cr.stroke
+      end
+    end
+  end
+
+  module_function def draw_text(x, y, str, size: 32, color: :BLACK, a: 1.0)
+    cr = Nyle.module_eval{ @__cr }
+    cr.save do
+      cr.select_font_face("+")   # Temporaly use "+"  [TODO] (Need to confirm font name)
+      cr.font_size = size
+      if a == 1.0
+        cr.set_source_color(color)
+      else
+        cr.set_source_rgba(Cairo::Color.parse(color).r, 
+                           Cairo::Color.parse(color).g, 
+                           Cairo::Color.parse(color).b, a)
+      end
+      cr.move_to(x, y)
+      cr.show_text(str)
+    end
+  end
+
+  module INNER
+    # for Nyle.load_image* methods
+    class << self
+      private def _load_image(filename, color_key: nil)
+        loaded = GdkPixbuf::Pixbuf.new(file: filename)
+        if color_key
+          # Set transparent color with given color (alpha = 0)
+          loaded.add_alpha(true,
+                           Cairo::Color.parse(color_key).r * 255,   # 0 - 255
+                           Cairo::Color.parse(color_key).g * 255,   # 0 - 255
+                           Cairo::Color.parse(color_key).b * 255)   # 0 - 255
+        else
+          # Not to transpare
+          loaded
+        end
+      end
+    end
+  end
+
+  module_function def load_image(filename, color_key: nil, sx: 1.0, sy: 1.0, cx: nil, cy: nil, cw: nil, ch: nil)
+    loaded = Nyle::INNER.module_eval{ _load_image(filename, color_key: color_key) }
+    if !(cx.nil? or cy.nil? or cw.nil? or ch.nil?)
+      loaded = loaded.subpixbuf(cx, cy, cw, ch)
+    end
+    loaded = loaded.scale(loaded.width * sx, loaded.height * sy)
+  end
+
+  module_function def load_image_tiles(filename, xcount, ycount, color_key: nil, sx: 1.0, sy: 1.0)
+    loaded = Nyle::INNER.module_eval{ _load_image(filename, color_key: color_key) }
+    xcount = 1 if xcount < 1
+    ycount = 1 if ycount < 1
+    cw = loaded.width  / xcount
+    ch = loaded.height / ycount
+    tiles = []
+    for i in (0...xcount) do
+      line = []
+      for j in (0...ycount) do
+        line << loaded.subpixbuf(cw * i, ch * j, cw, ch).scale(cw * sx, ch * sy)
+      end
+      tiles << line
+    end
+    tiles
+  end
+
+  module_function def draw_image(x, y, pixbuf)
+    cr = Nyle.module_eval{ @__cr }
+    cr.save do
+      cr.set_source_pixbuf(pixbuf, x, y)
+      cr.paint
+    end
+  end
+
+  module_function def save_image(filename)
+    cr = Nyle.module_eval{ @__cr }
+    cr.target.write_to_png(filename)
+  end
+
+  module_function def translate(tx, ty)
+    cr = Nyle.module_eval{ @__cr }
+    cr.translate(tx, ty)
+  end
+
+  module_function def rotate(angle)
+    cr = Nyle.module_eval{ @__cr }
+    cr.rotate(angle)
+  end
+
+  module_function def scale(sx, sy)
+    cr = Nyle.module_eval{ @__cr }
+    cr.scale(sx, sy)
+  end
+
+  module_function def quit
+    Gtk.main_quit
+  end
+
+end
+
+
+
+if $0 == __FILE__
+  p Nyle
+  p Nyle.instance_methods
+  p Nyle.private_instance_methods
+ #p Nyle.private_methods
+  p Nyle.protected_methods
+ #p Nyle.public_methods
+  p Nyle.singleton_methods
+
+  p Nyle::Frame
+  p Nyle::Frame.instance_methods(false)
+  p Nyle::Frame.private_instance_methods(false)
+  p Nyle::Frame.singleton_methods(false)
+
+  p Nyle::Screen
+  p Nyle::Screen.instance_methods(false)
+  p Nyle::Screen.private_instance_methods(false)
+  p Nyle::Screen.singleton_methods(false)
+
+  p Nyle.os
+end
+
+
+# [TODO] Font name (draw_text)
+

data/nyle.gemspec

@@ -0,0 +1,44 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "nyle/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "nyle"
+  spec.version       = Nyle::VERSION
+  spec.authors       = ["Koki Kitamura"]
+  spec.email         = ["spool.kitamura@nifty.ne.jp"]
+
+  spec.summary       = %q{minimal graphics framework using Ruby/GTK3 with Cairo}
+  spec.description   = %q{'Nyle' is a minimal graphics framework using Ruby/GTK3 with Cairo}
+  spec.homepage      = "https://github.com/spoolkitamura/nyle"
+  spec.license       = "MIT"
+
+  ## Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  ## to allow pushing to a single host or delete this section to allow pushing to any host.
+  #if spec.respond_to?(:metadata)
+  #  spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  #
+  #  spec.metadata["homepage_uri"] = spec.homepage
+  #  spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  #  spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  #else
+  #  raise "RubyGems 2.0 or newer is required to protect against " \
+  #    "public gem pushes."
+  #end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_runtime_dependency "gtk3", "~> 3.3.0", ">= 3.3.0"
+  spec.add_runtime_dependency "rsvg2", "~> 3.3.0", ">= 3.3.0"
+end