net.mograsim.logic.ui/src/net/mograsim/logic/ui/model/components/SubmodelComponent.java

   1 package net.mograsim.logic.ui.model.components;
   2
   3 import java.util.Collections;
   4 import java.util.HashMap;
   5 import java.util.Iterator;
   6 import java.util.List;
   7 import java.util.Map;
   8 import java.util.Map.Entry;
   9
  10 import net.haspamelodica.swt.helper.gcs.GCConfig;
  11 import net.haspamelodica.swt.helper.gcs.GeneralGC;
  12 import net.haspamelodica.swt.helper.gcs.TranslatedGC;
  13 import net.haspamelodica.swt.helper.swtobjectwrappers.Point;
  14 import net.haspamelodica.swt.helper.swtobjectwrappers.Rectangle;
  15 import net.mograsim.logic.ui.LogicUIRenderer;
  16 import net.mograsim.logic.ui.model.ViewModel;
  17 import net.mograsim.logic.ui.model.ViewModelModifiable;
  18 import net.mograsim.logic.ui.model.components.SubmodelComponentParams.ComponentCompositionParams;
  19 import net.mograsim.logic.ui.model.components.SubmodelComponentParams.ComponentCompositionParams.InnerComponentParams;
  20 import net.mograsim.logic.ui.model.components.SubmodelComponentParams.InnerPinParams;
  21 import net.mograsim.logic.ui.model.components.SubmodelComponentParams.InnerWireParams;
  22 import net.mograsim.logic.ui.model.components.SubmodelComponentParams.InterfacePinParams;
  23 import net.mograsim.logic.ui.model.wires.GUIWire;
  24 import net.mograsim.logic.ui.model.wires.MovablePin;
  25 import net.mograsim.logic.ui.model.wires.Pin;
  26
  27 public abstract class SubmodelComponent extends GUIComponent
  28 {
  29         protected final ViewModelModifiable submodelModifiable;
  30         public final ViewModel submodel;
  31         private final Map<MovablePin, MovablePin> submodelPinsPerSupermodelPin;
  32         private final Map<Pin, Pin> submodelPinsPerSupermodelPinUnmodifiable;
  33         private final Map<MovablePin, MovablePin> supermodelPinsPerSubmodelPin;
  34         private final Map<Pin, Pin> supermodelPinsPerSubmodelPinUnmodifiable;
  35         private final SubmodelInterface submodelInterface;
  36
  37         private double submodelScale;
  38         private double maxVisibleRegionFillRatioForAlpha0;
  39         private double minVisibleRegionFillRatioForAlpha1;
  40         private final LogicUIRenderer renderer;
  41
  42         public SubmodelComponent(ViewModelModifiable model)
  43         {
  44                 super(model);
  45                 this.submodelModifiable = new ViewModelModifiable();
  46                 this.submodel = submodelModifiable;
  47                 this.submodelPinsPerSupermodelPin = new HashMap<>();
  48                 this.submodelPinsPerSupermodelPinUnmodifiable = Collections.unmodifiableMap(submodelPinsPerSupermodelPin);
  49                 this.supermodelPinsPerSubmodelPin = new HashMap<>();
  50                 this.supermodelPinsPerSubmodelPinUnmodifiable = Collections.unmodifiableMap(supermodelPinsPerSubmodelPin);
  51                 this.submodelInterface = new SubmodelInterface(submodelModifiable);
  52
  53                 this.submodelScale = 1;
  54                 this.maxVisibleRegionFillRatioForAlpha0 = 0.4;
  55                 this.minVisibleRegionFillRatioForAlpha1 = 0.8;
  56                 this.renderer = new LogicUIRenderer(submodelModifiable);
  57
  58                 submodelModifiable.addRedrawListener(this::requestRedraw);
  59         }
  60
  61         protected void setSubmodelScale(double submodelScale)
  62         {
  63                 this.submodelScale = submodelScale;
  64
  65                 for (Entry<MovablePin, MovablePin> e : supermodelPinsPerSubmodelPin.entrySet())
  66                         e.getKey().setRelPos(e.getValue().getRelX() * submodelScale, e.getValue().getRelY() * submodelScale);
  67
  68                 requestRedraw();// needed if there is no submodel interface pin
  69         }
  70
  71         protected double getSubmodelScale()
  72         {
  73                 return submodelScale;
  74         }
  75
  76         /**
  77          * Returns the submodel pin.
  78          */
  79         protected Pin addSubmodelInterface(String name, int logicWidth, double relX, double relY)
  80         {
  81                 MovablePin submodelPin = new MovablePin(submodelInterface, name, logicWidth, relX / submodelScale, relY / submodelScale);
  82                 submodelInterface.addPin(submodelPin);
  83
  84                 MovablePin supermodelPin = new MovablePin(this, name, logicWidth, relX, relY);
  85                 addPin(supermodelPin);
  86
  87                 submodelPinsPerSupermodelPin.put(supermodelPin, submodelPin);
  88                 supermodelPinsPerSubmodelPin.put(submodelPin, supermodelPin);
  89
  90                 // no need to call requestRedraw() because addPin() will request a redraw
  91                 return submodelPin;
  92         }
  93
  94         protected void moveSubmodelInterface(Pin supermodelPin, double relX, double relY)
  95         {
  96                 MovablePin submodelPin = getSubmodelMovablePin(supermodelPin);
  97                 MovablePin supermodelPinMovable = getSupermodelMovablePin(submodelPin);
  98
  99                 submodelPin.setRelPos(relX / submodelScale, relY / submodelScale);
 100                 supermodelPinMovable.setRelPos(relX, relY);
 101
 102                 // no need to call requestRedraw() because setRelPos() will request a redraw
 103         }
 104
 105         protected void removeSubmodelInterface(Pin supermodelPin)
 106         {
 107                 removePin(supermodelPin);
 108                 Pin submodelPin = getSubmodelMovablePin(supermodelPin);
 109                 submodelInterface.removePin(submodelPin);
 110
 111                 submodelPinsPerSupermodelPin.remove(supermodelPin);
 112                 supermodelPinsPerSubmodelPin.remove(submodelPin);
 113
 114                 // no need to call requestRedraw() because removePin() will request a redraw
 115         }
 116
 117         public Map<Pin, Pin> getSupermodelPinsPerSubmodelPin()
 118         {
 119                 return supermodelPinsPerSubmodelPinUnmodifiable;
 120         }
 121
 122         public Pin getSupermodelPin(Pin submodelPin)
 123         {
 124                 return getSupermodelMovablePin(submodelPin);
 125         }
 126
 127         protected MovablePin getSupermodelMovablePin(Pin submodelPin)
 128         {
 129                 return supermodelPinsPerSubmodelPin.get(submodelPin);
 130         }
 131
 132         public Map<Pin, Pin> getSubmodelPinsPerSupermodelPin()
 133         {
 134                 return submodelPinsPerSupermodelPinUnmodifiable;
 135         }
 136
 137         public Pin getSubmodelPin(Pin supermodelPin)
 138         {
 139                 return getSubmodelMovablePin(supermodelPin);
 140         }
 141
 142         protected MovablePin getSubmodelMovablePin(Pin supermodelPin)
 143         {
 144                 return submodelPinsPerSupermodelPin.get(supermodelPin);
 145         }
 146
 147         @Override
 148         public void render(GeneralGC gc, Rectangle visibleRegion)
 149         {
 150                 double posX = getBounds().x;
 151                 double posY = getBounds().y;
 152
 153                 GCConfig conf = new GCConfig(gc);
 154                 TranslatedGC tgc = new TranslatedGC(gc, posX, posY, submodelScale, true);
 155                 conf.reset(tgc);
 156                 double visibleRegionFillRatio = Math.max(getBounds().width / visibleRegion.width, getBounds().height / visibleRegion.height);
 157                 double alphaFactor = map(visibleRegionFillRatio, maxVisibleRegionFillRatioForAlpha0, minVisibleRegionFillRatioForAlpha1, 0, 1);
 158                 alphaFactor = Math.max(0, Math.min(1, alphaFactor));
 159                 // we need to take the old alpha into account to support nested submodules better.
 160                 int oldAlpha = gc.getAlpha();
 161                 int submodelAlpha = Math.max(0, Math.min(255, (int) (oldAlpha * alphaFactor)));
 162                 int labelAlpha = Math.max(0, Math.min(255, (int) (oldAlpha * (1 - alphaFactor))));
 163                 if (submodelAlpha != 0)
 164                 {
 165                         gc.setAlpha(submodelAlpha);
 166                         renderer.render(tgc, visibleRegion.translate(posX / submodelScale, posY / submodelScale, 1 / submodelScale));
 167                 }
 168                 if (labelAlpha != 0)
 169                 {
 170                         gc.setAlpha(labelAlpha);
 171                         renderSymbol(gc, visibleRegion);
 172                 }
 173                 conf.reset(gc);
 174                 // draw the outline after all other operations to make interface pins look better
 175                 renderOutline(gc, visibleRegion);
 176         }
 177
 178         protected abstract void renderOutline(GeneralGC gc, Rectangle visibleRegion);
 179
 180         protected abstract void renderSymbol(GeneralGC gc, Rectangle visibleRegion);
 181
 182         private static double map(double val, double valMin, double valMax, double mapMin, double mapMax)
 183         {
 184                 return mapMin + (val - valMin) * (mapMax - mapMin) / (valMax - valMin);
 185         }
 186
 187         @Override
 188         public boolean clicked(double x, double y)
 189         {
 190                 // TODO
 191                 double scaledX = (x - getBounds().x) / submodelScale;
 192                 double scaledY = (y - getBounds().y) / submodelScale;
 193                 double roundedScaledX = Math.round(scaledX / 5 * 2) * 5 / 2.;
 194                 double roundedScaledY = Math.round(scaledY / 5 * 2) * 5 / 2.;
 195                 System.out.println(scaledX + "|" + scaledY + ", rounded " + roundedScaledX + "|" + roundedScaledY);
 196                 return true;
 197         }
 198
 199         /**
 200          * @return {@link SubmodelComponentParams}, which describe this {@link SubmodelComponent}.
 201          */
 202         public SubmodelComponentParams calculateParams()
 203         {
 204                 SubmodelComponentParams params = new SubmodelComponentParams();
 205                 params.type = SubmodelComponent.class.getSimpleName();
 206                 params.composition = calculateCompositionParams();
 207
 208                 Rectangle bounds = getBounds();
 209                 params.width = bounds.width;
 210                 params.height = bounds.height;
 211
 212                 List<Pin> pinList = pinsUnmodifiable;
 213                 InterfacePinParams[] iPins = new InterfacePinParams[pinList.size()];
 214                 int i = 0;
 215                 for (Pin p : pinList)
 216                 {
 217                         InterfacePinParams iPinParams = new InterfacePinParams();
 218                         iPins[i] = iPinParams;
 219                         iPinParams.location = p.getRelPos();
 220                         iPinParams.name = p.name;
 221                         iPinParams.logicWidth = p.logicWidth;
 222                         i++;
 223                 }
 224                 params.interfacePins = iPins;
 225                 return params;
 226         }
 227
 228         protected ComponentCompositionParams calculateCompositionParams()
 229         {
 230                 ComponentCompositionParams params = new ComponentCompositionParams();
 231                 params.innerScale = getSubmodelScale();
 232
 233                 List<GUIComponent> compList = submodelModifiable.getComponents();
 234                 Iterator<GUIComponent> componentIt = compList.iterator();
 235                 componentIt.next(); // Skip inner SubmodelInterface
 236                 InnerComponentParams[] comps = new InnerComponentParams[compList.size() - 1];
 237                 int i = 0;
 238                 while (componentIt.hasNext())
 239                 {
 240                         GUIComponent component = componentIt.next();
 241                         InnerComponentParams inner = new InnerComponentParams();
 242                         comps[i] = inner;
 243                         inner.logicWidth = component.getPins().get(0).logicWidth; // This could be done a little more elegantly
 244                         Rectangle bounds = component.getBounds();
 245                         inner.pos = new Point(bounds.x, bounds.y);
 246                         inner.type = component.getIdentifier();
 247                         i++;
 248                 }
 249                 params.subComps = comps;
 250
 251                 List<GUIWire> wireList = submodelModifiable.getWires();
 252                 InnerWireParams wires[] = new InnerWireParams[wireList.size()];
 253                 i = 0;
 254                 for (GUIWire wire : wireList)
 255                 {
 256                         InnerWireParams inner = new InnerWireParams();
 257                         wires[i] = inner;
 258                         InnerPinParams pin1Params = new InnerPinParams(), pin2Params = new InnerPinParams();
 259
 260                         pin1Params.pinIndex = wire.getPin1().component.getPins().indexOf(wire.getPin1());
 261                         pin1Params.compId = compList.indexOf(wire.getPin1().component);
 262                         pin2Params.pinIndex = wire.getPin2().component.getPins().indexOf(wire.getPin2());
 263                         pin2Params.compId = compList.indexOf(wire.getPin2().component);
 264                         inner.pin1 = pin1Params;
 265                         inner.pin2 = pin2Params;
 266                         inner.path = wire.getPath();
 267                         i++;
 268                 }
 269                 params.innerWires = wires;
 270                 return params;
 271         }
 272 }