Added enabled flag for UpdateOp

[simantics/interop.git] / org.simantics.interop.update / src / org / simantics / interop / update / model / UpdateOp.java

diff --git a/org.simantics.interop.update/src/org/simantics/interop/update/model/UpdateOp.java b/org.simantics.interop.update/src/org/simantics/interop/update/model/UpdateOp.java
index 907741c23300b71a60b2504f26676363c05b61df..6fba56723f2c5cf2cca45117643664eb30448991 100644 (file)
--- a/org.simantics.interop.update/src/org/simantics/interop/update/model/UpdateOp.java
+++ b/org.simantics.interop.update/src/org/simantics/interop/update/model/UpdateOp.java
@@ -4,6 +4,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 
 import org.simantics.db.Resource;
+import org.simantics.db.Statement;
 import org.simantics.db.WriteGraph;
 import org.simantics.db.exception.DatabaseException;
 import org.simantics.interop.test.GraphChanges;
@@ -21,6 +22,8 @@ public abstract class UpdateOp {
        private boolean selected = false;
        private boolean manualSelection = false;
        protected boolean applied = false;
+       protected boolean visible = true;
+       protected boolean enabled = true;
        
        private Collection<UpdateOp> parentOps = new ArrayList<UpdateOp>();
        private Collection<UpdateOp> subOps = new ArrayList<UpdateOp>();
@@ -63,10 +66,42 @@ public abstract class UpdateOp {
        public abstract boolean isAdd();
        public abstract boolean isDelete();
        
+       public boolean isChange() {
+               return isAdd() || isDelete();
+       }
+       
+       /**
+        * Is parent operation applied before this.
+        * @return
+        */
        public abstract boolean requiresParentOps();
+       /**
+        * Is child operation applied before this.
+        * @return
+        */
        public abstract boolean requiresSubOps(); 
        
+       /**
+        * Is parent operation selected when this is selected
+        * @return
+        */
+       public boolean selectParentOps() {
+               return requiresParentOps();
+       }
+       
+       /**
+        * Is child operation selected when this is selected
+        * @return
+        */
+       public boolean selectSubOps() {
+               return requiresSubOps();
+       }
+       
        public boolean select(boolean select) {
+           if (!enabled)
+               return false;
+           if (!isChange())
+               return false;
                boolean b = _select(select);
                if (b)
                        manualSelection = true;
@@ -76,15 +111,19 @@ public abstract class UpdateOp {
        private boolean _select(boolean select) {
                if (select == selected)
                        return true;
+               if (applied)
+                       return false;
+               if (!isChange())
+                   return false;
                if (select) {
-                       if (requiresParentOps()) {
+                       if (selectParentOps()) {
                                for (UpdateOp op : parentOps)
                                        op._select(true);
                        }
                        
                        selected = true;
                        manualSelection = false;
-                       if (requiresSubOps()) {
+                       if (selectSubOps()) {
                                for (UpdateOp op : subOps)
                                        op._select(true);
                        }
@@ -93,13 +132,13 @@ public abstract class UpdateOp {
                        selected = false;
                        manualSelection = false;
                        for (UpdateOp op : subOps) {
-                               if (op.requiresParentOps())
+                               if (op.selectParentOps())
                                        op._select(false);
                                else if (!op.manualSelection)
                                        op._select(false);
                        }
                        for (UpdateOp op : parentOps)
-                               if (op.requiresSubOps())
+                               if (op.selectSubOps())
                                        op._select(false);
                        return true;
                }
@@ -112,6 +151,24 @@ public abstract class UpdateOp {
        public boolean applied() {
                return applied;
        }
+       
+       public boolean isVisible() {
+               return visible;
+       }
+       
+       /**
+     * Is change enabled. Disabled changes do not allow changing selected state.
+     * @return
+     */
+    public boolean enabled() {
+        return enabled;
+    }
+    
+    public void setEnabled(boolean enabled) {
+        this.enabled = enabled;
+    }
+       
+       
        public void apply(WriteGraph g) throws DatabaseException {
                if (applied)
                        return;
@@ -120,6 +177,12 @@ public abstract class UpdateOp {
                
        }
        
+       /**
+        * Applies the changes into the database.
+        * 
+        * @param g
+        * @throws DatabaseException
+        */
        protected abstract void _apply(WriteGraph g) throws DatabaseException;
        
        /**
@@ -128,6 +191,12 @@ public abstract class UpdateOp {
         */
        public abstract Resource getResource();
        
+       /**
+        * Returns resource that this operation is changing.
+        * @return
+        */
+       public abstract Statement getStatement();
+       
        /**
         * Returns resource that this operation created during apply operation. If operation did not add anything, this returns null.
         * @return