Changeset 115 for trunk/src/org/expeditee/gui/Frame.java

Timestamp:

07/02/08 12:38:54 (16 years ago)

Author:

ra33

Message:

added functionality for dockable @v's

File:

• trunk/src/org/expeditee/gui/Frame.java (modified) (15 diffs)

trunk/src/org/expeditee/gui/Frame.java

@@ -112 +112 @@
         private Text _frameName = null;
 
-        private List<Overlay> _overlays = new ArrayList<Overlay>();
+        private Map<Overlay, Frame> _overlays = new HashMap<Overlay, Frame>();
 
         private List<Vector> _vectors = new ArrayList<Vector>();
@@ -123 +123 @@
 
         private Time _darkTime = new Time(0);
+
+        private Collection<Item> _overlayItems = new LinkedHashSet<Item>();
+
+        private Collection<Item> _vectorItems = new LinkedHashSet<Item>();
 
         /**
@@ -286 +290 @@
         }
 
+        public List<Item> getNonAnnotationItems() {
+                List<Item> items = new ArrayList<Item>();
+                for (Item i : getItems()) {
+                        // only add up normal body text items
+                        if (!i.isAnnotation()) {
+                                items.add(i);
+                        }
+                }
+                return items;
+        }
+
         /**
          * Gets the last item on the frame that is a non annotation item but is also
@@ -427 +442 @@
 
         public Item getStatsTextItem(String itemText) {
-                Text t = getStatTemplate();
+                return getTextItem(itemText, getStatTemplate());
+        }
+
+        public Item getTextItem(String itemText) {
+                return getTextItem(itemText, getItemTemplate());
+        }
+
+        private Item getTextItem(String itemText, Text template) {
+                Text t = template;
                 // We dont want the stats to wrap at all
                 t.setMaxSize(new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE));
@@ -470 +493 @@
                 }
 
-                for (Overlay o : _overlays)
+                for (Overlay o : _overlays.keySet())
                         results.addAll(o.Frame.getItemsWithin(poly));
 
@@ -774 +797 @@
 
                 change();
+                FrameMouseActions.getInstance().refreshHighlights();
                 FrameGraphics.Repaint();
                 ItemUtils.EnclosedCheck(_body);
@@ -882 +906 @@
 
         public String toString() {
-                String s = "";
-                s += "Name: " + _frameset + _number + "\n";
-                s += "Version: " + _version + "\n";
-                s += "Protection: " + _permission + "\n";
-                s += "Owner: " + _owner + "\n";
-                s += "Date Created: " + _creationDate + "\n";
-                s += "Last Mod. User: " + _modifiedUser + "\n";
-                s += "Last Mod. Date: " + _modifiedDate + "\n";
-                s += "Last Froz. Date: " + _frozenDate + "\n";
-
-                s += "\n";
-                s += "\n";
-
-                s += "Items: " + _body.size() + "\n";
-
-                return s;
+                StringBuilder s = new StringBuilder();
+                s.append(String.format("Name: %s%d%n", _frameset, _number));
+                s.append(String.format("Version: %d%n", _version));
+                s.append(String.format("Permission: %s%n", _permission.toString()));
+                s.append(String.format("Owner: %s%n", _owner));
+                s.append(String.format("Date Created: %s%n", _creationDate));
+                s.append(String.format("Last Mod. User: %s%n", _modifiedUser));
+                s.append(String.format("Last Mod. Date: %s%n", _modifiedDate));
+                s.append(String.format("Items: %d%n", _body.size()));
+                return s.toString();
         }
 
@@ -952 +970 @@
                 if (from == null)
                         return null;
-
-                /**
-                 * TODO: Check
-                 */
 
                 List<Item> column = new ArrayList<Item>();
@@ -982 +996 @@
          *             If overlay is null.
          */
-        public void addVector(Vector vector) {
-                if (vector == null)
-                        throw new NullPointerException("Frame.addVector");
+        protected boolean addVector(Vector toAdd) {
                 // make sure we dont add this frame as an overlay of itself
-                if (vector.Frame == this)
-                        return;
-
-                // if (_vectors.contains(vector))
-                // return;
-
-                _vectors.add(vector);
-
-                // TODO add the code below
-                // Items must be notified that they have been added to this frame via
-                // the vector...
-                // List<Item> items = new LinkedList<Item>();
-                // FrameGraphics.AddAllOverlayItems(items, vector.Frame,
-                // new LinkedList<Frame>());
-                //              
-                // for (Item i : items) {
-                // i.onParentStateChanged(new ItemParentStateChangedEvent(this,
-                // ItemParentStateChangedEvent.EVENT_TYPE_ADDED_VIA_VECTOR,
-                // overlay.Level));
-                // }
-        }
-
-        /**
-         * Adds the given Frame to the list of overlays Frames being drawn with this
-         * Frame.
-         * 
-         * @param overlay
-         *            The Frame to add
-         * 
-         * @throws NullPointerException
-         *             If overlay is null.
-         */
-        public void addOverlay(Overlay overlay) {
-                if (overlay == null)
-                        throw new NullPointerException("overlay");
-                // make sure we dont add this frame as an overlay of itself
-                if (overlay.Frame == this)
-                        return;
-
-                if (_overlays.contains(overlay))
-                        return;
-
-                _overlays.add(overlay);
-
-                // Items must be notified that they have been added to this frame via
-                // the overlay...
-                List<Item> items = new LinkedList<Item>();
-                FrameGraphics.AddAllOverlayItems(items, overlay.Frame,
-                                new LinkedList<Frame>());
-                for (Item i : items) {
+                if (toAdd.Frame == this)
+                        return false;
+                _vectors.add(toAdd);
+                // Items must be notified that they have been added or removed from this
+                // frame via the vector...              
+                for (Item i : ItemUtils.CopyItems(toAdd.Frame.getVectorItems(), toAdd)) {
                         i.onParentStateChanged(new ItemParentStateChangedEvent(this,
                                         ItemParentStateChangedEvent.EVENT_TYPE_ADDED_VIA_OVERLAY,
-                                        overlay.Level));
-                }
-        }
-
-        /**
-         * Removes the given overlay from the list of overlays being drawn with this
-         * Frame.
-         * 
-         * @param overlay
-         *            The overlay to remove
-         * 
-         * @throws NullPointerException
-         *             If overlay is null.
-         */
-        public void removeOverlay(Overlay overlay) {
-                if (overlay == null)
-                        throw new NullPointerException("overlay");
-
-                this._overlays.remove(overlay);
-
-                // Items must be notified that they have been removed from this frame
-                // via the overlay...
-                List<Item> items = new LinkedList<Item>();
-                FrameGraphics.AddAllOverlayItems(items, overlay.Frame,
-                                new LinkedList<Frame>());
-                for (Item i : items) {
-                        i.onParentStateChanged(new ItemParentStateChangedEvent(this,
-                                        ItemParentStateChangedEvent.EVENT_TYPE_REMOVED_VIA_OVERLAY,
-                                        overlay.Level));
-                }
-        }
-
-        /**
-         * Removes the given vector from the list of vector being drawn with this
-         * Frame.
-         * 
-         * @param vector
-         *            The overlay to remove
-         * 
-         * @throws NullPointerException
-         *             If overlay is null.
-         */
-        public void removeVector(Vector vector) {
-                if (vector == null)
-                        throw new NullPointerException("Frame.removeVector");
-
-                this._vectors.remove(vector);
-
-                // TODO figure out what the code below needs to be changed to
-                // Items must be notified that they have been removed from this frame
-                // via the overlay...
-                // List<Item> items = new LinkedList<Item>();
-                // FrameGraphics.AddAllOverlayItems(items, vector.Frame,
-                // new LinkedList<Frame>());
-                // for (Item i : items) {
-                // i.onParentStateChanged(new ItemParentStateChangedEvent(this,
-                // ItemParentStateChangedEvent.EVENT_TYPE_REMOVED_VIA_OVERLAY,
-                // vector.Level));
-                // }
-        }
-
-        /**
-         * Removes the given Frame from the list of overlayed Frames being drawn
-         * with this Frame.
-         * 
-         * @param overlayedFrame
-         *            The Frame to remove
-         * 
-         * @throws NullPointerException
-         *             If overlayedFrame is null.
-         */
-        public void removeOverlay(Frame overlayedFrame) {
-                if (overlayedFrame == null)
-                        throw new NullPointerException("overlay");
-
-                // Locate the oveylay(s) that match this
-                List<Overlay> overlaysToRemove = new LinkedList<Overlay>();
-                for (Overlay o : _overlays) {
-                        if (overlayedFrame.equals(o.Frame))
-                                overlaysToRemove.add(o);
-                }
-                for (Overlay o : overlaysToRemove) { // must be enumerated seperate
-                        // to above...
-                        removeOverlay(o);
-                }
-
-        }
-
-        public List<Vector> getVectors() {
-                List<Vector> l = new LinkedList<Vector>();
+                                        toAdd.permission));
+                        _vectorItems.add(i);
+                }
+                return true;
+        }
+
+        public Collection<Vector> getVectors() {
+                Collection<Vector> l = new LinkedList<Vector>();
                 l.addAll(_vectors);
                 return l;
         }
 
-        public List<Overlay> getOverlays() {
-                List<Overlay> l = new LinkedList<Overlay>();
-                l.addAll(_overlays);
-                return l;
-        }
-
-        /**
-         * @return All overlays seen by this frame (including its overlays'
-         *         overlays).
-         */
-        public List<Overlay> getOverlaysDeep() {
-                List<Overlay> l = new LinkedList<Overlay>();
-                getOverlaysDeep(l, this, new LinkedList<Frame>());
-                return l;
+        public Collection<Overlay> getOverlays() {
+                return new LinkedList<Overlay>(_overlays.keySet());
         }
 
@@ -1174 +1048 @@
         }
 
-        private boolean getOverlaysDeep(List<Overlay> overlays, Frame overlay,
-                        List<Frame> seenOverlays) {
-
-                if (seenOverlays.contains(overlay))
-                        return false;
-
-                seenOverlays.add(overlay);
-
-                for (Overlay o : overlay.getOverlays()) {
-                        if (getOverlaysDeep(overlays, o.Frame, seenOverlays)) {
-                                overlays.add(o);
-                        }
-                }
-
-                return true;
-        }
+        // private boolean getOverlaysDeep(List<Overlay> overlays, Frame overlay,
+        // List<Frame> seenOverlays) {
+        //
+        // if (seenOverlays.contains(overlay))
+        // return false;
+        //
+        // seenOverlays.add(overlay);
+        //
+        // for (Overlay o : overlay.getOverlays()) {
+        // if (getOverlaysDeep(overlays, o.Frame, seenOverlays)) {
+        // overlays.add(o);
+        // }
+        // }
+        //
+        // return true;
+        // }
 
         /**
@@ -1202 +1076 @@
                 if (item == null)
                         throw new NullPointerException("item");
-                List<Overlay> overlays = getOverlaysDeep();
-                for (Overlay l : overlays) {
-                        // if (l.Frame.containsItem(item)) return l;
+                
+                for (Overlay l : getOverlays()) {
                         if (item.getParent() == l.Frame)
                                 return l;
                 }
 
+                //TODO return the correct vector... not just the first vector matching the vectorFrame
+                for (Vector v : getVectors()) {
+                        if (item.getParent() == v.Frame)
+                                return v;
+                }
+                
                 return null;
         }
 
         public void clearVectors() {
-                while (!_vectors.isEmpty()) {
-                        removeVector(_vectors.get(0)); // centralise removing
-                }
+                _vectors.clear();
+                _vectorItems.clear();
+        }
+
+        protected boolean removeVector(Vector toRemove) {
+                if(_overlays.remove(toRemove) == null)
+                        return false;
+                for (Item i : toRemove.Frame.getVectorItems()) {
+                        _overlayItems.remove(i);
+                        i.onParentStateChanged(new ItemParentStateChangedEvent(this,
+                                        ItemParentStateChangedEvent.EVENT_TYPE_REMOVED_VIA_OVERLAY,
+                                        toRemove.permission));
+                }
+                return true;
         }
 
         public void clearOverlays() {
-                while (!_overlays.isEmpty()) {
-                        removeOverlay(_overlays.get(0)); // centralise removing
-                }
+                for (Overlay o : _overlays.keySet()) {
+                        removeOverlay(o.Frame);
+                }
+                assert (_overlays.isEmpty());
+        }
+
+        protected boolean removeOverlay(Frame f) {
+                for (Overlay o : _overlays.keySet()) {
+                        if (o.Frame == f) {
+                                _overlays.remove(o);
+                                for (Item i : f.getItems()) {
+                                        _overlayItems.remove(i);
+                                        i
+                                                        .onParentStateChanged(new ItemParentStateChangedEvent(
+                                                                        this,
+                                                                        ItemParentStateChangedEvent.EVENT_TYPE_REMOVED_VIA_OVERLAY,
+                                                                        o.permission));
+                                }
+                                return true;
+                        }
+                }
+                return false;
         }
 
         public void addAllVectors(List<Vector> vectors) {
                 for (Vector v : vectors) {
-                        addVector(v); // centralise adding
-                }
-        }
-
-        public void addAllOverlays(List<Overlay> overlays) {
+                        addVector(v);
+                }
+        }
+
+        public void addAllOverlays(Collection<Overlay> overlays) {
                 for (Overlay o : overlays) {
-                        addOverlay(o); // centralise adding
-                }
+                        addOverlay(o);
+                }
+        }
+
+        protected boolean addOverlay(Overlay toAdd) {
+                // make sure we dont add this frame as an overlay of itself
+                if (toAdd.Frame == this)
+                        return false;
+                // Dont add the overlay if there is already one for this frame
+                if (_overlays.values().contains(toAdd.Frame))
+                        return false;
+                // Add the overlay to the map of overlays on this frame
+                _overlays.put(toAdd, toAdd.Frame);
+                // Add all the overlays from the overlay frame to this frame
+                for (Overlay o : toAdd.Frame.getOverlays())
+                        addOverlay(o);
+
+                // Now add the items for this overlay
+
+                // Items must be notified that they have been added or removed from this
+                // frame via the overlay...
+                for (Item i : toAdd.Frame.getVisibleItems()) {
+                        i.onParentStateChanged(new ItemParentStateChangedEvent(this,
+                                        ItemParentStateChangedEvent.EVENT_TYPE_ADDED_VIA_OVERLAY,
+                                        toAdd.permission));
+                        _overlayItems.add(i);
+                }
+                return true;
         }
 
@@ -1761 +1696 @@
 
                 String[] tokens = text.getProcessedText();
-                if (tokens != null || tokens.length > 1)
+                if (tokens != null && tokens.length > 1)
                         return tokens[1];
                 return null;
@@ -1771 +1706 @@
                 _annotations.clear();
         }
-
+        
         public List<Item> getVisibleItems() {
                 return getItems(true);
@@ -1813 +1748 @@
                                 seenWidgets.add(iw);
                                 toSave.add(iw.getSource());
-                        } else if(i instanceof XRayable){
-                                XRayable x = (XRayable)i;
+                        } else if (i instanceof XRayable) {
+                                XRayable x = (XRayable) i;
                                 toSave.addAll(x.getItemsToSave());
-                        }//Circle centers are items with attached enclosures 
-                        else if (i.hasEnclosures()){
+                        }// Circle centers are items with attached enclosures
+                        else if (i.hasEnclosures()) {
                                 continue;
-                        }else{
+                        } else {
                                 toSave.add(i);
                         }
@@ -1826 +1761 @@
                 return toSave;
         }
+
+        public Collection<Item> getOverlayItems() {
+                return _overlayItems;
+        }
+
+        /**
+         * Returns true if this frame has and overlays for the specified frame.
+         * 
+         * @param frame
+         * @return
+         */
+        public boolean hasOverlay(Frame frame) {
+                return _overlays.containsValue(frame);
+        }
+
+        public Collection<Item> getAllItems() {
+                Collection<Item> allItems = new LinkedHashSet<Item>(_body);
+                allItems.addAll(_overlayItems);
+                allItems.addAll(_vectorItems);
+                return allItems;
+        }
+
+        public Collection<Item> getVectorItems() {
+                Collection<Item>vectorItems = new LinkedHashSet<Item>(_vectorItems);
+                vectorItems.addAll(getNonAnnotationItems());
+                return vectorItems;
+        }
 }