tk 0.1.0

data/lib/tkextlib/blt/container.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: false
+#
+#  tkextlib/blt/container.rb
+#                               by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+
+require 'tk'
+require 'tkextlib/blt.rb'
+
+module Tk::BLT
+  class Container < TkWindow
+    TkCommandNames = ['::blt::container'.freeze].freeze
+    WidgetClassName = 'Container'.freeze
+    WidgetClassNames[WidgetClassName] ||= self
+
+    def __strval_optkeys
+      super() << 'name'
+    end
+    private :__strval_optkeys
+
+    def find_command(pat)
+      Hash[*simplelist(tk_send_without_enc('find', '-command', pat))]
+    end
+
+    def find_name(pat)
+      Hash[*simplelist(tk_send_without_enc('find', '-name', pat))]
+    end
+  end
+end

data/lib/tkextlib/blt/cutbuffer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: false
+#
+#  tkextlib/blt/cutbuffer.rb
+#                               by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+
+require 'tk'
+require 'tkextlib/blt.rb'
+
+module Tk::BLT
+  module CutBuffer
+    TkCommandNames = ['::blt::cutbuffer'.freeze].freeze
+
+    def self.get(num = 0)
+      Tk.tk_call('::blt::cutbuffer', 'get', num)
+    end
+    def self.rotate(count = 1)
+      Tk.tk_call('::blt::cutbuffer', 'rotate', count)
+    end
+    def self.set(val, num = 0)
+      Tk.tk_call('::blt::cutbuffer', 'set', val, num)
+    end
+  end
+end

data/lib/tkextlib/blt/dragdrop.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: false
+#
+#  tkextlib/blt/dragdrop.rb
+#                               by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+
+require 'tk'
+require 'tk/itemconfig'
+require 'tkextlib/blt.rb'
+
+module Tk::BLT
+  module DragDrop
+    extend TkCore
+
+    TkCommandNames = ['::blt::drag&drop'.freeze].freeze
+
+    class Token < TkWindow
+      WidgetClassName = 'DragDropToken'.freeze
+      WidgetClassNames[WidgetClassName] ||= self
+
+      def initialize(arg)
+        if arg.kind_of?(Hash) # arg is a hash includes the widgetpath of token
+          arg = _symbolkey2str(arg)
+          install_win(nil, arg['widgetname'])
+        else  # arg is a drag&drop source
+          tk_call('::blt::drag&drop', 'source', arg)
+          install_win(nil, tk_call('::blt::drag&drop', 'token', arg))
+        end
+      end
+    end
+
+    ###################################
+
+    extend TkItemConfigMethod
+    extend Tk::ValidateConfigure
+
+    class << self
+      def __item_config_cmd(id)  # id := ['source'|'target', win]
+        ['::blt::drag&drop', id[0], id[1]]
+      end
+      private :__item_config_cmd
+
+      def __item_boolval_optkeys(id)
+        super(id) << 'selftarget'
+      end
+      private :__item_boolval_optkeys
+
+      def __item_listval_optkeys(id)
+        super(id) << 'send'
+      end
+      private :__item_listval_optkeys
+
+      def __item_strval_optkeys(id)
+        super(id) << 'rejectbg' << 'rejectfg' << 'tokenbg'
+      end
+      private :__item_strval_optkeys
+
+      undef itemcget
+      undef itemcget_tkstring
+      private :itemconfigure, :itemconfiginfo, :current_itemconfiginfo
+
+      def source_configure(win, slot, value=None)
+        itemconfigure(['source', win], slot, value)
+      end
+      def source_configinfo(win, slot=nil)
+        itemconfiginfo(['source', win], slot)
+      end
+      def current_source_configinfo(win, slot=nil)
+        current_itemconfiginfo(['source', win], slot)
+      end
+    end
+
+    class PackageCommand < TkValidateCommand
+      class ValidateArgs < TkUtil::CallbackSubst
+        KEY_TBL = [
+          [ ?t, ?w, :token ],
+          [ ?W, ?w, :widget ],
+          nil
+        ]
+
+        PROC_TBL = [
+          [ ?w, TkComm.method(:window) ],
+          nil
+        ]
+
+=begin
+        # for Ruby m17n :: ?x --> String --> char-code ( getbyte(0) )
+        KEY_TBL.map!{|inf|
+          if inf.kind_of?(Array)
+            inf[0] = inf[0].getbyte(0) if inf[0].kind_of?(String)
+            inf[1] = inf[1].getbyte(0) if inf[1].kind_of?(String)
+          end
+          inf
+        }
+
+        PROC_TBL.map!{|inf|
+          if inf.kind_of?(Array)
+            inf[0] = inf[0].getbyte(0) if inf[0].kind_of?(String)
+          end
+          inf
+        }
+=end
+
+        _setup_subst_table(KEY_TBL, PROC_TBL)
+
+        def self.ret_val(val)
+          val
+        end
+      end
+
+      def self._config_keys
+        ['packagecmd']
+      end
+    end
+
+    class SiteCommand < TkValidateCommand
+      class ValidateArgs < TkUtil::CallbackSubst
+        KEY_TBL = [
+          [ ?s, ?b, :compatible ],
+          [ ?t, ?w, :token ],
+          nil
+        ]
+
+        PROC_TBL = [
+          [ ?b, TkComm.method(:bool) ],
+          [ ?w, TkComm.method(:window) ],
+          nil
+        ]
+
+=begin
+        # for Ruby m17n :: ?x --> String --> char-code ( getbyte(0) )
+        KEY_TBL.map!{|inf|
+          if inf.kind_of?(Array)
+            inf[0] = inf[0].getbyte(0) if inf[0].kind_of?(String)
+            inf[1] = inf[1].getbyte(0) if inf[1].kind_of?(String)
+          end
+          inf
+        }
+
+        PROC_TBL.map!{|inf|
+          if inf.kind_of?(Array)
+            inf[0] = inf[0].getbyte(0) if inf[0].kind_of?(String)
+          end
+          inf
+        }
+=end
+
+        _setup_subst_table(KEY_TBL, PROC_TBL)
+
+        def self.ret_val(val)
+          val
+        end
+      end
+
+      def self._config_keys
+        ['sitecmd']
+      end
+    end
+
+    def self.__validation_class_list
+      super() << PackageCommand << SiteCommand
+    end
+
+    class << self
+      Tk::ValidateConfigure.__def_validcmd(binding, PackageCommand)
+      Tk::ValidateConfigure.__def_validcmd(binding, SiteCommand)
+    end
+
+    ###################################
+
+    class DnD_Handle < TkUtil::CallbackSubst
+      KEY_TBL = [
+        [ ?i, ?s, :ip_name ],
+        [ ?v, ?v, :value ],
+        [ ?W, ?w, :widget ],
+        nil
+      ]
+
+      PROC_TBL = [
+        [ ?i, TkComm.method(:string) ],
+        [ ?v, TkComm.method(:tk_tcl2ruby) ],
+        [ ?w, TkComm.method(:window) ],
+        nil
+      ]
+
+=begin
+      # for Ruby m17n :: ?x --> String --> char-code ( getbyte(0) )
+      KEY_TBL.map!{|inf|
+        if inf.kind_of?(Array)
+          inf[0] = inf[0].getbyte(0) if inf[0].kind_of?(String)
+          inf[1] = inf[1].getbyte(0) if inf[1].kind_of?(String)
+        end
+        inf
+      }
+
+      PROC_TBL.map!{|inf|
+        if inf.kind_of?(Array)
+          inf[0] = inf[0].getbyte(0) if inf[0].kind_of?(String)
+        end
+        inf
+      }
+=end
+
+      _setup_subst_table(KEY_TBL, PROC_TBL)
+    end
+
+    def self.source_handler(win, datatype, cmd=Proc.new, *args)
+      _bind_for_event_class(DnD_Handle,
+                            ['::blt::drag&drop', 'source', win, 'handler'],
+                            cmd, *args)
+    end
+
+    def self.target_handler(win, datatype, cmd=Proc.new, *args)
+      _bind_for_event_class(DnD_Handle,
+                            ['::blt::drag&drop', 'target', win, 'handler'],
+                            cmd, *args)
+    end
+
+    ###################################
+
+    def self.init_source(win)
+      tk_call('::blt::drag&drop', 'source', win)
+    end
+
+    def self.source()
+      list(tk_call('::blt::drag&drop', 'source'))
+    end
+
+    def self.source_handler_list(win)
+      simplelist(tk_call('::blt::drag&drop', 'source', win, 'handler'))
+    end
+    def self.source_handler_info(win, type)
+      tk_tcl2ruby(tk_call('::blt::drag&drop', 'source', win, 'handler', type))
+    end
+
+    def self.target
+      list(tk_call('::blt::drag&drop', 'target'))
+    end
+    def self.target_handler_list(win)
+      simplelist(tk_call('::blt::drag&drop', 'target', win, 'handler'))
+    end
+
+    def self.handle_target(win, type, val=None)
+      tk_call('::blt::drag&drop', 'target', win, 'handle', type, val)
+    end
+
+    def self.token(win)
+      window(tk_call('::blt::drag&drop', 'token', win))
+    end
+
+    def self.drag(win, x, y)
+      tk_call('::blt::drag&drop', 'drag', win, x, y)
+    end
+    def self.drop(win, x, y)
+      tk_call('::blt::drag&drop', 'drop', win, x, y)
+    end
+
+    def self.errors(cmd=Proc.new)
+      tk_call('::blt::drag&drop', 'errors', cmd)
+    end
+
+    def self.active
+      bool(tk_call('::blt::drag&drop', 'active'))
+    end
+
+    def self.location(x=None, y=None)
+      list(tk_call('::blt::drag&drop', 'location', x, y))
+    end
+  end
+end

data/lib/tkextlib/blt/eps.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: false
+#
+#  tkextlib/blt/eps.rb
+#                               by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+
+require 'tk'
+require 'tk/canvas'
+require 'tkextlib/blt.rb'
+
+module Tk::BLT
+  class EPS < TkcItem
+    CItemTypeName = 'eps'.freeze
+    CItemTypeToClass[CItemTypeName] = self
+  end
+end
+
+class Tk::Canvas
+  alias __BLT_EPS_item_strval_optkeys __item_strval_optkeys
+  def __item_strval_optkeys(id)
+    __BLT_EPS_item_strval_optkeys(id) + [
+      'shadowcolor', 'title', 'titlecolor'
+    ]
+  end
+  private :__item_strval_optkeys
+
+  alias __BLT_EPS_item_boolval_optkeys __item_boolval_optkeys
+  def __item_boolval_optkeys(id)
+    __BLT_EPS_item_boolval_optkeys(id) + ['showimage']
+  end
+  private :__item_boolval_optkeys
+end
+

data/lib/tkextlib/blt/graph.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: false
+#
+#  tkextlib/blt/graph.rb
+#                               by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+
+require 'tk'
+require 'tkextlib/blt.rb'
+require 'tkextlib/blt/component.rb'
+
+module Tk::BLT
+  class Graph < TkWindow
+    TkCommandNames = ['::blt::graph'.freeze].freeze
+    WidgetClassName = 'Graph'.freeze
+    WidgetClassNames[WidgetClassName] ||= self
+
+    include PlotComponent
+    include GraphCommand
+
+    def __boolval_optkeys
+      ['bufferelements', 'invertxy']
+    end
+    private :__boolval_optkeys
+
+    def __strval_optkeys
+      ['text', 'label', 'title', 'file', 'plotbackground']
+    end
+    private :__strval_optkeys
+
+=begin
+    BarElement_ID = ['blt_graph_bar'.freeze, TkUtil.untrust('00000')].freeze
+
+    def bar(elem=nil, keys={})
+      if elem.kind_of?(Hash)
+        keys = elem
+        elem = nil
+      end
+      unless elem
+        elem = BarElement_ID.join(TkCore::INTERP._ip_id_).freeze
+        BarElement_ID[1].succ!
+      end
+      tk_send('bar', elem, keys)
+      Element.new(self, elem, :without_creating=>true)
+    end
+=end
+
+    def extents(item)
+      num_or_str(tk_send_without_enc('extents', item))
+    end
+
+    def invtransform(x, y)
+      list(tk_send_without_enc('invtransform', x, y))
+    end
+
+    def inside(x, y)
+      bool(tk_send_without_enc('inside', x, y))
+    end
+
+    def snap(output, keys={})
+      tk_send_without_enc('snap', *(hash_kv(keys, false) + output))
+      self
+    end
+
+    def transform(x, y)
+      list(tk_send_without_enc('transform', x, y))
+    end
+  end
+end

data/lib/tkextlib/blt/htext.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: false
+#
+#  tkextlib/blt/htext.rb
+#                               by Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+
+require 'tk'
+require 'tk/itemconfig.rb'
+require 'tkextlib/blt.rb'
+
+module Tk::BLT
+  class Htext<TkWindow
+    Htext_Var = TkVarAccess.new_hash('htext')
+    Htext_Widget = TkVarAccess.new('htext(widget)', :window)
+    Htext_File = TkVarAccess.new('htext(file)')
+    Htext_Line = TkVarAccess.new('htext(line)')
+
+    include TkItemConfigMethod
+    include Scrollable
+
+    TkCommandNames = ['::blt::htext'.freeze].freeze
+    WidgetClassName = 'Htext'.freeze
+    WidgetClassNames[WidgetClassName] ||= self
+
+    alias window_cget_tkstring itemcget_tkstring
+    alias window_cget itemcget
+    alias window_cget_strict itemcget_strict
+    alias window_configure itemconfigure
+    alias window_configuinfo itemconfiginfo
+    alias current_window_configuinfo current_itemconfiginfo
+
+    def __strval_optkeys
+      super() << 'filename'
+    end
+  private :__strval_optkeys
+
+    def append(win, keys={})
+      tk_send('append', _epath(win), keys)
+      self
+    end
+
+    def goto_line(idx)
+      tk_send_without_enc('gotoline', idx)
+      self
+    end
+    def current_line
+      number(tk_send_without_enc('gotoline'))
+    end
+
+    def index(str)
+      number(tk_send('index', str))
+    end
+
+    def line_pos(str)
+      tk_send('linepos', str)
+    end
+
+    def range(from=None, to=None)
+      tk_send_without_enc('range', from, to)
+    end
+
+    def scan_mark(pos)
+      tk_send_without_enc('scan', 'mark', pos)
+      self
+    end
+
+    def scan_dragto(pos)
+      tk_send_without_enc('scan', 'dragto', pos)
+      self
+    end
+
+    def search(pat, from=None, to=None)
+      num = number(tk_send('search', pat, from, to))
+      (num < 0)? nil: num
+    end
+
+    def selection_adjust(index)
+      tk_send_without_enc('selection', 'adjust', index)
+      self
+    end
+    def selection_clear()
+      tk_send_without_enc('selection', 'clear')
+      self
+    end
+    def selection_from(index)
+      tk_send_without_enc('selection', 'from', index)
+      self
+    end
+    def selection_line(index)
+      tk_send_without_enc('selection', 'line', index)
+      self
+    end
+    def selection_present()
+      bool(tk_send_without_enc('selection', 'present'))
+    end
+    def selection_range(first, last)
+      tk_send_without_enc('selection', 'range', first, last)
+      self
+    end
+    def selection_to(index)
+      tk_send_without_enc('selection', 'to', index)
+      self
+    end
+    def selection_word(index)
+      tk_send_without_enc('selection', 'word', index)
+      self
+    end
+
+    def windows(pat=None)
+      list(tk_send('windows', pat))
+    end
+  end
+end