tk 0.1.0

data/lib/tkextlib/bwidget/widget.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: false
+#
+#  tkextlib/bwidget/widget.rb
+#                               by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+
+require 'tk'
+require 'tkextlib/bwidget.rb'
+
+module Tk
+  module BWidget
+    module Widget
+    end
+  end
+end
+
+module Tk::BWidget::Widget
+  include Tk
+  extend Tk
+
+  def self.__pathname
+    'Widget::configure'
+  end
+
+  def self.__cget_cmd
+    ['Widget::cget']
+  end
+
+  def self.__config_cmd
+    ['Widget::configure']
+  end
+
+  def self.cget_strict(slot)
+    slot = slot.to_s
+    info = {}
+    self.current_configinfo.each{|k,v| info[k.to_s] = v if k.to_s == slot}
+    fail RuntimeError, "unknown option \"-#{slot}\""  if info.empty?
+    info.values[0]
+  end
+  def self.cget(slot)
+    self.current_configinfo(slot).values[0]
+  end
+
+  def self.add_map(klass, subclass, subpath, opts)
+    tk_call('Widget::addmap', klass, subclass, subpath, opts)
+  end
+
+  def self.bwinclude(klass, subclass, subpath, *args)
+    tk_call('Widget::bwinclude', klass, subclass, subpath, *args)
+  end
+
+  def self.create(klass, path, rename=None, &b)
+    win = window(tk_call('Widget::create', klass, path, rename))
+    if b
+      if TkCore::WITH_RUBY_VM  ### Ruby 1.9 !!!!
+        win.instance_exec(self, &b)
+      else
+        win.instance_eval(&b)
+      end
+    end
+    win
+  end
+
+  def self.declare(klass, optlist)
+    tk_call('Widget::declare', klass, optlist)
+  end
+
+  def self.define(klass, filename, *args)
+    tk_call('Widget::define', klass, filename, *args)
+  end
+
+  def self.destroy(win)
+    tk_call('Widget::destroy', _epath(win))
+  end
+
+  def self.focus_next(win)
+    tk_call('Widget::focusNext', win)
+  end
+
+  def self.focus_ok(win)
+    tk_call('Widget::focusOk', win)
+  end
+
+  def self.focus_prev(win)
+    tk_call('Widget::focusPrev', win)
+  end
+
+  def self.generate_doc(dir, widgetlist)
+    tk_call('Widget::generate-doc', dir, widgetlist)
+  end
+
+  def self.generate_widget_doc(klass, iscmd, file)
+    tk_call('Widget::generate-widget-doc', klass, iscmd, file)
+  end
+
+  def self.get_option(win, option)
+    tk_call('Widget::getoption', win, option)
+  end
+
+  def self.get_variable(win, varname, my_varname=None)
+    tk_call('Widget::getVariable', win, varname, my_varname)
+  end
+
+  def self.has_changed(win, option, pvalue)
+    tk_call('Widget::hasChanged', win, option, pvalue)
+  end
+
+  def self.init(klass, win, options)
+    tk_call('Widget::init', klass, win, options)
+  end
+
+  def self.set_option(win, option, value)
+    tk_call('Widget::setoption', win, option, value)
+  end
+
+  def self.sub_cget_strict(win, subwidget)
+    tk_call('Widget::subcget', win, subwidget)
+  end
+  def self.sub_cget(win, subwidget)
+    self.sub_cget_strict(win, subwidget)
+  end
+
+  def self.sync_options(klass, subclass, subpath, options)
+    tk_call('Widget::syncoptions', klass, subclass, subpath, options)
+  end
+
+  def self.tkinclude(klass, tkwidget, subpath, *args)
+    tk_call('Widget::tkinclude', klass, tkwidget, subpath, *args)
+  end
+end

data/lib/tkextlib/itcl.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: false
+#
+#  [incr Tcl] support
+#                               by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+
+# call setup script for general 'tkextlib' libraries
+require 'tkextlib/setup.rb'
+
+# call setup script
+require 'tkextlib/itcl/setup.rb'
+
+# load library
+require 'tkextlib/itcl/incr_tcl.rb'

data/lib/tkextlib/itcl/incr_tcl.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: false
+#
+#  tkextlib/itk/incr_tcl.rb
+#                               by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+
+require 'tk'
+
+# call setup script
+require 'tkextlib/itcl.rb'
+
+# TkPackage.require('Itcl', '3.2')
+TkPackage.require('Itcl')
+
+module Tk
+  module Itcl
+    include Tk
+    extend Tk
+
+    LIBRARY = TkVarAccess.new('::itcl::library')
+    PURIST = TkVarAccess.new('::itcl::purist')
+
+    VERSION    = TkCore::INTERP._invoke("set", "::itcl::version").freeze
+    PATCHLEVEL = TkCore::INTERP._invoke("set", "::itcl::patchLevel").freeze
+
+    PACKAGE_NAME = 'Itcl'.freeze
+    def self.package_name
+      PACKAGE_NAME
+    end
+
+    def self.package_version
+      begin
+        TkPackage.require('Itcl')
+      rescue
+        ''
+      end
+    end
+
+    ##############################################
+
+    class ItclObject < TkObject
+      ITCL_CLASSNAME = ''.freeze
+
+      (ITCL_OBJ_ID = ['itclobj'.freeze, TkUtil.untrust('00000')]).instance_eval{
+        @mutex = Mutex.new
+        def mutex; @mutex; end
+        freeze
+      }
+      ITCL_OBJ_TBL = TkUtil.untrust({})
+
+      def initialize(*args)
+        if (@klass = self.class::ITCL_CLASSNAME).empty?
+          fail RuntimeError, 'unknown itcl class (abstract class?)'
+        end
+        Tk::Itcl::ItclObject::ITCL_OBJ_ID.mutex.synchronize{
+          @id = Tk::Itcl::ItclObject::TCL_OBJ_ID.join(TkCore::INTERP._ip_id_)
+          Tk::Itcl::ItclObject::ITCL_OBJ_ID[1].succ!
+        }
+        @path = @id
+      end
+
+      def self.call_proc(name, *args)
+        tk_call("#{ITCL_CLASSNAME}::#{cmd}", *args)
+      end
+
+      def call_method(name, *args)
+        tk_call(@path, name, *args)
+      end
+
+      def isa(klass)
+        bool(tk_call(@path, 'isa', klass))
+      end
+      alias itcl_kind_of? isa
+
+      def info_class
+        tk_call(@path, 'info', 'class')
+      end
+
+      def info_inherit
+        simplelist(tk_call(@path, 'info', 'inherit'))
+      end
+
+      def info_heritage
+        list(tk_call(@path, 'info', 'heritage'))
+      end
+
+      def info_function(*args)
+        if args[-1].kind_of?(Array)
+          params = args.pop
+          params.each{|param|
+            param = param.to_s
+            args << ( (param[0] == ?-)? param: "-#{param}" )
+          }
+        end
+        list(tk_call(@path, 'info', 'function', *args))
+      end
+
+      def info_variable(*args)
+        if args[-1].kind_of?(Array)
+          params = args.pop
+          params.each{|param|
+            param = param.to_s
+            args << ( (param[0] == ?-)? param: "-#{param}" )
+          }
+        end
+        list(tk_call(@path, 'info', 'variable', *args))
+      end
+    end
+
+    ##############################################
+
+    def self.body(klass, func, args, body)
+      tk_call('::itcl::body', "#{klass}::#{func}", args, body)
+    end
+
+    def self.code(cmd, *args)
+      tk_call('::itcl::code', cmd, *args)
+    end
+
+    def self.code_in_namespace(namespace, cmd, *args)
+      tk_call('::itcl::code', '-namespace', namespace, cmd, *args)
+    end
+
+    def self.configbody(klass, var, body)
+      tk_call('::itcl::configbody', "#{klass}::#{var}", body)
+    end
+
+    def self.create_itcl_class(name, body)
+      TkCore::INTERP._invoke('::itcl::class', name, body)
+      klass = Class.new(Tk::Itcl::ItclObject)
+      klass.const_set('ITCL_CLASSNAME', name.dup.freeze)
+      klass
+    end
+
+    def self.delete_itcl_class(*names)
+      tk_call('::itcl::delete', 'class',  *names)
+    end
+
+    def self.delete_itcl_object(*names)
+      tk_call('::itcl::delete', 'object',  *names)
+    end
+
+    def self.delete_namespace(*names)
+      tk_call('::itcl::delete', 'namespace',  *names)
+    end
+
+    def self.ensemble(name, *args)
+      tk_call('::itcl::ensemble', name, *args)
+    end
+
+    def self.find_classes(pat=None)
+      simplelist(tk_call('::itcl::find', 'classes', pat))
+    end
+
+    def self.find_objects(*args)
+      simplelist(tk_call('::itcl::find', 'objects', *args))
+    end
+
+    def self.is_itcl_class(target)
+      bool(tk_call('::itcl::is', 'class', target))
+    end
+
+    def self.is_itcl_object(target)
+      bool(tk_call('::itcl::is', 'object', target))
+    end
+
+    def self.create_local_obj(klass, name, *args)
+      tk_call('::itcl::local', klass, name, *args)
+    end
+
+    def self.is_itcl_instance(klass, target)
+      bool(tk_call('::itcl::is', 'object', '-class', klass, target))
+    end
+
+    def self.scope(var)
+      tk_call('::itcl::scope', var)
+    end
+  end
+end

data/lib/tkextlib/itcl/setup.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: false
+#
+#  setup.rb   --   setup script before calling TkPackage.require()
+#
+#    If you need some setup operations (for example, add a library path
+#    to the library search path) before using Tcl/Tk library packages
+#    wrapped by Ruby scripts in this directory, please write the setup
+#    operations in this file.
+#
+
+
+# set [incr Tcl] library directory
+
+# ENV['ITCL_LIBRARY'] = '/usr/local/ActiveTcl/lib/itcl3.2/'

data/lib/tkextlib/itk.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: false
+#
+#  [incr Tk] support
+#                               by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+
+# call setup script for general 'tkextlib' libraries
+require 'tkextlib/setup.rb'
+
+# call setup script
+require 'tkextlib/itk/setup.rb'
+
+# load library
+require 'tkextlib/itk/incr_tk.rb'

data/lib/tkextlib/itk/incr_tk.rb

@@ -0,0 +1,447 @@
+# frozen_string_literal: false
+#
+#  tkextlib/itk/incr_tk.rb
+#                               by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+
+require 'tk'
+require 'tk/menuspec'
+require 'tkextlib/itcl.rb'
+
+# call setup script
+require 'tkextlib/itk.rb'
+
+#TkPackage.require('Itk', '3.2')
+TkPackage.require('Itk')
+
+module Tk
+  module Itk
+    include Tk
+    extend Tk
+
+    LIBRARY = TkVarAccess.new('::itk::library')
+
+    PACKAGE_NAME = 'Itk'.freeze
+    def self.package_name
+      PACKAGE_NAME
+    end
+
+    def self.package_version
+      begin
+        TkPackage.require('Itk')
+      rescue
+        ''
+      end
+    end
+
+    def self.usual(arg, *args)
+      tk_call('::itk::usual', arg, *args)
+    end
+
+    def self.usual_names
+      list(tk_call('::itk::usual'))
+    end
+
+    ############################
+
+    class Archetype < TkWindow
+      TkCommandNames = [].freeze
+      # WidgetClassName = 'Archetype'.freeze
+      # WidgetClassNames[WidgetClassName] = self
+
+      def self.to_eval
+        '::itk::' << self::WidgetClassName
+      end
+
+      def __destroy_hook__
+        Tk::Itk::Component::ComponentID_TBL.delete(self.path)
+      end
+
+      #### [incr Tk] public methods
+      def component
+        simplelist(tk_send('component'))
+      end
+
+      def component_path(name)
+        window(tk_send('component', name))
+      end
+      alias component_widget component_path
+
+      def component_invoke(name, cmd, *args)
+        window(tk_send('component', name, cmd, *args))
+      end
+
+      def component_obj(*names)
+        names = component if names.empty?
+        names.collect{|name| Tk::Itk::Component.new(self.path, name) }
+      end
+
+      #### [incr Tk] protected methods
+=begin
+      def itk_component_add(visibility, name, create_cmds, option_cmds=None)
+        args = []
+        visibility.each{|v| v = v.to_s; args << ( (v[0] == ?-)? v: "-#{v}" )}
+        args << '--' << name << create_cmd << option_cmds
+        tk_call('itk_component', 'add', *args)
+      end
+
+      def itk_component_delete(*names)
+        tk_call('itk_component', 'delete', *names)
+      end
+
+      def itk_initialize(keys={})
+        tk_call('itk_initialize', keys)
+      end
+
+      def itk_option_add(*args)
+        tk_call('itk_option', 'add', *args)
+      end
+
+      def itk_option_define(name, resource, klass, init, config=None)
+        tk_call('itk_option', 'define', name, resource, klass, init, config)
+      end
+
+      def itk_option_remove(*args)
+        tk_call('itk_option', 'remove', *args)
+      end
+=end
+    end
+
+    ############################
+
+    class Toplevel < Archetype
+      TkCommandNames = ['::itk::Toplevel'].freeze
+      WidgetClassName = 'Toplevel'.freeze
+      WidgetClassNames[WidgetClassName] ||= self
+
+      include Wm
+      include TkMenuSpec
+
+      def __strval_optkeys
+        super() << 'title'
+      end
+      private :__strval_optkeys
+    end
+
+    ############################
+
+    class Widget < Archetype
+      TkCommandNames = ['::itk::Widget'].freeze
+      WidgetClassName = 'Widget'.freeze
+      WidgetClassNames[WidgetClassName] ||= self
+    end
+
+
+    ############################
+
+    class Component < TkObject
+      def __cget_cmd
+        [self.master, 'component', self.name, 'cget']
+      end
+      private :__cget_cmd
+
+      def __config_cmd
+        [self.master, 'component', self.name, 'configure']
+      end
+      private :__config_cmd
+
+      ComponentID_TBL = TkCore::INTERP.create_table
+
+      (Itk_Component_ID = ['itk:component'.freeze, TkUtil.untrust('00000')]).instance_eval{
+        @mutex = Mutex.new
+        def mutex; @mutex; end
+        freeze
+      }
+
+      TkCore::INTERP.init_ip_env{
+        ComponentID_TBL.mutex.synchronize{ ComponentID_TBL.clear }
+      }
+
+      def self.id2obj(master, id)
+        if master.kind_of?(TkObject)
+          master = master.path
+        else
+          master = master.to_s
+        end
+        ComponentID_TBL.mutex.synchronize{
+          if ComponentID_TBL.key?(master)
+            (ComponentID_TBL[master].key?(id))? ComponentID_TBL[master][id]: id
+          else
+            id
+          end
+        }
+      end
+
+      def self.new(master, component=nil)
+        if master.kind_of?(TkObject)
+          master = master.path
+        else
+          master = master.to_s
+        end
+
+        if component.kind_of?(Tk::Itk::Component)
+          component = component.name
+        elsif component
+          component = component.to_s
+        else
+          Itk_Component_ID.mutex.synchronize{
+            component = Itk_Component_ID.join(TkCore::INTERP._ip_id_)
+            Itk_Component_ID[1].succ!
+          }
+        end
+
+        ComponentID_TBL.mutex.synchronize{
+          if ComponentID_TBL.key?(master)
+            if ComponentID_TBL[master].key?(component)
+              return ComponentID_TBL[master][component]
+            end
+          else
+            ComponentID_TBL[master] = {}
+          end
+        }
+
+        super(master, component)
+      end
+
+      def initialize(master, component)
+        @master = master
+        @component = component
+
+        ComponentID_TBL.mutex.synchronize{
+          ComponentID_TBL[@master][@component] = self
+        }
+
+        begin
+          @widget = window(tk_call(@master, 'component', @component))
+          @path = @widget.path
+        rescue
+          @widget = nil
+          @path = nil
+        end
+      end
+
+      def path
+        unless @path
+          begin
+            @widget = window(tk_call(@master, 'component', @component))
+            @path = @widget.path
+          rescue
+            fail RuntimeError, 'component is not assigned to a widget'
+          end
+        end
+        @path
+      end
+
+      def epath
+        path()
+      end
+
+      def to_eval
+        path()
+      end
+
+      def master
+        @master
+      end
+
+      def name
+        @component
+      end
+
+      def widget
+        unless @widget
+          begin
+            @widget = window(tk_call(@master, 'component', @component))
+            @path = @widget.path
+          rescue
+            fail RuntimeError, 'component is not assigned to a widget'
+          end
+        end
+        @widget
+      end
+
+      def widget_class
+        unless @widget
+          begin
+            @widget = window(tk_call(@master, 'component', @component))
+            @path = @widget.path
+            @widget.classname
+          rescue
+            nil
+          end
+        end
+      end
+
+      def method_missing(id, *args)
+        name = id.id2name
+
+        # try 1 : component command
+        begin
+          return tk_call(@master, 'component', @component, name, *args)
+        rescue
+        end
+
+        # try 2 : component configure
+        len = args.length
+        begin
+          case len
+          when 1
+            if name[-1] == ?=
+              return configure(name[0..-2], args[0])
+            else
+              return configure(name, args[0])
+            end
+          when 0
+            return cget(name)
+          end
+        rescue
+        end
+
+        # try 3 : widget method or widget configure
+        begin
+          unless @widget
+            @widget = window(tk_call(@master, 'component', @component))
+            @path = @widget.path
+          end
+          @widget.__send__(id, *args)
+        rescue
+        end
+
+        # unknown method
+        super(id, *args)
+        # fail RuntimeError, "unknown method '#{name}' for #{self.inspect}"
+      end
+
+      def tk_send(cmd, *rest)
+        begin
+          tk_call(@master, 'component', @component, cmd, *rest)
+        rescue
+          unless @path
+            begin
+              @widget = window(tk_call(@master, 'component', @component))
+              @path = @widget.path
+            rescue
+              fail RuntimeError, 'component is not assigned to a widget'
+            end
+          end
+          tk_call(@path, cmd, *rest)
+        end
+      end
+
+      def tk_send_without_enc(cmd, *rest)
+        begin
+          tk_call_without_enc(@master, 'component', @component, cmd, *rest)
+        rescue
+          unless @path
+            begin
+              @widget = window(tk_call(@master, 'component', @component))
+              @path = @widget.path
+            rescue
+              fail RuntimeError, 'component is not assigned to a widget'
+            end
+          end
+          tk_call_without_enc(@path, cmd, *rest)
+        end
+      end
+
+      def tk_send_with_enc(cmd, *rest)
+        begin
+          tk_call_with_enc(@master, 'component', @component, cmd, *rest)
+        rescue
+          unless @path
+            begin
+              @widget = window(tk_call(@master, 'component', @component))
+              @path = @widget.path
+            rescue
+              fail RuntimeError, 'component is not assigned to a widget'
+            end
+          end
+          tk_call_with_enc(@path, cmd, *rest)
+        end
+      end
+
+      #def bind(*args)
+      #  unless @widget
+      #    begin
+      #      @widget = window(tk_call(@master, 'component', @component))
+      #      @path = @widget.path
+      #    rescue
+      #      fail RuntimeError, 'component is not assigned to a widget'
+      #    end
+      #  end
+      #  @widget.bind(*args)
+      #end
+      def bind(context, *args)
+        unless @widget
+          begin
+            @widget = window(tk_call(@master, 'component', @component))
+            @path = @widget.path
+          rescue
+            fail RuntimeError, 'component is not assigned to a widget'
+          end
+        end
+        # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
+        if TkComm._callback_entry?(args[0]) || !block_given?
+          cmd = args.shift
+        else
+          cmd = Proc.new
+        end
+        @widget.bind(context, cmd, *args)
+      end
+
+      #def bind_append(*args)
+      #  unless @widget
+      #    begin
+      #      @widget = window(tk_call(@master, 'component', @component))
+      #      @path = @widget.path
+      #    rescue
+      #      fail RuntimeError, 'component is not assigned to a widget'
+      #    end
+      #  end
+      #  @widget.bind_append(*args)
+      #end
+      def bind_append(context, *args)
+        unless @widget
+          begin
+            @widget = window(tk_call(@master, 'component', @component))
+            @path = @widget.path
+          rescue
+            fail RuntimeError, 'component is not assigned to a widget'
+          end
+        end
+        # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
+        if TkComm._callback_entry?(args[0]) || !block_given?
+          cmd = args.shift
+        else
+          cmd = Proc.new
+        end
+        @widget.bind_append(context, cmd, *args)
+      end
+
+      def bind_remove(*args)
+        unless @widget
+          begin
+            @widget = window(tk_call(@master, 'component', @component))
+            @path = @widget.path
+          rescue
+            fail RuntimeError, 'component is not assigned to a widget'
+          end
+        end
+        @widget.bind_remove(*args)
+      end
+
+      def bindinfo(*args)
+        unless @widget
+          begin
+            @widget = window(tk_call(@master, 'component', @component))
+            @path = @widget.path
+          rescue
+            fail RuntimeError, 'component is not assigned to a widget'
+          end
+        end
+        @widget.bindinfo(*args)
+      end
+
+    end
+  end
+end