Insured InstructionTable removes all Listeners

[Mograsim.git] / plugins / net.mograsim.plugin.core / src / net / mograsim / plugin / tables / mi / InstructionView.java

diff --git a/plugins/net.mograsim.plugin.core/src/net/mograsim/plugin/tables/mi/InstructionView.java b/plugins/net.mograsim.plugin.core/src/net/mograsim/plugin/tables/mi/InstructionView.java
index b352e09..e354c8f 100644 (file)
--- a/plugins/net.mograsim.plugin.core/src/net/mograsim/plugin/tables/mi/InstructionView.java
+++ b/plugins/net.mograsim.plugin.core/src/net/mograsim/plugin/tables/mi/InstructionView.java
@@ -11,7 +11,6 @@ import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.layout.GridLayout;
 import org.eclipse.swt.widgets.Button;
 import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Display;
 import org.eclipse.ui.IEditorInput;
 import org.eclipse.ui.IEditorSite;
 import org.eclipse.ui.IFileEditorInput;
@@ -19,25 +18,52 @@ import org.eclipse.ui.PartInitException;
 import org.eclipse.ui.part.EditorPart;
 
 import net.mograsim.machine.Memory.MemoryCellModifiedListener;
+import net.mograsim.machine.mi.AssignableMicroInstructionMemory.MIMemoryReassignedListener;
 import net.mograsim.machine.mi.MicroInstructionMemory;
 import net.mograsim.machine.mi.MicroInstructionMemory.ActiveMicroInstructionChangedListener;
 import net.mograsim.machine.mi.MicroInstructionMemoryParseException;
 import net.mograsim.machine.mi.MicroInstructionMemoryParser;
 import net.mograsim.plugin.nature.MachineContext;
+import net.mograsim.plugin.nature.MachineContext.ActiveMachineListener;
 import net.mograsim.plugin.nature.ProjectMachineContext;
 import net.mograsim.plugin.tables.DisplaySettings;
-import net.mograsim.plugin.tables.LazyTableViewer;
 import net.mograsim.plugin.tables.RadixSelector;
 
-public class InstructionView extends EditorPart implements MemoryCellModifiedListener, ActiveMicroInstructionChangedListener
+public class InstructionView extends EditorPart
 {
        private InstructionTableContentProvider provider;
-       private int highlighted = 0;
        private boolean dirty = false;
        private MicroInstructionMemory memory;
        private InstructionTable table;
        private MachineContext context;
 
+       // Listeners
+       private MemoryCellModifiedListener cellModifiedListener = address ->
+       {
+               setDirty(true);
+               table.refresh();
+       };
+
+       private ActiveMicroInstructionChangedListener activeInstructionChangedListener = address -> highlight(
+                       (int) (address - memory.getDefinition().getMinimalAddress()));
+
+       private MIMemoryReassignedListener reassignedListener = newAssignee ->
+       {
+               // clear highlighting if the memory is reassigned
+               if (newAssignee != memory)
+                       highlight(-1);
+       };
+
+       private ActiveMachineListener activeMachineListener = (oldMachine, newMachine) ->
+       {
+               // clear highlighting if the active machine changes
+               if (newMachine.isEmpty() || !newMachine.equals(oldMachine))
+               {
+                       highlight(-1);
+                       oldMachine.ifPresent(m -> m.getMicroInstructionMemory().deregisterMemoryReassignedListener(reassignedListener));
+               }
+       };
+
        @SuppressWarnings("unused")
        @Override
        public void createPartControl(Composite parent)
@@ -50,8 +76,7 @@ public class InstructionView extends EditorPart implements MemoryCellModifiedLis
                new RadixSelector(parent, displaySettings);
 
                addActivationButton(parent);
-
-               table = new InstructionTable(parent, displaySettings);
+               table = new InstructionTable(parent, displaySettings, getSite().getWorkbenchWindow().getWorkbench().getThemeManager());
                table.setContentProvider(provider);
                table.bindMicroInstructionMemory(memory);
 
@@ -60,39 +85,35 @@ public class InstructionView extends EditorPart implements MemoryCellModifiedLis
                table.getTableViewer().getTable().setLayoutData(viewerData);
        }
 
-       public void highlight(int index)
+       public void highlight(int row)
        {
-               Display.getDefault().asyncExec(() ->
-               {
-                       LazyTableViewer viewer = table.getTableViewer();
-                       viewer.highlightRow(highlighted, false);
-                       highlighted = index;
-                       viewer.highlightRow(index, true);
-                       viewer.getTable().showItem(viewer.getTable().getItem(Math.min((int) memory.getDefinition().getMaximalAddress(), index + 2)));
-                       viewer.getTable().showItem(viewer.getTable().getItem(index));
-               });
+               table.highlight(row);
        }
 
        private void addActivationButton(Composite parent)
        {
                Button activationButton = new Button(parent, SWT.PUSH);
                activationButton.setText("Set Active");
-               activationButton.addListener(SWT.Selection,
-                               e -> context.getActiveMachine().ifPresent(m -> m.getMicroInstructionMemory().bind(memory)));
+               activationButton.addListener(SWT.Selection, e -> context.getActiveMachine().ifPresent(m ->
+               {
+                       m.getMicroInstructionMemory().registerMemoryReassignedListener(reassignedListener);
+                       context.addActiveMachineListener(activeMachineListener);
+                       m.getMicroInstructionMemory().bind(memory);
+               }));
        }
 
        public void bindMicroInstructionMemory(MicroInstructionMemory memory)
        {
                if (this.memory != null)
                {
-                       this.memory.deregisterCellModifiedListener(this);
-                       this.memory.deregisterActiveMicroInstructionChangedListener(this);
+                       this.memory.deregisterCellModifiedListener(cellModifiedListener);
+                       this.memory.deregisterActiveMicroInstructionChangedListener(activeInstructionChangedListener);
                }
                this.memory = memory;
                if (memory != null)
                {
-                       this.memory.registerCellModifiedListener(this);
-                       this.memory.registerActiveMicroInstructionChangedListener(this);
+                       this.memory.registerCellModifiedListener(cellModifiedListener);
+                       this.memory.registerActiveMicroInstructionChangedListener(activeInstructionChangedListener);
                }
                if (table != null)
                        table.bindMicroInstructionMemory(memory);
@@ -175,6 +196,7 @@ public class InstructionView extends EditorPart implements MemoryCellModifiedLis
                        {
                                IFileEditorInput fileInput = (IFileEditorInput) input;
                                context = ProjectMachineContext.getMachineContextOf(fileInput.getFile().getProject());
+                               context.activateMachine();
                                setPartName(fileInput.getName());
                                open(fileInput.getFile());
                        }
@@ -198,13 +220,6 @@ public class InstructionView extends EditorPart implements MemoryCellModifiedLis
                return false;
        }
 
-       @Override
-       public void update(long address)
-       {
-               setDirty(true);
-               table.refresh();
-       }
-
        private void setDirty(boolean value)
        {
                dirty = value;
@@ -212,8 +227,12 @@ public class InstructionView extends EditorPart implements MemoryCellModifiedLis
        }
 
        @Override
-       public void activeMicroInstructionChanged(long address)
+       public void dispose()
        {
-               highlight((int) (address - memory.getDefinition().getMinimalAddress()));
+               memory.deregisterActiveMicroInstructionChangedListener(activeInstructionChangedListener);
+               memory.deregisterCellModifiedListener(cellModifiedListener);
+               context.getActiveMachine().ifPresent(m -> m.getMicroInstructionMemory().deregisterMemoryReassignedListener(reassignedListener));
+               context.removeActiveMachineListener(activeMachineListener);
+               super.dispose();
        }
 }