1 /*******************************************************************************
2 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
4 * All rights reserved. This program and the accompanying materials
5 * are made available under the terms of the Eclipse Public License v1.0
6 * which accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * VTT Technical Research Centre of Finland - initial API and implementation
11 *******************************************************************************/
12 package org.simantics.g2d.layers;
14 import java.util.Collections;
15 import java.util.Comparator;
17 import java.util.TreeSet;
18 import java.util.concurrent.CopyOnWriteArrayList;
20 import org.simantics.utils.strings.AlphanumComparator;
23 * @author Antti Villberg
25 public class SimpleLayers implements ILayersEditor {
27 private static final Comparator<ILayer> LAYER_COMPARATOR = new Comparator<ILayer>() {
29 public int compare(ILayer o1, ILayer o2) {
30 return AlphanumComparator.COMPARATOR.compare(o1.getName(), o2.getName());
34 private Set<ILayer> all = new TreeSet<ILayer>(LAYER_COMPARATOR);
35 private volatile Set<ILayer> allSnapshot;
37 private Set<ILayer> visible = new TreeSet<ILayer>(LAYER_COMPARATOR);
38 private volatile Set<ILayer> visibleSnapshot;
40 private CopyOnWriteArrayList<ILayersEditorListener> layerEditorListeners = new CopyOnWriteArrayList<ILayersEditorListener>();
41 private CopyOnWriteArrayList<ILayersListener> layersListeners = new CopyOnWriteArrayList<ILayersListener>();
43 private boolean ignoreFocusSettings = false;
45 private boolean ignoreVisibilitySettings = false;
47 public SimpleLayers() {
50 public SimpleLayers(String... content) {
51 for (String s : content) {
52 ILayer layer = new SimpleLayer(s);
59 public void update(Set<ILayer> allLayers, Set<ILayer> visibleLayers) {
62 all.addAll(allLayers);
64 visible.addAll(visibleLayers);
66 visibleSnapshot = null;
68 for (ILayersListener listener : layersListeners) {
74 public Set<ILayer> getLayers() {
75 // Double-checked locking idiom: http://en.wikipedia.org/wiki/Double-checked_locking
76 // Works with acquire/release semantics for volatile
77 // Broken under Java 1.4 and earlier semantics for volatile
78 if (allSnapshot == null) {
80 if (allSnapshot == null) {
81 TreeSet<ILayer> ss = new TreeSet<ILayer>(LAYER_COMPARATOR);
83 allSnapshot = Collections.unmodifiableSet(ss);
91 public Set<ILayer> getVisibleLayers() {
92 // Double-checked locking idiom: http://en.wikipedia.org/wiki/Double-checked_locking
93 // Works with acquire/release semantics for volatile
94 // Broken under Java 1.4 and earlier semantics for volatile
95 if (visibleSnapshot == null) {
97 if (visibleSnapshot == null) {
98 TreeSet<ILayer> ss = new TreeSet<ILayer>(LAYER_COMPARATOR);
100 visibleSnapshot = Collections.unmodifiableSet(ss);
104 return visibleSnapshot;
108 public boolean isActive(ILayer layer) {
109 synchronized (this) {
110 return visible.contains(layer);
115 public void deactivate(ILayer layer) {
116 boolean deactivated = false;
117 synchronized (this) {
118 deactivated = visible.remove(layer);
121 synchronized (this) {
122 visibleSnapshot = null;
124 for (ILayersListener listener : layersListeners) {
127 for (ILayersEditorListener listener : layerEditorListeners) {
128 listener.layerDeactivated(layer);
134 public void activate(ILayer layer) {
135 boolean activated = false;
136 synchronized (this) {
137 activated = visible.add(layer);
140 synchronized (this) {
141 visibleSnapshot = null;
143 for (ILayersListener listener : layersListeners) {
146 for (ILayersEditorListener listener : layerEditorListeners) {
147 listener.layerActivated(layer);
153 public void addLayer(ILayer layer) {
154 boolean added = false;
155 synchronized (this) {
156 added = all.add(layer);
159 synchronized (this) {
162 for (ILayersListener listener : layersListeners) {
165 for (ILayersEditorListener listener : layerEditorListeners) {
166 listener.layerAdded(layer);
172 public void removeLayer(ILayer layer) {
173 boolean removed = false;
174 synchronized (this) {
175 removed = all.remove(layer);
176 visible.remove(layer);
179 synchronized (this) {
181 visibleSnapshot = null;
183 for (ILayersListener listener : layersListeners) {
186 for (ILayersEditorListener listener : layerEditorListeners) {
187 listener.layerRemoved(layer);
193 public void addLayerEditorListener(ILayersEditorListener listener) {
194 layerEditorListeners.add(listener);
198 public void removeLayerEditorListener(ILayersEditorListener listener) {
199 layerEditorListeners.remove(listener);
203 public void addLayersListener(ILayersListener listener) {
204 layersListeners.add(listener);
208 public void removeLayersListener(ILayersListener listener) {
209 layersListeners.remove(listener);
213 public boolean getIgnoreFocusSettings() {
214 return ignoreFocusSettings;
218 public void setIgnoreFocusSettings(boolean value) {
219 boolean changed = ignoreFocusSettings != value;
220 ignoreFocusSettings = value;
222 for (ILayersListener listener : layersListeners) {
225 for (ILayersEditorListener listener : layerEditorListeners) {
226 listener.ignoreFocusChanged(value);
232 public boolean getIgnoreVisibilitySettings() {
233 return ignoreVisibilitySettings;
237 public void setIgnoreVisibilitySettings(boolean value) {
238 boolean changed = ignoreVisibilitySettings != value;
239 ignoreVisibilitySettings = value;
241 for (ILayersListener listener : layersListeners) {
244 for (ILayersEditorListener listener : layerEditorListeners) {
245 listener.ignoreVisibilityChanged(value);