tk_as_gem 0.0.0

data/ext/lib/tk/scrollbar.rb

@@ -0,0 +1,177 @@
+#
+# tk/scrollbar.rb : treat scrollbar widget
+#
+require 'tk'
+
+class Tk::Scrollbar<TkWindow
+  TkCommandNames = ['scrollbar'.freeze].freeze
+  WidgetClassName = 'Scrollbar'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+  def create_self(keys)
+    @assigned = []
+    @scroll_proc = proc{|*args| 
+      if self.orient == 'horizontal'
+        @assigned.each{|w| w.xview(*args)}
+      else # 'vertical'
+        @assigned.each{|w| w.yview(*args)}
+      end
+    }
+
+    if keys and keys != None
+      unless TkConfigMethod.__IGNORE_UNKNOWN_CONFIGURE_OPTION__
+        #tk_call_without_enc('scrollbar', @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('scrollbar', @path)
+      tk_call_without_enc(self.class::TkCommandNames[0], @path)
+    end
+  end
+  private :create_self
+
+  def propagate_set(src_win, first, last)
+    self.set(first, last)
+    if self.orient == 'horizontal'
+      @assigned.each{|w| w.xview('moveto', first) if w != src_win}
+    else # 'vertical'
+      @assigned.each{|w| w.yview('moveto', first) if w != src_win}
+    end
+  end
+
+  def assign(*wins)
+    begin
+      self.command(@scroll_proc) if self.cget('command').cmd != @scroll_proc
+    rescue Exception
+      self.command(@scroll_proc)
+    end
+    orient = self.orient
+    wins.each{|w|
+      @assigned << w unless @assigned.index(w)
+      if orient == 'horizontal'
+        w.xscrollcommand proc{|first, last| self.propagate_set(w, first, last)}
+      else # 'vertical'
+        w.yscrollcommand proc{|first, last| self.propagate_set(w, first, last)}
+      end
+    }
+    Tk.update  # avoid scrollbar trouble
+    self
+  end
+
+  def assigned_list
+    begin
+      return @assigned.dup if self.cget('command').cmd == @scroll_proc
+    rescue Exception
+    end
+    fail RuntimeError, "not depend on the assigned_list"
+  end
+
+  def configure(*args)
+    ret = super(*args)
+    # Tk.update  # avoid scrollbar trouble
+    ret
+  end
+
+  #def delta(deltax=None, deltay=None)
+  def delta(deltax, deltay)
+    number(tk_send_without_enc('delta', deltax, deltay))
+  end
+
+  #def fraction(x=None, y=None)
+  def fraction(x, y)
+    number(tk_send_without_enc('fraction', x, y))
+  end
+
+  def identify(x, y)
+    tk_send_without_enc('identify', x, y)
+  end
+
+  def get
+    #ary1 = tk_send('get').split
+    #ary2 = []
+    #for i in ary1
+    #  ary2.push number(i)
+    #end
+    #ary2
+    list(tk_send_without_enc('get'))
+  end
+
+  def set(first, last)
+    tk_send_without_enc('set', first, last)
+    self
+  end
+
+  def activate(element=None)
+    tk_send_without_enc('activate', element)
+  end
+
+  def moveto(fraction)
+    tk_send_without_enc('moveto', fraction)
+    self
+  end
+
+  def scroll(*args)
+    tk_send_without_enc('scroll', *args)
+    self
+  end
+
+  def scroll_units(num)
+    scroll(num, 'units')
+    self
+  end
+
+  def scroll_pages(num)
+    scroll(num, 'pages')
+    self
+  end
+end
+
+#TkScrollbar = Tk::Scrollbar unless Object.const_defined? :TkScrollbar
+Tk.__set_toplevel_aliases__(:Tk, Tk::Scrollbar, :TkScrollbar)
+
+
+class Tk::XScrollbar<Tk::Scrollbar
+  def create_self(keys)
+    keys = {} unless keys
+    keys['orient'] = 'horizontal'
+    super(keys)
+  end
+  private :create_self
+end
+
+#TkXScrollbar = Tk::XScrollbar unless Object.const_defined? :TkXScrollbar
+Tk.__set_toplevel_aliases__(:Tk, Tk::XScrollbar, :TkXScrollbar)
+
+
+class Tk::YScrollbar<Tk::Scrollbar
+  def create_self(keys)
+    keys = {} unless keys
+    keys['orient'] = 'vertical'
+    super(keys)
+  end
+  private :create_self
+end
+
+#TkYScrollbar = Tk::YScrollbar unless Object.const_defined? :TkYScrollbar
+Tk.__set_toplevel_aliases__(:Tk, Tk::YScrollbar, :TkYScrollbar)

data/ext/lib/tk/scrollbox.rb

@@ -0,0 +1,39 @@
+#
+#               tk/scrollbox.rb - Tk Listbox with Scrollbar
+#                                 as an example of Composite Widget
+#                       by Yukihiro Matsumoto <matz@netlab.co.jp>
+#
+require 'tk'
+require 'tk/listbox'
+
+class TkScrollbox<Tk::Listbox
+  include TkComposite
+  def initialize_composite(keys=nil)
+    #list = Tk::Listbox.new(@frame)
+    # -> use current TkListbox class
+    list = TkListbox.new(@frame)
+    #scroll = Tk::Scrollbar.new(@frame)
+    # -> use current TkScrollbar class
+    scroll = TkScrollbar.new(@frame)
+    @path = list.path
+
+=begin
+    list.configure 'yscroll', scroll.path+" set"
+    list.pack 'side'=>'left','fill'=>'both','expand'=>'yes'
+    scroll.configure 'command', list.path+" yview"
+    scroll.pack 'side'=>'right','fill'=>'y'
+=end
+    list.yscrollbar(scroll)
+    list.pack('side'=>'left','fill'=>'both','expand'=>'yes')
+    scroll.pack('side'=>'right','fill'=>'y')
+
+    delegate('DEFAULT', list)
+    delegate('foreground', list)
+    delegate('background', list, scroll)
+    delegate('borderwidth', @frame)
+    delegate('relief', @frame)
+
+    configure keys if keys
+  end
+  private :initialize_composite
+end

data/ext/lib/tk/selection.rb

@@ -0,0 +1,86 @@
+#
+# tk/selection.rb : control selection
+#
+require 'tk'
+
+module TkSelection
+  include Tk
+  extend Tk
+
+  TkCommandNames = ['selection'.freeze].freeze
+
+  def self.clear(sel=nil)
+    if sel
+      tk_call_without_enc('selection', 'clear', '-selection', sel)
+    else
+      tk_call_without_enc('selection', 'clear')
+    end
+  end
+  def self.clear_on_display(win, sel=nil)
+    if sel
+      tk_call_without_enc('selection', 'clear', 
+                          '-displayof', win, '-selection', sel)
+    else
+      tk_call_without_enc('selection', 'clear', '-displayof', win)
+    end
+  end
+  def clear(sel=nil)
+    TkSelection.clear_on_display(self, sel)
+    self
+  end
+
+  def self.get(keys=nil)
+    #tk_call('selection', 'get', *hash_kv(keys))
+    _fromUTF8(tk_call_without_enc('selection', 'get', *hash_kv(keys)))
+  end
+  def self.get_on_display(win, keys=nil)
+    #tk_call('selection', 'get', '-displayof', win, *hash_kv(keys))
+    _fromUTF8(tk_call_without_enc('selection', 'get', '-displayof', 
+                                  win, *hash_kv(keys)))
+  end
+  def get(keys=nil)
+    TkSelection.get_on_display(self, sel)
+  end
+
+  def self.handle(win, func=Proc.new, keys=nil, &b)
+    if func.kind_of?(Hash) && keys == nil
+      keys = func
+      func = Proc.new(&b)
+    end
+    args = ['selection', 'handle']
+    args.concat(hash_kv(keys))
+    args.concat([win, func])
+    tk_call_without_enc(*args)
+  end
+  def handle(func=Proc.new, keys=nil, &b)
+    TkSelection.handle(self, func, keys, &b)
+  end
+
+  def self.get_owner(sel=nil)
+    if sel
+      window(tk_call_without_enc('selection', 'own', '-selection', sel))
+    else
+      window(tk_call_without_enc('selection', 'own'))
+    end
+  end
+  def self.get_owner_on_display(win, sel=nil)
+    if sel
+      window(tk_call_without_enc('selection', 'own', 
+                                 '-displayof', win, '-selection', sel))
+    else
+      window(tk_call_without_enc('selection', 'own', '-displayof', win))
+    end
+  end
+  def get_owner(sel=nil)
+    TkSelection.get_owner_on_display(self, sel)
+    self
+  end
+
+  def self.set_owner(win, keys=nil)
+    tk_call_without_enc('selection', 'own', *(hash_kv(keys) << win))
+  end
+  def set_owner(keys=nil)
+    TkSelection.set_owner(self, keys)
+    self
+  end
+end

data/ext/lib/tk/spinbox.rb

@@ -0,0 +1,119 @@
+#
+#               tk/spinbox.rb - Tk spinbox classes
+#                       by Yukihiro Matsumoto <matz@caelum.co.jp>
+#
+require 'tk'
+require 'tk/entry'
+
+class Tk::Spinbox<Tk::Entry
+  TkCommandNames = ['spinbox'.freeze].freeze
+  WidgetClassName = 'Spinbox'.freeze
+  WidgetClassNames[WidgetClassName] = self
+
+  class SpinCommand < TkValidateCommand
+    class ValidateArgs < TkUtil::CallbackSubst
+      KEY_TBL = [
+        [ ?d, ?s, :direction ], 
+        [ ?s, ?e, :current ], 
+        [ ?W, ?w, :widget ], 
+        nil
+      ]
+
+      PROC_TBL = [
+        [ ?s, TkComm.method(:string) ], 
+        [ ?w, TkComm.method(:window) ], 
+
+        [ ?e, proc{|val|
+            #enc = Tk.encoding
+            enc = ((Tk.encoding)? Tk.encoding : Tk.encoding_system)
+            if enc
+              Tk.fromUTF8(TkComm::string(val), enc)
+            else
+              TkComm::string(val)
+            end
+          }
+        ], 
+
+        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)? '1': '0'
+      end
+    end
+
+    def self._config_keys
+      ['command']
+    end
+  end
+
+  def __validation_class_list
+    super() << SpinCommand
+  end
+
+  Tk::ValidateConfigure.__def_validcmd(binding, SpinCommand)
+
+  #def create_self(keys)
+  #  tk_call_without_enc('spinbox', @path)
+  #  if keys and keys != None
+  #    configure(keys)
+  #  end
+  #end
+  #private :create_self
+
+  def __boolval_optkeys
+    super() << 'wrap'
+  end
+  private :__boolval_optkeys
+
+  def __strval_optkeys
+    super() << 'buttonbackground' << 'format'
+  end
+  private :__strval_optkeys
+
+  def __listval_optkeys
+    super() << 'values'
+  end
+  private :__listval_optkeys
+
+  def identify(x, y)
+    tk_send_without_enc('identify', x, y)
+  end
+
+  def spinup
+    tk_send_without_enc('invoke', 'spinup')
+    self
+  end
+
+  def spindown
+    tk_send_without_enc('invoke', 'spindown')
+    self
+  end
+
+  def set(str)
+    _fromUTF8(tk_send_without_enc('set', _get_eval_enc_str(str)))
+  end
+end
+
+#TkSpinbox = Tk::Spinbox unless Object.const_defined? :TkSpinbox
+Tk.__set_toplevel_aliases__(:Tk, Tk::Spinbox, :TkSpinbox)

data/ext/lib/tk/tagfont.rb

@@ -0,0 +1,43 @@
+#
+# tk/tagfont.rb : control font of tags
+#
+require 'tk'
+
+module TkTreatTagFont
+  def font_configinfo
+    @parent.tagfont_configinfo(@id)
+  end
+#  alias font font_configinfo
+
+  def font_configure(slot)
+    @parent.tagfont_configure(@id, slot)
+    self
+  end
+
+  def latinfont_configure(ltn, keys=nil)
+    @parent.latintagfont_configure(@id, ltn, keys)
+    self
+  end
+  alias asciifont_configure latinfont_configure
+
+  def kanjifont_configure(knj, keys=nil)
+    @parent.kanjitagfont_configure(@id, ltn, keys)
+    self
+  end
+
+  def font_copy(win, wintag=nil)
+    @parent.tagfont_copy(@id, win, wintag)
+    self
+  end
+
+  def latinfont_copy(win, wintag=nil)
+    @parent.latintagfont_copy(@id, win, wintag)
+    self
+  end
+  alias asciifont_copy latinfont_copy
+
+  def kanjifont_copy(win, wintag=nil)
+    @parent.kanjitagfont_copy(@id, win, wintag)
+    self
+  end
+end