package net.mograsim.plugin.tables.mi;
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileReader;
import java.io.IOException;
+import java.io.InputStream;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.swt.SWT;
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.swt.widgets.FileDialog;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorSite;
-import org.eclipse.ui.IPathEditorInput;
+import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.part.EditorPart;
+import net.mograsim.machine.Machine.ActiveMicroInstructionChangedListener;
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.MachineContext;
+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 String machineName;
private MicroInstructionMemory memory;
private InstructionTable table;
+ private MachineContext context;
+
+ // Listeners
+ private MemoryCellModifiedListener cellModifiedListener = address ->
+ {
+ setDirty(true);
+ table.refresh();
+ };
+
+ private ActiveMicroInstructionChangedListener instChangeListener = (oldAddress, newAddress) ->
+ {
+ highlight((int) (newAddress - 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
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);
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().setTopIndex(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 -> MachineContext.getInstance().getMachine().getMicroInstructionMemory().bind(memory));
+ activationButton.addListener(SWT.Selection, e -> context.getActiveMachine().ifPresent(m ->
+ {
+ m.getMicroInstructionMemory().registerMemoryReassignedListener(reassignedListener);
+ context.addActiveMachineListener(activeMachineListener);
+ m.getMicroInstructionMemory().bind(memory);
+ m.addActiveMicroInstructionChangedListener(instChangeListener);
+ }));
}
public void bindMicroInstructionMemory(MicroInstructionMemory memory)
{
+ if (this.memory != null)
+ {
+ this.memory.deregisterCellModifiedListener(cellModifiedListener);
+ }
this.memory = memory;
- this.memory.registerCellModifiedListener(this);
- this.memory.registerActiveMicroInstructionChangedListener(this);
+ if (memory != null)
+ {
+ this.memory.registerCellModifiedListener(cellModifiedListener);
+ }
if (table != null)
table.bindMicroInstructionMemory(memory);
}
- private void open(String file)
+ private void open(IFile file) throws IOException, MicroInstructionMemoryParseException, CoreException
{
- try (BufferedReader bf = new BufferedReader(new FileReader(file)))
- {
- machineName = bf.readLine();
- bindMicroInstructionMemory(MicroInstructionMemoryParser.parseMemory(machineName, bf));
- }
- catch (IOException | MicroInstructionMemoryParseException e)
- {
- e.printStackTrace();
- }
+ bindMicroInstructionMemory(MicroInstructionMemoryParser.parseMemory(
+ context.getMachineDefinition().orElseThrow(() -> new MicroInstructionMemoryParseException("No MachineDefinition assigned!"))
+ .getMicroInstructionMemoryDefinition(),
+ file.getContents()));
}
- private void save(String file)
+ private void save(IFile file, IProgressMonitor progressMonitor) throws IOException, CoreException, MicroInstructionMemoryParseException
{
if (memory == null)
{
- System.err.println("Failed to write MicroprogrammingMemory to File. No MicroprogrammingMemory assigned.");
- return;
- }
- try
- {
- MicroInstructionMemoryParser.write(memory, machineName, file);
+ throw new MicroInstructionMemoryParseException(
+ "Failed to write MicroprogrammingMemory to File. No MicroprogrammingMemory assigned.");
}
- catch (IOException e)
+ try (InputStream toWrite = MicroInstructionMemoryParser.write(memory))
{
- e.printStackTrace();
+ file.setContents(toWrite, 0, progressMonitor);
}
}
public void doSave(IProgressMonitor progressMonitor)
{
IEditorInput input = getEditorInput();
- if (input instanceof IPathEditorInput)
+ if (input instanceof IFileEditorInput)
{
- IPathEditorInput pathInput = (IPathEditorInput) input;
- save(pathInput.getPath().toOSString());
- setDirty(false);
- }
+ IFileEditorInput pathInput = (IFileEditorInput) input;
+ try
+ {
+ save(pathInput.getFile(), progressMonitor);
+ setDirty(false);
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ progressMonitor.setCanceled(true);
+ }
+ } else
+ progressMonitor.setCanceled(true);
}
@Override
public void doSaveAs()
{
- openSaveAsDialog();
+// openSaveAsDialog();
}
- private void openSaveAsDialog()
- {
- FileDialog d = new FileDialog(table.getTableViewer().getTable().getShell(), SWT.SAVE);
- d.open();
- String filename = d.getFileName();
- if (!filename.equals(""))
- {
- save(d.getFilterPath() + File.separator + filename);
- setDirty(false);
- }
- }
+// private void openSaveAsDialog()
+// {
+// FileDialog d = new FileDialog(table.getTableViewer().getTable().getShell(), SWT.SAVE);
+// d.open();
+// String filename = d.getFileName();
+// if (!filename.equals(""))
+// {
+// save(d.getFilterPath() + File.separator + filename);
+// setDirty(false);
+// }
+// }
@Override
public void init(IEditorSite site, IEditorInput input) throws PartInitException
{
setSite(site);
setInput(input);
- if (input instanceof IPathEditorInput)
+ try
{
- IPathEditorInput pathInput = (IPathEditorInput) input;
- setPartName(pathInput.getName());
- open(pathInput.getPath().toOSString());
+ if (input instanceof IFileEditorInput)
+ {
+ IFileEditorInput fileInput = (IFileEditorInput) input;
+ context = ProjectMachineContext.getMachineContextOf(fileInput.getFile().getProject());
+ context.activateMachine();
+ setPartName(fileInput.getName());
+ open(fileInput.getFile());
+ }
}
+ catch (Exception e)
+ {
+ throw new PartInitException("Failed to read input!", e);
+ }
+
}
@Override
@Override
public boolean isSaveAsAllowed()
{
- return true;
- }
-
- @Override
- public void update(long address)
- {
- setDirty(true);
- table.refresh();
+ return false;
}
private void setDirty(boolean value)
}
@Override
- public void activeMicroInstructionChanged(long address)
+ public void dispose()
{
- highlight((int) (address - memory.getDefinition().getMinimalAddress()));
+ memory.deregisterCellModifiedListener(cellModifiedListener);
+ context.getActiveMachine().ifPresent(m ->
+ {
+ m.removeActiveMicroInstructionChangedListener(instChangeListener);
+ m.getMicroInstructionMemory().deregisterMemoryReassignedListener(reassignedListener);
+ });
+ context.removeActiveMachineListener(activeMachineListener);
+ super.dispose();
}
}