tk 0.1.0

data/lib/tk/fontchooser.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: false
+#
+# tk/fontchooser.rb -- "tk fontchooser" support (Tcl/Tk8.6 or later)
+#
+require 'tk'
+require 'tk/font'
+
+module TkFont::Chooser
+  extend TkCore
+end
+
+module Tk
+  Fontchooser = TkFont::Chooser
+end
+
+class << TkFont::Chooser
+  def method_missing(id, *args)
+    name = id.id2name
+    case args.length
+    when 1
+      if name[-1] == ?=
+        configure name[0..-2], args[0]
+        args[0]
+      else
+        configure name, args[0]
+        self
+      end
+    when 0
+      begin
+        cget(name)
+      rescue
+        super(id, *args)
+      end
+    else
+      super(id, *args)
+    end
+  end
+
+  def __configinfo_value(key, val)
+    case key
+    when 'parent'
+      window(val)
+    when 'title'
+      val
+    when 'font'
+      if (lst = tk_split_simplelist(val)).size == 1
+        lst[0]
+      else
+        lst.map{|elem| num_or_str(elem)}
+      end
+    when 'command'
+      tk_tcl2ruby(val)
+    when 'visible'
+      bool(val)
+    else # unknown
+      val
+    end
+  end
+  private :__configinfo_value
+
+  def configinfo(option=nil)
+    if !option && TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
+      lst = tk_split_simplelist(tk_call('tk', 'fontchooser', 'configure'))
+      ret = []
+      TkComm.slice_ary(lst, 2){|k, v|
+        k = k[1..-1]
+        ret << [k, __configinfo_value(k, v)]
+      }
+      ret
+    else
+      current_configinfo(option)
+    end
+  end
+
+  def current_configinfo(option=nil)
+    if option
+      opt = option.to_s
+      fail ArgumentError, "Invalid option `#{option.inspect}'" if opt.empty?
+      __configinfo_value(option.to_s, tk_call('tk','fontchooser',
+                                              'configure',"-#{opt}"))
+    else
+      lst = tk_split_simplelist(tk_call('tk', 'fontchooser', 'configure'))
+      ret = {}
+      TkComm.slice_ary(lst, 2){|k, v|
+        k = k[1..-1]
+        ret[k] = __configinfo_value(k, v)
+      }
+      ret
+    end
+  end
+
+  def configure(option, value=None)
+    if option.kind_of? Hash
+      tk_call('tk', 'fontchooser', 'configure',
+              *hash_kv(_symbolkey2str(option)))
+    else
+      opt = option.to_s
+      fail ArgumentError, "Invalid option `#{option.inspect}'" if opt.empty?
+      tk_call('tk', 'fontchooser', 'configure', "-#{opt}", value)
+    end
+    self
+  end
+
+  def configure_cmd(slot, value)
+    configure(slot, install_cmd(value))
+  end
+
+  def command(cmd=nil, &b)
+    if cmd
+      configure_cmd('command', cmd)
+    elsif b
+      configure_cmd('command', Proc.new(&b))
+    else
+      cget('command')
+    end
+  end
+
+  def cget(slot)
+    configinfo slot
+  end
+
+  def [](slot)
+    cget slot
+  end
+
+  def []=(slot, val)
+    configure slot, val
+    val
+  end
+
+  def show
+    tk_call('tk', 'fontchooser', 'show')
+    self
+  end
+
+  def hide
+    tk_call('tk', 'fontchooser', 'hide')
+    self
+  end
+
+  def toggle
+    cget(:visible) ?  hide: show
+    self
+  end
+
+  def set_for(target, title="Font")
+    if target.kind_of? TkFont
+      configs = {
+        :font=>target.actual_hash,
+        :command=>proc{|fnt, *args|
+          target.configure(TkFont.actual_hash(fnt))
+        }
+      }
+    elsif target.kind_of? Hash
+      # key=>value list or OptionObj
+      fnt = target[:font] rescue ''
+      fnt = fnt.actual_hash if fnt.kind_of?(TkFont)
+      configs = {
+        :font => fnt,
+        :command=>proc{|fnt, *args|
+          target[:font] = TkFont.actual_hash(fnt)
+        }
+      }
+    else
+      configs = {
+        :font=>target.cget_tkstring(:font),
+        :command=>proc{|fnt, *args|
+          target.font = TkFont.actual_hash_displayof(fnt, target)
+        }
+      }
+    end
+
+    configs[:title] = title if title
+    configure(configs)
+    target
+  end
+
+  def unset
+    configure(:command, nil)
+  end
+end

data/lib/tk/frame.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: false
+#
+# tk/frame.rb : treat frame widget
+#
+require 'tk'
+
+class Tk::Frame<TkWindow
+  TkCommandNames = ['frame'.freeze].freeze
+  WidgetClassName = 'Frame'.freeze
+  WidgetClassNames[WidgetClassName] ||= self
+
+################# old version
+#  def initialize(parent=nil, keys=nil)
+#    if keys.kind_of? Hash
+#      keys = keys.dup
+#      @classname = keys.delete('classname') if keys.key?('classname')
+#      @colormap  = keys.delete('colormap')  if keys.key?('colormap')
+#      @container = keys.delete('container') if keys.key?('container')
+#      @visual    = keys.delete('visual')    if keys.key?('visual')
+#    end
+#    super(parent, keys)
+#  end
+#
+#  def create_self
+#    s = []
+#    s << "-class"     << @classname if @classname
+#    s << "-colormap"  << @colormap  if @colormap
+#    s << "-container" << @container if @container
+#    s << "-visual"    << @visual    if @visual
+#    tk_call 'frame', @path, *s
+#  end
+#################
+
+  def __boolval_optkeys
+    super() << 'container'
+  end
+  private :__boolval_optkeys
+
+  def initialize(parent=nil, keys=nil)
+    my_class_name = nil
+    if self.class < WidgetClassNames[self.class::WidgetClassName]
+      my_class_name = self.class.name
+      my_class_name = nil if my_class_name == ''
+    end
+    if parent.kind_of? Hash
+      keys = _symbolkey2str(parent)
+    else
+      if keys
+        keys = _symbolkey2str(keys)
+        keys['parent'] = parent
+      else
+        keys = {'parent'=>parent}
+      end
+    end
+    if keys.key?('classname')
+       keys['class'] = keys.delete('classname')
+    end
+    @classname = keys['class']
+    @colormap  = keys['colormap']
+    @container = keys['container']
+    @visual    = keys['visual']
+    if !@classname && my_class_name
+      keys['class'] = @classname = my_class_name
+    end
+    if @classname.kind_of? TkBindTag
+      @db_class = @classname
+      @classname = @classname.id
+    elsif @classname
+      @db_class = TkDatabaseClass.new(@classname)
+    else
+      @db_class = self.class
+      @classname = @db_class::WidgetClassName
+    end
+    super(keys)
+  end
+
+  #def create_self(keys)
+  #  if keys and keys != None
+  #    tk_call_without_enc('frame', @path, *hash_kv(keys))
+  #  else
+  #    tk_call_without_enc( 'frame', @path)
+  #  end
+  #end
+  #private :create_self
+
+  def database_classname
+    @classname
+  end
+
+  def self.database_class
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      self
+    else
+      TkDatabaseClass.new(self.name)
+    end
+  end
+  def self.database_classname
+    self.database_class.name
+  end
+
+  def self.bind(*args, &b)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args, &b)
+    else
+      TkDatabaseClass.new(self.name).bind(*args, &b)
+    end
+  end
+  def self.bind_append(*args, &b)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args, &b)
+    else
+      TkDatabaseClass.new(self.name).bind_append(*args, &b)
+    end
+  end
+  def self.bind_remove(*args)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args)
+    else
+      TkDatabaseClass.new(self.name).bind_remove(*args)
+    end
+  end
+  def self.bindinfo(*args)
+    if self == WidgetClassNames[WidgetClassName] || self.name == ''
+      super(*args)
+    else
+      TkDatabaseClass.new(self.name).bindinfo(*args)
+    end
+  end
+end
+
+#TkFrame = Tk::Frame unless Object.const_defined? :TkFrame
+#Tk.__set_toplevel_aliases__(:Tk, Tk::Frame, :TkFrame)
+Tk.__set_loaded_toplevel_aliases__('tk/frame.rb', :Tk, Tk::Frame, :TkFrame)

data/lib/tk/grid.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: false
+#
+# tk/grid.rb : control grid geometry manager
+#
+require 'tk'
+
+module TkGrid
+  include Tk
+  extend Tk
+
+  TkCommandNames = ['grid'.freeze].freeze
+
+  def anchor(master, anchor=None)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    tk_call_without_enc('grid', 'anchor', master, anchor)
+  end
+
+  def bbox(master, *args)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    args.unshift(master)
+    list(tk_call_without_enc('grid', 'bbox', *args))
+  end
+
+=begin
+  def configure(win, *args)
+    if args[-1].kind_of?(Hash)
+      opts = args.pop
+    else
+      opts = {}
+    end
+    params = []
+    params.push(_epath(win))
+    args.each{|win|
+      case win
+      when '-', 'x', '^'  # RELATIVE PLACEMENT
+        params.push(win)
+      else
+        params.push(_epath(win))
+      end
+    }
+    opts.each{|k, v|
+      params.push("-#{k}")
+      params.push((v.kind_of?(TkObject))? v.epath: v)
+    }
+    if Tk::TCL_MAJOR_VERSION < 8 ||
+        (Tk::TCL_MAJOR_VERSION == 8 && Tk::TCL_MINOR_VERSION <= 3)
+      if params[0] == '-' || params[0] == 'x' || params[0] == '^'
+        tk_call_without_enc('grid', *params)
+      else
+        tk_call_without_enc('grid', 'configure', *params)
+      end
+    else
+      tk_call_without_enc('grid', 'configure', *params)
+    end
+  end
+=end
+  def configure(*args)
+    if args[-1].kind_of?(Hash)
+      opts = args.pop
+    else
+      opts = {}
+    end
+    fail ArgumentError, 'no widget is given' if args.empty?
+    params = []
+    args.flatten(1).each{|win|
+      case win
+      when '-', ?-              # RELATIVE PLACEMENT (increase columnspan)
+        params.push('-')
+      when /^-+$/             # RELATIVE PLACEMENT (increase columnspan)
+        params.concat(win.to_s.split(//))
+      when '^', ?^              # RELATIVE PLACEMENT (increase rowspan)
+        params.push('^')
+      when /^\^+$/             # RELATIVE PLACEMENT (increase rowspan)
+        params.concat(win.to_s.split(//))
+      when 'x', :x, ?x, nil, '' # RELATIVE PLACEMENT (empty column)
+        params.push('x')
+      when /^x+$/             # RELATIVE PLACEMENT (empty column)
+        params.concat(win.to_s.split(//))
+      else
+        params.push(_epath(win))
+      end
+    }
+    opts.each{|k, v|
+      params.push("-#{k}")
+      params.push(_epath(v))  # have to use 'epath' (hash_kv() is unavailable)
+    }
+    if Tk::TCL_MAJOR_VERSION < 8 ||
+        (Tk::TCL_MAJOR_VERSION == 8 && Tk::TCL_MINOR_VERSION <= 3)
+      if params[0] == '-' || params[0] == 'x' || params[0] == '^'
+        tk_call_without_enc('grid', *params)
+      else
+        tk_call_without_enc('grid', 'configure', *params)
+      end
+    else
+      tk_call_without_enc('grid', 'configure', *params)
+    end
+  end
+  alias grid configure
+
+  def columnconfigure(master, index, args)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    tk_call_without_enc("grid", 'columnconfigure',
+                        master, index, *hash_kv(args))
+  end
+
+  def rowconfigure(master, index, args)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    tk_call_without_enc("grid", 'rowconfigure', master, index, *hash_kv(args))
+  end
+
+  def columnconfiginfo(master, index, slot=nil)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    if slot
+      case slot
+      when 'uniform', :uniform
+        tk_call_without_enc('grid', 'columnconfigure',
+                            master, index, "-#{slot}")
+      else
+        num_or_str(tk_call_without_enc('grid', 'columnconfigure',
+                                       master, index, "-#{slot}"))
+      end
+    else
+      #ilist = list(tk_call_without_enc('grid','columnconfigure',master,index))
+      ilist = simplelist(tk_call_without_enc('grid', 'columnconfigure',
+                                             master, index))
+      info = {}
+      while key = ilist.shift
+        case key
+        when 'uniform'
+          info[key[1..-1]] = ilist.shift
+        else
+          info[key[1..-1]] = tk_tcl2ruby(ilist.shift)
+        end
+      end
+      info
+    end
+  end
+
+  def rowconfiginfo(master, index, slot=nil)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    if slot
+      case slot
+      when 'uniform', :uniform
+        tk_call_without_enc('grid', 'rowconfigure',
+                            master, index, "-#{slot}")
+      else
+        num_or_str(tk_call_without_enc('grid', 'rowconfigure',
+                                       master, index, "-#{slot}"))
+      end
+    else
+      #ilist = list(tk_call_without_enc('grid', 'rowconfigure', master, index))
+      ilist = simplelist(tk_call_without_enc('grid', 'rowconfigure',
+                                             master, index))
+      info = {}
+      while key = ilist.shift
+        case key
+        when 'uniform'
+          info[key[1..-1]] = ilist.shift
+        else
+          info[key[1..-1]] = tk_tcl2ruby(ilist.shift)
+        end
+      end
+      info
+    end
+  end
+
+  def column(master, index, keys=nil)
+    if keys.kind_of?(Hash)
+      columnconfigure(master, index, keys)
+    else
+      columnconfiginfo(master, index, keys)
+    end
+  end
+
+  def row(master, index, keys=nil)
+    if keys.kind_of?(Hash)
+      rowconfigure(master, index, keys)
+    else
+      rowconfiginfo(master, index, keys)
+    end
+  end
+
+  def add(widget, *args)
+    configure(widget, *args)
+  end
+
+  def forget(*args)
+    return '' if args.size == 0
+    wins = args.collect{|win|
+      # (win.kind_of?(TkObject))? win.epath: win
+      _epath(win)
+    }
+    tk_call_without_enc('grid', 'forget', *wins)
+  end
+
+  def info(slave)
+    # slave = slave.epath if slave.kind_of?(TkObject)
+    slave = _epath(slave)
+    #ilist = list(tk_call_without_enc('grid', 'info', slave))
+    ilist = simplelist(tk_call_without_enc('grid', 'info', slave))
+    info = {}
+    while key = ilist.shift
+      #info[key[1..-1]] = ilist.shift
+      info[key[1..-1]] = tk_tcl2ruby(ilist.shift)
+    end
+    return info
+  end
+
+  def location(master, x, y)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    list(tk_call_without_enc('grid', 'location', master, x, y))
+  end
+
+  def propagate(master, mode=None)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    if mode == None
+      bool(tk_call_without_enc('grid', 'propagate', master))
+    else
+      tk_call_without_enc('grid', 'propagate', master, mode)
+    end
+  end
+
+  def remove(*args)
+    return '' if args.size == 0
+    wins = args.collect{|win|
+      # (win.kind_of?(TkObject))? win.epath: win
+      _epath(win)
+    }
+    tk_call_without_enc('grid', 'remove', *wins)
+  end
+
+  def size(master)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    list(tk_call_without_enc('grid', 'size', master))
+  end
+
+  def slaves(master, keys=nil)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    list(tk_call_without_enc('grid', 'slaves', master, *hash_kv(args)))
+  end
+
+  module_function :anchor, :bbox, :add, :forget, :propagate, :info
+  module_function :remove, :size, :slaves, :location
+  module_function :grid, :configure, :columnconfigure, :rowconfigure
+  module_function :column, :row, :columnconfiginfo, :rowconfiginfo
+end
+=begin
+def TkGrid(win, *args)
+  if args[-1].kind_of?(Hash)
+    opts = args.pop
+  else
+    opts = {}
+  end
+  params = []
+  params.push((win.kind_of?(TkObject))? win.epath: win)
+  args.each{|win|
+    case win
+    when '-', 'x', '^'  # RELATIVE PLACEMENT
+      params.push(win)
+    else
+      params.push((win.kind_of?(TkObject))? win.epath: win)
+    end
+  }
+  opts.each{|k, v|
+    params.push("-#{k}")
+    params.push((v.kind_of?(TkObject))? v.epath: v)
+  }
+  tk_call_without_enc("grid", *params)
+end
+=end