import org.simantics.g2d.element.handler.Children;
import org.simantics.g2d.element.handler.Children.ChildEvent;
import org.simantics.g2d.element.handler.Children.ChildListener;
+import org.simantics.g2d.element.handler.ElementLayers;
import org.simantics.g2d.element.handler.FillColor;
import org.simantics.g2d.element.handler.Outline;
import org.simantics.g2d.element.handler.OutlineColorSpec;
import org.simantics.g2d.element.handler.StrokeSpec;
import org.simantics.g2d.element.handler.TerminalTopology;
import org.simantics.g2d.element.handler.Transform;
-import org.simantics.g2d.layers.ILayer;
+import org.simantics.g2d.layers.ILayers;
+import org.simantics.g2d.layers.ILayers.ILayersListener;
import org.simantics.g2d.layers.ILayersEditor;
-import org.simantics.g2d.layers.ILayersEditor.ILayersEditorListener;
import org.simantics.g2d.participant.TransformUtil;
import org.simantics.g2d.scenegraph.SceneGraphConstants;
import org.simantics.g2d.utils.ElementNodeBridge;
import org.simantics.scenegraph.g2d.G2DParentNode;
import org.simantics.scenegraph.g2d.G2DSceneGraph;
import org.simantics.scenegraph.g2d.IG2DNode;
+import org.simantics.scenegraph.g2d.color.ColorFilter;
import org.simantics.scenegraph.g2d.nodes.ConnectionNode;
import org.simantics.scenegraph.g2d.nodes.DataNode;
import org.simantics.scenegraph.g2d.nodes.LinkNode;
oldValue.removeKeyHintListener(Hints.KEY_DIRTY, diagramHintListener);
oldValue.removeKeyHintListener(Hints.KEY_DISABLE_PAINTING, diagramHintListener);
- ILayersEditor layers = oldValue.getHint(DiagramHints.KEY_LAYERS_EDITOR);
+ ILayers layers = oldValue.getHint(DiagramHints.KEY_LAYERS);
if (layers != null) {
- layers.removeListener(layersListener);
+ layers.removeLayersListener(layersListener);
}
for (TransactionContext tc : oldValue.getDiagramClass().getItemsByClass(TransactionContext.class)) {
newValue.addKeyHintListener(Hints.KEY_DISABLE_PAINTING, diagramHintListener);
newValue.addKeyHintListener(Hints.KEY_DIRTY, diagramHintListener);
- ILayersEditor layers = newValue.getHint(DiagramHints.KEY_LAYERS_EDITOR);
+ ILayers layers = newValue.getHint(DiagramHints.KEY_LAYERS);
if (layers != null) {
- layers.addListener(layersListener);
+ layers.addLayersListener(layersListener);
}
for (TransactionContext tc : newValue.getDiagramClass().getItemsByClass(TransactionContext.class)) {
// Layer configuration change listening and reaction logic
// ------------------------------------------------------------------------
- ILayersEditorListener layersListener = new ILayersEditorListener() {
- private void layersChanged() {
+ ILayersListener layersListener = new ILayersListener() {
+ @Override
+ public void changed() {
Object task = BEGIN("EP.layersChanged");
- // Update visibility/focusability for each node only, do not reinitialize the graphics.
+ ICanvasContext ctx = getContext();
+ if(ctx != null) {
+ G2DSceneGraph sg = ctx.getSceneGraph();
+ if(sg != null) {
+ ILayersEditor layers = diagram.getHint(DiagramHints.KEY_LAYERS);
+ sg.setGlobalProperty(G2DSceneGraph.IGNORE_FOCUS, layers.getIgnoreFocusSettings());
+ }
+ }
updateAllVisibility();
END(task);
}
- @Override
- public void layerRemoved(ILayer layer) {
- layersChanged();
- }
- @Override
- public void layerDeactivated(ILayer layer) {
- layersChanged();
- }
- @Override
- public void layerAdded(ILayer layer) {
- layersChanged();
- }
- @Override
- public void layerActivated(ILayer layer) {
- layersChanged();
- }
- @Override
- public void ignoreFocusChanged(boolean value) {
- ICanvasContext ctx = getContext();
- if(ctx == null) return;
- G2DSceneGraph sg = ctx.getSceneGraph();
- if(sg == null) return;
- sg.setGlobalProperty(G2DSceneGraph.IGNORE_FOCUS, value);
- }
- @Override
- public void ignoreVisibilityChanged(boolean value) {
- layersChanged();
- }
};
protected void updateAllVisibility() {
}
} else if (key == ElementHints.KEY_FOCUS_LAYERS || key == ElementHints.KEY_VISIBLE_LAYERS) {
if (sender instanceof IElement) {
- assert getContext().getThreadAccess().currentThreadAccess();
- IElement e = (IElement) sender;
- Object task = BEGIN("layers changed: " + e);
- update(e);
- END(task);
+ getContext().getThreadAccess().asyncExec(new Runnable() {
+
+ @Override
+ public void run() {
+ assert getContext().getThreadAccess().currentThreadAccess();
+ IElement e = (IElement) sender;
+ Object task = BEGIN("layers changed: " + e);
+ update(e);
+ END(task);
+ }
+ });
}
}
}
if (ElementUtils.isHidden(e))
return null;
-// ElementClass ec = e.getElementClass();
-// ILayers layers = diagram.getHint(DiagramHints.KEY_LAYERS);
-// if (layers != null && !layers.getIgnoreVisibilitySettings()) {
-// ElementLayers el = ec.getAtMostOneItemOfClass(ElementLayers.class);
-// if (el != null && !el.isVisible(e, layers)) {
-// return null;
-// }
-// }
// Update the node scene graph through SceneGraph handlers.
List<SceneGraph> nodeHandlers = e.getElementClass().getItemsByClass(SceneGraph.class);
e.setHint(elementSgNodeKey, holder);
}
holder.setComposite(composite);
- holder.setVisible(true);
+ boolean visible = true;
+ ElementClass ec = e.getElementClass();
+ ILayers layers = diagram.getHint(DiagramHints.KEY_LAYERS);
+ if (layers != null && !layers.getIgnoreVisibilitySettings()) {
+ ElementLayers el = ec.getAtMostOneItemOfClass(ElementLayers.class);
+ if (el != null && !el.isVisible(e, layers)) {
+ visible = false;
+ }
+ }
+ holder.setVisible(visible);
+
+ ColorFilter colorFilter = e.getHint(ElementHints.KEY_COLOR_FILTER);
+ holder.setColorFilter(colorFilter);
for (SceneGraph n : nodeHandlers) {
n.init(e, holder);