Commit: 6028aaf1a49bfa6287ca63f9a9c22ece68fba207 - wmxmled (git)

wxPythonで作った簡易XMLエディタ

Commit MetaInfo

• Revisão: 6028aaf1a49bfa6287ca63f9a9c22ece68fba207 (tree)
• Hora: 2014-04-07 09:26:16
• Autor: tamanegi <tamanegi@user...>
• Commiter: tamanegi

Mensagem de Log

fix undo

Mudança Sumário

• modified: README
• modified: wmutils.py
• modified: wmxmled.py

Diff

--- a/README
+++ b/README
@@ -6,6 +6,7 @@ TODO
 * implement multiple delete, copy, cut
 
 CHANGELOG
+2014/04/07: fix and improve undo functions (paste, del, add)
 2014/03/14: read file from command line argument
             fix bug on removing attributes
             add multiple delete (ad hoc); multiple copy/cut is not supported yet

--- a/wmutils.py
+++ b/wmutils.py
@@ -226,9 +226,6 @@ class Action:
   def undo( self, treectrl ):
     return True
 
-  def gatherItemIdsForUndo( self ):
-    return []
-
 # edit action; reversed action is also edit
 class ActionEdit( Action ):
   def __init__( self, itemid = None, myxml = None ):
@@ -259,9 +256,6 @@ class ActionEdit( Action ):
   def reverse( self ):
     return ActionEdit( self.itemid, self.myxml )
 
-  def gatherItemIdsForUndo( self ):
-    return [ self.itemid ]
-
 # edit multipe elements at once
 class ActionEdits( Action ):
   def __init__( self, itemids = None, myxmls = None ):
@@ -292,72 +286,74 @@ class ActionEdits( Action ):
   def reverse( self ):
     return( ActionEdits( self.itemids, self.myxmls ) )
 
-  def gatherItemIdsForUndo( self ):
-    return self.itemids
-
 # add action; reversed action is delete
 class ActionAdd( Action ):
-  def __init__( self, parent = None, pos = None, itemid = None, myxml = None ):
+  def __init__( self, uniqids = None, pos = None, itemid = None, myxml = None ):
     Action.__init__( self )
     # itemid is an TreeItemId of added object
     # myxml is optional argument now
     if not itemid is None:
-      self.initialize( parent, pos, itemid, myxml )
+      self.initialize( uniqids, pos, itemid, myxml )
 
-  def initialize( self, parent, pos, itemid, myxml = None ):
-    self.parent = parent
+  def initialize( self, uniqids, pos, itemid, myxml = None ):
+    self.uniqids = copy.deepcopy( uniqids )
     self.pos = copy.deepcopy( pos )
     self.itemid = itemid
     self.myxml = copy.deepcopy( myxml )
 
   # simply delete specified data
   def undo( self, treectrl, wmxmled ):
-    self.parent = treectrl.GetItemParent( self.itemid )
+    self.itemid = wmxmled.findItemIdByUniqId( self.uniqids[1] )
     self.pos = wmxmled.calculateItemPosition( self.itemid )
-    self.myxml = wmxmled.createElementTreeFromTreeCtrl( self.itemid ).getroot()
+    # do not update uniqids here
+    self.myxml, uniqids = wmxmled.createElementTreeFromTreeCtrl( self.itemid )
+    self.myxml = self.myxml.getroot()
     # ListCtrl is not updated here
     return wmxmled.deleteTreeCtrlItem( self.itemid )
 
   def reverse( self ):
-    return ActionDel( self.parent, self.pos, self.itemid, self.myxml )
-
-  def gatherItemIdsForUndo( self ):
-    return [ self.parent ]
+    return ActionDel( self.uniqids, self.pos, self.itemid, self.myxml )
 
 # delete action; reversed action is add
 class ActionDel( Action ):
-  def __init__( self, parent = None, pos = None, itemid = None, myxml = None ):
+  def __init__( self, uniqids = None, pos = None, itemid = None, myxml = None ):
     Action.__init__( self )
     # note: myxml is not WMXmlElement, but is Element object of ET
     #       itemid is optional, currently unused.
     if not myxml is None:
-      self.initialize( parent, pos, itemid, myxml )
+      self.initialize( uniqids, pos, itemid, myxml )
 
-  def initialize( self, parent, pos, itemid, myxml ):
-    self.parent = parent
+  def initialize( self, uniqids, pos, itemid, myxml ):
+    self.uniqids = copy.deepcopy( uniqids )
     self.pos = copy.deepcopy( pos )
     self.itemid = itemid
     self.myxml = copy.deepcopy( myxml )
 
   # wmxmled is the main class; WMXmlEditor in wmxmled.py
   def undo( self, treectrl, wmxmled ):
-    if self.parent is None and treectrl.tc.IsEmpty(): # maybe root element
+    if treectrl.IsEmpty(): # maybe root element
       wmxmled.createXmlTree( self.myxml )
     else: # add as a child element
       tag = wmxmled.createTreeCtrlLabel( self.myxml )
+      parentid = wmxmled.findItemIdByUniqId(self.uniqids[0])
+      # find parent from saved uniqid
       if self.pos < 0:
         # if the original item is the last one
         # i.e. GetNextSibling(itemid) returns false
-        self.itemid = treectrl.AppendItem( self.parent, tag, wmxmled.imageFolder, wmxmled.imageFolderOpen )
+        self.itemid = treectrl.AppendItem( parentid, tag, wmxmled.imageFolder, wmxmled.imageFolderOpen )
       else:
-        self.itemid = treectrl.InsertItemBefore( self.parent, self.pos, tag, wmxmled.imageFolder, wmxmled.imageFolderOpen )
-      treectrl.SetItemPyData( self.itemid, [ 0, WMXmlElement( self.myxml ) ] )
+        self.itemid = treectrl.InsertItemBefore( parentid, self.pos, tag, wmxmled.imageFolder, wmxmled.imageFolderOpen )
+      treectrl.SetItemPyData( self.itemid, [ 0, WMXmlElement( self.myxml ), self.uniqids[1] ] )
+      # save current uniqid
+      uniqid_tmp = wmxmled.uniqid
+      # add to tree
       wmxmled.createXmlTreeRecursive( self.myxml, self.itemid )
+      # reassign uniq ids
+      wmxmled.reassignUniqIDsRecursive( self.itemid, self.uniqids )
+      # reset uniqid
+      wmxmled.uniqid = uniqid_tmp
     # ListCtrl is not updated here
     return True
 
   def reverse( self ):
-    return ActionAdd( self.parent, self.pos, self.itemid, self.myxml )
-
-  def gatherItemIdsForUndo( self ):
-    return [ self.parent ]
+    return ActionAdd( self.uniqids, self.pos, self.itemid, self.myxml )

--- a/wmxmled.py
+++ b/wmxmled.py
@@ -143,6 +143,8 @@ class WMXmlEditor( wx.App ):
     self.initializeImagesForTreeCtrl()
     # undo and redo list
     self.clearUndoList()
+    # unique ids for objects
+    self.uniqid = 0
 
   def clearUndoList( self ):
     self.undo = []
@@ -309,11 +311,13 @@ class WMXmlEditor( wx.App ):
   def createXmlTree( self, xmlroot ):
     # initialize tree control
     self.tc.DeleteAllItems()
+    self.uniqid = 0
     showname = self.createTreeCtrlLabel( xmlroot )
     root_itemid = self.tc.AddRoot( showname, self.imageFolder, self.imageFolderOpen )
     num = self.tc.GetCount() - 1
     # first element of the data is tentative value
-    self.tc.SetItemPyData( root_itemid, [ num, WMXmlElement( xmlroot ) ] )
+    self.tc.SetItemPyData( root_itemid, [ num, WMXmlElement( xmlroot ), self.uniqid ] )
+    self.uniqid += 1
     self.createXmlTreeRecursive( xmlroot, root_itemid )
 
   def createXmlTreeRecursive( self, element, itemid ):
@@ -321,7 +325,8 @@ class WMXmlEditor( wx.App ):
       showname = self.createTreeCtrlLabel( child )
       child_itemid = self.tc.AppendItem( itemid, showname, self.imageFolder, self.imageFolderOpen )
       num = self.tc.GetCount() - 1
-      self.tc.SetItemPyData( child_itemid, [ num, WMXmlElement( child ) ] )
+      self.tc.SetItemPyData( child_itemid, [ num, WMXmlElement( child ), self.uniqid ] )
+      self.uniqid += 1
       self.createXmlTreeRecursive( child, child_itemid )
 
   def createTreeCtrlLabel( self, myxml ):
@@ -339,6 +344,14 @@ class WMXmlEditor( wx.App ):
       ret += attr + ":" + val
     return ret
 
+  def reassignUniqIDsRecursive( self, itemid, uniqids ):
+    localcounter = 1
+    for val in self.childItemIdGeneratorRecursive( itemid ):
+      localcounter += 1
+      # item order shall not be changed
+      curdata = self.tc.GetItemPyData( val )
+      self.tc.SetItemPyData( val, [ curdata[0], curdata[1], uniqids[localcounter] ] )
+
   ### create ListCtrl from pre-built TreeCtrl
   def createListCtrlFromTreeData( self ):
     # initialize ListCtrl
@@ -666,38 +679,9 @@ class WMXmlEditor( wx.App ):
     if not itemid.IsOk():
       self.miscShowMessageBox( "unexisting item id is requested to delete?" )
       return False
-    # check undo queue (queue is expected to be small)
-    for i in range( 0, len( self.undo ) ):
-      ####queueitem = self.undo[i]
-      queueitemids = self.undo[i].gatherItemIdsForUndo()
-      # if the object trying to delete is found in undo queue, show dialog
-      if self.isDescendantItem( itemid, queueitemids ):
-        if not WMXmlEditorParams.UNDO_truncate_queue_wo_query:
-          message = "Your " + str(i) + "the action cannot be undone due to the technical problem.\n" + "Can I truncate undo queue?"
-          dialog = wx.MessageDialog( self.frameMain, message, style=wx.YES_NO|wx.NO_DEFAULT )
-          try:
-            if dialog.ShowModal() == wx.ID_YES:
-              del self.undo[i:]
-              break
-            else:
-              return False
-          finally:
-            dialog.Destroy()
-        else:
-          del self.undo[i:]
-          break
     self.tc.Delete( itemid )
     return True
 
-  def isDescendantItem( self, parent, candidates ):
-    for candidate in candidates:
-      itemid = candidate
-      while itemid.IsOk():
-        if parent == itemid:
-          return True
-        itemid = self.tc.GetItemParent( itemid )
-    return False
-
   ### "File" menu events and related
   def evMenuFileNew( self, event = None ):
     # NOTE: Close is usually more safer method.
@@ -770,7 +754,7 @@ class WMXmlEditor( wx.App ):
     fh.close()
 
   def writeXml( self, fh ):
-    xmltree = self.createElementTreeFromTreeCtrl( self.tc.GetRootItem() )
+    xmltree, uniqids = self.createElementTreeFromTreeCtrl( self.tc.GetRootItem() )
     if xmltree is None:
       self.miscShowMessageBox( "no data to write." )
     else:
@@ -808,19 +792,24 @@ class WMXmlEditor( wx.App ):
   def createElementTreeFromTreeCtrl( self, itemid ):
     # if data is empty do nothing and return None
     if not itemid.IsOk():
-      return None
-    element = self.createElementFromWMXmlElement( self.tc.GetItemPyData( itemid )[1] )
-    self.createElementFromTreeCtrlRecursive( itemid, element )
+      return None, None
+    element_data = self.tc.GetItemPyData( itemid )
+    element = self.createElementFromWMXmlElement( element_data[1] )
+    # first item of uniqids is itemid of its parent, and the second is itemid
+    # of the selected element
+    uniqids = [element_data[2]]
+    self.createElementFromTreeCtrlRecursive( itemid, element, uniqids )
     ret = ET.ElementTree( element )
-    return ret
+    return ret, uniqids
 
-  def createElementFromTreeCtrlRecursive( self, itemid, element ):
+  def createElementFromTreeCtrlRecursive( self, itemid, element, uniqids ):
     if self.tc.ItemHasChildren( itemid ):
       child_itemid, cookie = self.tc.GetFirstChild( itemid )
       while child_itemid.IsOk():
-        child_element = self.createElementFromWMXmlElement( self.tc.GetItemPyData( child_itemid )[1] )
-        element.append( child_element )
-        self.createElementFromTreeCtrlRecursive( child_itemid, element[-1] )
+        element_data = self.tc.GetItemPyData( child_itemid )
+        element.append( self.createElementFromWMXmlElement( element_data[1] ) )
+        uniqids.append( element_data[2] )
+        self.createElementFromTreeCtrlRecursive( child_itemid, element[-1], uniqids )
         child_itemid, cookie = self.tc.GetNextChild( itemid, cookie )
 
   def createElementFromWMXmlElement( self, wmxml ):
@@ -1100,7 +1089,9 @@ class WMXmlEditor( wx.App ):
       return
     myindex = min( self.lc_editing_index, self.l2l_correspondence[self.lc_editing_index] )
     treeitemid = self.l2t_correspondence[myindex]
-    self.copybuffer = self.createElementTreeFromTreeCtrl( treeitemid ).getroot()
+    # uniqids will be discarded
+    self.copybuffer, uniqids = self.createElementTreeFromTreeCtrl( treeitemid )
+    self.copybuffer = self.copybuffer.getroot()
 
   def evPopupMenuCut( self, event ):
     if not self.popupIsItemAvailable( self.lc_editing_index ):
@@ -1155,9 +1146,15 @@ class WMXmlEditor( wx.App ):
           return
         else:
           my_itemid = self.appendElement( showname, treeitemid )
-    self.tc.SetItemPyData( my_itemid, [ self.tc.GetCount() - 1, WMXmlElement( self.copybuffer ) ] )
+    newxml = WMXmlElement( self.copybuffer )
+    # use new uniq id
+    self.tc.SetItemPyData( my_itemid, [ self.tc.GetCount() - 1, newxml, self.uniqid ] )
+    self.uniqid += 1
     self.createXmlTreeRecursive( self.copybuffer, my_itemid )
     self.createListCtrlFromTreeData()
+    # add to the undo queue
+    self.addActionToUndoQueue( ActionAdd( self.gatherUniqIds( my_itemid ), 0, my_itemid, newxml ) )
+    self.IsSaved = False
 
   def evPopupMenuDelete( self, event ):
     if not self.popupIsItemAvailable( self.lc_editing_index ):
@@ -1165,17 +1162,22 @@ class WMXmlEditor( wx.App ):
     myindex = self.lc_editing_index
     treeitemid = self.l2t_correspondence[myindex]
     # save action
-    parent = self.tc.GetItemParent( treeitemid )
     pos = self.calculateItemPosition( treeitemid )
     if not self.tc.GetNextSibling( treeitemid ):
       pos = -1
     ## we need Element, not WMXmlElement
-    myxml = self.createElementTreeFromTreeCtrl( treeitemid ).getroot()
+    myxml, uniqids = self.createElementTreeFromTreeCtrl( treeitemid )
+    myxml = myxml.getroot()
+    parent = self.tc.GetItemParent(treeitemid)
+    if parent.IsOk():
+      uniqids.insert( 0, self.tc.GetItemPyData(parent)[2] )
+    else:
+      uniqids.insert( 0, None )
     #myxml = self.tc.GetItemPyData( treeitemid )[1]
     # remove item
     if self.deleteTreeCtrlItem( treeitemid ):
       # add to undo queue
-      self.addActionToUndoQueue( ActionDel( parent, pos, None, myxml ) )
+      self.addActionToUndoQueue( ActionDel( uniqids, pos, None, myxml ) )
       # store removed data for undo
       # reset flag
       self.IsSaved = False
@@ -1222,10 +1224,11 @@ class WMXmlEditor( wx.App ):
           my_itemid = self.insertElement( showname, treeitemid )
         else: # append
           my_itemid = self.appendElement( showname, treeitemid )
-      self.tc.SetItemPyData( my_itemid, [ self.tc.GetCount() - 1, newxml ] )
+      self.tc.SetItemPyData( my_itemid, [ self.tc.GetCount() - 1, newxml, self.uniqid ] )
+      self.uniqid += 1
       self.createListCtrlFromTreeData()
       # add to undo queue
-      self.addActionToUndoQueue( ActionAdd( None, 0, my_itemid, newxml ) )
+      self.addActionToUndoQueue( ActionAdd( self.gatherUniqIds( my_itemid ), 0, my_itemid, newxml ) )
       # work-up
       self.IsSaved = False
 
@@ -1294,10 +1297,11 @@ class WMXmlEditor( wx.App ):
         my_itemid = self.insertChildElement( showname, treeitemid )
       else: # append
         my_itemid = self.appendChildElement( showname, treeitemid )
-      self.tc.SetItemPyData( my_itemid, [ self.tc.GetCount() - 1, newxml ] )
+      self.tc.SetItemPyData( my_itemid, [ self.tc.GetCount() - 1, newxml, self.uniqid ] )
+      self.uniqid += 1
       self.createListCtrlFromTreeData()
       # register undo
-      self.addActionToUndoQueue( ActionAdd( None, 0, my_itemid, newxml ) )
+      self.addActionToUndoQueue( ActionAdd( self.gatherUniqIds( my_itemid ), 0, my_itemid, newxml ) )
       # work up
       self.IsSaved = False
 
@@ -1320,6 +1324,51 @@ class WMXmlEditor( wx.App ):
   def miscShowMessageBox( self, msg, msgtype = 'Info' ):
     wx.MessageBox( msg, msgtype )
 
+  def findItemIdByUniqId( self, uniqid ):
+    for myid in self.allItemIdGenerator():
+      if myid.IsOk():
+        if self.tc.GetItemPyData(myid)[2] == uniqid:
+          return myid
+    return None
+
+  def gatherUniqIds( self, itemid ):
+    if not itemid.IsOk():
+      return None
+    ret = [self.tc.GetItemPyData(itemid)[2]]
+    self.gatherUniqIdsRecursive( itemid, ret )
+    tmpid = self.tc.GetItemParent( itemid )
+    if tmpid.IsOk():
+      ret.insert( 0, self.tc.GetItemPyData( tmpid )[2] )
+    else:
+      ret.insert( 0, None )
+    return ret
+
+  def gatherUniqIdsRecursive( self, itemid, ret ):
+    if self.tc.ItemHasChildren( itemid ):
+      child_itemid, cookie = self.tc.GetFirstChild( itemid )
+      while child_itemid.IsOk():
+        ret.append( self.tc.GetItemPyData(child_itemid)[2] )
+        self.gatherUniqIdsRecursive( child_itemid, ret )
+        child_itemid, cookie = self.tc.GetNextChild( itemid, cookie )
+
+  # all itemid generator
+  def allItemIdGenerator( self ):
+    rootid = self.tc.GetRootItem()
+    if rootid.IsOk():
+      yield rootid
+      for val in self.childItemIdGeneratorRecursive( rootid ):
+        yield val
+
+  def childItemIdGeneratorRecursive( self, itemid ):
+    if self.tc.ItemHasChildren( itemid ):
+      citemid, cookie = self.tc.GetFirstChild( itemid )
+      while citemid.IsOk():
+        yield citemid
+        if self.tc.ItemHasChildren( citemid ):
+          for val in self.childItemIdGeneratorRecursive( citemid ):
+            yield val
+        citemid, cookie = self.tc.GetNextChild( itemid, cookie )
+
   ### undo and redo queues related
   def addActionToUndoQueue( self, action, remove = False ):
     self.addActionToQueue( action, self.undo )
@@ -1382,24 +1431,6 @@ class WMXmlEditor( wx.App ):
     for itemid in matched:
       self.tc.SelectItem( itemid )
 
-  # all itemid generator
-  def allItemIdGenerator( self ):
-    rootid = self.tc.GetRootItem()
-    if rootid.IsOk():
-      yield rootid
-      for val in self.childItemIdGeneratorRecursive( rootid ):
-        yield val
-
-  def childItemIdGeneratorRecursive( self, itemid ):
-    if self.tc.ItemHasChildren( itemid ):
-      citemid, cookie = self.tc.GetFirstChild( itemid )
-      while citemid.IsOk():
-        yield citemid
-        if self.tc.ItemHasChildren( citemid ):
-          for val in self.childItemIdGeneratorRecursive( citemid ):
-            yield val
-        citemid, cookie = self.tc.GetNextChild( itemid, cookie )
-
   def genXmlQuery( self ):
     ret = WMXmlQuery()
     ret.setElementQuery( xrc.XRCCTRL( self.dialogFind, "textCtrlElementFind" ).GetValue(),