Commit: 151a0572fd896a9b542fbbc8771c712b3284672c - ruby-gtk3 (git)

Ruby GTK3移行後のメインリポジトリ

Commit MetaInfo

• Revision: 151a0572fd896a9b542fbbc8771c712b3284672c (tree)
• Zeit: 2014-05-01 23:52:11
• Autor: Shyouzou Sugitani <shy@user...>
• Commiter: Shyouzou Sugitani

Log Message

add kinoko.rb

Ändern Zusammenfassung

• add: lib/ninix/kinoko.rb
• modified: lib/ninix/pix.rb
• modified: lib/ninix/seriko.rb

Diff

--- /dev/null
+++ b/lib/ninix/kinoko.rb
@@ -0,0 +1,599 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright (C) 2004-2014 by Shyouzou Sugitani <[e-mail]>
+#
+#  This program is free software; you can redistribute it and/or modify it
+#  under the terms of the GNU General Public License (version 2) as
+#  published by the Free Software Foundation.  It is distributed in the
+#  hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
+#  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+#  PURPOSE.  See the GNU General Public License for more details.
+#
+
+# TODO:
+# - きのことサーフェスの間に他のウインドウが入ることができてしまうのを直す.
+# - NAYUKI/2.0
+# - 透明度の設定
+
+require 'gettext'
+require "gtk3"
+
+require "ninix/config"
+require "ninix/seriko"
+require "ninix/pix"
+
+module Kinoko
+
+  class Menu
+  include GetText
+
+  bindtextdomain("ninix-aya")
+
+    def initialize(accelgroup)
+      @parent = nil
+      ui_info = <<-EOS
+        <ui>
+          <popup name='popup'>
+            <menuitem action='Settings'/>
+            <menu action='Skin'>
+            </menu>
+            <separator/>
+            <menuitem action='Exit'/>
+          </popup>
+        </ui>
+      EOS
+      @__menu_list = {
+        'settings' => [['Settings', nil, _('Settings...(_O)'), nil,
+                        '', lambda {|a, b| return @parent.handle_request('NOTIFY', 'edit_preferences')}],
+                       '/ui/popup/Settings'],
+        'skin' => [['Skin', nil, _('Skin(_K)'), nil],
+                   nil, '/ui/popup/Skin'],
+        'exit' => [['Exit', nil, _('Exit(_Q)'), nil,
+                    '', lambda {|a, b| return @parent.handle_request('NOTIFY', 'close')}],
+                   '/ui/popup/Exit'],
+      }
+      @__skin_list = nil
+      actions = Gtk::ActionGroup.new('Actions')
+      entry = []
+      for value in @__menu_list.values()
+        entry << value[0]
+      end
+      actions.add_actions(entry)
+      ui_manager = Gtk::UIManager.new()
+      ui_manager.insert_action_group(actions, 0)
+      ui_manager.add_ui(ui_info)
+      @__popup_menu = ui_manager.get_widget('/ui/popup')
+      for key in @__menu_list.keys
+        path = @__menu_list[key][-1]
+        @__menu_list[key][1] = ui_manager.get_widget(path)
+      end
+    end
+
+    def set_responsible(parent)
+      @parent = parent
+    end
+
+    def popup(button)
+      skin_list = @parent.handle_request('GET', 'get_skin_list')
+      set_skin_menu(skin_list)
+      @__popup_menu.popup(nil, nil, button, Gtk.current_event_time())
+    end
+
+    def set_skin_menu(list) ## FIXME
+      key = 'skin'
+      if list
+        menu = Gtk.Menu()
+        for skin in list
+          item = Gtk.MenuItem(skin['title'])
+          item.signal_connect(
+                       'activate',
+                       lambda {|a, k| return @parent.handle_request('NOTIFY', 'select_skin', k)},
+                       [skin])
+          menu.add(item)
+          item.show()
+        end
+        @__menu_list[key][1].set_submenu(menu)
+        menu.show()
+        @__menu_list[key][1].show()
+      else
+        @__menu_list[key][1].hide()
+      end
+    end
+  end
+
+  class Nayuki
+
+    def initialize()
+    end
+  end
+
+  class Kinoko
+
+    def initialize(skin_list)
+      @skin_list = skin_list
+      @skin = nil
+    end
+
+    def edit_preferences()
+    end
+
+    def finalize()
+      @__running = false
+      self.target.detach_observer(self)
+      if self.skin != nil
+        self.skin.destroy()
+      end
+    end
+
+    def observer_update(event, args)
+      if self.skin == nil
+        return
+      end
+      if ['set position', 'set surface'].include?(event)
+        self.skin.set_position()
+        self.skin.show()
+      elsif event == 'set scale'
+        scale = self.target.get_surface_scale()
+        self.skin.set_scale(scale)
+      elsif event == 'hide'
+        side = args
+        if side == 0 # sakura side
+          self.skin.hide()
+        end
+      elsif event == 'iconified'
+        self.skin.hide()
+      elsif event == 'deiconified'
+        self.skin.show()
+      elsif event == 'finalize'
+        self.finalize()
+      elsif event == 'move surface'
+        side, xoffset, yoffset = args
+        if side == 0 # sakura side
+          self.skin.set_position(xoffset, yoffset)
+        end
+      elsif event == 'raise'
+        side = args
+        if side == 0 # sakura side
+          self.skin.set_position() ## FIXME
+        end
+      else
+        ##logging.debug('OBSERVER(kinoko): ignore - {0}'.format(event))
+      end
+    end
+
+    def load_skin()
+      scale = @target.get_surface_scale()
+      @skin = Skin.new(@accelgroup)
+      @skin.set_responsible(@target)
+      @skin.load(@data, scale)
+      print("SKIN: ", @skin, "\n")
+    end
+
+    def handle_request(event_type, event, *arglist, **argdict)
+      #assert ['GET', 'NOTIFY'].include?(event_type)
+      handlers = {
+        'get_target_window' =>  lambda {|a| return self.target.surface.window[0].window}, # XXX
+        'get_kinoko_position' => self.target.get_kinoko_position,
+      }
+      handler = handlers.get(event,
+                             getattr(self, event,
+                                     lambda {|a| return nil})) ## FIXME
+      result = handler(*arglist, **argdict)
+      if event_type == 'GET'
+        return result
+      end
+    end
+
+    def load(data, target)
+      @data = data
+      @target = target
+      @target.attach_observer(self)
+      @accelgroup = Gtk::AccelGroup.new()
+      load_skin()
+      if @skin == nil
+        return 0
+      else
+        self.send_event('OnKinokoObjectCreate')
+      end
+      @__running = true
+      GLib::Timeout.add(10) { do_idle_tasks } # 10[ms]
+      return 1
+    end
+
+    def do_idle_tasks()
+      if @__running
+        return true
+      else
+        return false
+      end
+    end
+
+    def close()
+      self.finalize()
+      self.send_event('OnKinokoObjectDestroy')
+    end
+
+    def send_event(event)
+      if not ['OnKinokoObjectCreate', 'OnKinokoObjectDestroy',
+              'OnKinokoObjectChanging', 'OnKinokoObjectChanged',
+              'OnKinokoObjectInstalled'].include?(event)
+        ## 'OnBatteryLow', 'OnBatteryCritical',
+        ## 'OnSysResourceLow', 'OnSysResourceCritical'
+        return
+      end
+      args = [@data['title'],
+              @data['ghost'],
+              @data['category']]
+      @target.notify_event(event, *args)
+    end
+
+    def get_skin_list()
+      return @skin_list
+    end
+
+    def select_skin(args)
+      self.send_event('OnKinokoObjectChanging')
+      self.skin.destroy()
+      self.data = args
+      self.load_skin()
+      if self.skin == nil
+        return 0
+      else
+        self.send_event('OnKinokoObjectChanged')
+      end
+      return 1
+    end
+  end
+
+  class Skin
+
+    def initialize(accelgroup)
+      @frame_buffer = []
+      @accelgroup = accelgroup
+      @parent = nil
+      @__menu = Menu.new(@accelgroup)
+      @__menu.set_responsible(self)
+    end
+
+    def get_seriko
+      return @seriko
+    end
+
+    def set_responsible(parent)
+      @parent = parent
+    end
+
+    def handle_request(event_type, event, *arglist, **argdict)
+      #assert ['GET', 'NOTIFY'].include?(event_type)
+      handlers = {
+      }
+#      handler = handlers.get(event, getattr(self, event, nil))
+#      if handler == nil
+      if not handlers.include?(event)
+        result = @parent.handle_request(event_type, event, *arglist, **argdict)
+      else
+#        result = handler(*arglist, **argdict)
+        ## FIXME
+        result = class_eval(event) #( *arglist, **argdict)
+      end
+      if event_type == 'GET'
+        return result
+      end
+    end
+
+    def load(data, scale)
+      @data = data
+      @__scale = scale
+      @__shown = false
+      @surface_id = 0 # dummy
+      @window = Pix::TransparentWindow.new()
+      ##self.window.set_title(''.join(('surface.', name)))
+      @window.set_skip_taskbar_hint(true)
+      @window.signal_connect('delete_event') do |w, e|
+        delete(w, e)
+      end
+      @window.add_accel_group(@accelgroup) ## FIXME
+      if @data['animation'] != nil
+        path = File.join(@data['dir'], @data['animation'])
+        actors = {'' => Seriko.get_actors(NConfig.create_from_file(path))}
+      else
+        base = File.basename(@data['base'], ".*")
+        ext = File.extname(@data['base'])
+        path = File.join(@data['dir'], base + 'a.txt')
+        if File.exists?(path)
+          actors = {'' =>  Seriko.get_actors(NConfig.create_from_file(path))}
+        else
+          actors = {'' =>  []}
+        end
+      end
+      print("ACTORS: ", actors, "\n")
+      @seriko = Seriko::Controler.new(actors)
+      @seriko.set_responsible(self) ## FIXME
+      path = File.join(@data['dir'], @data['base'])
+      print("PATH: ", path, "\n")
+      begin
+        @image_surface = Pix.create_surface_from_file(path)
+        w = [8, (@image_surface.width * @__scale / 100).to_i].max
+        h = [8, (@image_surface.height * @__scale / 100).to_i].max
+      rescue #except: ## FIXME
+        @parent.handle_request('NOTIFY', 'close')
+        return
+      end
+      print("SURFACE: ", w, " , ", h, "\n")
+      @path = path
+      @w, @h = w, h
+      @darea = @window.darea # @window.get_child()
+      @darea.set_events(Gdk::Event::EXPOSURE_MASK|
+                        Gdk::Event::BUTTON_PRESS_MASK|
+                        Gdk::Event::BUTTON_RELEASE_MASK|
+                        Gdk::Event::POINTER_MOTION_MASK|
+                        Gdk::Event::LEAVE_NOTIFY_MASK)
+      @darea.signal_connect('button_press_event') do |w, e|
+        button_press(w, e)
+      end
+      @darea.signal_connect('button_release_event') do |w, e|
+        button_release(w, e)
+      end
+      @darea.signal_connect('motion_notify_event') do |w, e|
+          motion_notify(w, e)
+      end
+      @darea.signal_connect('leave_notify_event') do |w, e|
+        leave_notify(w, e)
+      end
+      @darea.signal_connect('draw') do |w, cr|
+        redraw(w, cr)
+      end
+      @window.update_size(@w, @h)
+      set_position()
+      target_window = @parent.handle_request('GET', 'get_target_window')
+      if @data['ontop']
+        @window.set_transient_for(target_window)
+      else
+        target_window.set_transient_for(@window)
+      end
+      show()
+      @seriko.reset(self, '') # XXX
+      @seriko.start(self)
+      @seriko.invoke_kinoko(self)
+    end
+
+    def get_surface_id ## FIXME
+      return @surface_id
+    end
+
+    def get_preference(name) # dummy
+      if name == 'animation_quality'
+        return 1.0
+      else
+        return nil
+      end
+    end
+
+    def show()
+      if not @__shown
+        @window.show_all()
+        @__shown = true
+      end
+    end
+
+    def hide()
+      if @__shown
+        @window.hide_all()
+        @__shown = false
+      end
+    end
+
+    def append_actor(frame, actor)
+      @seriko.append_actor(frame, actor)
+    end
+
+    def set_position(xoffset=0, yoffset=0)
+      base_x, base_y = @parent.handle_request('GET', 'get_kinoko_position', @data['baseposition'])
+      a, b = [[0.5, 1], [0.5, 0], [0, 0.5], [1, 0.5], [0, 1],
+              [1, 1], [0, 0], [1, 0], [0.5, 0.5]][@data['baseadjust']]
+      offsetx = (@data['offsetx'] * @__scale / 100).to_i
+      offsety = (@data['offsety'] * @__scale / 100).to_i
+      @x = base_x - (@w * a).to_i + offsetx + xoffset
+      @y = base_y - (@h * b).to_i + offsety + yoffset
+      @window.move(@x, @y)
+    end
+
+    def set_scale(scale)
+      @__scale = scale
+      reset_surface()
+      set_position()
+    end
+
+    def get_surface() ## FIXME
+      return nil
+    end
+
+    def redraw(widget, cr)
+      scale = @__scale
+      cr.scale(scale / 100.0, scale / 100.0)
+      cr.set_source(@image_surface, 0, 0)
+      cr.set_operator(Cairo::OPERATOR_SOURCE)
+      cr.paint()
+      print("REDRAW: ", cr, "\n")
+    end
+
+    def get_image_surface(surface_id)
+      path = File.join(@data['dir'],
+                       'surface'+ surface_id.to_s + '.png')
+      if File.exists?(path)
+        surface = Pix.create_surface_from_file(path)
+      else
+        surface = nil
+      end
+      return surface
+    end
+
+    def create_image_surface(surface_id)
+      if surface_id != nil and surface_id != ''
+        surface = get_image_surface(surface_id)
+      else
+        surface = Pix.create_surface_from_file(@path)
+      end
+      return surface
+    end
+
+    def update_frame_buffer()
+      print("UPDATE FRAME: ", @seriko.get_base_id, "\n")
+      new_surface = create_image_surface(@seriko.get_base_id)
+      #assert new_surface != nil
+      # draw overlays
+      for surface_id, x, y, method in @seriko.iter_overlays()
+        print("OVERLAY: ", surface_id, x, y, method, "\n")
+        if 1#begin
+          overlay_surface = get_image_surface(surface_id)
+        else#rescue #except:
+          continue
+        end
+        # overlay surface
+        cr = Cairo::Context.new(new_surface)
+        cr.set_source(overlay_surface, x, y)
+        cr.mask(overlay_surface, x, y)
+        #del cr
+      end
+      #self.darea.queue_draw_area(0, 0, w, h)
+      @image_surface = new_surface
+      @darea.queue_draw()
+    end
+
+    def terminate()
+      @seriko.terminate(self)
+    end
+
+    def add_overlay(actor, surface_id, x, y, method)
+      @seriko.add_overlay(self, actor, surface_id, x, y, method)
+    end
+
+    def remove_overlay(actor)
+      @seriko.remove_overlay(actor)
+    end
+
+    def move_surface(xoffset, yoffset)
+      @window.move(@x + xoffset, @y + yoffset)
+    end
+
+    def reset_surface() ## FIXME
+      @seriko.reset(self, '') # XXX
+      path = os.path.join(os.fsencode(@data['dir']),
+                          os.fsencode(@data['base']))
+      w, h = ninix.pix.get_png_size(path)
+      w = [8, (w * @__scale / 100).to_i].max
+      h = [8, (h * @__scale / 100).to_i].max
+      @w, @h = w, h # XXX
+      @window.update_size(w, h)
+      @window.queue_resize()
+      @seriko.start(self)
+      @seriko.invoke_kinoko(self)
+    end
+
+    def set_surface(surface_id, restart=1) ## FIXME
+      path = os.path.join(os.fsencode(@data['dir']),
+                          'surface' + os.fsencode(str(surface_id)) + '.png')
+      if os.path.exists(path)
+        @path = path
+      else
+        #self.path = None
+        @path = File.join(@data['dir'], @data['base'])
+      end
+    end
+
+    def invoke(actor_id, update=0)
+      @seriko.invoke(self, actor_id, update)
+    end
+
+    def delete() #widget, event)
+      @parent.handle_request('NOTIFY', 'close')
+    end
+
+    def destroy()
+      @seriko.destroy()
+      @window.destroy()
+    end
+
+    def button_press(widget, event) ## FIXME
+      @x_root = event.x_root
+      @y_root = event.y_root
+      if event.event_type == Gdk::Event::BUTTON_PRESS
+        click = 1
+      else
+        click = 2
+      end
+      button = event.button
+      if button == 3 and click == 1
+        @__menu.popup(button)
+      end
+      return true
+    end
+
+    def button_release(widget, event) ## FIXME
+    end
+
+    def motion_notify(widget, event) ## FIXME
+    end
+
+    def leave_notify(widget, event) ## FIXME
+    end
+  end
+
+  class TEST
+
+    def initialize(path)
+      @win = Pix::TransparentWindow.new
+      @win.signal_connect('destroy') do
+        Gtk.main_quit
+      end
+      @win.darea.signal_connect('draw') do |w, cr|
+        expose_cb(w, cr)
+      end
+      @surface = Pix.create_surface_from_file(path, true, true)
+      @win.set_default_size(@surface.width, @surface.height)
+      @win.show_all
+      require "ninix/home"
+      kinoko_list = Home.search_kinoko()
+      kinoko = Kinoko.new(kinoko_list)
+      print("K: ", kinoko, "\n")
+      kinoko.load(kinoko_list.sample, self)
+      Gtk.main
+    end
+
+    def notify_event(event, *args) # dummy
+    end
+
+    def handle_request(type, event, *a) # dummy
+      if event == 'get_kinoko_position'
+        return 0, 0
+      end
+    end
+
+    def attach_observer(arg) # dummy
+    end
+
+    def get_surface_scale() # dummy
+      return 100
+    end
+
+    def expose_cb(widget, cr)
+      cr.set_source(@surface, 0, 0)
+      cr.set_operator(Cairo::OPERATOR_SOURCE)
+      cr.paint
+      region = Cairo::Region.new()
+      data = @surface.data
+      for i in 0..(data.size / 4 - 1)
+        if (data[i * 4 + 3].ord) != 0
+          x = i % @surface.width
+          y = i / @surface.width
+          region.union!(x, y, 1, 1)
+        end
+      end
+      @win.input_shape_combine_region(region)
+    end
+  end
+end
+
+$:.unshift(File.dirname(__FILE__))
+
+Kinoko::TEST.new(ARGV.shift)

--- a/lib/ninix/pix.rb
+++ b/lib/ninix/pix.rb
@@ -83,9 +83,12 @@ module Pix
 #        ##self.input_shape_combine_region(region)
 #        _gtkhack.gtkwindow_set_input_shape(self, cr.get_target())
 
-#    def update_size(self, w, h):
+    def update_size(w, h)
 #        self.get_child().set_size_request(w, h) # XXX
 #        self.queue_resize()
+      @darea.set_size_request(w, h) # XXX
+      queue_resize()
+    end
 
 #    def size_allocate(self, widget, event):
 #        new_x, new_y = self.__position

--- a/lib/ninix/seriko.rb
+++ b/lib/ninix/seriko.rb
@@ -22,13 +22,14 @@ module Seriko
 
     def initialize(seriko)
       @seriko = seriko
-      self.request_parent = lambda {|a| return nil} # dummy
+#      self.request_parent = lambda {|a| return nil} # dummy
+      @parent = nil
       @exclusive_actor = nil
       @base_id = nil
       @timeout_id = nil
       reset_overlays()
       @queue = []
-      @fps = Controler.DEFAULT_FPS
+      @fps = DEFAULT_FPS
       @next_tick = 0
       @prev_tick = 0 # XXX
       @active = []
@@ -36,22 +37,27 @@ module Seriko
       @dirty = true
     end
 
-    def set_responsible(request_method)
-      self.request_parent = request_method
+    def set_responsible(parent) #(request_method)
+      ##self.request_parent = request_method
+      @parent = parent
     end
     
     def set_base_id(window, surface_id)
       if surface_id == '-2'
         terminate(window)
-        @base_id = window.surface_id
+        @base_id = window.get_surface_id
       elsif surface_id == '-1'
-        @base_id = window.surface_id
+        @base_id = window.get_surface_id
       else
         @base_id = surface_id
       end
       @dirty = true
     end
 
+    def get_base_id()
+      return @base_id
+    end
+
     def move_surface(xoffset, yoffset)
       @move = [xoffset, yoffset]
     end
@@ -68,7 +74,7 @@ module Seriko
         last_actor = actor
         frame, actor = get_actor_next(window)
       end
-      if last_actor != nil and last_actor.exclusive and \
+      if last_actor != nil and last_actor.exclusive? and \
         last_actor.terminate_flag and @exclusive_actor == nil # XXX
         invoke_restart(window)
       end
@@ -76,18 +82,20 @@ module Seriko
 
     def get_actor_next(window)
       if not @active.empty?
-        @active.sort(key=lambda {|x| return x[0]})
+        @active.sort {|x| x[0]} # (key=lambda {|x| return x[0]})
         if @active[0][0] <= @next_tick
-          return @active.pop(0)
+          return @active.shift
         end
       end
       return nil, nil
     end
 
     def update(window)
-      current_tick = GLib.get_monotonic_time() # [microsec]
-      quality = self.request_parent('GET', 'get_preference', 'animation_quality')
-      @fps = Controler.DEFAULT_FPS * quality
+      ##current_tick = GLib.get_monotonic_time() # [microsec]
+      ## FIXME: GLib.get_monotonic_time
+      current_tick = (Time.now.to_f * 1000000).to_i # [microsec]
+      quality = @parent.handle_request('GET', 'get_preference', 'animation_quality')
+      @fps = DEFAULT_FPS * quality
       if @prev_tick == 0 ## First time
         delta_tick = 1000.0 / @fps # [msec]
       else
@@ -104,8 +112,7 @@ module Seriko
         window.move_surface(*@move)
         @move = nil
       end
-      @timeout_id = GLib.timeout_add((1000.0 / @fps).to_i, # [msec]
-                                     @update, window)
+      @timeout_id = GLib::Timeout.add((1000.0 / @fps).to_i) { update(window) } # [msec]
       return false
     end
 
@@ -131,7 +138,6 @@ module Seriko
       begin
         del @overlays[actor]
       rescue # except KeyError:
-        pass
       end
       @dirty = true
     end
@@ -157,7 +163,7 @@ module Seriko
         @queue << actor
         return
       end
-      if actor.exclusive
+      if actor.exclusive?
         lock_exclusive(window, actor)
       end
       actor.invoke(window, @next_tick)
@@ -261,11 +267,11 @@ module Seriko
       terminate(window)
       @next_tick = 0
       @prev_tick = 0 # XXX
-      set_base_id(window, window.surface_id)
+      set_base_id(window, window.get_surface_id)
       if @seriko.include?(surface_id)
         @base_id = surface_id
       else
-        @base_id = window.surface_id
+        @base_id = window.get_surface_id
       end
       @dirty = true # XXX
     end
@@ -276,8 +282,7 @@ module Seriko
       if @timeout_id != nil
         GLib.source_remove(@timeout_id)
       end
-      @timeout_id = GLib.timeout_add((1000.0 / @fps).to_i, # [msec]
-                                     @update, window)
+      @timeout_id = GLib::Timeout.add((1000.0 / @fps).to_i) { update(window) } # [msec]
     end
 
     def terminate(window)
@@ -311,7 +316,7 @@ module Seriko
     end
 
     def iter_overlays()
-      actors = list(@overlays.keys())
+      actors = @overlays.keys()
       temp = []
       for actor in actors
         temp << [actor.get_id(), actor]
@@ -323,13 +328,16 @@ module Seriko
         temp << actor
       end
       actors = temp
+      result = []
       for actor in actors
         surface_id, x, y, method = @overlays[actor]
         ##logging.debug(
         ##    'actor={0:d}, id={1}, x={2:d}, y={3:d}'.format(
         ##        actor.get_id(), surface_id, x, y))
-        yield surface_id, x, y, method
+        #yield surface_id, x, y, method
+        result << [surface_id, x, y, method]
       end
+      return result
     end
   end
 
@@ -343,7 +351,15 @@ module Seriko
       @last_method = nil
       @exclusive = 0
       @post_proc = nil
-      @terminate_flag = 1
+      @terminate_flag = true
+    end
+
+    def exclusive?
+      if @exclusive != 0
+        return true
+      else
+        return false
+      end
     end
 
     def set_post_proc(proc, args)
@@ -372,18 +388,17 @@ module Seriko
     end
 
     def invoke(window, base_frame)
-      @terminate_flag = 0
+      @terminate_flag = false
     end
 
     def update(window, base_frame)
       if @terminate_flag
-        return False
+        return false
       end
-      pass
     end
 
     def terminate()
-      @terminate_flag = 1
+      @terminate_flag = true
       if @post_proc != nil
         proc, args = @post_proc
         @post_proc = nil
@@ -405,23 +420,23 @@ module Seriko
                    'interpolate', 'reduce', 'replace', 'asis']
 
     def show_pattern(window, surface, method, args)
-      if Actor.OVERLAY_SET.include?(@last_method)
+      if OVERLAY_SET.include?(@last_method)
         window.remove_overlay(self)
       end
       if method == 'move'
-        window.seriko.move_surface(args[0], args[1]) ## FIXME
-      elsif Actor.OVERLAY_SET.include?(method)
+        window.get_seriko.move_surface(args[0], args[1]) ## FIXME
+      elsif OVERLAY_SET.include?(method)
         window.add_overlay(self, surface, args[0], args[1], method)
       elsif method == 'base'
-        window.seriko.set_base_id(window, surface) ## FIXME
+        window.get_seriko.set_base_id(window, surface) ## FIXME
       elsif method == 'start'
         window.invoke(args[0], update=1)
       elsif method == 'alternativestart'
         window.invoke(args.sample, update=1)
       elsif method == 'stop'
-        window.seriko.stop_actor(args[0]) ## FIXME
+        window.get_seriko.stop_actor(args[0]) ## FIXME
       elsif method == 'alternativestop'
-        window.seriko.stop_actor(args.sample) ## FIXME
+        window.get_seriko.stop_actor(args.sample) ## FIXME
       else
         raise RuntimeError('should not reach here')
       end
@@ -440,14 +455,14 @@ module Seriko
 
     def invoke(window, base_frame)
       terminate()
-      @terminate_flag = 0
+      @terminate_flag = false
       @pattern = 0
       update(window, base_frame)
     end
 
     def update(window, base_frame)
       if @terminate_flag
-        return False
+        return false
       end
       if @pattern == 0
         @surface_id = window.get_surface()
@@ -459,7 +474,7 @@ module Seriko
       end
       show_pattern(window, surface, method, args)
       window.append_actor(base_frame + interval, self)
-      return False
+      return false
     end
   end
 
@@ -479,14 +494,14 @@ module Seriko
 
     def invoke(window, base_frame)
       terminate()
-      @terminate_flag = 0
+      @terminate_flag = false
       reset()
       window.append_actor(base_frame + @wait, self)
     end
 
     def update(window, base_frame)
       if @terminate_flag
-        return False
+        return false
       end
       if @pattern == 0
         @surface_id = window.get_surface()
@@ -500,7 +515,7 @@ module Seriko
       end
       show_pattern(window, surface, method, args)
       window.append_actor(base_frame + @wait, self)
-      return False
+      return false
     end
   end
 
@@ -515,7 +530,7 @@ module Seriko
 
     def invoke(window, base_frame)
       terminate()
-      @terminate_flag = 0
+      @terminate_flag = false
       @wait = 0
       @pattern = 0
       update(window, base_frame)
@@ -523,7 +538,7 @@ module Seriko
 
     def update(window, base_frame)
       if @terminate_flag
-        return False
+        return false
       end
       if @pattern == 0
         @surface_id = window.get_surface()
@@ -540,7 +555,7 @@ module Seriko
       if @wait >= 0
         window.append_actor(base_frame + @wait, self)
       end
-      return False
+      return false
     end
   end
 
@@ -553,7 +568,7 @@ module Seriko
 
     def invoke(window, base_frame)
       terminate()
-      @terminate_flag = 0
+      @terminate_flag = false
       @wait = 0
       @pattern = 0
       update(window, base_frame)
@@ -561,7 +576,7 @@ module Seriko
 
     def update(window, base_frame)
       if @terminate_flag
-        return False
+        return false
       end
       if @pattern == 0
         @surface_id = window.get_surface()
@@ -578,7 +593,7 @@ module Seriko
       if @wait >= 0
         window.append_actor(base_frame + @wait, self)
       end
-      return False
+      return false
     end
   end
 
@@ -586,11 +601,9 @@ module Seriko
   class Mayuna < Actor
 
     def set_exclusive()
-        pass
     end
 
     def show_pattern(window, surface, method, args)
-        pass
     end
   end