Class Tk::BLT::Tree < TkObject

# File ext/tk/lib/tkextlib/blt/tree.rb, line 620
def self.destroy(*names)
  tk_call('::blt::tree', 'destroy',
          *(names.collect{|n| (n.kind_of?(Tk::BLT::Tree))? n.id: n }) )
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 608
def self.id2obj(id)
  TreeID_TBL.mutex.synchronize{
    TreeID_TBL[id]? TreeID_TBL[id]: id
  }
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 614
def self.names(pat = None)
  simplelist(tk_call('::blt::tree', 'names', pat)).collect{|name|
    id2obj(name)
  }
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 625
def self.new(name = nil)
  TreeID_TBL.mutex.synchronize{
    if name && TreeID_TBL[name]
      TreeID_TBL[name]
    else
      (obj = self.allocate).instance_eval{
        initialize(name)
        TreeID_TBL[@id] = self
      }
      obj
    end
  }
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 639
def initialize(name = nil)
  if name
    @path = @id = name
  else
    Tree_ID.mutex.synchronize{
      @path = @id = Tree_ID.join(TkCore::INTERP._ip_id_)
      Tree_ID[1].succ!
    }
  end

  tk_call('::blt::tree', 'create', @id)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 652
def __destroy_hook__
  Tk::BLT::Tree::Node::TreeNodeID_TBL.mutex.synchronize{
    Tk::BLT::Tree::Node::TreeNodeID_TBL.delete(@path)
  }
  Tk::BLT::Tree::Tag::TreeTagID_TBL.mutex.synchronize{
    Tk::BLT::Tree::Tag::TreeTagID_TBL.delete(@path)
  }
  Tk::BLT::Tree::Notify::NotifyID_TBL.mutex.synchronize{
    Tk::BLT::Tree::Notify::NotifyID_TBL.delete(@path)
  }
  Tk::BLT::Tree::Trace::TraceID_TBL.mutex.synchronize{
    Tk::BLT::Tree::Trace::TraceID_TBL.delete(@path)
  }
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 588
def __keyonly_optkeys
  {
    # apply / find  command
    'invert'=>nil, 'leafonly'=>nil, 'nocase'=>nil,

    # apply / find / sort command
    'path'=>nil,

    # copy / restore / restorefile command
    'overwrite'=>nil,

    # copy command
    'recurse'=>nil, 'tags'=>nil,

    # sort command
    'ascii'=>nil, 'decreasing'=>nil, 'disctionary'=>nil,
    'integer'=>nil, 'real'=>nil, 'recurse'=>nil, 'reorder'=>nil,
  }
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 683
def ancestor(node1, node2)
  Tk::BLT::Tree::Node.id2obj(self, tk_call('::blt::tree', 'ancestor',
                                           tagid(node1), tagid(node2)))
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 788
def ancestor?(node1, node2)
  bool(tk_call('::blt::tree', 'is', 'ancestor',
               tagid(node1), tagid(node2)))
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 688
def apply(node, keys={})
  tk_call('::blt::tree', 'apply', tagid(node), __conv_keyonly_opts(keys))
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 693
def attach(tree_obj)
  tk_call('::blt::tree', 'attach', tree_obj)
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 792
def before?(node1, node2)
  bool(tk_call('::blt::tree', 'is', 'before',
               tagid(node1), tagid(node2)))
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 698
def children(node)
  simplelist(tk_call('::blt::tree', 'children', tagid(node))).collect{|n|
    Tk::BLT::Tree::Node.id2obj(self, n)
  }
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 704
def copy(src, parent, keys={})
  id = tk_call('::blt::tree', 'copy', tagid(src), tagid(parent),
               __conv_keyonly_opts(keys))
  Tk::BLT::Tree::Node.new(self, nil, 'node'=>id)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 709
def copy_to(src, dest_tree, parent, keys={})
  return copy(src, parent, keys={}) unless dest_tree

  id = tk_call('::blt::tree', 'copy', tagid(src), dest_tree,
               tagid(parent), __conv_keyonly_opts(keys))
  Tk::BLT::Tree::Node.new(dest_tree, nil, 'node'=>id)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 717
def degree(node)
  number(tk_call('::blt::tree', 'degree', tagid(node)))
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 721
def delete(*nodes)
  tk_call('::blt::tree', 'delete', *(nodes.collect{|node| tagid(node)}))
  Tk::BLT::Tree::Node::TreeNodeID_TBL.mutex.synchronize{
    nodes.each{|node|
      if node.kind_of?(Tk::BLT::Tree::Node)
        Tk::BLT::Tree::Node::TreeNodeID_TBL[@path].delete(node.id)
      else
        Tk::BLT::Tree::Node::TreeNodeID_TBL[@path].delete(node.to_s)
      end
    }
  }
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 735
def depth(node)
  number(tk_call('::blt::tree', 'depth', tagid(node)))
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 678
def destroy()
  tk_call('::blt::tree', 'destroy', @id)
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 739
def dump(node)
  simplelist(tk_call('::blt::tree', 'dump', tagid(node))).collect{|n|
    simplelist(n)
  }
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 745
def dump_to_file(node, file)
  tk_call('::blt::tree', 'dumpfile', tagid(node), file)
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 750
def exist?(node, key=None)
  bool(tk_call('::blt::tree', 'exists', tagid(node), key))
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 754
def find(node, keys={})
  simplelist(tk_call('::blt::tree', 'find', tagid(node),
                     __conv_keyonly_opts(keys))).collect{|n|
    Tk::BLT::Tree::Node.id2obj(self, n)
  }
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 761
def find_child(node, label)
  ret = tk_call('::blt::tree', 'findchild', tagid(node), label)
  (ret == '-1')? nil: Tk::BLT::Tree::Node.id2obj(self, ret)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 766
def first_child(node)
  ret = tk_call('::blt::tree', 'firstchild', tagid(node))
  (ret == '-1')? nil: Tk::BLT::Tree::Node.id2obj(self, ret)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 887
def fullpath(node)
  tk_call('::blt::tree', 'path', tagid(node))
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 771
def get(node)
  Hash[*simplelist(tk_call('::blt::tree', 'get', tagid(node)))]
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 774
def get_value(node, key, default_val=None)
  tk_call('::blt::tree', 'get', tagid(node), key, default_val)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 778
def index(node)
  Tk::BLT::Tree::Node.id2obj(self,
                             tk_call('::blt::tree', 'index', tagid(node)))
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 783
def insert(parent, keys={})
  id = tk_call('::blt::tree', 'insert', tagid(parent), keys)
  Tk::BLT::Tree::Node.new(self, nil, 'node'=>id)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 806
def keys(node, *nodes)
  if nodes.empty?
    simplelist(tk_call('blt::tree', 'keys', tagid(node)))
  else
    simplelist(tk_call('blt::tree', 'keys', tagid(node),
                       *(nodes.collect{|n| tagid(n)}))).collect{|lst|
      simplelist(lst)
    }
  end
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 817
def label(node, text=nil)
  if text
    tk_call('::blt::tree', 'label', tagid(node), text)
    text
  else
    tk_call('::blt::tree', 'label', tagid(node))
  end
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 826
def last_child(node)
  ret = tk_call('::blt::tree', 'lastchild', tagid(node))
  (ret == '-1')? nil: Tk::BLT::Tree::Node.id2obj(self, ret)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 796
def leaf?(node)
  bool(tk_call('::blt::tree', 'is', 'leaf', tagid(node)))
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 831
def link(parent, node, keys={})
  ret = tk_call('::blt::tree', 'link', tagid(parent), tagid(node),
                __conv_keyonly_opts(keys))
  (ret == '-1')? nil: Tk::BLT::Tree::Node.id2obj(self, ret)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 799
def link?(node)
  bool(tk_call('::blt::tree', 'is', 'link', tagid(node)))
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 837
def move(node, dest, keys={})
  tk_call('::blt::tree', 'move', tagid(node), tagid(dest), keys)
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 584
def mutex; @mutex; end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 842
def next(node)
  ret = tk_call('::blt::tree', 'next', tagid(node))
  (ret == '-1')? nil: Tk::BLT::Tree::Node.id2obj(self, ret)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 847
def next_sibling(node)
  ret = tk_call('::blt::tree', 'nextsibling', tagid(node))
  (ret == '-1')? nil: Tk::BLT::Tree::Node.id2obj(self, ret)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 852
def notify_create(*args, &b)
  Tk::BLT::Tree::Notify.new(self, *args, &b)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 856
def notify_delete(id)
  if id.kind_of?(Tk::BLT::Tree::Notify)
    id.delete
  else
    tk_call(@path, 'notify', 'delete', id)
    Tk::BLT::Tree::Notify::NotifyID_TBL.mutex.synchronize{
      Tk::BLT::Tree::Notify::NotifyID_TBL[@path].delete(id.to_s)
    }
  end
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 868
def notify_info(id)
  lst = simplelist(tk_call(@path, 'notify', 'info', tagid(id)))
  lst[0] = Tk::BLT::Tree::Notify.id2obj(self, lst[0])
  lst[1] = simplelist(lst[1]).collect{|flag| flag[1..-1]}
  lst[2] = tk_tcl2ruby(lst[2])
  lst
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 876
def notify_names()
  tk_call(@path, 'notify', 'names').collect{|id|
    Tk::BLT::Tree::Notify.id2obj(self, id)
  }
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 882
def parent(node)
  ret = tk_call('::blt::tree', 'parent', tagid(node))
  (ret == '-1')? nil: Tk::BLT::Tree::Node.id2obj(self, ret)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 891
def position(node)
  number(tk_call('::blt::tree', 'position', tagid(node)))
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 900
def prev_sibling(node)
  ret = tk_call('::blt::tree', 'prevsibling', tagid(node))
  (ret == '-1')? nil: Tk::BLT::Tree::Node.id2obj(self, ret)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 895
def previous(node)
  ret = tk_call('::blt::tree', 'previous', tagid(node))
  (ret == '-1')? nil: Tk::BLT::Tree::Node.id2obj(self, ret)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 905
def restore(node, str, keys={})
  tk_call('::blt::tree', 'restore', tagid(node), str,
          __conv_keyonly_opts(keys))
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 918
def restore_from_file(node, file, keys={})
  tk_call('::blt::tree', 'restorefile', tagid(node), file,
          __conv_keyonly_opts(keys))
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 910
def restore_overwrite(node, str, keys={})
  keys = __conv_keyonly_opts(keys)
  keys.delete('overwrite')
  keys.delete(:overwrite)
  tk_call('::blt::tree', 'restore', tagid(node), str, '-overwrite', keys)
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 923
def restore_overwrite_from_file(node, file, keys={})
  keys = __conv_keyonly_opts(keys)
  keys.delete('overwrite')
  keys.delete(:overwrite)
  tk_call('::blt::tree', 'restorefile', tagid(node), file,
          '-overwrite', keys)
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 932
def root(node=None)
  Tk::BLT::Tree::Node.id2obj(self, tk_call('::blt::tree', 'root',
                                           tagid(node)))
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 802
def root?(node)
  bool(tk_call('::blt::tree', 'is', 'root', tagid(node)))
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 937
def set(node, data)
  unless data.kind_of?(Hash)
    fail ArgumentError, 'Hash is expected for data'
  end
  args = []
  data.each{|k, v|  args << k << v}
  tk_call('::blt::tree', 'set', tagid(node), *args)
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 947
def size(node)
  number(tk_call('::blt::tree', 'size', tagid(node)))
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 951
def sort(node, keys={})
  tk_call('::blt::tree', 'sort', tagid(node), __conv_keyonly_opts(keys))
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 956
def tag_add(tag, *nodes)
  tk_call(@path, 'tag', 'add', tagid(tag), *(nodes.collect{|n| tagid(n)}))
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 961
def tag_delete(tag, *nodes)
  tk_call(@path, 'tag', 'delete', tagid(tag),
          *(nodes.collect{|n| tagid(n)}))
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 967
def tag_forget(tag)
  tag = tag.id if tag.kind_of?(Tk::BLT::Tree::Tag)
  tk_call(@path, 'tag', 'forget', tag)
  TreeTagID_TBL.mutex.synchronize{
    TreeTagID_TBL[@path].delete(tag)
  }
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 976
def tag_get(node, *patterns)
  simplelist(tk_call(@tpath, 'tag', 'get', tagid(node),
                     *(patterns.collect{|pat| tagid(pat)}))).collect{|str|
    Tk::BLT::Tree::Tag.id2obj(self, str)
  }
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 983
def tag_names(node = None)
  simplelist(tk_call(@tpath, 'tag', 'names', tagid(node))).collect{|str|
    Tk::BLT::Tree::Tag.id2obj(self, str)
  }
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 989
def tag_nodes(tag)
  simplelist(tk_call(@tpath, 'tag', 'nodes', tagid(tag))).collect{|node|
    Tk::BLT::Tree::Node.id2obj(self, node)
  }
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 995
def tag_set(node, *tags)
  tk_call(@path, 'tag', 'set', tagid(node), *(tags.collect{|t| tagid(t)}))
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 1000
def tag_unset(node, *tags)
  tk_call(@path, 'tag', 'unset', tagid(node),
          *(tags.collect{|t| tagid(t)}))
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 667
def tagid(tag)
  if tag.kind_of?(Tk::BLT::Tree::Node) ||
      tag.kind_of?(Tk::BLT::Tree::Tag) ||
      tag.kind_of?(Tk::BLT::Tree::Notify) ||
      tag.kind_of?(Tk::BLT::Tree::Trace)
    tag.id
  else
    tag  # maybe an Array of configure parameters
  end
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 1006
def trace_create(*args, &b)
  Tk::BLT::Tree::Trace.new(self, *args, &b)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 1023
def trace_delete(*args)
  args = args.collect{|id| tagid(id)}
  tk_call(@path, 'trace', 'delete', *args)
  Tk::BLT::Tree::Trace::TraceID_TBL.mutex.synchronize{
    args.each{|id| Tk::BLT::Tree::Trace::TraceID_TBL[@path].delete(id.to_s)}
  }
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 1032
def trace_info(id)
  lst = simplelist(tk_call(@path, 'trace', 'info', tagid(id)))
  lst[0] = Tk::BLT::Tree::Trace.id2obj(self, lst[0])
  lst[2] = simplelist(lst[2])
  lst[3] = tk_tcl2ruby(lst[3])
  lst
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 1040
def trace_names()
  tk_call(@path, 'trace', 'names').collect{|id|
    Tk::BLT::Tree::Trace.id2obj(self, id)
  }
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 1046
def type(node, key)
  tk_call('::blt::tree', 'type', tagid(node), key)
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 1050
def unset(node, *keys)
  tk_call('::blt::tree', 'unset', tagid(node), *keys)
  self
end

# File ext/tk/lib/tkextlib/blt/tree.rb, line 1055
def values(node, key=None)
  simplelist(tk_call('::blt::tree', 'values', tagid(node), key))
end