import org.simantics.db.Resource;
import org.simantics.db.WriteGraph;
import org.simantics.db.common.procedure.adapter.AsyncProcedureAdapter;
+import org.simantics.db.common.request.ResourceRead;
import org.simantics.db.exception.CancelTransactionException;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.exception.ServiceException;
+import org.simantics.db.layer0.util.RemoverUtil;
import org.simantics.db.procedure.AsyncProcedure;
+import org.simantics.db.procedure.Listener;
import org.simantics.diagram.stubs.DiagramResource;
import org.simantics.diagram.synchronization.IModificationQueue;
import org.simantics.diagram.synchronization.ModificationAdapter;
import org.simantics.g2d.diagram.IDiagram;
import org.simantics.g2d.element.ElementHints;
import org.simantics.g2d.element.IElement;
-import org.simantics.g2d.element.handler.ElementLayers;
import org.simantics.g2d.layers.IEditableLayer;
import org.simantics.g2d.layers.IEditableLayer.ILayerListener;
import org.simantics.g2d.layers.IEditableLayer.LayerChangeEvent;
import org.simantics.g2d.layers.ILayers;
import org.simantics.g2d.layers.ILayersEditor;
import org.simantics.g2d.layers.ILayersEditor.ILayersEditorListener;
-import org.simantics.g2d.layers.SimpleLayer;
import org.simantics.g2d.layers.SimpleLayers;
import org.simantics.layer0.Layer0;
*/
LayerListener layerListener = new LayerListener();
+ boolean disposed = false;
+
public GraphLayerManager(ReadGraph graph, IModificationQueue modificationQueue, Resource diagram) {
this.modificationQueue = modificationQueue;
this.diagram = diagram;
}
}
layers.clear();
+ disposed = true;
}
Resource getDiagramResource() {
@Override
public void perform(WriteGraph g) throws Exception {
String newName = layer.getName();
- for (Resource l : g.getObjects(diagram, dia.HasLayer)) {
- String name = g.getRelatedValue(l, l0.HasName);
+ for (Resource layer : g.getObjects(diagram, dia.HasLayer)) {
+ String name = g.getRelatedValue(layer, l0.HasName);
if (newName.equals(name)) {
return;
}
}
- GraphLayer l = new GraphLayerUtil(g).createLayer(newName, false);
- g.claim(diagram, dia.HasLayer, l.getLayer());
- layers.put(newName, l);
+
+ IGraphLayerUtil util = g.adapt(DiagramResource.getInstance(g).Layer, IGraphLayerUtil.class);
+ GraphLayer layer = util.createLayer(g, newName, false);
+ g.claim(diagram, dia.HasLayer, layer.getLayer());
+ layers.put(newName, layer);
}
}
if (removedName.equals(name)) {
g.denyStatement(diagram, dia.HasLayer, l);
deleteLayer(g, l);
-
- // NOTE: leave the layer tags intact, remove them gradually
- // by checking the validity of all layer tags during element
- // writeback.
layers.remove(name);
return;
}
}
void deleteLayer(WriteGraph g, Resource layer) throws DatabaseException {
- g.deny(layer);
+ RemoverUtil.remove(g, layer);
}
}
}
}
- GraphLayer loadLayer(ReadGraph g, Resource layer) throws DatabaseException {
- String name = g.getRelatedValue(layer, l0.HasName);
- Resource visible = g.getSingleObject(layer, dia.HasVisibleTag);
- Resource focusable = g.getSingleObject(layer, dia.HasFocusableTag);
- return new GraphLayer(name, layer, visible, focusable);
- }
-
public ILayersEditor loadLayers(IDiagram diagram, ReadGraph g, Resource diagramResource) throws DatabaseException {
- SimpleLayers result = new SimpleLayers();
- ConcurrentMap<String, GraphLayer> newLayers = new ConcurrentHashMap<String, GraphLayer>();
-
+
+ layerEditor = new SimpleLayers();
+ layerEditor.addLayerEditorListener(layerListener);
+
String[] fixed = diagram.getHint(DiagramHints.KEY_FIXED_LAYERS);
- if (fixed != null) {
-
-// for (String name : fixed) {
-// SimpleLayer l = new SimpleLayer(name);
-// result.addLayer(l);
-// result.activate(l);
-// }
-
- // We need to put GraphLayer to newLayers so...
- for (Resource layer : g.getObjects(diagramResource, dia.HasLayer)) {
- GraphLayer gl = loadLayer(g, layer);
- for (String name : fixed) {
- if (name.equals(gl.getName())) {
- SimpleLayer l = new SimpleLayer(gl.getName());
- newLayers.put(gl.getName(), gl);
- result.addLayer(l);
- result.activate(l);
- }
+
+ g.syncRequest(new ResourceRead<LayersSpec>(diagramResource) {
+
+ @Override
+ public LayersSpec perform(ReadGraph g) throws DatabaseException {
+ Collection<GraphLayer> gls = new ArrayList<>();
+ for (Resource layer : g.getObjects(resource, dia.HasLayer)) {
+ IGraphLayerUtil layerUtil = g.adapt(g.getSingleObject(layer, Layer0.getInstance(g).InstanceOf), IGraphLayerUtil.class);
+ GraphLayer gl = layerUtil.loadLayer(g, layer);
+ gls.add(gl);
}
+ return new LayersSpec(gls);
}
+
+ }, new Listener<LayersSpec>() {
+
+ @Override
+ public void execute(LayersSpec layersSpec) {
+ ConcurrentMap<String, GraphLayer> newLayers = new ConcurrentHashMap<String, GraphLayer>();
+ Set<ILayer> visibleLayers = new HashSet<>();
+ Set<ILayer> allLayers = new HashSet<>();
+
+ if (fixed != null) {
+ for (GraphLayer gl : layersSpec.getGraphLayers()) {
+ for (String name : fixed) {
+ if (name.equals(gl.getName())) {
+ ILayer l = gl.getILayer();
+ newLayers.put(gl.getName(), gl);
+ allLayers.add(l);
+ visibleLayers.add(l);
+ }
+ }
+ }
+
+ } else {
- } else {
+ if (DEBUG_LAYERS)
+ System.out.println("Loading layers");
- if (DEBUG_LAYERS)
- System.out.println("Loading layers");
+ for (GraphLayer gl : layersSpec.getGraphLayers()) {
+ ILayer l = gl.getILayer();
- for (Resource layer : g.getObjects(diagramResource, dia.HasLayer)) {
- GraphLayer gl = loadLayer(g, layer);
- SimpleLayer l = new SimpleLayer(gl.getName());
+ newLayers.put(gl.getName(), gl);
- newLayers.put(gl.getName(), gl);
- result.addLayer(l);
+ if (DEBUG_LAYERS)
+ System.out.println(" Loaded " + (gl.isActive() ? "active" : "inactive") + " layer '" + gl.getName() + "'");
+
+ if (l instanceof IEditableLayer)
+ ((IEditableLayer) l).addLayerListener(layerListener);
- Boolean active = g.getPossibleRelatedValue(layer, dia.IsActive);
- if (active == null)
- active = Boolean.FALSE;
+ allLayers.add(l);
+ if (gl.isActive())
+ visibleLayers.add(l);
+
+ }
+ }
+ // Show all and focus all by default if there are no layers
+
+
+ if (newLayers.isEmpty()) {
+ layerEditor.setIgnoreVisibilitySettings(true);
+ layerEditor.setIgnoreFocusSettings(true);
+ }
if (DEBUG_LAYERS)
- System.out.println(" Loaded " + (active ? "active" : "inactive") + " layer '" + gl.getName() + "'");
+ System.out.println("Loaded " + newLayers.size() + " layers");
- l.addLayerListener(layerListener);
- if (active)
- result.activate(l);
+ layerEditor.update(allLayers, visibleLayers);
+
+ layers = newLayers;
}
- if (DEBUG_LAYERS)
- System.out.println("Loaded " + newLayers.size() + " layers");
+ @Override
+ public void exception(Throwable t) {
+ t.printStackTrace();
+ }
- }
+ @Override
+ public boolean isDisposed() {
+ return disposed;
+ }
+
+ });
- this.layers = newLayers;
- this.layerEditor = result;
- this.layerEditor.addListener(layerListener);
- return result;
+ return layerEditor;
}
public void loadLayersForElement(ReadGraph graph, ILayersEditor layersEditor, IElement e, Resource element)
* many times depending on how many errors occur during layer loading
* @throws DatabaseException
*/
- public void loadLayersForElement(AsyncReadGraph graph, ILayersEditor layersEditor, final IElement e,
+ public void loadLayersForElement(AsyncReadGraph graph, ILayers layers2, final IElement e,
Resource element, final AsyncProcedure<IElement> callback) {
if (DEBUG_LAYERS)
System.out.println("Loading layers for element " + element + " - " + e);
// NOTE: must not set layer hints into element until the layer sets have
// been properly loaded.
- Set<ILayer> allLayers = layersEditor.getLayers();
+ Set<ILayer> allLayers = layers2.getLayers();
if (allLayers.isEmpty()) {
e.setHint(ElementHints.KEY_VISIBLE_LAYERS, visible);
e.setHint(ElementHints.KEY_FOCUS_LAYERS, focusable);
graph.forHasStatement(element, gl.getVisible(), element, new AsyncProcedureAdapter<Boolean>() {
@Override
public void execute(AsyncReadGraph graph, Boolean result) {
- synchronized (visible) {
- visible.add(l);
+ if (result) {
+ synchronized (visible) {
+ visible.add(l);
+ }
}
if (DEBUG_LAYERS)
System.out.println(" Visible on layer '" + gl.getName() + "'");
graph.forHasStatement(element, gl.getFocusable(), element, new AsyncProcedureAdapter<Boolean>() {
@Override
public void execute(AsyncReadGraph graph, Boolean result) {
- synchronized (focusable) {
- focusable.add(l);
+ if (result) {
+ synchronized (focusable) {
+ focusable.add(l);
+ }
}
if (DEBUG_LAYERS)
System.out.println(" Focusable on layer '" + gl.getName() + "'");
}
}
- void putElementOnVisibleLayers(IDiagram diagram, IElement element) {
- // Make the new element visible and focusable on all currently
- // active layers.
- ILayers diagramLayers = diagram.getHint(DiagramHints.KEY_LAYERS);
- if (diagramLayers != null) {
- element.setHint(ElementHints.KEY_VISIBLE_LAYERS, new HashSet<ILayer>());
- element.setHint(ElementHints.KEY_FOCUS_LAYERS, new HashSet<ILayer>());
- Set<ILayer> visibleLayers = diagramLayers.getVisibleLayers();
-
- if (DEBUG_LAYERS)
- System.out.println("Marking element visible and focusable only on visible layers: " + visibleLayers);
-
- for (ElementLayers elementLayers : element.getElementClass().getItemsByClass(ElementLayers.class)) {
- for (ILayer layer : visibleLayers) {
- elementLayers.setVisibility(element, layer, true);
- elementLayers.setFocusability(element, layer, true);
- }
- }
- }
- }
-
public void putElementOnVisibleLayers(IDiagram diagram, WriteGraph g, Resource element) throws DatabaseException {
// Make the new element visible and focusable on all currently
// active layers.
for (ILayer layer : visibleLayers) {
GraphLayer gl = layers.get(layer.getName());
if (gl != null) {
- DiagramGraphUtil.tag(g, element, gl.getVisible(), true);
- DiagramGraphUtil.tag(g, element, gl.getFocusable(), true);
+ gl.forEachTag(tag -> DiagramGraphUtil.tag(g, element, tag, true));
}
}
}
Code Review / simantics / platform.git / blobdiff