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.params.GeneralComponentParams;
  19 import net.mograsim.logic.ui.model.components.params.SubComponentParams;
  20 import net.mograsim.logic.ui.model.components.params.RectComponentParams.InnerComponentParams;
  21 import net.mograsim.logic.ui.model.components.params.RectComponentParams.InnerPinParams;
  22 import net.mograsim.logic.ui.model.components.params.RectComponentParams.InnerWireParams;
  23 import net.mograsim.logic.ui.model.components.params.SubComponentParams.InterfacePinParams;
  24 import net.mograsim.logic.ui.model.wires.GUIWire;
  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<PinMovable, PinMovable> submodelPinsPerSupermodelPin;
  32         private final Map<Pin, Pin> submodelPinsPerSupermodelPinUnmodifiable;
  33         private final Map<PinMovable, PinMovable> 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<PinMovable, PinMovable> 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(int logicWidth, double relX, double relY)
  80         {
  81                 PinMovable submodelPin = new PinMovable(submodelInterface, logicWidth, relX / submodelScale, relY / submodelScale);
  82                 submodelInterface.addPin(submodelPin);
  83
  84                 PinMovable supermodelPin = new PinMovable(this, 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                 PinMovable submodelPin = getSubmodelMovablePin(supermodelPin);
  97                 PinMovable 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 PinMovable 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 PinMovable 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         private static class PinMovable extends Pin
 200         {
 201                 public PinMovable(GUIComponent component, int logicWidth, double relX, double relY)
 202                 {
 203                         super(component, logicWidth, relX, relY);
 204                 }
 205
 206                 @Override
 207                 protected void setRelPos(double relX, double relY)
 208                 {
 209                         super.setRelPos(relX, relY);
 210                 }
 211         }
 212
 213         public SubComponentParams calculateParams()
 214         {
 215                 SubComponentParams params = new SubComponentParams();
 216                 params.composition = calculateCompositionParams();
 217
 218                 Rectangle bounds = getBounds();
 219                 params.width = bounds.width;
 220                 params.height = bounds.height;
 221
 222                 List<Pin> pinList = pinsUnmodifiable;
 223                 InterfacePinParams[] iPins = new InterfacePinParams[pinList.size()];
 224                 int i = 0;
 225                 for (Pin p : pinList)
 226                 {
 227                         InterfacePinParams iPinParams = new InterfacePinParams();
 228                         iPins[i] = iPinParams;
 229                         iPinParams.location = p.getRelPos();
 230                         iPinParams.logicWidth = p.logicWidth;
 231                         i++;
 232                 }
 233                 params.interfacePins = iPins;
 234                 return params;
 235         }
 236
 237         protected GeneralComponentParams calculateCompositionParams()
 238         {
 239                 GeneralComponentParams params = new GeneralComponentParams();
 240                 params.innerScale = getSubmodelScale();
 241
 242                 List<GUIComponent> compList = submodelModifiable.getComponents();
 243                 Iterator<GUIComponent> componentIt = compList.iterator();
 244                 componentIt.next(); // Skip inner SubmodelInterface
 245                 InnerComponentParams[] comps = new InnerComponentParams[compList.size() - 1];
 246                 int i = 0;
 247                 while (componentIt.hasNext())
 248                 {
 249                         GUIComponent component = componentIt.next();
 250                         InnerComponentParams inner = new InnerComponentParams();
 251                         comps[i] = inner;
 252                         inner.logicWidth = component.getPins().get(0).logicWidth; // This could be done a little more elegantly
 253                         Rectangle bounds = component.getBounds();
 254                         inner.pos = new Point(bounds.x, bounds.y);
 255                         inner.type = component.getIdentifier();
 256                         i++;
 257                 }
 258                 params.subComps = comps;
 259
 260                 List<GUIWire> wireList = submodelModifiable.getWires();
 261                 InnerWireParams wires[] = new InnerWireParams[wireList.size()];
 262                 i = 0;
 263                 for (GUIWire wire : wireList)
 264                 {
 265                         InnerWireParams inner = new InnerWireParams();
 266                         wires[i] = inner;
 267                         InnerPinParams pin1Params = new InnerPinParams(), pin2Params = new InnerPinParams();
 268
 269                         pin1Params.pinIndex = wire.getPin1().component.getPins().indexOf(wire.getPin1());
 270                         pin1Params.compId = compList.indexOf(wire.getPin1().component);
 271                         pin2Params.pinIndex = wire.getPin2().component.getPins().indexOf(wire.getPin2());
 272                         pin2Params.compId = compList.indexOf(wire.getPin2().component);
 273                         inner.pin1 = pin1Params;
 274                         inner.pin2 = pin2Params;
 275                         inner.path = wire.getPath();
 276                         i++;
 277                 }
 278                 params.innerWires = wires;
 279                 return params;
 280         }
 281 }