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

   1 package net.mograsim.plugin.tables.mi;
   2
   3 import static net.mograsim.plugin.preferences.PluginPreferences.MPM_EDITOR_BITS_AS_COLUMN_NAME;
   4
   5 import java.util.Arrays;
   6
   7 import org.eclipse.jface.viewers.ColumnLabelProvider;
   8 import org.eclipse.jface.viewers.ColumnViewerEditor;
   9 import org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent;
  10 import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;
  11 import org.eclipse.jface.viewers.EditingSupport;
  12 import org.eclipse.jface.viewers.FocusCellOwnerDrawHighlighter;
  13 import org.eclipse.jface.viewers.TableViewerColumn;
  14 import org.eclipse.jface.viewers.TableViewerEditor;
  15 import org.eclipse.jface.viewers.TableViewerFocusCellManager;
  16 import org.eclipse.swt.SWT;
  17 import org.eclipse.swt.graphics.Color;
  18 import org.eclipse.swt.graphics.Font;
  19 import org.eclipse.swt.layout.GridData;
  20 import org.eclipse.swt.widgets.Composite;
  21 import org.eclipse.swt.widgets.Display;
  22 import org.eclipse.swt.widgets.Table;
  23 import org.eclipse.swt.widgets.TableColumn;
  24 import org.eclipse.ui.themes.IThemeManager;
  25
  26 import net.mograsim.machine.mi.MicroInstructionDefinition;
  27 import net.mograsim.machine.mi.MicroInstructionMemory;
  28 import net.mograsim.machine.mi.parameters.MnemonicFamily;
  29 import net.mograsim.machine.mi.parameters.ParameterClassification;
  30 import net.mograsim.plugin.MograsimActivator;
  31 import net.mograsim.plugin.tables.AddressLabelProvider;
  32 import net.mograsim.plugin.tables.DisplaySettings;
  33 import net.mograsim.plugin.tables.LazyTableViewer;
  34
  35 public class InstructionTable
  36 {
  37         protected final DisplaySettings displaySettings;
  38         protected final LazyTableViewer viewer;
  39         private TableViewerColumn[] columns = new TableViewerColumn[0];
  40         private MicroInstructionDefinition miDef;
  41         private MicroInstructionMemory memory;
  42         private InstructionTableContentProvider provider;
  43         private final RowHighlighter highlighter;
  44         private final FontAndColorHelper cProv;
  45
  46         private final boolean isEditable;
  47
  48         public InstructionTable(Composite parent, DisplaySettings displaySettings, IThemeManager themeManager)
  49         {
  50                 this(parent, displaySettings, themeManager, true);
  51         }
  52
  53         public InstructionTable(Composite parent, DisplaySettings displaySettings, IThemeManager themeManager, boolean allowEditing)
  54         {
  55                 viewer = new LazyTableViewer(parent, SWT.FULL_SELECTION | SWT.BORDER | SWT.VIRTUAL);
  56                 this.displaySettings = displaySettings;
  57                 this.cProv = new FontAndColorHelper(viewer, themeManager);
  58                 this.highlighter = new RowHighlighter(viewer, cProv);
  59                 this.isEditable = allowEditing;
  60
  61                 Table table = viewer.getTable();
  62                 table.setHeaderVisible(true);
  63                 table.setLinesVisible(true);
  64                 viewer.setUseHashlookup(true);
  65                 table.addDisposeListener(e -> dispose());
  66
  67                 TableViewerFocusCellManager focusCellManager = new TableViewerFocusCellManager(viewer, new FocusCellOwnerDrawHighlighter(viewer));
  68
  69                 ColumnViewerEditorActivationStrategy actSupport = new ColumnViewerEditorActivationStrategy(viewer)
  70                 {
  71                         @Override
  72                         protected boolean isEditorActivationEvent(ColumnViewerEditorActivationEvent event)
  73                         {
  74                                 return event.eventType == ColumnViewerEditorActivationEvent.TRAVERSAL
  75                                                 || event.eventType == ColumnViewerEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION
  76                                                 || (event.eventType == ColumnViewerEditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR)
  77                                                 || event.eventType == ColumnViewerEditorActivationEvent.PROGRAMMATIC;
  78                         }
  79                 };
  80                 int features = ColumnViewerEditor.TABBING_HORIZONTAL | ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR
  81                                 | ColumnViewerEditor.TABBING_VERTICAL | ColumnViewerEditor.KEYBOARD_ACTIVATION;
  82                 TableViewerEditor.create(viewer, focusCellManager, actSupport, features);
  83
  84                 GridData viewerData = new GridData(GridData.GRAB_HORIZONTAL | GridData.GRAB_VERTICAL | GridData.FILL_BOTH);
  85                 viewerData.horizontalSpan = 3;
  86                 viewer.getTable().setLayoutData(viewerData);
  87
  88                 displaySettings.addObserver(() -> viewer.refresh());
  89         }
  90
  91         private void deleteColumns()
  92         {
  93                 for (TableViewerColumn col : columns)
  94                         col.getColumn().dispose();
  95         }
  96
  97         private void createColumns()
  98         {
  99                 viewer.getTable().setVisible(false);
 100
 101                 int size = miDef.size();
 102                 columns = new TableViewerColumn[size + 1];
 103
 104                 TableViewerColumn col = createTableViewerColumn("Address", null);
 105                 columns[0] = col;
 106                 col.setLabelProvider(new AddressLabelProvider()
 107                 {
 108                         @Override
 109                         public Color getBackground(Object element)
 110                         {
 111                                 return cProv.getBackground(element, -1);
 112                         }
 113
 114                         @Override
 115                         public Color getForeground(Object element)
 116                         {
 117                                 return cProv.getForeground(element, -1);
 118                         }
 119
 120                         @Override
 121                         public Font getFont(Object element)
 122                         {
 123                                 return cProv.getFont(element, -1);
 124                         }
 125                 });
 126
 127                 String[] columnTitles = new String[size];
 128
 129                 int bit = miDef.sizeInBits();
 130                 ParameterClassification[] classes = miDef.getParameterClassifications();
 131
 132                 for (int i = 0; i < size; i++)
 133                 {
 134                         int startBit = bit - 1;
 135                         int endBit = bit = bit - classes[i].getExpectedBits();
 136
 137                         String columnTitle;
 138                         String bitString = startBit == endBit ? Integer.toString(startBit) : startBit + "..." + endBit;
 139                         // TODO add a listener
 140                         if (MograsimActivator.instance().getPluginPrefs().getBoolean(MPM_EDITOR_BITS_AS_COLUMN_NAME))
 141                                 columnTitle = bitString;
 142                         else
 143                                 columnTitle = miDef.getParameterTitle(i).orElse(bitString);
 144                         columnTitles[i] = columnTitle;
 145                         String columnTooltip = miDef.getParameterDescription(i).orElse(null);
 146
 147                         col = createTableViewerColumn(columnTitle, columnTooltip);
 148                         columns[i + 1] = col;
 149                         createEditingAndLabel(col, miDef, i);
 150                 }
 151
 152                 calculateOptimalColumnSize(0, "Address", generateLongestHexStrings(12));
 153
 154                 for (int i = 0; i < size; i++)
 155                 {
 156                         String[] longestPossibleContents;
 157                         switch (classes[i].getExpectedType())
 158                         {
 159                         case INTEGER_IMMEDIATE:
 160                                 longestPossibleContents = generateLongestHexStrings(classes[i].getExpectedBits());
 161                                 break;
 162                         case BOOLEAN_IMMEDIATE:
 163                         case MNEMONIC:
 164                                 longestPossibleContents = ((MnemonicFamily) classes[i]).getStringValues();
 165                                 break;
 166                         default:
 167                                 longestPossibleContents = new String[0];
 168                                 break;
 169                         }
 170                         calculateOptimalColumnSize(i + 1, columnTitles[i], longestPossibleContents);
 171                 }
 172
 173                 viewer.getTable().setVisible(true);
 174         }
 175
 176         public void bindMicroInstructionMemory(MicroInstructionMemory memory)
 177         {
 178                 this.memory = memory;
 179                 if (memory != null)
 180                 {
 181                         this.miDef = memory.getDefinition().getMicroInstructionDefinition();
 182                         setViewerInput(memory);
 183                 }
 184         }
 185
 186         private static final String[] HEX_DIGITS = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F" };
 187
 188         private static String[] generateLongestHexStrings(int bitWidth)
 189         {
 190                 return Arrays.stream(HEX_DIGITS).map(s -> "0x" + s.repeat((bitWidth + 3) / 4)).toArray(String[]::new);
 191         }
 192
 193         private void createEditingAndLabel(TableViewerColumn col, MicroInstructionDefinition miDef, int index)
 194         {
 195                 ParameterClassification parameterClassification = miDef.getParameterClassifications()[index];
 196                 EditingSupport support;
 197                 ColumnLabelProvider provider;
 198                 switch (parameterClassification.getExpectedType())
 199                 {
 200                 case BOOLEAN_IMMEDIATE:
 201                         support = isEditable ? new BooleanEditingSupport(viewer, miDef, index) : null;
 202                         provider = new ParameterLabelProvider(cProv, index);
 203                         break;
 204                 case INTEGER_IMMEDIATE:
 205                         support = isEditable ? new IntegerEditingSupport(viewer, miDef, index, displaySettings, this.provider) : null;
 206                         provider = new IntegerColumnLabelProvider(displaySettings, cProv, index);
 207                         break;
 208                 case MNEMONIC:
 209                         support = isEditable ? new MnemonicEditingSupport(viewer, miDef, index, this.provider) : null;
 210                         provider = new ParameterLabelProvider(cProv, index);
 211                         break;
 212                 default:
 213                         throw new IllegalStateException(
 214                                         "Unable to create EditingSupport for unknown ParameterType " + parameterClassification.getExpectedType());
 215                 }
 216                 if (isEditable)
 217                         col.setEditingSupport(support);
 218                 col.setLabelProvider(provider);
 219         }
 220
 221         private TableViewerColumn createTableViewerColumn(String title, String toolTip)
 222         {
 223                 TableViewerColumn viewerColumn = new TableViewerColumn(viewer, SWT.NONE);
 224                 TableColumn column = viewerColumn.getColumn();
 225                 column.setText(title);
 226                 column.setToolTipText(toolTip);
 227                 column.setResizable(true);
 228                 column.setMoveable(false);
 229                 return viewerColumn;
 230         }
 231
 232         private void calculateOptimalColumnSize(int i, String title, String... longestPossibleContents)
 233         {
 234                 TableColumn column = viewer.getTable().getColumn(i);
 235                 int maxWidth = 0;
 236                 for (String s : longestPossibleContents)
 237                 {
 238                         column.setText(s);
 239                         column.pack();
 240                         if (column.getWidth() > maxWidth)
 241                                 maxWidth = column.getWidth();
 242                 }
 243                 column.setText(title);
 244                 column.pack();
 245                 if (column.getWidth() < maxWidth)
 246                         column.setWidth(maxWidth);
 247         }
 248
 249         public LazyTableViewer getTableViewer()
 250         {
 251                 return viewer;
 252         }
 253
 254         public MicroInstructionMemory getMicroInstructionMemory()
 255         {
 256                 return memory;
 257         }
 258
 259         public void setContentProvider(InstructionTableContentProvider provider)
 260         {
 261                 this.provider = provider;
 262                 viewer.setContentProvider(provider);
 263         }
 264
 265         private void setViewerInput(MicroInstructionMemory memory)
 266         {
 267                 deleteColumns();
 268                 viewer.setInput(memory);
 269                 createColumns();
 270         }
 271
 272         public void refresh()
 273         {
 274                 Display.getDefault().asyncExec(() -> viewer.refresh());
 275         }
 276
 277         private void dispose()
 278         {
 279                 cProv.dispose();
 280                 viewer.getTable().dispose();
 281         }
 282
 283         public void highlight(int row)
 284         {
 285                 highlighter.highlight(row);
 286         }
 287 }