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

   1 package net.mograsim.logic.model.model.components.submodels;
   2
   3 import java.util.Collections;
   4 import java.util.HashMap;
   5 import java.util.Map;
   6 import java.util.Map.Entry;
   7 import java.util.function.Consumer;
   8
   9 import net.haspamelodica.swt.helper.gcs.GCConfig;
  10 import net.haspamelodica.swt.helper.gcs.GeneralGC;
  11 import net.haspamelodica.swt.helper.gcs.TranslatedGC;
  12 import net.haspamelodica.swt.helper.swtobjectwrappers.Rectangle;
  13 import net.mograsim.logic.model.LogicUIRenderer;
  14 import net.mograsim.logic.model.model.ViewModel;
  15 import net.mograsim.logic.model.model.ViewModelModifiable;
  16 import net.mograsim.logic.model.model.components.GUIComponent;
  17 import net.mograsim.logic.model.model.wires.MovablePin;
  18 import net.mograsim.logic.model.model.wires.Pin;
  19 import net.mograsim.logic.model.model.wires.PinUsage;
  20 import net.mograsim.logic.model.serializing.IdentifyParams;
  21 import net.mograsim.logic.model.serializing.IndirectGUIComponentCreator;
  22 import net.mograsim.logic.model.serializing.SubmodelComponentParams;
  23 import net.mograsim.logic.model.serializing.SubmodelComponentSerializer;
  24 import net.mograsim.logic.model.snippets.Renderer;
  25 import net.mograsim.logic.model.util.JsonHandler;
  26 import net.mograsim.preferences.Preferences;
  27
  28 /**
  29  * A {@link GUIComponent} consisting of another model. A <code>SubmodelComponent</code> can have so-called "interface pins" connecting the
  30  * inner and outer models.
  31  */
  32 public abstract class SubmodelComponent extends GUIComponent
  33 {
  34         public static final String SUBMODEL_INTERFACE_NAME = "_submodelinterface";
  35         /**
  36          * A modifiable view of {@link #submodel}.
  37          */
  38         protected final ViewModelModifiable submodelModifiable;
  39         /**
  40          * The model this {@link SubmodelComponent} consists of.
  41          */
  42         public final ViewModel submodel;
  43         /**
  44          * The list of all submodel interface pins of this {@link SubmodelComponent} on the submodel side.
  45          */
  46         private final Map<String, MovablePin> submodelPins;
  47         /**
  48          * An unmodifiable view of {@link #submodelPins}.
  49          */
  50         private final Map<String, MovablePin> submodelMovablePinsUnmodifiable;
  51         /**
  52          * An unmodifiable view of {@link #submodelPins} where pins are not movable.
  53          */
  54         private final Map<String, Pin> submodelUnmovablePinsUnmodifiable;
  55         /**
  56          * The list of all submodel interface pins of this {@link SubmodelComponent} on the supermodel side.
  57          */
  58         private final Map<String, MovablePin> supermodelPins;
  59         /**
  60          * An unmodifiable view of {@link #supermodelPins}.
  61          */
  62         private final Map<String, MovablePin> supermodelMovablePinsUnmodifiable;
  63         /**
  64          * An unmodifiable view of {@link #supermodelPins} where pins are not movable.
  65          */
  66         private final Map<String, Pin> supermodelUnmovablePinsUnmodifiable;
  67         /**
  68          * A pseudo-component containing all submodel interface pins on the submodel side.
  69          */
  70         private final SubmodelInterface submodelInterface;
  71
  72         /**
  73          * The factor by which the submodel is scaled when rendering.
  74          */
  75         private double submodelScale;
  76         /**
  77          * If this {@link SubmodelComponent} fills at least this amount of the visible region vertically or horizontally, the submodel starts to
  78          * be visible.
  79          */
  80         private double maxVisibleRegionFillRatioForAlpha0;
  81         /**
  82          * If this {@link SubmodelComponent} fills at least this amount of the visible region vertically or horizontally, the submodel is fully
  83          * visible.
  84          */
  85         private double minVisibleRegionFillRatioForAlpha1;
  86         /**
  87          * The renderer used for rendering the submodel.
  88          */
  89         private final LogicUIRenderer renderer;
  90
  91         /**
  92          * The {@link Renderer} used to render the symbol of this SubmodelCoponent.
  93          */
  94         private Renderer symbolRenderer;
  95         /**
  96          * The {@link Renderer} used to render the outline of this SubmodelCoponent.
  97          */
  98         private Renderer outlineRenderer;
  99
 100         // creation and destruction
 101
 102         public SubmodelComponent(ViewModelModifiable model, String name)
 103         {
 104                 super(model, name);
 105                 this.submodelModifiable = new ViewModelModifiable();
 106                 this.submodel = submodelModifiable;
 107                 this.submodelPins = new HashMap<>();
 108                 this.submodelMovablePinsUnmodifiable = Collections.unmodifiableMap(submodelPins);
 109                 this.submodelUnmovablePinsUnmodifiable = Collections.unmodifiableMap(submodelPins);
 110                 this.supermodelPins = new HashMap<>();
 111                 this.supermodelMovablePinsUnmodifiable = Collections.unmodifiableMap(supermodelPins);
 112                 this.supermodelUnmovablePinsUnmodifiable = Collections.unmodifiableMap(supermodelPins);
 113                 this.submodelInterface = new SubmodelInterface(submodelModifiable, SUBMODEL_INTERFACE_NAME);
 114
 115                 this.submodelScale = 1;
 116                 this.maxVisibleRegionFillRatioForAlpha0 = 0.8;
 117                 this.minVisibleRegionFillRatioForAlpha1 = 0.9;
 118                 this.renderer = new LogicUIRenderer(submodelModifiable);
 119
 120                 Consumer<Runnable> redrawHandlerChangedListener = submodelModifiable::setRedrawHandler;
 121                 model.addRedrawHandlerChangedListener(redrawHandlerChangedListener);
 122                 model.addComponentRemovedListener(c ->
 123                 {
 124                         if (c == this)
 125                                 model.removeRedrawHandlerChangedListener(redrawHandlerChangedListener);
 126                 });
 127                 submodelModifiable.setRedrawHandler(model.getRedrawHandler());
 128         }
 129
 130         // pins
 131
 132         /**
 133          * Adds a new submodel interface pin.
 134          *
 135          * @param supermodelPin the submodel interface pin on the supermodel side
 136          *
 137          * @return the submodel interface pin on the submodel side
 138          *
 139          * @author Daniel Kirschten
 140          */
 141         protected Pin addSubmodelInterface(MovablePin supermodelPin)
 142         {
 143                 super.addPin(supermodelPin);// do this first to be fail-fast if the supermodel does not belong to this component
 144
 145                 String name = supermodelPin.name;
 146                 // TODO if we upgrade to Java 12, replace with switch-expression
 147                 PinUsage submodelPinUsage;
 148                 switch (supermodelPin.usage)
 149                 {
 150                 case INPUT:
 151                         submodelPinUsage = PinUsage.OUTPUT;
 152                         break;
 153                 case OUTPUT:
 154                         submodelPinUsage = PinUsage.INPUT;
 155                         break;
 156                 case TRISTATE:
 157                         submodelPinUsage = PinUsage.TRISTATE;
 158                         break;
 159                 default:
 160                         throw new IllegalArgumentException("Unknown enum constant: " + supermodelPin.usage);
 161                 }
 162                 MovablePin submodelPin = new MovablePin(submodelInterface, name, supermodelPin.logicWidth, submodelPinUsage,
 163                                 supermodelPin.getRelX() / submodelScale, supermodelPin.getRelY() / submodelScale);
 164
 165                 submodelPin.addPinMovedListener(p ->
 166                 {
 167                         double newRelX = p.getRelX() * submodelScale;
 168                         double newRelY = p.getRelY() * submodelScale;
 169                         if (supermodelPin.getRelX() != newRelX || supermodelPin.getRelY() != newRelY)
 170                                 supermodelPin.setRelPos(newRelX, newRelY);
 171                 });
 172                 supermodelPin.addPinMovedListener(p ->
 173                 {
 174                         double newRelX = p.getRelX() / submodelScale;
 175                         double newRelY = p.getRelY() / submodelScale;
 176                         if (submodelPin.getRelX() != newRelX || submodelPin.getRelY() != newRelY)
 177                                 submodelPin.setRelPos(newRelX, newRelY);
 178                 });
 179
 180                 submodelInterface.addPin(submodelPin);
 181
 182                 submodelPins.put(name, submodelPin);
 183                 supermodelPins.put(name, supermodelPin);
 184
 185                 // no need to call requestRedraw() because addPin() will request a redraw
 186                 return submodelPin;
 187         }
 188
 189         /**
 190          * Removes a submodel interface pin.
 191          *
 192          * @author Daniel Kirschten
 193          */
 194         protected void removeSubmodelInterface(String name)
 195         {
 196                 super.removePin(name);// do this first to be fail-fast if this component doesn't have a pin with the given name
 197                 Pin submodelPin = submodelPins.remove(name);
 198                 submodelInterface.removePin(submodelPin.name);
 199                 supermodelPins.remove(name);
 200
 201                 // no need to call requestRedraw() because removePin() will request a redraw
 202         }
 203
 204         /**
 205          * Returns a collection of submodel interface pins on the submodel side of this component.
 206          *
 207          * @author Daniel Kirschten
 208          */
 209         public Map<String, Pin> getSubmodelPins()
 210         {
 211                 return submodelUnmovablePinsUnmodifiable;
 212         }
 213
 214         /**
 215          * Returns the submodel interface pin with the given name on the submodel side of this component.
 216          *
 217          * @author Daniel Kirschten
 218          */
 219         public Pin getSubmodelPin(String name)
 220         {
 221                 return getSubmodelMovablePin(name);
 222         }
 223
 224         /**
 225          * Returns a collection of movable submodel interface pins on the submodel side of this component.
 226          *
 227          * @author Daniel Kirschten
 228          */
 229         protected Map<String, MovablePin> getSubmodelMovablePins()
 230         {
 231                 return submodelMovablePinsUnmodifiable;
 232         }
 233
 234         /**
 235          * Returns the movable submodel interface pin with the given name on the submodel side of this component.
 236          *
 237          * @author Daniel Kirschten
 238          */
 239         protected MovablePin getSubmodelMovablePin(String name)
 240         {
 241                 return submodelPins.get(name);
 242         }
 243
 244         /**
 245          * Returns a collection of submodel interface pins on the supermodel side of this component.
 246          *
 247          * @author Daniel Kirschten
 248          */
 249         public Map<String, Pin> getSupermodelPins()
 250         {
 251                 return supermodelUnmovablePinsUnmodifiable;
 252         }
 253
 254         /**
 255          * Returns the submodel interface pin with the given name on the supermodel side of this component.
 256          *
 257          * @author Daniel Kirschten
 258          */
 259         public Pin getSupermodelPin(String name)
 260         {
 261                 return getSupermodelMovablePin(name);
 262         }
 263
 264         /**
 265          * Returns a collection of movable submodel interface pins on the supermodel side of this component.
 266          *
 267          * @author Daniel Kirschten
 268          */
 269         protected Map<String, MovablePin> getSupermodelMovablePins()
 270         {
 271                 return supermodelMovablePinsUnmodifiable;
 272         }
 273
 274         /**
 275          * Returns the movable submodel interface pin with the given name on the supermodel side of this component.
 276          *
 277          * @author Daniel Kirschten
 278          */
 279         protected MovablePin getSupermodelMovablePin(String name)
 280         {
 281                 return supermodelPins.get(name);
 282         }
 283
 284         // "graphical" operations
 285
 286         /**
 287          * Sets the factor by which the submodel is scaled when rendering and calls redrawListeners. Note that the submodel interface pins will
 288          * stay at their position relative to the supermodel, which means they will move relative to the submodel.
 289          *
 290          * @author Daniel Kirschten
 291          */
 292         protected void setSubmodelScale(double submodelScale)
 293         {
 294                 this.submodelScale = submodelScale;
 295
 296                 for (Entry<String, MovablePin> e : supermodelPins.entrySet())
 297                         getSubmodelMovablePin(e.getKey()).setRelPos(e.getValue().getRelX() * submodelScale, e.getValue().getRelY() * submodelScale);
 298
 299                 model.requestRedraw();// needed if there is no submodel interface pin
 300         }
 301
 302         /**
 303          * Returns the current factor by which the submodel is scaled when rendering.
 304          *
 305          * @author Daniel Kirschten
 306          */
 307         public double getSubmodelScale()
 308         {
 309                 return submodelScale;
 310         }
 311
 312         /**
 313          * @see #renderSymbol(GeneralGC, Rectangle)
 314          *
 315          * @author Daniel Kirschten
 316          */
 317         protected void setSymbolRenderer(Renderer symbolRenderer)
 318         {
 319                 this.symbolRenderer = symbolRenderer;
 320                 model.requestRedraw();
 321         }
 322
 323         /**
 324          * @see #renderSymbol(GeneralGC, Rectangle)
 325          *
 326          * @author Daniel Kirschten
 327          */
 328         public Renderer getSymbolRenderer()
 329         {
 330                 return symbolRenderer;
 331         }
 332
 333         /**
 334          * @see #renderOutline(GeneralGC, Rectangle)
 335          *
 336          * @author Daniel Kirschten
 337          */
 338         protected void setOutlineRenderer(Renderer outlineRenderer)
 339         {
 340                 this.outlineRenderer = outlineRenderer;
 341                 model.requestRedraw();
 342         }
 343
 344         /**
 345          * @see #renderOutline(GeneralGC, Rectangle)
 346          *
 347          * @author Daniel Kirschten
 348          */
 349         public Renderer getOutlineRenderer()
 350         {
 351                 return outlineRenderer;
 352         }
 353
 354         @Override
 355         public boolean clicked(double x, double y)
 356         {
 357                 double scaledX = (x - getPosX()) / submodelScale;
 358                 double scaledY = (y - getPosY()) / submodelScale;
 359                 for (GUIComponent component : submodel.getComponentsByName().values())
 360                         if (component.getBounds().contains(scaledX, scaledY) && component.clicked(scaledX, scaledY))
 361                                 return true;
 362                 return false;
 363         }
 364
 365         @Override
 366         public void render(GeneralGC gc, Rectangle visibleRegion)
 367         {
 368                 GCConfig conf = new GCConfig(gc);
 369                 GeneralGC tgc = new TranslatedGC(gc, getPosX(), getPosY(), submodelScale, true);
 370                 conf.reset(tgc);
 371                 double visibleRegionFillRatio = Math.max(getWidth() / visibleRegion.width, getHeight() / visibleRegion.height);
 372                 double alphaFactor = map(visibleRegionFillRatio, maxVisibleRegionFillRatioForAlpha0, minVisibleRegionFillRatioForAlpha1, 0, 1);
 373                 alphaFactor = Math.max(0, Math.min(1, alphaFactor));
 374                 // we need to take the old alpha into account to support nested submodules better.
 375                 int oldAlpha = gc.getAlpha();
 376                 int submodelAlpha = Math.max(0, Math.min(255, (int) (oldAlpha * alphaFactor)));
 377                 int labelAlpha = Math.max(0, Math.min(255, (int) (oldAlpha * (1 - alphaFactor))));
 378                 if (submodelAlpha != 0)
 379                 {
 380                         gc.setAlpha(submodelAlpha);
 381                         renderer.render(tgc, visibleRegion.translate(getPosX() / submodelScale, getPosY() / submodelScale, 1 / submodelScale));
 382                 }
 383                 if (labelAlpha != 0)
 384                 {
 385                         gc.setAlpha(labelAlpha);
 386                         renderSymbol(gc, visibleRegion);
 387                 }
 388                 conf.reset(gc);
 389                 // reset line width explicitly to avoid rounding errors causing weird glitches
 390                 gc.setLineWidth(Preferences.current().getDouble("net.mograsim.logic.model.linewidth.default"));
 391                 // draw the outline after all other operations to make interface pins look better
 392                 renderOutline(gc, visibleRegion);
 393         }
 394
 395         /**
 396          * Render the symbol of this {@link SubmodelComponent}, e.g. the things that should be hidden if the submodel is drawn.
 397          *
 398          * @author Daniel Kirschten
 399          */
 400         protected void renderSymbol(GeneralGC gc, Rectangle visibleRegion)
 401         {
 402                 if (symbolRenderer != null)
 403                         symbolRenderer.render(gc, visibleRegion);
 404         }
 405
 406         /**
 407          * Render the outline of this {@link SubmodelComponent}, e.g. the graphical elements that should stay visible if the submodel is drawn.
 408          *
 409          * @author Daniel Kirschten
 410          */
 411         protected void renderOutline(GeneralGC gc, Rectangle visibleRegion)
 412         {
 413                 if (outlineRenderer != null)
 414                         outlineRenderer.render(gc, visibleRegion);
 415         }
 416
 417         private static double map(double val, double valMin, double valMax, double mapMin, double mapMax)
 418         {
 419                 return mapMin + (val - valMin) * (mapMax - mapMin) / (valMax - valMin);
 420         }
 421
 422         // serializing
 423
 424         @Override
 425         public String getIDForSerializing(IdentifyParams idParams)
 426         {
 427                 return "submodel";// TODO what ID?
 428         }
 429
 430         @Override
 431         public SubmodelComponentParams getParamsForSerializing(IdentifyParams idParams)
 432         {
 433                 return SubmodelComponentSerializer.serialize(this, idParams);
 434         }
 435
 436         // operations no longer supported
 437
 438         @Override
 439         protected void addPin(Pin pin)
 440         {
 441                 throw new UnsupportedOperationException("Can't add pins to a SubmodelComponent directly, call addSubmodelInterface instead");
 442         }
 443
 444         @Override
 445         protected void removePin(String name)
 446         {
 447                 throw new UnsupportedOperationException("Can't remove pins of a SubmodelComponent directly, call removeSubmodelInterface instead");
 448         }
 449
 450         static
 451         {
 452                 IndirectGUIComponentCreator.setComponentSupplier(SubmodelComponent.class.getCanonicalName(),
 453                                 (m, p, n) -> SubmodelComponentSerializer.deserialize(m, JsonHandler.fromJsonTree(p, SubmodelComponentParams.class), n));
 454         }
 455 }