tk_as_gem 0.0.0

data/ext/lib/tk/textimage.rb

@@ -0,0 +1,88 @@
+#
+# tk/textimage.rb - treat Tk text image object
+#
+require 'tk'
+require 'tk/text'
+
+class TkTextImage<TkObject
+  include Tk::Text::IndexModMethods
+
+  def initialize(parent, index, keys)
+    #unless parent.kind_of?(Tk::Text)
+    #  fail ArgumentError, "expect Tk::Text for 1st argument"
+    #end
+    @t = parent
+    if index == 'end' || index == :end
+      @path = TkTextMark.new(@t, tk_call(@t.path, 'index', 'end - 1 chars'))
+    elsif index.kind_of? TkTextMark
+      if tk_call_without_enc(@t.path,'index',index.path) == tk_call_without_enc(@t.path,'index','end')
+        @path = TkTextMark.new(@t, tk_call_without_enc(@t.path, 'index', 
+                                                       'end - 1 chars'))
+      else
+        @path = TkTextMark.new(@t, tk_call_without_enc(@t.path, 'index', 
+                                                       index.path))
+      end
+    else
+      @path = TkTextMark.new(@t, tk_call_without_enc(@t.path, 'index', 
+                                                     _get_eval_enc_str(index)))
+    end
+    @path.gravity = 'left'
+    @index = @path.path
+    @id = tk_call_without_enc(@t.path, 'image', 'create', @index, 
+                              *hash_kv(keys, true)).freeze
+    @path.gravity = 'right'
+  end
+
+  def id
+    Tk::Text::IndexString.new(@id)
+  end
+  def mark
+    @path
+  end
+
+  def [](slot)
+    cget(slot)
+  end
+  def []=(slot, value)
+    configure(slot, value)
+    value
+  end
+
+  def cget(slot)
+    @t.image_cget(@index, slot)
+  end
+
+  def cget_strict(slot)
+    @t.image_cget_strict(@index, slot)
+  end
+
+  def configure(slot, value=None)
+    @t.image_configure(@index, slot, value)
+    self
+  end
+#  def configure(slot, value)
+#    tk_call @t.path, 'image', 'configure', @index, "-#{slot}", value
+#  end
+
+  def configinfo(slot = nil)
+    @t.image_configinfo(@index, slot)
+  end
+
+  def current_configinfo(slot = nil)
+    @t.current_image_configinfo(@index, slot)
+  end
+
+  def image
+    img = tk_call_without_enc(@t.path, 'image', 'cget', @index, '-image')
+    TkImage::Tk_IMGTBL[img]? TkImage::Tk_IMGTBL[img] : img
+  end
+
+  def image=(value)
+    tk_call_without_enc(@t.path, 'image', 'configure', @index, '-image', 
+                        _get_eval_enc_str(value))
+    #self
+    value
+  end
+end
+
+TktImage = TkTextImage

data/ext/lib/tk/textmark.rb

@@ -0,0 +1,204 @@
+#
+# tk/textmark.rb - methods for treating text marks
+#
+require 'tk'
+require 'tk/text'
+
+class TkTextMark<TkObject
+  include Tk::Text::IndexModMethods
+
+  TMarkID_TBL = TkCore::INTERP.create_table
+
+  (Tk_TextMark_ID = ['mark'.freeze, '00000'.taint]).instance_eval{
+    @mutex = Mutex.new
+    def mutex; @mutex; end
+    freeze
+  }
+
+  TkCore::INTERP.init_ip_env{
+    TMarkID_TBL.mutex.synchronize{ TMarkID_TBL.clear }
+  }
+
+  def TkTextMark.id2obj(text, id)
+    tpath = text.path
+    TMarkID_TBL.mutex.synchronize{
+      if TMarkID_TBL[tpath]
+        TMarkID_TBL[tpath][id]? TMarkID_TBL[tpath][id]: id
+      else
+        id 
+      end
+    }
+  end
+
+  def initialize(parent, index)
+    #unless parent.kind_of?(Tk::Text)
+    #  fail ArgumentError, "expect Tk::Text for 1st argument"
+    #end
+    @parent = @t = parent
+    @tpath = parent.path
+    Tk_TextMark_ID.mutex.synchronize{
+      # @path = @id = Tk_TextMark_ID.join('')
+      @path = @id = Tk_TextMark_ID.join(TkCore::INTERP._ip_id_).freeze
+      Tk_TextMark_ID[1].succ!
+    }
+    TMarkID_TBL.mutex.synchronize{
+      TMarkID_TBL[@id] = self
+      TMarkID_TBL[@tpath] = {} unless TMarkID_TBL[@tpath]
+      TMarkID_TBL[@tpath][@id] = self
+    }
+    tk_call_without_enc(@t.path, 'mark', 'set', @id, 
+                        _get_eval_enc_str(index))
+    @t._addtag id, self
+  end
+
+  def id
+    Tk::Text::IndexString.new(@id)
+  end
+
+  def exist?
+    #if ( tk_split_simplelist(_fromUTF8(tk_call_without_enc(@t.path, 'mark', 'names'))).find{|id| id == @id } )
+    if ( tk_split_simplelist(tk_call_without_enc(@t.path, 'mark', 'names'), false, true).find{|id| id == @id } )
+      true
+    else
+      false
+    end
+  end
+
+=begin
+  # move to Tk::Text::IndexModMethods module
+  def +(mod)
+    return chars(mod) if mod.kind_of?(Numeric)
+
+    mod = mod.to_s
+    if mod =~ /^\s*[+-]?\d/
+      Tk::Text::IndexString.new(@id + ' + ' + mod)
+    else
+      Tk::Text::IndexString.new(@id + ' ' + mod)
+    end
+  end
+
+  def -(mod)
+    return chars(-mod) if mod.kind_of?(Numeric)
+
+    mod = mod.to_s
+    if mod =~ /^\s*[+-]?\d/
+      Tk::Text::IndexString.new(@id + ' - ' + mod)
+    elsif mod =~ /^\s*[-]\s+(\d.*)$/
+      Tk::Text::IndexString.new(@id + ' - -' + $1)
+    else
+      Tk::Text::IndexString.new(@id + ' ' + mod)
+    end
+  end
+=end
+
+  def pos
+    @t.index(@id)
+  end
+
+  def pos=(where)
+    set(where)
+  end
+
+  def set(where)
+    tk_call_without_enc(@t.path, 'mark', 'set', @id, 
+                        _get_eval_enc_str(where))
+    self
+  end
+
+  def unset
+    tk_call_without_enc(@t.path, 'mark', 'unset', @id)
+    self
+  end
+  alias destroy unset
+
+  def gravity
+    tk_call_without_enc(@t.path, 'mark', 'gravity', @id)
+  end
+
+  def gravity=(direction)
+    tk_call_without_enc(@t.path, 'mark', 'gravity', @id, direction)
+    #self
+    direction
+  end
+
+  def next(index = nil)
+    if index
+      @t.tagid2obj(_fromUTF8(tk_call_without_enc(@t.path, 'mark', 'next', _get_eval_enc_str(index))))
+    else
+      @t.tagid2obj(_fromUTF8(tk_call_without_enc(@t.path, 'mark', 'next', @id)))
+    end
+  end
+
+  def previous(index = nil)
+    if index
+      @t.tagid2obj(_fromUTF8(tk_call_without_enc(@t.path, 'mark', 'previous', _get_eval_enc_str(index))))
+    else
+      @t.tagid2obj(_fromUTF8(tk_call_without_enc(@t.path, 'mark', 'previous', @id)))
+    end
+  end
+end
+TktMark = TkTextMark
+
+class TkTextNamedMark<TkTextMark
+  def self.new(parent, name, index=nil)
+    TMarkID_TBL.mutex.synchronize{
+      if TMarkID_TBL[parent.path] && TMarkID_TBL[parent.path][name]
+        obj = TMarkID_TBL[parent.path][name]
+      else
+        # super(parent, name, *args)
+        (obj = self.allocate).instance_eval{
+          @parent = @t = parent
+          @tpath = parent.path
+          @path = @id = name
+          TMarkID_TBL[@id] = self
+          TMarkID_TBL[@tpath] = {} unless TMarkID_TBL[@tpath]
+          TMarkID_TBL[@tpath][@id] = self unless TMarkID_TBL[@tpath][@id]
+          @t._addtag @id, self
+        }
+        obj
+      end
+
+      if obj && index
+        tk_call_without_enc(parent.path, 'mark', 'set', name, 
+                            _get_eval_enc_str(index))
+      end
+      obj
+    }
+  end
+
+  def initialize(parent, name, index=nil)
+    # dummy:: not called by 'new' method
+
+    #unless parent.kind_of?(Tk::Text)
+    #  fail ArgumentError, "expect Tk::Text for 1st argument"
+    #end
+    @parent = @t = parent
+    @tpath = parent.path
+    @path = @id = name
+    tk_call_without_enc(@t.path, 'mark', 'set', @id, 
+                        _get_eval_enc_str(index)) if index
+    @t._addtag @id, self
+  end
+end
+TktNamedMark = TkTextNamedMark
+
+class TkTextMarkInsert<TkTextNamedMark
+  def self.new(parent,*args)
+    super(parent, 'insert', *args)
+  end
+end
+TktMarkInsert = TkTextMarkInsert
+
+class TkTextMarkCurrent<TkTextNamedMark
+  def self.new(parent,*args)
+    super(parent, 'current', *args)
+  end
+end
+TktMarkCurrent = TkTextMarkCurrent
+
+class TkTextMarkAnchor<TkTextNamedMark
+  def self.new(parent,*args)
+    super(parent, 'anchor', *args)
+  end
+end
+TktMarkAnchor = TkTextMarkAnchor

data/ext/lib/tk/texttag.rb

@@ -0,0 +1,318 @@
+#
+# tk/texttag.rb - methods for treating text tags
+#
+require 'tk'
+require 'tk/text'
+require 'tk/tagfont'
+
+class TkTextTag<TkObject
+  include TkTreatTagFont
+  include Tk::Text::IndexModMethods
+
+  TTagID_TBL = TkCore::INTERP.create_table
+
+  (Tk_TextTag_ID = ['tag'.freeze, '00000'.taint]).instance_eval{
+    @mutex = Mutex.new
+    def mutex; @mutex; end
+    freeze
+  }
+
+  TkCore::INTERP.init_ip_env{
+    TTagID_TBL.mutex.synchronize{ TTagID_TBL.clear }
+  }
+
+  def TkTextTag.id2obj(text, id)
+    tpath = text.path
+    TTagID_TBL.mutex.synchronize{
+      if TTagID_TBL[tpath]
+        TTagID_TBL[tpath][id]? TTagID_TBL[tpath][id]: id
+      else 
+        id
+      end
+    }
+  end
+
+  def initialize(parent, *args)
+    #unless parent.kind_of?(TkText)
+    #  fail ArgumentError, "expect TkText for 1st argument"
+    #end
+    @parent = @t = parent
+    @tpath = parent.path
+    Tk_TextTag_ID.mutex.synchronize{
+      # @path = @id = Tk_TextTag_ID.join('')
+      @path = @id = Tk_TextTag_ID.join(TkCore::INTERP._ip_id_).freeze
+      Tk_TextTag_ID[1].succ!
+    }
+    TTagID_TBL.mutex.synchronize{
+      TTagID_TBL[@id] = self
+      TTagID_TBL[@tpath] = {} unless TTagID_TBL[@tpath]
+      TTagID_TBL[@tpath][@id] = self
+    }
+    #tk_call @t.path, "tag", "configure", @id, *hash_kv(keys)
+    if args != []
+      keys = args.pop
+      if keys.kind_of?(Hash)
+        add(*args) if args != []
+        configure(keys)
+      else
+        args.push keys
+        add(*args)
+      end
+    end
+    @t._addtag id, self
+  end
+
+  def id
+    Tk::Text::IndexString.new(@id)
+  end
+
+  def exist?
+    #if ( tk_split_simplelist(_fromUTF8(tk_call_without_enc(@t.path, 'tag', 'names'))).find{|id| id == @id } )
+    if ( tk_split_simplelist(tk_call_without_enc(@t.path, 'tag', 'names'), false, true).find{|id| id == @id } )
+      true
+    else
+      false
+    end
+  end
+
+  def first
+    Tk::Text::IndexString.new(@id + '.first')
+  end
+
+  def last
+    Tk::Text::IndexString.new(@id + '.last')
+  end
+
+  def add(*indices)
+    tk_call_without_enc(@t.path, 'tag', 'add', @id, 
+                        *(indices.collect{|idx| _get_eval_enc_str(idx)}))
+    self
+  end
+
+  def remove(*indices)
+    tk_call_without_enc(@t.path, 'tag', 'remove', @id, 
+                        *(indices.collect{|idx| _get_eval_enc_str(idx)}))
+    self
+  end
+
+  def ranges
+    l = tk_split_simplelist(tk_call_without_enc(@t.path, 'tag', 'ranges', @id))
+    r = []
+    while key=l.shift
+      r.push [Tk::Text::IndexString.new(key), Tk::Text::IndexString.new(l.shift)]
+    end
+    r
+  end
+
+  def nextrange(first, last=None)
+    simplelist(tk_call_without_enc(@t.path, 'tag', 'nextrange', @id, 
+                                   _get_eval_enc_str(first), 
+                                   _get_eval_enc_str(last))).collect{|idx|
+      Tk::Text::IndexString.new(idx)
+    }
+  end
+
+  def prevrange(first, last=None)
+    simplelist(tk_call_without_enc(@t.path, 'tag', 'prevrange', @id, 
+                                   _get_eval_enc_str(first), 
+                                   _get_eval_enc_str(last))).collect{|idx|
+      Tk::Text::IndexString.new(idx)
+    }
+  end
+
+  def [](key)
+    cget key
+  end
+
+  def []=(key,val)
+    configure key, val
+    val
+  end
+
+  def cget(key)
+    @t.tag_cget @id, key
+  end
+  def cget_strict(key)
+    @t.tag_cget_strict @id, key
+  end
+=begin
+  def cget(key)
+    case key.to_s
+    when 'text', 'label', 'show', 'data', 'file'
+      _fromUTF8(tk_call_without_enc(@t.path, 'tag', 'cget', @id, "-#{key}"))
+    when 'font', 'kanjifont'
+      #fnt = tk_tcl2ruby(tk_call(@t.path, 'tag', 'cget', @id, "-#{key}"))
+      fnt = tk_tcl2ruby(_fromUTF8(tk_call_without_enc(@t.path, 'tag', 'cget', 
+                                                      @id, '-font')))
+      unless fnt.kind_of?(TkFont)
+        fnt = tagfontobj(@id, fnt)
+      end
+      if key.to_s == 'kanjifont' && JAPANIZED_TK && TK_VERSION =~ /^4\.*/
+        # obsolete; just for compatibility
+        fnt.kanji_font
+      else
+        fnt
+      end
+    else
+      tk_tcl2ruby(_fromUTF8(tk_call_without_enc(@t.path, 'tag', 'cget', 
+                                                @id, "-#{key}")))
+    end
+  end
+=end
+
+  def configure(key, val=None)
+    @t.tag_configure @id, key, val
+  end
+#  def configure(key, val=None)
+#    if key.kind_of?(Hash)
+#      tk_call @t.path, 'tag', 'configure', @id, *hash_kv(key)
+#    else
+#      tk_call @t.path, 'tag', 'configure', @id, "-#{key}", val
+#    end
+#  end
+#  def configure(key, value)
+#    if value == FALSE
+#      value = "0"
+#    elsif value.kind_of?(Proc)
+#      value = install_cmd(value)
+#    end
+#    tk_call @t.path, 'tag', 'configure', @id, "-#{key}", value
+#  end
+
+  def configinfo(key=nil)
+    @t.tag_configinfo @id, key
+  end
+
+  def current_configinfo(key=nil)
+    @t.current_tag_configinfo @id, key
+  end
+
+  #def bind(seq, cmd=Proc.new, *args)
+  #  _bind([@t.path, 'tag', 'bind', @id], seq, cmd, *args)
+  #  self
+  #end
+  def bind(seq, *args)
+    # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
+    if TkComm._callback_entry?(args[0]) || !block_given?
+      cmd = args.shift
+    else
+      cmd = Proc.new
+    end
+    _bind([@t.path, 'tag', 'bind', @id], seq, cmd, *args)
+    self
+  end
+
+  #def bind_append(seq, cmd=Proc.new, *args)
+  #  _bind_append([@t.path, 'tag', 'bind', @id], seq, cmd, *args)
+  #  self
+  #end
+  def bind_append(seq, *args)
+    # if args[0].kind_of?(Proc) || args[0].kind_of?(Method)
+    if TkComm._callback_entry?(args[0]) || !block_given?
+      cmd = args.shift
+    else
+      cmd = Proc.new
+    end
+    _bind_append([@t.path, 'tag', 'bind', @id], seq, cmd, *args)
+    self
+  end
+
+  def bind_remove(seq)
+    _bind_remove([@t.path, 'tag', 'bind', @id], seq)
+    self
+  end
+
+  def bindinfo(context=nil)
+    _bindinfo([@t.path, 'tag', 'bind', @id], context)
+  end
+
+  def raise(above=None)
+    tk_call_without_enc(@t.path, 'tag', 'raise', @id, 
+                        _get_eval_enc_str(above))
+    self
+  end
+
+  def lower(below=None)
+    tk_call_without_enc(@t.path, 'tag', 'lower', @id, 
+                        _get_eval_enc_str(below))
+    self
+  end
+
+  def destroy
+    tk_call_without_enc(@t.path, 'tag', 'delete', @id)
+    TTagID_TBL.mutex.synchronize{
+      TTagID_TBL[@tpath].delete(@id) if TTagID_TBL[@tpath]
+    }
+    self
+  end
+end
+TktTag = TkTextTag
+
+class TkTextNamedTag<TkTextTag
+  def self.new(parent, name, *args)
+    tagobj = nil
+    TTagID_TBL.mutex.synchronize{
+      if TTagID_TBL[parent.path] && TTagID_TBL[parent.path][name]
+        tagobj = TTagID_TBL[parent.path][name]
+      else
+        # super(parent, name, *args)
+        (tagobj = self.allocate).instance_eval{
+          @parent = @t = parent
+          @tpath = parent.path
+          @path = @id = name
+          TTagID_TBL[@id] = self
+          TTagID_TBL[@tpath] = {} unless TTagID_TBL[@tpath]
+          TTagID_TBL[@tpath][@id] = self unless TTagID_TBL[@tpath][@id]
+          @t._addtag @id, self
+        }
+      end
+    }
+
+    if args != []
+      keys = args.pop
+      if keys.kind_of?(Hash)
+        tagobj.add(*args) if args != []
+        tagobj.configure(keys)
+      else
+        args.push keys
+        tagobj.add(*args)
+      end
+    end
+
+    tagobj
+  end
+
+  def initialize(parent, name, *args)
+    # dummy:: not called by 'new' method
+
+    #unless parent.kind_of?(Tk::Text)
+    #  fail ArgumentError, "expect Tk::Text for 1st argument"
+    #end
+    @parent = @t = parent
+    @tpath = parent.path
+    @path = @id = name
+
+    #if mode
+    #  tk_call @t.path, "addtag", @id, *args
+    #end
+    if args != []
+      keys = args.pop
+      if keys.kind_of?(Hash)
+        add(*args) if args != []
+        configure(keys)
+      else
+        args.push keys
+        add(*args)
+      end
+    end
+    @t._addtag @id, self
+  end
+end
+TktNamedTag = TkTextNamedTag
+
+class TkTextTagSel<TkTextNamedTag
+  def self.new(parent, *args)
+    super(parent, 'sel', *args)
+  end
+end
+TktTagSel = TkTextTagSel