/** * Adds a primitive to the collection. Override to ensure primitive is put in Layers Color Map * <p> * It should be noted that this operation will not have an apparent effect for an already rendered (drawn) Container. * In other words, if the Container has already been drawn and a new primitive is added, you'll need to invoke draw() on the * Container. This is done to enhance performance, otherwise, for every add we would have draws impacting performance. */ @Override public void add(IPrimitive<?> child) { super.add(child); child.attachToLayerColorMap(); }
@Override public T copy() { Node<?> node = copyUnchecked(); if (null == node) { return null; } if (getNodeType() != node.getNodeType()) { return null; } return node.cast(); }
/** * Sets the Transform for this Viewport and fires a ZoomEvent * to any ZoomHandlers registered with this Viewport. * * * @param transform Transform * @return this Viewport */ @Override public Viewport setTransform(Transform transform) { super.setTransform(transform); super.fireEvent(new ViewportTransformChangedEvent(this)); return this; }
/** * Moves the {@link Layer} to the top */ @Override public void moveToTop(M node) { getChildNodes().moveToTop(node); }
/** * Removes a primitive from the container. Override to ensure primitive is removed from Layers Color Map * <p> * It should be noted that this operation will not have an apparent effect for an already rendered (drawn) Container. * In other words, if the Container has already been drawn and a new primitive is added, you'll need to invoke draw() on the * Container. This is done to enhance performance, otherwise, for every add we would have draws impacting performance. */ @Override public void remove(IPrimitive<?> child) { child.detachFromLayerColorMap(); super.remove(child); }
/** * Removes all primitives from the collection. Override to ensure all primitives are removed from Layers Color Map * <p> * It should be noted that this operation will not have an apparent effect for an already rendered (drawn) Container. * In other words, if the Container has already been drawn and a new primitive is added, you'll need to invoke draw() on the * Container. This is done to enhance performance, otherwise, for every add we would have draws impacting performance. */ @Override public void removeAll() { detachFromLayerColorMap(); super.removeAll(); }
/** * Enables event handling on this object. * * @param listening * @param Layer */ @Override public Layer setListening(boolean listening) { super.setListening(listening); if (false == listening) { m_select = null; } return this; }
/** * Sets whether this object is visible. * * @param visible * @return Layer */ @Override public Layer setVisible(boolean visible) { super.setVisible(visible); if (null != m_element) { if (false == visible) { m_element.getStyle().setVisibility(Visibility.HIDDEN); } else { m_element.getStyle().setVisibility(Visibility.VISIBLE); } } return this; }
/** * Moves the {@link Layer} to the bottom */ @Override public void moveToBottom(M node) { getChildNodes().moveToBottom(node); }
/** * Removes a primitive from the container. Override to ensure primitive is removed from Layers Color Map * <p> * It should be noted that this operation will not have an apparent effect for an already rendered (drawn) Container. * In other words, if the Container has already been drawn and a new primitive is added, you'll need to invoke draw() on the * Container. This is done to enhance performance, otherwise, for every add we would have draws impacting performance. */ @Override public void remove(IPrimitive<?> child) { child.detachFromLayerColorMap(); super.remove(child); }
/** * Removes all primitives from the collection. Override to ensure all primitives are removed from Layers Color Map * <p> * It should be noted that this operation will not have an apparent effect for an already rendered (drawn) Container. * In other words, if the Container has already been drawn and a new primitive is added, you'll need to invoke draw() on the * Container. This is done to enhance performance, otherwise, for every add we would have draws impacting performance. */ @Override public void removeAll() { FastArrayList<IPrimitive<?>> list = getChildNodes(); if (null != list) { int size = list.length(); for (int i = 0; i < size; i++) { list.get(i).detachFromLayerColorMap(); } } super.removeAll(); }
/** * Moves the {@link Layer} up */ @Override public void moveUp(M node) { getChildNodes().moveUp(node); }
/** * Adds a primitive to the collection. Override to ensure primitive is put in Layers Color Map * <p> * It should be noted that this operation will not have an apparent effect for an already rendered (drawn) Container. * In other words, if the Container has already been drawn and a new primitive is added, you'll need to invoke draw() on the * Container. This is done to enhance performance, otherwise, for every add we would have draws impacting performance. */ @Override public void add(IPrimitive<?> child) { super.add(child); child.attachToLayerColorMap(); }
/** * Removes a {@link Layer} */ @Override public void remove(Layer layer) { if ((null != layer) && (LienzoGlobals.getInstance().isCanvasSupported())) { CanvasElement element = layer.getCanvasElement(); getElement().removeChild(element); super.remove(layer); } }
/** * Removes all {@link Layer} */ @Override public void removeAll() { if (LienzoGlobals.getInstance().isCanvasSupported()) { while (getElement().getChildCount() > 0) { CanvasElement element = getElement().getChild(0).cast(); getElement().removeChild(element); } super.removeAll(); } }
/** * Moves the {@link Layer} down */ @Override public void moveDown(M node) { getChildNodes().moveDown(node); }
/** * Adds a {@link Scene} to this viewport. * * @param scene */ @Override public void add(Scene scene) { if ((null != scene) && (LienzoGlobals.getInstance().isCanvasSupported())) { DivElement element = scene.getElement(); scene.setPixelSize(m_wide, m_high); element.getStyle().setPosition(Position.ABSOLUTE); element.getStyle().setDisplay(Display.INLINE_BLOCK); getElement().appendChild(element); super.add(scene); } }
/** * Adds a {@link Layer} to the Scene. * A draw will be invoked after the layer is added. */ @Override public void add(Layer layer) { if ((null != layer) && (LienzoGlobals.getInstance().isCanvasSupported())) { CanvasElement element = layer.getCanvasElement(); layer.setPixelSize(m_wide, m_high); element.getStyle().setPosition(Position.ABSOLUTE); element.getStyle().setDisplay(Display.INLINE_BLOCK); getElement().appendChild(element); super.add(layer); layer.draw(); } }