tk_as_gem 0.0.0

data/ext/lib/tkextlib/blt/unix_dnd.rb

@@ -0,0 +1,135 @@
+#
+#  tkextlib/blt/unix_dnd.rb
+#
+#    *** This is alpha version, because there is no document on BLT. ***
+#
+#                               by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+
+require 'tk'
+require 'tkextlib/blt.rb'
+
+module Tk::BLT
+  module DnD
+    extend TkCore
+
+    TkCommandNames = ['::blt::dnd'.freeze].freeze
+
+    ##############################
+
+    extend TkItemConfigMethod
+
+    class << self
+      def __item_cget_cmd(id)
+        ['::blt::dnd', *id]
+      end
+      private :__item_cget_cmd
+
+      def __item_config_cmd(id)
+        ['::blt::dnd', *id]
+      end
+      private :__item_config_cmd
+
+      private :itemcget, :itemcget_strict
+      private :itemconfigure, :itemconfiginfo, :current_itemconfiginfo
+
+      def cget(win, option)
+        itemcget(['cget', win], option)
+      end
+      def cget_strict(win, option)
+        itemcget_strict(['cget', win], option)
+      end
+      def configure(win, slot, value=None)
+        itemconfigure(['configure', win], slot, value)
+      end
+      def configinfo(win, slot=nil)
+        itemconfiginfo(['configure', win], slot)
+      end
+      def current_configinfo(win, slot=nil)
+        current_itemconfiginfo(['configure', win], slot)
+      end
+
+      def token_cget(win, option)
+        itemcget(['token', 'cget', win], option)
+      end
+      def token_cget_strict(win, option)
+        itemcget_strict(['token', 'cget', win], option)
+      end
+      def token_configure(win, slot, value=None)
+        itemconfigure(['token', 'configure', win], slot, value)
+      end
+      def token_configinfo(win, slot=nil)
+        itemconfiginfo(['token', 'configure', win], slot)
+      end
+      def current_token_configinfo(win, slot=nil)
+        current_itemconfiginfo(['token', 'configure', win], slot)
+      end
+
+      def token_windowconfigure(win, slot, value=None)
+        itemconfigure(['token', 'window', win], slot, value)
+      end
+      def token_windowconfiginfo(win, slot=nil)
+        itemconfiginfo(['token', 'window', win], slot)
+      end
+      def current_token_windowconfiginfo(win, slot=nil)
+        current_itemconfiginfo(['token', 'window', win], slot)
+      end
+    end
+
+    ##############################
+
+    def self.cancel(win)
+      tk_call('::blt::dnd', 'cancel', *wins)
+    end
+    def self.delete(*wins)
+      tk_call('::blt::dnd', 'delete', *wins)
+    end
+    def self.delete_source(*wins)
+      tk_call('::blt::dnd', 'delete', '-source', *wins)
+    end
+    def self.delete_target(*wins)
+      tk_call('::blt::dnd', 'delete', '-target', *wins)
+    end
+    def self.drag(win, x, y, token=None)
+      tk_call('::blt::dnd', 'drag', win, x, y, token)
+    end
+    def self.drop(win, x, y, token=None)
+      tk_call('::blt::dnd', 'drop', win, x, y, token)
+    end
+    def self.get_data(win, fmt=nil, cmd=nil)
+      if fmt
+        tk_call('::blt::dnd', 'getdata', win, fmt, cmd)
+      else
+        list(tk_call('::blt::dnd', 'getdata', win))
+      end
+    end
+    def self.names(pat=None)
+      list(tk_call('::blt::dnd', 'names', pat))
+    end
+    def self.source_names(pat=None)
+      list(tk_call('::blt::dnd', 'names', '-source', pat))
+    end
+    def self.target_names(pat=None)
+      list(tk_call('::blt::dnd', 'names', '-target', pat))
+    end
+    def self.pull(win, fmt)
+      tk_call('::blt::dnd', 'pull', win, fmt)
+    end
+    def self.register(win, keys={})
+      tk_call('::blt::dnd', 'register', win, keys)
+    end
+    def self.select(win, x, y, timestamp)
+      tk_call('::blt::dnd', 'select', win, x, y, timestamp)
+    end
+    def self.set_data(win, fmt=nil, cmd=nil)
+      if fmt
+        tk_call('::blt::dnd', 'setdata', win, fmt, cmd)
+      else
+        list(tk_call('::blt::dnd', 'setdata', win))
+      end
+    end
+    def self.token(*args)
+      tk_call('::blt::dnd', 'token', *args)
+    end
+  end
+end

data/ext/lib/tkextlib/blt/vector.rb

@@ -0,0 +1,256 @@
+#
+#  tkextlib/blt/vector.rb
+#                               by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+
+require 'tk'
+require 'tkextlib/blt.rb'
+
+module Tk::BLT
+  class Vector < TkVariable
+    TkCommandNames = ['::blt::vector'.freeze].freeze
+
+    def self.create(*args)
+      tk_call('::blt::vector', 'create', *args)
+    end
+
+    def self.destroy(*args)
+      tk_call('::blt::vector', 'destroy', *args)
+    end
+
+    def self.expr(expression)
+      tk_call('::blt::vector', 'expr', expression)
+    end
+
+    def self.names(pat=None)
+      list = simplelist(tk_call('::blt::vector', 'names', pat))
+      TkVar_ID_TBL.mutex.synchronize{
+        list.collect{|name|
+          if TkVar_ID_TBL[name]
+            TkVar_ID_TBL[name]
+          elsif name[0..1] == '::' && TkVar_ID_TBL[name[2..-1]]
+            TkVar_ID_TBL[name[2..-1]]
+          else
+            name
+          end
+        }
+      }
+    end
+
+    ####################################
+
+    def initialize(size=nil, keys={})
+      if size.kind_of?(Hash)
+        keys = size
+        size = nil
+      end
+      if size.kind_of?(Array)
+        # [first, last]
+        size = size.join(':')
+      end
+      if size
+        @id = TkCore::INTERP._invoke('::blt::vector', 'create', 
+                                     "#auto(#{size})", *hash_kv(keys))
+      else
+        @id = TkCore::INTERP._invoke('::blt::vector', 'create', 
+                                     "#auto", *hash_kv(keys))
+      end
+
+      TkVar_ID_TBL.mutex.synchronize{
+        TkVar_ID_TBL[@id] = self
+      }
+
+      @def_default = false
+      @default_val = nil
+
+      @trace_var  = nil
+      @trace_elem = nil
+      @trace_opts = nil
+
+      # teach Tk-ip that @id is global var
+      TkCore::INTERP._invoke_without_enc('global', @id)
+    end
+
+    def destroy
+      tk_call('::blt::vector', 'destroy', @id)
+    end
+
+    def inspect
+      '#<Tk::BLT::Vector: ' + @id + '>'
+    end
+
+    def to_s
+      @id
+    end
+
+    def *(item)
+      list(tk_call(@id, '*', item))
+    end
+
+    def +(item)
+      list(tk_call(@id, '+', item))
+    end
+
+    def -(item)
+      list(tk_call(@id, '-', item))
+    end
+
+    def /(item)
+      list(tk_call(@id, '/', item))
+    end
+
+    def append(*vectors)
+      tk_call(@id, 'append', *vectors)
+    end
+
+    def binread(channel, len=None, keys={})
+      if len.kind_of?(Hash)
+        keys = len
+        len = None
+      end
+      keys = _symbolkey2str(keys)
+      keys['swap'] = None if keys.delete('swap')
+      tk_call(@id, 'binread', channel, len, keys)
+    end
+
+    def clear()
+      tk_call(@id, 'clear')
+      self
+    end
+
+    def delete(*indices)
+      tk_call(@id, 'delete', *indices)
+      self
+    end
+
+    def dup_vector(vec)
+      tk_call(@id, 'dup', vec)
+      self
+    end
+
+    def expr(expression)
+      tk_call(@id, 'expr', expression)
+      self
+    end
+
+    def index(idx, val=None)
+      number(tk_call(@id, 'index', idx, val))
+    end
+
+    def [](idx)
+      index(idx)
+    end
+
+    def []=(idx, val)
+      index(idx, val)
+    end
+
+    def length()
+      number(tk_call(@id, 'length'))
+    end
+
+    def length=(size)
+      number(tk_call(@id, 'length', size))
+    end
+
+    def merge(*vectors)
+      tk_call(@id, 'merge', *vectors)
+      self
+    end
+
+    def normalize(vec=None)
+      tk_call(@id, 'normalize', vec)
+      self
+    end
+
+    def notify(keyword)
+      tk_call(@id, 'notify', keyword)
+      self
+    end
+
+    def offset()
+      number(tk_call(@id, 'offset'))
+    end
+
+    def offset=(val)
+      number(tk_call(@id, 'offset', val))
+    end
+
+    def random()
+      tk_call(@id, 'random')
+    end
+
+    def populate(vector, density=None)
+      tk_call(@id, 'populate', vector, density)
+      self
+    end
+
+    def range(first, last=None)
+      list(tk_call(@id, 'range', first, last))
+    end
+
+    def search(val1, val2=None)
+      list(tk_call(@id, 'search', val1, val2))
+    end
+
+    def set(item)
+      tk_call(@id, 'set', item)
+      self
+    end
+
+    def seq(start, finish=None, step=None)
+      tk_call(@id, 'seq', start, finish, step)
+      self
+    end
+
+    def sort(*vectors)
+      tk_call(@id, 'sort', *vectors)
+      self
+    end
+
+    def sort_reverse(*vectors)
+      tk_call(@id, 'sort', '-reverse', *vectors)
+      self
+    end
+
+    def split(*vectors)
+      tk_call(@id, 'split', *vectors)
+      self
+    end
+
+    def variable(var)
+      tk_call(@id, 'variable', var)
+      self
+    end
+  end
+
+  class VectorAccess < Vector
+    def self.new(name)
+      TkVar_ID_TBL.mutex.synchronize{
+        if TkVar_ID_TBL[name]
+          TkVar_ID_TBL[name]
+        else
+          (obj = self.allocate).instance_eval{
+            initialize(name)
+            TkVar_ID_TBL[@id] = self
+          }
+          obj
+        end
+      }
+    end
+
+    def initialize(vec_name)
+      @id = vec_name
+
+      @def_default = false
+      @default_val = nil
+
+      @trace_var  = nil
+      @trace_elem = nil
+      @trace_opts = nil
+
+      # teach Tk-ip that @id is global var
+      TkCore::INTERP._invoke_without_enc('global', @id)
+    end
+  end
+end

data/ext/lib/tkextlib/blt/watch.rb

@@ -0,0 +1,175 @@
+#
+#  tkextlib/blt/watch.rb
+#                               by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+
+require 'tk'
+require 'tkextlib/blt.rb'
+
+module Tk::BLT
+  class Watch < TkObject
+    extend TkCore
+
+    TkCommandNames = ['::blt::watch'.freeze].freeze
+
+    WATCH_ID_TBL = TkCore::INTERP.create_table
+
+    (BLT_WATCH_ID = ['blt_watch_id'.freeze, '00000'.taint]).instance_eval{
+      @mutex = Mutex.new
+      def mutex; @mutex; end
+      freeze
+    }
+
+    TkCore::INTERP.init_ip_env{
+      WATCH_ID_TBL.mutex.synchronize{ WATCH_ID_TBL.clear }
+    }
+
+    def self.names(state = None)
+      lst = tk_split_list(tk_call('::blt::watch', 'names', state))
+      WATCH_ID_TBL.mutex.synchronize{
+        lst.collect{|name|
+          WATCH_ID_TBL[name] || name
+        }
+      }
+    end
+
+    def __numval_optkeys
+      ['maxlevel']
+    end
+    private :__numval_optkeys
+
+    def __boolval_optkeys
+      ['active']
+    end
+    private :__boolval_optkeys
+
+    def __config_cmd
+      ['::blt::watch', 'configure', self.path]
+    end
+    private :__config_cmd
+
+    def initialize(name = nil, keys = {})
+      if name.kind_of?(Hash)
+        keys = name
+        name = nil
+      end
+
+      if name
+        @id = name.to_s
+      else
+        BLT_WATCH_ID.mutex.synchronize{
+          @id = BLT_WATCH_ID.join(TkCore::INTERP._ip_id_)
+          BLT_WATCH_ID[1].succ!
+        }
+      end
+
+      @path = @id
+
+      WATCH_ID_TBL.mutex.synchronize{
+        WATCH_ID_TBL[@id] = self
+      }
+      tk_call('::blt::watch', 'create', @id, *hash_kv(keys))
+    end
+
+    def activate
+      tk_call('::blt::watch', 'activate', @id)
+      self
+    end
+    def deactivate
+      tk_call('::blt::watch', 'deactivate', @id)
+      self
+    end
+    def delete
+      tk_call('::blt::watch', 'delete', @id)
+      self
+    end
+    def info
+      ret = []
+      lst = tk_split_simplelist(tk_call('::blt::watch', 'info', @id))
+      until lst.empty?
+        k, v, *lst = lst
+        k = k[1..-1]
+        case k
+        when /^(#{__strval_optkeys.join('|')})$/
+          # do nothing
+
+        when /^(#{__numval_optkeys.join('|')})$/
+          begin
+            v = number(v)
+          rescue
+            v = nil
+          end
+
+        when /^(#{__numstrval_optkeys.join('|')})$/
+          v = num_or_str(v)
+
+        when /^(#{__boolval_optkeys.join('|')})$/
+          begin
+            v = bool(v)
+          rescue
+            v = nil
+          end
+
+        when /^(#{__listval_optkeys.join('|')})$/
+          v = simplelist(v)
+
+        when /^(#{__numlistval_optkeys.join('|')})$/
+          v = list(v)
+
+        else
+          if v.index('{')
+            v = tk_split_list(v)
+          else
+            v = tk_tcl2ruby(v)
+          end
+        end
+
+        ret << [k, v]
+      end
+
+      ret
+    end
+    def configinfo(slot = nil)
+      if slot
+        slot = slot.to_s
+        v = cget(slot)
+        if TkComm::GET_CONFIGINFO_AS_ARRAY
+          [slot, v]
+        else
+          {slot=>v}
+        end
+      else
+        if TkComm::GET_CONFIGINFO_AS_ARRAY
+          info
+        else
+          Hash[*(info.flatten)]
+        end
+      end
+    end
+    def cget_strict(key)
+      key = key.to_s
+      begin
+        info.assoc(key)[1]
+      rescue
+        fail ArgumentError, "unknown option '#{key}'"
+      end
+    end
+    def cget(key)
+      unless TkConfigMethod.__IGNORE_UNKNOWN_CONFIGURE_OPTION__
+        cget_strict(key)
+      else
+        begin
+          cget_strict(key)
+        rescue => e
+          if current_configinfo.has_key?(key.to_s)
+            # error on known option
+            fail e
+          else
+            # unknown option
+            nil
+          end
+        end
+      end
+    end
+  end
+end