RefactoringRope/RefactoringDialogBase.py

branch
server_client_variant
changeset 171
9872d31f8755
parent 147
3f8a995f6e49
child 172
c8890f852917
diff -r 05ef7c12a6d4 -r 9872d31f8755 RefactoringRope/RefactoringDialogBase.py
--- a/RefactoringRope/RefactoringDialogBase.py	Sun Sep 17 18:30:14 2017 +0200
+++ b/RefactoringRope/RefactoringDialogBase.py	Sun Sep 17 20:03:39 2017 +0200
@@ -10,7 +10,7 @@
 from __future__ import unicode_literals
 
 from PyQt5.QtCore import Qt
-from PyQt5.QtWidgets import QDialog, QApplication
+from PyQt5.QtWidgets import QDialog
 
 from E5Gui.E5Application import e5App
 
@@ -34,80 +34,74 @@
         
         self._refactoring = refactoring
         self._title = title
-        self.__handle = None
     
-    def __createProgressHandle(self, interruptable=True):
-        """
-        Private method to create a TaskHandle to update a progress dialog.
-        
-        @param interruptable flag indicating, that the task may be
-            interrupted (boolean)
+    def calculateChanges(self):
         """
-        from ProgressHandle import ProgressHandle
-        self.__handle = ProgressHandle(self._title, interruptable, self)
-        self.__handle.show()
-        QApplication.processEvents()
-    
-    def _calculateChanges(self, handle):
-        """
-        Protected method to calculate the changes.
+        Public method to initiate the calculation of changes.
         
-        @param handle reference to the task handle
-            (rope.base.taskhandle.TaskHandle)
-        @ireturn reference to the ChangeSet object (rope.base.change.ChangeSet)
         @exception NotImplementedError raised to indicate that this method must
             be overridden by subclasses
         """
         raise NotImplementedError("_calculateChanges must be overridden.")
     
-    def __getChanges(self):
-        """
-        Private method to build the Changes object.
-        
-        @return reference to the Changes object (rope.base.change.ChangeSet)
-        """
-        self.__createProgressHandle()
-        changes = self._calculateChanges(self.__handle)
-        self.__handle.reset()
-        self.__handle = None
-        
-        return changes
-    
-    def previewChanges(self):
+    def previewChanges(self, data):
         """
         Public method to preview the changes.
+        
+        @param data dictionary containing the change data
+        @type dict
         """
-        changes = self.__getChanges()
-        
-        if changes is not None:
-            from ChangesPreviewDialog import ChangesPreviewDialog
-            dlg = ChangesPreviewDialog(changes, self)
-            if dlg.exec_() == QDialog.Accepted:
-                self.applyChanges(changes)
+        from ChangesPreviewDialog import ChangesPreviewDialog
+        dlg = ChangesPreviewDialog(
+            data["Description"], data["Changes"], self)
+        if dlg.exec_() == QDialog.Accepted:
+            self.applyChanges()
     
-    def applyChanges(self, changes=None):
+    def applyChanges(self):
         """
         Public method to apply the changes.
-        
-        @param changes reference to the ChangeSet object
-            (rope.base.change.ChangeSet)
         """
-        if changes is None:
-            changes = self.__getChanges()
+        self._refactoring.sendJson("ApplyChanges", {
+            "ChangeGroup": self._changeGroupName,
+        })
+##        if changes is not None:
+##            self.__createProgressHandle(False)
+##            try:
+##                self._refactoring.getProject().do(changes, self.__handle)
+##            except Exception as err:
+##                self._refactoring.handleRopeError(
+##                    err, self._title, self.__handle)
+##            self.__handle.reset()
+##            self.__handle = None
+    
+    def processChangeData(self, data):
+        """
+        Public method to process the change data sent by the refactoring
+        client.
         
-        if changes is not None:
-            self.__createProgressHandle(False)
-            try:
-                self._refactoring.getProject().do(changes, self.__handle)
-            except Exception as err:
-                self._refactoring.handleRopeError(
-                    err, self._title, self.__handle)
-            self.__handle.reset()
-            self.__handle = None
-            
-            self._refactoring.refreshEditors(changes)
+        @param data dictionary containing the change data
+        @type dict
+        """
+        subcommand = data["Subcommand"]
+        if subcommand == "PreviewChanges":
+            self.previewChanges(data)
+        elif subcommand == "ChangesApplied":
+            self._refactoring.refreshEditors(data["ChangedFiles"])
             p = e5App().getObject("Project")
             if p.isDirty():
                 p.saveProject()
         
-        self.accept()
+            self.accept()
+    
+    def closeEvent(self, evt):
+        """
+        Protected method handling close events.
+        
+        @param evt reference to the close event object
+        @type QCloseEvent
+        """
+        self.__refactoring.sendJson("ClearChanges", {
+            "ChangeGroup": self._changeGroupName,
+        })
+        
+        evt.accept()

eric ide

mercurial