ObjectManager.java
001 /*
002  *
003  * All content copyright Terracotta, Inc., unless otherwise indicated. All rights reserved.
004  *
005  */
006 package demo.sharededitor.models;
007 
008 import demo.sharededitor.events.ListListener;
009 
010 import java.util.ArrayList;
011 import java.util.List;
012 import java.util.Collections;
013 import java.util.Iterator;
014 
015 public class ObjectManager implements ListListener {
016    private List objList;
017 
018    private transient List grabList;
019 
020    private transient ListListener listener;
021 
022    private transient BaseObject lastGrabbed;
023 
024    public ObjectManager() {
025       objList = Collections.synchronizedList(new ArrayList());
026       init_transients();
027       notifyListener(null);
028    }
029 
030    public void init_transients() {
031       listener = null;
032       grabList = Collections.synchronizedList(new ArrayList());
033    }
034 
035    public void setListener(ListListener listener) {
036       this.listener = listener;
037       notifyListener(null);
038    }
039 
040    private void notifyListener(Object obj) {
041       if (listener != null) {
042          listener.changed(this, obj);
043       }
044    }
045 
046    public synchronized void add(BaseObject obj) {
047       synchronized (objList) {
048          if (objList.contains(obj))
049             return;
050 
051          obj.addListener(this);
052          objList.add(obj);
053          obj.notifyListeners(obj);
054 
055          notifyListener(obj);
056       }
057    }
058 
059    public synchronized void remove(BaseObject obj) {
060       synchronized (objList) {
061          if (!objList.contains(obj))
062             return;
063 
064          objList.remove(obj);
065          obj.notifyListeners(obj);
066          obj.removeListener(this);
067 
068          notifyListener(obj);
069       }
070    }
071 
072    public BaseObject[] reversedList() {
073       synchronized (objList) {
074          List list = new ArrayList(objList);
075          Collections.reverse(list);
076          return (BaseObject[]) list.toArray(new BaseObject[0]);
077       }
078    }
079 
080    public BaseObject[] list() {
081       synchronized (objList) {
082          return (BaseObject[]) objList.toArray(new BaseObject[0]);
083       }
084    }
085 
086    public boolean canGrabAt(int x, int y) {
087       BaseObject[] list = reversedList();
088       for (int i = 0; i < list.length; i++) {
089          BaseObject obj = list[i];
090          if (obj.isAt(x, y))
091             return true;
092       }
093       return false;
094    }
095 
096    public BaseObject create(int x, int y, String name) {
097       BaseObject obj = BaseObject.createObject(name);
098       obj.move(x, y);
099       add(obj);
100       ungrabAll();
101       grab(obj, x, y);
102       return obj;
103    }
104 
105    public BaseObject grabAt(int x, int y, boolean ungrabAll) {
106       BaseObject[] list = reversedList();
107       for (int i = 0; i < list.length; i++) {
108          BaseObject obj = list[i];
109          if (obj.isAt(x, y)) {
110             if (ungrabAll)
111                ungrabAll();
112             grab(obj, x, y);
113             return obj;
114          }
115       }
116       if (ungrabAll)
117          ungrabAll();
118       return null;
119    }
120 
121    public BaseObject lastGrabbed() {
122       return lastGrabbed;
123    }
124 
125    private void ungrabAll() {
126       synchronized (grabList) {
127          lastGrabbed = null;
128          grabList.clear();
129          notifyListener(null);
130       }
131    }
132 
133    private void grab(BaseObject obj, int x, int y) {
134       synchronized (grabList) {
135          obj.selectAction(true);
136 
137          if (grabList.contains(obj))
138             return;
139 
140          grabList.add(obj);
141          obj.setGrabbedAnchorAt(x, y);
142 
143          notifyListener(obj);
144          lastGrabbed = obj;
145       }
146    }
147 
148    private void ungrab(BaseObject obj) {
149       synchronized (grabList) {
150          obj.selectAction(false);
151 
152          if (!grabList.contains(obj))
153             return;
154 
155          grabList.remove(obj);
156          notifyListener(obj);
157          lastGrabbed = null;
158       }
159    }
160 
161    private void grab(BaseObject obj) {
162       synchronized (grabList) {
163          if (grabList.contains(obj))
164             return;
165 
166          obj.selectAction(true);
167          grabList.add(obj);
168          notifyListener(obj);
169          lastGrabbed = obj;
170       }
171    }
172 
173    public void deleteSelection() {
174       synchronized (grabList) {
175          Iterator i = grabList.iterator();
176          while (i.hasNext())
177             remove((BaseObjecti.next());
178       }
179    }
180 
181    public void selectAll() {
182       BaseObject[] list = list();
183       for (int i = 0; i < list.length; i++)
184          grab(list[i]);
185    }
186 
187    public void selectAllWithin(BaseObject boundary) {
188       BaseObject[] list = list();
189       for (int i = 0; i < list.length; i++) {
190          java.awt.Shape s1 = boundary.getShape();
191          java.awt.Shape s2 = list[i].getShape();
192          if (s1.contains(s2.getBounds2D()))
193             grab(list[i]);
194       }
195    }
196 
197    public void clearSelection() {
198       BaseObject[] list = list();
199       for (int i = 0; i < list.length; i++)
200          ungrab(list[i]);
201    }
202 
203    public void invertSelection() {
204       BaseObject[] list = list();
205       for (int i = 0; i < list.length; i++) {
206          BaseObject obj = list[i];
207          if (isGrabbed(obj))
208             ungrab(obj);
209          else
210             grab(obj);
211       }
212    }
213 
214    public void toggleSelection() {
215       synchronized (objList) {
216          synchronized (grabList) {
217             if (objList.size() == grabList.size())
218                clearSelection();
219             else
220                selectAll();
221          }
222       }
223    }
224 
225    public boolean isGrabbed(BaseObject obj) {
226       synchronized (grabList) {
227          return grabList.contains(obj);
228       }
229    }
230 
231    public void changed(Object source, Object obj) {
232       notifyListener(obj);
233    }
234 }