plugins/net.mograsim.plugin.core/src/net/mograsim/plugin/tables/mi/InstructionView.java

   1 package net.mograsim.plugin.tables.mi;
   2
   3 import java.io.IOException;
   4 import java.io.InputStream;
   5
   6 import org.eclipse.core.resources.IFile;
   7 import org.eclipse.core.runtime.CoreException;
   8 import org.eclipse.core.runtime.IProgressMonitor;
   9 import org.eclipse.swt.SWT;
  10 import org.eclipse.swt.layout.GridData;
  11 import org.eclipse.swt.layout.GridLayout;
  12 import org.eclipse.swt.widgets.Button;
  13 import org.eclipse.swt.widgets.Composite;
  14 import org.eclipse.ui.IEditorInput;
  15 import org.eclipse.ui.IEditorSite;
  16 import org.eclipse.ui.IFileEditorInput;
  17 import org.eclipse.ui.PartInitException;
  18 import org.eclipse.ui.part.EditorPart;
  19
  20 import net.mograsim.machine.Machine.ActiveMicroInstructionChangedListener;
  21 import net.mograsim.machine.Memory.MemoryCellModifiedListener;
  22 import net.mograsim.machine.mi.AssignableMicroInstructionMemory.MIMemoryReassignedListener;
  23 import net.mograsim.machine.mi.MicroInstructionMemory;
  24 import net.mograsim.machine.mi.MicroInstructionMemoryParseException;
  25 import net.mograsim.machine.mi.MicroInstructionMemoryParser;
  26 import net.mograsim.plugin.nature.MachineContext;
  27 import net.mograsim.plugin.nature.MachineContext.ActiveMachineListener;
  28 import net.mograsim.plugin.nature.ProjectMachineContext;
  29 import net.mograsim.plugin.tables.DisplaySettings;
  30 import net.mograsim.plugin.tables.RadixSelector;
  31
  32 public class InstructionView extends EditorPart
  33 {
  34         private InstructionTableContentProvider provider;
  35         private boolean dirty = false;
  36         private MicroInstructionMemory memory;
  37         private InstructionTable table;
  38         private MachineContext context;
  39
  40         // Listeners
  41         private MemoryCellModifiedListener cellModifiedListener = address ->
  42         {
  43                 setDirty(true);
  44                 table.refresh();
  45         };
  46
  47         private ActiveMicroInstructionChangedListener instChangeListener = (oldAddress, newAddress) ->
  48         {
  49                 highlight((int) (newAddress - memory.getDefinition().getMinimalAddress()));
  50         };
  51
  52         private MIMemoryReassignedListener reassignedListener = newAssignee ->
  53         {
  54                 // clear highlighting if the memory is reassigned
  55                 if (newAssignee != memory)
  56                         highlight(-1);
  57         };
  58
  59         private ActiveMachineListener activeMachineListener = (oldMachine, newMachine) ->
  60         {
  61                 // clear highlighting if the active machine changes
  62                 if (newMachine.isEmpty() || !newMachine.equals(oldMachine))
  63                 {
  64                         highlight(-1);
  65                         oldMachine.ifPresent(m -> m.getMicroInstructionMemory().deregisterMemoryReassignedListener(reassignedListener));
  66                 }
  67         };
  68
  69         @SuppressWarnings("unused")
  70         @Override
  71         public void createPartControl(Composite parent)
  72         {
  73                 provider = new InstructionTableLazyContentProvider();
  74                 GridLayout layout = new GridLayout(3, false);
  75                 parent.setLayout(layout);
  76
  77                 DisplaySettings displaySettings = new DisplaySettings();
  78                 new RadixSelector(parent, displaySettings);
  79
  80                 addActivationButton(parent);
  81                 table = new InstructionTable(parent, displaySettings, getSite().getWorkbenchWindow().getWorkbench().getThemeManager());
  82                 table.setContentProvider(provider);
  83                 table.bindMicroInstructionMemory(memory);
  84
  85                 GridData viewerData = new GridData(GridData.GRAB_HORIZONTAL | GridData.GRAB_VERTICAL | GridData.FILL_BOTH);
  86                 viewerData.horizontalSpan = 3;
  87                 table.getTableViewer().getTable().setLayoutData(viewerData);
  88         }
  89
  90         public void highlight(int row)
  91         {
  92                 table.highlight(row);
  93         }
  94
  95         private void addActivationButton(Composite parent)
  96         {
  97                 Button activationButton = new Button(parent, SWT.PUSH);
  98                 activationButton.setText("Set Active");
  99                 activationButton.addListener(SWT.Selection, e -> context.getActiveMachine().ifPresent(m ->
 100                 {
 101                         m.getMicroInstructionMemory().registerMemoryReassignedListener(reassignedListener);
 102                         context.addActiveMachineListener(activeMachineListener);
 103                         m.getMicroInstructionMemory().bind(memory);
 104                         m.addActiveMicroInstructionChangedListener(instChangeListener);
 105                 }));
 106         }
 107
 108         public void bindMicroInstructionMemory(MicroInstructionMemory memory)
 109         {
 110                 if (this.memory != null)
 111                 {
 112                         this.memory.deregisterCellModifiedListener(cellModifiedListener);
 113                 }
 114                 this.memory = memory;
 115                 if (memory != null)
 116                 {
 117                         this.memory.registerCellModifiedListener(cellModifiedListener);
 118                 }
 119                 if (table != null)
 120                         table.bindMicroInstructionMemory(memory);
 121         }
 122
 123         private void open(IFile file) throws IOException, MicroInstructionMemoryParseException, CoreException
 124         {
 125                 bindMicroInstructionMemory(MicroInstructionMemoryParser.parseMemory(
 126                                 context.getMachineDefinition().orElseThrow(() -> new MicroInstructionMemoryParseException("No MachineDefinition assigned!"))
 127                                                 .getMicroInstructionMemoryDefinition(),
 128                                 file.getContents()));
 129         }
 130
 131         private void save(IFile file, IProgressMonitor progressMonitor) throws IOException, CoreException, MicroInstructionMemoryParseException
 132         {
 133                 if (memory == null)
 134                 {
 135                         throw new MicroInstructionMemoryParseException(
 136                                         "Failed to write MicroprogrammingMemory to File. No MicroprogrammingMemory assigned.");
 137                 }
 138                 try (InputStream toWrite = MicroInstructionMemoryParser.write(memory))
 139                 {
 140                         file.setContents(toWrite, 0, progressMonitor);
 141                 }
 142         }
 143
 144         @Override
 145         public void setFocus()
 146         {
 147                 table.getTableViewer().getControl().setFocus();
 148         }
 149
 150         @Override
 151         public void doSave(IProgressMonitor progressMonitor)
 152         {
 153                 IEditorInput input = getEditorInput();
 154                 if (input instanceof IFileEditorInput)
 155                 {
 156                         IFileEditorInput pathInput = (IFileEditorInput) input;
 157                         try
 158                         {
 159                                 save(pathInput.getFile(), progressMonitor);
 160                                 setDirty(false);
 161                         }
 162                         catch (Exception e)
 163                         {
 164                                 e.printStackTrace();
 165                                 progressMonitor.setCanceled(true);
 166                         }
 167                 } else
 168                         progressMonitor.setCanceled(true);
 169         }
 170
 171         @Override
 172         public void doSaveAs()
 173         {
 174 //              openSaveAsDialog();
 175         }
 176
 177 //      private void openSaveAsDialog()
 178 //      {
 179 //              FileDialog d = new FileDialog(table.getTableViewer().getTable().getShell(), SWT.SAVE);
 180 //              d.open();
 181 //              String filename = d.getFileName();
 182 //              if (!filename.equals(""))
 183 //              {
 184 //                      save(d.getFilterPath() + File.separator + filename);
 185 //                      setDirty(false);
 186 //              }
 187 //      }
 188
 189         @Override
 190         public void init(IEditorSite site, IEditorInput input) throws PartInitException
 191         {
 192                 setSite(site);
 193                 setInput(input);
 194                 try
 195                 {
 196                         if (input instanceof IFileEditorInput)
 197                         {
 198                                 IFileEditorInput fileInput = (IFileEditorInput) input;
 199                                 context = ProjectMachineContext.getMachineContextOf(fileInput.getFile().getProject());
 200                                 context.activateMachine();
 201                                 setPartName(fileInput.getName());
 202                                 open(fileInput.getFile());
 203                         }
 204                 }
 205                 catch (Exception e)
 206                 {
 207                         throw new PartInitException("Failed to read input!", e);
 208                 }
 209
 210         }
 211
 212         @Override
 213         public boolean isDirty()
 214         {
 215                 return dirty;
 216         }
 217
 218         @Override
 219         public boolean isSaveAsAllowed()
 220         {
 221                 return false;
 222         }
 223
 224         private void setDirty(boolean value)
 225         {
 226                 dirty = value;
 227                 firePropertyChange(PROP_DIRTY);
 228         }
 229
 230         @Override
 231         public void dispose()
 232         {
 233                 memory.deregisterCellModifiedListener(cellModifiedListener);
 234                 context.getActiveMachine().ifPresent(m ->
 235                 {
 236                         m.removeActiveMicroInstructionChangedListener(instChangeListener);
 237                         m.getMicroInstructionMemory().deregisterMemoryReassignedListener(reassignedListener);
 238                 });
 239                 context.removeActiveMachineListener(activeMachineListener);
 240                 super.dispose();
 241         }
 242 }