General SubmodelComponents can now be saved to a json format
[Mograsim.git] / 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 }