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