tk_as_gem 0.0.0

data/ext/lib/tk/place.rb

@@ -0,0 +1,128 @@
+#
+# tk/place.rb : control place geometry manager
+#
+require 'tk'
+
+module TkPlace
+  include Tk
+  extend Tk
+
+  TkCommandNames = ['place'.freeze].freeze
+
+  def configure(win, slot, value=None)
+    # for >= Tk8.4a2 ?
+    # win = win.epath if win.kind_of?(TkObject)
+    win = _epath(win)
+    if slot.kind_of? Hash
+      params = []
+      slot.each{|k, v|
+        params.push("-#{k}")
+        # params.push((v.kind_of?(TkObject))? v.epath: v)
+        params.push(_epath(v))
+      }
+      tk_call_without_enc('place', 'configure', win, *params)
+    else
+      # value = value.epath if value.kind_of?(TkObject)
+      value = _epath(value)
+      tk_call_without_enc('place', 'configure', win, "-#{slot}", value)
+    end
+  end
+  alias place configure
+
+  def configinfo(win, slot = nil)
+    # for >= Tk8.4a2 ?
+    if TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
+      # win = win.epath if win.kind_of?(TkObject)
+      win = _epath(win)
+      if slot
+        #conf = tk_split_list(tk_call_without_enc('place', 'configure', 
+        #                                        win, "-#{slot}") )
+        conf = tk_split_simplelist(tk_call_without_enc('place', 'configure', 
+                                                       win, "-#{slot}") )
+        conf[0] = conf[0][1..-1]
+        conf[1] = tk_tcl2ruby(conf[1])
+        conf[2] = tk_tcl2ruby(conf[1])
+        conf[3] = tk_tcl2ruby(conf[1])
+        conf[4] = tk_tcl2ruby(conf[1])
+        conf
+      else
+        tk_split_simplelist(tk_call_without_enc('place', 'configure', 
+                                                win)).collect{|conflist|
+          #conf = list(conflist)
+          conf = simplelist(conflist).collect!{|inf| tk_tcl2ruby(inf)}
+          conf[0] = conf[0][1..-1]
+          conf
+        }
+      end
+    else # ! TkComm::GET_CONFIGINFOwoRES_AS_ARRAY
+      current_configinfo(win, slot)
+    end
+  end
+
+  def current_configinfo(win, slot = nil)
+    # win = win.epath if win.kind_of?(TkObject)
+    win = _epath(win)
+    if slot
+      #conf = tk_split_list(tk_call_without_enc('place', 'configure', 
+      #                                         win, "-#{slot}") )
+      conf = tk_split_simplelist(tk_call_without_enc('place', 'configure', 
+                                                     win, "-#{slot}") )
+      # { conf[0][1..-1] => conf[1] }
+      { conf[0][1..-1] => tk_tcl2ruby(conf[4]) }
+    else
+      ret = {}
+      #tk_split_list(tk_call_without_enc('place','configure',win)).each{|conf|
+      tk_split_simplelist(tk_call_without_enc('place', 'configure', 
+                                              win)).each{|conf_list|
+        #ret[conf[0][1..-1]] = conf[1]
+        conf = simplelist(conf_list)
+        ret[conf[0][1..-1]] = tk_tcl2ruby(conf[4])
+      }
+      ret
+    end
+  end
+
+  def forget(win)
+    # win = win.epath if win.kind_of?(TkObject)
+    win = _epath(win)
+    tk_call_without_enc('place', 'forget', win)
+  end
+
+  def info(win)
+    # win = win.epath if win.kind_of?(TkObject)
+    win = _epath(win)
+    #ilist = list(tk_call_without_enc('place', 'info', win))
+    ilist = simplelist(tk_call_without_enc('place', 'info', win))
+    info = {}
+    while key = ilist.shift
+      #info[key[1..-1]] = ilist.shift
+      info[key[1..-1]] = tk_tcl2ruby(ilist.shift)
+    end
+    return info
+  end
+
+  def slaves(master)
+    # master = master.epath if master.kind_of?(TkObject)
+    master = _epath(master)
+    list(tk_call('place', 'slaves', master))
+  end
+
+  module_function :place, :configure, :configinfo, :current_configinfo
+  module_function :forget, :info, :slaves
+end
+=begin
+def TkPlace(win, slot, value=None)
+  win = win.epath if win.kind_of?(TkObject)
+  if slot.kind_of? Hash
+    params = []
+    slot.each{|k, v|
+      params.push("-#{k}")
+      params.push((v.kind_of?(TkObject))? v.epath: v)
+    }
+    tk_call_without_enc('place', win, *params)
+  else
+    value = value.epath if value.kind_of?(TkObject)
+    tk_call_without_enc('place', win, "-#{slot}", value)
+  end
+end
+=end

data/ext/lib/tk/radiobutton.rb

@@ -0,0 +1,71 @@
+#
+# tk/radiobutton.rb : treat radiobutton widget
+#
+require 'tk'
+require 'tk/button'
+
+class Tk::RadioButton<Tk::Button
+  TkCommandNames = ['radiobutton'.freeze].freeze
+  WidgetClassName = 'Radiobutton'.freeze
+  WidgetClassNames[WidgetClassName] = self
+  #def create_self(keys)
+  #  if keys and keys != None
+  #    tk_call_without_enc('radiobutton', @path, *hash_kv(keys, true))
+  #  else
+  #    tk_call_without_enc('radiobutton', @path)
+  #  end
+  #end
+  #private :create_self
+
+  def __boolval_optkeys
+    super() << 'indicatoron'
+  end
+  private :__boolval_optkeys
+
+  def __strval_optkeys
+    super() << 'selectcolor'
+  end
+  private :__strval_optkeys
+
+  def __ruby2val_optkeys  # { key=>proc, ... }
+    {
+      'variable'=>proc{|v| tk_trace_variable(v)}  # for backward compatibility
+    }
+  end
+  private :__ruby2val_optkeys
+
+
+  def deselect
+    tk_send_without_enc('deselect')
+    self
+  end
+  def select
+    tk_send_without_enc('select')
+    self
+  end
+
+  def get_value
+    var = tk_send_without_enc('cget', '-variable')
+    if TkVariable::USE_TCLs_SET_VARIABLE_FUNCTIONS
+      _fromUTF8(INTERP._get_global_var(var))
+    else
+      INTERP._eval(Kernel.format('global %s; set %s', var, var))
+    end
+  end
+
+  def set_value(val)
+    var = tk_send_without_enc('cget', '-variable')
+    if TkVariable::USE_TCLs_SET_VARIABLE_FUNCTIONS
+      _fromUTF8(INTERP._set_global_var(var, _get_eval_string(val, true)))
+    else
+      s = '"' + _get_eval_string(val).gsub(/[\[\]$"\\]/, '\\\\\&') + '"'
+      INTERP._eval(Kernel.format('global %s; set %s %s', var, var, s))
+    end
+  end
+end
+
+Tk::Radiobutton = Tk::RadioButton
+#TkRadioButton = Tk::RadioButton unless Object.const_defined? :TkRadioButton
+#TkRadiobutton = Tk::Radiobutton unless Object.const_defined? :TkRadiobutton
+Tk.__set_toplevel_aliases__(:Tk, Tk::RadioButton, 
+                            :TkRadioButton, :TkRadiobutton)

data/ext/lib/tk/root.rb

@@ -0,0 +1,95 @@
+#
+# tk/root.rb : treat root widget
+#
+require 'tk'
+require 'tk/wm'
+require 'tk/menuspec'
+
+class Tk::Root<TkWindow
+  include Wm
+  include TkMenuSpec
+
+  def __methodcall_optkeys  # { key=>method, ... }
+    TOPLEVEL_METHODCALL_OPTKEYS
+  end
+  private :__methodcall_optkeys
+
+  def Root.new(keys=nil, &b)
+    unless TkCore::INTERP.tk_windows['.']
+      TkCore::INTERP.tk_windows['.'] = 
+        super(:without_creating=>true, :widgetname=>'.'){}
+    end
+    root = TkCore::INTERP.tk_windows['.']
+
+    keys = _symbolkey2str(keys)
+
+    # wm commands
+    root.instance_eval{
+      __methodcall_optkeys.each{|key, method|
+        value = keys.delete(key.to_s)
+        self.__send__(method, value) if value
+      }
+    }
+
+    if keys  # wm commands ( for backward comaptibility )
+      keys.each{|k,v|
+        if v.kind_of? Array
+          root.__send__(k,*v)
+        else
+          root.__send__(k,v)
+        end
+      }
+    end
+
+    if block_given?
+      if TkCore::WITH_RUBY_VM  ### Ruby 1.9 !!!!
+        root.instance_exec(root, &b)
+      else
+        root.instance_eval(&b)
+      end
+    end
+    root
+  end
+
+  WidgetClassName = 'Tk'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+  def self.to_eval
+    # self::WidgetClassName
+    '.'
+  end
+
+  def create_self
+    @path = '.'
+  end
+  private :create_self
+
+  def path
+    "."
+  end
+
+  def add_menu(menu_info, tearoff=false, opts=nil)
+    # See tk/menuspec.rb for menu_info.
+    # opts is a hash of default configs for all of cascade menus. 
+    # Configs of menu_info can override it. 
+    if tearoff.kind_of?(Hash)
+      opts = tearoff
+      tearoff = false
+    end
+    _create_menubutton(self, menu_info, tearoff, opts)
+  end
+
+  def add_menubar(menu_spec, tearoff=false, opts=nil)
+    # See tk/menuspec.rb for menu_spec.
+    # opts is a hash of default configs for all of cascade menus.
+    # Configs of menu_spec can override it. 
+    menu_spec.each{|info| add_menu(info, tearoff, opts)}
+    self.menu
+  end
+
+  def Root.destroy
+    TkCore::INTERP._invoke('destroy', '.')
+  end
+end
+
+TkRoot = Tk::Root unless Object.const_defined? :TkRoot

data/ext/lib/tk/scale.rb

@@ -0,0 +1,111 @@
+#
+# tk/scale.rb : treat scale widget
+#
+require 'tk'
+
+class Tk::Scale<TkWindow
+  TkCommandNames = ['scale'.freeze].freeze
+  WidgetClassName = 'Scale'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+  def create_self(keys)
+    if keys and keys != None
+      if keys.key?('command') && ! keys['command'].kind_of?(String)
+        cmd = keys.delete('command')
+        keys['command'] = proc{|val| cmd.call(val.to_f)}
+      end
+      unless TkConfigMethod.__IGNORE_UNKNOWN_CONFIGURE_OPTION__
+        #tk_call_without_enc('scale', @path, *hash_kv(keys, true))
+        tk_call_without_enc(self.class::TkCommandNames[0], @path, 
+                            *hash_kv(keys, true))
+      else
+        begin
+          tk_call_without_enc(self.class::TkCommandNames[0], @path, 
+                              *hash_kv(keys, true))
+        rescue
+          tk_call_without_enc(self.class::TkCommandNames[0], @path)
+          keys = __check_available_configure_options(keys)
+          unless keys.empty?
+            begin
+              tk_call_without_enc('destroy', @path)
+            rescue
+              # cannot destroy
+              configure(keys)
+            else
+              # re-create widget
+              tk_call_without_enc(self.class::TkCommandNames[0], @path, 
+                                  *hash_kv(keys, true))
+            end
+          end
+        end
+      end
+    else
+      #tk_call_without_enc('scale', @path)
+      tk_call_without_enc(self.class::TkCommandNames[0], @path)
+    end
+  end
+  private :create_self
+
+  def __strval_optkeys
+    super() << 'label'
+  end
+  private :__strval_optkeys
+
+  def _wrap_command_arg(cmd)
+    proc{|val|
+      if val.kind_of?(String)
+        cmd.call(number(val))
+      else
+        cmd.call(val)
+      end
+    }
+  end
+  private :_wrap_command_arg
+
+  def configure_cmd(slot, value)
+    configure(slot=>value)
+  end
+
+  def configure(slot, value=None)
+    if (slot == 'command' || slot == :command)
+      configure('command'=>value)
+    elsif slot.kind_of?(Hash) && 
+        (slot.key?('command') || slot.key?(:command))
+      slot = _symbolkey2str(slot)
+      slot['command'] = _wrap_command_arg(slot.delete('command'))
+    end
+    super(slot, value)
+  end
+
+  def command(cmd=Proc.new)
+    configure('command'=>cmd)
+  end
+
+  def get(x=None, y=None)
+    number(tk_send_without_enc('get', x, y))
+  end
+
+  def coords(val=None)
+    tk_split_list(tk_send_without_enc('coords', val))
+  end
+
+  def identify(x, y)
+    tk_send_without_enc('identify', x, y)
+  end
+
+  def set(val)
+    tk_send_without_enc('set', val)
+  end
+
+  def value
+    get
+  end
+
+  def value= (val)
+    set(val)
+    val
+  end
+end
+
+#TkScale = Tk::Scale unless Object.const_defined? :TkScale
+Tk.__set_toplevel_aliases__(:Tk, Tk::Scale, :TkScale)

data/ext/lib/tk/scrollable.rb

@@ -0,0 +1,82 @@
+#
+# tk/scrollable.rb : module for scrollable widget
+#
+require 'tk'
+
+module Tk
+  module XScrollable
+    def xscrollcommand(cmd=Proc.new)
+      configure_cmd 'xscrollcommand', cmd
+      # Tk.update  # avoid scrollbar trouble
+      self
+    end
+
+    def xview(*index)
+      if index.size == 0
+        list(tk_send_without_enc('xview'))
+      else
+        tk_send_without_enc('xview', *index)
+        self
+      end
+    end
+    def xview_moveto(*index)
+      xview('moveto', *index)
+    end
+    def xview_scroll(*index)
+      xview('scroll', *index)
+    end
+
+    def xscrollbar(bar=nil)
+      if bar
+        @xscrollbar = bar
+        @xscrollbar.orient 'horizontal'
+        self.xscrollcommand {|*arg| @xscrollbar.set(*arg)}
+        @xscrollbar.command {|*arg| self.xview(*arg)}
+        Tk.update  # avoid scrollbar trouble
+      end
+      @xscrollbar
+    end
+  end
+
+  module YScrollable
+    def yscrollcommand(cmd=Proc.new)
+      configure_cmd 'yscrollcommand', cmd
+      # Tk.update  # avoid scrollbar trouble
+      self
+    end
+
+    def yview(*index)
+      if index.size == 0
+        list(tk_send_without_enc('yview'))
+      else
+        tk_send_without_enc('yview', *index)
+        self
+      end
+    end
+    def yview_moveto(*index)
+      yview('moveto', *index)
+    end
+    def yview_scroll(*index)
+      yview('scroll', *index)
+    end
+
+    def yscrollbar(bar=nil)
+      if bar
+        @yscrollbar = bar
+        @yscrollbar.orient 'vertical'
+        self.yscrollcommand {|*arg| @yscrollbar.set(*arg)}
+        @yscrollbar.command {|*arg| self.yview(*arg)}
+        Tk.update  # avoid scrollbar trouble
+      end
+      @yscrollbar
+    end
+  end
+
+  X_Scrollable = XScrollable
+  Y_Scrollable = YScrollable
+
+  module Scrollable
+    include XScrollable
+    include YScrollable
+  end
+end