import pickle
 
class Tree(object):
  # a tree class, with a single root (a Node object)
  def __init__(self):
    self.root = None
  def fillCtrl(self, ctrl):
    # fills an empty wx.TreeCtrl (ctrl) with the content of the tree structure
    if self.root is None:
      return
    root_item = ctrl.AddRoot(self.root.text)
    self.root.fillCtrl(ctrl, root_item)
  def dump(self, file):
    # writes the tree structure to a file using the pickle protocol
    pickle.dump(file, self)
  @staticmethod
  def load(file):
    # creates a new Tree which content is read in a file
    return pickle.load(file)
  @staticmethod readCtrl(ctrl):
    # creates a new Tree from the content of a wx.TreeCtrl
    self = Tree()
    item = ctrl.GetRootItem()
    self.root = Node()
    self.root.text = ctrl.GetItemText(item)
    self.root.readCtrl(ctrl, item)
    return self
 
class Node(list):
  # A class for nodes of Tree objects. Each node is a list which elements are
  # the subnodes
  def __init__(self):
    list.__init__(self)
    self.text = ""
  def fillCtrl(self, ctrl, parent_item):
    # fills a wx.TreeCtrl with items corresponding to the descent of this node
    for child in self:
      item = ctrl.AppendItem(parent_item, child.text)
      child.fillCtrl(ctrl, item)
  def readCtrl(self, ctrl, item):
    # creates the descent of this node from the content of a wx.TreeCtrl item
    child_item = ctrl.GetFirstChild(item)
    if child_item[0]:
      child_item = child_item[0]
    else:
      return
    while True:
      self.append(Node())
      self[-1].text = ctrl.GetItemText(child_item)
      self[-1].readCtrl(ctrl, child_item)
      child_item = ctrl.GetNextSibling(child_item)
      if not child_item:
        break
 
 
def dumpCtrl(ctrl, file):
  # Dumps the content of a wx.TreeCtrl to a opened file
  tree = Tree.readCtrl(ctrl)
  tree.dump(file)
 
def loadCtrl(ctrl, file):
  # loads a file containing the content of a wx.TreeCtrl
  tree = Tree.load(file)
  tree.fillCtrl(ctrl)

    @staticmethod readCtrl(ctrl):

    @staticmethod
    def readCtrl(ctrl):

self.HoldBuffer1 = ""
self.HoldBuffer2 = ""
self.TROG = ""

#    
    def btnSAVE_OnClick(self, event): 
        #we can set this to root here because we want to
        #start from the first item
        self.HoldBuffer1 = "ROOT"
        #just as good housekeeping
        self.TROG = ""
        #call the routine that will build the data to
        #save
        self.tSaveTree(self.cTREE.GetRootItem())
        #save the data
        f = open( 'treestructure.dat', 'w')
        f.write(self.TROG)            
        f.close()
        event.Skip()
 
#
#
#
#
#
    def tSaveTree(self, treeNode): 
        #as we loop through the tree we add the relevant info
        #to TROG
        if self.HoldBuffer1 == "ROOT":
            self.TROG = self.TROG + "ROOT#" + self.cTREE.GetItemText(treeNode) + "\n"
            self.HoldBuffer1 = ""
        else:
            #because this is not the root item we need to
            #find the text of the parent item
            x = self.cTREE.GetItemParent(treeNode)
            b =  self.cTREE.GetItemText(x)
            self.TROG = self.TROG + b + "#" + self.cTREE.GetItemText(treeNode) + "\n"
 
        if self.cTREE.GetChildrenCount(treeNode, False):
            cookie = -1
            child, cookie = self.cTREE.GetFirstChild(treeNode)
            while child:
                self.tSaveTree(child)
                child, cookie = self.cTREE.GetNextChild(treeNode, cookie)
 
#

#
#    
    def btnLOAD_OnClick(self, event): 
        i = 0
        f = open( 'treestructure.dat', 'r')
        x = f.readline()
        #loop for as long as we have something in
        #the line
        while x > "":
            #remove the linefeed at the end of the line
            #or things go wrong 
            #KLeft is my own little function - you can
            #use any method you like as long as you
            #lose the linefeed!
            z = KLeft(x, len(x) - 1)
            #split the string
            dank = z.split('#')
            #if this is the first line we have read
            #then we know that it will be the root item
            if i == 0:
                #this is the root item
                troot = self.cTREE.AddRoot(dank[1])
            else:
                #dank 0 holds the text of the parent item
                self.HoldBuffer1 = dank[0]
                self.HoldBuffer2 = dank[1]
                self.tLoadTree(self.cTREE.GetRootItem())
 
            #increment this now for the next item
            i = i + 1
            #read the next line
            x = f.readline()
        #all done so close the file
        f.close()
 
#
#
#
#
#
    def tLoadTree(self, treeNode): 
        if self.HoldBuffer1 == self.cTREE.GetItemText(treeNode):
            self.cTREE.AppendItem(treeNode,self.HoldBuffer2)
            return
 
        if self.cTREE.GetChildrenCount(treeNode, False):
            cookie = -1
            child, cookie = self.cTREE.GetFirstChild(treeNode)
            while child:
                self.tLoadTree(child)
                child, cookie = self.cTREE.GetNextChild(treeNode, cookie)
#
#