-/*******************************************************************************\r
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
- * in Industry THTH ry.\r
- * All rights reserved. This program and the accompanying materials\r
- * are made available under the terms of the Eclipse Public License v1.0\r
- * which accompanies this distribution, and is available at\r
- * http://www.eclipse.org/legal/epl-v10.html\r
- *\r
- * Contributors:\r
- * VTT Technical Research Centre of Finland - initial API and implementation\r
- *******************************************************************************/\r
-package org.simantics.g2d.diagram.impl;\r
-\r
-import java.util.ArrayList;\r
-import java.util.Collections;\r
-import java.util.Comparator;\r
-import java.util.HashSet;\r
-import java.util.List;\r
-import java.util.Map;\r
-import java.util.Set;\r
-\r
-import org.simantics.g2d.diagram.DiagramClass;\r
-import org.simantics.g2d.diagram.IDiagram;\r
-import org.simantics.g2d.diagram.handler.DiagramAdapter;\r
-import org.simantics.g2d.diagram.handler.ElementListener;\r
-import org.simantics.g2d.diagram.handler.LifeCycle;\r
-import org.simantics.g2d.element.IElement;\r
-import org.simantics.utils.datastructures.ListenerList;\r
-import org.simantics.utils.datastructures.hints.IHintContext;\r
-import org.simantics.utils.datastructures.hints.IHintListener;\r
-import org.simantics.utils.threads.IThreadWorkQueue;\r
-\r
-/**\r
- * @author Toni Kalajainen\r
- */\r
-public class AbstractDiagram implements IDiagram {\r
-\r
- ListenerList<CompositionVetoListener> compositionVetoListeners;\r
- ListenerList<CompositionListener> compositionListeners;\r
-\r
- Set<IElement> elements = new HashSet<IElement>();\r
- ArrayList<IElement> list = new ArrayList<IElement>();\r
- List<IElement> unmodifiableList = Collections.unmodifiableList(list);\r
- volatile List<IElement> snapshot = null;\r
- DiagramClass clazz;\r
- IHintContext hintCtx;\r
-\r
- public AbstractDiagram(DiagramClass clazz, IHintContext hintCtx)\r
- {\r
- if (clazz == null)\r
- throw new NullPointerException("null clazz");\r
- this.clazz = clazz;\r
- this.hintCtx = hintCtx;\r
- }\r
-\r
- public void destroy()\r
- {\r
- List<IElement> ss = getElements();\r
-\r
- dispose();\r
-\r
- // Fire destroy elements\r
- for (IElement e : ss)\r
- e.destroy();\r
-\r
- // Fire destroy diagram\r
- for (org.simantics.g2d.diagram.handler.LifeCycle lc : clazz.getItemsByClass(org.simantics.g2d.diagram.handler.LifeCycle.class))\r
- lc.onDiagramDestroyed(this);\r
- }\r
-\r
- public void dispose()\r
- {\r
- List<IElement> ss = getElements();\r
- // Fire deactiavate elements\r
- for (IElement e : ss)\r
- for (org.simantics.g2d.element.handler.LifeCycle lc : e.getElementClass().getItemsByClass(org.simantics.g2d.element.handler.LifeCycle.class))\r
- lc.onElementDeactivated(this, e);\r
-\r
- // Fire deactivate diagram\r
- fireDeactivated();\r
-\r
- // Dispose all elements to ensure their hints are freed up.\r
- for (IElement e : ss) {\r
- e.addedToDiagram(null);\r
- e.dispose();\r
- }\r
-\r
- elements.clear();\r
- list.clear();\r
- snapshot = null;\r
-\r
- hintCtx.clearWithoutNotification();\r
- }\r
-\r
- public DiagramClass getDiagramClass()\r
- {\r
- return clazz;\r
- }\r
-\r
- public synchronized void addCompositionListener(CompositionListener listener) {\r
- if (compositionListeners ==null)\r
- compositionListeners = new ListenerList<CompositionListener>(CompositionListener.class);\r
- compositionListeners.add(listener);\r
- }\r
- public synchronized void removeCompositionListener(CompositionListener listener) {\r
- if (compositionListeners == null)\r
- return;\r
- compositionListeners.remove(listener);\r
- if (compositionListeners.isEmpty())\r
- compositionListeners = null;\r
- }\r
-\r
- public synchronized void addCompositionVetoListener(CompositionVetoListener listener) {\r
- if (compositionVetoListeners ==null)\r
- compositionVetoListeners = new ListenerList<CompositionVetoListener>(CompositionVetoListener.class);\r
- compositionVetoListeners.add(listener);\r
- }\r
- public synchronized void removeCompositionVetoListener(CompositionVetoListener listener) {\r
- if (compositionVetoListeners == null)\r
- return;\r
- compositionVetoListeners.remove(listener);\r
- if (compositionVetoListeners.isEmpty())\r
- compositionVetoListeners = null;\r
- }\r
-\r
- /**\r
- * Adds a new element. The element will not be initialized\r
- * @param clazz element class\r
- * @return element of class\r
- */\r
- public synchronized void addElement(IElement e) {\r
- assert(clazz!=null);\r
-\r
- // Give the possibility for listeners to veto an element addition\r
- if (!fireBeforeElementAdded(e)) {\r
- System.out.println("Element addition VETOED for " + e);\r
- return;\r
- }\r
-\r
- snapshot = null;\r
- elements.add(e);\r
- list.add(e);\r
-\r
- e.addedToDiagram(this);\r
-\r
- for (org.simantics.g2d.element.handler.LifeCycle lc : e.getElementClass().getItemsByClass(org.simantics.g2d.element.handler.LifeCycle.class))\r
- lc.onElementActivated(this, e);\r
-\r
- for (ElementListener el : clazz.getItemsByClass(ElementListener.class))\r
- el.onElementAdded(this, e);\r
-\r
- fireElementAdded(e);\r
- }\r
-\r
- protected void assertHasElement(IElement e)\r
- {\r
- assert(elements.contains(e));\r
- }\r
-\r
- @Override\r
- public boolean containsElement(IElement element) {\r
- return elements.contains(element);\r
- }\r
-\r
- /**\r
- * Remove element from the diagram\r
- * @param element element to remove\r
- */\r
- public synchronized void removeElement(IElement e) {\r
-\r
-// new Exception(e.toString()).printStackTrace();\r
-\r
- // Give the possibility for listeners to veto an element removal.\r
- if (!fireBeforeElementRemoved(e)) {\r
- System.out.println("Element removal VETOED for " + e);\r
- return;\r
- }\r
-\r
- //System.out.println("[" + this + "] removed element " + e + "");\r
-\r
- boolean removed = elements.remove(e);\r
- assert(removed);\r
- list.remove(e);\r
- snapshot = null;\r
-\r
- e.addedToDiagram(null);\r
-\r
- for (ElementListener el : clazz.getItemsByClass(ElementListener.class))\r
- el.onElementRemoved(this, e);\r
-\r
- for (org.simantics.g2d.element.handler.LifeCycle lc : e.getElementClass().getItemsByClass(org.simantics.g2d.element.handler.LifeCycle.class))\r
- lc.onElementDeactivated(this, e);\r
-\r
- fireElementRemoved(e);\r
- }\r
-\r
- /**\r
- * @param e the element to be added\r
- * @return <code>true</code> if the addition was allowed by all listeners or\r
- * <code>false</code> if the addition was vetoed\r
- */\r
- protected boolean fireBeforeElementAdded(IElement e) {\r
- if (compositionVetoListeners==null) return true;\r
- for (CompositionVetoListener l : compositionVetoListeners.getListeners())\r
- if (!l.beforeElementAdded(this, e))\r
- return false;\r
- return true;\r
- }\r
-\r
- /**\r
- * @param e the element to be removed\r
- * @return <code>true</code> if the removal was allowed by all listeners or\r
- * <code>false</code> if the removal was vetoed\r
- */\r
- protected boolean fireBeforeElementRemoved(IElement e) {\r
- if (compositionVetoListeners==null) return true;\r
- for (CompositionVetoListener l : compositionVetoListeners.getListeners())\r
- if (!l.beforeElementRemoved(this, e))\r
- return false;\r
- return true;\r
- }\r
- protected void fireElementAdded(IElement e) {\r
- if (compositionListeners==null) return;\r
- for (CompositionListener l : compositionListeners.getListeners())\r
- l.onElementAdded(this, e);\r
- }\r
- protected void fireElementRemoved(IElement e) {\r
- if (compositionListeners==null) return;\r
- for (CompositionListener l : compositionListeners.getListeners())\r
- l.onElementRemoved(this, e);\r
- }\r
-\r
- @Override\r
- public List<IElement> getSnapshot() {\r
- List<IElement> snap = snapshot;\r
- if (snap != null)\r
- return snap;\r
- synchronized (this) {\r
- snap = snapshot;\r
- if (snap == null)\r
- snapshot = snap = Collections.unmodifiableList( new ArrayList<IElement>(list) );\r
- }\r
- return snap;\r
- }\r
-\r
- protected static void fireDestroyed(IDiagram e)\r
- {\r
- for (LifeCycle lc : e.getDiagramClass().getItemsByClass(LifeCycle.class))\r
- lc.onDiagramDestroyed(e);\r
- }\r
-\r
- protected static void fireDeactivated(IDiagram e)\r
- {\r
- for (LifeCycle lc : e.getDiagramClass().getItemsByClass(LifeCycle.class))\r
- lc.onDiagramDisposed(e);\r
- }\r
-\r
- protected static void fireCreated(IDiagram e)\r
- {\r
- for (LifeCycle lc : e.getDiagramClass().getItemsByClass(LifeCycle.class))\r
- lc.onDiagramCreated(e);\r
- }\r
-\r
- protected static void fireLoaded(IDiagram e)\r
- {\r
- for (LifeCycle lc : e.getDiagramClass().getItemsByClass(LifeCycle.class))\r
- lc.onDiagramLoaded(e, e.getElements());\r
- }\r
-\r
- protected void fireCreated()\r
- {\r
- fireCreated(this);\r
- }\r
-\r
- protected void fireLoaded()\r
- {\r
- fireLoaded(this);\r
- }\r
-\r
- protected void fireDestroyed()\r
- {\r
- fireDestroyed(this);\r
- }\r
-\r
- protected void fireDeactivated()\r
- {\r
- fireDeactivated(this);\r
- }\r
-\r
- @Override\r
- public void clearWithoutNotification() {\r
- hintCtx.clearWithoutNotification();\r
- }\r
-\r
- @Override\r
- public <E> E removeHint(Key key) {\r
- return hintCtx.removeHint(key);\r
- }\r
-\r
- @Override\r
- public void setHint(Key key, Object value) {\r
- hintCtx.setHint(key, value);\r
- }\r
-\r
- @Override\r
- public void setHints(Map<Key, Object> hints) {\r
- hintCtx.setHints(hints);\r
- }\r
-\r
- @Override\r
- public void addHintListener(IHintListener listener) {\r
- hintCtx.addHintListener(listener);\r
- }\r
-\r
- @Override\r
- public void addHintListener(IThreadWorkQueue threadAccess,\r
- IHintListener listener) {\r
- hintCtx.addHintListener(threadAccess, listener);\r
- }\r
-\r
- @Override\r
- public void addKeyHintListener(Key key, IHintListener listener) {\r
- hintCtx.addKeyHintListener(key, listener);\r
- }\r
-\r
- @Override\r
- public void addKeyHintListener(IThreadWorkQueue threadAccess, Key key,\r
- IHintListener listener) {\r
- hintCtx.addKeyHintListener(threadAccess, key, listener);\r
- }\r
-\r
- @Override\r
- public boolean containsHint(Key key) {\r
- return hintCtx.containsHint(key);\r
- }\r
-\r
- @Override\r
- public <E> E getHint(Key key) {\r
- return hintCtx.getHint(key);\r
- }\r
-\r
- @Override\r
- public Map<Key, Object> getHints() {\r
- return hintCtx.getHints();\r
- }\r
-\r
- @Override\r
- public Map<Key, Object> getHintsUnsafe() {\r
- return hintCtx.getHintsUnsafe();\r
- }\r
-\r
- @Override\r
- public <E extends Key> Map<E, Object> getHintsOfClass(Class<E> clazz) {\r
- return hintCtx.getHintsOfClass(clazz);\r
- }\r
-\r
- @Override\r
- public void removeHintListener(IHintListener listener) {\r
- hintCtx.removeHintListener(listener);\r
- }\r
-\r
- @Override\r
- public void removeHintListener(IThreadWorkQueue threadAccess,\r
- IHintListener listener) {\r
- hintCtx.removeHintListener(threadAccess, listener);\r
- }\r
-\r
- @Override\r
- public void removeKeyHintListener(Key key, IHintListener listener) {\r
- hintCtx.removeKeyHintListener(key, listener);\r
- }\r
-\r
- @Override\r
- public void removeKeyHintListener(IThreadWorkQueue threadAccess, Key key,\r
- IHintListener listener) {\r
- hintCtx.removeKeyHintListener(threadAccess, key, listener);\r
- }\r
-\r
- @Override\r
- public boolean bringToTop(IElement e) {\r
- assertHasElement(e);\r
- if (list.get(list.size()-1)==e) return false;\r
- list.add( e );\r
- list.remove( e );\r
- snapshot = null;\r
- return true;\r
- }\r
-\r
- @Override\r
- public boolean bringUp(IElement e) {\r
- assertHasElement(e);\r
- int i = list.indexOf(e);\r
- if (i==list.size()-1) return false;\r
- int j = i+1;\r
- IElement upper = list.get(j);\r
- list.set(j, e);\r
- list.set(i, upper);\r
- snapshot = null;\r
- return true;\r
- }\r
-\r
- @Override\r
- public boolean sendDown(IElement e) {\r
- assertHasElement(e);\r
- int i = list.indexOf(e);\r
- if (i==0) return false;\r
- int j = i-1;\r
- IElement lower = list.get(j);\r
- list.set(j, e);\r
- list.set(i, lower);\r
- snapshot = null;\r
- return true;\r
- }\r
-\r
- @Override\r
- public boolean sendToBottom(IElement e) {\r
- assertHasElement(e);\r
- if (list.get(0)==e) return false;\r
- list.remove(e);\r
- list.add(0, e);\r
- snapshot = null;\r
- return true;\r
- }\r
-\r
- @Override\r
- public boolean moveTo(IElement e, int position) {\r
- assertHasElement(e);\r
- int indexOf = list.indexOf(e);\r
- if (indexOf==position) return false;\r
- list.remove(indexOf);\r
- list.add(position, e);\r
- snapshot = null;\r
- return true;\r
- }\r
-\r
- @Override\r
- public List<IElement> getElements() {\r
- return unmodifiableList;\r
- }\r
-\r
- @Override\r
- public void sort(Comparator<IElement> comparator) {\r
- Collections.sort(list, comparator);\r
- }\r
-\r
- @SuppressWarnings("rawtypes")\r
- public Object getAdapter(Class adapter) {\r
- for (DiagramAdapter ea : clazz.getItemsByClass(DiagramAdapter.class)) {\r
- Object result = ea.getAdapter(this, adapter);\r
- if (result != null)\r
- return result;\r
- }\r
- return null;\r
- }\r
-\r
-}\r
+/*******************************************************************************
+ * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * in Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
+package org.simantics.g2d.diagram.impl;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.simantics.g2d.diagram.DiagramClass;
+import org.simantics.g2d.diagram.IDiagram;
+import org.simantics.g2d.diagram.handler.DiagramAdapter;
+import org.simantics.g2d.diagram.handler.ElementListener;
+import org.simantics.g2d.diagram.handler.LifeCycle;
+import org.simantics.g2d.element.IElement;
+import org.simantics.utils.datastructures.ListenerList;
+import org.simantics.utils.datastructures.hints.IHintContext;
+import org.simantics.utils.datastructures.hints.IHintListener;
+import org.simantics.utils.threads.IThreadWorkQueue;
+
+/**
+ * @author Toni Kalajainen
+ */
+public class AbstractDiagram implements IDiagram {
+
+ ListenerList<CompositionVetoListener> compositionVetoListeners;
+ ListenerList<CompositionListener> compositionListeners;
+
+ Set<IElement> elements = new HashSet<IElement>();
+ ArrayList<IElement> list = new ArrayList<IElement>();
+ List<IElement> unmodifiableList = Collections.unmodifiableList(list);
+ volatile List<IElement> snapshot = null;
+ DiagramClass clazz;
+ IHintContext hintCtx;
+
+ public AbstractDiagram(DiagramClass clazz, IHintContext hintCtx)
+ {
+ if (clazz == null)
+ throw new NullPointerException("null clazz");
+ this.clazz = clazz;
+ this.hintCtx = hintCtx;
+ }
+
+ public void destroy()
+ {
+ List<IElement> ss = getElements();
+
+ dispose();
+
+ // Fire destroy elements
+ for (IElement e : ss)
+ e.destroy();
+
+ // Fire destroy diagram
+ for (org.simantics.g2d.diagram.handler.LifeCycle lc : clazz.getItemsByClass(org.simantics.g2d.diagram.handler.LifeCycle.class))
+ lc.onDiagramDestroyed(this);
+ }
+
+ public void dispose()
+ {
+ List<IElement> ss = getElements();
+ // Fire deactiavate elements
+ for (IElement e : ss)
+ for (org.simantics.g2d.element.handler.LifeCycle lc : e.getElementClass().getItemsByClass(org.simantics.g2d.element.handler.LifeCycle.class))
+ lc.onElementDeactivated(this, e);
+
+ // Fire deactivate diagram
+ fireDeactivated();
+
+ // Dispose all elements to ensure their hints are freed up.
+ for (IElement e : ss) {
+ e.addedToDiagram(null);
+ e.dispose();
+ }
+
+ elements.clear();
+ list.clear();
+ snapshot = null;
+
+ hintCtx.clearWithoutNotification();
+ }
+
+ public DiagramClass getDiagramClass()
+ {
+ return clazz;
+ }
+
+ public synchronized void addCompositionListener(CompositionListener listener) {
+ if (compositionListeners ==null)
+ compositionListeners = new ListenerList<CompositionListener>(CompositionListener.class);
+ compositionListeners.add(listener);
+ }
+ public synchronized void removeCompositionListener(CompositionListener listener) {
+ if (compositionListeners == null)
+ return;
+ compositionListeners.remove(listener);
+ if (compositionListeners.isEmpty())
+ compositionListeners = null;
+ }
+
+ public synchronized void addCompositionVetoListener(CompositionVetoListener listener) {
+ if (compositionVetoListeners ==null)
+ compositionVetoListeners = new ListenerList<CompositionVetoListener>(CompositionVetoListener.class);
+ compositionVetoListeners.add(listener);
+ }
+ public synchronized void removeCompositionVetoListener(CompositionVetoListener listener) {
+ if (compositionVetoListeners == null)
+ return;
+ compositionVetoListeners.remove(listener);
+ if (compositionVetoListeners.isEmpty())
+ compositionVetoListeners = null;
+ }
+
+ /**
+ * Adds a new element. The element will not be initialized
+ * @param clazz element class
+ * @return element of class
+ */
+ public synchronized void addElement(IElement e) {
+ assert(clazz!=null);
+
+ // Give the possibility for listeners to veto an element addition
+ if (!fireBeforeElementAdded(e)) {
+ System.out.println("Element addition VETOED for " + e);
+ return;
+ }
+
+ snapshot = null;
+ elements.add(e);
+ list.add(e);
+
+ e.addedToDiagram(this);
+
+ for (org.simantics.g2d.element.handler.LifeCycle lc : e.getElementClass().getItemsByClass(org.simantics.g2d.element.handler.LifeCycle.class))
+ lc.onElementActivated(this, e);
+
+ for (ElementListener el : clazz.getItemsByClass(ElementListener.class))
+ el.onElementAdded(this, e);
+
+ fireElementAdded(e);
+ }
+
+ protected void assertHasElement(IElement e)
+ {
+ assert(elements.contains(e));
+ }
+
+ @Override
+ public boolean containsElement(IElement element) {
+ return elements.contains(element);
+ }
+
+ /**
+ * Remove element from the diagram
+ * @param element element to remove
+ */
+ public synchronized void removeElement(IElement e) {
+
+// new Exception(e.toString()).printStackTrace();
+
+ // Give the possibility for listeners to veto an element removal.
+ if (!fireBeforeElementRemoved(e)) {
+ System.out.println("Element removal VETOED for " + e);
+ return;
+ }
+
+ //System.out.println("[" + this + "] removed element " + e + "");
+
+ boolean removed = elements.remove(e);
+ assert(removed);
+ list.remove(e);
+ snapshot = null;
+
+ e.addedToDiagram(null);
+
+ for (ElementListener el : clazz.getItemsByClass(ElementListener.class))
+ el.onElementRemoved(this, e);
+
+ for (org.simantics.g2d.element.handler.LifeCycle lc : e.getElementClass().getItemsByClass(org.simantics.g2d.element.handler.LifeCycle.class))
+ lc.onElementDeactivated(this, e);
+
+ fireElementRemoved(e);
+ }
+
+ /**
+ * @param e the element to be added
+ * @return <code>true</code> if the addition was allowed by all listeners or
+ * <code>false</code> if the addition was vetoed
+ */
+ protected boolean fireBeforeElementAdded(IElement e) {
+ if (compositionVetoListeners==null) return true;
+ for (CompositionVetoListener l : compositionVetoListeners.getListeners())
+ if (!l.beforeElementAdded(this, e))
+ return false;
+ return true;
+ }
+
+ /**
+ * @param e the element to be removed
+ * @return <code>true</code> if the removal was allowed by all listeners or
+ * <code>false</code> if the removal was vetoed
+ */
+ protected boolean fireBeforeElementRemoved(IElement e) {
+ if (compositionVetoListeners==null) return true;
+ for (CompositionVetoListener l : compositionVetoListeners.getListeners())
+ if (!l.beforeElementRemoved(this, e))
+ return false;
+ return true;
+ }
+ protected void fireElementAdded(IElement e) {
+ if (compositionListeners==null) return;
+ for (CompositionListener l : compositionListeners.getListeners())
+ l.onElementAdded(this, e);
+ }
+ protected void fireElementRemoved(IElement e) {
+ if (compositionListeners==null) return;
+ for (CompositionListener l : compositionListeners.getListeners())
+ l.onElementRemoved(this, e);
+ }
+
+ @Override
+ public List<IElement> getSnapshot() {
+ List<IElement> snap = snapshot;
+ if (snap != null)
+ return snap;
+ synchronized (this) {
+ snap = snapshot;
+ if (snap == null)
+ snapshot = snap = Collections.unmodifiableList( new ArrayList<IElement>(list) );
+ }
+ return snap;
+ }
+
+ protected static void fireDestroyed(IDiagram e)
+ {
+ for (LifeCycle lc : e.getDiagramClass().getItemsByClass(LifeCycle.class))
+ lc.onDiagramDestroyed(e);
+ }
+
+ protected static void fireDeactivated(IDiagram e)
+ {
+ for (LifeCycle lc : e.getDiagramClass().getItemsByClass(LifeCycle.class))
+ lc.onDiagramDisposed(e);
+ }
+
+ protected static void fireCreated(IDiagram e)
+ {
+ for (LifeCycle lc : e.getDiagramClass().getItemsByClass(LifeCycle.class))
+ lc.onDiagramCreated(e);
+ }
+
+ protected static void fireLoaded(IDiagram e)
+ {
+ for (LifeCycle lc : e.getDiagramClass().getItemsByClass(LifeCycle.class))
+ lc.onDiagramLoaded(e, e.getElements());
+ }
+
+ protected void fireCreated()
+ {
+ fireCreated(this);
+ }
+
+ protected void fireLoaded()
+ {
+ fireLoaded(this);
+ }
+
+ protected void fireDestroyed()
+ {
+ fireDestroyed(this);
+ }
+
+ protected void fireDeactivated()
+ {
+ fireDeactivated(this);
+ }
+
+ @Override
+ public void clearWithoutNotification() {
+ hintCtx.clearWithoutNotification();
+ }
+
+ @Override
+ public <E> E removeHint(Key key) {
+ return hintCtx.removeHint(key);
+ }
+
+ @Override
+ public void setHint(Key key, Object value) {
+ hintCtx.setHint(key, value);
+ }
+
+ @Override
+ public void setHints(Map<Key, Object> hints) {
+ hintCtx.setHints(hints);
+ }
+
+ @Override
+ public void addHintListener(IHintListener listener) {
+ hintCtx.addHintListener(listener);
+ }
+
+ @Override
+ public void addHintListener(IThreadWorkQueue threadAccess,
+ IHintListener listener) {
+ hintCtx.addHintListener(threadAccess, listener);
+ }
+
+ @Override
+ public void addKeyHintListener(Key key, IHintListener listener) {
+ hintCtx.addKeyHintListener(key, listener);
+ }
+
+ @Override
+ public void addKeyHintListener(IThreadWorkQueue threadAccess, Key key,
+ IHintListener listener) {
+ hintCtx.addKeyHintListener(threadAccess, key, listener);
+ }
+
+ @Override
+ public boolean containsHint(Key key) {
+ return hintCtx.containsHint(key);
+ }
+
+ @Override
+ public <E> E getHint(Key key) {
+ return hintCtx.getHint(key);
+ }
+
+ @Override
+ public Map<Key, Object> getHints() {
+ return hintCtx.getHints();
+ }
+
+ @Override
+ public Map<Key, Object> getHintsUnsafe() {
+ return hintCtx.getHintsUnsafe();
+ }
+
+ @Override
+ public <E extends Key> Map<E, Object> getHintsOfClass(Class<E> clazz) {
+ return hintCtx.getHintsOfClass(clazz);
+ }
+
+ @Override
+ public void removeHintListener(IHintListener listener) {
+ hintCtx.removeHintListener(listener);
+ }
+
+ @Override
+ public void removeHintListener(IThreadWorkQueue threadAccess,
+ IHintListener listener) {
+ hintCtx.removeHintListener(threadAccess, listener);
+ }
+
+ @Override
+ public void removeKeyHintListener(Key key, IHintListener listener) {
+ hintCtx.removeKeyHintListener(key, listener);
+ }
+
+ @Override
+ public void removeKeyHintListener(IThreadWorkQueue threadAccess, Key key,
+ IHintListener listener) {
+ hintCtx.removeKeyHintListener(threadAccess, key, listener);
+ }
+
+ @Override
+ public boolean bringToTop(IElement e) {
+ assertHasElement(e);
+ if (list.get(list.size()-1)==e) return false;
+ list.add( e );
+ list.remove( e );
+ snapshot = null;
+ return true;
+ }
+
+ @Override
+ public boolean bringUp(IElement e) {
+ assertHasElement(e);
+ int i = list.indexOf(e);
+ if (i==list.size()-1) return false;
+ int j = i+1;
+ IElement upper = list.get(j);
+ list.set(j, e);
+ list.set(i, upper);
+ snapshot = null;
+ return true;
+ }
+
+ @Override
+ public boolean sendDown(IElement e) {
+ assertHasElement(e);
+ int i = list.indexOf(e);
+ if (i==0) return false;
+ int j = i-1;
+ IElement lower = list.get(j);
+ list.set(j, e);
+ list.set(i, lower);
+ snapshot = null;
+ return true;
+ }
+
+ @Override
+ public boolean sendToBottom(IElement e) {
+ assertHasElement(e);
+ if (list.get(0)==e) return false;
+ list.remove(e);
+ list.add(0, e);
+ snapshot = null;
+ return true;
+ }
+
+ @Override
+ public boolean moveTo(IElement e, int position) {
+ assertHasElement(e);
+ int indexOf = list.indexOf(e);
+ if (indexOf==position) return false;
+ list.remove(indexOf);
+ list.add(position, e);
+ snapshot = null;
+ return true;
+ }
+
+ @Override
+ public List<IElement> getElements() {
+ return unmodifiableList;
+ }
+
+ @Override
+ public void sort(Comparator<IElement> comparator) {
+ Collections.sort(list, comparator);
+ }
+
+ @SuppressWarnings("rawtypes")
+ public Object getAdapter(Class adapter) {
+ for (DiagramAdapter ea : clazz.getItemsByClass(DiagramAdapter.class)) {
+ Object result = ea.getAdapter(this, adapter);
+ if (result != null)
+ return result;
+ }
+ return null;
+ }
+
+}
Code Review / simantics / platform.git / blobdiff