Make FileUnsharedEvent a batch event

cli-lanterna/src/main/groovy/com/muwire/clilanterna/FilesModel.groovy

@@ -52,7 +52,7 @@ class FilesModel {
     
     void onFileUnsharedEvent(FileUnsharedEvent e) {
         guiThread.invokeLater {
-            sharedFiles.remove(e.unsharedFile)
+            sharedFiles.removeAll(e.unsharedFiles)
         }
     }
     

cli-lanterna/src/main/groovy/com/muwire/clilanterna/FilesView.groovy

@@ -82,7 +82,7 @@ class FilesView extends BasicWindow {
         contentPanel.setLayoutManager(new GridLayout(4))
         
         Button unshareButton = new Button("Unshare", {
-            core.eventBus.publish(new FileUnsharedEvent(unsharedFile : sf))
+            core.eventBus.publish(new FileUnsharedEvent(unsharedFiles : new SharedFile[]{sf}))
             MessageDialog.showMessageDialog(textGUI, "File Unshared", "Unshared "+sf.getFile().getName(), MessageDialogButton.OK)
         } )
         Button addCommentButton = new Button("Add Comment", {

core/src/main/groovy/com/muwire/core/collections/CollectionManager.groovy

@@ -284,14 +284,16 @@ class CollectionManager {
     }
     
     synchronized void onFileUnsharedEvent(FileUnsharedEvent e) {
-        InfoHash infoHash = new InfoHash(e.unsharedFile.getRoot())
+        for (SharedFile sf : e.unsharedFiles) {
-        Set<FileCollection> affected = fileRootToCollections.get(infoHash)
+            InfoHash infoHash = sf.getRootInfoHash()
-        if (affected == null || affected.isEmpty()) {
+            Set<FileCollection> affected = fileRootToCollections.get(infoHash)
-            return
+            if (affected == null || affected.isEmpty()) {
-        }
+                continue
-        affected.each { c ->
+            }
-            diskIO.execute({delete(c)} as Runnable)
+            affected.each { c ->
-            eventBus.publish(new CollectionUnsharedEvent(collection : c))
+                diskIO.execute({ delete(c) } as Runnable)
+                eventBus.publish(new CollectionUnsharedEvent(collection: c))
+            }
         }
     }
     

core/src/main/groovy/com/muwire/core/files/DirectoryWatcher.groovy

@@ -135,7 +135,7 @@ class DirectoryWatcher {
         log.fine("deleted entry $f")
         SharedFile sf = fileManager.fileToSharedFile.get(f)
         if (sf != null)
-            eventBus.publish(new FileUnsharedEvent(unsharedFile : sf, deleted : true))
+            eventBus.publish(new FileUnsharedEvent(unsharedFiles : new SharedFile[]{sf}, deleted : true))
         else if (watchedDirectoryManager.isWatched(f)) 
             eventBus.publish(new DirectoryUnsharedEvent(directory : f, deleted : true))
         else

core/src/main/groovy/com/muwire/core/files/FileManager.groovy

@@ -132,7 +132,11 @@ class FileManager {
     }
 
     void onFileUnsharedEvent(FileUnsharedEvent e) {
-        SharedFile sf = e.unsharedFile
+        for(SharedFile sharedFile : e.unsharedFiles)
+            unshareFile(sharedFile, e.deleted)
+    }
+    
+    private void unshareFile(SharedFile sf, boolean deleted) {
         InfoHash infoHash = new InfoHash(sf.getRoot())
         SharedFile[] existing = rootToFiles.get(infoHash)
         if (existing != null) {
@@ -149,7 +153,7 @@ class FileManager {
 
         fileToSharedFile.remove(sf.file)
         positiveTree.remove(sf.file)
-        if (!e.deleted && negativeTree.fileToNode.containsKey(sf.file.getParentFile())) {
+        if (!deleted && negativeTree.fileToNode.containsKey(sf.file.getParentFile())) {
             negativeTree.add(sf.file,null)
             saveNegativeTree()
         }
@@ -258,22 +262,23 @@ class FileManager {
         negativeTree.remove(e.directory)
         saveNegativeTree()
         if (!e.deleted) {
+            List<SharedFile> unsharedFiles = new ArrayList<>()
             e.directory.listFiles().each {
                 if (it.isDirectory())
                     eventBus.publish(new DirectoryUnsharedEvent(directory : it))
                 else {
                     SharedFile sf = fileToSharedFile.get(it)
                     if (sf != null)
-                        eventBus.publish(new FileUnsharedEvent(unsharedFile : sf))
+                        unsharedFiles.add(sf)
                 }
             }
+            eventBus.publish(new FileUnsharedEvent(unsharedFiles : unsharedFiles.toArray(new SharedFile[0])))
         } else {
              def cb = new DirDeletionCallback()
              positiveTree.traverse(e.directory, cb)
              positiveTree.remove(e.directory)
-             cb.unsharedFiles.each { 
+             eventBus.publish(new FileUnsharedEvent()unsharedFiles: cb.unsharedFiles.toArray(new SharedFile[0]), 
-                 eventBus.publish(new FileUnsharedEvent(unsharedFile : it, deleted: true))
+                deleted: true)
-             }
              cb.subDirs.each {
                  eventBus.publish(new DirectoryUnsharedEvent(directory : it, deleted : true))
              }

core/src/main/groovy/com/muwire/core/files/FileUnsharedEvent.groovy

@@ -4,6 +4,6 @@ import com.muwire.core.Event
 import com.muwire.core.SharedFile
 
 class FileUnsharedEvent extends Event {
-    SharedFile unsharedFile
+    SharedFile[] unsharedFiles
     boolean deleted
 }

core/src/main/groovy/com/muwire/core/files/HasherService.groovy

@@ -78,7 +78,7 @@ class HasherService {
     }
     
     void onFileUnsharedEvent(FileUnsharedEvent evt) {
-        hashed.remove(evt.unsharedFile.file)
+        hashed.removeAll(evt.unsharedFiles)
     }
     
     void onDirectoryUnsharedEvent(DirectoryUnsharedEvent evt) {

core/src/main/groovy/com/muwire/core/files/PersisterFolderService.groovy

@@ -80,12 +80,17 @@ class PersisterFolderService extends BasePersisterService {
      * @param unsharedEvent
      */
     void onFileUnsharedEvent(FileUnsharedEvent unsharedEvent) {
-        def jsonPath = getJsonPath(unsharedEvent.unsharedFile)
+        for(SharedFile sharedFile : unsharedEvent.unsharedFiles)
+            unshareFile(sharedFile)
+    }
+    
+    private void unshareFile(SharedFile sharedFile) {
+        def jsonPath = getJsonPath(sharedFile)
         def jsonFile = jsonPath.toFile()
         if(jsonFile.isFile()){
             jsonFile.delete()
         }
-        def hashListPath = getHashListPath(unsharedEvent.unsharedFile)
+        def hashListPath = getHashListPath(sharedFile)
         def hashListFile = hashListPath.toFile()
         if (hashListFile.isFile())
             hashListFile.delete()

core/src/main/groovy/com/muwire/core/files/directories/WatchedDirectoryManager.groovy

@@ -195,9 +195,7 @@ class WatchedDirectoryManager {
         
         Set<File> deletedFiles = new HashSet<>(cb.files)
         deletedFiles.removeAll(filesOnFS)
-        deletedFiles.each {
+        eventBus.publish(new FileUnsharedEvent(unsharedFiles: deletedFiles.toArray(new SharedFile[0]), deleted: true))
-            eventBus.publish(new FileUnsharedEvent(unsharedFile : fileManager.getFileToSharedFile().get(it), deleted : true))
-        }
         Set<File> deletedDirs = new HashSet<>(cb.dirs)
         deletedDirs.removeAll(dirsOnFS)
         deletedDirs.each {

core/src/test/groovy/com/muwire/core/files/FileManagerTest.groovy

@@ -154,7 +154,7 @@ class FileManagerTest {
         manager.onFileLoadedEvent new FileLoadedEvent(loadedFile : sf1)
         manager.onFileLoadedEvent new FileLoadedEvent(loadedFile : sf2)
 
-        manager.onFileUnsharedEvent new FileUnsharedEvent(deleted : true, unsharedFile: sf2)
+        manager.onFileUnsharedEvent new FileUnsharedEvent(deleted : true, unsharedFiles: new SharedFile[]{sf2})
 
         manager.onSearchEvent new SearchEvent(searchHash : ih.getRoot())
         Thread.sleep(20)
@@ -175,7 +175,7 @@ class FileManagerTest {
         SharedFile sf2 = new SharedFile(f2, ih2.getRoot(), 0)
         manager.onFileLoadedEvent new FileLoadedEvent(loadedFile: sf2)
 
-        manager.onFileUnsharedEvent new FileUnsharedEvent(deleted : true, unsharedFile: sf2)
+        manager.onFileUnsharedEvent new FileUnsharedEvent(deleted : true, unsharedFiles: new SharedFile[]{sf2})
 
         // 1 match left
         manager.onSearchEvent new SearchEvent(searchTerms: ["c"])
@@ -202,7 +202,7 @@ class FileManagerTest {
         sf1.setComment(comment)
         
         manager.onFileLoadedEvent(new FileLoadedEvent(loadedFile : sf1))
-        manager.onFileUnsharedEvent(new FileUnsharedEvent(unsharedFile : sf1, deleted : true))
+        manager.onFileUnsharedEvent(new FileUnsharedEvent(unsharedFiles : new SharedFile[]{sf1}, deleted : true))
         
         File f2 = new File("MuWire-0.6.0.AppImage")
         InfoHash ih2 = InfoHash.fromHashList(new byte[64])

gui/griffon-app/controllers/com/muwire/gui/MainFrameController.groovy

@@ -455,6 +455,7 @@ class MainFrameController {
         def sfs = view.selectedSharedFiles()
         if (sfs == null)
             return
+        List<SharedFile> toUnshare = new ArrayList<>()
         sfs.each { SharedFile sf ->
             
             if (view.settings.collectionWarning) {
@@ -475,9 +476,9 @@ class MainFrameController {
                         return
                 }
             }
-            
+            toUnshare.add(sf)
-            core.eventBus.publish(new FileUnsharedEvent(unsharedFile : sf))
         }
+        core.eventBus.publish(new FileUnsharedEvent(unsharedFiles : toUnshare.toArray(new SharedFile[0])))
     }
     
     @ControllerAction

gui/griffon-app/models/com/muwire/gui/MainFrameModel.groovy

@@ -538,60 +538,66 @@ class MainFrameModel {
 
     void onFileUnsharedEvent(FileUnsharedEvent e) {
         runInsideUIAsync {
-            allSharedFiles.remove(e.unsharedFile)
+            synchronized (allSharedFiles) {
+                allSharedFiles.removeAll(e.unsharedFiles)
+            }
             loadedFiles = allSharedFiles.size()
             
-            boolean wasVisible = shared.remove(e.unsharedFile)
+            for (SharedFile sharedFile : e.unsharedFiles) {
-            
+                boolean wasVisible = shared.remove(sharedFile)
-            DefaultMutableTreeNode dmtn = fileToNode.remove(e.unsharedFile)
+
-            if (dmtn != null) {
+                DefaultMutableTreeNode dmtn = fileToNode.remove(sharedFile)
-                
+                if (dmtn != null) {
-                if (wasVisible) {
+
-                    Object[] path = dmtn.getUserObjectPath()
+                    if (wasVisible) {
-                    DefaultMutableTreeNode otherNode = treeRoot
+                        Object[] path = dmtn.getUserObjectPath()
-                    for (int i = 1; i < path.length; i ++) {
+                        DefaultMutableTreeNode otherNode = treeRoot
-                        Object o = path[i]
+                        for (int i = 1; i < path.length; i++) {
-                        DefaultMutableTreeNode next = null
+                            Object o = path[i]
-                        for (int j = 0; j < otherNode.childCount; j ++) {
+                            DefaultMutableTreeNode next = null
-                            if (otherNode.getChildAt(j).getUserObject() == o) {
+                            for (int j = 0; j < otherNode.childCount; j++) {
-                                next = otherNode.getChildAt(j)
+                                if (otherNode.getChildAt(j).getUserObject() == o) {
-                                break
+                                    next = otherNode.getChildAt(j)
+                                    break
+                                }
                             }
+                            if (next == null)
+                                throw new IllegalStateException()
+                            otherNode = next
+                        }
+                        while (true) {
+                            def parent = otherNode.getParent()
+                            otherNode.removeFromParent()
+                            if (parent.getChildCount() == 0) {
+                                otherNode = parent
+                            } else
+                                break
                         }
-                        if (next == null)
-                            throw new IllegalStateException()
-                        otherNode = next
                     }
-                    while(true) {
+
-                        def parent = otherNode.getParent()
+                    List<File> unshared = new ArrayList<>()
-                        otherNode.removeFromParent()
+                    while (true) {
-                        if (parent.getChildCount() == 0) {
+                        def parent = dmtn.getParent()
-                            otherNode = parent
+                        parent.remove(dmtn)
-                        } else
+                        if (parent == allFilesTreeRoot)
                             break
-                    }
+                        if (parent.getChildCount() == 0) {
-                }
+                            File file = parent.getUserObject().file
-                
+                            if (core.watchedDirectoryManager.isWatched(file))
-                List<File> unshared = new ArrayList<>()
+                                unshared.add(file)
-                while (true) {
+                            dmtn = parent
-                    def parent = dmtn.getParent()
+                            continue
-                    parent.remove(dmtn)
+                        }
-                    if (parent == allFilesTreeRoot)
                         break
-                    if (parent.getChildCount() == 0) {
-                        File file = parent.getUserObject().file
-                        if (core.watchedDirectoryManager.isWatched(file))
-                            unshared.add(file)
-                        dmtn = parent
-                        continue
                     }
-                    break
+                    if (!unshared.isEmpty()) {
+                        File unsharedRoot = unshared.get(unshared.size() - 1)
+                        core.eventBus.publish(new DirectoryUnsharedEvent(directory: unsharedRoot))
+                    }
                 }
-                if (!unshared.isEmpty()) {
+            }
-                    File unsharedRoot = unshared.get( unshared.size() -1 )
+            
-                    core.eventBus.publish(new DirectoryUnsharedEvent(directory : unsharedRoot))
+            view.refreshSharedFiles()
-                }
-            } 
         }
     }