001: /*
002: * Sun Public License Notice
003: *
004: * The contents of this file are subject to the Sun Public License
005: * Version 1.0 (the "License"). You may not use this file except in
006: * compliance with the License. A copy of the License is available at
007: * http://www.sun.com/
008: *
009: * The Original Code is NetBeans. The Initial Developer of the Original
010: * Code is Sun Microsystems, Inc. Portions Copyright 1997-2000 Sun
011: * Microsystems, Inc. All Rights Reserved.
012: */
013:
014: package org.netbeans.editor;
015:
016: import java.util.ArrayList;
017: import java.util.Arrays;
018:
019: /**
020: * Draw layer list stores multiple draw-layers sorted according to their
021: * visibility which is the integer giving the z-order in which the layers are
022: * sorted. It also provides an iterator to go through the draw layer members.
023: *
024: * @author Miloslav Metelka
025: * @version 1.00
026: */
027:
028: class DrawLayerList {
029:
030: private static final DrawLayer[] EMPTY = new DrawLayer[0];
031:
032: private DrawLayer[] layers = EMPTY;
033:
034: private final ArrayList visibilityList = new ArrayList();
035:
036: /**
037: * Add the new layer to the list depending on visibility.
038: *
039: * @param layer
040: * layer to add to the layer list
041: * @return true when new layer was added false otherwise. The layer is not
042: * added if there is already a layer with the same name. There can
043: * be a layer with the same visibility like the layer being added.
044: */
045: synchronized boolean add(DrawLayer layer, int visibility) {
046: if (indexOf(layer.getName()) >= 0) { // already layer with that name
047: return false;
048: }
049:
050: int indAdd = layers.length;
051: for (int i = 0; i < layers.length; i++) {
052: if (((Integer) visibilityList.get(i)).intValue() > visibility) {
053: indAdd = i;
054: break;
055: }
056: }
057:
058: ArrayList l = new ArrayList(Arrays.asList(layers));
059: l.add(indAdd, layer);
060: layers = new DrawLayer[layers.length + 1];
061: l.toArray(layers);
062:
063: visibilityList.add(indAdd, new Integer(visibility));
064:
065: return true;
066: }
067:
068: synchronized void add(DrawLayerList l) {
069: DrawLayer[] lta = l.layers;
070: for (int i = 0; i < lta.length; i++) {
071: add(lta[i], ((Integer) l.visibilityList.get(i)).intValue());
072: }
073: }
074:
075: /**
076: * Remove layer specified by layerName from layer list.
077: *
078: * @param layer
079: * layer to remove from the layer list
080: */
081: synchronized DrawLayer remove(String layerName) {
082: int ind = indexOf(layerName);
083: DrawLayer removed = null;
084:
085: if (ind >= 0) {
086: removed = layers[ind];
087: ArrayList l = new ArrayList(Arrays.asList(layers));
088: l.remove(ind);
089: layers = new DrawLayer[layers.length - 1];
090: l.toArray(layers);
091:
092: visibilityList.remove(ind);
093: }
094:
095: return removed;
096: }
097:
098: synchronized void remove(DrawLayerList l) {
099: DrawLayer[] lta = l.layers;
100: for (int i = 0; i < lta.length; i++) {
101: remove(lta[i].getName());
102: }
103: }
104:
105: synchronized DrawLayer findLayer(String layerName) {
106: int ind = indexOf(layerName);
107: return (ind >= 0) ? layers[ind] : null;
108: }
109:
110: /**
111: * Get the snapshot of the current layers. This is useful for drawing
112: * process that would otherwise have to hold a lock on editorUI so that no
113: * layer would be added or removed during the drawing.
114: */
115: synchronized DrawLayer[] currentLayers() {
116: return (DrawLayer[]) layers.clone();
117: }
118:
119: private int indexOf(String layerName) {
120: for (int i = 0; i < layers.length; i++) {
121: if (layerName.equals(layers[i].getName())) {
122: return i;
123: }
124: }
125: return -1;
126: }
127:
128: public String toString() {
129: switch (layers.length) {
130: case 0:
131: return "No layers";
132: case 1:
133: return "Standalone " + layers[0];
134: default:
135: return "Layers:\n" + EditorDebug.debugArray(layers);
136: }
137: }
138:
139: }
|