{
private final Mnemonic[] values;
private final String[] stringValues;
- private final Map<String, Mnemonic> byText;
- private final int vectorLength;
+ private Map<String, Mnemonic> byText;
+ private int vectorLength;
+
+ public MnemonicFamily(String... names)
+ {
+ this.values = new Mnemonic[names.length];
+ this.stringValues = new String[names.length];
+ BitVector[] values = new BitVector[names.length];
+ int bits = (int) Math.ceil(Math.log(names.length));
+ for(int i = 0; i < names.length; i++)
+ {
+ values[i] = BitVector.from(i, bits);
+ }
+
+ setup(names, values);
+ }
+
+ public MnemonicFamily(String[] names, long[] values, int bits)
+ {
+ if(names.length != values.length)
+ throw new IllegalArgumentException();
+ this.values = new Mnemonic[values.length];
+ this.stringValues = new String[values.length];
+ BitVector[] vectors = new BitVector[values.length];
+
+ for(int i = 0; i < vectors.length; i++)
+ {
+ vectors[i] = BitVector.from(values[i], bits);
+ }
+
+ setup(names, vectors);
+ }
+
+ public MnemonicFamily(String[] names, BitVector[] values)
+ {
+ if(names.length != values.length)
+ throw new IllegalArgumentException();
+ this.values = new Mnemonic[values.length];
+ this.stringValues = new String[values.length];
+
+ setup(names, values);
+ }
public MnemonicFamily(MnemonicPair... values)
{
this.values = new Mnemonic[values.length];
this.stringValues = new String[values.length];
+ setup(values);
+ }
+
+ private void setup(String[] names, BitVector[] values)
+ {
+ MnemonicPair[] mnemonics = new MnemonicPair[values.length];
+ for(int i = 0; i < values.length; i++)
+ mnemonics[i] = new MnemonicPair(names[i], values[i]);
+ setup(mnemonics);
+ }
+
+ private void setup(MnemonicPair[] values)
+ {
for(int i = 0; i < values.length; i++)
{
this.values[i] = createMnemonic(values[i], i);
if(values.length != byText.keySet().size())
throw new IllegalArgumentException("MnemonicFamily contains multiple Mnemonics with the same name!");
}
-
+
private Mnemonic createMnemonic(MnemonicPair mnemonicPair, int ordinal)
{
return new Mnemonic(mnemonicPair.name, mnemonicPair.value, this, ordinal);
--- /dev/null
+package net.mograsim.plugin.tables;
+
+import org.eclipse.jface.viewers.IContentProvider;
+import org.eclipse.jface.viewers.ILazyContentProvider;
+import org.eclipse.jface.viewers.TableViewer;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Table;
+
+public class LazyTableViewer extends TableViewer
+{
+
+ public LazyTableViewer(Composite parent, int style)
+ {
+ super(parent, style | SWT.VIRTUAL);
+ }
+
+ public LazyTableViewer(Composite parent)
+ {
+ super(parent);
+ }
+
+ public LazyTableViewer(Table table)
+ {
+ super(table);
+ }
+
+ @Override
+ public void setContentProvider(IContentProvider provider)
+ {
+ if (!(provider instanceof ILazyContentProvider))
+ throw new IllegalArgumentException("Content provider must be an ILazyContentProvider");
+ super.setContentProvider(provider);
+ }
+
+ public void refreshLazy()
+ {
+ Table t = getTable();
+ ILazyContentProvider provider = (ILazyContentProvider) getContentProvider();
+ doClearAll();
+ int startIndex = t.getTopIndex();
+ int numRows = t.getBounds().height / t.getItemHeight();
+ int endIndex = startIndex + numRows + 5;
+
+ for (int i = startIndex; i < endIndex; i++)
+ {
+ provider.updateElement(i);
+ }
+ }
+}
import java.math.BigInteger;
import java.util.Optional;
-import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TableViewerColumn;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.VerifyListener;
import net.mograsim.plugin.asm.AsmNumberUtil;
import net.mograsim.plugin.tables.AddressLabelProvider;
import net.mograsim.plugin.tables.DisplaySettings;
+import net.mograsim.plugin.tables.LazyTableViewer;
import net.mograsim.plugin.tables.NumberColumnLabelProvider;
import net.mograsim.plugin.tables.RadixSelector;
public class MemoryView extends ViewPart implements ContextObserver
{
- private TableViewer viewer;
+ private LazyTableViewer viewer;
private MemoryTableContentProvider provider;
private DisplaySettings displaySettings;
createHeader(parent);
createViewer(parent);
- displaySettings.addObserver(() -> viewer.refresh());
+ displaySettings.addObserver(() -> viewer.refreshLazy());
setupContextBinding();
}
private void createViewer(Composite parent)
{
- viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER | SWT.VIRTUAL);
+ viewer = new LazyTableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER | SWT.VIRTUAL);
createColumns();
Table table = viewer.getTable();
table.setHeaderVisible(true);
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.EditingSupport;
-import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TableViewerColumn;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import net.mograsim.plugin.MachineContext.ContextObserver;
import net.mograsim.plugin.tables.AddressLabelProvider;
import net.mograsim.plugin.tables.DisplaySettings;
+import net.mograsim.plugin.tables.LazyTableViewer;
import net.mograsim.plugin.tables.RadixSelector;
import net.mograsim.plugin.util.DropDownMenu;
import net.mograsim.plugin.util.DropDownMenu.DropDownEntry;
public class InstructionView extends ViewPart implements ContextObserver
{
private String saveLoc = null;
- private TableViewer viewer;
+ private LazyTableViewer viewer;
private TableViewerColumn[] columns = new TableViewerColumn[0];
private MicroInstructionDefinition miDef;
private MicroInstructionMemory memory;
new RadixSelector(parent, displaySettings);
parent.setLayout(layout);
- viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER | SWT.VIRTUAL);
+ viewer = new LazyTableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER | SWT.VIRTUAL);
Table table = viewer.getTable();
table.setHeaderVisible(true);
viewerData.horizontalSpan = 3;
viewer.getTable().setLayoutData(viewerData);
- displaySettings.addObserver(() -> viewer.refresh());
+ displaySettings.addObserver(() -> viewer.refreshLazy());
MachineContext.getInstance().registerObserver(this);
}
provider = new IntegerColumnLabelProvider(displaySettings, index);
break;
case MNEMONIC:
- support = new MnemonicEditingSupport(viewer, miDef, index);
+ support = new MnemonicEditingSupport(viewer, miDef, index, this.provider);
provider = new ParameterLabelProvider(index);
break;
default:
{
private IntegerClassification classification;
private int index;
- private TableViewer viewer;
private InstructionTableContentProvider provider;
public IntegerEditingSupport(TableViewer viewer, MicroInstructionDefinition miDef, int index, DisplaySettings displaySettings,
super(viewer, displaySettings);
classification = (IntegerClassification) miDef.getParameterClassifications()[index];
this.index = index;
- this.viewer = viewer;
this.provider = provider;
}
{
private final ComboBoxCellEditor editor;
private final MnemonicFamily family;
- private final TableViewer viewer;
private final int index;
+ private InstructionTableContentProvider provider;
- public MnemonicEditingSupport(TableViewer viewer, MicroInstructionDefinition definition, int index)
+ public MnemonicEditingSupport(TableViewer viewer, MicroInstructionDefinition definition, int index,
+ InstructionTableContentProvider provider)
{
super(viewer);
- this.viewer = viewer;
family = (MnemonicFamily) definition.getParameterClassifications()[index];
editor = new ComboBoxCellEditor(viewer.getTable(), family.getStringValues(), SWT.READ_ONLY);
this.index = index;
editor.setValidator(new MnemonicCellEditorValidator(family));
+ this.provider = provider;
}
@Override
@Override
protected void setValue(Object element, Object value)
{
- ((InstructionTableRow) element).data.setParameter(index, family.get((Integer) value));
- viewer.update(element, null);
+ InstructionTableRow row = ((InstructionTableRow) element);
+ row.data.setParameter(index, family.get((Integer) value));
+ provider.update(row.address);
}
}