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